@lapismd/mira 0.0.1

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

@@ -0,0 +1,419 @@
+import { EditorView, ViewPlugin, } from "@codemirror/view";
+import { selectionTouchesIndent } from "./indent";
+const measuredPaddingProperty = "--hmd-indent-padding-measured";
+const measuredPrefixProperty = "--hmd-indent-prefix-measured";
+function setStylePropertyIfChanged(line, property, value) {
+    if (line.style.getPropertyValue(property) !== value) {
+        line.style.setProperty(property, value);
+    }
+}
+function removeStylePropertyIfPresent(line, property) {
+    if (line.style.getPropertyValue(property)) {
+        line.style.removeProperty(property);
+    }
+}
+export function syncMeasuredIndentStyles(content, measurements) {
+    for (const line of content.querySelectorAll(".cm-line")) {
+        const from = Number.parseInt(line.dataset["lineFrom"] ?? "", 10);
+        const measurement = Number.isFinite(from)
+            ? measurements.get(from)
+            : undefined;
+        if (!measurement) {
+            // The read and write phases can straddle a CodeMirror decoration
+            // update. Preserve a still-participating line that was absent from this
+            // read; only a line that definitively lost its indent contract clears
+            // the last valid measurement.
+            if (!line.hasAttribute("data-indent-prefix")) {
+                removeStylePropertyIfPresent(line, measuredPaddingProperty);
+                removeStylePropertyIfPresent(line, measuredPrefixProperty);
+            }
+            continue;
+        }
+        // A null component means that this measurement pass could not resolve it,
+        // not that the line stopped participating. Preserve the last valid value
+        // through focus and decoration transitions; a line absent from the map is
+        // the explicit signal to clear both properties.
+        if (measurement.paddingPx !== null) {
+            setStylePropertyIfChanged(line, measuredPaddingProperty, `${measurement.paddingPx}px`);
+        }
+        if (measurement.prefixPx !== null) {
+            setStylePropertyIfChanged(line, measuredPrefixProperty, `${measurement.prefixPx}px`);
+        }
+    }
+}
+function quotePrefixLength(line) {
+    return line.match(/^\s*>+\s*/u)?.[0].length ?? 0;
+}
+function measureLeadingRawPrefixBox(line, prefix) {
+    const rawPrefix = Array.from(line.childNodes).find((node) => node.nodeType === Node.TEXT_NODE &&
+        typeof node.textContent === "string" &&
+        node.textContent.startsWith(prefix));
+    if (!rawPrefix) {
+        return null;
+    }
+    const range = document.createRange();
+    range.setStart(rawPrefix, 0);
+    range.setEnd(rawPrefix, Math.min(prefix.length, rawPrefix.length));
+    const rect = Array.from(range.getClientRects()).find((candidate) => candidate.width > 0 || candidate.height > 0) ?? range.getBoundingClientRect();
+    return Number.isFinite(rect.width) && rect.width > 0
+        ? { width: rect.width }
+        : null;
+}
+function measureTextNodeWidth(node) {
+    if (node.length <= 0) {
+        return null;
+    }
+    const range = document.createRange();
+    range.setStart(node, 0);
+    range.setEnd(node, node.length);
+    const rect = Array.from(range.getClientRects()).find((candidate) => candidate.width > 0 || candidate.height > 0) ?? range.getBoundingClientRect();
+    return Number.isFinite(rect.width) && rect.width > 0 ? rect.width : null;
+}
+function measureMarkerWidth(line) {
+    const marker = line.querySelector(".cm-formatting-list-ul, .cm-formatting-list-ol");
+    const width = marker?.getBoundingClientRect().width;
+    return width && Number.isFinite(width) && width > 0 ? width : 0;
+}
+function measureQuotePrefixWidth(view, from) {
+    const length = quotePrefixLength(view.state.doc.lineAt(from).text);
+    if (length <= 0) {
+        return null;
+    }
+    const start = view.coordsAtPos(from);
+    const end = view.coordsAtPos(from + length);
+    if (!start || !end) {
+        return null;
+    }
+    const measured = end.left - start.left;
+    return Number.isFinite(measured) && measured > 0 ? measured : null;
+}
+function measureStableWidgetWidth(line) {
+    const widget = line.querySelector(".cm-plain-indent-widget, .cm-hmd-list-indent");
+    if (!widget) {
+        return null;
+    }
+    const segmentWidth = Array.from(widget.querySelectorAll(".cm-indent")).reduce((total, segment) => {
+        return total + (measureIndentSegmentWidth(segment) ?? 0);
+    }, 0);
+    if (segmentWidth > 0) {
+        return segmentWidth;
+    }
+    const widgetWidth = widget.getBoundingClientRect().width;
+    return Number.isFinite(widgetWidth) && widgetWidth > 0 ? widgetWidth : null;
+}
+export function measureIndentSegmentWidth(segment) {
+    if (segment.classList.contains("cm-indent-spacer")) {
+        let textWidth = 0;
+        let measuredText = false;
+        const walker = document.createTreeWalker(segment, NodeFilter.SHOW_TEXT);
+        while (walker.nextNode()) {
+            const node = walker.currentNode;
+            if (!(node instanceof Text)) {
+                continue;
+            }
+            const width = measureTextNodeWidth(node);
+            if (width !== null) {
+                textWidth += width;
+                measuredText = true;
+            }
+        }
+        if (measuredText && textWidth > 0) {
+            return textWidth;
+        }
+    }
+    const width = segment.getBoundingClientRect().width;
+    return Number.isFinite(width) && width > 0 ? width : null;
+}
+function measureRawPrefixWidth(view, line, from, prefix) {
+    const rawWidth = measureLeadingRawPrefixBox(line, prefix)?.width;
+    if (rawWidth !== undefined) {
+        return rawWidth;
+    }
+    const start = view.coordsAtPos(from);
+    const end = view.coordsAtPos(from + prefix.length);
+    if (start && end) {
+        const measured = end.left - start.left;
+        if (Number.isFinite(measured) && measured > 0) {
+            return measured;
+        }
+    }
+    return null;
+}
+function measuredWidth(cache, line, cacheKey, canMeasureWidget) {
+    const measured = canMeasureWidget ? measureStableWidgetWidth(line) : null;
+    return measured ?? cache.get(cacheKey) ?? null;
+}
+function firstContentTextNode(line) {
+    const walker = document.createTreeWalker(line, NodeFilter.SHOW_TEXT);
+    while (walker.nextNode()) {
+        const node = walker.currentNode;
+        if (!(node instanceof Text)) {
+            continue;
+        }
+        const skipped = node.parentElement?.closest(".cm-hmd-list-indent, .cm-plain-indent-widget, .cm-formatting-list-ul, .cm-formatting-list-ol, .cm-blockquote-border, .cm-formatting-quote");
+        if (skipped && skipped !== line) {
+            continue;
+        }
+        const index = Array.from(node.textContent ?? "").findIndex((character) => /\S/u.test(character));
+        if (index < 0) {
+            continue;
+        }
+        return node;
+    }
+    return null;
+}
+function measureLeadingContentChrome(line) {
+    const node = firstContentTextNode(line);
+    let chrome = 0;
+    for (let element = node?.parentElement ?? null; element && element !== line; element = element.parentElement) {
+        const style = getComputedStyle(element);
+        for (const value of [
+            style.paddingInlineStart,
+            style.borderInlineStartWidth,
+            style.marginInlineStart,
+        ]) {
+            const width = Number.parseFloat(value);
+            if (Number.isFinite(width)) {
+                chrome += width;
+            }
+        }
+    }
+    return chrome;
+}
+function measureFirstContentOffset(line) {
+    const lineRect = line.getBoundingClientRect();
+    const node = firstContentTextNode(line);
+    if (node) {
+        const index = Array.from(node.textContent ?? "").findIndex((character) => /\S/u.test(character));
+        const range = document.createRange();
+        range.setStart(node, index);
+        range.setEnd(node, Math.min(index + 1, node.length));
+        const rect = Array.from(range.getClientRects()).find((candidate) => candidate.width > 0 || candidate.height > 0) ?? range.getBoundingClientRect();
+        if (Number.isFinite(rect.left) && (rect.width > 0 || rect.height > 0)) {
+            return rect.left - lineRect.left;
+        }
+    }
+    return null;
+}
+class MeasuredIndentPlugin {
+    cache = new Map();
+    measuredPaddingByFrom = new Map();
+    reschedule = false;
+    scheduled = false;
+    transitionRetryFrames = 0;
+    retryFrames = 0;
+    destroyed = false;
+    constructor(view) {
+        this.schedule(view);
+        this.retryStartup(view);
+    }
+    update(update) {
+        if (update.docChanged) {
+            this.measuredPaddingByFrom.clear();
+        }
+        let needsMeasure = update.geometryChanged;
+        const selectionChanged = !update.startState.selection.eq(update.state.selection);
+        if (update.focusChanged || selectionChanged) {
+            // CodeMirror can rebuild line decorations across several frames after a
+            // focus or selection transition. Keep measuring until that transition
+            // has exposed its stable DOM, including under a busy browser worker.
+            this.transitionRetryFrames = 30;
+        }
+        // A geometry update can be the second half of CodeMirror revealing a raw
+        // prefix. Keep the last widget-backed width until a laid-out widget can
+        // replace it; clearing the cache here creates a one-frame 2ch/4ch jump.
+        needsMeasure ||= update.docChanged || update.viewportChanged;
+        needsMeasure ||= update.focusChanged;
+        needsMeasure ||= selectionChanged;
+        if (needsMeasure) {
+            this.schedule(update.view);
+        }
+    }
+    schedule(view) {
+        if (this.scheduled) {
+            // Focus, selection, and geometry updates can arrive before the pending
+            // measure writes. Remember the later invalidation so a transitional DOM
+            // read cannot become the final indentation state.
+            this.reschedule = true;
+            return true;
+        }
+        if (!view.inView) {
+            return false;
+        }
+        this.scheduled = true;
+        view.requestMeasure({
+            read: () => {
+                const selection = view.state.selection.main;
+                if (!view.inView) {
+                    return {
+                        inactive: true,
+                        measurements: [],
+                        selectionFrom: selection.from,
+                        selectionTo: selection.to,
+                    };
+                }
+                const lines = view.contentDOM.querySelectorAll(".cm-line[data-indent-prefix]");
+                const measurements = [];
+                for (const line of lines) {
+                    const from = Number.parseInt(line.dataset["lineFrom"] ?? "", 10);
+                    if (!Number.isFinite(from)) {
+                        continue;
+                    }
+                    const prefix = line.dataset["indentPrefix"] ?? "";
+                    const variant = line.dataset["indentVariant"] ?? "unknown";
+                    const listKind = line.dataset["listKind"] ?? "";
+                    const cacheKey = `${variant}\u0000${listKind}\u0000${prefix}`;
+                    const isList = line.hasAttribute("data-list-kind");
+                    const hasPrefix = prefix.length > 0;
+                    const hasIndentWidget = Boolean(line.querySelector(".cm-plain-indent-widget, .cm-hmd-list-indent"));
+                    const selection = view.state.selection.main;
+                    const expectsIndentWidget = hasPrefix &&
+                        !selectionTouchesIndent(selection.from, selection.to, from, from + prefix.length);
+                    const stableIndentPx = hasPrefix
+                        ? measuredWidth(this.cache, line, cacheKey, hasIndentWidget)
+                        : isList
+                            ? 0
+                            : null;
+                    const rawPrefixWidth = hasPrefix
+                        ? measureLeadingRawPrefixBox(line, prefix)?.width
+                        : undefined;
+                    const visibleIndentPx = hasPrefix
+                        ? expectsIndentWidget
+                            ? stableIndentPx === null
+                                ? null
+                                : stableIndentPx + measureLeadingContentChrome(line)
+                            : (rawPrefixWidth ??
+                                (hasIndentWidget
+                                    ? null
+                                    : measureRawPrefixWidth(view, line, from, prefix)))
+                        : isList
+                            ? 0
+                            : null;
+                    const markerWidth = measureMarkerWidth(line);
+                    const lineText = view.state.doc.lineAt(from).text;
+                    const hasQuote = quotePrefixLength(lineText) > 0;
+                    const isQuoteList = variant === "quote-list" || (isList && hasQuote);
+                    const quoteWidth = variant === "quote" || isQuoteList
+                        ? measureQuotePrefixWidth(view, from)
+                        : null;
+                    let prefixPx = visibleIndentPx;
+                    if (isList && prefixPx !== null) {
+                        prefixPx += markerWidth;
+                    }
+                    if (quoteWidth !== null) {
+                        prefixPx = isQuoteList ? quoteWidth + markerWidth : quoteWidth;
+                    }
+                    let paddingPx = stableIndentPx;
+                    if (isList && paddingPx !== null) {
+                        paddingPx += markerWidth;
+                    }
+                    if (quoteWidth !== null) {
+                        paddingPx = isQuoteList ? quoteWidth + markerWidth : quoteWidth;
+                    }
+                    const anchorFrom = Number.parseInt(line.dataset["indentAnchorLineFrom"] ?? "", 10);
+                    if (Number.isFinite(anchorFrom)) {
+                        const anchor = view.contentDOM.querySelector(`.cm-line[data-line-from="${anchorFrom}"]`);
+                        const anchorOffset = anchor
+                            ? measureFirstContentOffset(anchor)
+                            : null;
+                        if (anchorOffset !== null && anchorOffset > 0) {
+                            paddingPx = anchorOffset;
+                        }
+                        else {
+                            // Focus and decoration transitions can briefly replace the
+                            // anchor's measurable content span. Retain this document's last
+                            // resolved parent column instead of dropping to the narrower
+                            // structural fallback for a paint frame.
+                            paddingPx = this.measuredPaddingByFrom.get(from) ?? null;
+                        }
+                    }
+                    measurements.push({
+                        cacheKey,
+                        from,
+                        paddingPx,
+                        prefixPx,
+                        stableIndentPx,
+                    });
+                }
+                return {
+                    inactive: false,
+                    measurements,
+                    selectionFrom: selection.from,
+                    selectionTo: selection.to,
+                };
+            },
+            write: ({ inactive, measurements, selectionFrom, selectionTo }) => {
+                this.scheduled = false;
+                const reschedule = this.reschedule;
+                this.reschedule = false;
+                const scheduleFollowUp = () => {
+                    if (reschedule) {
+                        this.schedule(view);
+                        return;
+                    }
+                    if (this.transitionRetryFrames <= 0) {
+                        return;
+                    }
+                    this.transitionRetryFrames -= 1;
+                    requestAnimationFrame(() => {
+                        if (!this.destroyed) {
+                            this.schedule(view);
+                        }
+                    });
+                };
+                // CodeMirror can move an otherwise visible editor out of its measured
+                // viewport between scheduling and reading. That is not evidence that
+                // its valid line measurements became stale.
+                if (inactive) {
+                    scheduleFollowUp();
+                    return;
+                }
+                const selection = view.state.selection.main;
+                if (selection.from !== selectionFrom || selection.to !== selectionTo) {
+                    this.schedule(view);
+                    return;
+                }
+                const byFrom = new Map();
+                for (const measurement of measurements) {
+                    const { cacheKey, from, paddingPx, prefixPx, stableIndentPx } = measurement;
+                    if (paddingPx !== null) {
+                        this.measuredPaddingByFrom.set(from, paddingPx);
+                    }
+                    if (paddingPx !== null || prefixPx !== null) {
+                        byFrom.set(from, { paddingPx, prefixPx });
+                    }
+                    const previous = this.cache.get(cacheKey);
+                    if (stableIndentPx !== null &&
+                        (previous === undefined ||
+                            Math.abs(previous - stableIndentPx) > 0.5)) {
+                        this.cache.set(cacheKey, stableIndentPx);
+                    }
+                }
+                syncMeasuredIndentStyles(view.contentDOM, byFrom);
+                scheduleFollowUp();
+            },
+        });
+        return true;
+    }
+    retryStartup(view) {
+        if (this.destroyed || this.retryFrames > 60) {
+            return;
+        }
+        this.retryFrames += 1;
+        requestAnimationFrame(() => {
+            if (!this.destroyed) {
+                this.schedule(view);
+                this.retryStartup(view);
+            }
+        });
+    }
+    destroy() {
+        this.destroyed = true;
+    }
+}
+export function measuredIndentExtension() {
+    return [
+        ViewPlugin.fromClass(MeasuredIndentPlugin),
+        EditorView.editorAttributes.of({ class: "cm-measured-indent" }),
+    ];
+}

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

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

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

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

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

