phormat 0.0.5

package/dist/editor/block-specs/horizontalRule/inlineSecondPass.js

@@ -0,0 +1,5 @@
+export function applyHorizontalRuleInlineSecondPass(block, _source, _insideBlockquote, _ctx) {
+    if (block.type !== 'horizontalRule')
+        return block;
+    return block;
+}

package/dist/editor/block-specs/horizontalRule/parse.d.ts

@@ -0,0 +1,2 @@
+export declare function isHorizontalRuleLine(line: string): boolean;
+export declare function parseHorizontalRules(source: string): import('./types').HorizontalRuleBlock[];

package/dist/editor/block-specs/horizontalRule/parse.js

@@ -0,0 +1,15 @@
+/** `---`, `***`, or `___` (3+ of one kind), optional leading/trailing whitespace only. */
+const HR_LINE = /^\s*(?:-{3,}|\*{3,}|_{3,})\s*$/;
+export function isHorizontalRuleLine(line) {
+    return HR_LINE.test(line);
+}
+export function parseHorizontalRules(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (HR_LINE.test(lines[i])) {
+            out.push({ lineIndex: i });
+        }
+    }
+    return out;
+}

package/dist/editor/block-specs/horizontalRule/reconcile.d.ts

@@ -0,0 +1,2 @@
+import type { EditorBlock } from '../../model/types';
+export declare function horizontalRuleReconcileFingerprint(block: EditorBlock): string;

package/dist/editor/block-specs/horizontalRule/reconcile.js

@@ -0,0 +1,5 @@
+export function horizontalRuleReconcileFingerprint(block) {
+    if (block.type !== 'horizontalRule')
+        return '';
+    return `horizontalRule:${block.sourceRange.startLine}:${block.sourceRange.endLine}`;
+}

package/dist/editor/block-specs/horizontalRule/serialize.d.ts

@@ -0,0 +1,2 @@
+import type { EditorBlock } from '../../model/types';
+export declare function serializeHorizontalRuleBlock(_block: EditorBlock): string;

package/dist/editor/block-specs/horizontalRule/serialize.js

@@ -0,0 +1,3 @@
+export function serializeHorizontalRuleBlock(_block) {
+    return '---';
+}

package/dist/editor/block-specs/horizontalRule/types.d.ts

@@ -0,0 +1,3 @@
+export type HorizontalRuleBlock = {
+    lineIndex: number;
+};

package/dist/editor/block-specs/horizontalRule/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editor/block-specs/horizontalRuleSpec.d.ts

@@ -0,0 +1,2 @@
+import type { BlockSpec } from './types';
+export declare const horizontalRuleSpec: BlockSpec;

package/dist/editor/block-specs/horizontalRuleSpec.js

@@ -0,0 +1,24 @@
+import EditableHorizontalRule from '../blocks/EditableHorizontalRule.svelte';
+import { horizontalRuleCommands } from './horizontalRule/commands';
+import { applyHorizontalRuleInlineSecondPass } from './horizontalRule/inlineSecondPass';
+import { isHorizontalRuleLine, parseHorizontalRules } from './horizontalRule/parse';
+import { horizontalRuleReconcileFingerprint } from './horizontalRule/reconcile';
+import { serializeHorizontalRuleBlock } from './horizontalRule/serialize';
+import { horizontalRuleRenderer } from './horizontalRule/HorizontalRuleRenderer.svelte';
+export const horizontalRuleSpec = {
+    type: 'horizontalRule',
+    id: 'horizontal-rule',
+    render: horizontalRuleRenderer,
+    editComponent: EditableHorizontalRule,
+    parse: { isHorizontalRuleLine, parseHorizontalRules },
+    serialize: serializeHorizontalRuleBlock,
+    applyInlineSecondPass: applyHorizontalRuleInlineSecondPass,
+    reconcileFingerprint: horizontalRuleReconcileFingerprint,
+    commands: horizontalRuleCommands,
+    toRenderBlock: (block) => ({
+        id: block.id,
+        pluginId: 'horizontal-rule',
+        data: block.data,
+        render: horizontalRuleRenderer
+    })
+};

