@jianwen-lang/parser 0.1.1 → 0.1.2

package/README.md

@@ -1,4 +1,4 @@
-# @jianwen-lang/parser `0.1.0`
+# @jianwen-lang/parser `0.1.2`
 
 Jianwen（简文）是一种类似 Markdown 的轻量级标记语言，针对网页博客、公众号等内容发布场景的排版能力进行优化。本包提供 Jianwen 的 **TypeScript 核心解析器**（输出结构化 AST）以及 **HTML 渲染器**，用于在编辑器、渲染服务、静态站点生成等场景复用同一套解析语义。
 
@@ -55,6 +55,19 @@ const { html, ast, errors } = renderJianwenToHtmlDocument(source, {
 });
 ```
 
+如果你在做编辑器并需要“渲染区块 ↔ 源码行范围”映射（例如拖拽区块后回写源码），可以使用：
+
+```ts
+import { renderJianwenToHtmlDocumentWithBlockMap } from '@jianwen-lang/parser';
+
+const result = renderJianwenToHtmlDocumentWithBlockMap(source, {
+  document: { format: true },
+});
+
+console.log(result.groups);
+// [{ id, kind, startLine, endLine, readOnly, origin? }, ...]
+```
+
 ## Include：文件/标签展开（可选）
 
 解析阶段支持将 `[@](path)`（文件 include）或 `[@=tag]`（标签 include）按需展开。开启方式：
@@ -83,7 +96,9 @@ const { ast, errors } = parseJianwenWithErrors(source, {
   - `ParseOptions`：`expandInclude` / `includeMaxDepth` / `loadFile`
 - 渲染
   - `renderDocumentToHtml(doc, options?) => string`
+  - `renderDocumentToHtmlWithBlockMap(doc, options?) => { html; groups }`
   - `renderJianwenToHtmlDocument(source, options?) => { html; ast; errors }`
+  - `renderJianwenToHtmlDocumentWithBlockMap(source, options?) => { html; ast; errors; groups }`
   - `buildHtmlDocument(bodyHtml, options?) => string`
 
 ## 规范与扩展

package/dist/core/block/rules/attribute-line.d.ts

@@ -0,0 +1,13 @@
+import { BlockAttributes } from '../../ast';
+import { ParseError } from '../../errors';
+import { PendingBlockContext } from '../types';
+export interface ConsumeAttributeLineOptions {
+    text: string;
+    lineNumber: number;
+    errors: ParseError[];
+    pending: PendingBlockContext;
+    fallbackPosition?: BlockAttributes['position'];
+    tabCount?: number;
+}
+export declare function isAttributeOnlyLine(text: string): boolean;
+export declare function tryConsumeAttributeOnlyLine(options: ConsumeAttributeLineOptions): boolean;

package/dist/core/block/rules/attribute-line.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAttributeOnlyLine = isAttributeOnlyLine;
+exports.tryConsumeAttributeOnlyLine = tryConsumeAttributeOnlyLine;
+const diagnostics_1 = require("../../diagnostics");
+const include_1 = require("./include");
+const MULTI_ARROW_WARNING_CODE = 'layout-multi-arrow';
+const UNKNOWN_ATTRIBUTE_WARNING_CODE = 'unknown-attribute-token';
+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 tryConsumeAttributeOnlyLine(options) {
+    const result = parseAttributeLine(options.text, options.lineNumber, options.errors, options.pending.attrs, options.fallbackPosition, options.tabCount);
+    if (!result.recognizedAny) {
+        return false;
+    }
+    if (result.attrs) {
+        options.pending.attrs = mergeBlockAttributes(options.pending.attrs, result.attrs);
+    }
+    if (result.foldNext) {
+        options.pending.foldNext = true;
+    }
+    if (result.tagName) {
+        options.pending.tagName = result.tagName;
+    }
+    if (result.isComment) {
+        options.pending.isComment = true;
+    }
+    if (result.isDisabled) {
+        options.pending.isDisabled = true;
+    }
+    if (result.isSheet) {
+        options.pending.isSheet = true;
+    }
+    if (result.isHtml) {
+        options.pending.isHtml = true;
+    }
+    return true;
+}
+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 mapTabsToPosition(tabCount) {
+    if (tabCount === 0) {
+        return 'L';
+    }
+    if (tabCount === 1) {
+        return 'C';
+    }
+    if (tabCount >= 2) {
+        return 'R';
+    }
+    return undefined;
+}
+function shiftPositionRight(position) {
+    if (position === 'L') {
+        return 'C';
+    }
+    if (position === 'C') {
+        return 'R';
+    }
+    if (position === 'R') {
+        return 'R';
+    }
+    return 'C';
+}

package/dist/core/block/rules/code-block.d.ts

@@ -0,0 +1,2 @@
+import { BlockRuleContext } from './types';
+export declare function tryParseCodeBlock(ctx: BlockRuleContext): number | null;

package/dist/core/block/rules/code-block.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseCodeBlock = tryParseCodeBlock;
+const diagnostics_1 = require("../../diagnostics");
+const location_1 = require("../../location");
+const lexer_1 = require("../../../lexer/lexer");
+const code_fence_1 = require("./code-fence");
+function tryParseCodeBlock(ctx) {
+    const codeFenceStart = (0, code_fence_1.matchCodeFenceStart)(ctx.trimmedContent);
+    const attrCodeFenceStart = codeFenceStart ? null : (0, code_fence_1.matchAttributedCodeFence)(ctx.trimmedContent);
+    const effectiveCodeFence = codeFenceStart || attrCodeFenceStart;
+    if (!effectiveCodeFence) {
+        return null;
+    }
+    const rawLines = [ctx.lineInfo.raw];
+    const codeLines = [];
+    const fenceIndent = ctx.lineInfo.tabCount;
+    let jCode = ctx.index + 1;
+    let closed = false;
+    while (jCode < ctx.lines.length) {
+        const nextRaw = ctx.lines[jCode];
+        if (nextRaw === undefined) {
+            jCode += 1;
+            continue;
+        }
+        const nextInfo = (0, lexer_1.getLineInfo)(nextRaw);
+        const nextTrimmed = nextInfo.content.trim();
+        if ((0, code_fence_1.isCodeFenceEnd)(nextTrimmed)) {
+            rawLines.push(nextInfo.raw);
+            closed = true;
+            jCode += 1;
+            break;
+        }
+        rawLines.push(nextInfo.raw);
+        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)(ctx.errors, {
+            message: 'Code block is not closed with ```',
+            line: ctx.index + 1,
+        });
+    }
+    const blockAttrs = ctx.buildBlockAttrs(ctx.lineInfo.tabCount);
+    const isHtmlBlock = ctx.pending.isHtml || (attrCodeFenceStart?.isHtml ?? false);
+    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 codeBlock = {
+            type: 'code',
+            language: effectiveCodeFence.language,
+            value: codeLines.join('\n'),
+            htmlLike: isHtmlBlock ? true : undefined,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(codeBlock, ctx.lineLocation);
+        block = codeBlock;
+    }
+    ctx.commitBlock(block, blockAttrs, { allowTag: !ctx.pending.isDisabled });
+    return jCode;
+}

