@jianwen-lang/parser 0.1.1

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

@@ -0,0 +1,2 @@
+import { InlineRule } from './types';
+export declare const disabledRule: InlineRule;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disabledRule = void 0;
+const diagnostics_1 = require("../../diagnostics");
+exports.disabledRule = {
+    flushTextBefore: false,
+    parse(scanner, ctx) {
+        const startLine = scanner.line;
+        const startColumn = scanner.column;
+        const open = scanner.next();
+        if (open !== '{') {
+            return { kind: 'append', text: '' };
+        }
+        let content = '';
+        while (!scanner.eof()) {
+            const ch = scanner.peek();
+            if (ch === undefined) {
+                break;
+            }
+            if (ch === '}') {
+                scanner.next();
+                return { kind: 'append', text: content };
+            }
+            scanner.next();
+            content += ch;
+        }
+        (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+            message: 'Missing closing } for disabled inline segment',
+            line: startLine,
+            column: startColumn,
+        });
+        return { kind: 'append', text: `{${content}` };
+    },
+};

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

@@ -0,0 +1,2 @@
+import { InlineRule } from './types';
+export declare const escapeRule: InlineRule;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRule = void 0;
+exports.escapeRule = {
+    flushTextBefore: false,
+    parse(scanner) {
+        scanner.next();
+        const escaped = scanner.next();
+        return { kind: 'append', text: escaped ?? '' };
+    },
+};

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

@@ -0,0 +1,2 @@
+import { InlineRule } from './types';
+export declare function getInlineRuleForChar(ch: string): InlineRule | undefined;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInlineRuleForChar = getInlineRuleForChar;
+const backtick_1 = require("./backtick");
+const bracket_1 = require("./bracket");
+const disabled_1 = require("./disabled");
+const escape_1 = require("./escape");
+const marker_highlight_1 = require("./marker-highlight");
+const style_1 = require("./style");
+const INLINE_RULES_BY_FIRST_CHAR = {
+    '\\': escape_1.escapeRule,
+    '{': disabled_1.disabledRule,
+    '`': backtick_1.backtickRule,
+    '=': marker_highlight_1.markerHighlightRule,
+    '*': style_1.styleRule,
+    '/': style_1.styleRule,
+    _: style_1.styleRule,
+    '-': style_1.styleRule,
+    '~': style_1.styleRule,
+    '^': style_1.styleRule,
+    '[': bracket_1.bracketRule,
+};
+function getInlineRuleForChar(ch) {
+    return INLINE_RULES_BY_FIRST_CHAR[ch];
+}

package/dist/core/inline/rules/marker-highlight.d.ts

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

