@lapismd/mira 0.0.1

package/dist/internal/codemirror/rich/index.js

@@ -0,0 +1,727 @@
+import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
+import { EditorState, StateField, } from "@codemirror/state";
+import { Decoration, EditorView, ViewPlugin, WidgetType, } from "@codemirror/view";
+import { resolveMiraExtensions, resolveMiraListCallouts, } from "@lapismd/mira/extensions";
+import { resolveMiraDoodleDividerPair } from "../../doodle-dividers";
+import { miraRichEditorTheme } from "./theme";
+import { codeBlockLineDecorations } from "./utils/code-block-lines";
+import { getFencedCodeLanguage } from "./utils/fenced-code";
+import { getAtxHeadingMarkerRange, selectionTouchesLine, } from "./utils/headings";
+import { getTaskMarkerRange, selectionTouchesTaskMarker } from "./utils/tasks";
+import { findMarkdownImageRanges, isStandaloneMarkdownImageLine, resolveMarkdownImageWidgetSource, } from "./utils/images";
+import { findInlineCodeRanges, isPositionInsideRanges, } from "./utils/inline-code";
+import { findInlineMathRanges } from "./utils/inline-math";
+import { indentGuideDecorations } from "./utils/indent";
+import { measuredIndentExtension } from "./utils/measured-indent";
+import { getMarkdownLinkTextRange, isBareExternalAutolinkUrl, isExternalMarkdownLink, } from "./utils/links";
+import { createListCalloutMatcher, } from "./utils/list-callouts";
+import { hasInitialFrontmatterCursor, hasRenderedInitialFrontmatterCursor, rangeContainsSelectionCursor, rangeIntersectsSelection, rangesOverlap, sortRanges, } from "./utils/ranges";
+import { blockControlExtensions } from "./block-controls";
+import { foldIndicatorDecorations } from "./decorations/fold-indicators";
+import { headingGutterExtension } from "./decorations/heading-gutter";
+import { BlockPreviewWidget, InlineMarkdownWidget, InlineMathWidget, } from "./widgets/preview-widgets";
+import { ListCalloutWidget } from "./widgets/list-callout";
+import { TaskCheckboxWidget } from "./widgets/task-checkbox";
+export { getFoldAnchor } from "./decorations/fold-indicators";
+export { PREVIEW_INTERACTIVE_SELECTOR, shouldActivateEditablePreview, } from "./utils/activation";
+export { buildCodeBlockLineDecorations, codeBlockLineDecorations, isFencedCodeLine, } from "./utils/code-block-lines";
+export { getFencedCodeLanguage, getFencedCodeWidgetRange, } from "./utils/fenced-code";
+export { getAtxHeadingMarkerRange, selectionTouchesLine, } from "./utils/headings";
+export { getTaskMarkerRange, selectionTouchesTaskMarker } from "./utils/tasks";
+export { estimateMarkdownBlockHeight } from "./utils/height-estimates";
+export { findInlineMathRanges, } from "./utils/inline-math";
+export { getIndentLineLayout, getLineIndentInfo, normalizeIndentText, selectionTouchesIndent, splitIndentSegments, toMarkdownColumns, } from "./utils/indent";
+export { measuredIndentExtension, syncMeasuredIndentStyles, } from "./utils/measured-indent";
+export { getMarkdownLinkTextRange, isBareExternalAutolinkUrl, isExternalMarkdownDestination, isExternalMarkdownLink, } from "./utils/links";
+export { collectMarkdownBlockHandles, collectMarkdownBlockRanges, deleteMarkdownBlockHandle, deleteMarkdownBlockRange, duplicateMarkdownBlockHandle, duplicateMarkdownBlockRange, markdownBlockAt, moveMarkdownBlockHandle, moveMarkdownBlockRange, replaceMarkdownRange, } from "./block-ranges";
+const BLOCK_WIDGET_NODE_NAMES = new Set([
+    "Frontmatter",
+    "FencedCode",
+    "HorizontalRule",
+    "BlockMathDollar",
+    "BlockMathBracket",
+    "Blockquote",
+    "Table",
+    "GridTable",
+    "LeafDirective",
+    "ContainerDirective",
+]);
+const hiddenFormattingMark = Decoration.mark({
+    class: "cm-formatting cm-formatting-hidden",
+});
+const strongMark = Decoration.mark({ class: "cm-strong" });
+const emphasisMark = Decoration.mark({ class: "cm-emphasis" });
+const strikethroughMark = Decoration.mark({ class: "cm-strikethrough" });
+const inlineCodeMark = Decoration.mark({ class: "cm-inline-code" });
+const internalLinkMark = Decoration.mark({ class: "cm-internal-link" });
+const externalLinkMark = Decoration.mark({ class: "cm-external-link" });
+const linkTextMark = Decoration.mark({
+    class: "cm-link-text cm-link-string",
+});
+const linkTargetMark = Decoration.mark({ class: "cm-link-target" });
+const linkPathTargetMark = Decoration.mark({
+    class: "cm-path cm-link-target",
+});
+const INLINE_SOURCE_TOKEN_NAMES = new Set([
+    "Emphasis",
+    "StrongEmphasis",
+    "Strikethrough",
+    "StrikethroughEmphasis",
+    "InlineCode",
+    "CodeBlock",
+    "Link",
+    "PathLink",
+    "WikiLink",
+    "EmbedLink",
+    "Image",
+]);
+const INLINE_FORMATTING_NODE_NAMES = new Set([
+    "HardBreak",
+    "LinkMark",
+    "PathLinkMark",
+    "PathLinkDestination",
+    "EmphasisMark",
+    "CodeMark",
+    "StrikethroughMark",
+    "URL",
+]);
+export function createRichEditorExtensions(options = {}) {
+    if (options.enabled === false) {
+        return [];
+    }
+    const livePreview = options.livePreview ?? true;
+    const extensionListCallouts = resolveMiraExtensions(options.extensions, {
+        mode: livePreview ? "live-preview" : "source",
+        readonly: false,
+        sourcePath: options.sourcePath,
+    }).listCallouts;
+    const resolvedOptions = {
+        ...options,
+        listCallouts: [...extensionListCallouts, ...(options.listCallouts ?? [])],
+    };
+    return [
+        miraRichEditorTheme,
+        codeBlockLineDecorations(),
+        headingGutterExtension(),
+        headingLineDecorations(),
+        resolvedOptions.indentGuides !== false
+            ? [
+                EditorView.editorAttributes.of({
+                    class: "cm-show-indentation-guides",
+                }),
+                indentGuideDecorations({ livePreview }),
+                measuredIndentExtension(),
+            ]
+            : [],
+        // Lapis only mounts richEditor() for live-preview. Source keeps delimiters
+        // (`>`, backticks, fences) with HyperMD line classes only.
+        livePreview ? blockPreviewDecorations(resolvedOptions) : [],
+        livePreview
+            ? inlinePreviewDecorations({ ...resolvedOptions, livePreview })
+            : [],
+        foldIndicatorDecorations(),
+        blockControlExtensions(resolvedOptions),
+        livePreview
+            ? EditorView.editorAttributes.compute(["doc", "selection"], (state) => ({
+                class: [
+                    "mira-live-preview-mode markdown-live-preview-mode markdown-live-preview-view cm-live-preview",
+                    hasRenderedInitialFrontmatterCursor(state)
+                        ? "mira-live-preview-hide-cursor"
+                        : "",
+                ]
+                    .filter(Boolean)
+                    .join(" "),
+            }))
+            : [],
+    ];
+}
+function blockPreviewDecorations(options) {
+    return StateField.define({
+        create(state) {
+            return buildBlockPreviewDecorations(state, options);
+        },
+        update(value, transaction) {
+            if (transaction.docChanged || transaction.selection) {
+                return buildBlockPreviewDecorations(transaction.state, options);
+            }
+            return value.map(transaction.changes);
+        },
+        provide: (field) => EditorView.decorations.from(field),
+    });
+}
+function inlinePreviewDecorations(options) {
+    return ViewPlugin.fromClass(class {
+        view;
+        decorations;
+        constructor(view) {
+            this.view = view;
+            this.decorations = buildInlinePreviewDecorations(view, options);
+        }
+        update(update) {
+            if (update.docChanged ||
+                update.selectionSet ||
+                update.viewportChanged) {
+                this.decorations = buildInlinePreviewDecorations(update.view, options);
+            }
+        }
+    }, {
+        decorations: (value) => value.decorations,
+    });
+}
+function buildBlockPreviewDecorations(state, options) {
+    const ranges = [];
+    const replacedRanges = [];
+    const tree = ensureSyntaxTree(state, state.doc.length, 100) ?? syntaxTree(state);
+    tree.iterate({
+        from: 0,
+        to: state.doc.length,
+        enter: (node) => {
+            if (!BLOCK_WIDGET_NODE_NAMES.has(node.name)) {
+                return;
+            }
+            let from = state.doc.lineAt(node.from).from;
+            let to = state.doc.lineAt(node.to).to;
+            if (node.name === "HorizontalRule") {
+                const pair = resolveMiraDoodleDividerPair(state, node.from, node.to);
+                if (pair) {
+                    from = pair.from;
+                    to = pair.to;
+                }
+            }
+            const selectionInside = node.name === "Frontmatter"
+                ? rangeContainsSelectionCursor(state, from, to) &&
+                    !hasInitialFrontmatterCursor(state, from)
+                : rangeContainsSelectionCursor(state, from, to);
+            if (selectionInside &&
+                (node.name === "BlockMathDollar" || node.name === "BlockMathBracket") &&
+                !replacedRanges.some((range) => rangesOverlap(range, { from, to }))) {
+                const markdown = state.doc.sliceString(from, to);
+                ranges.push(Decoration.widget({
+                    block: true,
+                    side: 1,
+                    widget: new BlockPreviewWidget({
+                        from,
+                        to,
+                        markdown,
+                        nodeName: node.name,
+                        options,
+                    }),
+                }).range(to));
+                return false;
+            }
+            if (selectionInside ||
+                replacedRanges.some((range) => rangesOverlap(range, { from, to }))) {
+                return;
+            }
+            const previewSource = getBlockPreviewSource(state, node.name, node.from, node.to, from, to);
+            ranges.push(Decoration.replace({
+                block: true,
+                widget: new BlockPreviewWidget({
+                    from,
+                    to,
+                    markdown: previewSource.markdown,
+                    markdownFrom: previewSource.from,
+                    markdownIndentLength: previewSource.indentLength,
+                    markdownIndentedLineStarts: previewSource.indentedLineStarts,
+                    nodeName: node.name,
+                    options,
+                }),
+            }).range(from, to));
+            replacedRanges.push({ from, to });
+            return false;
+        },
+    });
+    for (let lineNumber = 1; lineNumber <= state.doc.lines; lineNumber += 1) {
+        const line = state.doc.line(lineNumber);
+        const standaloneEmbed = isStandaloneEmbedLine(line.text);
+        const standaloneImage = isStandaloneMarkdownImageLine(line.text);
+        if (!standaloneEmbed && !standaloneImage) {
+            continue;
+        }
+        const from = line.from;
+        const to = line.to;
+        if (rangeContainsSelectionCursor(state, from, to) ||
+            replacedRanges.some((range) => rangesOverlap(range, { from, to }))) {
+            continue;
+        }
+        const markdown = standaloneEmbed
+            ? line.text.trim()
+            : resolveMarkdownImageWidgetSource(line.text, state.doc.toString());
+        if (!markdown) {
+            continue;
+        }
+        ranges.push(Decoration.replace({
+            block: true,
+            widget: new BlockPreviewWidget({
+                from,
+                to,
+                markdown,
+                nodeName: standaloneEmbed ? "EmbedLink" : "Image",
+                options,
+            }),
+        }).range(from, to));
+        replacedRanges.push({ from, to });
+    }
+    return Decoration.set(sortRanges(ranges), true);
+}
+function getBlockPreviewSource(state, nodeName, nodeFrom, nodeTo, replacementFrom, replacementTo) {
+    if (nodeName === "Blockquote" &&
+        /^[\t ]+$/u.test(state.doc.sliceString(replacementFrom, nodeFrom))) {
+        const indent = state.doc.sliceString(replacementFrom, nodeFrom);
+        const lines = state.doc.sliceString(nodeFrom, nodeTo).split("\n");
+        const indentedLineStarts = [];
+        let markdown = "";
+        for (const [index, sourceLine] of lines.entries()) {
+            if (index > 0) {
+                markdown += "\n";
+            }
+            const removesParentIndent = index > 0 && sourceLine.startsWith(indent);
+            if (removesParentIndent) {
+                indentedLineStarts.push(markdown.length);
+            }
+            markdown += removesParentIndent
+                ? sourceLine.slice(indent.length)
+                : sourceLine;
+        }
+        return {
+            from: nodeFrom,
+            to: nodeTo,
+            indentLength: indent.length,
+            indentedLineStarts,
+            markdown,
+        };
+    }
+    return {
+        from: replacementFrom,
+        to: replacementTo,
+        markdown: state.doc.sliceString(replacementFrom, replacementTo),
+    };
+}
+function buildInlinePreviewDecorations(view, options) {
+    const ranges = [];
+    const replaceWidgets = options.livePreview ?? true;
+    const fencedCodeLineClasses = getFencedCodeLineClasses(view.state);
+    const listCallouts = resolveMiraListCallouts(options.listCallouts);
+    const listCalloutMatcher = createListCalloutMatcher(options.listCallouts);
+    const syntaxHiddenRanges = [];
+    const activeInlineSourceRanges = [];
+    if (replaceWidgets) {
+        collectActiveTaskMarkerRanges(view, activeInlineSourceRanges);
+    }
+    decorateInlineSyntax(view, ranges, syntaxHiddenRanges, activeInlineSourceRanges);
+    for (const visibleRange of view.visibleRanges) {
+        let line = view.state.doc.lineAt(visibleRange.from);
+        while (line.from <= visibleRange.to) {
+            const fencedCodeLineClass = fencedCodeLineClasses.get(line.number);
+            if (fencedCodeLineClass) {
+                ranges.push(Decoration.line({ class: fencedCodeLineClass }).range(line.from));
+            }
+            // Heading line classes come from always-on headingLineDecorations().
+            decorateFootnotes(line.text, line.from, ranges);
+            if (replaceWidgets) {
+                decorateListCallouts(line.text, line.from, ranges, view.state, listCalloutMatcher, listCallouts);
+                decorateTaskCheckboxes(line.text, line.from, ranges, options, view.state, activeInlineSourceRanges);
+            }
+            decorateStrikethroughRanges(line.text, line.from, ranges, syntaxHiddenRanges, activeInlineSourceRanges, view.state);
+            const inlineMathRanges = replaceWidgets && !fencedCodeLineClass
+                ? decorateInlineMath(line.text, line.from, ranges, options, view.state)
+                : [];
+            const inlineMarkdownWidgetRanges = replaceWidgets && !fencedCodeLineClass
+                ? decorateInlineMarkdownWidgets(line.text, line.from, ranges, options, view.state)
+                : [];
+            // Lapis: hide formatting marks only in live preview; source keeps delimiters.
+            if (replaceWidgets && !fencedCodeLineClass) {
+                decorateHiddenFormatting(line.text, line.from, ranges, {
+                    excludedRanges: [
+                        ...inlineMathRanges,
+                        ...inlineMarkdownWidgetRanges,
+                        ...syntaxHiddenRanges,
+                        ...activeInlineSourceRanges,
+                    ],
+                    state: view.state,
+                });
+            }
+            if (line.to >= visibleRange.to || line.number >= view.state.doc.lines) {
+                break;
+            }
+            line = view.state.doc.line(line.number + 1);
+        }
+    }
+    return Decoration.set(sortRanges(ranges), true);
+}
+class ListCalloutBackgroundWidget extends WidgetType {
+    toDOM() {
+        const span = document.createElement("span");
+        span.className = "lc-list-bg";
+        span.setAttribute("aria-hidden", "true");
+        return span;
+    }
+    eq() {
+        return true;
+    }
+}
+function decorateListCallouts(text, lineStart, ranges, state, matchListCallout, listCallouts) {
+    const markerRange = matchListCallout(text, lineStart);
+    if (!markerRange) {
+        return;
+    }
+    ranges.push(Decoration.line({
+        class: "lc-list-callout",
+        attributes: {
+            "data-callout": markerRange.marker,
+            style: `--lc-callout-color: ${markerRange.color}`,
+        },
+    }).range(lineStart));
+    ranges.push(Decoration.widget({
+        side: -1,
+        widget: new ListCalloutBackgroundWidget(),
+    }).range(lineStart));
+    if (rangeIntersectsSelection(state, markerRange.markerStart, markerRange.markerEnd)) {
+        return;
+    }
+    ranges.push(Decoration.replace({
+        widget: new ListCalloutWidget({
+            from: markerRange.markerStart,
+            to: markerRange.markerEnd,
+            removeTo: markerRange.removeEnd,
+            callout: markerRange.callout,
+            callouts: listCallouts,
+        }),
+    }).range(markerRange.markerStart, markerRange.markerEnd));
+}
+function decorateInlineSyntax(view, ranges, hiddenRanges, activeSourceRanges) {
+    const tree = ensureSyntaxTree(view.state, view.state.doc.length, 100) ??
+        syntaxTree(view.state);
+    for (const visibleRange of view.visibleRanges) {
+        tree.iterate({
+            from: visibleRange.from,
+            to: visibleRange.to,
+            enter(node) {
+                const parent = node.node.parent;
+                const parentName = parent?.name;
+                const parentFrom = parent?.from ?? node.from;
+                const parentTo = parent?.to ?? node.to;
+                const nodeSource = view.state.sliceDoc(node.from, node.to);
+                if (INLINE_SOURCE_TOKEN_NAMES.has(node.name)) {
+                    decorateInlineTokenElement(view, node.name, node.from, node.to, ranges);
+                    if (rangeIntersectsSelection(view.state, node.from, node.to)) {
+                        activeSourceRanges.push({ from: node.from, to: node.to });
+                    }
+                }
+                decorateInlineTokenPart(view, node.name, node.from, node.to, nodeSource, parentName, ranges);
+                if (INLINE_FORMATTING_NODE_NAMES.has(node.name) &&
+                    !isBareExternalAutolinkUrl(node.name, parentName, nodeSource) &&
+                    !rangeIntersectsSelection(view.state, parentFrom, parentTo) &&
+                    !activeSourceRanges.some((range) => rangesOverlap(range, { from: node.from, to: node.to }))) {
+                    hiddenRanges.push({ from: node.from, to: node.to });
+                    ranges.push(hiddenFormattingMark.range(node.from, node.to));
+                }
+            },
+        });
+    }
+}
+function collectActiveTaskMarkerRanges(view, activeSourceRanges) {
+    for (const visibleRange of view.visibleRanges) {
+        let line = view.state.doc.lineAt(visibleRange.from);
+        while (line.from <= visibleRange.to) {
+            const taskRange = getTaskMarkerRange(line.text, line.from);
+            if (taskRange &&
+                selectionTouchesTaskMarker(view.state, line.from, taskRange.markerEnd)) {
+                activeSourceRanges.push({
+                    from: taskRange.markerStart,
+                    to: taskRange.markerEnd,
+                });
+            }
+            if (line.to >= visibleRange.to || line.number >= view.state.doc.lines) {
+                break;
+            }
+            line = view.state.doc.line(line.number + 1);
+        }
+    }
+}
+function decorateInlineMarkdownWidgets(text, lineStart, ranges, options, state) {
+    const widgetRanges = [];
+    const codeRanges = findInlineCodeRanges(text);
+    if (isStandaloneEmbedLine(text) || isStandaloneMarkdownImageLine(text)) {
+        widgetRanges.push({ from: lineStart, to: lineStart + text.length });
+        return widgetRanges;
+    }
+    for (const match of text.matchAll(/!?\[\[[^\]\r\n]+\]\]/gu)) {
+        const localFrom = match.index ?? 0;
+        const localTo = localFrom + match[0].length;
+        if (isPositionInsideRanges(localFrom, codeRanges) ||
+            isPositionInsideRanges(localTo - 1, codeRanges)) {
+            continue;
+        }
+        const from = lineStart + localFrom;
+        const to = lineStart + localTo;
+        if (rangeContainsSelectionCursor(state, from, to)) {
+            continue;
+        }
+        widgetRanges.push({ from, to });
+        ranges.push(Decoration.replace({
+            widget: new InlineMarkdownWidget({
+                from,
+                to,
+                markdown: match[0],
+                options,
+            }),
+        }).range(from, to));
+    }
+    for (const image of findMarkdownImageRanges(text, state.doc.toString())) {
+        const from = lineStart + image.from;
+        const to = lineStart + image.to;
+        if (rangeContainsSelectionCursor(state, from, to) ||
+            widgetRanges.some((range) => rangesOverlap(range, { from, to }))) {
+            continue;
+        }
+        widgetRanges.push({ from, to });
+        ranges.push(Decoration.replace({
+            widget: new InlineMarkdownWidget({
+                from,
+                to,
+                markdown: image.source,
+                options,
+            }),
+        }).range(from, to));
+    }
+    return widgetRanges;
+}
+function isStandaloneEmbedLine(text) {
+    return /^\s*!\[\[[^\]\r\n]+\]\]\s*$/u.test(text);
+}
+function decorateInlineTokenElement(view, name, from, to, ranges) {
+    if (name === "StrongEmphasis") {
+        ranges.push(strongMark.range(from, to));
+        return;
+    }
+    if (name === "Emphasis") {
+        ranges.push(emphasisMark.range(from, to));
+        return;
+    }
+    if (name === "Strikethrough" || name === "StrikethroughEmphasis") {
+        ranges.push(strikethroughMark.range(from, to));
+        return;
+    }
+    if (name === "InlineCode" || name === "CodeBlock") {
+        ranges.push(inlineCodeMark.range(from, to));
+        return;
+    }
+    if (name === "Link" || name === "PathLink") {
+        const source = view.state.sliceDoc(from, to);
+        ranges.push((isExternalMarkdownLink(source)
+            ? externalLinkMark
+            : internalLinkMark).range(from, to));
+        const textRange = getMarkdownLinkTextRange(source, from, to);
+        if (textRange) {
+            ranges.push(linkTextMark.range(textRange.from, textRange.to));
+        }
+        return;
+    }
+    if (name === "WikiLink" || name === "EmbedLink" || name === "Image") {
+        ranges.push(internalLinkMark.range(from, to));
+    }
+}
+function decorateInlineTokenPart(view, name, from, to, source, parentName, ranges) {
+    if (name === "URL") {
+        ranges.push((parentName === "Link" ? linkTargetMark : externalLinkMark).range(from, to));
+        if (parentName !== "Link" && isExternalMarkdownLink(source)) {
+            const textRange = getMarkdownLinkTextRange(source, from, to);
+            if (textRange) {
+                ranges.push(linkTextMark.range(textRange.from, textRange.to));
+            }
+        }
+        return;
+    }
+    if (name === "PathLinkDestination") {
+        ranges.push(linkPathTargetMark.range(from, to));
+        return;
+    }
+    if (name === "WikiLinkPath" ||
+        name === "WikiLinkAnchor" ||
+        name === "EmbedLinkPath" ||
+        name === "EmbedLinkAnchor") {
+        ranges.push(linkTargetMark.range(from, to));
+        return;
+    }
+    if (name === "WikiLinkText" || name === "EmbedLinkText") {
+        ranges.push(linkTextMark.range(from, to));
+    }
+}
+function decorateStrikethroughRanges(text, lineStart, ranges, hiddenRanges, activeSourceRanges, state) {
+    for (const match of text.matchAll(/~~(?=\S)(.+?)(?<=\S)~~/gu)) {
+        const from = lineStart + (match.index ?? 0);
+        const to = from + match[0].length;
+        const opening = { from, to: from + 2 };
+        const closing = { from: to - 2, to };
+        ranges.push(strikethroughMark.range(from, to));
+        if (rangeIntersectsSelection(state, from, to)) {
+            activeSourceRanges.push({ from, to });
+            continue;
+        }
+        hiddenRanges.push(opening, closing);
+        ranges.push(hiddenFormattingMark.range(opening.from, opening.to));
+        ranges.push(hiddenFormattingMark.range(closing.from, closing.to));
+    }
+}
+function getFencedCodeLineClasses(state) {
+    const classes = new Map();
+    const tree = ensureSyntaxTree(state, state.doc.length, 100) ?? syntaxTree(state);
+    tree.iterate({
+        from: 0,
+        to: state.doc.length,
+        enter(node) {
+            if (node.name !== "FencedCode") {
+                return;
+            }
+            const start = state.doc.lineAt(node.from);
+            const end = state.doc.lineAt(node.to);
+            const markdown = state.doc.sliceString(start.from, end.to);
+            const language = getFencedCodeLanguage(markdown);
+            const isTextCode = language === "text";
+            for (let lineNumber = start.number; lineNumber <= end.number; lineNumber += 1) {
+                const classNames = ["cm-formatting-code"];
+                if (isTextCode) {
+                    classNames.push("cm-formatting-code-language-text");
+                }
+                if (lineNumber === start.number) {
+                    classNames.push("cm-formatting-code-start");
+                }
+                if (lineNumber === end.number) {
+                    classNames.push("cm-formatting-code-end");
+                }
+                classes.set(lineNumber, classNames.join(" "));
+            }
+        },
+    });
+    return classes;
+}
+function decorateTaskCheckboxes(text, lineStart, ranges, options, state, activeSourceRanges) {
+    const taskRange = getTaskMarkerRange(text, lineStart);
+    if (taskRange) {
+        ranges.push(Decoration.line({
+            class: "cm-task-line HyperMD-task-line",
+            attributes: {
+                "data-task": taskRange.taskValue,
+            },
+        }).range(lineStart));
+        if (selectionTouchesTaskMarker(state, lineStart, taskRange.markerEnd)) {
+            activeSourceRanges.push({
+                from: taskRange.markerStart,
+                to: taskRange.markerEnd,
+            });
+            return;
+        }
+        ranges.push(Decoration.replace({
+            widget: new TaskCheckboxWidget({
+                from: taskRange.checkboxStart,
+                value: taskRange.taskValue,
+                checked: taskRange.taskValue.trim().length > 0,
+            }),
+        }).range(taskRange.markerStart, taskRange.checkboxEnd));
+    }
+}
+function decorateFootnotes(text, lineStart, ranges) {
+    const definition = text.match(/^\[\^([^\]\r\n]+)\]:/u);
+    if (definition) {
+        ranges.push(Decoration.line({
+            class: "cm-footnote cm-footnote-definition",
+        }).range(lineStart));
+    }
+    for (const match of text.matchAll(/\[\^([^\]\r\n]+)\]/gu)) {
+        const from = lineStart + (match.index ?? 0);
+        ranges.push(Decoration.mark({
+            class: "cm-footnote cm-footnote-ref",
+        }).range(from, from + match[0].length));
+    }
+}
+function decorateInlineMath(text, lineStart, ranges, options, state) {
+    const mathRanges = findInlineMathRanges(text);
+    const absoluteRanges = [];
+    for (const range of mathRanges) {
+        const from = lineStart + range.from;
+        const to = lineStart + range.to;
+        absoluteRanges.push({ from, to });
+        const widget = new InlineMathWidget({
+            from,
+            to,
+            source: range.source,
+            options,
+        });
+        if (rangeIntersectsSelection(state, from, to)) {
+            ranges.push(Decoration.widget({
+                side: 1,
+                widget,
+            }).range(to));
+        }
+        else {
+            ranges.push(Decoration.replace({
+                widget,
+            }).range(from, to));
+        }
+    }
+    return absoluteRanges;
+}
+const headingLineDecorationMarks = Array.from({ length: 6 }, (_, index) => Decoration.line({
+    class: [
+        "cm-header",
+        "HyperMD-header",
+        `cm-header-${index + 1}`,
+        `HyperMD-header-${index + 1}`,
+    ].join(" "),
+}));
+function buildHeadingLineDecorations(state) {
+    const ranges = [];
+    for (let number = 1; number <= state.doc.lines; number += 1) {
+        const line = state.doc.line(number);
+        const match = line.text.match(/^(#{1,6})(?=\s)/);
+        if (match?.[1]) {
+            ranges.push(headingLineDecorationMarks[match[1].length - 1].range(line.from));
+        }
+    }
+    return Decoration.set(sortRanges(ranges));
+}
+function headingLineDecorations() {
+    return StateField.define({
+        create: buildHeadingLineDecorations,
+        update(value, transaction) {
+            return transaction.docChanged
+                ? buildHeadingLineDecorations(transaction.state)
+                : value.map(transaction.changes);
+        },
+        provide: (field) => EditorView.decorations.from(field),
+    });
+}
+function decorateHiddenFormatting(text, lineStart, ranges, options = {}) {
+    addRegexMarks(text, lineStart, ranges, /(\*\*|__|\*|_|~~|`)/g, options);
+    addRegexMarks(text, lineStart, ranges, /(!?\[|\]\(|\[\[|\]\])/g, options);
+    decorateHeadingFormatting(text, lineStart, ranges, options);
+    // Blockquote `>` is owned by indent quote chrome + .cm-formatting-quote CSS
+    // (transparent / faint on active line). Collapsing it with formatting-hidden
+    // removes marker width and the hanging quote padding as soon as focus leaves
+    // the `>` characters.
+}
+function decorateHeadingFormatting(text, lineStart, ranges, options) {
+    const markerRange = getAtxHeadingMarkerRange(text, lineStart);
+    if (!markerRange ||
+        options.excludedRanges?.some((range) => rangesOverlap(range, markerRange)) ||
+        (options.state &&
+            selectionTouchesLine(options.state, lineStart, lineStart + text.length))) {
+        return;
+    }
+    ranges.push(hiddenFormattingMark.range(markerRange.from, markerRange.to));
+}
+function addRegexMarks(text, lineStart, ranges, regexp, options = {}) {
+    for (const match of text.matchAll(regexp)) {
+        const token = match[1] ?? match[0];
+        const start = lineStart + (match.index ?? 0);
+        const tokenStart = match[0].indexOf(token);
+        const from = start + Math.max(0, tokenStart);
+        const to = from + token.length;
+        if (options.excludedRanges?.some((range) => rangesOverlap(range, { from, to })) ||
+            (options.state && rangeIntersectsSelection(options.state, from, to))) {
+            continue;
+        }
+        ranges.push(hiddenFormattingMark.range(from, to));
+    }
+}