@jianwen-lang/parser 0.1.1

package/dist/core/block-parser.js

@@ -0,0 +1,1385 @@
+"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 heading_1 = require("./block/rules/heading");
+const horizontal_rule_1 = require("./block/rules/horizontal-rule");
+const include_1 = require("./block/rules/include");
+const lexer_1 = require("../lexer/lexer");
+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';
+    let i = 0;
+    while (i < lines.length) {
+        const raw = lines[i];
+        if (raw === undefined) {
+            i += 1;
+            continue;
+        }
+        const lineInfo = getLineInfo(raw);
+        const lineLocation = buildLineLocation(i, lineInfo);
+        const trimmedContent = lineInfo.content.trim();
+        if (trimmedContent.length === 0) {
+            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);
+        };
+        const nextIndexFromRule = (0, rules_1.tryParseBlockRules)({
+            lines,
+            index: i,
+            lineInfo,
+            trimmedContent,
+            lineLocation,
+            pending,
+            errors,
+            buildBlockAttrs: (tabCount) => buildBlockAttrs(pending, tabCount),
+            commitBlock,
+        });
+        if (nextIndexFromRule !== null) {
+            i = nextIndexFromRule;
+            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);
+                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) {
+                    break;
+                }
+                if (isAttributeOnlyLine(nextTrimmed)) {
+                    break;
+                }
+                if (!isTableRow(nextInfo.content)) {
+                    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) {
+                    break;
+                }
+                if (isAttributeOnlyLine(nextTrimmed)) {
+                    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;
+                        }
+                    }
+                    break;
+                }
+                if (nextMatch.kind !== listFirstMatch.kind) {
+                    break;
+                }
+                if (nextMatch.indent < listFirstMatch.indent) {
+                    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)) {
+                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);
+            }
+        }
+        block = wrapCommentIfNeeded(block, pending, lineLocation);
+        lastBlockPosition = pushBlockAndResetPending(blocks, block, lineInfo, pending, lastBlockPosition);
+        i = j;
+    }
+    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';
+}