phormat 0.0.5

package/dist/editor/model/nestedContainerTransactions.js

@@ -0,0 +1,336 @@
+import { serializeListRegion } from '../block-specs/list/serialize';
+import { serializeEditorBlock, serializeTopLevelBlockSpan } from './serializeMarkdownDocument';
+import { cloneInlineNodeDeep, inlineTextNode, wrapInlineSelection } from './inlineEditCommands';
+import { inlineNodesToPlainText } from './inlinePlain';
+import { deepCloneBlocks, findBlockLocation, listRegionBounds, sourceRangeForBlockSpan } from './blockTree';
+import { normalizeBlockSliceReplacement } from './blockEditCommands';
+import { blockTreeDropTransaction } from './blockTreeDrop';
+import { findListItemPath, listDeleteItem, listDuplicateItem, listMoveSibling, resolveListItem, siblingFocusIdForListDelete } from './listEditCommands';
+import { calloutDeleteChild, calloutDuplicateChild, calloutExitReplacementMarkdown, calloutMoveSibling, siblingFocusIdForCalloutDelete } from './calloutEditCommands';
+import { findQuoteBlockPath, quoteDeleteBlock, quoteDuplicateBlock, quoteMoveSibling } from './quoteEditCommands';
+export { applyBlockTreeDrop, blockTreeDropTransaction, canBlockTreeDrop } from './blockTreeDrop';
+export { isDescendantBlock, nestUnderPreviousSibling, nestUnderTarget, promoteOneLevel, removeBlockFromTree } from './blockTreeMutations';
+function sliceReplaceTransaction(source, range, nextMarkdown, caret, txId) {
+    const text = normalizeBlockSliceReplacement(source, range.start, range.end, nextMarkdown);
+    return {
+        ok: true,
+        transaction: {
+            id: txId,
+            operations: [{ type: 'replaceSlice', range, text }],
+            selection: { anchor: caret, focus: caret }
+        }
+    };
+}
+function topLevelStructSpanForBlock(blocks, blockId) {
+    const loc = findBlockLocation(blocks, blockId);
+    if (!loc)
+        return null;
+    if (blocks[loc.topLevelIndex]?.type === 'listItem') {
+        return listRegionBounds(blocks, loc.topLevelIndex);
+    }
+    return { start: loc.topLevelIndex, end: loc.topLevelIndex + 1 };
+}
+export function listRegionStructMutation(source, doc, itemId, mutate, txId, caretBlockId) {
+    const bounds = topLevelStructSpanForBlock(doc.blocks, itemId);
+    if (!bounds)
+        return { ok: false, error: 'Block not found.' };
+    const clone = deepCloneBlocks(doc.blocks);
+    const nextBlocks = mutate(clone);
+    if (!nextBlocks)
+        return { ok: false, error: 'List edit failed.' };
+    const range = sourceRangeForBlockSpan(doc.blocks, bounds.start, bounds.end, source);
+    if (!range)
+        return { ok: false, error: 'List region has no source range.' };
+    const topLevelDelta = nextBlocks.length - doc.blocks.length;
+    const nextEnd = Math.max(bounds.start, Math.min(nextBlocks.length, bounds.end + topLevelDelta));
+    const md = serializeTopLevelBlockSpan(nextBlocks, bounds.start, nextEnd, source);
+    let caret = range.start;
+    if (caretBlockId) {
+        const loc = findBlockLocation(nextBlocks, caretBlockId);
+        if (loc?.block.sourceRange.start !== undefined && loc.block.sourceRange.start >= 0) {
+            caret = loc.block.sourceRange.start;
+        }
+    }
+    return sliceReplaceTransaction(source, range, md, caret, txId);
+}
+function blockquoteMutationTransaction(source, doc, blockIndex, mutate, txId, caretBlockId) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'blockquote')
+        return { ok: false, error: 'Expected blockquote block.' };
+    const nextRoot = mutate(deepCloneBlocks([block])[0]);
+    if (!nextRoot)
+        return { ok: false, error: 'Blockquote edit failed.' };
+    const md = serializeEditorBlock(nextRoot, source);
+    let caret = block.sourceRange.start;
+    if (caretBlockId) {
+        const loc = findBlockLocation([nextRoot], caretBlockId);
+        if (loc?.block.sourceRange.start !== undefined && loc.block.sourceRange.start >= 0) {
+            caret = loc.block.sourceRange.start;
+        }
+    }
+    if (block.sourceRange.start < 0)
+        return { ok: false, error: 'Cannot edit synthetic block.' };
+    return sliceReplaceTransaction(source, { start: block.sourceRange.start, end: block.sourceRange.end }, md, caret, txId);
+}
+export function moveListItemSiblingTransaction(source, doc, _itemIndex, itemId, direction) {
+    return listRegionStructMutation(source, doc, itemId, (blocks) => listMoveSibling(blocks, itemId, direction), `list-item-move-${direction}:${itemId}`, itemId);
+}
+export function listItemTreeDropTransaction(source, doc, _blockIndex, draggedId, targetId, placement) {
+    return blockTreeDropTransaction(source, doc, draggedId, targetId, placement);
+}
+export function deleteListItemTransaction(source, doc, _blockIndex, itemId, focusAfterId) {
+    return listRegionStructMutation(source, doc, itemId, (blocks) => listDeleteItem(blocks, itemId), `list-item-delete:${itemId}`, focusAfterId);
+}
+export function duplicateListItemTransaction(source, doc, _blockIndex, itemId) {
+    let duplicateId;
+    return listRegionStructMutation(source, doc, itemId, (blocks) => {
+        const before = findListItemPath(blocks, itemId);
+        const next = listDuplicateItem(blocks, itemId);
+        if (!next || !before)
+            return null;
+        const nav = resolveListItem(next, before);
+        duplicateId = nav?.siblings[nav.itemIndex + 1]?.id;
+        return next;
+    }, `list-item-duplicate:${itemId}`, duplicateId);
+}
+export { siblingFocusIdForListDelete };
+export function moveQuoteBlockSiblingTransaction(source, doc, blockIndex, quoteBlockId, direction) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'blockquote')
+        return { ok: false, error: 'Expected blockquote.' };
+    const path = findQuoteBlockPath(block, quoteBlockId);
+    if (!path)
+        return { ok: false, error: 'Blockquote node not found.' };
+    return blockquoteMutationTransaction(source, doc, blockIndex, (root) => quoteMoveSibling(root, path, direction), `quote-move-${direction}:${quoteBlockId}`, quoteBlockId);
+}
+export function deleteQuoteBlockTransaction(source, doc, blockIndex, quoteBlockId, focusAfterId) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'blockquote')
+        return { ok: false, error: 'Expected blockquote.' };
+    const path = findQuoteBlockPath(block, quoteBlockId);
+    if (!path)
+        return { ok: false, error: 'Blockquote node not found.' };
+    return blockquoteMutationTransaction(source, doc, blockIndex, (root) => quoteDeleteBlock(root, path), `quote-delete:${quoteBlockId}`, focusAfterId);
+}
+export function duplicateQuoteBlockTransaction(source, doc, blockIndex, quoteBlockId) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'blockquote')
+        return { ok: false, error: 'Expected blockquote.' };
+    const path = findQuoteBlockPath(block, quoteBlockId);
+    if (!path)
+        return { ok: false, error: 'Blockquote node not found.' };
+    let duplicateId;
+    return blockquoteMutationTransaction(source, doc, blockIndex, (root) => {
+        const next = quoteDuplicateBlock(root, path);
+        if (!next)
+            return null;
+        const p = findQuoteBlockPath(next, quoteBlockId);
+        if (p) {
+            let parent = next;
+            for (let i = 0; i < p.length - 1; i++)
+                parent = parent.children[p[i]];
+            duplicateId = parent.children?.[p[p.length - 1] + 1]?.id;
+        }
+        return next;
+    }, `quote-duplicate:${quoteBlockId}`, duplicateId);
+}
+export function applyListItemInlineWrapTransaction(source, doc, _blockIndex, itemId, plainStart, plainEnd, kind, linkHref) {
+    const path = findListItemPath(doc.blocks, itemId);
+    if (!path)
+        return { ok: false, error: 'List item not found.' };
+    const a = Math.min(plainStart, plainEnd);
+    const b = Math.max(plainStart, plainEnd);
+    return listRegionStructMutation(source, doc, itemId, (blocks) => {
+        const nav = resolveListItem(blocks, path);
+        if (!nav)
+            return null;
+        const bodyPlain = nav.item.inlines?.length ? inlineNodesToPlainText(nav.item.inlines) : '';
+        const baseNodes = nav.item.inlines?.length
+            ? nav.item.inlines.map(cloneInlineNodeDeep)
+            : bodyPlain.length > 0
+                ? [inlineTextNode(bodyPlain)]
+                : [];
+        const wrapped = wrapInlineSelection(baseNodes, a, b, kind, linkHref);
+        if (!wrapped)
+            return null;
+        nav.item.inlines = wrapped;
+        return blocks;
+    }, `list-item-inline:${itemId}:${kind}`, itemId);
+}
+export function applyQuoteBlockInlineWrapTransaction(source, doc, blockIndex, quoteBlockId, plainStart, plainEnd, kind, linkHref) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'blockquote')
+        return { ok: false, error: 'Expected blockquote.' };
+    const path = findQuoteBlockPath(block, quoteBlockId);
+    if (!path)
+        return { ok: false, error: 'Blockquote node not found.' };
+    const a = Math.min(plainStart, plainEnd);
+    const b = Math.max(plainStart, plainEnd);
+    return blockquoteMutationTransaction(source, doc, blockIndex, (root) => {
+        let node = root;
+        if (path.length === 0) {
+            node = root;
+        }
+        else {
+            for (const i of path)
+                node = node.children[i];
+        }
+        if (node.type !== 'blockquote')
+            return null;
+        const bodyPlain = node.inlines?.length ? inlineNodesToPlainText(node.inlines) : '';
+        const baseNodes = node.inlines?.length
+            ? node.inlines.map(cloneInlineNodeDeep)
+            : bodyPlain.length > 0
+                ? [inlineTextNode(bodyPlain)]
+                : [];
+        const wrapped = wrapInlineSelection(baseNodes, a, b, kind, linkHref);
+        if (!wrapped)
+            return null;
+        node.inlines = wrapped;
+        return root;
+    }, `quote-inline:${quoteBlockId}:${kind}`, quoteBlockId);
+}
+export function quoteStructMutationTransaction(source, doc, blockIndex, quoteBlockId, mutate, txId, caretBlockId) {
+    return blockquoteMutationTransaction(source, doc, blockIndex, mutate, txId, caretBlockId);
+}
+export const moveQuoteParagraphSiblingTransaction = moveQuoteBlockSiblingTransaction;
+export const deleteQuoteParagraphTransaction = deleteQuoteBlockTransaction;
+export const duplicateQuoteParagraphTransaction = duplicateQuoteBlockTransaction;
+export const applyQuoteParagraphInlineWrapTransaction = applyQuoteBlockInlineWrapTransaction;
+export function siblingFocusIdForQuoteDelete(block, quoteBlockId) {
+    if (block.type !== 'blockquote')
+        return undefined;
+    const path = findQuoteBlockPath(block, quoteBlockId);
+    if (!path)
+        return undefined;
+    let parent = block;
+    for (let i = 0; i < path.length - 1; i++)
+        parent = parent.children[path[i]];
+    const idx = path[path.length - 1];
+    const chs = parent.children ?? [];
+    if (idx > 0)
+        return chs[idx - 1]?.id;
+    if (idx + 1 < chs.length)
+        return chs[idx + 1]?.id;
+    return undefined;
+}
+export function quoteParagraphReorderTransaction(source, doc, blockIndex, quotePath, fromIndex, toIndex, paragraphId) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'blockquote')
+        return { ok: false, error: 'Expected blockquote.' };
+    return blockquoteMutationTransaction(source, doc, blockIndex, (root) => quoteMoveSibling(root, quotePath, fromIndex < toIndex ? 'down' : 'up'), `quote-reorder:${paragraphId}`, paragraphId);
+}
+function calloutMutationTransaction(source, doc, blockIndex, mutate, txId, caretBlockId) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'callout')
+        return { ok: false, error: 'Expected callout block.' };
+    if (block.sourceRange.start < 0)
+        return { ok: false, error: 'Cannot edit synthetic callout.' };
+    const nextRoot = mutate(deepCloneBlocks([block])[0]);
+    if (!nextRoot)
+        return { ok: false, error: 'Callout edit failed.' };
+    const md = serializeEditorBlock(nextRoot, source);
+    let caret = block.sourceRange.start;
+    if (caretBlockId) {
+        const loc = findBlockLocation([nextRoot], caretBlockId);
+        if (loc?.block.sourceRange.start !== undefined && loc.block.sourceRange.start >= 0) {
+            caret = loc.block.sourceRange.start;
+        }
+    }
+    return sliceReplaceTransaction(source, { start: block.sourceRange.start, end: block.sourceRange.end }, md, caret, txId);
+}
+function calloutBlocksStructMutation(source, doc, calloutBlockIndex, draggedId, mutate, txId, caretBlockId) {
+    const oldCallout = doc.blocks[calloutBlockIndex];
+    if (!oldCallout || oldCallout.type !== 'callout')
+        return { ok: false, error: 'Expected callout.' };
+    if (oldCallout.sourceRange.start < 0)
+        return { ok: false, error: 'Cannot edit synthetic callout.' };
+    const clone = deepCloneBlocks(doc.blocks);
+    const nextBlocks = mutate(clone);
+    if (!nextBlocks)
+        return { ok: false, error: 'Callout edit failed.' };
+    let idx = calloutBlockIndex;
+    const newCallout = nextBlocks[idx];
+    if (!newCallout || newCallout.type !== 'callout') {
+        idx = nextBlocks.findIndex((b) => b.id === oldCallout.id);
+        if (idx < 0 || nextBlocks[idx]?.type !== 'callout') {
+            return { ok: false, error: 'Callout block lost after edit.' };
+        }
+    }
+    const liveCallout = nextBlocks[idx];
+    let spanStart = oldCallout.sourceRange.start;
+    let spanEnd = oldCallout.sourceRange.end;
+    if (nextBlocks.length !== doc.blocks.length && draggedId) {
+        const draggedOld = findBlockLocation(doc.blocks, draggedId);
+        if (draggedOld?.parent === null && draggedOld.topLevelIndex !== calloutBlockIndex) {
+            spanStart = Math.min(spanStart, draggedOld.block.sourceRange.start);
+        }
+    }
+    const parts = [serializeEditorBlock(liveCallout, source)];
+    let i = idx + 1;
+    while (i < nextBlocks.length) {
+        const b = nextBlocks[i];
+        const oldLoc = findBlockLocation(doc.blocks, b.id);
+        if (oldLoc?.topLevelIndex === calloutBlockIndex && oldLoc.parent?.id === oldCallout.id) {
+            parts.push(serializeEditorBlock(b, source));
+            const oldEnd = oldLoc.block.sourceRange.end;
+            if (oldEnd > spanEnd)
+                spanEnd = oldEnd;
+            i++;
+            continue;
+        }
+        break;
+    }
+    const md = parts.join('\n\n');
+    let caret = spanStart;
+    if (caretBlockId) {
+        const loc = findBlockLocation(nextBlocks, caretBlockId);
+        if (loc?.block.sourceRange.start !== undefined && loc.block.sourceRange.start >= 0) {
+            caret = loc.block.sourceRange.start;
+        }
+    }
+    return sliceReplaceTransaction(source, { start: spanStart, end: spanEnd }, md, caret, txId);
+}
+export function calloutStructMutationTransaction(source, doc, blockIndex, childBlockId, mutate, txId, caretBlockId) {
+    return calloutMutationTransaction(source, doc, blockIndex, mutate, txId, caretBlockId);
+}
+export function calloutExitTransaction(source, doc, blockIndex, rootAfterExit) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'callout')
+        return { ok: false, error: 'Expected callout.' };
+    const calloutMd = serializeEditorBlock(rootAfterExit, source);
+    const { replacement, caret } = calloutExitReplacementMarkdown(calloutMd, block.sourceRange.start);
+    return sliceReplaceTransaction(source, { start: block.sourceRange.start, end: block.sourceRange.end }, replacement, caret, `callout-exit:${block.id}`);
+}
+export function moveCalloutChildSiblingTransaction(source, doc, blockIndex, childId, direction) {
+    return calloutMutationTransaction(source, doc, blockIndex, (root) => calloutMoveSibling(root, childId, direction), `callout-move-${direction}:${childId}`, childId);
+}
+export function deleteCalloutChildTransaction(source, doc, blockIndex, childId, focusAfterId) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'callout')
+        return { ok: false, error: 'Expected callout.' };
+    return calloutMutationTransaction(source, doc, blockIndex, (root) => calloutDeleteChild(root, childId), `callout-delete:${childId}`, focusAfterId);
+}
+export function duplicateCalloutChildTransaction(source, doc, blockIndex, childId) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'callout')
+        return { ok: false, error: 'Expected callout.' };
+    let duplicateId;
+    return calloutMutationTransaction(source, doc, blockIndex, (root) => {
+        const clone = deepCloneBlocks([root])[0];
+        const before = findBlockLocation([clone], childId);
+        const next = calloutDuplicateChild(clone, childId);
+        if (!next || !before)
+            return null;
+        const after = findBlockLocation([next], childId);
+        duplicateId = after?.siblings[before.index + 1]?.id;
+        return next;
+    }, `callout-duplicate:${childId}`, duplicateId);
+}
+export function calloutBodyTreeDropTransaction(source, doc, _blockIndex, draggedId, targetId, placement) {
+    return blockTreeDropTransaction(source, doc, draggedId, targetId, placement);
+}
+export function calloutDocumentStructMutation(source, doc, calloutBlockIndex, anchorBlockId, mutate, txId, caretBlockId) {
+    return calloutBlocksStructMutation(source, doc, calloutBlockIndex, undefined, mutate, txId, caretBlockId ?? anchorBlockId);
+}
+export { siblingFocusIdForCalloutDelete };

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

