phormat 0.0.5

package/dist/editor/model/inlineEditCommands.js

@@ -0,0 +1,581 @@
+import { inlineNodesToPlainText } from './inlinePlain';
+export function syntheticInlineSourceRange() {
+    return { start: -1, end: -1, startLine: -1, endLine: -1, synthetic: true };
+}
+export function inlineTextNode(text) {
+    return { type: 'text', text, sourceRange: syntheticInlineSourceRange() };
+}
+export function nodePlainLength(n) {
+    switch (n.type) {
+        case 'text':
+        case 'code':
+            return n.text.length;
+        case 'autolink':
+            return n.href.length;
+        case 'wikiLink':
+            return n.label.length;
+        case 'mention':
+            return n.kind === 'page' ? `@[${n.name}]`.length : `@${n.name}`.length;
+        default:
+            return inlineNodesToPlainText(n.children).length;
+    }
+}
+function normalizeAdjacentTextNodes(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        const last = out[out.length - 1];
+        if (n.type === 'text' && last?.type === 'text') {
+            last.text += n.text;
+            continue;
+        }
+        out.push(n);
+    }
+    return out;
+}
+function isInlineWrapMark(n) {
+    switch (n.type) {
+        case 'strong':
+        case 'emphasis':
+        case 'strikethrough':
+        case 'highlight':
+        case 'code':
+            return true;
+        default:
+            return false;
+    }
+}
+function canMergeWrapMarks(a, b) {
+    if (a.type !== b.type)
+        return false;
+    switch (a.type) {
+        case 'code':
+        case 'strong':
+        case 'emphasis':
+        case 'strikethrough':
+            return true;
+        case 'highlight':
+            if (b.type !== 'highlight')
+                return false;
+            return a.color === b.color;
+        default:
+            return false;
+    }
+}
+function mergeWrapMarkPair(a, b) {
+    const sr = syntheticInlineSourceRange();
+    if (a.type === 'code' && b.type === 'code') {
+        return { type: 'code', text: a.text + b.text, sourceRange: sr };
+    }
+    if ('children' in a && 'children' in b) {
+        return {
+            ...a,
+            children: coalesceAdjacentWrapMarks(normalizeAdjacentTextNodes([...a.children, ...b.children])),
+            sourceRange: sr
+        };
+    }
+    return a;
+}
+function coalesceChildrenInWrapMarks(nodes) {
+    return nodes.map((n) => {
+        if (n.type === 'emphasis' ||
+            n.type === 'strong' ||
+            n.type === 'strikethrough' ||
+            n.type === 'highlight' ||
+            n.type === 'link' ||
+            n.type === 'image') {
+            return {
+                ...n,
+                children: coalesceAdjacentWrapMarks(n.children)
+            };
+        }
+        return n;
+    });
+}
+/** Merge adjacent same-type wrap marks; drop empty wraps after range edits. */
+function coalesceAdjacentWrapMarks(nodes) {
+    const withMergedChildren = coalesceChildrenInWrapMarks(normalizeAdjacentTextNodes(nodes));
+    const out = [];
+    for (const n of withMergedChildren) {
+        const last = out[out.length - 1];
+        if (last && canMergeWrapMarks(last, n)) {
+            out[out.length - 1] = mergeWrapMarkPair(last, n);
+            continue;
+        }
+        out.push(n);
+    }
+    return pruneEmptyWrapMarks(out);
+}
+function pruneEmptyWrapMarks(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        let node = n;
+        if (n.type === 'emphasis' ||
+            n.type === 'strong' ||
+            n.type === 'strikethrough' ||
+            n.type === 'highlight' ||
+            n.type === 'link' ||
+            n.type === 'image') {
+            node = { ...n, children: pruneEmptyWrapMarks(n.children) };
+        }
+        if (isInlineWrapMark(node) && nodePlainLength(node) === 0)
+            continue;
+        out.push(node);
+    }
+    return out;
+}
+function nodeMatchesWrapKind(n, kind) {
+    return n.type === kind;
+}
+function inlineNodeRangeFullyCoveredByKind(n, start, end, offset, kind, inherited = false) {
+    const len = nodePlainLength(n);
+    const nodeStart = offset;
+    const nodeEnd = offset + len;
+    if (end <= nodeStart || start >= nodeEnd)
+        return true;
+    const active = inherited || nodeMatchesWrapKind(n, kind);
+    if (n.type === 'code')
+        return active;
+    if (n.type === 'emphasis' ||
+        n.type === 'strong' ||
+        n.type === 'link' ||
+        n.type === 'image' ||
+        n.type === 'strikethrough' ||
+        n.type === 'highlight') {
+        let o = nodeStart;
+        for (const ch of n.children) {
+            if (!inlineNodeRangeFullyCoveredByKind(ch, start, end, o, kind, active))
+                return false;
+            o += nodePlainLength(ch);
+        }
+        return true;
+    }
+    return active;
+}
+export function inlineRangeFullyCoveredByKind(nodes, start, end, kind) {
+    const a = Math.min(start, end);
+    const b = Math.max(start, end);
+    if (a === b)
+        return false;
+    let o = 0;
+    for (const n of nodes) {
+        if (!inlineNodeRangeFullyCoveredByKind(n, a, b, o, kind))
+            return false;
+        o += nodePlainLength(n);
+    }
+    return true;
+}
+function unwrapKindFromNodes(nodes, kind) {
+    const out = [];
+    for (const n of nodes) {
+        if (n.type === 'code') {
+            if (kind === 'code')
+                out.push(inlineTextNode(n.text));
+            else
+                out.push(cloneInlineNodeDeep(n));
+            continue;
+        }
+        if (n.type === 'emphasis' ||
+            n.type === 'strong' ||
+            n.type === 'link' ||
+            n.type === 'image' ||
+            n.type === 'strikethrough' ||
+            n.type === 'highlight') {
+            const children = unwrapKindFromNodes(n.children, kind);
+            if (nodeMatchesWrapKind(n, kind)) {
+                out.push(...children);
+            }
+            else {
+                out.push({ ...n, children, sourceRange: syntheticInlineSourceRange() });
+            }
+            continue;
+        }
+        out.push(cloneInlineNodeDeep(n));
+    }
+    return coalesceAdjacentWrapMarks(out);
+}
+export function cloneInlineNodeDeep(n) {
+    const sr = syntheticInlineSourceRange();
+    switch (n.type) {
+        case 'text':
+        case 'code':
+        case 'autolink':
+        case 'wikiLink':
+        case 'mention':
+            return { ...n, sourceRange: sr };
+        case 'link':
+        case 'image':
+            return {
+                ...n,
+                sourceRange: sr,
+                children: n.children.map(cloneInlineNodeDeep)
+            };
+        case 'emphasis':
+        case 'strong':
+        case 'strikethrough':
+        case 'highlight':
+            return {
+                ...n,
+                sourceRange: sr,
+                children: n.children.map(cloneInlineNodeDeep)
+            };
+        default:
+            return n;
+    }
+}
+function splitNodeAtPlainOffset(n, offset) {
+    if (offset <= 0)
+        return { left: [], right: [cloneInlineNodeDeep(n)] };
+    const len = nodePlainLength(n);
+    if (offset >= len)
+        return { left: [cloneInlineNodeDeep(n)], right: [] };
+    if (n.type === 'text') {
+        return {
+            left: n.text.slice(0, offset) ? [inlineTextNode(n.text.slice(0, offset))] : [],
+            right: n.text.slice(offset) ? [inlineTextNode(n.text.slice(offset))] : []
+        };
+    }
+    if (n.type === 'code') {
+        const sr = syntheticInlineSourceRange();
+        return {
+            left: n.text.slice(0, offset)
+                ? [{ type: 'code', text: n.text.slice(0, offset), sourceRange: sr }]
+                : [],
+            right: n.text.slice(offset)
+                ? [{ type: 'code', text: n.text.slice(offset), sourceRange: sr }]
+                : []
+        };
+    }
+    if (n.type === 'autolink') {
+        const href = n.href;
+        const sr = syntheticInlineSourceRange();
+        return {
+            left: href.slice(0, offset)
+                ? [{ type: 'autolink', href: href.slice(0, offset), sourceRange: sr }]
+                : [],
+            right: href.slice(offset)
+                ? [{ type: 'autolink', href: href.slice(offset), sourceRange: sr }]
+                : []
+        };
+    }
+    if (n.type === 'wikiLink') {
+        const label = n.label;
+        const sr = syntheticInlineSourceRange();
+        return {
+            left: label.slice(0, offset)
+                ? [{ type: 'wikiLink', label: label.slice(0, offset), target: n.target, sourceRange: sr }]
+                : [],
+            right: label.slice(offset)
+                ? [{ type: 'wikiLink', label: label.slice(offset), target: n.target, sourceRange: sr }]
+                : []
+        };
+    }
+    if (n.type === 'mention') {
+        const plain = n.kind === 'page' ? `@[${n.name}]` : `@${n.name}`;
+        const leftS = plain.slice(0, offset);
+        const rightS = plain.slice(offset);
+        return {
+            left: leftS ? [inlineTextNode(leftS)] : [],
+            right: rightS ? [inlineTextNode(rightS)] : []
+        };
+    }
+    if (n.type === 'emphasis' ||
+        n.type === 'strong' ||
+        n.type === 'link' ||
+        n.type === 'image' ||
+        n.type === 'strikethrough' ||
+        n.type === 'highlight') {
+        const split = splitInlineNodesAtPlainOffset(n.children, offset);
+        const wrap = (side) => {
+            if (side.length === 0)
+                return [];
+            const cloned = {
+                ...n,
+                children: side,
+                sourceRange: syntheticInlineSourceRange()
+            };
+            return [cloned];
+        };
+        return { left: wrap(split.left), right: wrap(split.right) };
+    }
+    const _never = n;
+    return _never;
+}
+/** Split `nodes` into plain-offset prefix / suffix at `offset` (0-based into concatenated plain text). */
+export function splitInlineNodesAtPlainOffset(nodes, offset) {
+    if (offset <= 0)
+        return { left: [], right: normalizeAdjacentTextNodes(nodes.map(cloneInlineNodeDeep)) };
+    let remaining = offset;
+    const left = [];
+    for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i];
+        const len = nodePlainLength(n);
+        if (remaining > len) {
+            left.push(cloneInlineNodeDeep(n));
+            remaining -= len;
+            continue;
+        }
+        if (remaining === len) {
+            left.push(cloneInlineNodeDeep(n));
+            return {
+                left: normalizeAdjacentTextNodes(left),
+                right: normalizeAdjacentTextNodes(nodes.slice(i + 1).map(cloneInlineNodeDeep))
+            };
+        }
+        const { left: ln, right: rn } = splitNodeAtPlainOffset(cloneInlineNodeDeep(n), remaining);
+        left.push(...ln);
+        return {
+            left: normalizeAdjacentTextNodes(left),
+            right: normalizeAdjacentTextNodes([...rn, ...nodes.slice(i + 1).map(cloneInlineNodeDeep)])
+        };
+    }
+    return { left: normalizeAdjacentTextNodes(left), right: [] };
+}
+function wrapMidNormalized(mid, kind, linkHref) {
+    const sr = syntheticInlineSourceRange();
+    if (kind === 'code') {
+        const t = inlineNodesToPlainText(mid);
+        return [{ type: 'code', text: t, sourceRange: sr }];
+    }
+    const children = mid.length ? mid : [inlineTextNode('')];
+    switch (kind) {
+        case 'strong':
+            return [{ type: 'strong', children, sourceRange: sr }];
+        case 'emphasis':
+            return [{ type: 'emphasis', children, sourceRange: sr }];
+        case 'strikethrough':
+            return [{ type: 'strikethrough', children, sourceRange: sr }];
+        case 'highlight':
+            return [{ type: 'highlight', color: null, children, sourceRange: sr }];
+        case 'link':
+            return [
+                {
+                    type: 'link',
+                    href: linkHref ?? '',
+                    title: null,
+                    children,
+                    sourceRange: sr
+                }
+            ];
+        default:
+            return children;
+    }
+}
+export function wrapInlineSelection(nodes, start, end, kind, linkHref) {
+    const a = Math.min(start, end);
+    const b = Math.max(start, end);
+    const s1 = splitInlineNodesAtPlainOffset(nodes, a);
+    const s2 = splitInlineNodesAtPlainOffset(s1.right, b - a);
+    const mid = s2.left;
+    const replacement = inlineRangeFullyCoveredByKind(nodes, a, b, kind)
+        ? unwrapKindFromNodes(mid, kind)
+        : wrapMidNormalized(mid, kind, linkHref);
+    return coalesceAdjacentWrapMarks([...s1.left, ...replacement, ...s2.right]);
+}
+function singleCharPlainDelta(oldPlain, newPlain) {
+    if (oldPlain === newPlain)
+        return null;
+    if (newPlain.length === oldPlain.length + 1) {
+        let i = 0;
+        const minLen = oldPlain.length;
+        while (i < minLen && oldPlain[i] === newPlain[i])
+            i++;
+        return { type: 'insert', pos: i, ch: newPlain[i] };
+    }
+    if (newPlain.length === oldPlain.length - 1) {
+        let i = 0;
+        const minLen = newPlain.length;
+        while (i < minLen && oldPlain[i] === newPlain[i])
+            i++;
+        if (oldPlain.slice(i + 1) === newPlain.slice(i))
+            return { type: 'delete', pos: i };
+    }
+    return null;
+}
+function insertCharAtPlainInNodes(nodes, pos, ch) {
+    if (pos < 0)
+        return null;
+    let o = 0;
+    for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i];
+        const len = nodePlainLength(n);
+        if (pos < o + len) {
+            const inner = pos - o;
+            const rep = insertCharIntoNode(cloneInlineNodeDeep(n), inner, ch);
+            if (!rep)
+                return null;
+            return [
+                ...nodes.slice(0, i).map(cloneInlineNodeDeep),
+                rep,
+                ...nodes.slice(i + 1).map(cloneInlineNodeDeep)
+            ];
+        }
+        if (pos === o + len) {
+            if (i + 1 < nodes.length) {
+                const rep = insertCharIntoNode(cloneInlineNodeDeep(nodes[i + 1]), 0, ch);
+                if (!rep)
+                    return null;
+                return [
+                    ...nodes.slice(0, i + 1).map(cloneInlineNodeDeep),
+                    rep,
+                    ...nodes.slice(i + 2).map(cloneInlineNodeDeep)
+                ];
+            }
+            const rep = insertCharIntoNode(cloneInlineNodeDeep(n), len, ch);
+            if (!rep)
+                return null;
+            return [
+                ...nodes.slice(0, i).map(cloneInlineNodeDeep),
+                rep,
+                ...nodes.slice(i + 1).map(cloneInlineNodeDeep)
+            ];
+        }
+        o += len;
+    }
+    if (pos === o)
+        return [...nodes.map(cloneInlineNodeDeep), inlineTextNode(ch)];
+    return null;
+}
+function insertCharIntoNode(n, offset, ch) {
+    if (n.type === 'text') {
+        const t = n.text.slice(0, offset) + ch + n.text.slice(offset);
+        return inlineTextNode(t);
+    }
+    if (n.type === 'code') {
+        const t = n.text.slice(0, offset) + ch + n.text.slice(offset);
+        return { type: 'code', text: t, sourceRange: syntheticInlineSourceRange() };
+    }
+    if ('children' in n && n.children) {
+        const inner = insertCharAtPlainInNodes(n.children, offset, ch);
+        if (!inner)
+            return null;
+        return { ...n, children: inner, sourceRange: syntheticInlineSourceRange() };
+    }
+    return null;
+}
+function deleteCharAtPlainInNodes(nodes, pos) {
+    if (pos < 0)
+        return null;
+    let o = 0;
+    for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i];
+        const len = nodePlainLength(n);
+        if (pos < o + len) {
+            const inner = pos - o;
+            const rep = deleteCharFromNode(cloneInlineNodeDeep(n), inner);
+            if (!rep)
+                return null;
+            const rest = [
+                ...nodes.slice(0, i).map(cloneInlineNodeDeep),
+                ...rep,
+                ...nodes.slice(i + 1).map(cloneInlineNodeDeep)
+            ];
+            return normalizeAdjacentTextNodes(rest);
+        }
+        o += len;
+    }
+    return null;
+}
+function deleteCharFromNode(n, offset) {
+    if (n.type === 'text') {
+        if (offset < 0 || offset >= n.text.length)
+            return null;
+        const t = n.text.slice(0, offset) + n.text.slice(offset + 1);
+        return t ? [inlineTextNode(t)] : [];
+    }
+    if (n.type === 'code') {
+        if (offset < 0 || offset >= n.text.length)
+            return null;
+        const t = n.text.slice(0, offset) + n.text.slice(offset + 1);
+        return t ? [{ type: 'code', text: t, sourceRange: syntheticInlineSourceRange() }] : [];
+    }
+    if ('children' in n && n.children) {
+        const inner = deleteCharAtPlainInNodes(n.children, offset);
+        if (!inner)
+            return null;
+        if (inner.length === 0)
+            return [];
+        return [{ ...n, children: inner, sourceRange: syntheticInlineSourceRange() }];
+    }
+    return null;
+}
+/** Returns updated nodes when `newPlain` differs by a single insert/delete; otherwise `null`. */
+export function mergePlainTypingIntoInlines(nodes, newPlain) {
+    const oldPlain = inlineNodesToPlainText(nodes);
+    const delta = singleCharPlainDelta(oldPlain, newPlain);
+    if (!delta)
+        return null;
+    if (delta.type === 'insert') {
+        return insertCharAtPlainInNodes(nodes, delta.pos, delta.ch);
+    }
+    return deleteCharAtPlainInNodes(nodes, delta.pos);
+}
+export function isInlineAtom(n) {
+    switch (n.type) {
+        case 'link':
+        case 'image':
+        case 'autolink':
+        case 'wikiLink':
+        case 'mention':
+            return true;
+        default:
+            return false;
+    }
+}
+/** Clone block `inlines` for a session draft, or seed from display plain. */
+export function draftInlinesFromBlock(inlines, displayPlain) {
+    const inlinePlain = inlines?.length ? inlineNodesToPlainText(inlines) : '';
+    if (displayPlain.length > 0) {
+        if (inlinePlain === displayPlain && inlines?.length) {
+            return inlines.map(cloneInlineNodeDeep);
+        }
+        return [inlineTextNode(displayPlain)];
+    }
+    // Empty editor buffer — ignore demotion materialization space in model inlines.
+    if (inlinePlain === ' ')
+        return [];
+    if (inlines?.length)
+        return inlines.map(cloneInlineNodeDeep);
+    return [];
+}
+/** Remove plain-text range `[start, end)` from inline AST. */
+export function deletePlainRange(nodes, start, end) {
+    const a = Math.min(start, end);
+    const b = Math.max(start, end);
+    if (a === b)
+        return nodes.map(cloneInlineNodeDeep);
+    const s1 = splitInlineNodesAtPlainOffset(nodes, a);
+    const s2 = splitInlineNodesAtPlainOffset(s1.right, b - a);
+    return coalesceAdjacentWrapMarks([...s1.left, ...s2.right]);
+}
+export function deleteCharBefore(nodes, pos) {
+    if (pos <= 0)
+        return null;
+    return deletePlainRange(nodes, pos - 1, pos);
+}
+export function deleteCharAfter(nodes, pos) {
+    const len = inlineNodesToPlainText(nodes).length;
+    if (pos >= len)
+        return null;
+    return deletePlainRange(nodes, pos, pos + 1);
+}
+/** Insert plain text at offset; optionally strip newlines (heading single-line). */
+export function insertTextAtPlainOffset(nodes, pos, text, options = {}) {
+    let insert = text;
+    if (options.stripNewlines)
+        insert = insert.replace(/\n/g, '');
+    if (!insert)
+        return nodes.map(cloneInlineNodeDeep);
+    const s = splitInlineNodesAtPlainOffset(nodes, pos);
+    return normalizeAdjacentTextNodes([...s.left, inlineTextNode(insert), ...s.right]);
+}
+/** Apply a controlled-input delta; falls back to plain flattening when merge fails. */
+export function applyControlledPlainEdit(nodes, oldPlain, newPlain) {
+    if (oldPlain === newPlain)
+        return nodes.map(cloneInlineNodeDeep);
+    const merged = mergePlainTypingIntoInlines(nodes, newPlain);
+    if (merged)
+        return merged;
+    if (newPlain.length === 0)
+        return [];
+    return [inlineTextNode(newPlain)];
+}

