@jianwen-lang/parser 0.1.1

package/dist/core/parser.js

@@ -0,0 +1,423 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJianwen = parseJianwen;
+exports.parseJianwenWithErrors = parseJianwenWithErrors;
+const diagnostics_1 = require("./diagnostics");
+const block_parser_1 = require("./block-parser");
+const inline_parser_1 = require("./inline-parser");
+const location_1 = require("./location");
+const clone_1 = require("./clone");
+const traverse_1 = require("./traverse");
+function parseJianwen(source, options = {}) {
+    return parseJianwenWithErrors(source, options).ast;
+}
+function parseJianwenWithErrors(source, options = {}) {
+    const errors = [];
+    const { meta, body } = parseInitializationTemplate(source);
+    const blocks = (0, block_parser_1.parseBlocks)(body, errors);
+    applyInlineParsing(blocks, errors);
+    const ast = {
+        type: 'document',
+        source,
+        meta,
+        children: blocks,
+    };
+    postProcessDocument(ast, options, errors);
+    return { ast, errors };
+}
+function parseInitializationTemplate(source) {
+    const lines = source.split('\n');
+    let start = -1;
+    let end = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line !== undefined && isTemplateBoundaryLine(line)) {
+            start = i;
+            break;
+        }
+    }
+    if (start === -1) {
+        return { body: source };
+    }
+    for (let i = start + 1; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line !== undefined && isTemplateBoundaryLine(line)) {
+            end = i;
+            break;
+        }
+    }
+    if (end === -1) {
+        return { body: source };
+    }
+    const meta = {};
+    for (let i = start + 1; i < end; i += 1) {
+        const line = lines[i];
+        if (line === undefined) {
+            continue;
+        }
+        const bracketIndex = line.indexOf('[');
+        if (bracketIndex === -1) {
+            continue;
+        }
+        const segment = line.slice(bracketIndex);
+        const pattern = /\[([^\]]+?)\]=([^[]*)/g;
+        let match;
+        while ((match = pattern.exec(segment)) !== null) {
+            const rawKey = match[1];
+            const rawValue = match[2];
+            if (rawKey === undefined || rawValue === undefined) {
+                continue;
+            }
+            const key = rawKey.trim();
+            const value = rawValue.trim();
+            applyMetaKey(meta, key, value);
+        }
+    }
+    const bodyLines = lines.slice(0, start).concat(lines.slice(end + 1));
+    const body = bodyLines.join('\n');
+    if (isMetaEmpty(meta)) {
+        return { body };
+    }
+    return { meta, body };
+}
+function isTemplateBoundaryLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+        return false;
+    }
+    for (let i = 0; i < trimmed.length; i += 1) {
+        if (trimmed[i] !== '_') {
+            return false;
+        }
+    }
+    return true;
+}
+function applyMetaKey(meta, key, rawValue) {
+    const value = rawValue.trim();
+    if (key === 'title') {
+        if (value.length > 0) {
+            meta.title = value;
+        }
+        return;
+    }
+    if (key === 'author') {
+        if (value.length > 0) {
+            const match = /^(.*)\(([^)]+)\)$/.exec(value);
+            if (match && match[1] !== undefined && match[2] !== undefined) {
+                meta.author = match[1].trim();
+                meta.authorUrl = match[2].trim();
+            }
+            else {
+                meta.author = value;
+            }
+        }
+        return;
+    }
+    if (key === 'author_url') {
+        if (value.length > 0) {
+            meta.authorUrl = value;
+        }
+        return;
+    }
+    if (key === 'time') {
+        if (value.length > 0) {
+            meta.time = value;
+        }
+        return;
+    }
+    if (key === 'add_info') {
+        if (value.length > 0) {
+            meta.addInfo = value;
+        }
+        return;
+    }
+    if (key === 'tag(s)') {
+        if (value.length === 0) {
+            return;
+        }
+        const parts = value.split(',');
+        const tags = [];
+        for (const part of parts) {
+            const t = part.trim();
+            if (t.length > 0) {
+                tags.push(t);
+            }
+        }
+        if (tags.length > 0) {
+            meta.tags = tags;
+        }
+        return;
+    }
+    if (key === 'global_font') {
+        if (value.length === 0) {
+            return;
+        }
+        const parts = value.split(',');
+        const fonts = [];
+        for (const part of parts) {
+            const f = part.trim();
+            if (f === 'italic' ||
+                f === 'bold' ||
+                f === 'heavy' ||
+                f === 'slim' ||
+                f === 'serif' ||
+                f === 'mono') {
+                fonts.push(f);
+            }
+        }
+        if (fonts.length > 0) {
+            meta.globalFont = fonts;
+        }
+        return;
+    }
+}
+function isMetaEmpty(meta) {
+    if (meta.title)
+        return false;
+    if (meta.author)
+        return false;
+    if (meta.authorUrl)
+        return false;
+    if (meta.time)
+        return false;
+    if (meta.addInfo)
+        return false;
+    if (meta.tags && meta.tags.length > 0)
+        return false;
+    if (meta.globalFont && meta.globalFont.length > 0)
+        return false;
+    return true;
+}
+function getInlineBasePosition(node) {
+    const loc = (0, location_1.getNodeLocation)(node);
+    return { line: loc?.line ?? 1, column: loc?.column ?? 1 };
+}
+function applyInlineParsing(blocks, errors) {
+    (0, traverse_1.forEachInlineContainerInBlocks)(blocks, (children, owner) => {
+        const text = collectInlineSource(children);
+        if (text.length === 0) {
+            return;
+        }
+        const base = getInlineBasePosition(owner);
+        const parsed = (0, inline_parser_1.parseInlines)(text, errors, base.line, base.column);
+        if (owner && typeof owner === 'object' && 'children' in owner) {
+            owner.children = parsed;
+        }
+    });
+}
+function collectInlineSource(children) {
+    let result = '';
+    for (const child of children) {
+        if (child.type === 'text') {
+            result += child.value;
+        }
+    }
+    return result;
+}
+function postProcessDocument(document, options, errors) {
+    if (options.expandInclude) {
+        const tagIndex = buildTagIndex(document.children);
+        const context = {
+            stack: [],
+            maxDepth: typeof options.includeMaxDepth === 'number' ? options.includeMaxDepth : 16,
+            loadFile: options.loadFile,
+            tagIndex,
+            fileCache: new Map(),
+        };
+        document.children = expandIncludesInBlocks(document.children, document, options, errors, context);
+    }
+    checkFootnotes(document, errors);
+}
+function buildTagIndex(blocks) {
+    const index = new Map();
+    for (const block of blocks) {
+        if (block.type === 'taggedBlock') {
+            if (!index.has(block.name)) {
+                index.set(block.name, block);
+            }
+        }
+    }
+    return index;
+}
+function expandIncludesInBlocks(blocks, document, options, errors, context) {
+    const result = [];
+    for (const block of blocks) {
+        if (block.type === 'include') {
+            const expanded = expandSingleInclude(block, document, options, errors, context);
+            if (expanded && expanded.length > 0) {
+                for (const b of expanded) {
+                    result.push(b);
+                }
+            }
+            else {
+                result.push(block);
+            }
+            continue;
+        }
+        if (block.type === 'quote') {
+            const children = expandIncludesInBlocks(block.children, document, options, errors, context);
+            result.push({ ...block, children });
+            continue;
+        }
+        if (block.type === 'list') {
+            const items = block.children.map((item) => {
+                const itemChildren = expandIncludesInBlocks(item.children, document, options, errors, context);
+                return { ...item, children: itemChildren };
+            });
+            result.push({ ...block, children: items });
+            continue;
+        }
+        if (block.type === 'footnotes') {
+            const defs = block.children.map((def) => {
+                const defChildren = expandIncludesInBlocks(def.children, document, options, errors, context);
+                return { ...def, children: defChildren };
+            });
+            result.push({ ...block, children: defs });
+            continue;
+        }
+        if (block.type === 'footnoteDef') {
+            const children = expandIncludesInBlocks(block.children, document, options, errors, context);
+            result.push({ ...block, children });
+            continue;
+        }
+        if (block.type === 'commentBlock') {
+            const children = expandIncludesInBlocks(block.children, document, options, errors, context);
+            result.push({ ...block, children });
+            continue;
+        }
+        result.push(block);
+    }
+    return result;
+}
+function expandSingleInclude(block, document, options, errors, context) {
+    if (block.type !== 'include') {
+        return undefined;
+    }
+    const includeLoc = (0, location_1.getNodeLocation)(block);
+    const includeLine = includeLoc?.line ?? 1;
+    const includeColumn = includeLoc?.column;
+    if (block.mode === 'tag') {
+        const taggedFromIndex = context.tagIndex.get(block.target);
+        const tagged = taggedFromIndex ?? findTaggedBlock(document.children, block.target);
+        if (!tagged) {
+            (0, diagnostics_1.reportParseWarning)(errors, {
+                message: `Include tag target "${block.target}" not found`,
+                line: includeLine,
+                column: includeColumn,
+            });
+            return [block];
+        }
+        const cloned = (0, clone_1.cloneBlock)(tagged.child);
+        return [cloned];
+    }
+    if (context.stack.length >= context.maxDepth) {
+        (0, diagnostics_1.reportParseWarning)(errors, {
+            message: `Include max depth ${context.maxDepth} exceeded for target "${block.target}"`,
+            line: includeLine,
+            column: includeColumn,
+        });
+        return [block];
+    }
+    if (context.stack.indexOf(block.target) !== -1) {
+        (0, diagnostics_1.reportParseWarning)(errors, {
+            message: `Include cycle detected for target "${block.target}"`,
+            line: includeLine,
+            column: includeColumn,
+        });
+        return [block];
+    }
+    if (!context.loadFile) {
+        (0, diagnostics_1.reportParseWarning)(errors, {
+            message: `IncludeBlock with mode "file" requires loadFile option to expand target "${block.target}"`,
+            line: includeLine,
+            column: includeColumn,
+        });
+        return [block];
+    }
+    const cached = context.fileCache.get(block.target);
+    if (cached) {
+        for (const e of cached.errors) {
+            errors.push((0, diagnostics_1.prefixIncludeError)(e, block.target));
+        }
+        return cached.ast.children.map((child) => (0, clone_1.cloneBlock)(child, { origin: block.target }));
+    }
+    const nextStack = context.stack.concat(block.target);
+    const source = context.loadFile(block.target, nextStack);
+    if (source === undefined) {
+        (0, diagnostics_1.reportParseWarning)(errors, {
+            message: `Include target "${block.target}" could not be loaded`,
+            line: includeLine,
+            column: includeColumn,
+        });
+        return [block];
+    }
+    const childResult = parseJianwenWithErrors(source, {
+        ...options,
+        expandInclude: true,
+        loadFile: undefined,
+    });
+    context.fileCache.set(block.target, childResult);
+    for (const e of childResult.errors) {
+        errors.push((0, diagnostics_1.prefixIncludeError)(e, block.target));
+    }
+    return childResult.ast.children.map((child) => (0, clone_1.cloneBlock)(child, { origin: block.target }));
+}
+function findTaggedBlock(blocks, name) {
+    for (const block of blocks) {
+        if (block.type === 'taggedBlock' && block.name === name) {
+            return block;
+        }
+    }
+    return undefined;
+}
+function checkFootnotes(document, errors) {
+    const defsById = new Map();
+    collectFootnoteDefs(document.children, defsById);
+    const referencedIds = new Map();
+    collectFootnoteRefsInBlocks(document.children, referencedIds);
+    for (const [id, location] of referencedIds) {
+        if (!defsById.has(id)) {
+            const originSuffix = location.origin ? ` (from include "${location.origin}")` : '';
+            (0, diagnostics_1.reportParseWarning)(errors, {
+                message: `Footnote reference "${id}" has no corresponding FootnoteDefBlock${originSuffix}`,
+                line: location.line,
+                column: location.column,
+            });
+        }
+    }
+}
+function collectFootnoteDefs(blocks, defsById) {
+    (0, traverse_1.forEachBlock)(blocks, (block) => {
+        if (block.type !== 'footnoteDef') {
+            return;
+        }
+        let list = defsById.get(block.id);
+        if (!list) {
+            list = [];
+            defsById.set(block.id, list);
+        }
+        list.push(block);
+    });
+}
+function collectFootnoteRefsInBlocks(blocks, referencedIds) {
+    (0, traverse_1.forEachInlineContainerInBlocks)(blocks, (nodes) => {
+        collectFootnoteRefsInInlines(nodes, referencedIds);
+    });
+}
+function collectFootnoteRefsInInlines(nodes, referencedIds) {
+    (0, traverse_1.walkInlines)(nodes, (node) => {
+        if (node.type !== 'footnoteRef') {
+            return;
+        }
+        if (referencedIds.has(node.id)) {
+            return;
+        }
+        const loc = (0, location_1.getNodeLocation)(node);
+        const origin = (0, location_1.getNodeOrigin)(node);
+        referencedIds.set(node.id, {
+            line: loc?.line ?? 1,
+            column: loc?.column,
+            origin,
+        });
+    });
+}