@@ -0,0 +1,2 @@
+import type { EditorDocument } from './types';
+export declare function parseMarkdownDocument(source: string, fileName?: string | null): EditorDocument;

package/dist/editor/model/parseMarkdownDocument.js

@@ -0,0 +1,324 @@
+import { buildBlockquoteAtDepth, parseBlockquoteLine, parseBlockquoteLineInfo } from '../block-specs/blockquote/parse';
+import { buildListItemForest, parseListLine } from '../block-specs/list/parse';
+import { paragraphBlocksFromLines } from '../block-specs/paragraph/parse';
+import { tryParseCalloutAt } from '../block-specs/callout/parse';
+import { isHorizontalRuleLine } from '../block-specs/horizontalRule/parse';
+import { couldStartTableAt, tryParseTableAt } from '../block-specs/table/parse';
+import { tryParseToggleAt } from '../block-specs/toggle/parse';
+import { COLUMN_LINE_SCANNER, tryParseColumnsAt } from '../block-specs/columns/parse';
+import { ATX_HEADING, stripClosingHashes } from '../block-specs/heading/parse';
+import { tryParseTocAt, TOC_LINE } from '../block-specs/toc/parse';
+import { collectExtensionSyntaxWarnings } from './extensionSyntaxWarnings';
+import { collectToggleStructureWarnings, explainTableParseFailure } from './structureParseWarnings';
+import { afterLineTerminator, splitLinesWithOffsets } from './line-utils';
+import { stableBlockId } from './types';
+/** Opening fence: optional indent, run of 3+ backticks, optional info (e.g. language). */
+const FENCE_OPEN = /^(\s*)(`{3,})(.*)$/;
+/** Callout opener `> [!type] Title` — must run before generic blockquotes. */
+const CALLOUT_OPENER = /^\s*>\s*\[!([^\]]+)\]\s*(.*)$/;
+const TOGGLE_OPEN = /^\s*\+\+\+\s+(.+)$/;
+function parseLanguage(infoLine) {
+    const trimmed = infoLine.trim();
+    if (trimmed === '')
+        return null;
+    return trimmed.split(/\s+/)[0] ?? null;
+}
+/** Lines that look like an opening fence but never close before EOF. */
+function collectUnclosedFenceWarnings(rows) {
+    const warns = [];
+    let i = 0;
+    while (i < rows.length) {
+        const open = rows[i].line.match(FENCE_OPEN);
+        if (!open) {
+            i++;
+            continue;
+        }
+        const fenceLen = open[2].length;
+        let j = i + 1;
+        while (j < rows.length) {
+            const close = rows[j].line.match(/^(\s*)(`{3,})\s*$/);
+            if (close && close[2].length >= fenceLen)
+                break;
+            j++;
+        }
+        if (j >= rows.length) {
+            warns.push(`Unclosed code fence starting at line ${i + 1}.`);
+            i++;
+        }
+        else {
+            i = j + 1;
+        }
+    }
+    return warns;
+}
+function collectFencedBlocks(source, rows) {
+    const out = [];
+    let i = 0;
+    while (i < rows.length) {
+        const open = rows[i].line.match(FENCE_OPEN);
+        if (!open) {
+            i++;
+            continue;
+        }
+        const fenceLen = open[2].length;
+        const lang = parseLanguage(open[3]);
+        const bodyLines = [];
+        let j = i + 1;
+        while (j < rows.length) {
+            const close = rows[j].line.match(/^(\s*)(`{3,})\s*$/);
+            if (close && close[2].length >= fenceLen)
+                break;
+            bodyLines.push(rows[j].line);
+            j++;
+        }
+        if (j >= rows.length) {
+            i++;
+            continue;
+        }
+        out.push({
+            openLine: i,
+            closeLine: j,
+            language: lang,
+            code: bodyLines.join('\n'),
+            startOffset: rows[i].start,
+            endOffset: afterLineTerminator(source, rows[j])
+        });
+        i = j + 1;
+    }
+    return out;
+}
+/* --------------------------------- main pass -------------------------------- */
+export function parseMarkdownDocument(source, fileName = null) {
+    const rows = splitLinesWithOffsets(source);
+    const fenceWarnings = collectUnclosedFenceWarnings(rows);
+    const fences = collectFencedBlocks(source, rows);
+    const fenceAtOpenLine = new Map();
+    for (const f of fences)
+        fenceAtOpenLine.set(f.openLine, f);
+    const blocks = [];
+    const structureWarnings = [];
+    let i = 0;
+    while (i < rows.length) {
+        const fence = fenceAtOpenLine.get(i);
+        if (fence) {
+            const sourceRange = {
+                start: fence.startOffset,
+                end: fence.endOffset,
+                startLine: fence.openLine,
+                endLine: fence.closeLine
+            };
+            const data = {
+                kind: 'fenced',
+                language: fence.language,
+                code: fence.code,
+                startLine: fence.openLine
+            };
+            blocks.push({
+                type: 'codeFence',
+                id: stableBlockId('codeFence', sourceRange),
+                sourceRange,
+                data
+            });
+            i = fence.closeLine + 1;
+            continue;
+        }
+        const row = rows[i];
+        if (row.line.trim() === '' && row.line !== ' ') {
+            i++;
+            continue;
+        }
+        if (TOC_LINE.test(row.line)) {
+            const tocHit = tryParseTocAt(i, rows, source);
+            if (tocHit) {
+                blocks.push(tocHit.block);
+                i = tocHit.nextLine;
+                continue;
+            }
+        }
+        const hm = row.line.match(ATX_HEADING);
+        if (hm) {
+            const level = hm[2].length;
+            const text = stripClosingHashes(hm[4]).trim();
+            const sourceRange = {
+                start: row.start,
+                end: afterLineTerminator(source, row),
+                startLine: i,
+                endLine: i
+            };
+            const data = { level, text, lineIndex: i };
+            blocks.push({
+                type: 'heading',
+                id: stableBlockId('heading', sourceRange),
+                sourceRange,
+                data
+            });
+            i++;
+            continue;
+        }
+        if (isHorizontalRuleLine(row.line)) {
+            const sourceRange = {
+                start: row.start,
+                end: afterLineTerminator(source, row),
+                startLine: i,
+                endLine: i
+            };
+            const data = { lineIndex: i };
+            blocks.push({
+                type: 'horizontalRule',
+                id: stableBlockId('horizontalRule', sourceRange),
+                sourceRange,
+                data
+            });
+            i++;
+            continue;
+        }
+        const tableHit = tryParseTableAt(i, rows, source, fenceAtOpenLine);
+        if (tableHit) {
+            blocks.push(tableHit.block);
+            i = tableHit.nextLine;
+            continue;
+        }
+        const tableExplain = explainTableParseFailure(i, rows, fenceAtOpenLine);
+        if (tableExplain)
+            structureWarnings.push(tableExplain);
+        const calloutHit = tryParseCalloutAt(i, rows, source, fenceAtOpenLine);
+        if (calloutHit) {
+            blocks.push(calloutHit.block);
+            i = calloutHit.nextLine;
+            continue;
+        }
+        const toggleHit = tryParseToggleAt(i, rows, source, fenceAtOpenLine);
+        if (toggleHit) {
+            blocks.push(toggleHit.block);
+            i = toggleHit.nextLine;
+            continue;
+        }
+        const colHit = tryParseColumnsAt(i, rows, source, fenceAtOpenLine);
+        if (colHit) {
+            blocks.push(colHit.block);
+            i = colHit.nextLine;
+            continue;
+        }
+        if (parseBlockquoteLine(row.line)) {
+            const startLine = i;
+            const lineInfos = [];
+            while (i < rows.length) {
+                const info = parseBlockquoteLineInfo(rows[i], i, source);
+                if (!info)
+                    break;
+                lineInfos.push(info);
+                i++;
+            }
+            if (lineInfos.length === 0)
+                continue;
+            const tree = buildBlockquoteAtDepth(lineInfos, 1, source);
+            const endLine = i - 1;
+            tree.sourceRange = {
+                start: rows[startLine].start,
+                end: afterLineTerminator(source, rows[endLine]),
+                startLine,
+                endLine
+            };
+            tree.id = stableBlockId('blockquote', tree.sourceRange);
+            blocks.push(tree);
+            continue;
+        }
+        const listHead = parseListLine(rows[i].line, i);
+        if (listHead) {
+            const startLine = i;
+            const chunk = [listHead];
+            i++;
+            while (i < rows.length) {
+                const raw = rows[i].line;
+                if (raw.trim() === '')
+                    break;
+                const next = parseListLine(raw, i);
+                if (!next)
+                    break;
+                chunk.push(next);
+                i++;
+            }
+            const endLine = i - 1;
+            const items = buildListItemForest(chunk, source, rows);
+            if (items.length === 0)
+                continue;
+            const fullStart = rows[startLine].start;
+            const fullEnd = afterLineTerminator(source, rows[endLine]);
+            items[0].sourceRange = {
+                ...items[0].sourceRange,
+                start: fullStart,
+                startLine
+            };
+            items[items.length - 1].sourceRange = {
+                ...items[items.length - 1].sourceRange,
+                end: fullEnd,
+                endLine
+            };
+            for (const item of items) {
+                item.id = stableBlockId('listItem', item.sourceRange);
+                blocks.push(item);
+            }
+            continue;
+        }
+        const pStart = i;
+        const buf = [];
+        while (i < rows.length) {
+            if (fenceAtOpenLine.has(i))
+                break;
+            const r = rows[i];
+            if (r.line.trim() === '' && r.line !== ' ')
+                break;
+            if (TOC_LINE.test(r.line))
+                break;
+            if (r.line.match(ATX_HEADING))
+                break;
+            if (isHorizontalRuleLine(r.line))
+                break;
+            if (couldStartTableAt(i, rows, fenceAtOpenLine))
+                break;
+            if (CALLOUT_OPENER.test(r.line))
+                break;
+            if (TOGGLE_OPEN.test(r.line))
+                break;
+            if (COLUMN_LINE_SCANNER.test(r.line))
+                break;
+            if (parseBlockquoteLine(r.line))
+                break;
+            if (parseListLine(r.line, i))
+                break;
+            buf.push(r.line);
+            i++;
+        }
+        if (buf.length === 0)
+            continue;
+        const paras = paragraphBlocksFromLines(buf, pStart);
+        let lineOffset = 0;
+        for (const para of paras) {
+            const numLines = para.lines.length;
+            const startLine = pStart + lineOffset;
+            const endLine = pStart + lineOffset + numLines - 1;
+            const sourceRange = {
+                start: rows[startLine].start,
+                end: afterLineTerminator(source, rows[endLine]),
+                startLine,
+                endLine
+            };
+            blocks.push({
+                type: 'paragraph',
+                id: stableBlockId('paragraph', sourceRange),
+                sourceRange,
+                data: para
+            });
+            lineOffset += numLines;
+        }
+    }
+    const fencePairs = fences.map((f) => ({ openLine: f.openLine, closeLine: f.closeLine }));
+    const fenceCharRanges = fences.map((f) => ({ start: f.startOffset, end: f.endOffset }));
+    const parseWarnings = [
+        ...fenceWarnings,
+        ...structureWarnings,
+        ...collectToggleStructureWarnings(rows, fenceAtOpenLine),
+        ...collectExtensionSyntaxWarnings(source, fencePairs, fenceCharRanges)
+    ];
+    return { source, fileName, blocks, parseWarnings };
+}