@@ -0,0 +1,102 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { measureIndentSegmentWidth, syncMeasuredIndentStyles, } from "./measured-indent";
+function appendLine(root, from) {
+    const line = document.createElement("div");
+    line.className = "cm-line";
+    line.dataset["lineFrom"] = `${from}`;
+    root.append(line);
+    return line;
+}
+function domRect(width) {
+    return {
+        bottom: 16,
+        height: 16,
+        left: 0,
+        right: width,
+        toJSON: () => ({}),
+        top: 0,
+        width,
+        x: 0,
+        y: 0,
+    };
+}
+function mockTextRangeMeasurements(characterWidth) {
+    vi.spyOn(document, "createRange").mockImplementation(() => {
+        let node = null;
+        let end = 0;
+        const range = {
+            setStart(nextNode) {
+                node = nextNode;
+            },
+            setEnd(_nextNode, nextEnd) {
+                end = nextEnd;
+            },
+            getClientRects() {
+                const width = (node?.data.slice(0, end).length ?? 0) * characterWidth;
+                return [domRect(width)];
+            },
+            getBoundingClientRect() {
+                const width = (node?.data.slice(0, end).length ?? 0) * characterWidth;
+                return domRect(width);
+            },
+        };
+        return range;
+    });
+}
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe("measured indent styles", () => {
+    it("measures plain spacer text instead of its minimum guide slot", () => {
+        mockTextRangeMeasurements(8);
+        const spacer = document.createElement("span");
+        spacer.className = "cm-indent cm-indent-spacer";
+        spacer.textContent = "  ";
+        vi.spyOn(spacer, "getBoundingClientRect").mockReturnValue(domRect(32));
+        expect(measureIndentSegmentWidth(spacer)).toBe(16);
+    });
+    it("keeps guide segments measured by their rendered slot", () => {
+        mockTextRangeMeasurements(8);
+        const guide = document.createElement("span");
+        guide.className = "cm-indent cm-indent-guide";
+        guide.textContent = "    ";
+        vi.spyOn(guide, "getBoundingClientRect").mockReturnValue(domRect(32));
+        expect(measureIndentSegmentWidth(guide)).toBe(32);
+    });
+    it("only writes changed measurements", () => {
+        const root = document.createElement("div");
+        const line = appendLine(root, 10);
+        line.style.setProperty("--hmd-indent-padding-measured", "24px");
+        line.style.setProperty("--hmd-indent-prefix-measured", "8px");
+        const setProperty = vi.spyOn(line.style, "setProperty");
+        syncMeasuredIndentStyles(root, new Map([[10, { paddingPx: 24, prefixPx: 8 }]]));
+        expect(setProperty).not.toHaveBeenCalled();
+    });
+    it("removes measurements from lines that no longer carry a prefix", () => {
+        const root = document.createElement("div");
+        const line = appendLine(root, 10);
+        line.style.setProperty("--hmd-indent-padding-measured", "24px");
+        line.style.setProperty("--hmd-indent-prefix-measured", "8px");
+        syncMeasuredIndentStyles(root, new Map());
+        expect(line.style.getPropertyValue("--hmd-indent-padding-measured")).toBe("");
+        expect(line.style.getPropertyValue("--hmd-indent-prefix-measured")).toBe("");
+    });
+    it("preserves a participating line omitted by a transitional read", () => {
+        const root = document.createElement("div");
+        const line = appendLine(root, 10);
+        line.dataset["indentPrefix"] = "  ";
+        line.style.setProperty("--hmd-indent-padding-measured", "24px");
+        line.style.setProperty("--hmd-indent-prefix-measured", "8px");
+        syncMeasuredIndentStyles(root, new Map());
+        expect(line.style.getPropertyValue("--hmd-indent-padding-measured")).toBe("24px");
+        expect(line.style.getPropertyValue("--hmd-indent-prefix-measured")).toBe("8px");
+    });
+    it("keeps the last measured padding when the parent temporarily falls back", () => {
+        const root = document.createElement("div");
+        const line = appendLine(root, 10);
+        line.style.setProperty("--hmd-indent-padding-measured", "24px");
+        syncMeasuredIndentStyles(root, new Map([[10, { paddingPx: null, prefixPx: 32 }]]));
+        expect(line.style.getPropertyValue("--hmd-indent-padding-measured")).toBe("24px");
+        expect(line.style.getPropertyValue("--hmd-indent-prefix-measured")).toBe("32px");
+    });
+});