package/dist/core/traverse.d.ts

@@ -0,0 +1,7 @@
+import { BlockNode, InlineNode } from './ast';
+export type BlockVisitor = (block: BlockNode) => void;
+export declare function forEachBlock(blocks: BlockNode[], visit: BlockVisitor): void;
+export type InlineContainerVisitor = (nodes: InlineNode[], owner: object) => void;
+export declare function forEachInlineContainerInBlocks(blocks: BlockNode[], visit: InlineContainerVisitor): void;
+export type InlineVisitor = (node: InlineNode) => void;
+export declare function walkInlines(nodes: InlineNode[], visit: InlineVisitor): void;

package/dist/core/traverse.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachBlock = forEachBlock;
+exports.forEachInlineContainerInBlocks = forEachInlineContainerInBlocks;
+exports.walkInlines = walkInlines;
+function forEachBlock(blocks, visit) {
+    for (const block of blocks) {
+        visit(block);
+        if (block.type === 'taggedBlock') {
+            forEachBlock([block.child], visit);
+            continue;
+        }
+        if (block.type === 'quote') {
+            forEachBlock(block.children, visit);
+            continue;
+        }
+        if (block.type === 'list') {
+            forEachBlock(block.children, visit);
+            continue;
+        }
+        if (block.type === 'listItem') {
+            forEachBlock(block.children, visit);
+            continue;
+        }
+        if (block.type === 'footnotes') {
+            forEachBlock(block.children, visit);
+            continue;
+        }
+        if (block.type === 'footnoteDef') {
+            forEachBlock(block.children, visit);
+            continue;
+        }
+        if (block.type === 'commentBlock') {
+            forEachBlock(block.children, visit);
+            continue;
+        }
+    }
+}
+function forEachInlineContainerInBlocks(blocks, visit) {
+    forEachBlock(blocks, (block) => {
+        if (block.type === 'paragraph' || block.type === 'heading' || block.type === 'contentTitle') {
+            visit(block.children, block);
+            return;
+        }
+        if (block.type === 'table') {
+            for (const row of block.rows) {
+                for (const cell of row.cells) {
+                    visit(cell.children, cell);
+                }
+            }
+        }
+    });
+}
+function walkInlines(nodes, visit) {
+    for (const node of nodes) {
+        visit(node);
+        if (node.type === 'em' ||
+            node.type === 'strong' ||
+            node.type === 'underline' ||
+            node.type === 'strike' ||
+            node.type === 'wave' ||
+            node.type === 'sup' ||
+            node.type === 'sub' ||
+            node.type === 'highlight' ||
+            node.type === 'link' ||
+            node.type === 'commentInline' ||
+            node.type === 'inlineAttrs') {
+            walkInlines(node.children, visit);
+        }
+    }
+}

