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

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2019 Yusuke Hirao
+Copyright (c) 2017-2024 Yusuke Hirao
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/index.d.ts

@@ -1,2 +1 @@
-export { parse } from './parse.js';
-export declare const endTag = "never";
+export { parser } from './parser.js';

package/lib/index.js

@@ -1,2 +1 @@
-export { parse } from './parse.js';
-export const endTag = 'never';
+export { parser } from './parser.js';

package/lib/parser.d.ts

@@ -0,0 +1,25 @@
+import type { ASTNode } from './pug-parser/index.js';
+import type { MLASTAttr, MLASTNodeTreeItem, MLASTParentNode } from '@markuplint/ml-ast';
+import type { ChildToken, ParseOptions, Token } from '@markuplint/parser-utils';
+import { ParserError, Parser } from '@markuplint/parser-utils';
+declare class PugParser extends Parser<ASTNode> {
+    constructor();
+    tokenize(options?: ParseOptions): {
+        ast: ASTNode[];
+        isFragment: boolean;
+    };
+    parseError(error: any): ParserError;
+    nodeize(originNode: ASTNode, parentNode: MLASTParentNode | null, depth: number): readonly MLASTNodeTreeItem[];
+    afterFlattenNodes(nodeList: readonly MLASTNodeTreeItem[]): readonly MLASTNodeTreeItem[];
+    visitElement(token: ChildToken & {
+        readonly nodeName: string;
+        readonly namespace: string;
+    }, childNodes: readonly ASTNode[], options: {
+        readonly overwriteProps: {
+            readonly attributes: readonly MLASTAttr[];
+        };
+    }): MLASTNodeTreeItem[];
+    visitAttr(token: Token): MLASTAttr;
+}
+export declare const parser: PugParser;
+export {};

package/lib/parser.js