package/dist/core/inline/rules/marker-highlight.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markerHighlightRule = void 0;
+exports.readMarkerHighlight = readMarkerHighlight;
+const diagnostics_1 = require("../../diagnostics");
+function readMarkerHighlight(scanner, ctx) {
+    const startLine = scanner.line;
+    const startColumn = scanner.column;
+    const first = scanner.next();
+    if (first !== '=') {
+        return undefined;
+    }
+    const remaining = scanner.text.slice(scanner.index);
+    if (!remaining.includes('=')) {
+        return { type: 'text', value: '=' };
+    }
+    let content = '';
+    while (!scanner.eof()) {
+        const ch = scanner.peek();
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === '=') {
+            scanner.next();
+            if (content.length === 0) {
+                return { type: 'text', value: '==' };
+            }
+            const children = ctx.parseNested(content, startLine);
+            const node = {
+                type: 'highlight',
+                mode: 'marker',
+                children,
+            };
+            return node;
+        }
+        scanner.next();
+        content += ch;
+    }
+    (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+        message: 'Missing closing = for marker highlight',
+        line: startLine,
+        column: startColumn,
+    });
+    return { type: 'text', value: `=${content}` };
+}
+exports.markerHighlightRule = {
+    flushTextBefore: true,
+    parse(scanner, ctx) {
+        const node = readMarkerHighlight(scanner, ctx);
+        if (node) {
+            return { kind: 'emit', node };
+        }
+        const consumed = scanner.next();
+        return { kind: 'append', text: consumed ?? '' };
+    },
+};

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

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

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.styleRule = void 0;
+exports.readStyledSegment = readStyledSegment;
+const diagnostics_1 = require("../../diagnostics");
+function isAsciiWordChar(ch) {
+    if (!ch) {
+        return false;
+    }
+    return /[A-Za-z0-9]/.test(ch);
+}
+function shouldTreatMarkerAsLiteralWordSeparator(scanner, marker, markerStartIndex) {
+    if (marker !== '-' && marker !== '/' && marker !== '_' && marker !== '^') {
+        return false;
+    }
+    const prev = markerStartIndex > 0 ? scanner.text[markerStartIndex - 1] : undefined;
+    const next = markerStartIndex + 1 < scanner.length ? scanner.text[markerStartIndex + 1] : undefined;
+    return isAsciiWordChar(prev) && isAsciiWordChar(next);
+}
+function hasClosingDelimiterAhead(scanner, marker, expectDoubleCaret) {
+    const remaining = scanner.text.slice(scanner.index);
+    if (marker === '^' && expectDoubleCaret) {
+        return remaining.includes('^^');
+    }
+    return remaining.includes(marker);
+}
+function readStyledSegment(scanner, ctx) {
+    const startLine = scanner.line;
+    const startColumn = scanner.column;
+    const markerStartIndex = scanner.index;
+    const marker = scanner.next();
+    if (!marker) {
+        return undefined;
+    }
+    let styleType;
+    let expectDoubleCaret = false;
+    if (marker === '*') {
+        styleType = 'strong';
+    }
+    else if (marker === '/') {
+        styleType = 'em';
+    }
+    else if (marker === '_') {
+        styleType = 'underline';
+    }
+    else if (marker === '-') {
+        styleType = 'strike';
+    }
+    else if (marker === '~') {
+        styleType = 'wave';
+    }
+    else if (marker === '^') {
+        if (!scanner.eof() && scanner.peek() === '^') {
+            scanner.next();
+            styleType = 'sub';
+            expectDoubleCaret = true;
+        }
+        else {
+            styleType = 'sup';
+        }
+    }
+    if (!styleType) {
+        return undefined;
+    }
+    const openingToken = marker === '^' && expectDoubleCaret ? '^^' : marker;
+    if (shouldTreatMarkerAsLiteralWordSeparator(scanner, marker, markerStartIndex)) {
+        return { type: 'text', value: openingToken };
+    }
+    if (!hasClosingDelimiterAhead(scanner, marker, expectDoubleCaret)) {
+        if (marker === '-' || marker === '/' || marker === '_' || marker === '^') {
+            return { type: 'text', value: openingToken };
+        }
+    }
+    let content = '';
+    while (!scanner.eof()) {
+        const ch = scanner.peek();
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === marker || (marker === '^' && ch === '^')) {
+            if (marker === '^' && expectDoubleCaret) {
+                const saveIndex = scanner.index;
+                const firstCaret = scanner.next();
+                const secondCaret = scanner.peek();
+                if (firstCaret === '^' && secondCaret === '^') {
+                    scanner.next();
+                    const children = ctx.parseNested(content, startLine);
+                    const node = { type: styleType, children };
+                    return node;
+                }
+                scanner.index = saveIndex;
+            }
+            else {
+                scanner.next();
+                const children = ctx.parseNested(content, startLine);
+                const node = { type: styleType, children };
+                return node;
+            }
+        }
+        scanner.next();
+        content += ch;
+    }
+    (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+        message: 'Missing closing style delimiter',
+        line: startLine,
+        column: startColumn,
+    });
+    return { type: 'text', value: `${marker}${content}` };
+}
+exports.styleRule = {
+    flushTextBefore: true,
+    parse(scanner, ctx) {
+        const node = readStyledSegment(scanner, ctx);
+        if (node) {
+            return { kind: 'emit', node };
+        }
+        const consumed = scanner.next();
+        return { kind: 'append', text: consumed ?? '' };
+    },
+};

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

@@ -0,0 +1,22 @@
+import { InlineNode } from '../../ast';
+import { ParseError } from '../../errors';
+import { CharScanner } from '../../../lexer/lexer';
+export type InlineScanner = CharScanner;
+export interface InlineRuleContext {
+    errors: ParseError[];
+    parseNested: (text: string, baseLine: number) => InlineNode[];
+}
+export type InlineRuleResult = {
+    kind: 'append';
+    text: string;
+} | {
+    kind: 'emit';
+    node: InlineNode;
+} | {
+    kind: 'emitText';
+    text: string;
+};
+export interface InlineRule {
+    flushTextBefore: boolean;
+    parse: (scanner: InlineScanner, ctx: InlineRuleContext) => InlineRuleResult;
+}

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

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

