state.doc.nodesBetween(from, to, (node, pos, parent) => {
        if (!node.type.isBlock) {
            return false
        }

        if (
            (!allowedBlocks ||
                (Array.isArray(allowedBlocks)
                    ? allowedBlocks.indexOf(node.type) > -1
                    : allowedBlocks(state.schema, node, parent))) &&
            parent.type.allowsMarkType(markType)
        ) {
            const oldMarks = node.marks.filter(mark => mark.type === markType)

            const prevAttrs = oldMarks.length ? (oldMarks[0].attrs as T) : undefined
            const newAttrs = getAttrs(prevAttrs, node)

            if (newAttrs !== undefined) {
                tr.setNodeMarkup(
                    pos,
                    node.type,
                    node.attrs,
                    node.marks
                        .filter(mark => !markType.excludes(mark.type))
                        .concat(newAttrs === false ? [] : markType.create(newAttrs)),
                )
                markApplied = true
            }
        }
    })

export const isMarkTypeActive = (state: EditorState, markType: MarkType): boolean => {
    const { $from, from, to, empty } = state.selection
    if (empty) {
        return !!markType.isInSet(state.storedMarks || $from.marks())
    }
    return state.doc.rangeHasMark(from, to, markType)
}

const cm2: model.ContentMatch = cm1.matchType({} as any)!;
const cm3: model.ContentMatch = cm1.matchFragment({} as any)!;
const cm4: model.Fragment = cm1.fillBefore({} as any)!;
const cm5: model.NodeType[] = cm1.findWrapping({} as any)!;

const f1 = new model.Fragment();
f1.nodesBetween(0, 0, () => {});
f1.nodesBetween(0, 0, () => null);
f1.nodesBetween(0, 0, () => undefined);
f1.nodesBetween(0, 0, () => true);

f1.descendants(() => {});
f1.descendants(() => null);
f1.descendants(() => undefined);
f1.descendants(() => true);

const res2_1: model.Node = f1.maybeChild(0)!;
const res2_2: number = f1.findDiffStart(f1)!;
const res2_3: { a: number, b: number } = f1.findDiffEnd({} as any)!;
const res2_4: object = f1.toJSON()!;

const res3_1 = new model.ResolvedPos();
const res3_2: model.Mark[] = res3_1.marksAcross(res3_1)!;
const res3_3: model.NodeRange = res3_1.blockRange(res3_1)!;

const res4_1 = new model.NodeType();
const res4_2: model.Node = res4_1.createAndFill()!;

const res5_1 = new model.MarkType();
const res5_2: model.Mark = res5_1.isInSet([])!;

    return (state, match, start, end) => {
        const [, prefix, textWithCombo] = match
        const to = end
        // in case of *string* pattern it matches the text from beginning of the paragraph,
        // because we want ** to work for strong text
        // that's why "start" argument is wrong and we need to calculate it ourselves
        const from = textWithCombo ? start + prefix.length : start
        const nodeBefore = state.doc.resolve(start + prefix.length).nodeBefore

        if (
            prefix &&
            prefix.length > 0 &&
            !validRegex(char, prefix) &&
            !(nodeBefore && nodeBefore.type === state.schema.nodes.hardBreak)
        ) {
            return null
        }
        // fixes the following case: my `*name` is *
        // expected result: should ignore special characters inside "code"
        if (
            state.schema.marks.code &&
            state.schema.marks.code.isInSet(state.doc.resolve(from + 1).marks())
        ) {
            return null
        }

        // Prevent autoformatting across hardbreaks
        let containsHardBreak
        state.doc.nodesBetween(from, to, node => {
            if (node.type === schema.nodes.hardBreak) {
                containsHardBreak = true
                return false
            }
            return !containsHardBreak
        })
        if (containsHardBreak) {
            return null
        }

        // fixes autoformatting in heading nodes: # Heading *bold*
        // expected result: should not autoformat *bold*; <h1>Heading *bold*</h1>
        if (state.doc.resolve(from).sameParent(state.doc.resolve(to))) {
            if (!state.doc.resolve(from).parent.type.allowsMarkType(markType)) {
                return null
            }
        }

        // apply mark to the range (from, to)
        let tr = state.tr.addMark(from, to, markType.create())

        if (charSize > 1) {
            // delete special characters after the text
            // Prosemirror removes the last symbol by itself, so we need to remove "charSize - 1" symbols
            tr = tr.delete(to - (charSize - 1), to)
        }

        return (
            tr
                // delete special characters before the text
                .delete(from, from + charSize)
                .removeStoredMark(markType)
        )
    }

 .filter(mark => !markType.excludes(mark.type))