@@ -0,0 +1,269 @@
+import { HtmlParser, getNamespace } from '@markuplint/html-parser';
+import { ParserError, Parser, AttrState, scriptParser } from '@markuplint/parser-utils';
+import { pugParse } from './pug-parser/index.js';
+class HtmlInPugParser extends HtmlParser {
+    constructor() {
+        super({
+            ignoreTags: [
+                /**
+                 * Tag Interpolation
+                 *
+                 * @see https://pugjs.org/language/interpolation.html#tag-interpolation
+                 */
+                {
+                    type: 'tag-interpolation',
+                    start: '#[',
+                    end: ']',
+                },
+            ],
+        });
+    }
+}
+class PugParser extends Parser {
+    constructor() {
+        super({
+            endTagType: 'never',
+        });
+    }
+    tokenize(options) {
+        const offsetOffset = options?.offsetOffset ?? 0;
+        return {
+            ast: pugParse(this.rawCode, offsetOffset >= 1).nodes,
+            isFragment: true,
+        };
+    }
+    parseError(error) {
+        if (error instanceof Error && 'msg' in error && 'line' in error && 'column' in error && 'src' in error) {
+            return new ParserError(error.msg, {
+                line: error.line,
+                col: error.column,
+                raw: error.src,
+            });
+        }
+        return super.parseError(error);
+    }
+    nodeize(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    originNode, parentNode, depth) {
+        const parentNamespace = parentNode && 'namespace' in parentNode ? parentNode.namespace : 'http://www.w3.org/1999/xhtml';
+        const token = this.sliceFragment(originNode.offset, originNode.endOffset);
+        switch (originNode.type) {
+            case 'Doctype': {
+                return this.visitDoctype({
+                    ...token,
+                    depth,
+                    parentNode,
+                    name: originNode.val ?? '',
+                    publicId: '',
+                    systemId: '',
+                });
+            }
+            case 'Text': {
+                if (originNode.raw.trim() === '') {
+                    return [];
+                }
+                const htmlDoc = new HtmlInPugParser().parse(originNode.raw, {
+                    offsetOffset: originNode.offset,
+                    offsetLine: originNode.line,
+                    offsetColumn: originNode.column,
+                    depth,
+                });
+                const newNodeList = [];
+                for (const node of htmlDoc.nodeList) {
+                    if (node.nodeName === '#ps:tag-interpolation') {
+                        // Remove `#[` and `]`
+                        const raw = node.raw.slice(2, -1);
+                        const innerNodes = new PugParser().parse(raw, {
+                            offsetOffset: node.startOffset + 2,
+                            offsetLine: node.startLine,
+                            offsetColumn: node.startCol + 2,
+                            depth: node.depth,
+                        });
+                        newNodeList.push(...innerNodes.nodeList);
+                        continue;
+                    }
+                    newNodeList.push(node);
+                }
+                return newNodeList;
+            }
+            case 'Comment': {
+                return this.visitComment({
+                    ...token,
+                    depth,
+                    parentNode,
+                }, {
+                    isBogus: false,
+                });
+            }
+            case 'Tag': {
+                const namespace = getNamespace(originNode.name, parentNamespace);
+                const attrs = originNode.attrs.map(attr => {
+                    // eslint-disable-next-line prefer-const
+                    let { offset, endOffset } = this.getOffsetsFromCode(attr.line, attr.column, attr.endLine, attr.endColumn);
+                    if ((attr.name === 'id' || attr.name === 'class') &&
+                        attr.offset === attr.endOffset &&
+                        typeof attr.val === 'string') {
+                        /**
+                         * #value =>
+                         * {
+                         *   name: 'id',
+                         *   val: "'value'",
+                         * }
+                         * Remove single quotes and add (#|.) prefix
+                         */
+                        endOffset = attr.offset + attr.val.length - 1;
+                    }
+                    const token = this.sliceFragment(offset, endOffset);
+                    return this.visitAttr(token);
+                });
+                // &attributes(syntax)
+                const andAttr = originNode.attributeBlocks.map(block => {
+                    const blockLength = '&attributes('.length;
+                    const { offset, endOffset } = this.getOffsetsFromCode(block.line, block.column + blockLength, block.line, block.column + blockLength + block.val.length);
+                    const token = this.sliceFragment(offset, endOffset);
+                    const node = this.createToken(token.raw, token.startOffset, token.startLine, token.startCol);
+                    return {
+                        ...node,
+                        type: 'spread',
+                        nodeName: '#spread',
+                    };
+                });
+                return this.visitElement({
+                    ...token,
+                    depth,
+                    parentNode,
+                    nodeName: originNode.name,
+                    namespace,
+                }, originNode.block.nodes, {
+                    overwriteProps: {
+                        attributes: [...attrs, ...andAttr],
+                    },
+                });
+            }
+            default: {
+                return this.visitPsBlock({
+                    ...token,
+                    depth,
+                    parentNode,
+                    nodeName: originNode.type,
+                }, 'block' in originNode && originNode.block ? originNode.block.nodes : []);
+            }
+        }
+    }
+    afterFlattenNodes(nodeList) {
+        return super.afterFlattenNodes(nodeList, {
+            exposeInvalidNode: false,
+            exposeWhiteSpace: false,
+        });
+    }
+    visitElement(token, 
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    childNodes, options) {
+        const startTag = {
+            ...token,
+            ...this.createToken(token),
+            ...options.overwriteProps,
+            type: 'starttag',
+            elementType: this.detectElementType(token.nodeName),
+            childNodes: [],
+            pairNode: null,
+            tagOpenChar: '',
+            tagCloseChar: '',
+            isGhost: false,
+        };
+        const siblings = this.visitChildren(childNodes, startTag);
+        return [startTag, ...siblings];
+    }
+    visitAttr(token) {
+        if (token.raw[0] === '#' || token.raw[0] === '.') {
+            const attr = super.visitAttr(token, {
+                startState: AttrState.BeforeValue,
+                quoteSet: [],
+                quoteInValueChars: [],
+                endOfUnquotedValueChars: [],
+            });
+            if (attr.type === 'spread') {
+                return attr;
+            }
+            const potentialName = token.raw[0] === '#' ? 'id' : 'class';
+            this.updateAttr(attr, {
+                potentialName,
+                potentialValue: attr.raw.slice(1),
+                isDuplicatable: potentialName === 'class',
+            });
+            return attr;
+        }
+        const attr = super.visitAttr(token, {
+            quoteSet: [],
+            quoteInValueChars: [],
+            endOfUnquotedValueChars: [],
+        });
+        if (attr.type === 'spread') {
+            return attr;
+        }
+        if (attr.name.raw.toLowerCase() === 'class') {
+            this.updateAttr(attr, { isDuplicatable: true });
+        }
+        if (attr.name.raw.startsWith("'") && attr.name.raw.endsWith("'")) {
+            this.updateAttr(attr, {
+                potentialName: attr.name.raw.slice(1, -1),
+            });
+        }
+        if (attr.name.raw.endsWith('!')) {
+            this.updateAttr(attr, {
+                potentialName: attr.name.raw.slice(0, -1),
+            });
+        }
+        const valueCodeTokens = scriptParser(attr.value.raw.trim());
+        if (valueCodeTokens.length === 1) {
+            const token = valueCodeTokens[0];
+            switch (token.type) {
+                case 'Numeric': {
+                    return {
+                        ...attr,
+                        valueType: 'number',
+                    };
+                }
+                case 'Boolean': {
+                    return {
+                        ...attr,
+                        valueType: 'boolean',
+                    };
+                }
+                case 'String':
+                case 'Template': {
+                    const value = super.visitAttr(attr.value, {
+                        startState: AttrState.BeforeValue,
+                        quoteSet: [
+                            { start: '"', end: '"' },
+                            { start: "'", end: "'" },
+                            { start: '`', end: '`' },
+                        ],
+                        quoteInValueChars: [
+                            { start: '"', end: '"' },
+                            { start: "'", end: "'" },
+                            { start: '`', end: '`' },
+                            { start: '${', end: '}' },
+                        ],
+                    });
+                    if (value.type === 'spread') {
+                        throw new ParserError('Unexpected attribute value', value);
+                    }
+                    return {
+                        ...attr,
+                        startQuote: value.startQuote,
+                        value: value.value,
+                        endQuote: value.endQuote,
+                        ...(attr.name.raw.endsWith('!') ? { valueType: 'code' } : {}),
+                    };
+                }
+            }
+        }
+        return {
+            ...attr,
+            isDynamicValue: true,
+            valueType: 'code',
+        };
+    }
+}
+export const parser = new PugParser();

