@markuplint/parser-utils 4.0.0-dev.28 → 4.0.0-rc.1

package/lib/ignore-block.js

@@ -1,21 +1,10 @@
 import { MASK_CHAR } from './const.js';
-import { uuid } from './create-token.js';
-import { sliceFragment } from './get-location.js';
-import { siblingsCorrection } from './siblings-correction.js';
+import { getCol, getLine } from './get-location.js';
+import { ParserError } from './parser-error.js';
 export function ignoreBlock(source, tags, maskChar = MASK_CHAR) {
     let replaced = source;
     const stack = [];
     for (const tag of tags) {
-        // Replace tags in attributes
-        const attr = maskText(prepend(tag.start, '(?<=(?:"|\'))'), append(tag.end, '(?=(?:"|\'))'), replaced, (startTag, taggedCode, endTag) => {
-            const mask = maskChar.repeat(startTag.length) +
-                taggedCode.replaceAll(/[^\n]/g, maskChar) +
-                maskChar.repeat((endTag ?? '').length);
-            return mask;
-        });
-        replaced = attr.replaced;
-        stack.push(...attr.stack.map(res => ({ ...res, type: tag.type })));
-        // Replace tags in other nodes
         const text = maskText(tag.start, tag.end, replaced, (startTag, taggedCode, endTag) => {
             const mask = maskChar.repeat(startTag.length) +
                 taggedCode.replaceAll(/[^\n]/g, maskChar) +
@@ -49,6 +38,7 @@ function maskText(start, end, replaced, masking) {
             startTag,
             taggedCode,
             endTag: endTag ?? null,
+            resolved: false,
         });
         /**
          * It will not replace line breaks because detects line number.
@@ -62,106 +52,41 @@ function maskText(start, end, replaced, masking) {
 }
 export function restoreNode(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeList, ignoreBlock) {
-    nodeList = [...nodeList];
+parser, nodeList, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+ignoreBlock, throwErrorWhenTagHasUnresolved = true) {
+    const newNodeList = [...nodeList];
     const { source, stack, maskChar } = ignoreBlock;
-    for (const node of nodeList) {
-        if (node.type === 'comment' || node.type === 'text' || node.type === 'psblock') {
-            if (!hasIgnoreBlock(node.raw, maskChar)) {
-                continue;
-            }
-            const parentNode = node.parentNode;
-            const index = nodeList.indexOf(node);
-            const insertList = [];
-            let text = node.raw;
-            let pointer = 0;
-            for (const tag of stack) {
-                if (node.startOffset <= tag.index && tag.index < node.endOffset) {
-                    const start = tag.index - node.startOffset;
-                    const body = tag.startTag + tag.taggedCode + (tag.endTag ?? '');
-                    const above = node.raw.slice(pointer, start);
-                    const below = text.slice(above.length + body.length);
-                    if (above) {
-                        const offset = node.startOffset + pointer;
-                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(source, offset, offset + above.length);
-                        const textNode = {
-                            ...node,
-                            uuid: uuid(),
-                            type: 'text',
-                            raw,
-                            startOffset,
-                            endOffset,
-                            startLine,
-                            endLine,
-                            startCol,
-                            endCol,
-                        };
-                        if (node.prevNode?.nextNode) {
-                            node.prevNode.nextNode = textNode;
-                        }
-                        if (node.nextNode?.prevNode) {
-                            node.nextNode.prevNode = textNode;
-                        }
-                        insertList.push(textNode);
-                    }
-                    if (body) {
-                        const offset = node.startOffset + pointer + above.length;
-                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(source, offset, offset + body.length);
-                        const bodyNode = {
-                            uuid: uuid(),
-                            type: 'psblock',
-                            nodeName: `#ps:${tag.type}`,
-                            raw,
-                            parentNode: node.parentNode,
-                            prevNode: null,
-                            nextNode: null,
-                            isFragment: node.isFragment,
-                            isGhost: false,
-                            startOffset,
-                            endOffset,
-                            startLine,
-                            endLine,
-                            startCol,
-                            endCol,
-                        };
-                        if (node.prevNode?.nextNode) {
-                            node.prevNode.nextNode = bodyNode;
-                        }
-                        if (node.nextNode?.prevNode) {
-                            node.nextNode.prevNode = bodyNode;
-                        }
-                        insertList.push(bodyNode);
-                    }
-                    text = below;
-                    pointer = start + body.length;
-                }
-            }
-            if (text) {
-                const offset = node.endOffset - text.length;
-                const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(source, offset, offset + text.length);
-                const textNode = {
-                    ...node,
-                    uuid: uuid(),
-                    type: 'text',
-                    raw,
-                    startOffset,
-                    endOffset,
-                    startLine,
-                    endLine,
-                    startCol,
-                    endCol,
-                };
-                insertList.push(textNode);
-            }
-            siblingsCorrection(insertList);
-            if (parentNode) {
-                parentNode.childNodes = insertList;
-            }
-            nodeList.splice(index, 1, ...insertList);
+    if (stack.length === 0) {
+        return newNodeList;
+    }
+    for (const tag of stack) {
+        const node = newNodeList.find(node => node.startOffset === tag.index);
+        if (!node) {
+            continue;
+        }
+        const raw = `${tag.startTag}${tag.taggedCode}${tag.endTag ?? ''}`;
+        const token = parser.createToken(raw, node.startOffset, node.startLine, node.startCol);
+        const psNode = {
+            ...token,
+            type: 'psblock',
+            depth: node.depth,
+            nodeName: `#ps:${tag.type}`,
+            parentNode: node.parentNode,
+            childNodes: [],
+            isBogus: false,
+        };
+        if (node.type !== 'doctype' && node.parentNode?.childNodes) {
+            parser.replaceChild(node.parentNode, node, psNode);
         }
+        const index = newNodeList.indexOf(node);
+        newNodeList.splice(index, 1, psNode);
+        tag.resolved = true;
+    }
+    for (const node of newNodeList) {
         if (node.type === 'starttag') {
             for (const attr of node.attributes) {
-                if (attr.type === 'ps-attr' || attr.value.raw === '' || !hasIgnoreBlock(attr.value.raw, maskChar)) {
+                if (attr.type === 'spread' || attr.value.raw === '' || !hasIgnoreBlock(attr.value.raw, maskChar)) {
                     continue;
                 }
                 for (const tag of stack) {
@@ -171,14 +96,39 @@ nodeList, ignoreBlock) {
                         const offset = tag.index - attr.value.startOffset;
                         const above = attr.value.raw.slice(0, offset);
                         const below = attr.value.raw.slice(offset + length);
-                        attr.value.raw = above + raw + below;
-                        attr.isDynamicValue = true;
+                        parser.updateRaw(attr.value, above + raw + below);
+                        parser.updateAttr(attr, { isDynamicValue: true });
+                        tag.resolved = true;
                     }
+                    parser.updateRaw(attr, attr.name.raw +
+                        attr.spacesBeforeEqual.raw +
+                        attr.equal.raw +
+                        attr.spacesAfterEqual.raw +
+                        attr.startQuote.raw +
+                        attr.value.raw +
+                        attr.endQuote.raw);
                 }
+                // Update node raw
+                const length = attr.raw.length;
+                const offset = attr.startOffset - node.startOffset;
+                const above = node.raw.slice(0, offset);
+                const below = node.raw.slice(offset + length);
+                parser.updateRaw(node, above + attr.raw + below);
             }
         }
     }
-    return nodeList;
+    if (throwErrorWhenTagHasUnresolved) {
+        for (const tag of stack) {
+            if (!tag.resolved) {
+                throw new ParserError('Parsing failed. Unsupported syntax detected', {
+                    line: getLine(source, tag.index),
+                    col: getCol(source, tag.index),
+                    raw: tag.startTag + tag.taggedCode + (tag.endTag ?? ''),
+                });
+            }
+        }
+    }
+    return newNodeList;
 }
 function snap(str, reg) {
     const matched = reg.exec(str);
@@ -192,14 +142,14 @@ function snap(str, reg) {
     return [index, above, snapPoint, below];
 }
 function removeGlobalOption(reg) {
+    if (typeof reg === 'string') {
+        return new RegExp(escapeRegExpForStr(reg));
+    }
     return new RegExp(reg.source, reg.ignoreCase ? 'i' : '');
 }
-function prepend(reg, str) {
-    return new RegExp(str + reg.source, reg.ignoreCase ? 'i' : '');
-}
-function append(reg, str) {
-    return new RegExp(reg.source + str, reg.ignoreCase ? 'i' : '');
-}
 function hasIgnoreBlock(textContent, maskChar) {
     return textContent.includes(maskChar);
 }
+function escapeRegExpForStr(str) {
+    return str.replaceAll(/[!$()*+./:=?[\\\]^{|}]/g, '\\$&');
+}

package/lib/ignore-front-matter.d.ts

@@ -1 +1,4 @@
-export declare function ignoreFrontMatter(code: string): string;
+export declare function ignoreFrontMatter(code: string): {
+    code: string;
+    frontMatter: string | null;
+};

package/lib/ignore-front-matter.js

@@ -1,17 +1,26 @@
 export function ignoreFrontMatter(code) {
-    const reStart = /^(?:\s*\r?\n)?---\r?\n/.exec(code);
+    const reStart = /^(?:\s*\n)?---\r?\n/.exec(code);
     if (!reStart) {
-        return code;
+        return {
+            code,
+            frontMatter: null,
+        };
     }
     const startPoint = reStart[0].length;
     const afterStart = code.slice(startPoint);
     const reEnd = /\r?\n---\r?\n/.exec(afterStart);
     if (!reEnd) {
-        return code;
+        return {
+            code,
+            frontMatter: null,
+        };
     }
     const endPoint = startPoint + reEnd.index + reEnd[0].length;
     const frontMatter = code.slice(0, endPoint);
     const afterCode = code.slice(endPoint);
     const masked = frontMatter.replaceAll(/[^\n\r]/g, ' ');
-    return masked + afterCode;
+    return {
+        code: masked + afterCode,
+        frontMatter,
+    };
 }

package/lib/index.d.ts

@@ -1,16 +1,7 @@
-export * from './const.js';
-export * from './create-token.js';
 export * from './debugger.js';
-export * from './decision.js';
-export * from './detect-element-type.js';
-export * from './flatten-nodes.js';
-export * from './get-location.js';
-export * from './get-space-before.js';
+export * from './enums.js';
 export * from './idl-attributes.js';
-export * from './ignore-block.js';
-export * from './ignore-front-matter.js';
-export * from './parse-attr.js';
 export * from './parser-error.js';
-export * from './remove-deprecated-node.js';
-export * from './tag-splitter.js';
-export * from './walker.js';
+export * from './parser.js';
+export * from './script-parser.js';
+export * from './types.js';

package/lib/index.js

@@ -1,16 +1,7 @@
-export * from './const.js';
-export * from './create-token.js';
 export * from './debugger.js';
-export * from './decision.js';
-export * from './detect-element-type.js';
-export * from './flatten-nodes.js';
-export * from './get-location.js';
-export * from './get-space-before.js';
+export * from './enums.js';
 export * from './idl-attributes.js';
-export * from './ignore-block.js';
-export * from './ignore-front-matter.js';
-export * from './parse-attr.js';
 export * from './parser-error.js';
-export * from './remove-deprecated-node.js';
-export * from './tag-splitter.js';
-export * from './walker.js';
+export * from './parser.js';
+export * from './script-parser.js';
+export * from './types.js';

package/lib/parser-error.d.ts

@@ -2,6 +2,7 @@ export type ParserErrorInfo = {
     readonly line?: number;
     readonly col?: number;
     readonly raw?: string;
+    readonly stack?: string;
 };
 export declare class ParserError extends Error {
     readonly col: number;

package/lib/parser-error.js

@@ -5,6 +5,7 @@ export class ParserError extends Error {
         this.line = info.line ?? 1;
         this.col = info.col ?? 0;
         this.raw = info.raw ?? '';
+        this.stack = info.stack ?? this.stack;
     }
 }
 export class TargetParserError extends ParserError {

package/lib/parser.d.ts

@@ -0,0 +1,112 @@
+import type { Token, ChildToken, QuoteSet, ParseOptions, ParserOptions, Tokenized } from './types.js';
+import type { EndTagType, MLASTDocument, MLASTParentNode, MLParser, ParserAuthoredElementNameDistinguishing, MLASTElement, MLASTElementCloseTag, MLASTToken, MLASTNodeTreeItem, MLASTTag, MLASTText, MLASTAttr, MLASTChildNode, MLASTSpreadAttr, ElementType, Walker, MLASTHTMLAttr } from '@markuplint/ml-ast';
+import { AttrState } from './enums.js';
+import { ParserError } from './parser-error.js';
+export declare abstract class Parser<Node extends {} = {}, State extends unknown = null> implements MLParser {
+    #private;
+    state: State;
+    get authoredElementName(): ParserAuthoredElementNameDistinguishing | undefined;
+    /**
+     * Detect value as a true if its attribute is booleanish value and omitted.
+     *
+     * Ex:
+     * ```jsx
+     * <Component aria-hidden />
+     * ```
+     *
+     * In the above, the `aria-hidden` is `true`.
+     */
+    get booleanish(): boolean;
+    /**
+     * The end tag omittable type.
+     *
+     * - `"xml"`: Must need an end tag or must self-close
+     * - `"omittable"`: May omit
+     * - `"never"`: Never need
+     */
+    get endTag(): EndTagType;
+    get rawCode(): string;
+    get tagNameCaseSensitive(): boolean;
+    constructor(options?: ParserOptions, defaultState?: State);
+    tokenize(options?: ParseOptions): Tokenized<Node, State>;
+    beforeParse(rawCode: string, options?: ParseOptions): string;
+    parse(rawCode: string, options?: ParseOptions): MLASTDocument;
+    afterParse(nodeList: readonly MLASTNodeTreeItem[], options?: ParseOptions): readonly MLASTNodeTreeItem[];
+    parseError(error: any): ParserError;
+    traverse(originNodes: readonly Node[], parentNode: MLASTParentNode | null | undefined, depth: number): {
+        childNodes: readonly MLASTChildNode[];
+        siblings: readonly MLASTNodeTreeItem[];
+    };
+    afterTraverse(nodeTree: readonly MLASTNodeTreeItem[]): readonly MLASTNodeTreeItem[];
+    nodeize(originNode: Node, parentNode: MLASTParentNode | null, depth: number): readonly MLASTNodeTreeItem[];
+    afterNodeize(siblings: readonly MLASTNodeTreeItem[], parentNode: MLASTParentNode | null, depth: number): {
+        siblings: MLASTChildNode[];
+        ancestors: MLASTNodeTreeItem[];
+    };
+    flattenNodes(nodeTree: readonly MLASTNodeTreeItem[]): readonly MLASTNodeTreeItem[];
+    afterFlattenNodes(nodeList: readonly MLASTNodeTreeItem[], options?: {
+        readonly exposeInvalidNode?: boolean;
+        readonly exposeWhiteSpace?: boolean;
+        readonly concatText?: boolean;
+    }): readonly MLASTNodeTreeItem[];
+    visitDoctype(token: ChildToken & {
+        readonly name: string;
+        readonly publicId: string;
+        readonly systemId: string;
+    }): readonly MLASTNodeTreeItem[];
+    visitComment(token: ChildToken, options?: {
+        readonly isBogus?: boolean;
+    }): readonly MLASTNodeTreeItem[];
+    visitText(token: ChildToken, options?: {
+        readonly researchTags?: boolean;
+        readonly invalidTagAsText?: boolean;
+    }): readonly MLASTNodeTreeItem[];
+    visitElement(token: ChildToken & {
+        readonly nodeName: string;
+        readonly namespace: string;
+    }, childNodes?: readonly Node[], options?: {
+        readonly createEndTagToken?: (startTag: MLASTElement) => ChildToken | null;
+        readonly namelessFragment?: boolean;
+        readonly overwriteProps?: Partial<MLASTElement>;
+    }): readonly MLASTNodeTreeItem[];
+    visitPsBlock(token: ChildToken & {
+        readonly nodeName: string;
+    }, childNodes?: readonly Node[], originBlockNode?: Node): readonly MLASTNodeTreeItem[];
+    visitChildren(children: readonly Node[], parentNode: MLASTParentNode | null): readonly MLASTNodeTreeItem[];
+    visitSpreadAttr(token: Token): MLASTSpreadAttr | null;
+    visitAttr(token: Token, options?: {
+        readonly quoteSet?: readonly QuoteSet[];
+        readonly quoteInValueChars?: readonly QuoteSet[];
+        readonly endOfUnquotedValueChars?: readonly string[];
+        readonly startState?: AttrState;
+    }): MLASTAttr & {
+        __rightText?: string;
+    };
+    parseCodeFragment(token: ChildToken, options?: {
+        readonly namelessFragment?: boolean;
+    }): (MLASTTag | MLASTText)[];
+    updateLocation(node: MLASTNodeTreeItem, props: Partial<Pick<MLASTNodeTreeItem, 'startOffset' | 'startLine' | 'startCol' | 'depth'>>): void;
+    /**
+     * Set new raw code to target node.
+     *
+     * Replace the raw code and update the start/end offset/line/column.
+     *
+     * @param node target node
+     * @param raw new raw code
+     */
+    updateRaw(node: MLASTToken, raw: string): void;
+    updateElement(el: MLASTElement, props: Partial<Pick<MLASTElement, 'nodeName' | 'elementType'>>): void;
+    updateElement(el: MLASTElementCloseTag, props: Partial<Pick<MLASTElementCloseTag, 'nodeName'>>): void;
+    updateAttr(attr: MLASTHTMLAttr, props: Partial<Pick<MLASTHTMLAttr, 'isDynamicValue' | 'isDirective' | 'potentialName' | 'potentialValue' | 'valueType' | 'candidate' | 'isDuplicatable'>>): void;
+    detectElementType(nodeName: string, defaultPattern?: ParserAuthoredElementNameDistinguishing): ElementType;
+    createToken(token: Token): MLASTToken;
+    createToken(token: string, startOffset: number, startLine: number, startCol: number): MLASTToken;
+    sliceFragment(start: number, end?: number): Token;
+    getOffsetsFromCode(startLine: number, startCol: number, endLine: number, endCol: number): {
+        offset: number;
+        endOffset: number;
+    };
+    walk<Node extends MLASTNodeTreeItem>(nodeList: readonly Node[], walker: Walker<Node>, depth?: number): void;
+    appendChild(parentNode: MLASTParentNode | null, ...childNodes: readonly MLASTChildNode[]): void;
+    replaceChild(parentNode: MLASTParentNode, oldChildNode: MLASTChildNode, newChildNode: MLASTChildNode): void;
+}