@markuplint/pug-parser 4.0.0-dev.20 → 4.0.0-dev.23

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2023 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,29 @@
+import type { ASTNode } from './pug-parser/index.js';
+import type { MLASTAttr, MLASTNodeTreeItem, MLASTParentNode } from '@markuplint/ml-ast';
+import type { ChildToken, Token } from '@markuplint/parser-utils';
+import { ParserError, Parser } from '@markuplint/parser-utils';
+declare class PugParser extends Parser<ASTNode> {
+    constructor();
+    tokenize(): {
+        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): (import("@markuplint/ml-ast").MLASTHTMLAttr & {
+        __rightText?: string | undefined;
+    }) | (import("@markuplint/ml-ast").MLASTSpreadAttr & {
+        __rightText?: string | undefined;
+    });
+}
+export declare const parser: PugParser;
+export {};

package/lib/parser.js

@@ -0,0 +1,162 @@
+import { getNamespace, parser as htmlParser } from '@markuplint/html-parser';
+import { ParserError, Parser, AttrState, removeQuote, scriptParser } from '@markuplint/parser-utils';
+import { pugParse } from './pug-parser/index.js';
+class PugParser extends Parser {
+    constructor() {
+        super({
+            endTagType: 'never',
+        });
+    }
+    tokenize() {
+        return {
+            ast: pugParse(this.rawCode).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 = htmlParser.parse(originNode.raw, {
+                    offsetOffset: originNode.offset,
+                    offsetLine: originNode.line,
+                    offsetColumn: originNode.column,
+                    depth,
+                });
+                return htmlDoc.nodeList;
+            }
+            case 'Comment': {
+                return this.visitComment({
+                    ...token,
+                    depth,
+                    parentNode,
+                }, {
+                    isBogus: false,
+                });
+            }
+            case 'Tag': {
+                const namespace = getNamespace(originNode.name, parentNamespace);
+                return this.visitElement({
+                    ...token,
+                    depth,
+                    parentNode,
+                    nodeName: originNode.name,
+                    namespace,
+                }, originNode.block.nodes, {
+                    overwriteProps: {
+                        attributes: originNode.attrs.map(attr => {
+                            const token = this.sliceFragment(attr.offset, attr.endOffset);
+                            return this.visitAttr(token);
+                        }),
+                    },
+                });
+            }
+            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;
+            }
+            this.updateAttr(attr, {
+                potentialName: token.raw[0] === '#' ? 'id' : 'class',
+                potentialValue: attr.value.raw.slice(1),
+                isDuplicatable: attr.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 });
+        }
+        const valueCodeTokens = scriptParser(attr.value.raw.trim());
+        if (valueCodeTokens.length === 1) {
+            const token = valueCodeTokens[0];
+            if (token.type === 'Numeric' || token.type === 'Boolean') {
+                this.updateAttr(attr, { potentialValue: token.value });
+            }
+            else if (token.type === 'String' || token.type === 'Template') {
+                this.updateAttr(attr, { potentialValue: removeQuote(token.value) });
+            }
+            else {
+                this.updateAttr(attr, { isDynamicValue: true });
+            }
+        }
+        else {
+            this.updateAttr(attr, { isDynamicValue: true });
+        }
+        return attr;
+    }
+}
+export const parser = new PugParser();

package/lib/pug-parser/index.js

@@ -7,8 +7,6 @@ export function pugParse(pug) {
     const lexOrigin = lexer(pug);
     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;
 }
@@ -292,8 +290,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.20+6b35da16",
+	"version": "4.0.0-dev.23+d6f2aa9bc",
 	"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.20+6b35da16",
-		"@markuplint/ml-ast": "4.0.0-dev.20+6b35da16",
-		"@markuplint/parser-utils": "4.0.0-dev.20+6b35da16",
+		"@markuplint/html-parser": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/ml-ast": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/parser-utils": "4.0.0-dev.23+d6f2aa9bc",
 		"pug-lexer": "^5.0.1",
 		"pug-parser": "^6.0.0"
 	},
-	"gitHead": "6b35da161d94f784953d0adecc2d28502052d92a"
+	"gitHead": "d6f2aa9bc287768466f23b5340e4e0eecfa30d59"
 }

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 declare function attrTokenizer(attr: ASTAttr): MLASTAttr;

package/lib/attr-tokenizer.js

@@ -1,134 +0,0 @@
-import { tokenizer, uuid, scriptParser, removeQuote } from '@markuplint/parser-utils';
-export function attrTokenizer(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-attr) {
-    if (attr.raw[0] === '#' || attr.raw[0] === '.') {
-        const value = `${attr.val}`;
-        const potentialValue = removeQuote(value);
-        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,
-            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;
-    const quoteChars = '';
-    let valueChars;
-    let potentialValue;
-    let isDynamicValue = undefined;
-    if (attr.val === true) {
-        spacesBeforeEqualChars = '';
-        equalChars = '';
-        spacesAfterEqualChars = '';
-        valueChars = '';
-        potentialValue = '';
-    }
-    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 valueTokens = scriptParser(attr.val);
-        spacesBeforeEqualChars = before ?? '';
-        equalChars = equal ?? '';
-        spacesAfterEqualChars = after ?? '';
-        valueChars = attr.val;
-        potentialValue = removeQuote(attr.val);
-        if (valueTokens.length > 1 || valueTokens[0].type !== 'String') {
-            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,
-        potentialValue,
-        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();