package/dist/editor/block-specs/list/ListRenderer.svelte

@@ -0,0 +1,70 @@
+<script module lang="ts">
+	import { StatusCheckbox } from 'phoundry-ui';
+	import type { EditorBlock, ListItemBlockData } from '../../model/types';
+	import { taskCheckboxStates } from '../../taskCheckboxStates.js';
+	import { inlineNodesSnippet } from '../../plugins/shared/InlineNodes.svelte';
+
+	const listClass = {
+		ul: 'list-outside pl-5 text-base text-txt-primary marker:text-txt-tertiary',
+		ol: 'list-outside pl-5 text-base text-txt-primary marker:text-txt-tertiary'
+	} as const;
+
+	const itemRowClass = 'flex items-start gap-2 leading-relaxed';
+
+	function itemData(item: EditorBlock): ListItemBlockData {
+		return item.data as ListItemBlockData;
+	}
+
+	export { listItemRenderer };
+</script>
+
+{#snippet taskCheckbox(data: ListItemBlockData)}
+	<div class="flex h-lh shrink-0 items-center">
+		<StatusCheckbox
+			activeKey={data.task!}
+			states={taskCheckboxStates}
+			fallbackChar={data.task === 'other' ? data.taskMarkerChar : undefined}
+			ariaLabelPrefix="Task"
+			disabled
+		/>
+	</div>
+{/snippet}
+
+{#snippet listItemNode(item: EditorBlock)}
+	{@const data = itemData(item)}
+	<li>
+		<div class={itemRowClass}>
+			{#if data.task !== undefined}
+				{@render taskCheckbox(data)}
+			{/if}
+			<span class="min-w-0 flex-1 pt-0.5">
+				{#if item.inlines && item.inlines.length > 0}
+					{@render inlineNodesSnippet(item.inlines)}
+				{/if}
+			</span>
+		</div>
+		{#each item.children ?? [] as child (child.id)}
+			{#if child.type === 'listItem'}
+				<div class="pl-4">
+					<ul class={`${listClass.ul} list-disc`}>
+						{@render listItemNode(child)}
+					</ul>
+				</div>
+			{/if}
+		{/each}
+	</li>
+{/snippet}
+
+{#snippet listItemRenderer(block: EditorBlock)}
+	<div class="mb-4">
+		{#if (block.data as ListItemBlockData).ordered}
+			<ol class={`${listClass.ol} list-decimal`} start={(block.data as ListItemBlockData).ordinalValue}>
+				{@render listItemNode(block)}
+			</ol>
+		{:else}
+			<ul class={`${listClass.ul} list-disc`}>
+				{@render listItemNode(block)}
+			</ul>
+		{/if}
+	</div>
+{/snippet}

package/dist/editor/block-specs/list/ListRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { EditorBlock } from '../../model/types';
+declare const listItemRenderer: (block: EditorBlock) => ReturnType<import("svelte").Snippet>;
+export { listItemRenderer };
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const ListRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type ListRenderer = InstanceType<typeof ListRenderer>;
+export default ListRenderer;

package/dist/editor/block-specs/list/commands.d.ts

@@ -0,0 +1,2 @@
+import type { EditorCommand } from '../../commandRegistry';
+export declare const listCommands: EditorCommand[];

package/dist/editor/block-specs/list/commands.js

@@ -0,0 +1,65 @@
+const moveShortcut = { ariaKeyShortcuts: 'Alt+Shift+ArrowUp' };
+const moveDownShortcut = { ariaKeyShortcuts: 'Alt+Shift+ArrowDown' };
+function isListItemRow(ctx) {
+    return ctx.nestedRowBlockId !== undefined && ctx.nestedRowBlockType === 'listItem';
+}
+export const listCommands = [
+    {
+        id: 'duplicateListItem',
+        label: 'Duplicate',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['listItem'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isListItemRow(ctx),
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.duplicateListItemAt(ctx.blockIndex, ctx.nestedRowBlockId);
+        }
+    },
+    {
+        id: 'deleteListItem',
+        label: 'Delete',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['listItem'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isListItemRow(ctx),
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.deleteListItemAt(ctx.blockIndex, ctx.nestedRowBlockId);
+        }
+    },
+    {
+        id: 'moveListItemUp',
+        label: 'Move up',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['listItem'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isListItemRow(ctx) && ctx.canMoveUp,
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.moveListItemSiblingAt(ctx.blockIndex, ctx.nestedRowBlockId, 'up');
+        },
+        shortcut: moveShortcut
+    },
+    {
+        id: 'moveListItemDown',
+        label: 'Move down',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['listItem'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isListItemRow(ctx) && ctx.canMoveDown,
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.moveListItemSiblingAt(ctx.blockIndex, ctx.nestedRowBlockId, 'down');
+        },
+        shortcut: moveDownShortcut
+    }
+];

package/dist/editor/block-specs/list/index.d.ts

@@ -0,0 +1,6 @@
+export { listCommands } from './commands';
+export { applyListItemInlineSecondPass } from './inlineSecondPass';
+export { buildForest, buildListItemForest, buildListBlockTree, parseListLine, parseLists, taskCheckboxFromMarker } from './parse';
+export { listItemReconcileFingerprint } from './reconcile';
+export { serializeListItem, serializeListRegion } from './serialize';
+export type { ListItemNode, ListsRegion, ListTree, ParsedListLine } from './types';

package/dist/editor/block-specs/list/index.js

@@ -0,0 +1,5 @@
+export { listCommands } from './commands';
+export { applyListItemInlineSecondPass } from './inlineSecondPass';
+export { buildForest, buildListItemForest, buildListBlockTree, parseListLine, parseLists, taskCheckboxFromMarker } from './parse';
+export { listItemReconcileFingerprint } from './reconcile';
+export { serializeListItem, serializeListRegion } from './serialize';

package/dist/editor/block-specs/list/inlineSecondPass.d.ts

@@ -0,0 +1,6 @@
+import type { EditorBlock } from '../../model/types';
+import { type RichInlineContext } from '../../model/richInlines';
+import type { LineRow } from '../../model/line-utils';
+type AnnotateBlockFn = (block: EditorBlock, source: string, rows: LineRow[], ctx: RichInlineContext, insideBlockquote: boolean) => EditorBlock;
+export declare function applyListItemInlineSecondPass(block: EditorBlock, source: string, rows: LineRow[], ctx: RichInlineContext, insideBlockquote: boolean, annotateBlock: AnnotateBlockFn): EditorBlock;
+export {};

package/dist/editor/block-specs/list/inlineSecondPass.js

@@ -0,0 +1,78 @@
+import { buildRichInlinesForRange } from '../../model/richInlines';
+function offsetToLine(source, offset) {
+    let line = 0;
+    const upto = Math.min(Math.max(0, offset), source.length);
+    for (let i = 0; i < upto; i++) {
+        if (source[i] === '\n')
+            line++;
+    }
+    return line;
+}
+function listItemTextRange(row, source) {
+    const line = row.line;
+    let i = 0;
+    while (i < line.length) {
+        const ch = line[i];
+        if (ch === ' ' || ch === '\t') {
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    const rest = line.slice(i);
+    const taskUm = rest.match(/^([-*+])([ \t]+)\[[^\]]+\]([ \t]+)(.*)$/);
+    const taskOm = rest.match(/^(\d+)\.([ \t]+)\[[^\]]+\]([ \t]+)(.*)$/);
+    const tm = taskUm ?? taskOm;
+    if (tm) {
+        const payload = tm[4] ?? '';
+        const markerLen = tm[0].length - payload.length;
+        const textStart = row.start + i + markerLen;
+        const text = payload.trimEnd();
+        const textEnd = textStart + text.length;
+        return {
+            start: textStart,
+            end: textEnd,
+            startLine: offsetToLine(source, textStart),
+            endLine: offsetToLine(source, Math.max(textStart, textEnd - 1))
+        };
+    }
+    const um = rest.match(/^([-*+])([ \t]+)(.*)$/);
+    const om = rest.match(/^(\d+)\.([ \t]+)(.*)$/);
+    const m = um ?? om;
+    if (!m) {
+        return {
+            start: row.start,
+            end: row.end,
+            startLine: offsetToLine(source, row.start),
+            endLine: offsetToLine(source, row.start)
+        };
+    }
+    const payload = m[3] ?? '';
+    const markerLen = m[0].length - payload.length;
+    const textStart = row.start + i + markerLen;
+    const text = payload.trimEnd();
+    const textEnd = textStart + text.length;
+    return {
+        start: textStart,
+        end: textEnd,
+        startLine: offsetToLine(source, textStart),
+        endLine: offsetToLine(source, Math.max(textStart, textEnd - 1))
+    };
+}
+export function applyListItemInlineSecondPass(block, source, rows, ctx, insideBlockquote, annotateBlock) {
+    if (block.type !== 'listItem')
+        return block;
+    const row = rows[block.sourceRange.startLine];
+    const inlines = row
+        ? (() => {
+            const tr = listItemTextRange(row, source);
+            return buildRichInlinesForRange(source, tr.start, tr.end, ctx);
+        })()
+        : [];
+    const out = { ...block, inlines };
+    if (block.children && block.children.length > 0) {
+        out.children = block.children.map((c) => annotateBlock(c, source, rows, ctx, insideBlockquote));
+    }
+    return out;
+}

package/dist/editor/block-specs/list/parse.d.ts

@@ -0,0 +1,11 @@
+import { type LineRow } from '../../model/line-utils';
+import type { EditorBlock, TaskCheckboxState } from '../../model/types';
+import type { ListTree, ListsRegion, ParsedListLine } from './types';
+export declare function taskCheckboxFromMarker(ch: string): TaskCheckboxState;
+export declare function parseListLine(line: string, lineIndex: number): ParsedListLine | null;
+export declare function buildForest(lines: ParsedListLine[]): ListTree[];
+export declare function parseLists(source: string): ListsRegion[];
+/** Build flat `listItem` forest from a contiguous chunk of list lines (Notion-style nesting). */
+export declare function buildListItemForest(chunk: ParsedListLine[], source: string, rows: LineRow[]): EditorBlock[];
+/** @deprecated Use {@link buildListItemForest}. */
+export declare function buildListBlockTree(chunk: ParsedListLine[], source: string, rows: LineRow[]): EditorBlock[];

package/dist/editor/block-specs/list/parse.js

@@ -0,0 +1,312 @@
+import { afterLineTerminator } from '../../model/line-utils';
+import { stableBlockId } from '../../model/types';
+const UNORDERED = /^([-*+])([ \t]+)(.*)$/;
+const ORDERED = /^(\d+)\.([ \t]+)(.*)$/;
+const TASK_UNORDERED = /^([-*+])([ \t]+)\[([^\]]+)\]([ \t]+)(.*)$/;
+const TASK_ORDERED = /^(\d+)\.([ \t]+)\[([^\]]+)\]([ \t]+)(.*)$/;
+function tabAdvance(col) {
+    return col + (4 - (col % 4 || 4));
+}
+function leadingColumns(line) {
+    let col = 0;
+    let i = 0;
+    while (i < line.length) {
+        const ch = line[i];
+        if (ch === ' ') {
+            col++;
+            i++;
+        }
+        else if (ch === '\t') {
+            col = tabAdvance(col);
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    return { columns: col, start: i };
+}
+export function taskCheckboxFromMarker(ch) {
+    if (ch === ' ' || ch === undefined)
+        return 'todo';
+    const u = ch.toLowerCase();
+    if (u === 'x')
+        return 'done';
+    if (ch === '/')
+        return 'in_progress';
+    if (ch === '>')
+        return 'deferred';
+    return 'other';
+}
+export function parseListLine(line, lineIndex) {
+    const { columns: indent, start } = leadingColumns(line);
+    const rest = line.slice(start);
+    let tm = rest.match(TASK_UNORDERED);
+    if (tm) {
+        return {
+            lineIndex,
+            indent,
+            ordered: false,
+            taskMarker: tm[3],
+            text: (tm[5] ?? '').trimEnd()
+        };
+    }
+    tm = rest.match(TASK_ORDERED);
+    if (tm) {
+        const orderValue = Number.parseInt(tm[1], 10);
+        if (!Number.isFinite(orderValue))
+            return null;
+        return {
+            lineIndex,
+            indent,
+            ordered: true,
+            orderValue,
+            taskMarker: tm[3],
+            text: (tm[5] ?? '').trimEnd()
+        };
+    }
+    let m = rest.match(UNORDERED);
+    if (m) {
+        return {
+            lineIndex,
+            indent,
+            ordered: false,
+            text: m[3].trimEnd()
+        };
+    }
+    m = rest.match(ORDERED);
+    if (m) {
+        const orderValue = Number.parseInt(m[1], 10);
+        if (!Number.isFinite(orderValue))
+            return null;
+        return {
+            lineIndex,
+            indent,
+            ordered: true,
+            orderValue,
+            text: m[3].trimEnd()
+        };
+    }
+    return null;
+}
+function createList(ordered, orderValue) {
+    const start = ordered && orderValue !== undefined && orderValue !== 1 ? orderValue : undefined;
+    return { ordered, start, items: [] };
+}
+function appendItem(list, text) {
+    const node = { text, nested: [] };
+    list.items.push(node);
+    return node;
+}
+export function buildForest(lines) {
+    if (lines.length === 0)
+        return [];
+    const roots = [];
+    const stack = [];
+    const first = lines[0];
+    const rootList = createList(first.ordered, first.orderValue);
+    roots.push(rootList);
+    const firstItem = appendItem(rootList, first.text);
+    stack.push({ list: rootList, markerCol: first.indent, lastItem: firstItem });
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        while (stack.length && line.indent < stack[stack.length - 1].markerCol) {
+            stack.pop();
+        }
+        if (stack.length === 0) {
+            const list = createList(line.ordered, line.orderValue);
+            roots.push(list);
+            const item = appendItem(list, line.text);
+            stack.push({ list, markerCol: line.indent, lastItem: item });
+            continue;
+        }
+        const top = stack[stack.length - 1];
+        if (line.indent > top.markerCol) {
+            const anchor = top.lastItem ?? top.list.items[top.list.items.length - 1] ?? null;
+            if (!anchor) {
+                const item = appendItem(top.list, line.text);
+                top.lastItem = item;
+                continue;
+            }
+            const nested = createList(line.ordered, line.orderValue);
+            anchor.nested.push(nested);
+            const item = appendItem(nested, line.text);
+            stack.push({ list: nested, markerCol: line.indent, lastItem: item });
+            continue;
+        }
+        if (line.indent === top.markerCol && line.ordered === top.list.ordered) {
+            const item = appendItem(top.list, line.text);
+            top.lastItem = item;
+            continue;
+        }
+        stack.pop();
+        const parent = stack[stack.length - 1];
+        const newList = createList(line.ordered, line.orderValue);
+        if (parent?.lastItem) {
+            parent.lastItem.nested.push(newList);
+        }
+        else {
+            roots.push(newList);
+        }
+        const item = appendItem(newList, line.text);
+        stack.push({ list: newList, markerCol: line.indent, lastItem: item });
+    }
+    return roots;
+}
+function isBlank(line) {
+    return line.trim() === '';
+}
+export function parseLists(source) {
+    const lines = source.split(/\r?\n/);
+    const regions = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (isBlank(lines[i])) {
+            i++;
+            continue;
+        }
+        const parsed = parseListLine(lines[i], i);
+        if (!parsed) {
+            i++;
+            continue;
+        }
+        const chunk = [parsed];
+        let j = i + 1;
+        while (j < lines.length) {
+            const raw = lines[j];
+            if (isBlank(raw))
+                break;
+            const next = parseListLine(raw, j);
+            if (!next)
+                break;
+            chunk.push(next);
+            j++;
+        }
+        regions.push({
+            startLine: i,
+            endLine: j - 1,
+            roots: buildForest(chunk)
+        });
+        i = j;
+    }
+    return regions;
+}
+function expandItemSubtreeRanges(block) {
+    let maxEnd = block.sourceRange.end;
+    let maxLine = block.sourceRange.endLine;
+    if (block.children) {
+        for (const child of block.children) {
+            const r = expandItemSubtreeRanges(child);
+            if (r.end > maxEnd) {
+                maxEnd = r.end;
+                maxLine = r.endLine;
+            }
+        }
+    }
+    return { end: maxEnd, endLine: maxLine };
+}
+function makeListItemBlock(line, source, rows) {
+    const task = line.taskMarker !== undefined ? taskCheckboxFromMarker(line.taskMarker) : undefined;
+    const data = {
+        ordered: line.ordered,
+        ...(line.orderValue !== undefined ? { ordinalValue: line.orderValue } : {}),
+        indentColumns: line.indent,
+        ...(task !== undefined
+            ? {
+                task,
+                ...(task === 'other' && line.taskMarker !== undefined
+                    ? { taskMarkerChar: line.taskMarker }
+                    : {})
+            }
+            : {})
+    };
+    const range = rangeForRow(source, rows[line.lineIndex], line.lineIndex);
+    return {
+        type: 'listItem',
+        id: stableBlockId('listItem', range),
+        sourceRange: range,
+        data,
+        children: []
+    };
+}
+function rangeForRow(source, row, lineIndex) {
+    return {
+        start: row.start,
+        end: afterLineTerminator(source, row),
+        startLine: lineIndex,
+        endLine: lineIndex
+    };
+}
+/** Build flat `listItem` forest from a contiguous chunk of list lines (Notion-style nesting). */
+export function buildListItemForest(chunk, source, rows) {
+    if (chunk.length === 0)
+        return [];
+    const roots = [];
+    const stack = [];
+    const pushItem = (line, items) => {
+        const item = makeListItemBlock(line, source, rows);
+        items.push(item);
+        return item;
+    };
+    const first = chunk[0];
+    const firstItem = pushItem(first, roots);
+    stack.push({ items: roots, markerCol: first.indent, ordered: first.ordered, lastItem: firstItem });
+    for (let i = 1; i < chunk.length; i++) {
+        const line = chunk[i];
+        while (stack.length && line.indent < stack[stack.length - 1].markerCol) {
+            stack.pop();
+        }
+        if (stack.length === 0) {
+            const item = pushItem(line, roots);
+            stack.push({ items: roots, markerCol: line.indent, ordered: line.ordered, lastItem: item });
+            continue;
+        }
+        const top = stack[stack.length - 1];
+        if (line.indent > top.markerCol) {
+            const anchor = top.lastItem;
+            if (!anchor) {
+                const item = pushItem(line, top.items);
+                top.lastItem = item;
+                continue;
+            }
+            if (!anchor.children)
+                anchor.children = [];
+            const item = pushItem(line, anchor.children);
+            stack.push({
+                items: anchor.children,
+                markerCol: line.indent,
+                ordered: line.ordered,
+                lastItem: item
+            });
+            continue;
+        }
+        if (line.indent === top.markerCol && line.ordered === top.ordered) {
+            const item = pushItem(line, top.items);
+            top.lastItem = item;
+            continue;
+        }
+        stack.pop();
+        const parentFrame = stack[stack.length - 1];
+        let targetItems;
+        if (parentFrame?.lastItem && line.indent > parentFrame.markerCol) {
+            if (!parentFrame.lastItem.children)
+                parentFrame.lastItem.children = [];
+            targetItems = parentFrame.lastItem.children;
+        }
+        else if (parentFrame) {
+            targetItems = parentFrame.items;
+        }
+        else {
+            targetItems = roots;
+        }
+        const item = pushItem(line, targetItems);
+        stack.push({ items: targetItems, markerCol: line.indent, ordered: line.ordered, lastItem: item });
+    }
+    for (const root of roots)
+        expandItemSubtreeRanges(root);
+    return roots;
+}
+/** @deprecated Use {@link buildListItemForest}. */
+export function buildListBlockTree(chunk, source, rows) {
+    return buildListItemForest(chunk, source, rows);
+}

package/dist/editor/block-specs/list/reconcile.d.ts

@@ -0,0 +1,2 @@
+import type { EditorBlock } from '../../model/types';
+export declare function listItemReconcileFingerprint(block: EditorBlock): string;