@jianwen-lang/parser 0.1.1 → 0.1.3

package/dist/core/block/rules/footnotes.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseFootnotesBlock = tryParseFootnotesBlock;
+exports.isFootnotesLine = isFootnotesLine;
+const location_1 = require("../../location");
+const lexer_1 = require("../../../lexer/lexer");
+function tryParseFootnotesBlock(ctx) {
+    if (!isFootnotesLine(ctx.trimmedContent)) {
+        return null;
+    }
+    const rawLines = [ctx.lineInfo.raw];
+    const regionLines = [];
+    let jFoot = ctx.index + 1;
+    while (jFoot < ctx.lines.length) {
+        const nextRaw = ctx.lines[jFoot];
+        if (nextRaw === undefined) {
+            jFoot += 1;
+            continue;
+        }
+        const nextInfo = (0, lexer_1.getLineInfo)(nextRaw);
+        const nextTrimmed = nextInfo.content.trim();
+        if (nextTrimmed.length === 0) {
+            break;
+        }
+        rawLines.push(nextInfo.raw);
+        regionLines.push(nextInfo.content);
+        jFoot += 1;
+    }
+    const blockAttrs = ctx.buildBlockAttrs(ctx.lineInfo.tabCount);
+    let block;
+    if (ctx.pending.isDisabled) {
+        const disabled = {
+            type: 'disabledBlock',
+            raw: rawLines.join('\n'),
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(disabled, ctx.lineLocation);
+        block = disabled;
+    }
+    else {
+        const children = parseFootnoteDefs(regionLines, ctx.errors, ctx.parseBlocks);
+        const footnotesBlock = {
+            type: 'footnotes',
+            children,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(footnotesBlock, ctx.lineLocation);
+        block = footnotesBlock;
+    }
+    ctx.commitBlock(block, blockAttrs);
+    return jFoot;
+}
+function isFootnotesLine(trimmed) {
+    return trimmed === '[footnotes]';
+}
+function parseFootnoteDefs(lines, errors, parseBlocks) {
+    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;
+}

package/dist/core/block/rules/html.d.ts

@@ -0,0 +1,7 @@
+import { BlockRuleContext } from './types';
+interface HtmlBlockMatchResult {
+    source: string;
+}
+export declare function tryParseHtmlBlock(ctx: BlockRuleContext): number | null;
+export declare function matchHtmlBlock(trimmed: string): HtmlBlockMatchResult | undefined;
+export {};

package/dist/core/block/rules/html.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseHtmlBlock = tryParseHtmlBlock;
+exports.matchHtmlBlock = matchHtmlBlock;
+const location_1 = require("../../location");
+function tryParseHtmlBlock(ctx) {
+    const htmlMatch = matchHtmlBlock(ctx.trimmedContent);
+    if (!htmlMatch) {
+        return null;
+    }
+    const blockAttrs = ctx.buildBlockAttrs(ctx.lineInfo.tabCount);
+    let block;
+    if (ctx.pending.isDisabled) {
+        const disabled = {
+            type: 'disabledBlock',
+            raw: ctx.lineInfo.raw,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(disabled, ctx.lineLocation);
+        block = disabled;
+    }
+    else {
+        const htmlBlock = {
+            type: 'html',
+            source: htmlMatch.source,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(htmlBlock, ctx.lineLocation);
+        block = htmlBlock;
+    }
+    ctx.commitBlock(block, blockAttrs);
+    return ctx.index + 1;
+}
+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 };
+}

package/dist/core/block/rules/image.d.ts

@@ -0,0 +1,9 @@
+import { BlockRuleContext } from './types';
+interface ImageBlockMatchResult {
+    url: string;
+    shape?: 'square' | 'rounded';
+    roundedRadius?: number;
+}
+export declare function tryParseImageBlock(ctx: BlockRuleContext): number | null;
+export declare function matchImageBlock(trimmed: string): ImageBlockMatchResult | undefined;
+export {};

package/dist/core/block/rules/image.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseImageBlock = tryParseImageBlock;
+exports.matchImageBlock = matchImageBlock;
+const location_1 = require("../../location");
+function tryParseImageBlock(ctx) {
+    const imageMatch = matchImageBlock(ctx.trimmedContent);
+    if (!imageMatch) {
+        return null;
+    }
+    const blockAttrs = ctx.buildBlockAttrs(ctx.lineInfo.tabCount);
+    let block;
+    if (ctx.pending.isDisabled) {
+        const disabled = {
+            type: 'disabledBlock',
+            raw: ctx.lineInfo.raw,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(disabled, ctx.lineLocation);
+        block = disabled;
+    }
+    else {
+        const image = {
+            type: 'image',
+            url: imageMatch.url,
+            shape: imageMatch.shape,
+            roundedRadius: imageMatch.roundedRadius,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(image, ctx.lineLocation);
+        block = image;
+    }
+    ctx.commitBlock(block, blockAttrs);
+    return ctx.index + 1;
+}
+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 };
+}

package/dist/core/block/rules/list.d.ts

@@ -0,0 +1,3 @@
+import { BlockRuleContext } from './types';
+export declare function tryParseListBlock(ctx: BlockRuleContext): number | null;
+export declare function isListItemStart(content: string): boolean;

package/dist/core/block/rules/list.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseListBlock = tryParseListBlock;
+exports.isListItemStart = isListItemStart;
+const location_1 = require("../../location");
+const lexer_1 = require("../../../lexer/lexer");
+const attribute_line_1 = require("./attribute-line");
+const code_fence_1 = require("./code-fence");
+function tryParseListBlock(ctx) {
+    const listFirstMatch = matchListItem(ctx.lineInfo.content, ctx.index + 1, ctx.lineInfo.tabCount + 1);
+    if (!listFirstMatch) {
+        return null;
+    }
+    const listMatches = [listFirstMatch];
+    const rawLines = [ctx.lineInfo.raw];
+    let jList = ctx.index + 1;
+    while (jList < ctx.lines.length) {
+        const nextRaw = ctx.lines[jList];
+        if (nextRaw === undefined) {
+            jList += 1;
+            continue;
+        }
+        const nextInfo = (0, lexer_1.getLineInfo)(nextRaw);
+        const nextTrimmed = nextInfo.content.trim();
+        if (nextTrimmed.length === 0) {
+            break;
+        }
+        if ((0, attribute_line_1.isAttributeOnlyLine)(nextTrimmed)) {
+            break;
+        }
+        const nextMatch = matchListItem(nextInfo.content, jList + 1, nextInfo.tabCount + 1);
+        if (!nextMatch) {
+            const codeFence = (0, code_fence_1.matchCodeFenceStart)(nextTrimmed);
+            const attrCodeFence = codeFence ? null : (0, code_fence_1.matchAttributedCodeFence)(nextTrimmed);
+            const effectiveFence = codeFence || attrCodeFence;
+            if (effectiveFence && listMatches.length > 0) {
+                const codeLines = [];
+                const fenceIndent = nextInfo.tabCount;
+                let kCode = jList + 1;
+                let codeClosed = false;
+                while (kCode < ctx.lines.length) {
+                    const codeRaw = ctx.lines[kCode];
+                    if (codeRaw === undefined) {
+                        kCode += 1;
+                        continue;
+                    }
+                    const codeInfo = (0, lexer_1.getLineInfo)(codeRaw);
+                    const codeTrimmed = codeInfo.content.trim();
+                    if ((0, code_fence_1.isCodeFenceEnd)(codeTrimmed)) {
+                        codeClosed = true;
+                        kCode += 1;
+                        break;
+                    }
+                    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, { line: jList + 1, column: nextInfo.tabCount + 1 });
+                    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 = ctx.buildBlockAttrs(ctx.lineInfo.tabCount);
+    let block;
+    if (ctx.pending.isDisabled) {
+        const disabled = {
+            type: 'disabledBlock',
+            raw: rawLines.join('\n'),
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(disabled, ctx.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, ctx.lineLocation);
+        block = listBlock;
+    }
+    ctx.commitBlock(block, blockAttrs);
+    return jList;
+}
+function isListItemStart(content) {
+    return matchListItem(content) !== undefined;
+}
+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];
+        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 };
+}

package/dist/core/block/rules/paragraph.d.ts

@@ -0,0 +1,6 @@
+import { BlockRuleContext } from './types';
+interface ParagraphRuleContext extends BlockRuleContext {
+    shouldStopParagraph: (content: string, trimmed: string) => boolean;
+}
+export declare function tryParseParagraphBlock(ctx: ParagraphRuleContext): number;
+export {};

package/dist/core/block/rules/paragraph.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseParagraphBlock = tryParseParagraphBlock;
+const location_1 = require("../../location");
+const lexer_1 = require("../../../lexer/lexer");
+const attribute_line_1 = require("./attribute-line");
+function tryParseParagraphBlock(ctx) {
+    const blockRawLines = [ctx.lineInfo.raw];
+    const blockTextLines = [ctx.lineInfo.content];
+    let j = ctx.index + 1;
+    while (j < ctx.lines.length) {
+        const nextRaw = ctx.lines[j];
+        if (nextRaw === undefined) {
+            j += 1;
+            continue;
+        }
+        const nextInfo = (0, lexer_1.getLineInfo)(nextRaw);
+        const nextTrimmed = nextInfo.content.trim();
+        if (nextTrimmed.length === 0) {
+            break;
+        }
+        if ((0, attribute_line_1.isAttributeOnlyLine)(nextTrimmed)) {
+            break;
+        }
+        if (ctx.shouldStopParagraph(nextInfo.content, nextTrimmed)) {
+            break;
+        }
+        blockRawLines.push(nextInfo.raw);
+        blockTextLines.push(nextInfo.content);
+        j += 1;
+    }
+    const blockText = blockTextLines.join('\n');
+    const blockAttrs = ctx.buildBlockAttrs(ctx.lineInfo.tabCount);
+    let block;
+    if (ctx.pending.isDisabled) {
+        const disabled = {
+            type: 'disabledBlock',
+            raw: blockRawLines.join('\n'),
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(disabled, ctx.lineLocation);
+        block = disabled;
+    }
+    else {
+        const paragraph = {
+            type: 'paragraph',
+            children: [{ type: 'text', value: blockText }],
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(paragraph, ctx.lineLocation);
+        block = paragraph;
+    }
+    ctx.commitBlock(block, blockAttrs, { allowTag: !ctx.pending.isDisabled });
+    return j;
+}

package/dist/core/block/rules/quote.d.ts

@@ -0,0 +1,13 @@
+import { BlockNode } from '../../ast';
+import { ParseError } from '../../errors';
+import { BlockRuleContext } from './types';
+interface QuoteRuleContext extends BlockRuleContext {
+    parseBlocks: (source: string, errors: ParseError[]) => BlockNode[];
+}
+interface QuoteMatchResult {
+    level: number;
+    text: string;
+}
+export declare function tryParseQuoteBlock(ctx: QuoteRuleContext): number | null;
+export declare function matchQuote(content: string): QuoteMatchResult | undefined;
+export {};