package/lib/pug-parser/index.d.ts

@@ -1,8 +1,9 @@
-export declare function pugParse(pug: string): ASTBlock;
+export declare function pugParse(pug: string, useOffset?: boolean): ASTBlock;
 export type ASTBlock = PugAST<ASTNode>;
-export type ASTNode = ASTTagNode | ASTTextNode | ASTCodeNode | ASTComment | ASTDoctype | ASTIncludeNode | ASTMixinNode | ASTMixinSlotNode | ASTFilterNode | ASTEachNode | ASTConditionalNode | ASTCaseNode | ASTCaseWhenNode;
-export type ASTTagNode = Omit<PugASTTagNode<ASTAttr, ASTBlock>, 'attributeBlocks' | 'selfClosing' | 'isInline'> & AdditionalASTData;
+export type ASTNode = ASTTagNode | ASTTextNode | ASTEmptyPipeNode | ASTCodeNode | ASTComment | ASTDoctype | ASTIncludeNode | ASTMixinNode | ASTMixinSlotNode | ASTFilterNode | ASTEachNode | ASTConditionalNode | ASTCaseNode | ASTCaseWhenNode;
+export type ASTTagNode = Omit<PugASTTagNode<ASTAttr, ASTBlock>, 'selfClosing' | 'isInline'> & AdditionalASTData;
 export type ASTTextNode = Omit<PugASTTextNode, 'val'> & AdditionalASTData;
+export type ASTEmptyPipeNode = PugASTEmptyPipeNode & AdditionalASTData;
 export type ASTCodeNode = PugASTCodeNode & AdditionalASTData;
 export type ASTComment = PugASTCommentNode & AdditionalASTData;
 export type ASTDoctype = PugASTDoctypeNode & AdditionalASTData;