package/dist/core/block/rules/code-fence.d.ts

@@ -0,0 +1,15 @@
+interface CodeFenceStartMatchResult {
+    language?: string;
+}
+export interface AttributedCodeFenceResult {
+    language?: string;
+    isHtml: boolean;
+}
+export declare function matchCodeFenceStart(trimmed: string): CodeFenceStartMatchResult | undefined;
+export declare function isCodeFenceEnd(trimmed: string): boolean;
+/**
+ * Match code fence with optional leading attributes like [html]```
+ * Returns the language and whether it's an HTML block
+ */
+export declare function matchAttributedCodeFence(trimmed: string): AttributedCodeFenceResult | undefined;
+export {};

package/dist/core/block/rules/code-fence.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchCodeFenceStart = matchCodeFenceStart;
+exports.isCodeFenceEnd = isCodeFenceEnd;
+exports.matchAttributedCodeFence = matchAttributedCodeFence;
+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 };
+}

package/dist/core/block/rules/content-title.d.ts

@@ -0,0 +1,12 @@
+import { BlockNode } from '../../ast';
+import { BlockRuleContext } from './types';
+interface ContentTitleRuleContext extends BlockRuleContext {
+    blocks: BlockNode[];
+    resetPending: () => void;
+}
+interface ContentTitleMatchResult {
+    text: string;
+}
+export declare function tryParseContentTitleBlock(ctx: ContentTitleRuleContext): number | null;
+export declare function matchContentTitle(content: string): ContentTitleMatchResult | undefined;
+export {};

package/dist/core/block/rules/content-title.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseContentTitleBlock = tryParseContentTitleBlock;
+exports.matchContentTitle = matchContentTitle;
+const location_1 = require("../../location");
+function tryParseContentTitleBlock(ctx) {
+    const contentTitleMatch = matchContentTitle(ctx.lineInfo.content);
+    if (!contentTitleMatch) {
+        return null;
+    }
+    const text = contentTitleMatch.text;
+    let consumedByImageTitle = false;
+    if (canAttachToPreviousImage(ctx.pending)) {
+        const lastBlock = ctx.blocks[ctx.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) {
+        ctx.resetPending();
+        return ctx.index + 1;
+    }
+    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 contentTitle = {
+            type: 'contentTitle',
+            children: [{ type: 'text', value: text }],
+        };
+        (0, location_1.setNodeLocation)(contentTitle, ctx.lineLocation);
+        block = contentTitle;
+    }
+    ctx.commitBlock(block, blockAttrs);
+    return ctx.index + 1;
+}
+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 canAttachToPreviousImage(pending) {
+    return (!pending.attrs &&
+        !pending.foldNext &&
+        !pending.tagName &&
+        !pending.isComment &&
+        !pending.isDisabled &&
+        !pending.isSheet &&
+        !pending.isHtml);
+}

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

@@ -0,0 +1,9 @@
+import { BlockNode } from '../../ast';
+import { ParseError } from '../../errors';
+import { BlockRuleContext } from './types';
+interface FootnotesRuleContext extends BlockRuleContext {
+    parseBlocks: (source: string, errors: ParseError[]) => BlockNode[];
+}
+export declare function tryParseFootnotesBlock(ctx: FootnotesRuleContext): number | null;
+export declare function isFootnotesLine(trimmed: string): boolean;
+export {};

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 {};