package/dist/editor/model/inlinePlain.d.ts

@@ -0,0 +1,3 @@
+import type { InlineNode } from './types';
+/** Plain-text rendering of inline AST (matches identity fingerprint / editor display). */
+export declare function inlineNodesToPlainText(inlines: InlineNode[] | undefined): string;

package/dist/editor/model/inlinePlain.js

@@ -0,0 +1,28 @@
+/** Plain-text rendering of inline AST (matches identity fingerprint / editor display). */
+export function inlineNodesToPlainText(inlines) {
+    if (!inlines || inlines.length === 0)
+        return '';
+    const parts = [];
+    for (const n of inlines) {
+        switch (n.type) {
+            case 'text':
+            case 'code':
+                parts.push(n.text);
+                break;
+            case 'autolink':
+                parts.push(n.href);
+                break;
+            case 'wikiLink':
+                parts.push(n.label);
+                break;
+            case 'mention':
+                parts.push(n.kind === 'page' ? `@[${n.name}]` : `@${n.name}`);
+                break;
+            default:
+                if ('children' in n && n.children)
+                    parts.push(inlineNodesToPlainText(n.children));
+                break;
+        }
+    }
+    return parts.join('');
+}

package/dist/editor/model/inlineSecondPass.d.ts

@@ -0,0 +1,4 @@
+import type { EditorDocument } from './types';
+export declare function applyInlineSecondPass(doc: EditorDocument): EditorDocument;
+/** **Scoped inline reparse** — annotate only selected top-level block indices. */
+export declare function applyInlineSecondPassToBlockIndices(doc: EditorDocument, blockIndices: readonly number[]): EditorDocument;