package/dist/html/convert.d.ts

@@ -0,0 +1,29 @@
+import { ParseOptions } from '../core/parser';
+import { JianwenDocument } from '../core/ast';
+import { ParseError } from '../core/errors';
+import { RenderHtmlOptions } from './render/utils';
+export declare const DEFAULT_RUNTIME_SRC = "dist/html/theme/runtime.js";
+export interface HtmlDocumentOptions {
+    title?: string;
+    lang?: string;
+    charset?: string;
+    headHtml?: string;
+    includeCss?: boolean;
+    cssText?: string;
+    cssHref?: string;
+    includeRuntime?: boolean;
+    runtimeSrc?: string;
+    format?: boolean;
+}
+export interface RenderJianwenToHtmlDocumentOptions {
+    parse?: ParseOptions;
+    render?: RenderHtmlOptions;
+    document?: HtmlDocumentOptions;
+}
+export interface RenderJianwenToHtmlDocumentResult {
+    html: string;
+    ast: JianwenDocument;
+    errors: ParseError[];
+}
+export declare function buildHtmlDocument(bodyHtml: string, options?: HtmlDocumentOptions): string;
+export declare function renderJianwenToHtmlDocument(source: string, options?: RenderJianwenToHtmlDocumentOptions): RenderJianwenToHtmlDocumentResult;