@@ -34,7 +35,12 @@ type PugASTTagNode<A, B> = {
     name: string;
     selfClosing: boolean;
     attrs: A[];
-    attributeBlocks: never[];
+    attributeBlocks: {
+        type: 'AttributeBlock';
+        val: string;
+        line: number;
+        column: number;
+    }[];
     isInline: boolean;
     line: number;
     column: number;
@@ -47,6 +53,12 @@ type PugASTTextNode = {
     line: number;
     column: number;
 };
+type PugASTEmptyPipeNode = {
+    type: 'EmptyPipe';
+    val: string;
+    line: number;
+    column: number;
+};
 type PugASTCodeNode = {
     type: 'Code';
     val: string;

package/lib/pug-parser/index.js

@@ -1,19 +1,29 @@
-// @ts-ignore
 import lexer from 'pug-lexer';
 // @ts-ignore
 import parser from 'pug-parser';
 import { getOffsetFromLineAndCol } from '../utils/get-offset-from-line-and-col.js';
-export function pugParse(pug) {
-    const lexOrigin = lexer(pug);
+export function pugParse(pug, useOffset = false) {
+    let lexOrigin = lexer(pug);
+    /**
+     * Exclude indent and outdent tokens when offset is received to avoid indentation errors
+     */
+    if (useOffset) {
+        const newLexOrigin = [];
+        for (const token of lexOrigin) {
+            if (token.type === 'indent' || token.type === 'outdent') {
+                continue;
+            }
+            newLexOrigin.push(token);
+        }
+        lexOrigin = newLexOrigin;
+    }
     const lex = JSON.parse(JSON.stringify(lexOrigin));
     const originAst = parser(lexOrigin);
-    // console.log(lex);
-    // console.log(JSON.stringify(originAst, null, 2));
     const ast = optimizeAST(originAst, lex, pug);
     return ast;
 }
 function getOffsetsFromLines(pug) {
-    const lines = pug.split(/\n/g);
+    const lines = pug.split(/\n/);
     let chars = 0;
     const result = lines.map(line => {
         chars += line.length + 1;
@@ -76,6 +86,7 @@ tokens, pug) {
                     endColumn,
                     block,
                     attrs,
+                    attributeBlocks: node.attributeBlocks,
                 };
                 nodes.push(tagNode);
                 continue;
@@ -224,6 +235,27 @@ tokens, pug) {
                 const { endOffset, endLine, endColumn } = getRawTextAndLocationEnd(node.val, offset, line, column, tokens, offsets, pug);
                 const raw = pug.slice(offset, endOffset);
                 // console.log({ v: node.val, r: raw });
+                /**
+                 *
+                 * Empty piped line
+                 *
+                 * @see https://pugjs.org/language/plain-text.html#recommended-solutions
+                 */
+                if (raw === '|') {
+                    const newNode = {
+                        type: 'EmptyPipe',
+                        raw,
+                        val: node.val,
+                        offset,
+                        endOffset,
+                        line,
+                        endLine,
+                        column,
+                        endColumn,
+                    };
+                    nodes.push(newNode);
+                    continue;
+                }
                 const textNode = {
                     type: node.type,
                     raw,
@@ -292,8 +324,9 @@ tokens, pug) {
                 continue;
             }
             default: {
+                throw new Error(`Unsupported syntax: The "${
                 // @ts-ignore
-                throw new Error(`Unsupported syntax: The "${node.type}" node\n${JSON.stringify(node, null, 2)}`);
+                node.type}" node\n${JSON.stringify(node, null, 2)}`);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/pug-parser",
-	"version": "4.0.0-dev.28+0131de5e",
+	"version": "4.0.0-rc.1",
 	"description": "Pug parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -21,11 +21,11 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "4.0.0-dev.28+0131de5e",
-		"@markuplint/ml-ast": "4.0.0-dev.28+0131de5e",
-		"@markuplint/parser-utils": "4.0.0-dev.28+0131de5e",
+		"@markuplint/html-parser": "4.0.0-rc.1",
+		"@markuplint/ml-ast": "4.0.0-rc.1",
+		"@markuplint/parser-utils": "4.0.0-rc.1",
 		"pug-lexer": "^5.0.1",
 		"pug-parser": "^6.0.0"
 	},
-	"gitHead": "0131de5ea9dd6d3fd5472d7b414b66644c758881"
+	"gitHead": "3a9dbbf4c3c05de66d402802919ee94a46a5eb67"
 }

package/lib/attr-tokenizer.d.ts

@@ -1,3 +0,0 @@
-import type { ASTAttr } from './pug-parser/index.js';
-import type { MLASTAttr } from '@markuplint/ml-ast';
-export default function attrTokenizer(attr: ASTAttr): MLASTAttr;

package/lib/attr-tokenizer.js

@@ -1,137 +0,0 @@
-import { tokenizer, uuid } from '@markuplint/parser-utils';
-export default function attrTokenizer(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-attr) {
-    if (attr.raw[0] === '#' || attr.raw[0] === '.') {
-        let value = '';
-        if (typeof attr.val === 'string') {
-            value = attr.val.match(/(["'`]?)([^\1]+)(\1)/)?.[2] ?? '';
-        }
-        else {
-            value = `${attr.val}`;
-        }
-        return {
-            type: 'ps-attr',
-            uuid: uuid(),
-            raw: attr.raw,
-            startOffset: attr.offset,
-            endOffset: attr.endOffset,
-            startLine: attr.line,
-            endLine: attr.endLine,
-            startCol: attr.column,
-            endCol: attr.endColumn,
-            potentialName: attr.name,
-            potentialValue: value ?? '',
-            valueType: 'string',
-            isDuplicatable: attr.raw[0] === '.',
-            nodeName: '#pug-special-attr',
-            parentNode: null,
-            nextNode: null,
-            prevNode: null,
-            isFragment: false,
-            isGhost: false,
-        };
-    }
-    const spacesBeforeAttrString = '';
-    const nameChars = attr.name;
-    let spacesBeforeEqualChars;
-    let equalChars;
-    let spacesAfterEqualChars;
-    let quoteChars;
-    let valueChars;
-    let isDynamicValue = undefined;
-    if (attr.val === true) {
-        spacesBeforeEqualChars = '';
-        equalChars = '';
-        spacesAfterEqualChars = '';
-        quoteChars = '';
-        valueChars = '';
-    }
-    else {
-        const withoutName = attr.raw.slice(attr.name.length);
-        const valueOffset = withoutName.indexOf(attr.val);
-        const equalAndBeforeSpaceAfterSpace = withoutName.slice(0, valueOffset);
-        const [, before, equal, after] = equalAndBeforeSpaceAfterSpace.match(/^(\s*)(=)(\s*)$/) ?? ['', '', '', ''];
-        const [, quote, coreValue] = attr.val.match(/(["'`]?)([^\1]+)(\1)/) ?? ['', '', ''];
-        spacesBeforeEqualChars = before ?? '';
-        equalChars = equal ?? '';
-        spacesAfterEqualChars = after ?? '';
-        quoteChars = quote ?? '';
-        valueChars = coreValue ?? '';
-        if (quote === '`' || quote === '') {
-            isDynamicValue = true;
-        }
-    }
-    const invalid = !!(valueChars && quoteChars === null && /["'<=>`]/.test(valueChars)) ||
-        !!(equalChars && quoteChars === null && valueChars === null);
-    if (invalid) {
-        throw new Error('Parse error: It has invalid attribute');
-    }
-    let offset = attr.offset;
-    let line = attr.line;
-    let col = attr.column;
-    const attrToken = tokenizer(attr.raw, line, col, offset);
-    const spacesBeforeName = tokenizer(spacesBeforeAttrString, line, col, offset);
-    line = spacesBeforeName.endLine;
-    col = spacesBeforeName.endCol;
-    offset = spacesBeforeName.endOffset;
-    const name = tokenizer(nameChars, line, col, offset);
-    line = name.endLine;
-    col = name.endCol;
-    offset = name.endOffset;
-    const spacesBeforeEqual = tokenizer(spacesBeforeEqualChars, line, col, offset);
-    line = spacesBeforeEqual.endLine;
-    col = spacesBeforeEqual.endCol;
-    offset = spacesBeforeEqual.endOffset;
-    const equal = tokenizer(equalChars, line, col, offset);
-    line = equal.endLine;
-    col = equal.endCol;
-    offset = equal.endOffset;
-    const spacesAfterEqual = tokenizer(spacesAfterEqualChars, line, col, offset);
-    line = spacesAfterEqual.endLine;
-    col = spacesAfterEqual.endCol;
-    offset = spacesAfterEqual.endOffset;
-    const startQuote = tokenizer(quoteChars, line, col, offset);
-    line = startQuote.endLine;
-    col = startQuote.endCol;
-    offset = startQuote.endOffset;
-    const value = tokenizer(valueChars, line, col, offset);
-    line = value.endLine;
-    col = value.endCol;
-    offset = value.endOffset;
-    const endQuote = tokenizer(quoteChars, line, col, offset);
-    line = endQuote.endLine;
-    col = endQuote.endCol;
-    offset = endQuote.endOffset;
-    let isDuplicatable = false;
-    if (name.raw.toLowerCase() === 'class') {
-        isDuplicatable = true;
-    }
-    return {
-        type: 'html-attr',
-        uuid: uuid(),
-        raw: attrToken.raw,
-        startOffset: attrToken.startOffset,
-        endOffset: attrToken.endOffset,
-        startLine: attrToken.startLine,
-        endLine: attrToken.endLine,
-        startCol: attrToken.startCol,
-        endCol: attrToken.endCol,
-        spacesBeforeName,
-        name,
-        spacesBeforeEqual,
-        equal,
-        spacesAfterEqual,
-        startQuote,
-        value,
-        endQuote,
-        isDynamicValue,
-        isDuplicatable,
-        nodeName: name.raw,
-        parentNode: null,
-        nextNode: null,
-        prevNode: null,
-        isFragment: false,
-        isGhost: false,
-    };
-}

package/lib/parse.d.ts

@@ -1,2 +0,0 @@
-import type { Parse } from '@markuplint/ml-ast';
-export declare const parse: Parse;

package/lib/parse.js

@@ -1,255 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Parser_ast;
-import { getNamespace, parse as htmlParse, isDocumentFragment } from '@markuplint/html-parser';
-import { detectElementType, ignoreFrontMatter, ParserError, tokenizer, uuid, walk, removeDeprecatedNode, } from '@markuplint/parser-utils';
-import attrTokenizer from './attr-tokenizer.js';
-import { pugParse } from './pug-parser/index.js';
-export const parse = (rawCode, options) => {
-    let unknownParseError;
-    let nodeList;
-    if (options?.ignoreFrontMatter) {
-        rawCode = ignoreFrontMatter(rawCode);
-    }
-    try {
-        const parser = new Parser(rawCode);
-        nodeList = parser.getNodeList();
-    }
-    catch (error) {
-        nodeList = [];
-        if (error instanceof Error && 'msg' in error && 'line' in error && 'column' in error && 'src' in error) {
-            throw new ParserError(
-            // @ts-ignore
-            error.msg, {
-                // @ts-ignore
-                line: error.line,
-                // @ts-ignore
-                col: error.column,
-                // @ts-ignore
-                raw: error.src,
-            });
-        }
-        unknownParseError = error instanceof Error ? error.message : new Error(`${error}`).message;
-    }
-    return {
-        nodeList,
-        isFragment: isDocumentFragment(rawCode),
-        unknownParseError: unknownParseError,
-    };
-};
-class Parser {
-    constructor(raw) {
-        _Parser_ast.set(this, void 0);
-        __classPrivateFieldSet(this, _Parser_ast, pugParse(raw), "f");
-        // console.log(JSON.stringify(this.#ast, null, 2));
-    }
-    flattenNodes(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    nodeTree) {
-        const nodeOrders = [];
-        walk(nodeTree, node => {
-            nodeOrders.push(node);
-        });
-        removeDeprecatedNode(nodeOrders);
-        return nodeOrders;
-    }
-    getNodeList() {
-        const nodeTree = this.traverse(__classPrivateFieldGet(this, _Parser_ast, "f").nodes, null);
-        return this.flattenNodes(nodeTree);
-    }
-    nodeize(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    originNode, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    prevNode, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    parentNode) {
-        const nextNode = null;
-        const startOffset = originNode.offset;
-        const endOffset = originNode.endOffset;
-        const startLine = originNode.line;
-        const endLine = originNode.endLine;
-        const startCol = originNode.column;
-        const endCol = originNode.endColumn;
-        const parentNamespace = parentNode && 'namespace' in parentNode ? parentNode.namespace : 'http://www.w3.org/1999/xhtml';
-        switch (originNode.type) {
-            case 'Doctype': {
-                return {
-                    uuid: uuid(),
-                    raw: originNode.raw,
-                    name: originNode.val ?? '',
-                    // TODO:
-                    publicId: '',
-                    // TODO:
-                    systemId: '',
-                    startOffset,
-                    endOffset,
-                    startLine,
-                    endLine,
-                    startCol,
-                    endCol,
-                    nodeName: '#doctype',
-                    type: 'doctype',
-                    parentNode,
-                    prevNode,
-                    _addPrevNode: 102,
-                    nextNode,
-                    isFragment: false,
-                    isGhost: false,
-                };
-            }
-            case 'Text': {
-                if (parentNode && /^script$|^style$/i.test(parentNode.nodeName)) {
-                    return {
-                        uuid: uuid(),
-                        raw: originNode.raw,
-                        startOffset,
-                        endOffset,
-                        startLine,
-                        endLine,
-                        startCol,
-                        endCol,
-                        nodeName: '#text',
-                        type: 'text',
-                        parentNode,
-                        prevNode,
-                        nextNode,
-                        isFragment: false,
-                        isGhost: false,
-                    };
-                }
-                const htmlDoc = htmlParse(originNode.raw, {
-                    offsetOffset: originNode.offset,
-                    offsetLine: originNode.line - 1,
-                    offsetColumn: originNode.column - 1,
-                });
-                const nodes = htmlDoc.nodeList.filter(node => {
-                    return node.parentNode == null && node.type !== 'endtag';
-                });
-                return nodes;
-            }
-            case 'Comment': {
-                return {
-                    uuid: uuid(),
-                    raw: originNode.raw,
-                    startOffset,
-                    endOffset,
-                    startLine,
-                    endLine,
-                    startCol,
-                    endCol,
-                    nodeName: '#comment',
-                    type: 'comment',
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    isFragment: false,
-                    isGhost: false,
-                };
-            }
-            case 'Tag': {
-                const namespace = getNamespace(originNode.name, parentNamespace);
-                const tag = {
-                    uuid: uuid(),
-                    raw: originNode.raw,
-                    startOffset,
-                    endOffset,
-                    startLine,
-                    endLine,
-                    startCol,
-                    endCol,
-                    nodeName: originNode.name,
-                    type: 'starttag',
-                    namespace,
-                    elementType: detectElementType(originNode.name),
-                    attributes: originNode.attrs.map(attr => attrTokenizer(attr)),
-                    hasSpreadAttr: false,
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    pearNode: null,
-                    selfClosingSolidus: tokenizer('', originNode.line, originNode.column, originNode.offset),
-                    endSpace: tokenizer('', originNode.line, originNode.column, originNode.offset),
-                    isFragment: false,
-                    isGhost: false,
-                    tagOpenChar: '',
-                    tagCloseChar: '',
-                };
-                if (originNode.block.nodes.length > 0) {
-                    tag.childNodes = this.traverse(originNode.block.nodes, tag);
-                }
-                return tag;
-            }
-            default: {
-                const tag = {
-                    uuid: uuid(),
-                    raw: originNode.raw,
-                    startOffset,
-                    endOffset,
-                    startLine,
-                    endLine,
-                    startCol,
-                    endCol,
-                    type: 'psblock',
-                    nodeName: originNode.type,
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    isFragment: true,
-                    isGhost: false,
-                };
-                if ('block' in originNode && originNode.block && originNode.block.nodes.length > 0) {
-                    tag.childNodes = this.traverse(originNode.block.nodes, tag);
-                }
-                return tag;
-            }
-        }
-    }
-    traverse(
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    astNodes, parentNode = null) {
-        const nodeList = [];
-        let prevNode = null;
-        for (const astNode of astNodes) {
-            const nodes = this.nodeize(astNode, prevNode, parentNode);
-            if (!nodes || (Array.isArray(nodes) && nodes.length === 0)) {
-                continue;
-            }
-            let node;
-            if (Array.isArray(nodes)) {
-                const lastNode = nodes.at(-1);
-                if (!lastNode) {
-                    continue;
-                }
-                node = lastNode;
-            }
-            else {
-                node = nodes;
-            }
-            if (prevNode) {
-                if (node.type !== 'endtag') {
-                    prevNode.nextNode = node;
-                }
-                node.prevNode = prevNode;
-            }
-            prevNode = node;
-            if (Array.isArray(nodes)) {
-                nodeList.push(...nodes);
-            }
-            else {
-                nodeList.push(nodes);
-            }
-        }
-        return nodeList;
-    }
-}
-_Parser_ast = new WeakMap();