@jianwen-lang/parser 0.1.1

package/dist/core/clone.d.ts

@@ -0,0 +1,9 @@
+import { BlockNode } from './ast';
+export interface CloneOptions {
+    /**
+     * Override origin for the entire cloned subtree.
+     * Useful for blocks expanded from include(file) where line numbers belong to the included file.
+     */
+    origin?: string;
+}
+export declare function cloneBlock(block: BlockNode, options?: CloneOptions): BlockNode;

package/dist/core/clone.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneBlock = cloneBlock;
+const location_1 = require("./location");
+function cloneBlock(block, options = {}) {
+    return cloneValue(block, options);
+}
+function cloneValue(value, options) {
+    if (Array.isArray(value)) {
+        return value.map((item) => (item === undefined ? null : cloneValue(item, options)));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const inputObject = value;
+    const outputObject = {};
+    for (const [key, child] of Object.entries(inputObject)) {
+        if (child === undefined) {
+            continue;
+        }
+        outputObject[key] = cloneValue(child, options);
+    }
+    const location = (0, location_1.getNodeLocation)(value);
+    if (location) {
+        (0, location_1.setNodeLocation)(outputObject, location);
+    }
+    const origin = options.origin ?? (0, location_1.getNodeOrigin)(value);
+    if (origin) {
+        (0, location_1.setNodeOrigin)(outputObject, origin);
+    }
+    return outputObject;
+}

package/dist/core/diagnostics.d.ts

@@ -0,0 +1,12 @@
+import { ParseError } from './errors';
+export type ParseErrorSeverity = ParseError['severity'];
+export interface ParseErrorInput {
+    message: string;
+    line: number;
+    column?: number;
+    code?: string;
+}
+export declare function buildParseError(input: ParseErrorInput, severity: ParseErrorSeverity): ParseError;
+export declare function reportParseError(errors: ParseError[], input: ParseErrorInput): void;
+export declare function reportParseWarning(errors: ParseError[], input: ParseErrorInput): void;
+export declare function prefixIncludeError(error: ParseError, target: string): ParseError;

package/dist/core/diagnostics.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildParseError = buildParseError;
+exports.reportParseError = reportParseError;
+exports.reportParseWarning = reportParseWarning;
+exports.prefixIncludeError = prefixIncludeError;
+function buildParseError(input, severity) {
+    return {
+        message: input.message,
+        line: input.line,
+        column: input.column,
+        severity,
+        code: input.code,
+    };
+}
+function reportParseError(errors, input) {
+    errors.push(buildParseError(input, 'error'));
+}
+function reportParseWarning(errors, input) {
+    errors.push(buildParseError(input, 'warning'));
+}
+function prefixIncludeError(error, target) {
+    return { ...error, message: `[include:${target}] ${error.message}` };
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,12 @@
+import { JianwenDocument } from './ast';
+export interface ParseError {
+    message: string;
+    line: number;
+    column?: number;
+    severity: 'error' | 'warning';
+    code?: string;
+}
+export interface ParseResult {
+    ast: JianwenDocument;
+    errors: ParseError[];
+}

package/dist/core/errors.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/inline/rules/backtick.d.ts

@@ -0,0 +1,4 @@
+import { InlineNode } from '../../ast';
+import { InlineRule, InlineRuleContext, InlineScanner } from './types';
+export declare function readBacktickSegment(scanner: InlineScanner, ctx: InlineRuleContext): InlineNode | undefined;
+export declare const backtickRule: InlineRule;

package/dist/core/inline/rules/backtick.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backtickRule = void 0;
+exports.readBacktickSegment = readBacktickSegment;
+const diagnostics_1 = require("../../diagnostics");
+function readBacktickSegment(scanner, ctx) {
+    const startLine = scanner.line;
+    const startColumn = scanner.column;
+    let tickCount = 0;
+    while (!scanner.eof() && scanner.peek() === '`') {
+        scanner.next();
+        tickCount += 1;
+    }
+    if (tickCount === 0) {
+        return undefined;
+    }
+    if (tickCount === 1) {
+        let value = '';
+        while (!scanner.eof()) {
+            const ch = scanner.peek();
+            if (ch === undefined) {
+                break;
+            }
+            if (ch === '`') {
+                scanner.next();
+                return { type: 'codeSpan', value };
+            }
+            scanner.next();
+            value += ch;
+        }
+        (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+            message: 'Missing closing backtick for inline code span',
+            line: startLine,
+            column: startColumn,
+        });
+        return { type: 'text', value: `\`${value}` };
+    }
+    let content = '';
+    while (!scanner.eof()) {
+        const ch = scanner.peek();
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === '`') {
+            const saveIndex = scanner.index;
+            const saveLine = scanner.line;
+            const saveColumn = scanner.column;
+            let matched = true;
+            for (let i = 0; i < tickCount; i += 1) {
+                const c = scanner.peek();
+                if (c !== '`') {
+                    matched = false;
+                    break;
+                }
+                scanner.next();
+            }
+            if (matched) {
+                const children = ctx.parseNested(content, startLine);
+                const node = {
+                    type: 'highlight',
+                    mode: 'frame',
+                    children,
+                };
+                return node;
+            }
+            scanner.index = saveIndex;
+            scanner.line = saveLine;
+            scanner.column = saveColumn;
+        }
+        scanner.next();
+        content += ch;
+    }
+    (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+        message: 'Missing closing double backticks for frame highlight',
+        line: startLine,
+        column: startColumn,
+    });
+    return { type: 'text', value: `${'`'.repeat(tickCount)}${content}` };
+}
+exports.backtickRule = {
+    flushTextBefore: true,
+    parse(scanner, ctx) {
+        const node = readBacktickSegment(scanner, ctx);
+        if (node) {
+            return { kind: 'emit', node };
+        }
+        const consumed = scanner.next();
+        return { kind: 'append', text: consumed ?? '' };
+    },
+};

package/dist/core/inline/rules/bracket.d.ts

@@ -0,0 +1,4 @@
+import { InlineNode } from '../../ast';
+import { InlineRule, InlineRuleContext, InlineScanner } from './types';
+export declare function parseBracketExpression(scanner: InlineScanner, ctx: InlineRuleContext): InlineNode | string | undefined;
+export declare const bracketRule: InlineRule;