@jianwen-lang/parser 0.1.1

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

@@ -0,0 +1,721 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bracketRule = void 0;
+exports.parseBracketExpression = parseBracketExpression;
+const diagnostics_1 = require("../../diagnostics");
+const location_1 = require("../../location");
+const backtick_1 = require("./backtick");
+const marker_highlight_1 = require("./marker-highlight");
+const style_1 = require("./style");
+const INLINE_FONT_STYLE_KEYS = new Set([
+    'italic',
+    'bold',
+    'heavy',
+    'slim',
+    'serif',
+    'mono',
+]);
+const INLINE_FONT_STYLE_ALIASES = {
+    i: 'italic',
+    b: 'bold',
+    bb: 'heavy',
+};
+function splitInlineAttributeParts(inside) {
+    return inside
+        .split(',')
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+}
+function normalizeFontStyleKey(part) {
+    const alias = INLINE_FONT_STYLE_ALIASES[part];
+    if (alias) {
+        return alias;
+    }
+    if (INLINE_FONT_STYLE_KEYS.has(part)) {
+        return part;
+    }
+    return undefined;
+}
+function parseColorAttributeFromToken(token) {
+    const value = token.trim();
+    if (value.length === 0) {
+        return undefined;
+    }
+    if (/^#[0-9A-Fa-f]{3,8}$/.test(value)) {
+        return { kind: 'hex', value };
+    }
+    if (/^[A-Za-z][A-Za-z0-9_-]*$/.test(value)) {
+        return { kind: 'preset', value };
+    }
+    return undefined;
+}
+function parseShapeAttributeFromToken(token) {
+    const value = token.trim();
+    if (value === 'square') {
+        return { shape: 'square' };
+    }
+    if (value === 'rounded') {
+        return { shape: 'rounded' };
+    }
+    const roundedMatch = value.match(/^rounded=([0-9.]+)$/);
+    if (roundedMatch && roundedMatch[1]) {
+        const num = parseFloat(roundedMatch[1]);
+        if (!isNaN(num) && num > 0) {
+            return { shape: 'rounded', roundedRadius: num };
+        }
+    }
+    return undefined;
+}
+function hasInlineAttributes(attrs) {
+    return Boolean(attrs.color ||
+        attrs.secondaryColor ||
+        attrs.shape ||
+        attrs.roundedRadius !== undefined ||
+        attrs.fontSize ||
+        attrs.fontStyle);
+}
+function isInlineAttributeExpression(inside) {
+    const parts = splitInlineAttributeParts(inside);
+    if (parts.length === 0) {
+        return false;
+    }
+    for (const part of parts) {
+        if (part === '->' || part === '<-' || part === '<->') {
+            return false;
+        }
+    }
+    let hasRecognized = false;
+    for (const part of parts) {
+        if (part.length === 0) {
+            continue;
+        }
+        hasRecognized = true;
+        const asNumber = Number(part);
+        if (!Number.isNaN(asNumber)) {
+            if (asNumber >= 0.5 &&
+                asNumber <= 5 &&
+                Math.abs(asNumber * 2 - Math.round(asNumber * 2)) < 1e-6) {
+                continue;
+            }
+            return false;
+        }
+        const styleKey = normalizeFontStyleKey(part);
+        if (styleKey) {
+            continue;
+        }
+        if (part === 'square' || part === 'rounded' || part.startsWith('rounded=')) {
+            if (parseShapeAttributeFromToken(part)) {
+                continue;
+            }
+            return false;
+        }
+        if (part.startsWith('!')) {
+            if (parseColorAttributeFromToken(part.slice(1))) {
+                continue;
+            }
+            return false;
+        }
+        if (parseColorAttributeFromToken(part)) {
+            continue;
+        }
+        return false;
+    }
+    return hasRecognized;
+}
+function parseInlineAttributes(inside, errors, line, column) {
+    const parts = splitInlineAttributeParts(inside);
+    if (parts.length === 0) {
+        return undefined;
+    }
+    const attrs = {};
+    const fontStyles = [];
+    for (const part of parts) {
+        if (part.length === 0) {
+            continue;
+        }
+        if (part === '->' || part === '<-' || part === '<->') {
+            continue;
+        }
+        const asNumber = Number(part);
+        if (!Number.isNaN(asNumber)) {
+            const size = asNumber;
+            if (size >= 0.5 && size <= 5 && Math.abs(size * 2 - Math.round(size * 2)) < 1e-6) {
+                attrs.fontSize = size;
+            }
+            else {
+                (0, diagnostics_1.reportParseWarning)(errors, {
+                    message: `Invalid fontSize ${part} in inline attributes`,
+                    line,
+                    column,
+                });
+            }
+            continue;
+        }
+        const styleKey = normalizeFontStyleKey(part);
+        if (styleKey) {
+            fontStyles.push(styleKey);
+            continue;
+        }
+        if (part === 'square' || part === 'rounded' || part.startsWith('rounded=')) {
+            const shapeAttr = parseShapeAttributeFromToken(part);
+            if (shapeAttr) {
+                attrs.shape = shapeAttr.shape;
+                if (shapeAttr.roundedRadius !== undefined) {
+                    attrs.roundedRadius = shapeAttr.roundedRadius;
+                }
+            }
+            else if (part.startsWith('rounded=')) {
+                (0, diagnostics_1.reportParseWarning)(errors, {
+                    message: `Invalid rounded radius "${part}" in inline attributes`,
+                    line,
+                    column,
+                });
+            }
+            continue;
+        }
+        if (part.startsWith('!')) {
+            const color = parseColorAttributeFromToken(part.slice(1));
+            if (color) {
+                attrs.secondaryColor = color;
+            }
+            continue;
+        }
+        const color = parseColorAttributeFromToken(part);
+        if (color) {
+            attrs.color = color;
+            continue;
+        }
+    }
+    if (fontStyles.length > 0) {
+        attrs.fontStyle = fontStyles;
+    }
+    if (!attrs.color &&
+        !attrs.secondaryColor &&
+        !attrs.shape &&
+        attrs.roundedRadius === undefined &&
+        !attrs.fontSize &&
+        !attrs.fontStyle) {
+        return undefined;
+    }
+    return attrs;
+}
+function mergeInlineAttributes(base, next) {
+    const merged = { ...base };
+    if (next.color) {
+        merged.color = next.color;
+    }
+    if (next.secondaryColor) {
+        merged.secondaryColor = next.secondaryColor;
+    }
+    if (next.fontSize) {
+        merged.fontSize = next.fontSize;
+    }
+    if (next.fontStyle) {
+        const styles = [...(merged.fontStyle ?? [])];
+        for (const style of next.fontStyle) {
+            if (!styles.includes(style)) {
+                styles.push(style);
+            }
+        }
+        merged.fontStyle = styles;
+    }
+    if (next.shape) {
+        merged.shape = next.shape;
+    }
+    if (next.roundedRadius !== undefined) {
+        merged.roundedRadius = next.roundedRadius;
+    }
+    return merged;
+}
+function isInlineSymbol(ch) {
+    return (ch === '`' ||
+        ch === '=' ||
+        ch === '*' ||
+        ch === '/' ||
+        ch === '_' ||
+        ch === '-' ||
+        ch === '~' ||
+        ch === '^' ||
+        ch === '[');
+}
+function applyHighlightColorsFromAttrs(node, attrs) {
+    if (node.type !== 'highlight' || !attrs) {
+        return;
+    }
+    if (attrs.color) {
+        node.colorAttr = attrs.color;
+    }
+    if (attrs.secondaryColor) {
+        node.fillColorAttr = attrs.secondaryColor;
+    }
+    if (attrs.shape) {
+        node.shape = attrs.shape;
+    }
+    if (attrs.roundedRadius !== undefined) {
+        node.roundedRadius = attrs.roundedRadius;
+    }
+}
+function parseInlineAttrsNode(scanner, ctx, attrs, baseLine, startColumn, rawInside) {
+    let segment = '';
+    let closedBySlash = false;
+    let closedByLineBreak = false;
+    let closedByNextAttr = false;
+    while (!scanner.eof()) {
+        const ch = scanner.peek();
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === '\n') {
+            closedByLineBreak = true;
+            break;
+        }
+        if (ch === '[') {
+            const saveIndex = scanner.index;
+            const saveLine = scanner.line;
+            const saveColumn = scanner.column;
+            scanner.next();
+            const next1 = scanner.peek();
+            if (next1 === '/') {
+                scanner.next();
+                const next2 = scanner.peek();
+                if (next2 === ']') {
+                    scanner.next();
+                    closedBySlash = true;
+                    break;
+                }
+            }
+            else {
+                const rest = scanner.text.slice(scanner.index);
+                const closingOffset = rest.indexOf(']');
+                if (closingOffset !== -1) {
+                    const insideCandidate = rest.slice(0, closingOffset);
+                    if (isInlineAttributeExpression(insideCandidate)) {
+                        closedByNextAttr = true;
+                        scanner.index = saveIndex;
+                        scanner.line = saveLine;
+                        scanner.column = saveColumn;
+                        break;
+                    }
+                }
+            }
+            scanner.index = saveIndex;
+            scanner.line = saveLine;
+            scanner.column = saveColumn;
+        }
+        scanner.next();
+        segment += ch;
+    }
+    const endedByEof = scanner.eof();
+    if (!closedBySlash && !closedByLineBreak && !closedByNextAttr && !endedByEof) {
+        (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+            message: 'Missing closing [/] for inline attributes',
+            line: baseLine,
+            column: startColumn,
+        });
+        return `[${rawInside}]${segment}`;
+    }
+    const children = ctx.parseNested(segment, baseLine);
+    const node = {
+        type: 'inlineAttrs',
+        attrs,
+        children,
+    };
+    return node;
+}
+function parseLinkAfterLinkKeyword(scanner, ctx, startLine) {
+    let raw = '[link]';
+    let linkColor;
+    let underlineColor;
+    while (!scanner.eof()) {
+        const ch = scanner.peek();
+        if (ch !== '[') {
+            break;
+        }
+        const saveIndex = scanner.index;
+        const saveLine = scanner.line;
+        const saveColumn = scanner.column;
+        scanner.next();
+        let attrInside = '';
+        let attrClosed = false;
+        while (!scanner.eof()) {
+            const c = scanner.peek();
+            if (c === undefined) {
+                break;
+            }
+            if (c === ']') {
+                scanner.next();
+                attrClosed = true;
+                break;
+            }
+            scanner.next();
+            attrInside += c;
+        }
+        if (!attrClosed) {
+            (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+                message: 'Missing closing ] for link attribute',
+                line: saveLine,
+                column: saveColumn,
+            });
+            return `[link][${attrInside}`;
+        }
+        if (attrInside.length === 0) {
+            scanner.index = saveIndex;
+            scanner.line = saveLine;
+            scanner.column = saveColumn;
+            break;
+        }
+        const parts = attrInside
+            .split(',')
+            .map((p) => p.trim())
+            .filter((p) => p.length > 0);
+        let recognizedColor = false;
+        for (const part of parts) {
+            if (part.startsWith('!')) {
+                const color = parseColorAttributeFromToken(part.slice(1));
+                if (color) {
+                    underlineColor = color;
+                    recognizedColor = true;
+                }
+            }
+            else {
+                const color = parseColorAttributeFromToken(part);
+                if (color) {
+                    linkColor = color;
+                    recognizedColor = true;
+                }
+            }
+        }
+        if (!recognizedColor) {
+            scanner.index = saveIndex;
+            scanner.line = saveLine;
+            scanner.column = saveColumn;
+            break;
+        }
+        raw += `[${attrInside}]`;
+    }
+    let text = '';
+    while (!scanner.eof()) {
+        const ch = scanner.peek();
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === '(') {
+            break;
+        }
+        scanner.next();
+        text += ch;
+    }
+    const trimmedText = text.trim();
+    if (trimmedText.length === 0) {
+        return raw + text;
+    }
+    raw += text;
+    const next = scanner.peek();
+    if (next !== '(') {
+        (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+            message: 'Missing (url) after [link]text for inline link',
+            line: scanner.line,
+            column: scanner.column,
+        });
+        return raw;
+    }
+    scanner.next();
+    let url = '';
+    while (!scanner.eof()) {
+        const ch = scanner.peek();
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === ')') {
+            scanner.next();
+            break;
+        }
+        scanner.next();
+        url += ch;
+    }
+    const href = url.trim();
+    if (href.length === 0) {
+        (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+            message: 'Empty url in inline link',
+            line: scanner.line,
+            column: scanner.column,
+        });
+        return `${raw}()`;
+    }
+    raw += `(${url})`;
+    const children = ctx.parseNested(trimmedText, startLine);
+    const node = {
+        type: 'link',
+        href,
+        children,
+    };
+    const linkNode = node;
+    if (linkColor) {
+        linkNode.colorAttr = linkColor;
+    }
+    if (underlineColor) {
+        linkNode.underlineColorAttr = underlineColor;
+    }
+    return node;
+}
+function parseBracketExpression(scanner, ctx) {
+    const startLine = scanner.line;
+    const startColumn = scanner.column;
+    const open = scanner.next();
+    if (open !== '[') {
+        return undefined;
+    }
+    let inside = '';
+    let closed = false;
+    while (!scanner.eof()) {
+        const ch = scanner.peek();
+        if (ch === undefined) {
+            break;
+        }
+        if (ch === ']') {
+            scanner.next();
+            closed = true;
+            break;
+        }
+        scanner.next();
+        inside += ch;
+    }
+    if (!closed) {
+        (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+            message: 'Missing closing ] for bracket expression',
+            line: startLine,
+            column: startColumn,
+        });
+        return `[${inside}`;
+    }
+    if (inside.length === 0) {
+        return '[]';
+    }
+    if (inside.startsWith('fn:')) {
+        const id = inside.slice(3).trim();
+        if (id.length === 0) {
+            return `[${inside}]`;
+        }
+        const node = {
+            type: 'footnoteRef',
+            id,
+        };
+        (0, location_1.setNodeLocation)(node, { line: startLine, column: startColumn });
+        return node;
+    }
+    if (inside === 'comment') {
+        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;
+                scanner.next();
+                const next1 = scanner.peek();
+                if (next1 === '/') {
+                    scanner.next();
+                    const next2 = scanner.peek();
+                    if (next2 === ']') {
+                        scanner.next();
+                        const children = ctx.parseNested(content, startLine);
+                        const node = {
+                            type: 'commentInline',
+                            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 [/] for inline comment',
+            line: startLine,
+            column: startColumn,
+        });
+        return `[comment]${content}`;
+    }
+    if (inside === 'link') {
+        const linkNodeOrText = parseLinkAfterLinkKeyword(scanner, ctx, startLine);
+        if (linkNodeOrText) {
+            return linkNodeOrText;
+        }
+        return '[link]';
+    }
+    const attrs = parseInlineAttributes(inside, ctx.errors, startLine, startColumn);
+    if (attrs) {
+        let mergedAttrs = attrs;
+        let mergedRawInside = inside;
+        while (true) {
+            const nextCh = scanner.peek();
+            if (nextCh !== '[') {
+                break;
+            }
+            const saveIndex = scanner.index;
+            const saveLine = scanner.line;
+            const saveColumn = scanner.column;
+            scanner.next();
+            let attrInside = '';
+            let attrClosed = false;
+            while (!scanner.eof()) {
+                const ch = scanner.peek();
+                if (ch === undefined) {
+                    break;
+                }
+                if (ch === ']') {
+                    scanner.next();
+                    attrClosed = true;
+                    break;
+                }
+                scanner.next();
+                attrInside += ch;
+            }
+            if (!attrClosed) {
+                (0, diagnostics_1.reportParseWarning)(ctx.errors, {
+                    message: 'Missing closing ] for inline attributes',
+                    line: saveLine,
+                    column: saveColumn,
+                });
+                return `[${mergedRawInside}][${attrInside}`;
+            }
+            if (!isInlineAttributeExpression(attrInside)) {
+                scanner.index = saveIndex;
+                scanner.line = saveLine;
+                scanner.column = saveColumn;
+                break;
+            }
+            const nextAttrs = parseInlineAttributes(attrInside, ctx.errors, saveLine, saveColumn);
+            if (!nextAttrs) {
+                scanner.index = saveIndex;
+                scanner.line = saveLine;
+                scanner.column = saveColumn;
+                break;
+            }
+            mergedAttrs = mergeInlineAttributes(mergedAttrs, nextAttrs);
+            mergedRawInside += `][${attrInside}`;
+        }
+        const nextCh = scanner.peek();
+        if (nextCh !== undefined && isInlineSymbol(nextCh)) {
+            const symbol = nextCh;
+            let inner;
+            if (symbol === '`') {
+                inner = (0, backtick_1.readBacktickSegment)(scanner, ctx);
+            }
+            else if (symbol === '=') {
+                inner = (0, marker_highlight_1.readMarkerHighlight)(scanner, ctx);
+            }
+            else if (symbol === '*' ||
+                symbol === '/' ||
+                symbol === '_' ||
+                symbol === '-' ||
+                symbol === '~' ||
+                symbol === '^') {
+                inner = (0, style_1.readStyledSegment)(scanner, ctx);
+            }
+            else if (symbol === '[') {
+                inner = parseBracketExpression(scanner, ctx);
+            }
+            if (!inner) {
+                return `[${inside}]`;
+            }
+            if (typeof inner === 'string') {
+                return `[${inside}]${inner}`;
+            }
+            if (inner.type === 'highlight') {
+                applyHighlightColorsFromAttrs(inner, mergedAttrs);
+                delete mergedAttrs.color;
+                delete mergedAttrs.secondaryColor;
+                delete mergedAttrs.shape;
+                delete mergedAttrs.roundedRadius;
+            }
+            if (!hasInlineAttributes(mergedAttrs)) {
+                return inner;
+            }
+            const node = {
+                type: 'inlineAttrs',
+                attrs: mergedAttrs,
+                children: [inner],
+            };
+            return node;
+        }
+        const saveIndex = scanner.index;
+        const saveLine = scanner.line;
+        const saveColumn = scanner.column;
+        let linkText = '';
+        let foundParen = false;
+        while (!scanner.eof()) {
+            const ch = scanner.peek();
+            if (ch === undefined) {
+                break;
+            }
+            if (ch === '(') {
+                foundParen = true;
+                break;
+            }
+            if (ch === '\n') {
+                break;
+            }
+            scanner.next();
+            linkText += ch;
+        }
+        if (foundParen && linkText.length > 0) {
+            scanner.next();
+            let url = '';
+            let foundCloseParen = false;
+            while (!scanner.eof()) {
+                const ch = scanner.peek();
+                if (ch === ')') {
+                    scanner.next();
+                    foundCloseParen = true;
+                    break;
+                }
+                scanner.next();
+                url += ch;
+            }
+            if (foundCloseParen && url.length > 0) {
+                const children = ctx.parseNested(linkText.trim(), startLine);
+                const linkNode = {
+                    type: 'link',
+                    href: url,
+                    children,
+                };
+                if (mergedAttrs.color) {
+                    linkNode.colorAttr = mergedAttrs.color;
+                }
+                if (mergedAttrs.secondaryColor) {
+                    linkNode.underlineColorAttr = mergedAttrs.secondaryColor;
+                }
+                return linkNode;
+            }
+        }
+        scanner.index = saveIndex;
+        scanner.line = saveLine;
+        scanner.column = saveColumn;
+        const node = parseInlineAttrsNode(scanner, ctx, mergedAttrs, startLine, startColumn, mergedRawInside);
+        if (node) {
+            return node;
+        }
+    }
+    return `[${inside}]`;
+}
+exports.bracketRule = {
+    flushTextBefore: true,
+    parse(scanner, ctx) {
+        const result = parseBracketExpression(scanner, ctx);
+        if (!result) {
+            return { kind: 'append', text: '' };
+        }
+        if (typeof result === 'string') {
+            return { kind: 'emitText', text: result };
+        }
+        return { kind: 'emit', node: result };
+    },
+};