@jianwen-lang/parser 0.1.1 → 0.1.2

package/dist/core/block-parser.js

@@ -1,91 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBlocks = parseBlocks;
-const diagnostics_1 = require("./diagnostics");
-const location_1 = require("./location");
 const rules_1 = require("./block/rules");
+const attribute_line_1 = require("./block/rules/attribute-line");
+const code_block_1 = require("./block/rules/code-block");
+const code_fence_1 = require("./block/rules/code-fence");
+const content_title_1 = require("./block/rules/content-title");
+const footnotes_1 = require("./block/rules/footnotes");
 const heading_1 = require("./block/rules/heading");
 const horizontal_rule_1 = require("./block/rules/horizontal-rule");
+const html_1 = require("./block/rules/html");
+const image_1 = require("./block/rules/image");
 const include_1 = require("./block/rules/include");
+const list_1 = require("./block/rules/list");
+const paragraph_1 = require("./block/rules/paragraph");
+const quote_1 = require("./block/rules/quote");
+const table_1 = require("./block/rules/table");
+const runtime_1 = require("./block/runtime");
 const lexer_1 = require("../lexer/lexer");
+const CONFIGURED_RULE_ORDER = [
+    'coreRuleSet',
+    'contentTitle',
+    'quote',
+    'table',
+    'image',
+    'html',
+    'list',
+];
+const PARAGRAPH_STOP_CHECKS = [
+    (_nextContent, nextTrimmed) => (0, footnotes_1.isFootnotesLine)(nextTrimmed),
+    (nextContent) => (0, include_1.matchInclude)(nextContent) !== undefined,
+    (nextContent) => (0, heading_1.matchHeading)(nextContent) !== undefined,
+    (nextContent) => (0, content_title_1.matchContentTitle)(nextContent) !== undefined,
+    (nextContent) => (0, quote_1.matchQuote)(nextContent) !== undefined,
+    (_nextContent, nextTrimmed) => (0, code_fence_1.matchCodeFenceStart)(nextTrimmed) !== undefined,
+    (_nextContent, nextTrimmed) => (0, horizontal_rule_1.matchHorizontalRule)(nextTrimmed) !== undefined,
+    (_nextContent, nextTrimmed) => (0, image_1.matchImageBlock)(nextTrimmed) !== undefined,
+    (_nextContent, nextTrimmed) => (0, html_1.matchHtmlBlock)(nextTrimmed) !== undefined,
+    (nextContent) => (0, list_1.isListItemStart)(nextContent),
+];
 function buildLineLocation(lineIndex, lineInfo) {
     return { line: lineIndex + 1, column: lineInfo.tabCount + 1 };
 }