package/dist/internal/codemirror/rich/utils/ranges.d.ts

@@ -0,0 +1,13 @@
+import type { EditorState, Range } from "@codemirror/state";
+import type { Decoration } from "@codemirror/view";
+export type RangeBoundary = {
+    from: number;
+    to: number;
+};
+export declare function rangeIntersectsSelection(state: EditorState, from: number, to: number): boolean;
+export declare function rangeContainsSelectionCursor(state: EditorState, from: number, to: number): boolean;
+export declare function hasInitialFrontmatterCursor(state: EditorState, from: number): boolean;
+export declare function hasRenderedInitialFrontmatterCursor(state: EditorState): boolean;
+export declare function rangesOverlap(left: RangeBoundary, right: RangeBoundary): boolean;
+export declare function sortRanges(ranges: Range<Decoration>[]): Range<Decoration>[];
+//# sourceMappingURL=ranges.d.ts.map

package/dist/internal/codemirror/rich/utils/ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ranges.d.ts","sourceRoot":"","sources":["../../../../../src/internal/codemirror/rich/utils/ranges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,OAAO,CAIT;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,OAAO,CAOT;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,GACX,OAAO,CAOT;AAED,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,WAAW,GACjB,OAAO,CAgBT;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,aAAa,GACnB,OAAO,CAET;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC,EAAE,CAO3E"}

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