package/dist/core/inline/types.d.ts

@@ -0,0 +1 @@
+export type InlineFontStyleKey = 'italic' | 'bold' | 'heavy' | 'slim' | 'serif' | 'mono';

package/dist/core/inline/types.js

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

package/dist/core/inline-parser.d.ts

@@ -0,0 +1,3 @@
+import { InlineNode } from './ast';
+import { ParseError } from './errors';
+export declare function parseInlines(text: string, errors: ParseError[], baseLine: number, baseColumn?: number): InlineNode[];

package/dist/core/inline-parser.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInlines = parseInlines;
+const lexer_1 = require("../lexer/lexer");
+const rules_1 = require("./inline/rules");
+function parseInlines(text, errors, baseLine, baseColumn = 1) {
+    const scanner = createScanner(text, baseLine, baseColumn);
+    const nodes = [];
+    let buffer = '';
+    const ctx = {
+        errors,
+        parseNested: (nestedText, nestedBaseLine) => parseInlines(nestedText, errors, nestedBaseLine),
+    };
+    function flushText() {
+        if (buffer.length === 0) {
+            return;
+        }
+        const node = { type: 'text', value: buffer };
+        nodes.push(node);
+        buffer = '';
+    }
+    while (!scanner.eof()) {
+        const ch = scanner.peek();
+        if (ch === undefined) {
+            break;
+        }
+        const rule = (0, rules_1.getInlineRuleForChar)(ch);
+        if (rule) {
+            if (rule.flushTextBefore) {
+                flushText();
+            }
+            const result = rule.parse(scanner, ctx);
+            if (result.kind === 'append') {
+                buffer += result.text;
+            }
+            else if (result.kind === 'emit') {
+                nodes.push(result.node);
+            }
+            else {
+                nodes.push({ type: 'text', value: result.text });
+            }
+            continue;
+        }
+        scanner.next();
+        buffer += ch;
+    }
+    flushText();
+    return nodes;
+}
+function createScanner(text, baseLine, baseColumn) {
+    return (0, lexer_1.createCharScanner)(text, baseLine, baseColumn);
+}

package/dist/core/location.d.ts

@@ -0,0 +1,9 @@
+export interface SourceLocation {
+    line: number;
+    column: number;
+}
+export type NodeOrigin = string;
+export declare function setNodeLocation(node: object, location: SourceLocation): void;
+export declare function getNodeLocation(node: object): SourceLocation | undefined;
+export declare function setNodeOrigin(node: object, origin: NodeOrigin): void;
+export declare function getNodeOrigin(node: object): NodeOrigin | undefined;

package/dist/core/location.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setNodeLocation = setNodeLocation;
+exports.getNodeLocation = getNodeLocation;
+exports.setNodeOrigin = setNodeOrigin;
+exports.getNodeOrigin = getNodeOrigin;
+const NODE_LOCATION = Symbol('jianwen.node.location');
+const NODE_ORIGIN = Symbol('jianwen.node.origin');
+function setNodeLocation(node, location) {
+    Object.defineProperty(node, NODE_LOCATION, {
+        value: location,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+}
+function getNodeLocation(node) {
+    return node[NODE_LOCATION];
+}
+function setNodeOrigin(node, origin) {
+    Object.defineProperty(node, NODE_ORIGIN, {
+        value: origin,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+}
+function getNodeOrigin(node) {
+    return node[NODE_ORIGIN];
+}

package/dist/core/parser.d.ts

@@ -0,0 +1,9 @@
+import { JianwenDocument } from './ast';
+import { ParseResult } from './errors';
+export interface ParseOptions {
+    expandInclude?: boolean;
+    includeMaxDepth?: number;
+    loadFile?: (path: string, fromStack: string[]) => string | undefined;
+}
+export declare function parseJianwen(source: string, options?: ParseOptions): JianwenDocument;
+export declare function parseJianwenWithErrors(source: string, options?: ParseOptions): ParseResult;