package/dist/editor/model/inlineSecondPass.js

@@ -0,0 +1,47 @@
+import { getBlockSpec } from '../block-specs/registry';
+import { applyBlockquoteInlineSecondPass } from '../block-specs/blockquote/inlineSecondPass';
+import { applyCalloutInlineSecondPass } from '../block-specs/callout/inlineSecondPass';
+import { applyHeadingInlineSecondPass } from '../block-specs/heading/inlineSecondPass';
+import { applyListItemInlineSecondPass } from '../block-specs/list/inlineSecondPass';
+import { applyParagraphInlineSecondPass } from '../block-specs/paragraph/inlineSecondPass';
+import { createRichInlineContext } from './richInlines';
+import { splitLinesWithOffsets } from './line-utils';
+function annotateBlock(block, source, rows, ctx, insideBlockquote) {
+    if (block.type === 'heading') {
+        return applyHeadingInlineSecondPass(block, source, rows, ctx);
+    }
+    if (block.type === 'paragraph') {
+        return applyParagraphInlineSecondPass(block, source, insideBlockquote, ctx);
+    }
+    if (block.type === 'listItem') {
+        return applyListItemInlineSecondPass(block, source, rows, ctx, insideBlockquote, annotateBlock);
+    }
+    if (block.type === 'blockquote') {
+        return applyBlockquoteInlineSecondPass(block, source, rows, ctx, annotateBlock);
+    }
+    if (block.type === 'callout') {
+        return applyCalloutInlineSecondPass(block, source, rows, ctx, annotateBlock);
+    }
+    const spec = getBlockSpec(block.type);
+    if (spec) {
+        return spec.applyInlineSecondPass(block, source, insideBlockquote, ctx);
+    }
+    console.error(`applyInlineSecondPass: missing BlockSpec for type "${block.type}"`);
+    return block;
+}
+export function applyInlineSecondPass(doc) {
+    const rows = splitLinesWithOffsets(doc.source);
+    const ctx = createRichInlineContext(doc.source);
+    const blocks = doc.blocks.map((b) => annotateBlock(b, doc.source, rows, ctx, false));
+    return { ...doc, blocks };
+}
+/** **Scoped inline reparse** — annotate only selected top-level block indices. */
+export function applyInlineSecondPassToBlockIndices(doc, blockIndices) {
+    if (blockIndices.length === 0)
+        return doc;
+    const rows = splitLinesWithOffsets(doc.source);
+    const ctx = createRichInlineContext(doc.source);
+    const indexSet = new Set(blockIndices);
+    const blocks = doc.blocks.map((b, i) => indexSet.has(i) ? annotateBlock(b, doc.source, rows, ctx, false) : b);
+    return { ...doc, blocks };
+}

package/dist/editor/model/line-utils.d.ts

@@ -0,0 +1,14 @@
+export type LineRow = {
+    line: string;
+    start: number;
+    end: number;
+};
+/** Split into lines with start/end indices in the original string (handles `\r`, `\r\n`, `\n`). */
+export declare function splitLinesWithOffsets(source: string): LineRow[];
+/** Line and character totals for editor chrome; uses the same line split as the parser. */
+export declare function sourceLineAndCharacterCount(source: string): {
+    lineCount: number;
+    characterCount: number;
+};
+/** Index just after the line's trailing `\r` / `\n` (or `source.length`). */
+export declare function afterLineTerminator(source: string, row: LineRow): number;