@@ -0,0 +1,42 @@
+export function rangeIntersectsSelection(state, from, to) {
+    return state.selection.ranges.some((selection) => selection.from <= to && selection.to >= from);
+}
+export function rangeContainsSelectionCursor(state, from, to) {
+    return state.selection.ranges.some((selection) => {
+        if (selection.empty) {
+            return selection.from > from && selection.from < to;
+        }
+        return selection.from < to && selection.to > from;
+    });
+}
+export function hasInitialFrontmatterCursor(state, from) {
+    return (from === 0 &&
+        state.selection.ranges.length === 1 &&
+        state.selection.main.empty &&
+        state.selection.main.from === 0);
+}
+export function hasRenderedInitialFrontmatterCursor(state) {
+    if (!hasInitialFrontmatterCursor(state, 0) || state.doc.lines < 3) {
+        return false;
+    }
+    if (state.doc.line(1).text !== "---") {
+        return false;
+    }
+    for (let lineNumber = 2; lineNumber <= state.doc.lines; lineNumber += 1) {
+        if (state.doc.line(lineNumber).text === "---") {
+            return true;
+        }
+    }
+    return false;
+}
+export function rangesOverlap(left, right) {
+    return left.from < right.to && right.from < left.to;
+}
+export function sortRanges(ranges) {
+    return ranges.sort((left, right) => {
+        if (left.from !== right.from) {
+            return left.from - right.from;
+        }
+        return left.to - right.to;
+    });
+}

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

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

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

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

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