package/dist/html/convert.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RUNTIME_SRC = void 0;
+exports.buildHtmlDocument = buildHtmlDocument;
+exports.renderJianwenToHtmlDocument = renderJianwenToHtmlDocument;
+const parser_1 = require("../core/parser");
+const format_1 = require("./format");
+const html_1 = require("./render/html");
+const utils_1 = require("./render/utils");
+const theme_1 = require("./theme/theme");
+exports.DEFAULT_RUNTIME_SRC = 'dist/html/theme/runtime.js';
+function buildHtmlDocument(bodyHtml, options = {}) {
+    const lang = options.lang ?? 'zh-CN';
+    const charset = options.charset ?? 'utf-8';
+    const title = options.title ?? 'Jianwen';
+    const headParts = [];
+    headParts.push(`<meta charset="${(0, utils_1.escapeAttr)(charset)}">`);
+    headParts.push(`<title>${(0, utils_1.escapeHtml)(title)}</title>`);
+    const includeCss = options.includeCss ?? true;
+    if (includeCss) {
+        if (options.cssHref) {
+            headParts.push(`<link rel="stylesheet" href="${(0, utils_1.escapeAttr)(options.cssHref)}">`);
+        }
+        else {
+            const cssText = options.cssText ?? theme_1.DEFAULT_CSS;
+            headParts.push(`<style>${cssText}</style>`);
+        }
+    }
+    if (options.headHtml) {
+        headParts.push(options.headHtml);
+    }
+    const runtimeHtml = options.includeRuntime && (options.runtimeSrc ?? exports.DEFAULT_RUNTIME_SRC)
+        ? `<script src="${(0, utils_1.escapeAttr)(options.runtimeSrc ?? exports.DEFAULT_RUNTIME_SRC)}"></script>`
+        : '';
+    const html = `<!DOCTYPE html>
+<html lang="${(0, utils_1.escapeAttr)(lang)}">
+<head>
+${headParts.join('\n')}
+</head>
+<body>
+${bodyHtml}
+${runtimeHtml}
+</body>
+</html>`;
+    return options.format ? (0, format_1.formatHtml)(html) : html;
+}
+function renderJianwenToHtmlDocument(source, options = {}) {
+    const parseResult = (0, parser_1.parseJianwenWithErrors)(source, options.parse);
+    const renderOptions = {
+        includeMeta: true,
+        includeComments: false,
+        ...options.render,
+    };
+    const bodyHtml = (0, html_1.renderDocumentToHtml)(parseResult.ast, renderOptions);
+    const title = options.document?.title ?? parseResult.ast.meta?.title;
+    const html = buildHtmlDocument(bodyHtml, {
+        ...options.document,
+        title,
+    });
+    return { html, ast: parseResult.ast, errors: parseResult.errors };
+}

package/dist/html/format.d.ts

@@ -0,0 +1 @@
+export declare function formatHtml(html: string): string;

package/dist/html/format.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHtml = formatHtml;
+const js_beautify_1 = require("js-beautify");
+const DEFAULT_HTML_FORMAT_OPTIONS = {
+    indent_size: 2,
+    indent_char: ' ',
+    indent_inner_html: true,
+    preserve_newlines: true,
+    max_preserve_newlines: 2,
+    wrap_line_length: 0,
+    content_unformatted: [],
+    end_with_newline: false,
+};
+function formatHtml(html) {
+    return (0, js_beautify_1.html)(html, DEFAULT_HTML_FORMAT_OPTIONS);
+}

package/dist/html/render/blocks.d.ts

@@ -0,0 +1,4 @@
+import { BlockNode } from '../../core/ast';
+import { RenderHtmlOptions } from './utils';
+export declare function renderBlocksToHtml(blocks: BlockNode[], options?: RenderHtmlOptions): string;
+export declare function renderBlockToHtml(block: BlockNode, options: RenderHtmlOptions): string;