-const MULTI_ARROW_WARNING_CODE = 'layout-multi-arrow';
-const UNKNOWN_ATTRIBUTE_WARNING_CODE = 'unknown-attribute-token';
-function buildBlockAttrs(pending, tabCount) {
-    const baseAttrs = pending.attrs ? { ...pending.attrs } : undefined;
-    const positionFromTabs = mapTabsToPosition(tabCount);
-    let blockAttrs = baseAttrs;
-    if (positionFromTabs) {
-        if (!blockAttrs) {
-            blockAttrs = {};
-        }
-        if (!blockAttrs.position) {
-            blockAttrs.position = positionFromTabs;
-        }
-    }
-    if (pending.foldNext) {
-        if (!blockAttrs) {
-            blockAttrs = {};
-        }
-        blockAttrs.fold = true;
-    }
-    return blockAttrs;
-}
-function resetPending(pending) {
-    pending.attrs = undefined;
-    pending.foldNext = false;
-    pending.tagName = undefined;
-    pending.isComment = false;
-    pending.isDisabled = false;
-    pending.isSheet = false;
-    pending.isHtml = false;
-}
-function wrapTaggedIfNeeded(block, pending, blockAttrs, lineLocation) {
-    if (!pending.tagName) {
-        return block;
-    }
-    const tagged = {
-        type: 'taggedBlock',
-        name: pending.tagName,
-        child: block,
-        blockAttrs,
-    };
-    (0, location_1.setNodeLocation)(tagged, lineLocation);
-    return tagged;
-}
-function wrapCommentIfNeeded(block, pending, lineLocation) {
-    if (!pending.isComment) {
-        return block;
-    }
-    const comment = {
-        type: 'commentBlock',
-        children: [block],
-        blockAttrs: undefined,
-    };
-    (0, location_1.setNodeLocation)(comment, lineLocation);
-    return comment;
-}
-function pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition) {
-    blocks.push(block);
-    const nextPosition = resolveNextPosition(getBlockAttributes(block), lineInfo.tabCount, lastBlockPosition);
-    resetPending(pending);
-    return nextPosition;
-}
 function parseBlocks(source, errors) {
     const blocks = [];
     const lines = source.split(/\r?\n/);
-    const pending = {
-        attrs: undefined,
-        foldNext: false,
-        tagName: undefined,
-        isComment: false,
-        isDisabled: false,
-        isSheet: false,
-        isHtml: false,
-    };
-    let lastBlockPosition = 'L';
+    const runtime = (0, runtime_1.createBlockParseRuntime)();
     let i = 0;
     while (i < lines.length) {
         const raw = lines[i];
@@ -100,1286 +60,187 @@ function parseBlocks(source, errors) {
             i += 1;
             continue;
         }
-        if (isFootnotesLine(trimmedContent)) {
-            const rawLines = [lineInfo.raw];
-            const regionLines = [];
-            let jFoot = i + 1;
-            while (jFoot < lines.length) {
-                const nextRaw = lines[jFoot];
-                if (nextRaw === undefined) {
-                    jFoot += 1;
-                    continue;
-                }
-                const nextInfo = getLineInfo(nextRaw);
-                const nextTrimmed = nextInfo.content.trim();
-                if (nextTrimmed.length === 0) {
-                    break;
-                }
-                rawLines.push(nextInfo.raw);
-                regionLines.push(nextInfo.content);
-                jFoot += 1;
-            }
-            const blockAttrs = buildBlockAttrs(pending, lineInfo.tabCount);
-            let block;
-            if (pending.isDisabled) {
-                const disabled = {
-                    type: 'disabledBlock',
-                    raw: rawLines.join('\n'),
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(disabled, lineLocation);
-                block = disabled;
-            }
-            else {
-                const children = parseFootnoteDefs(regionLines, errors);
-                const footnotesBlock = {
-                    type: 'footnotes',
-                    children,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(footnotesBlock, lineLocation);
-                block = wrapTaggedIfNeeded(footnotesBlock, pending, blockAttrs, lineLocation);
-            }
-            block = wrapCommentIfNeeded(block, pending, lineLocation);
-            lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
-            i = jFoot;
-            continue;
-        }
-        // Check for code blocks - both plain ``` and attributed [html]``` forms
-        const codeFenceStart = matchCodeFenceStart(trimmedContent);
-        const attrCodeFenceStart = codeFenceStart ? null : matchAttributedCodeFence(trimmedContent);
-        const effectiveCodeFence = codeFenceStart || attrCodeFenceStart;
-        if (effectiveCodeFence) {
-            const rawLines = [lineInfo.raw];
-            const codeLines = [];
-            // Record the indentation level of the opening ``` to strip from content lines
-            const fenceIndent = lineInfo.tabCount;
-            let jCode = i + 1;
-            let closed = false;
-            while (jCode < lines.length) {
-                const nextRaw = lines[jCode];
-                if (nextRaw === undefined) {
-                    jCode += 1;
-                    continue;
-                }
-                const nextInfo = getLineInfo(nextRaw);
-                const nextTrimmed = nextInfo.content.trim();
-                if (isCodeFenceEnd(nextTrimmed)) {
-                    rawLines.push(nextInfo.raw);
-                    closed = true;
-                    jCode += 1;
-                    break;
-                }
-                rawLines.push(nextInfo.raw);
-                // Strip leading tabs matching the fence indentation level
-                let codeLine = nextRaw;
-                for (let t = 0; t < fenceIndent && codeLine.startsWith('\t'); t++) {
-                    codeLine = codeLine.slice(1);
-                }
-                codeLines.push(codeLine);
-                jCode += 1;
-            }
-            if (!closed) {
-                (0, diagnostics_1.reportParseError)(errors, {
-                    message: 'Code block is not closed with ```',
-                    line: i + 1,
-                });
-            }
-            const blockAttrs = buildBlockAttrs(pending, lineInfo.tabCount);
-            // Determine if this is an HTML block from either pending state or inline attribute
-            const isHtmlBlock = pending.isHtml || (attrCodeFenceStart?.isHtml ?? false);
-            let block;
-            if (pending.isDisabled) {
-                const disabled = {
-                    type: 'disabledBlock',
-                    raw: rawLines.join('\n'),
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(disabled, lineLocation);
-                block = disabled;
-            }
-            else {
-                const codeBlock = {
-                    type: 'code',
-                    language: effectiveCodeFence.language,
-                    value: codeLines.join('\n'),
-                    htmlLike: isHtmlBlock ? true : undefined,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(codeBlock, lineLocation);
-                block = wrapTaggedIfNeeded(codeBlock, pending, blockAttrs, lineLocation);
-            }
-            block = wrapCommentIfNeeded(block, pending, lineLocation);
-            lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
-            i = jCode;
-            continue;
-        }
-        if (isAttributeOnlyLine(trimmedContent)) {
-            const result = parseAttributeLine(trimmedContent, i + 1, errors, pending.attrs, lastBlockPosition, lineInfo.tabCount);
-            if (result.recognizedAny) {
-                if (result.attrs) {
-                    pending.attrs = mergeBlockAttributes(pending.attrs, result.attrs);
-                }
-                if (result.foldNext) {
-                    pending.foldNext = true;
-                }
-                if (result.tagName) {
-                    pending.tagName = result.tagName;
-                }
-                if (result.isComment) {
-                    pending.isComment = true;
-                }
-                if (result.isDisabled) {
-                    pending.isDisabled = true;
-                }
-                if (result.isSheet) {
-                    pending.isSheet = true;
-                }
-                if (result.isHtml) {
-                    pending.isHtml = true;
-                }
-                i += 1;
-                continue;
-            }
-        }
         const commitBlock = (block, blockAttrs, options) => {
-            const allowTag = options?.allowTag !== false;
-            const taggedOrOriginal = allowTag
-                ? wrapTaggedIfNeeded(block, pending, blockAttrs, lineLocation)
-                : block;
-            const finalBlock = wrapCommentIfNeeded(taggedOrOriginal, pending, lineLocation);
-            lastBlockPosition = pushBlockAndResetPending(blocks, finalBlock, lineInfo, pending, lastBlockPosition);
-            options?.postResetPending?.(pending);
+            (0, runtime_1.commitParsedBlock)({
+                runtime,
+                blocks,
+                block,
+                blockAttrs,
+                lineInfo,
+                lineLocation,
+                options,
+            });
         };
-        const nextIndexFromRule = (0, rules_1.tryParseBlockRules)({
+        const nextIndexFromFootnotes = (0, footnotes_1.tryParseFootnotesBlock)({
             lines,
             index: i,
             lineInfo,
             trimmedContent,
             lineLocation,
-            pending,
+            pending: runtime.pending,
             errors,
-            buildBlockAttrs: (tabCount) => buildBlockAttrs(pending, tabCount),
+            parseBlocks,
+            buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
             commitBlock,
         });
-        if (nextIndexFromRule !== null) {
-            i = nextIndexFromRule;
+        if (nextIndexFromFootnotes !== null) {
+            i = nextIndexFromFootnotes;
             continue;
         }
-        const contentTitleMatch = matchContentTitle(lineInfo.content);
-        if (contentTitleMatch) {
-            const text = contentTitleMatch.text;
-            let consumedByImageTitle = false;
-            if (!pending.attrs &&
-                !pending.foldNext &&
-                !pending.tagName &&
-                !pending.isComment &&
-                !pending.isDisabled &&
-                !pending.isSheet &&
-                !pending.isHtml) {
-                const lastBlock = blocks[blocks.length - 1];
-                if (lastBlock && lastBlock.type === 'image') {
-                    lastBlock.title = text;
-                    consumedByImageTitle = true;
-                }
-                else if (lastBlock &&
-                    lastBlock.type === 'taggedBlock' &&
-                    lastBlock.child.type === 'image') {
-                    lastBlock.child.title = text;
-                    consumedByImageTitle = true;
-                }
-            }
-            if (consumedByImageTitle) {
-                resetPending(pending);
+        const nextIndexFromCodeBlock = (0, code_block_1.tryParseCodeBlock)({
+            lines,
+            index: i,
+            lineInfo,
+            trimmedContent,
+            lineLocation,
+            pending: runtime.pending,
+            errors,
+            buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
+            commitBlock,
+        });
+        if (nextIndexFromCodeBlock !== null) {
+            i = nextIndexFromCodeBlock;
+            continue;
+        }
+        if ((0, attribute_line_1.isAttributeOnlyLine)(trimmedContent)) {
+            const consumed = (0, attribute_line_1.tryConsumeAttributeOnlyLine)({
+                text: trimmedContent,
+                lineNumber: i + 1,
+                errors,
+                pending: runtime.pending,
+                fallbackPosition: runtime.lastBlockPosition,
+                tabCount: lineInfo.tabCount,
+            });
+            if (consumed) {
                 i += 1;
                 continue;
             }
-            const blockAttrs = buildBlockAttrs(pending, lineInfo.tabCount);
-            let block;
-            if (pending.isDisabled) {
-                const disabled = {
-                    type: 'disabledBlock',
-                    raw: lineInfo.raw,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(disabled, lineLocation);
-                block = disabled;
-            }
-            else {
-                const contentTitle = {
-                    type: 'contentTitle',
-                    children: [{ type: 'text', value: text }],
-                };
-                (0, location_1.setNodeLocation)(contentTitle, lineLocation);
-                block = wrapTaggedIfNeeded(contentTitle, pending, blockAttrs, lineLocation);
-            }
-            block = wrapCommentIfNeeded(block, pending, lineLocation);
-            lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
-            i += 1;
-            continue;
-        }
-        const quoteMatch = matchQuote(lineInfo.content);
-        if (quoteMatch) {
-            const { level } = quoteMatch;
-            const innerLines = [];
-            const rawLines = [];
-            const first = matchQuote(lineInfo.content);
-            if (first) {
-                const normalized = normalizeQuoteLine(first, level);
-                if (normalized !== undefined) {
-                    innerLines.push(normalized);
-                }
-            }
-            rawLines.push(lineInfo.raw);
-            let jQuote = i + 1;
-            while (jQuote < lines.length) {
-                const nextRaw = lines[jQuote];
-                if (nextRaw === undefined) {
-                    jQuote += 1;
-                    continue;
-                }
-                const nextInfo = getLineInfo(nextRaw);
-                const nextTrimmed = nextInfo.content.trim();
-                if (nextTrimmed.length === 0) {
-                    break;
-                }
-                const m = matchQuote(nextInfo.content);
-                if (!m) {
-                    break;
-                }
-                const normalized = normalizeQuoteLine(m, level);
-                if (normalized === undefined) {
-                    break;
-                }
-                innerLines.push(normalized);
-                rawLines.push(nextInfo.raw);
-                jQuote += 1;
-            }
-            const innerSource = innerLines.join('\n');
-            const blockAttrs = buildBlockAttrs(pending, lineInfo.tabCount);
-            let block;
-            if (pending.isDisabled) {
-                const disabled = {
-                    type: 'disabledBlock',
-                    raw: rawLines.join('\n'),
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(disabled, lineLocation);
-                block = disabled;
-            }
-            else {
-                const children = parseBlocks(innerSource, errors);
-                adjustNestedQuoteLevels(children, level);
-                const quote = {
-                    type: 'quote',
-                    level,
-                    children,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(quote, lineLocation);
-                block = wrapTaggedIfNeeded(quote, pending, blockAttrs, lineLocation);
-            }
-            block = wrapCommentIfNeeded(block, pending, lineLocation);
-            lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
-            i = jQuote;
-            continue;
         }
-        if (pending.isSheet && isTableRow(lineInfo.content)) {
-            const rawLines = [lineInfo.raw];
-            const rowContents = [
-                { text: lineInfo.content, raw: lineInfo.raw, line: i + 1 },
-            ];
-            let jTable = i + 1;
-            while (jTable < lines.length) {
-                const nextRaw = lines[jTable];
-                if (nextRaw === undefined) {
-                    jTable += 1;
-                    continue;
-                }
-                const nextInfo = getLineInfo(nextRaw);
-                const nextTrimmed = nextInfo.content.trim();
-                if (nextTrimmed.length === 0) {
+        let handledByConfiguredRule = false;
+        for (const ruleName of CONFIGURED_RULE_ORDER) {
+            let nextIndex = null;
+            switch (ruleName) {
+                case 'coreRuleSet':
+                    nextIndex = (0, rules_1.tryParseBlockRules)({
+                        lines,
+                        index: i,
+                        lineInfo,
+                        trimmedContent,
+                        lineLocation,
+                        pending: runtime.pending,
+                        errors,
+                        buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
+                        commitBlock,
+                    });
                     break;
-                }
-                if (isAttributeOnlyLine(nextTrimmed)) {
+                case 'contentTitle':
+                    nextIndex = (0, content_title_1.tryParseContentTitleBlock)({
+                        lines,
+                        index: i,
+                        lineInfo,
+                        trimmedContent,
+                        lineLocation,
+                        pending: runtime.pending,
+                        errors,
+                        blocks,
+                        resetPending: () => (0, runtime_1.resetPending)(runtime.pending),
+                        buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
+                        commitBlock,
+                    });
                     break;
-                }
-                if (!isTableRow(nextInfo.content)) {
+                case 'quote':
+                    nextIndex = (0, quote_1.tryParseQuoteBlock)({
+                        lines,
+                        index: i,
+                        lineInfo,
+                        trimmedContent,
+                        lineLocation,
+                        pending: runtime.pending,
+                        errors,
+                        parseBlocks,
+                        buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
+                        commitBlock,
+                    });
                     break;
-                }
-                rawLines.push(nextInfo.raw);
-                rowContents.push({ text: nextInfo.content, raw: nextInfo.raw, line: jTable + 1 });
-                jTable += 1;
-            }
-            const { rows, align } = parseTableRows(rowContents, errors);
-            const blockAttrs = buildBlockAttrs(pending, lineInfo.tabCount);
-            let tableAlign = align;
-            if (!tableAlign && blockAttrs?.align && blockAttrs.align !== 'left') {
-                const columnCount = getMaxTableColumnCount(rows);
-                if (columnCount > 0) {
-                    tableAlign = Array.from({ length: columnCount }, () => blockAttrs.align);
-                }
-            }
-            let block;
-            if (pending.isDisabled) {
-                const disabled = {
-                    type: 'disabledBlock',
-                    raw: rawLines.join('\n'),
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(disabled, lineLocation);
-                block = disabled;
-            }
-            else {
-                const tableBlock = {
-                    type: 'table',
-                    rows,
-                    align: tableAlign,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(tableBlock, lineLocation);
-                block = wrapTaggedIfNeeded(tableBlock, pending, blockAttrs, lineLocation);
-            }
-            block = wrapCommentIfNeeded(block, pending, lineLocation);
-            lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
-            i = jTable;
-            continue;
-        }
-        const imageMatch = matchImageBlock(trimmedContent);
-        if (imageMatch) {
-            const blockAttrs = buildBlockAttrs(pending, lineInfo.tabCount);
-            let block;
-            if (pending.isDisabled) {
-                const disabled = {
-                    type: 'disabledBlock',
-                    raw: lineInfo.raw,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(disabled, lineLocation);
-                block = disabled;
-            }
-            else {
-                const image = {
-                    type: 'image',
-                    url: imageMatch.url,
-                    shape: imageMatch.shape,
-                    roundedRadius: imageMatch.roundedRadius,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(image, lineLocation);
-                block = wrapTaggedIfNeeded(image, pending, blockAttrs, lineLocation);
-            }
-            block = wrapCommentIfNeeded(block, pending, lineLocation);
-            lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
-            i += 1;
-            continue;
-        }
-        const htmlMatch = matchHtmlBlock(trimmedContent);
-        if (htmlMatch) {
-            const blockAttrs = buildBlockAttrs(pending, lineInfo.tabCount);
-            let block;
-            if (pending.isDisabled) {
-                const disabled = {
-                    type: 'disabledBlock',
-                    raw: lineInfo.raw,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(disabled, lineLocation);
-                block = disabled;
-            }
-            else {
-                const htmlBlock = {
-                    type: 'html',
-                    source: htmlMatch.source,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(htmlBlock, lineLocation);
-                block = wrapTaggedIfNeeded(htmlBlock, pending, blockAttrs, lineLocation);
-            }
-            block = wrapCommentIfNeeded(block, pending, lineLocation);
-            lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
-            i += 1;
-            continue;
-        }
-        const listFirstMatch = matchListItem(lineInfo.content, i + 1, lineInfo.tabCount + 1);
-        if (listFirstMatch) {
-            const listMatches = [listFirstMatch];
-            const rawLines = [lineInfo.raw];
-            let jList = i + 1;
-            while (jList < lines.length) {
-                const nextRaw = lines[jList];
-                if (nextRaw === undefined) {
-                    jList += 1;
-                    continue;
-                }
-                const nextInfo = getLineInfo(nextRaw);
-                const nextTrimmed = nextInfo.content.trim();
-                if (nextTrimmed.length === 0) {
+                case 'table':
+                    nextIndex = (0, table_1.tryParseTableBlock)({
+                        lines,
+                        index: i,
+                        lineInfo,
+                        trimmedContent,
+                        lineLocation,
+                        pending: runtime.pending,
+                        errors,
+                        buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
+                        commitBlock,
+                    });
                     break;
-                }
-                if (isAttributeOnlyLine(nextTrimmed)) {
+                case 'image':
+                    nextIndex = (0, image_1.tryParseImageBlock)({
+                        lines,
+                        index: i,
+                        lineInfo,
+                        trimmedContent,
+                        lineLocation,
+                        pending: runtime.pending,
+                        errors,
+                        buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
+                        commitBlock,
+                    });
                     break;
-                }
-                const nextMatch = matchListItem(nextInfo.content, jList + 1, nextInfo.tabCount + 1);
-                if (!nextMatch) {
-                    // Check if this is a code block that should be attached to the previous list item
-                    // Support both plain ``` and attributed [html]``` forms
-                    const codeFence = matchCodeFenceStart(nextTrimmed);
-                    const attrCodeFence = codeFence ? null : matchAttributedCodeFence(nextTrimmed);
-                    const effectiveFence = codeFence || attrCodeFence;
-                    if (effectiveFence && listMatches.length > 0) {
-                        // Parse the code block
-                        const codeLines = [];
-                        const fenceIndent = nextInfo.tabCount;
-                        let kCode = jList + 1;
-                        let codeClosed = false;
-                        while (kCode < lines.length) {
-                            const codeRaw = lines[kCode];
-                            if (codeRaw === undefined) {
-                                kCode += 1;
-                                continue;
-                            }
-                            const codeInfo = getLineInfo(codeRaw);
-                            const codeTrimmed = codeInfo.content.trim();
-                            if (isCodeFenceEnd(codeTrimmed)) {
-                                codeClosed = true;
-                                kCode += 1;
-                                break;
-                            }
-                            // Strip leading tabs matching the fence indentation level
-                            let codeLine = codeRaw;
-                            for (let t = 0; t < fenceIndent && codeLine.startsWith('\t'); t++) {
-                                codeLine = codeLine.slice(1);
-                            }
-                            codeLines.push(codeLine);
-                            kCode += 1;
-                        }
-                        if (codeClosed) {
-                            const isHtmlBlock = attrCodeFence?.isHtml ?? false;
-                            const codeBlock = {
-                                type: 'code',
-                                language: effectiveFence.language,
-                                value: codeLines.join('\n'),
-                                htmlLike: isHtmlBlock ? true : undefined,
-                            };
-                            (0, location_1.setNodeLocation)(codeBlock, buildLineLocation(jList, nextInfo));
-                            // Attach to the last list item
-                            const lastItem = listMatches[listMatches.length - 1];
-                            if (lastItem) {
-                                if (!lastItem.childBlocks) {
-                                    lastItem.childBlocks = [];
-                                }
-                                lastItem.childBlocks.push(codeBlock);
-                            }
-                            jList = kCode;
-                            continue;
-                        }
-                    }
+                case 'html':
+                    nextIndex = (0, html_1.tryParseHtmlBlock)({
+                        lines,
+                        index: i,
+                        lineInfo,
+                        trimmedContent,
+                        lineLocation,
+                        pending: runtime.pending,
+                        errors,
+                        buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
+                        commitBlock,
+                    });
                     break;
-                }
-                if (nextMatch.kind !== listFirstMatch.kind) {
+                case 'list':
+                    nextIndex = (0, list_1.tryParseListBlock)({
+                        lines,
+                        index: i,
+                        lineInfo,
+                        trimmedContent,
+                        lineLocation,
+                        pending: runtime.pending,
+                        errors,
+                        buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
+                        commitBlock,
+                    });
                     break;
-                }
-                if (nextMatch.indent < listFirstMatch.indent) {
+                default:
                     break;
-                }
-                listMatches.push(nextMatch);
-                rawLines.push(nextInfo.raw);
-                jList += 1;
-            }
-            const blockAttrs = buildBlockAttrs(pending, lineInfo.tabCount);
-            let block;
-            if (pending.isDisabled) {
-                const disabled = {
-                    type: 'disabledBlock',
-                    raw: rawLines.join('\n'),
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(disabled, lineLocation);
-                block = disabled;
             }
-            else {
-                const { items } = buildListItems(listMatches, 0, listFirstMatch.indent);
-                let listKind = listFirstMatch.kind;
-                const firstItem = items[0];
-                if (firstItem) {
-                    listKind = firstItem.kind;
-                }
-                const listBlock = {
-                    type: 'list',
-                    kind: listKind,
-                    orderedStyle: listKind === 'ordered' ? 'decimal' : undefined,
-                    children: items,
-                    blockAttrs,
-                };
-                (0, location_1.setNodeLocation)(listBlock, lineLocation);
-                block = wrapTaggedIfNeeded(listBlock, pending, blockAttrs, lineLocation);
-            }
-            block = wrapCommentIfNeeded(block, pending, lineLocation);
-            lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
-            i = jList;
-            continue;
-        }
-        const blockRawLines = [lineInfo.raw];
-        const blockTextLines = [lineInfo.content];
-        let j = i + 1;
-        while (j < lines.length) {
-            const nextRaw = lines[j];
-            if (nextRaw === undefined) {
-                j += 1;
-                continue;
-            }
-            const nextInfo = getLineInfo(nextRaw);
-            const nextTrimmed = nextInfo.content.trim();
-            if (nextTrimmed.length === 0) {
-                break;
-            }
-            if (isAttributeOnlyLine(nextTrimmed)) {
-                break;
-            }
-            if (isFootnotesLine(nextTrimmed)) {
-                break;
-            }
-            if ((0, include_1.matchInclude)(nextInfo.content)) {
-                break;
-            }
-            if ((0, heading_1.matchHeading)(nextInfo.content)) {
-                break;
-            }
-            if (matchContentTitle(nextInfo.content)) {
+            if (nextIndex !== null) {
+                i = nextIndex;
+                handledByConfiguredRule = true;
                 break;
             }
-            if (matchQuote(nextInfo.content)) {
-                break;
-            }
-            if (matchCodeFenceStart(nextTrimmed)) {
-                break;
-            }
-            if ((0, horizontal_rule_1.matchHorizontalRule)(nextTrimmed)) {
-                break;
-            }
-            if (matchImageBlock(nextTrimmed)) {
-                break;
-            }
-            if (matchHtmlBlock(nextTrimmed)) {
-                break;
-            }
-            if (matchListItem(nextInfo.content)) {
-                break;
-            }
-            blockRawLines.push(nextInfo.raw);
-            blockTextLines.push(nextInfo.content);
-            j += 1;
         }
-        const blockText = blockTextLines.join('\n');
-        const blockAttrs = buildBlockAttrs(pending, lineInfo.tabCount);
-        let block;
-        if (pending.isDisabled) {
-            const disabled = {
-                type: 'disabledBlock',
-                raw: blockRawLines.join('\n'),
-                blockAttrs,
-            };
-            (0, location_1.setNodeLocation)(disabled, lineLocation);
-            block = disabled;
-        }
-        else {
-            const paragraph = {
-                type: 'paragraph',
-                children: [{ type: 'text', value: blockText }],
-                blockAttrs,
-            };
-            (0, location_1.setNodeLocation)(paragraph, lineLocation);
-            block = paragraph;
-            if (pending.tagName) {
-                block = wrapTaggedIfNeeded(block, pending, blockAttrs, lineLocation);
-            }
+        if (handledByConfiguredRule) {
+            continue;
         }
-        block = wrapCommentIfNeeded(block, pending, lineLocation);
-        lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
-        i = j;
+        i = (0, paragraph_1.tryParseParagraphBlock)({
+            lines,
+            index: i,
+            lineInfo,
+            trimmedContent,
+            lineLocation,
+            pending: runtime.pending,
+            errors,
+            buildBlockAttrs: (tabCount) => (0, runtime_1.buildBlockAttrs)(runtime, tabCount),
+            commitBlock,
+            shouldStopParagraph: (nextContent, nextTrimmed) => PARAGRAPH_STOP_CHECKS.some((rule) => rule(nextContent, nextTrimmed)),
+        });
     }
     return blocks;
 }
-function getBlockAttributes(block) {
-    if ('blockAttrs' in block) {
-        const candidate = block.blockAttrs;
-        return candidate;
-    }
-    return undefined;
-}
-function resolveNextPosition(attrs, tabCount, fallback) {
-    if (attrs?.position) {
-        return attrs.position;
-    }
-    const tabPosition = mapTabsToPosition(tabCount);
-    if (tabPosition) {
-        return tabPosition;
-    }
-    return fallback;
-}
 function getLineInfo(raw) {
     return (0, lexer_1.getLineInfo)(raw);
 }
-function mapTabsToPosition(tabCount) {
-    if (tabCount === 0) {
-        return 'L';
-    }
-    if (tabCount === 1) {
-        return 'C';
-    }
-    if (tabCount >= 2) {
-        return 'R';
-    }
-    return undefined;
-}
-function isAttributeOnlyLine(text) {
-    if (text.length === 0) {
-        return false;
-    }
-    const trimmed = text.trim();
-    if ((0, include_1.matchInclude)(trimmed)) {
-        return false;
-    }
-    let i = 0;
-    while (i < text.length) {
-        const ch = text[i];
-        if (ch === '[') {
-            const end = text.indexOf(']', i + 1);
-            if (end === -1) {
-                return false;
-            }
-            i = end + 1;
-            continue;
-        }
-        if (ch === ' ' || ch === '\t') {
-            i += 1;
-            continue;
-        }
-        return false;
-    }
-    return true;
-}
-function isFootnotesLine(trimmed) {
-    return trimmed === '[footnotes]';
-}
-function parseFootnoteDefs(lines, errors) {
-    const defs = [];
-    let i = 0;
-    while (i < lines.length) {
-        const raw = lines[i];
-        if (raw === undefined) {
-            i += 1;
-            continue;
-        }
-        const trimmed = raw.trim();
-        const match = trimmed.match(/^\[fn=([^\]]+)\]\s*$/);
-        if (!match) {
-            i += 1;
-            continue;
-        }
-        const idGroup = match[1];
-        if (!idGroup) {
-            i += 1;
-            continue;
-        }
-        const id = idGroup.trim();
-        i += 1;
-        const contentLines = [];
-        while (i < lines.length) {
-            const innerRaw = lines[i];
-            if (innerRaw === undefined) {
-                i += 1;
-                continue;
-            }
-            const innerTrimmed = innerRaw.trim();
-            if (innerTrimmed.length === 0) {
-                break;
-            }
-            if (/^\[fn=[^\]]+\]\s*$/.test(innerTrimmed)) {
-                break;
-            }
-            contentLines.push(innerRaw);
-            i += 1;
-        }
-        const contentSource = contentLines.join('\n');
-        const children = contentSource.length > 0 ? parseBlocks(contentSource, errors) : [];
-        const def = {
-            type: 'footnoteDef',
-            id,
-            children,
-        };
-        defs.push(def);
-    }
-    return defs;
-}
-function isTableRow(content) {
-    const trimmed = content.trim();
-    if (!trimmed.startsWith('|')) {
-        return false;
-    }
-    return trimmed.indexOf('|', 1) !== -1;
-}
-function parseTableRows(lines, errors) {
-    if (lines.length === 0) {
-        return { rows: [], align: undefined };
-    }
-    for (const line of lines) {
-        const trimmed = line.text.trim();
-        if (isTableRow(trimmed) && !trimmed.endsWith('|')) {
-            const contentStart = line.raw.length - line.text.length;
-            const trimmedContent = line.text.replace(/\s+$/, '');
-            const column = contentStart + trimmedContent.length + 1;
-            (0, diagnostics_1.reportParseError)(errors, {
-                message: 'Table row is missing closing "|" border',
-                line: line.line,
-                column,
-            });
-        }
-    }
-    const remaining = [...lines];
-    let align;
-    // Check if the first line is an alignment row (JianWen native syntax: alignment row comes first)
-    const firstLine = remaining[0];
-    if (firstLine !== undefined) {
-        const firstTrimmed = firstLine.text.trim();
-        if (isAlignmentRow(firstTrimmed)) {
-            align = parseAlignmentLine(firstTrimmed);
-            remaining.shift();
-        }
-    }
-    // Check if the second line is an alignment row (Markdown compatible syntax: alignment row after header row)
-    if (align === undefined && remaining.length >= 2) {
-        const secondLine = remaining[1];
-        if (secondLine !== undefined) {
-            const secondTrimmed = secondLine.text.trim();
-            if (isAlignmentRow(secondTrimmed)) {
-                align = parseAlignmentLine(secondTrimmed);
-                remaining.splice(1, 1); // Remove the second line (alignment row)
-            }
-        }
-    }
-    const rows = [];
-    for (const line of remaining) {
-        const trimmed = line.text.trim();
-        if (!isTableRow(trimmed)) {
-            continue;
-        }
-        const rawCells = trimmed.split('|').slice(1, -1);
-        const cells = [];
-        for (let ci = 0; ci < rawCells.length; ci += 1) {
-            const rawCell = rawCells[ci];
-            if (rawCell === undefined) {
-                continue;
-            }
-            let cellText = rawCell.trim();
-            let cellAlign;
-            if (cellText.startsWith('[r]')) {
-                cellAlign = 'right';
-                cellText = cellText.slice(3).trim();
-            }
-            else if (cellText.startsWith('[c]')) {
-                cellAlign = 'center';
-                cellText = cellText.slice(3).trim();
-            }
-            else if (align && ci < align.length) {
-                cellAlign = align[ci];
-            }
-            const cell = {
-                type: 'tableCell',
-                children: cellText.length > 0 ? [{ type: 'text', value: cellText }] : [],
-                align: cellAlign,
-            };
-            (0, location_1.setNodeLocation)(cell, { line: line.line, column: 1 });
-            cells.push(cell);
-        }
-        const row = {
-            type: 'tableRow',
-            cells,
-        };
-        rows.push(row);
-    }
-    return { rows, align };
-}
-function isAlignmentRow(trimmed) {
-    if (!isTableRow(trimmed)) {
-        return false;
-    }
-    const segments = trimmed.split('|').slice(1, -1);
-    if (segments.length === 0) {
-        return false;
-    }
-    for (const seg of segments) {
-        const t = seg.trim();
-        if (!/^:?-+:?$/.test(t)) {
-            return false;
-        }
-    }
-    return true;
-}
-function parseAlignmentLine(trimmed) {
-    const segments = trimmed.split('|').slice(1, -1);
-    const result = [];
-    for (const seg of segments) {
-        const t = seg.trim();
-        const left = t.startsWith(':');
-        const right = t.endsWith(':');
-        if (left && right) {
-            result.push('center');
-        }
-        else if (right) {
-            result.push('right');
-        }
-        else {
-            result.push('left');
-        }
-    }
-    return result;
-}
-function getMaxTableColumnCount(rows) {
-    let max = 0;
-    for (const row of rows) {
-        if (row.cells.length > max) {
-            max = row.cells.length;
-        }
-    }
-    return max;
-}
-function matchImageBlock(trimmed) {
-    const m = trimmed.match(/^\[([^\]]+)\]\(([^)]+)\)\s*$/);
-    if (!m) {
-        return undefined;
-    }
-    const inside = m[1];
-    const urlGroup = m[2];
-    if (inside === undefined || urlGroup === undefined) {
-        return undefined;
-    }
-    const url = urlGroup.trim();
-    if (url.length === 0) {
-        return undefined;
-    }
-    const parts = inside
-        .split(',')
-        .map((part) => part.trim())
-        .filter((part) => part.length > 0);
-    if (!parts.includes('img')) {
-        return undefined;
-    }
-    let shape;
-    let roundedRadius;
-    for (const part of parts) {
-        if (part === 'rounded') {
-            shape = 'rounded';
-            continue;
-        }
-        if (part === 'square') {
-            shape = 'square';
-            continue;
-        }
-        const roundedMatch = part.match(/^rounded=([0-9.]+)$/);
-        if (roundedMatch && roundedMatch[1]) {
-            const num = parseFloat(roundedMatch[1]);
-            if (!isNaN(num) && num > 0) {
-                shape = 'rounded';
-                roundedRadius = num;
-            }
-        }
-    }
-    return { url, shape, roundedRadius };
-}
-function matchHtmlBlock(trimmed) {
-    const m = trimmed.match(/^\[html\]\(([^)]+)\)\s*$/);
-    if (!m) {
-        return undefined;
-    }
-    const urlGroup = m[1];
-    if (urlGroup === undefined) {
-        return undefined;
-    }
-    const source = urlGroup.trim();
-    if (source.length === 0) {
-        return undefined;
-    }
-    return { source };
-}
-function matchContentTitle(content) {
-    const m = content.match(/^>\s+(.+)$/);
-    if (!m) {
-        return undefined;
-    }
-    const group = m[1];
-    if (group === undefined) {
-        return undefined;
-    }
-    const text = group.trimEnd();
-    return { text };
-}
-function matchQuote(content) {
-    const m = content.match(/^(@+)\s+(.+)$/);
-    if (!m) {
-        return undefined;
-    }
-    const atGroup = m[1];
-    const textGroup = m[2];
-    if (atGroup === undefined || textGroup === undefined) {
-        return undefined;
-    }
-    const level = atGroup.length;
-    const text = textGroup.trimEnd();
-    return { level, text };
-}
-function normalizeQuoteLine(match, baseLevel) {
-    if (match.level < baseLevel) {
-        return undefined;
-    }
-    const relativeLevel = match.level - baseLevel;
-    if (relativeLevel === 0) {
-        return match.text;
-    }
-    const nestedMarkers = '@'.repeat(relativeLevel);
-    return `${nestedMarkers} ${match.text}`;
-}
-function adjustNestedQuoteLevels(nodes, parentLevel) {
-    for (const node of nodes) {
-        if (node.type !== 'quote') {
-            continue;
-        }
-        node.level += parentLevel;
-        adjustNestedQuoteLevels(node.children, node.level);
-    }
-}
-function matchCodeFenceStart(trimmed) {
-    if (!trimmed.startsWith('```')) {
-        return undefined;
-    }
-    const m = trimmed.match(/^```([^\s`]*)\s*$/);
-    if (!m) {
-        return undefined;
-    }
-    const group = m[1];
-    if (group === undefined || group.length === 0) {
-        return { language: undefined };
-    }
-    return { language: group };
-}
-function isCodeFenceEnd(trimmed) {
-    return /^```\s*$/.test(trimmed);
-}
-/**
- * Match code fence with optional leading attributes like [html]```
- * Returns the language and whether it's an HTML block
- */
-function matchAttributedCodeFence(trimmed) {
-    // Match pattern: optional [attr]... followed by ```language?
-    const match = trimmed.match(/^(\[.+\])*\s*```([^\s`]*)\s*$/);
-    if (!match) {
-        return undefined;
-    }
-    const attrPart = match[1] || '';
-    const language = match[2] || undefined;
-    const isHtml = /\[html\]/i.test(attrPart);
-    return { language, isHtml };
-}
-function matchListItem(content, line, column) {
-    const taskMatch = content.match(/^(-+)(\[(.|..)?\])(?:\s+(.*))?$/);
-    if (taskMatch) {
-        const dashes = taskMatch[1];
-        const markerGroup = taskMatch[2];
-        const markerInner = taskMatch[3];
-        const textGroup = taskMatch[4] || '';
-        if (!dashes || !markerGroup) {
-            return undefined;
-        }
-        const indent = dashes.length;
-        const taskStatus = mapTaskStatus(markerInner);
-        const text = textGroup.trimEnd();
-        const textColumn = getListTextColumn(column, taskMatch[0], textGroup);
-        return { kind: 'task', indent, taskStatus, text, line, column: textColumn };
-    }
-    const orderedMatch = content.match(/^(\d+(?:\.\d+)*)\.?\s*(\[(.|..)?\])?(?:\s+(.*))?$/);
-    if (orderedMatch) {
-        const ordinalGroup = orderedMatch[1];
-        const markerGroup = orderedMatch[2];
-        const markerInner = orderedMatch[3];
-        const textGroup = orderedMatch[4] || '';
-        if (!ordinalGroup) {
-            return undefined;
-        }
-        const ordinal = ordinalGroup;
-        const indent = ordinal.split('.').length;
-        const taskStatus = markerGroup ? mapTaskStatus(markerInner) : undefined;
-        const text = textGroup.trimEnd();
-        const textColumn = getListTextColumn(column, orderedMatch[0], textGroup);
-        return { kind: 'ordered', indent, ordinal, taskStatus, text, line, column: textColumn };
-    }
-    const foldableMatch = content.match(/^(\++)(\[(.|..)?\])?(?:\s+(.*))?$/);
-    if (foldableMatch) {
-        const pluses = foldableMatch[1];
-        const markerGroup = foldableMatch[2];
-        const markerInner = foldableMatch[3];
-        const textGroup = foldableMatch[4] || '';
-        if (!pluses) {
-            return undefined;
-        }
-        const indent = pluses.length;
-        const taskStatus = markerGroup ? mapTaskStatus(markerInner) : undefined;
-        const text = textGroup.trimEnd();
-        const textColumn = getListTextColumn(column, foldableMatch[0], textGroup);
-        return {
-            kind: 'foldable',
-            indent,
-            ordinal: ordinalFromIndent(indent),
-            taskStatus,
-            text,
-            line,
-            column: textColumn,
-        };
-    }
-    const bulletMatch = content.match(/^(-+)(?:\s+(.*))?$/);
-    if (bulletMatch) {
-        const dashes = bulletMatch[1];
-        const textGroup = bulletMatch[2] || '';
-        if (!dashes) {
-            return undefined;
-        }
-        const indent = dashes.length;
-        const text = textGroup.trimEnd();
-        const textColumn = getListTextColumn(column, bulletMatch[0], textGroup);
-        return { kind: 'bullet', indent, text, line, column: textColumn };
-    }
-    return undefined;
-}
-function getListTextColumn(baseColumn, matchText, rawText) {
-    if (baseColumn === undefined) {
-        return undefined;
-    }
-    const prefixLength = matchText.length - rawText.length;
-    return baseColumn + Math.max(0, prefixLength);
-}
-function mapTaskStatus(markerInner) {
-    if (!markerInner || markerInner === '') {
-        return 'unknown';
-    }
-    if (markerInner === 'o') {
-        return 'in_progress';
-    }
-    if (markerInner === 'x') {
-        return 'not_done';
-    }
-    if (markerInner === 'v') {
-        return 'done';
-    }
-    return 'unknown';
-}
-function ordinalFromIndent(indent) {
-    if (indent <= 0) {
-        return '1';
-    }
-    return Array(indent).fill('1').join('.');
-}
-function buildListItems(matches, startIndex, baseIndent) {
-    const items = [];
-    let index = startIndex;
-    while (index < matches.length) {
-        const current = matches[index];
-        if (!current) {
-            break;
-        }
-        if (current.indent < baseIndent) {
-            break;
-        }
-        if (current.indent > baseIndent) {
-            break;
-        }
-        const paragraph = {
-            type: 'paragraph',
-            children: [{ type: 'text', value: current.text }],
-        };
-        if (current.line !== undefined && current.column !== undefined) {
-            (0, location_1.setNodeLocation)(paragraph, {
-                line: current.line,
-                column: current.column,
-            });
-        }
-        const childrenBlocks = [paragraph];
-        // Add any child blocks (code blocks, etc.) that follow this list item
-        if (current.childBlocks && current.childBlocks.length > 0) {
-            childrenBlocks.push(...current.childBlocks);
-        }
-        index += 1;
-        const next = matches[index];
-        if (next && next.indent > current.indent) {
-            const childResult = buildListItems(matches, index, next.indent);
-            childrenBlocks.push({
-                type: 'list',
-                kind: next.kind,
-                orderedStyle: next.kind === 'ordered' ? 'decimal' : undefined,
-                children: childResult.items,
-            });
-            index = childResult.nextIndex;
-        }
-        const item = {
-            type: 'listItem',
-            kind: current.kind,
-            ordinal: current.ordinal,
-            taskStatus: current.taskStatus,
-            indent: current.indent,
-            children: childrenBlocks,
-        };
-        items.push(item);
-    }
-    return { items, nextIndex: index };
-}
-function parseAttributeLine(text, lineNumber, errors, baseAttrs, fallbackPosition, tabCount) {
-    const result = {
-        attrs: undefined,
-        foldNext: false,
-        tagName: undefined,
-        isComment: false,
-        isDisabled: false,
-        isSheet: false,
-        isHtml: false,
-        recognizedAny: false,
-    };
-    let attrs = baseAttrs ? { ...baseAttrs } : undefined;
-    const unknownTokens = [];
-    let arrowCount = 0;
-    let i = 0;
-    while (i < text.length) {
-        const start = text.indexOf('[', i);
-        if (start === -1) {
-            break;
-        }
-        const end = text.indexOf(']', start + 1);
-        if (end === -1) {
-            break;
-        }
-        const inside = text.slice(start + 1, end).trim();
-        if (inside.length === 0) {
-            i = end + 1;
-            continue;
-        }
-        const parts = inside.split(',');
-        for (const rawPart of parts) {
-            const part = rawPart.trim();
-            if (part.length === 0) {
-                continue;
-            }
-            if (part === 'c') {
-                attrs = ensureBlockAttributes(attrs);
-                attrs.align = 'center';
-                result.recognizedAny = true;
-                continue;
-            }
-            if (part === 'r') {
-                attrs = ensureBlockAttributes(attrs);
-                attrs.align = 'right';
-                result.recognizedAny = true;
-                continue;
-            }
-            if (part === '->' || part === '<-' || part === '<->') {
-                arrowCount += 1;
-                result.recognizedAny = true;
-                if (part === '->' && arrowCount > 2) {
-                    (0, diagnostics_1.reportParseWarning)(errors, {
-                        message: 'More than two [->] attributes in a row; extra [->] will be treated as plain text.',
-                        line: lineNumber,
-                        code: MULTI_ARROW_WARNING_CODE,
-                    });
-                    continue;
-                }
-                attrs = ensureBlockAttributes(attrs);
-                if (part === '->' || part === '<->') {
-                    const basePosition = attrs.position ??
-                        fallbackPosition ??
-                        (tabCount !== undefined ? mapTabsToPosition(tabCount) : undefined);
-                    attrs.position = shiftPositionRight(basePosition);
-                    attrs.sameLine = true;
-                }
-                if (part === '<-' || part === '<->') {
-                    attrs.truncateRight = true;
-                }
-                continue;
-            }
-            if (part === 'fold') {
-                result.foldNext = true;
-                result.recognizedAny = true;
-                continue;
-            }
-            if (part === 'sheet') {
-                result.isSheet = true;
-                result.recognizedAny = true;
-                continue;
-            }
-            if (part === 'html') {
-                result.isHtml = true;
-                result.recognizedAny = true;
-                continue;
-            }
-            if (part === 'comment') {
-                result.isComment = true;
-                result.recognizedAny = true;
-                continue;
-            }
-            if (part === 'disable' || part === 'd') {
-                result.isDisabled = true;
-                result.recognizedAny = true;
-                continue;
-            }
-            if (part.startsWith('tag=')) {
-                result.tagName = part.slice('tag='.length);
-                result.recognizedAny = true;
-                continue;
-            }
-            if (part.startsWith('t=')) {
-                result.tagName = part.slice(2);
-                result.recognizedAny = true;
-                continue;
-            }
-            if (part.startsWith('f=')) {
-                result.tagName = part.slice(2);
-                result.recognizedAny = true;
-                continue;
-            }
-            unknownTokens.push(part);
-            continue;
-        }
-        i = end + 1;
-    }
-    if (!result.recognizedAny && unknownTokens.length > 0) {
-        for (const token of unknownTokens) {
-            (0, diagnostics_1.reportParseWarning)(errors, {
-                message: `Unknown block attribute token "${token}"`,
-                line: lineNumber,
-                code: UNKNOWN_ATTRIBUTE_WARNING_CODE,
-            });
-        }
-    }
-    result.attrs = attrs;
-    return result;
-}
-function ensureBlockAttributes(attrs) {
-    if (attrs) {
-        return attrs;
-    }
-    return {};
-}
-function mergeBlockAttributes(base, extra) {
-    if (!base) {
-        return { ...extra };
-    }
-    return { ...base, ...extra };
-}
-function shiftPositionRight(position) {
-    if (position === 'L') {
-        return 'C';
-    }
-    if (position === 'C') {
-        return 'R';
-    }
-    if (position === 'R') {
-        return 'R';
-    }
-    return 'C';
-}