@jianwen-lang/parser 0.1.1

package/dist/core/ast.js

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

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

@@ -0,0 +1,9 @@
+import { BlockRule } from './types';
+interface HeadingMatchResult {
+    level: 1 | 2 | 3 | 4 | 5;
+    foldable?: boolean;
+    text: string;
+}
+export declare function matchHeading(content: string): HeadingMatchResult | undefined;
+export declare const tryParseHeading: BlockRule;
+export {};

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseHeading = void 0;
+exports.matchHeading = matchHeading;
+const location_1 = require("../../location");
+function matchHeading(content) {
+    const foldableMatch = content.match(/^(#{1,5})\+\s+(.+)$/);
+    if (foldableMatch) {
+        const hashes = foldableMatch[1];
+        const textGroup = foldableMatch[2];
+        if (hashes === undefined || textGroup === undefined) {
+            return undefined;
+        }
+        const text = textGroup.trimEnd();
+        const level = hashes.length;
+        return { level, foldable: true, text };
+    }
+    const normalMatch = content.match(/^(#{1,5})\s+(.+)$/);
+    if (!normalMatch) {
+        return undefined;
+    }
+    const hashes = normalMatch[1];
+    const textGroup = normalMatch[2];
+    if (hashes === undefined || textGroup === undefined) {
+        return undefined;
+    }
+    const text = textGroup.trimEnd();
+    const level = hashes.length;
+    return { level, text };
+}
+const tryParseHeading = (ctx) => {
+    const headingMatch = matchHeading(ctx.lineInfo.content);
+    if (!headingMatch) {
+        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;
+        ctx.commitBlock(block, blockAttrs, {
+            allowTag: false,
+            postResetPending: (pending) => {
+                if (headingMatch.foldable) {
+                    pending.foldNext = true;
+                }
+            },
+        });
+    }
+    else {
+        const heading = {
+            type: 'heading',
+            level: headingMatch.level,
+            foldable: headingMatch.foldable,
+            children: [{ type: 'text', value: headingMatch.text }],
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(heading, ctx.lineLocation);
+        block = heading;
+        ctx.commitBlock(block, blockAttrs, {
+            postResetPending: (pending) => {
+                if (headingMatch.foldable) {
+                    pending.foldNext = true;
+                }
+            },
+        });
+    }
+    return ctx.index + 1;
+};
+exports.tryParseHeading = tryParseHeading;

package/dist/core/block/rules/horizontal-rule.d.ts

@@ -0,0 +1,9 @@
+import { ColorAttribute, HorizontalRuleBlock } from '../../ast';
+import { BlockRule } from './types';
+interface HorizontalRuleMatchResult {
+    style: HorizontalRuleBlock['style'];
+    colorAttr?: ColorAttribute;
+}
+export declare function matchHorizontalRule(trimmed: string): HorizontalRuleMatchResult | undefined;
+export declare const tryParseHorizontalRule: BlockRule;
+export {};

package/dist/core/block/rules/horizontal-rule.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseHorizontalRule = void 0;
+exports.matchHorizontalRule = matchHorizontalRule;
+const location_1 = require("../../location");
+function parseColorAttribute(token) {
+    const text = token.trim();
+    if (text.length === 0) {
+        return undefined;
+    }
+    if (text.startsWith('#')) {
+        return { kind: 'hex', value: text };
+    }
+    return { kind: 'preset', value: text };
+}
+function matchHorizontalRule(trimmed) {
+    let rest = trimmed;
+    let colorAttr;
+    if (rest.startsWith('[')) {
+        const end = rest.indexOf(']');
+        if (end !== -1) {
+            const inside = rest.slice(1, end).trim();
+            const parsedColor = parseColorAttribute(inside);
+            if (parsedColor) {
+                colorAttr = parsedColor;
+                rest = rest.slice(end + 1).trim();
+            }
+        }
+    }
+    if (rest.length < 5) {
+        return undefined;
+    }
+    const ch = rest[0];
+    if (ch !== '-' && ch !== '*' && ch !== '=' && ch !== '~') {
+        return undefined;
+    }
+    for (let i = 1; i < rest.length; i += 1) {
+        if (rest[i] !== ch) {
+            return undefined;
+        }
+    }
+    let style;
+    if (ch === '-') {
+        style = 'solid';
+    }
+    else if (ch === '*') {
+        style = 'dashed';
+    }
+    else if (ch === '=') {
+        style = 'bold';
+    }
+    else {
+        style = 'wavy';
+    }
+    return { style, colorAttr };
+}
+const tryParseHorizontalRule = (ctx) => {
+    const hrMatch = matchHorizontalRule(ctx.trimmedContent);
+    if (!hrMatch) {
+        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;
+        ctx.commitBlock(block, blockAttrs, { allowTag: false });
+    }
+    else {
+        const hr = {
+            type: 'hr',
+            style: hrMatch.style,
+            colorAttr: hrMatch.colorAttr,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(hr, ctx.lineLocation);
+        block = hr;
+        ctx.commitBlock(block, blockAttrs);
+    }
+    return ctx.index + 1;
+};
+exports.tryParseHorizontalRule = tryParseHorizontalRule;

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

@@ -0,0 +1,9 @@
+import { IncludeBlock } from '../../ast';
+import { BlockRule } from './types';
+interface IncludeMatchResult {
+    mode: IncludeBlock['mode'];
+    target: string;
+}
+export declare function matchInclude(content: string): IncludeMatchResult | undefined;
+export declare const tryParseInclude: BlockRule;
+export {};

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseInclude = void 0;
+exports.matchInclude = matchInclude;
+const location_1 = require("../../location");
+function matchInclude(content) {
+    const trimmed = content.trim();
+    const fileMatch = trimmed.match(/^\[@\]\(([^)]+)\)\s*$/);
+    if (fileMatch) {
+        const pathGroup = fileMatch[1];
+        if (!pathGroup) {
+            return undefined;
+        }
+        const target = pathGroup.trim();
+        if (target.length === 0) {
+            return undefined;
+        }
+        return { mode: 'file', target };
+    }
+    const tagMatch = trimmed.match(/^\[@=([^\]]+)\]\s*$/);
+    if (tagMatch) {
+        const nameGroup = tagMatch[1];
+        if (!nameGroup) {
+            return undefined;
+        }
+        const target = nameGroup.trim();
+        if (target.length === 0) {
+            return undefined;
+        }
+        return { mode: 'tag', target };
+    }
+    return undefined;
+}
+const tryParseInclude = (ctx) => {
+    const includeMatch = matchInclude(ctx.lineInfo.content);
+    if (!includeMatch) {
+        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;
+        ctx.commitBlock(block, blockAttrs, { allowTag: false });
+    }
+    else {
+        const includeBlock = {
+            type: 'include',
+            mode: includeMatch.mode,
+            target: includeMatch.target,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(includeBlock, ctx.lineLocation);
+        block = includeBlock;
+        ctx.commitBlock(block, blockAttrs);
+    }
+    return ctx.index + 1;
+};
+exports.tryParseInclude = tryParseInclude;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseBlockRules = tryParseBlockRules;
+const include_1 = require("./include");
+const heading_1 = require("./heading");
+const horizontal_rule_1 = require("./horizontal-rule");
+const BLOCK_RULES = [include_1.tryParseInclude, heading_1.tryParseHeading, horizontal_rule_1.tryParseHorizontalRule];
+function tryParseBlockRules(ctx) {
+    for (const rule of BLOCK_RULES) {
+        const nextIndex = rule(ctx);
+        if (nextIndex !== null) {
+            return nextIndex;
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,21 @@
+import { BlockAttributes, BlockNode } from '../../ast';
+import { ParseError } from '../../errors';
+import { SourceLocation } from '../../location';
+import { PendingBlockContext } from '../types';
+import { LineInfo } from '../../../lexer/lexer';
+export interface CommitBlockOptions {
+    allowTag?: boolean;
+    postResetPending?: (pending: PendingBlockContext) => void;
+}
+export interface BlockRuleContext {
+    lines: string[];
+    index: number;
+    lineInfo: LineInfo;
+    trimmedContent: string;
+    lineLocation: SourceLocation;
+    pending: PendingBlockContext;
+    errors: ParseError[];
+    buildBlockAttrs: (tabCount: number) => BlockAttributes | undefined;
+    commitBlock: (block: BlockNode, blockAttrs: BlockAttributes | undefined, options?: CommitBlockOptions) => void;
+}
+export type BlockRule = (ctx: BlockRuleContext) => number | null;

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

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

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

@@ -0,0 +1,10 @@
+import { BlockAttributes } from '../ast';
+export interface PendingBlockContext {
+    attrs?: BlockAttributes;
+    foldNext: boolean;
+    tagName?: string;
+    isComment: boolean;
+    isDisabled: boolean;
+    isSheet: boolean;
+    isHtml: boolean;
+}

package/dist/core/block/types.js

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

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

@@ -0,0 +1,3 @@
+import { BlockNode } from './ast';
+import { ParseError } from './errors';
+export declare function parseBlocks(source: string, errors: ParseError[]): BlockNode[];