@@ -0,0 +1,22 @@
+import { EditorState } from "@codemirror/state";
+import { describe, expect, it } from "vitest";
+import { hasRenderedInitialFrontmatterCursor } from "./ranges";
+describe("range utilities", () => {
+    it("detects the hidden live-preview cursor state at rendered frontmatter start", () => {
+        const state = EditorState.create({
+            doc: "---\ntitle: Demo\n---\n# Heading",
+            selection: { anchor: 0 },
+        });
+        expect(hasRenderedInitialFrontmatterCursor(state)).toBe(true);
+    });
+    it("does not hide the cursor for normal document starts or frontmatter source edits", () => {
+        expect(hasRenderedInitialFrontmatterCursor(EditorState.create({
+            doc: "# Heading",
+            selection: { anchor: 0 },
+        }))).toBe(false);
+        expect(hasRenderedInitialFrontmatterCursor(EditorState.create({
+            doc: "---\ntitle: Demo\n---\n# Heading",
+            selection: { anchor: 5 },
+        }))).toBe(false);
+    });
+});

package/dist/internal/codemirror/rich/utils/tasks.d.ts

@@ -0,0 +1,11 @@
+import type { EditorState } from "@codemirror/state";
+export type TaskMarkerRange = {
+    markerStart: number;
+    checkboxStart: number;
+    checkboxEnd: number;
+    markerEnd: number;
+    taskValue: string;
+};
+export declare function getTaskMarkerRange(text: string, lineStart: number): TaskMarkerRange | null;
+export declare function selectionTouchesTaskMarker(state: EditorState, lineStart: number, markerEnd: number): boolean;
+//# sourceMappingURL=tasks.d.ts.map

package/dist/internal/codemirror/rich/utils/tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../../../../src/internal/codemirror/rich/utils/tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,eAAe,GAAG,IAAI,CAiBxB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAQT"}

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

@@ -0,0 +1,23 @@
+export function getTaskMarkerRange(text, lineStart) {
+    const match = text.match(/^([ \t]*(?:>[ \t]*)*)((?:[-*+]|\d+[.)])[ \t]+)\[([^\]\r\n])\][ \t]/u);
+    if (!match || match[1] === undefined || match[2] === undefined) {
+        return null;
+    }
+    const markerStart = lineStart + match[1].length;
+    const checkboxStart = markerStart + match[2].length;
+    return {
+        markerStart,
+        checkboxStart,
+        checkboxEnd: checkboxStart + 3,
+        markerEnd: lineStart + match[0].length,
+        taskValue: match[3] ?? " ",
+    };
+}
+export function selectionTouchesTaskMarker(state, lineStart, markerEnd) {
+    return state.selection.ranges.some((selection) => {
+        if (selection.empty) {
+            return selection.from >= lineStart && selection.from <= markerEnd;
+        }
+        return selection.from <= markerEnd && selection.to >= lineStart;
+    });
+}

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

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

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

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