@lapismd/mira 0.0.1

package/dist/internal/codemirror/rich/utils/indent.js

@@ -0,0 +1,435 @@
+import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
+import {} from "@codemirror/state";
+import { Decoration, EditorView, ViewPlugin, WidgetType, } from "@codemirror/view";
+import { isFencedCodeLine } from "./code-block-lines";
+import { sortRanges } from "./ranges";
+const INDENT_UNIT = 4;
+export function toMarkdownColumns(text) {
+    let columns = 0;
+    for (const char of text) {
+        if (char === "\t") {
+            columns += INDENT_UNIT - (columns % INDENT_UNIT || 0);
+            continue;
+        }
+        columns += 1;
+    }
+    return columns;
+}
+export function normalizeIndentText(text) {
+    let columns = 0;
+    let normalized = "";
+    for (const char of text) {
+        if (char === "\t") {
+            const tabWidth = INDENT_UNIT - (columns % INDENT_UNIT || 0);
+            normalized += " ".repeat(tabWidth);
+            columns += tabWidth;
+            continue;
+        }
+        normalized += char;
+        columns += 1;
+    }
+    return normalized;
+}
+export function splitIndentSegments(indentText) {
+    const normalized = normalizeIndentText(indentText);
+    const segments = [];
+    for (let index = 0; index < normalized.length; index += INDENT_UNIT) {
+        const text = normalized.slice(index, index + INDENT_UNIT);
+        segments.push({ text, guide: text.length === INDENT_UNIT });
+    }
+    return segments;
+}
+export function getLineIndentInfo(lineText) {
+    const listMatch = lineText.match(/^(\s*)([-*+]|\d+[.)])\s+/);
+    if (listMatch) {
+        const indentText = listMatch[1] ?? "";
+        const columns = toMarkdownColumns(indentText);
+        return {
+            columns,
+            depth: Math.max(1, Math.floor(columns / INDENT_UNIT) + 1),
+            kind: /^\d/u.test(listMatch[2] ?? "") ? "ol" : "ul",
+            text: indentText,
+        };
+    }
+    const plainMatch = lineText.match(/^(\s+)(?=\S)/);
+    if (!plainMatch) {
+        return null;
+    }
+    const indentText = plainMatch[1] ?? "";
+    const columns = toMarkdownColumns(indentText);
+    if (columns < 1) {
+        return null;
+    }
+    return {
+        columns,
+        depth: Math.max(1, Math.ceil(columns / INDENT_UNIT)),
+        kind: "plain",
+        text: indentText,
+    };
+}
+export function selectionTouchesIndent(selectionFrom, selectionTo, indentFrom, indentTo) {
+    if (selectionFrom === selectionTo) {
+        return selectionFrom >= indentFrom && selectionFrom <= indentTo;
+    }
+    return selectionFrom < indentTo && selectionTo > indentFrom;
+}
+export function shouldRenderStyledUnorderedMarker(livePreview, cursorFrom, markerFrom) {
+    return (livePreview && cursorFrom !== markerFrom && cursorFrom !== markerFrom + 1);
+}
+export function getIndentLineLayout(lineText) {
+    const leading = lineText.match(/^\s*/u)?.[0] ?? "";
+    const quote = lineText.slice(leading.length).match(/^(?:>\s*)+/u)?.[0] ?? "";
+    const structuredOffset = leading.length + quote.length;
+    const list = lineText.slice(structuredOffset).match(/^([-*+]|\d+[.)])(\s+)/u);
+    if (list) {
+        const marker = `${list[1] ?? ""}${list[2] ?? ""}`;
+        const markerFrom = structuredOffset;
+        const markerTo = markerFrom + marker.length;
+        const task = lineText.slice(markerTo).match(/^(\[[^\]]\]\s+)/u)?.[0] ?? "";
+        const prefixTo = markerTo + task.length;
+        const indentColumns = toMarkdownColumns(leading);
+        const listKind = /^\d/u.test(list[1] ?? "") ? "ol" : "ul";
+        return {
+            contentFrom: prefixTo,
+            depth: Math.max(1, Math.floor(indentColumns / INDENT_UNIT) + 1),
+            fallbackColumns: toMarkdownColumns(lineText.slice(0, prefixTo)),
+            guideCount: Math.max(0, Math.floor(indentColumns / INDENT_UNIT)),
+            indentColumns,
+            indentText: leading,
+            kind: quote ? "quote-list" : listKind,
+            listKind,
+            markerFrom,
+            markerTo,
+            ...(quote
+                ? {
+                    quoteFrom: leading.length,
+                    quoteTo: structuredOffset,
+                }
+                : {}),
+        };
+    }
+    if (quote) {
+        const prefixTo = structuredOffset;
+        return {
+            contentFrom: prefixTo,
+            depth: 1,
+            fallbackColumns: toMarkdownColumns(lineText.slice(0, prefixTo)),
+            guideCount: Math.max(0, Math.floor(toMarkdownColumns(leading) / INDENT_UNIT)),
+            indentColumns: toMarkdownColumns(leading),
+            // Lapis list/plain-indent only replace leading whitespace; `>` stays
+            // visible until live-preview rich decorations style/hide it.
+            indentText: leading,
+            kind: "quote",
+            quoteFrom: leading.length,
+            quoteTo: prefixTo,
+        };
+    }
+    const plain = getLineIndentInfo(lineText);
+    if (!plain || plain.kind !== "plain") {
+        return null;
+    }
+    return {
+        contentFrom: plain.text.length,
+        depth: plain.depth,
+        fallbackColumns: plain.columns,
+        guideCount: Math.max(0, Math.floor(plain.columns / INDENT_UNIT)),
+        indentColumns: plain.columns,
+        indentText: plain.text,
+        kind: "plain",
+    };
+}
+function fallbackLength(columns, adjustment) {
+    if (columns <= 0 && !adjustment) {
+        return "";
+    }
+    return adjustment
+        ? `calc(${Math.max(columns, 0)}ch + ${adjustment})`
+        : `${columns}ch`;
+}
+function unorderedMarkerAdjustment(markerColumns) {
+    return `var(--hmd-unordered-list-marker-slot-width, ${Math.max(markerColumns, 0)}ch) - ${Math.max(markerColumns, 0)}ch`;
+}
+function widgetFallbackLength(layout, adjustment) {
+    const segmentCount = splitIndentSegments(layout.indentText).length;
+    if (segmentCount === 0) {
+        return fallbackLength(layout.fallbackColumns, adjustment);
+    }
+    const parts = Array.from({ length: segmentCount }, () => "var(--list-indent)");
+    const suffixColumns = Math.max(layout.fallbackColumns - layout.indentColumns, 0);
+    if (suffixColumns > 0) {
+        parts.push(`${suffixColumns}ch`);
+    }
+    if (adjustment) {
+        parts.push(adjustment);
+    }
+    return parts.length === 1 ? parts[0] : `calc(${parts.join(" + ")})`;
+}
+function buildIndentStyle(layout, anchor, usesUnorderedMarkerSlot) {
+    const markerColumns = layout.markerFrom === undefined || layout.markerTo === undefined
+        ? 0
+        : layout.markerTo - layout.markerFrom;
+    const listMarkerAdjustment = layout.listKind === "ul" && usesUnorderedMarkerSlot
+        ? unorderedMarkerAdjustment(markerColumns)
+        : undefined;
+    const paddingFallback = fallbackLength(anchor?.fallbackPaddingColumns ?? layout.fallbackColumns, anchor?.fallbackPaddingAdjustment ?? listMarkerAdjustment);
+    const prefixFallback = fallbackLength(layout.fallbackColumns, listMarkerAdjustment);
+    const widgetPrefixFallback = widgetFallbackLength(layout, listMarkerAdjustment);
+    return [
+        layout.guideCount > 0 ? `--indent-guide-count: ${layout.guideCount};` : "",
+        anchor?.guideOffset || layout.listKind === "ul"
+            ? `--hmd-indent-guide-offset: ${anchor?.guideOffset ?? "var(--hmd-unordered-list-marker-guide-offset, 0px)"};`
+            : "",
+        paddingFallback ? `--hmd-indent-padding-fallback: ${paddingFallback};` : "",
+        prefixFallback ? `--hmd-indent-prefix-fallback: ${prefixFallback};` : "",
+        widgetPrefixFallback
+            ? `--hmd-indent-widget-prefix-fallback: ${widgetPrefixFallback};`
+            : "",
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+class IndentGuideWidget extends WidgetType {
+    segments;
+    plain;
+    constructor(segments, plain) {
+        super();
+        this.segments = segments;
+        this.plain = plain;
+    }
+    eq(other) {
+        return (this.plain === other.plain &&
+            JSON.stringify(this.segments) === JSON.stringify(other.segments));
+    }
+    toDOM() {
+        const guideCount = this.segments.filter((segment) => segment.guide).length;
+        const root = document.createElement("span");
+        root.className = [
+            "cm-hmd-list-indent",
+            `cm-hmd-list-indent-${guideCount}`,
+            this.plain ? "cm-plain-indent-widget" : "",
+        ]
+            .filter(Boolean)
+            .join(" ");
+        root.setAttribute("aria-hidden", "true");
+        for (const segment of this.segments) {
+            const indent = document.createElement("span");
+            indent.className = [
+                "cm-indent",
+                segment.guide ? "cm-indent-guide" : "cm-indent-spacer",
+            ].join(" ");
+            indent.textContent = segment.text;
+            root.append(indent);
+        }
+        return root;
+    }
+    ignoreEvent() {
+        return true;
+    }
+}
+export function indentGuideDecorations(options = {}) {
+    const livePreview = options.livePreview ?? true;
+    return ViewPlugin.fromClass(class {
+        decorations;
+        constructor(view) {
+            this.decorations = this.createDecorations(view);
+        }
+        update(update) {
+            if (update.docChanged ||
+                update.viewportChanged ||
+                update.selectionSet ||
+                update.focusChanged) {
+                this.decorations = this.createDecorations(update.view);
+            }
+        }
+        createDecorations(view) {
+            const decorations = [];
+            const cursor = view.state.selection.main;
+            for (const { from, to } of view.visibleRanges) {
+                let line = view.state.doc.lineAt(from);
+                while (line.from <= to) {
+                    const layout = getIndentLineLayout(line.text);
+                    if (layout && isMarkdownIndentLine(view, line, layout)) {
+                        // Pure quote chrome (`>`, blockquote border) is live-preview-only
+                        // in Lapis (RichEditPlugin). Source keeps literal `>` text.
+                        if (!livePreview && layout.kind === "quote") {
+                            if (line.number >= view.state.doc.lines) {
+                                break;
+                            }
+                            line = view.state.doc.line(line.number + 1);
+                            continue;
+                        }
+                        const indentTo = line.from + layout.indentText.length;
+                        const anchor = layout.kind === "plain"
+                            ? findPlainIndentAnchor(view, line, layout.indentColumns, livePreview)
+                            : null;
+                        const quoteChrome = livePreview &&
+                            (layout.kind === "quote" || layout.kind === "quote-list");
+                        decorations.push(Decoration.line({
+                            attributes: {
+                                "data-indent-prefix": layout.indentText,
+                                "data-indent-fallback-columns": `${layout.fallbackColumns}`,
+                                "data-indent-variant": layout.kind,
+                                "data-line-from": `${line.from}`,
+                                "data-list-depth": `${layout.depth}`,
+                                ...(layout.listKind
+                                    ? { "data-list-kind": layout.listKind }
+                                    : {}),
+                                ...(anchor
+                                    ? {
+                                        "data-indent-anchor-line-from": `${anchor.lineFrom}`,
+                                    }
+                                    : {}),
+                                style: buildIndentStyle(layout, anchor, livePreview),
+                            },
+                            class: [
+                                "indented-wrapped-line",
+                                layout.kind === "plain" ? "cm-plain-indent-line" : "",
+                                quoteChrome ? "cm-blockquote" : "",
+                                layout.listKind || layout.kind === "plain"
+                                    ? "HyperMD-list-line"
+                                    : "",
+                                layout.listKind || layout.kind === "plain"
+                                    ? `HyperMD-list-line-${layout.depth}`
+                                    : "",
+                                !layout.listKind ? "cm-formatting" : "",
+                                layout.kind === "plain" ? "cm-formatting-list" : "",
+                                layout.kind === "plain" ? "cm-formatting-list-ul" : "",
+                                layout.kind === "plain" ? `cm-list-${layout.depth}` : "",
+                            ]
+                                .filter(Boolean)
+                                .join(" "),
+                        }).range(line.from));
+                        if (layout.indentText.length > 0 &&
+                            !selectionTouchesIndent(cursor.from, cursor.to, line.from, indentTo)) {
+                            decorations.push(Decoration.replace({
+                                widget: new IndentGuideWidget(splitIndentSegments(layout.indentText), layout.kind === "plain"),
+                            }).range(line.from, indentTo));
+                        }
+                        if (layout.markerFrom !== undefined &&
+                            layout.markerTo !== undefined) {
+                            const markerFrom = line.from + layout.markerFrom;
+                            const styledUnorderedMarker = layout.listKind === "ul" &&
+                                shouldRenderStyledUnorderedMarker(livePreview, cursor.from, markerFrom);
+                            decorations.push(Decoration.mark({
+                                class: [
+                                    "cm-formatting",
+                                    "cm-formatting-list",
+                                    layout.listKind === "ol"
+                                        ? "cm-formatting-list-ol"
+                                        : "cm-formatting-list-ul",
+                                    `cm-list-${layout.depth}`,
+                                    styledUnorderedMarker ? "cm-formatting-list-bullet" : "",
+                                ]
+                                    .filter(Boolean)
+                                    .join(" "),
+                            }).range(markerFrom, line.from + layout.markerTo));
+                        }
+                        if (livePreview &&
+                            layout.quoteFrom !== undefined &&
+                            layout.quoteTo !== undefined) {
+                            const quoteDepth = (line.text
+                                .slice(layout.quoteFrom, layout.quoteTo)
+                                .match(/>/gu) ?? []).length;
+                            decorations.push(Decoration.mark({
+                                class: [
+                                    "cm-formatting-quote",
+                                    `cm-formatting-quote-${quoteDepth}`,
+                                    "cm-quote",
+                                    `cm-quote-${quoteDepth}`,
+                                    quoteDepth > 1 ? "cm-blockquote-border" : "",
+                                ]
+                                    .filter(Boolean)
+                                    .join(" "),
+                            }).range(line.from + layout.quoteFrom, line.from + layout.quoteTo));
+                        }
+                        if (layout.contentFrom < line.text.length) {
+                            decorations.push(Decoration.mark({
+                                class: `cm-list-${layout.depth}`,
+                            }).range(line.from + layout.contentFrom, line.to));
+                        }
+                    }
+                    if (line.number >= view.state.doc.lines) {
+                        break;
+                    }
+                    line = view.state.doc.line(line.number + 1);
+                }
+            }
+            return Decoration.set(sortRanges(decorations));
+        }
+    }, {
+        decorations: (plugin) => plugin.decorations,
+    });
+}
+function isMarkdownIndentLine(view, line, layout) {
+    // Fenced code keeps literal leading whitespace + the shared 24px fence
+    // padding. Hanging-indent chrome here pulls lines left of that padding
+    // until the cursor sits on the indent and clears the replace widget.
+    if (isFencedCodeLine(view.state, line.number)) {
+        return false;
+    }
+    if (!layout.listKind && layout.kind !== "quote") {
+        return true;
+    }
+    let list = false;
+    let quote = false;
+    const tree = ensureSyntaxTree(view.state, line.to, 25) ?? syntaxTree(view.state);
+    tree.iterate({
+        from: line.from,
+        to: line.to,
+        enter(node) {
+            list ||= node.name === "ListMark";
+            quote ||= node.name === "QuoteMark";
+        },
+    });
+    return layout.listKind ? list : quote;
+}
+export function shouldAnchorPlainIndentToListItem(indentColumns, parentContentColumns) {
+    return indentColumns < parentContentColumns + INDENT_UNIT;
+}
+function getMarkerEnd(lineText, lineFrom, markerFrom, markerTo) {
+    const markerOffset = markerFrom - lineFrom;
+    const spaceOffset = lineText.indexOf(" ", markerOffset);
+    return spaceOffset === -1 ? markerTo : lineFrom + spaceOffset + 1;
+}
+function getListPrefixEndFromText(remainder, markerEnd) {
+    const task = remainder.match(/^(\[[^\]]\]\s+)/u)?.[0] ?? "";
+    return markerEnd + task.length;
+}
+function findPlainIndentAnchor(view, line, indentColumns, usesUnorderedMarkerSlot) {
+    const tree = ensureSyntaxTree(view.state, line.to, 25) ?? syntaxTree(view.state);
+    const node = tree.resolve(line.from, 1);
+    for (let current = node; current; current = current.parent) {
+        if (current.name !== "ListItem") {
+            continue;
+        }
+        const list = current.parent;
+        if (!list || (list.name !== "BulletList" && list.name !== "OrderedList")) {
+            continue;
+        }
+        const listMark = current.getChild("ListMark");
+        if (!listMark) {
+            return null;
+        }
+        const anchorLine = view.state.doc.lineAt(listMark.from);
+        if (anchorLine.from === line.from) {
+            return null;
+        }
+        const markerEnd = getMarkerEnd(anchorLine.text, anchorLine.from, listMark.from, listMark.to);
+        const prefixEnd = getListPrefixEndFromText(view.state.sliceDoc(markerEnd, anchorLine.to), markerEnd);
+        const fallbackPaddingColumns = toMarkdownColumns(view.state.sliceDoc(anchorLine.from, prefixEnd));
+        if (!shouldAnchorPlainIndentToListItem(indentColumns, fallbackPaddingColumns)) {
+            return null;
+        }
+        if (list.name === "BulletList" && usesUnorderedMarkerSlot) {
+            const markerColumns = toMarkdownColumns(view.state.sliceDoc(listMark.from, markerEnd));
+            return {
+                fallbackPaddingAdjustment: unorderedMarkerAdjustment(markerColumns),
+                fallbackPaddingColumns,
+                guideOffset: "var(--hmd-unordered-list-marker-guide-offset, 0px)",
+                lineFrom: anchorLine.from,
+            };
+        }
+        return { fallbackPaddingColumns, lineFrom: anchorLine.from };
+    }
+    return null;
+}

package/dist/internal/codemirror/rich/utils/indent.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=indent.test.d.ts.map

package/dist/internal/codemirror/rich/utils/indent.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indent.test.d.ts","sourceRoot":"","sources":["../../../../../src/internal/codemirror/rich/utils/indent.test.ts"],"names":[],"mappings":""}

package/dist/internal/codemirror/rich/utils/indent.test.js

@@ -0,0 +1,169 @@
+import { describe, expect, it } from "vitest";
+import { EditorView } from "@codemirror/view";
+import { createMarkdownCodeMirrorExtensions } from "../../markdown";
+import { getIndentLineLayout, getLineIndentInfo, indentGuideDecorations, normalizeIndentText, selectionTouchesIndent, shouldRenderStyledUnorderedMarker, shouldAnchorPlainIndentToListItem, splitIndentSegments, toMarkdownColumns, } from "./indent";
+describe("indent helpers", () => {
+    it("derives Lapis-style indentation metadata", () => {
+        expect(toMarkdownColumns("\t  ")).toBe(6);
+        expect(normalizeIndentText("\t  ")).toBe("      ");
+        expect(splitIndentSegments("      ")).toEqual([
+            { text: "    ", guide: true },
+            { text: "  ", guide: false },
+        ]);
+        expect(getLineIndentInfo("    - nested")).toEqual({
+            columns: 4,
+            depth: 2,
+            kind: "ul",
+            text: "    ",
+        });
+        expect(getLineIndentInfo("  continuation")).toEqual({
+            columns: 2,
+            depth: 1,
+            kind: "plain",
+            text: "  ",
+        });
+        expect(selectionTouchesIndent(2, 2, 0, 4)).toBe(true);
+        expect(selectionTouchesIndent(5, 5, 0, 4)).toBe(false);
+        expect(shouldRenderStyledUnorderedMarker(true, 12, 10)).toBe(true);
+        expect(shouldRenderStyledUnorderedMarker(false, 12, 10)).toBe(false);
+        expect(shouldRenderStyledUnorderedMarker(true, 10, 10)).toBe(false);
+        expect(shouldRenderStyledUnorderedMarker(true, 11, 10)).toBe(false);
+        expect(shouldAnchorPlainIndentToListItem(2, 2)).toBe(true);
+        expect(shouldAnchorPlainIndentToListItem(8, 3)).toBe(false);
+    });
+    it("styles inactive dash and asterisk markers only in live preview", async () => {
+        const parent = document.createElement("div");
+        document.body.append(parent);
+        const view = new EditorView({
+            doc: ["# List markers", "", "- Dash item", "* Asterisk item"].join("\n"),
+            extensions: [
+                createMarkdownCodeMirrorExtensions(),
+                indentGuideDecorations({ livePreview: true }),
+            ],
+            parent,
+        });
+        await new Promise((resolve) => requestAnimationFrame(() => resolve(null)));
+        const markerFor = (snippet) => [...parent.querySelectorAll(".cm-line")]
+            .find((line) => (line.textContent || "").includes(snippet))
+            ?.querySelector(".cm-formatting-list-ul");
+        expect(markerFor("Dash item")?.textContent).toBe("- ");
+        expect(markerFor("Dash item")?.classList).toContain("cm-formatting-list-bullet");
+        expect(markerFor("Asterisk item")?.textContent).toBe("* ");
+        expect(markerFor("Asterisk item")?.classList).toContain("cm-formatting-list-bullet");
+        view.dispatch({ selection: { anchor: view.state.doc.line(3).from } });
+        expect(markerFor("Dash item")?.classList).not.toContain("cm-formatting-list-bullet");
+        expect(markerFor("Asterisk item")?.classList).toContain("cm-formatting-list-bullet");
+        view.destroy();
+        parent.remove();
+    });
+    it("derives authored prefixes for top-level, quoted, and plain lines", () => {
+        expect(getIndentLineLayout("- wrapped item")).toMatchObject({
+            fallbackColumns: 2,
+            indentText: "",
+            kind: "ul",
+            listKind: "ul",
+            markerFrom: 0,
+            markerTo: 2,
+        });
+        expect(getIndentLineLayout("> 1. quoted item")).toMatchObject({
+            fallbackColumns: 5,
+            indentText: "",
+            kind: "quote-list",
+            listKind: "ol",
+            quoteFrom: 0,
+            quoteTo: 2,
+        });
+        expect(getIndentLineLayout("> quoted paragraph")).toMatchObject({
+            fallbackColumns: 2,
+            indentText: "",
+            kind: "quote",
+            quoteFrom: 0,
+            quoteTo: 2,
+        });
+        expect(getIndentLineLayout("    > indented quote")).toMatchObject({
+            fallbackColumns: 6,
+            indentText: "    ",
+            kind: "quote",
+            quoteFrom: 4,
+            quoteTo: 6,
+        });
+        expect(getIndentLineLayout("    continuation")).toMatchObject({
+            fallbackColumns: 4,
+            indentText: "    ",
+            kind: "plain",
+        });
+    });
+    it("does not apply hanging indent inside fenced code blocks", async () => {
+        const parent = document.createElement("div");
+        document.body.append(parent);
+        const view = new EditorView({
+            doc: [
+                "~~~mermaid",
+                "  Source --> LivePreview",
+                "  LivePreview --> Preview",
+                "~~~",
+                "  outside continuation",
+            ].join("\n"),
+            extensions: indentGuideDecorations({ livePreview: false }),
+            parent,
+        });
+        await new Promise((resolve) => requestAnimationFrame(() => resolve(null)));
+        const fenceBody = [...parent.querySelectorAll(".cm-line")].filter((line) => (line.textContent || "").includes("Source --> LivePreview"));
+        expect(fenceBody.length).toBe(1);
+        expect(fenceBody[0]?.classList.contains("indented-wrapped-line")).toBe(false);
+        expect(fenceBody[0]?.querySelector(".cm-hmd-list-indent")).toBeNull();
+        const outside = [...parent.querySelectorAll(".cm-line")].find((line) => (line.textContent || "").includes("outside continuation"));
+        expect(outside?.classList.contains("indented-wrapped-line")).toBe(true);
+        view.destroy();
+        parent.remove();
+    });
+    it("anchors list continuations through syntax-tree ownership", async () => {
+        const parent = document.createElement("div");
+        document.body.append(parent);
+        const view = new EditorView({
+            doc: [
+                "- Bullet item",
+                " This single-space continuation",
+                "  This two-space continuation",
+                "",
+                "2. Multiple paragraphs:",
+                "    First ordered continuation",
+                "",
+                "    Second ordered continuation",
+                "",
+                "4. Preformatted content:",
+                "",
+                "        Eight-space preformatted content",
+            ].join("\n"),
+            extensions: [
+                createMarkdownCodeMirrorExtensions(),
+                indentGuideDecorations({ livePreview: false }),
+            ],
+            parent,
+        });
+        await new Promise((resolve) => requestAnimationFrame(() => resolve(null)));
+        const lineContaining = (snippet) => [...parent.querySelectorAll(".cm-line")].find((line) => (line.textContent || "").includes(snippet));
+        const bullet = lineContaining("Bullet item");
+        const ordered = lineContaining("Multiple paragraphs");
+        const single = lineContaining("single-space continuation");
+        const two = lineContaining("two-space continuation");
+        const first = lineContaining("First ordered continuation");
+        const second = lineContaining("Second ordered continuation");
+        const preformatted = lineContaining("Eight-space preformatted content");
+        expect(bullet?.dataset["indentAnchorLineFrom"]).toBeUndefined();
+        expect(bullet?.classList.contains("cm-formatting-list-ul")).toBe(false);
+        expect(bullet?.querySelector(".cm-formatting-list-ul")).not.toBeNull();
+        expect(single?.dataset["indentAnchorLineFrom"]).toBe(`${view.state.doc.line(1).from}`);
+        expect(two?.dataset["indentAnchorLineFrom"]).toBe(`${view.state.doc.line(1).from}`);
+        expect(two?.getAttribute("style")).toContain("--hmd-indent-widget-prefix-fallback: var(--list-indent)");
+        expect(two?.getAttribute("style")).toContain("--hmd-indent-padding-fallback: 2ch");
+        expect(first?.dataset["indentAnchorLineFrom"]).toBe(`${view.state.doc.line(5).from}`);
+        expect(second?.dataset["indentAnchorLineFrom"]).toBe(`${view.state.doc.line(5).from}`);
+        expect(ordered?.classList.contains("cm-formatting-list-ol")).toBe(false);
+        expect(preformatted?.dataset["indentAnchorLineFrom"]).toBeUndefined();
+        expect(preformatted?.querySelectorAll(".cm-indent-guide")).toHaveLength(2);
+        expect(preformatted?.getAttribute("style")).toContain("--hmd-indent-widget-prefix-fallback: calc(var(--list-indent) + var(--list-indent))");
+        view.destroy();
+        parent.remove();
+    });
+});

package/dist/internal/codemirror/rich/utils/inline-code.d.ts

@@ -0,0 +1,7 @@
+import type { RangeBoundary } from "./ranges";
+export declare function findInlineCodeRanges(text: string): RangeBoundary[];
+export declare function countRun(text: string, start: number, character: string): number;
+export declare function isPositionInsideRanges(position: number, ranges: RangeBoundary[]): boolean;
+export declare function isEscaped(text: string, index: number): boolean;
+export declare function isWhitespace(character: string): boolean;
+//# sourceMappingURL=inline-code.d.ts.map

package/dist/internal/codemirror/rich/utils/inline-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-code.d.ts","sourceRoot":"","sources":["../../../../../src/internal/codemirror/rich/utils/inline-code.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAwBlE;AAED,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GAChB,MAAM,CAMR;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,aAAa,EAAE,GACtB,OAAO,CAET;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAQ9D;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEvD"}

package/dist/internal/codemirror/rich/utils/inline-code.js

@@ -0,0 +1,43 @@
+export function findInlineCodeRanges(text) {
+    const ranges = [];
+    let index = 0;
+    while (index < text.length) {
+        if (text[index] !== "`" || isEscaped(text, index)) {
+            index += 1;
+            continue;
+        }
+        const tickCount = countRun(text, index, "`");
+        const closingIndex = text.indexOf("`".repeat(tickCount), index + tickCount);
+        if (closingIndex === -1) {
+            break;
+        }
+        ranges.push({
+            from: index,
+            to: closingIndex + tickCount,
+        });
+        index = closingIndex + tickCount;
+    }
+    return ranges;
+}
+export function countRun(text, start, character) {
+    let count = 0;
+    while (text[start + count] === character) {
+        count += 1;
+    }
+    return count;
+}
+export function isPositionInsideRanges(position, ranges) {
+    return ranges.some((range) => position >= range.from && position < range.to);
+}
+export function isEscaped(text, index) {
+    let backslashes = 0;
+    let cursor = index - 1;
+    while (cursor >= 0 && text[cursor] === "\\") {
+        backslashes += 1;
+        cursor -= 1;
+    }
+    return backslashes % 2 === 1;
+}
+export function isWhitespace(character) {
+    return character.length > 0 && /\s/u.test(character);
+}

package/dist/internal/codemirror/rich/utils/inline-math.d.ts

@@ -0,0 +1,6 @@
+import type { RangeBoundary } from "./ranges";
+export type InlineMathRange = RangeBoundary & {
+    source: string;
+};
+export declare function findInlineMathRanges(text: string): InlineMathRange[];
+//# sourceMappingURL=inline-math.d.ts.map

package/dist/internal/codemirror/rich/utils/inline-math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-math.d.ts","sourceRoot":"","sources":["../../../../../src/internal/codemirror/rich/utils/inline-math.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAQ9C,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG;IAC5C,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,EAAE,CAoDpE"}