@markuplint/pug-parser 3.12.0 → 4.0.0-alpha.10

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';
-export declare const endTag = 'never';
+export { parser } from './parser.js';

package/lib/index.js

@@ -1,6 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.endTag = exports.parse = void 0;
-var parse_1 = require("./parse");
-Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parse_1.parse; } });
-exports.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.d.ts

@@ -1,21 +1,7 @@
 export declare function pugParse(pug: string): 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 | ASTCodeNode | ASTComment | ASTDoctype | ASTIncludeNode | ASTMixinNode | ASTMixinSlotNode | ASTFilterNode | ASTEachNode | ASTConditionalNode | ASTCaseNode | ASTCaseWhenNode;
+export type ASTTagNode = Omit<PugASTTagNode<ASTAttr, ASTBlock>, 'attributeBlocks' | 'selfClosing' | 'isInline'> & AdditionalASTData;
 export type ASTTextNode = Omit<PugASTTextNode, 'val'> & AdditionalASTData;
 export type ASTCodeNode = PugASTCodeNode & AdditionalASTData;
 export type ASTComment = PugASTCommentNode & AdditionalASTData;
@@ -26,135 +12,135 @@ export type ASTMixinSlotNode = PugASTMixinSlotNode & AdditionalASTData;
 export type ASTFilterNode = PugASTFilterNode<ASTAttr, ASTBlock> & AdditionalASTData;
 export type ASTEachNode = PugASTEachNode<ASTBlock> & AdditionalASTData;
 export type ASTConditionalNode = Omit<PugASTConditionalNode<ASTBlock>, 'consequent' | 'alternate'> & {
-	block: ASTBlock;
+    block: ASTBlock;
 } & AdditionalASTData;
 export type ASTCaseNode = PugASTCaseNode<ASTBlock> & AdditionalASTData;
 export type ASTCaseWhenNode = PugASTCaseWhenNode<ASTBlock> & AdditionalASTData;
 export type ASTAttr = PugASTAttr & AdditionalASTData;
 type AdditionalASTData = {
-	raw: string;
-	offset: number;
-	endOffset: number;
-	endLine: number;
-	endColumn: number;
+    raw: string;
+    offset: number;
+    endOffset: number;
+    endLine: number;
+    endColumn: number;
 };
 interface PugAST<N> {
-	type: 'Block';
-	nodes: N[];
-	line: number;
+    type: 'Block';
+    nodes: N[];
+    line: number;
 }
 type PugASTTagNode<A, B> = {
-	type: 'Tag';
-	name: string;
-	selfClosing: boolean;
-	attrs: A[];
-	attributeBlocks: never[];
-	isInline: boolean;
-	line: number;
-	column: number;
-	block: B;
+    type: 'Tag';
+    name: string;
+    selfClosing: boolean;
+    attrs: A[];
+    attributeBlocks: never[];
+    isInline: boolean;
+    line: number;
+    column: number;
+    block: B;
 };
 type PugASTTextNode = {
-	type: 'Text';
-	val: string;
-	isHtml?: true;
-	line: number;
-	column: number;
+    type: 'Text';
+    val: string;
+    isHtml?: true;
+    line: number;
+    column: number;
 };
 type PugASTCodeNode = {
-	type: 'Code';
-	val: string;
-	buffer: boolean;
-	mustEscape: boolean;
-	isInline: boolean;
-	line: number;
-	column: number;
+    type: 'Code';
+    val: string;
+    buffer: boolean;
+    mustEscape: boolean;
+    isInline: boolean;
+    line: number;
+    column: number;
 };
 type PugASTCommentNode = {
-	type: 'Comment';
-	val: string;
-	buffer: boolean;
-	line: number;
-	column: number;
+    type: 'Comment';
+    val: string;
+    buffer: boolean;
+    line: number;
+    column: number;
 };
 type PugASTDoctypeNode = {
-	type: 'Doctype';
-	val: string;
-	line: number;
-	column: number;
+    type: 'Doctype';
+    val: string;
+    line: number;
+    column: number;
 };
 type PugASTIncludeNode<B> = {
-	type: 'Include';
-	file: {
-		type: 'FileReference';
-		path: string;
-		line: number;
-		column: number;
-	};
-	block: B;
-	line: number;
-	column: number;
+    type: 'Include';
+    file: {
+        type: 'FileReference';
+        path: string;
+        line: number;
+        column: number;
+    };
+    block: B;
+    line: number;
+    column: number;
 };
 type PugASTEachNode<B> = {
-	type: 'Each';
-	obj: string;
-	val: string;
-	key: string | null;
-	block: B;
-	line: number;
-	column: number;
+    type: 'Each';
+    obj: string;
+    val: string;
+    key: string | null;
+    block: B;
+    line: number;
+    column: number;
 };
 type PugASTMixinNode<A, B> = {
-	type: 'Mixin';
-	name: string;
-	args: string;
-	call: boolean;
-	block: B | null;
-	attrs?: A[];
-	attributeBlocks: never[];
-	line: number;
-	column: number;
+    type: 'Mixin';
+    name: string;
+    args: string;
+    call: boolean;
+    block: B | null;
+    attrs?: A[];
+    attributeBlocks: never[];
+    line: number;
+    column: number;
 };
 type PugASTMixinSlotNode = {
-	type: 'MixinBlock';
-	line: number;
-	column: number;
+    type: 'MixinBlock';
+    line: number;
+    column: number;
 };
 type PugASTFilterNode<A, B> = {
-	type: 'Filter';
-	name: string;
-	block: B;
-	attrs: A[];
-	line: number;
-	column: number;
+    type: 'Filter';
+    name: string;
+    block: B;
+    attrs: A[];
+    line: number;
+    column: number;
 };
 type PugASTConditionalNode<B> = {
-	type: 'Conditional';
-	test: string;
-	consequent: B;
-	alternate?: B | PugASTConditionalNode<B>;
-	line: number;
-	column: number;
+    type: 'Conditional';
+    test: string;
+    consequent: B;
+    alternate?: B | PugASTConditionalNode<B>;
+    line: number;
+    column: number;
 };
 type PugASTCaseNode<B> = {
-	type: 'Case';
-	expr: string;
-	block: B;
-	line: number;
-	column: number;
+    type: 'Case';
+    expr: string;
+    block: B;
+    line: number;
+    column: number;
 };
 type PugASTCaseWhenNode<B> = {
-	type: 'When';
-	expr: string;
-	block: B;
-	line: number;
-	column: number;
+    type: 'When';
+    expr: string;
+    block: B;
+    line: number;
+    column: number;
 };
 type PugASTAttr = {
-	name: string;
-	val: string | true;
-	mustEscape: boolean;
-	line: number;
-	column: number;
+    name: string;
+    val: string | true;
+    mustEscape: boolean;
+    line: number;
+    column: number;
 };
 export {};

package/lib/pug-parser/index.js

@@ -1,24 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pugParse = void 0;
-const tslib_1 = require("tslib");
 // @ts-ignore
-const pug_lexer_1 = tslib_1.__importDefault(require("pug-lexer"));
+import lexer from 'pug-lexer';
 // @ts-ignore
-const pug_parser_1 = tslib_1.__importDefault(require("pug-parser"));
-const get_offset_from_line_and_col_1 = require("../utils/get-offset-from-line-and-col");
-function pugParse(pug) {
-    const lexOrigin = (0, pug_lexer_1.default)(pug);
+import parser from 'pug-parser';
+import { getOffsetFromLineAndCol } from '../utils/get-offset-from-line-and-col.js';
+export function pugParse(pug) {
+    const lexOrigin = lexer(pug);
     const lex = JSON.parse(JSON.stringify(lexOrigin));
-    const originAst = (0, pug_parser_1.default)(lexOrigin);
-    // console.log(lex);
-    // console.log(JSON.stringify(originAst, null, 2));
+    const originAst = parser(lexOrigin);
     const ast = optimizeAST(originAst, lex, pug);
     return ast;
 }
-exports.pugParse = pugParse;
 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;
@@ -29,10 +22,9 @@ function getOffsetsFromLines(pug) {
 function mergeTextNode(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 nodes, pug) {
-    var _a;
     const baseNodes = [];
     for (const node of nodes) {
-        const prevNode = (_a = baseNodes[baseNodes.length - 1]) !== null && _a !== void 0 ? _a : null;
+        const prevNode = baseNodes.at(-1) ?? null;
         if (prevNode && prevNode.type === 'Text' && node.type === 'Text') {
             prevNode.raw = pug.slice(prevNode.offset, node.endOffset);
             prevNode.endColumn = node.endColumn;
@@ -55,13 +47,12 @@ function optimizeAST(
 originalAST, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 tokens, pug) {
-    var _a;
     const nodes = [];
     for (const node of originalAST.nodes) {
         const line = node.line;
         const column = node.column;
         const offsets = getOffsetsFromLines(pug);
-        const lineOffset = Math.max((_a = offsets[line - 2]) !== null && _a !== void 0 ? _a : 0, 0);
+        const lineOffset = Math.max(offsets[line - 2] ?? 0, 0);
         const offset = lineOffset + column - 1;
         const { endLine, endColumn, endOffset } = getLocationFromToken(offset, line, column, tokens);
         const raw = pug.slice(offset, endOffset);
@@ -299,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)}`);
             }
         }
     }
@@ -316,7 +308,6 @@ function optimizeASTOfConditionalNode(
 node, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 tokens, pug, offsets, depth) {
-    var _a, _b;
     const altNodes = [];
     let tokenOfCurrentNode = null;
     for (const token of tokens) {
@@ -327,7 +318,7 @@ tokens, pug, offsets, depth) {
     }
     if (tokenOfCurrentNode) {
         // console.log(JSON.stringify(node, null, 2));
-        const lineOffset = Math.max((_a = offsets[node.line - 2]) !== null && _a !== void 0 ? _a : 0, 0);
+        const lineOffset = Math.max(offsets[node.line - 2] ?? 0, 0);
         const offset = lineOffset + node.column - 1;
         const length = tokenOfCurrentNode.loc.end.column - tokenOfCurrentNode.loc.start.column;
         const endOffset = offset + length;
@@ -359,7 +350,7 @@ tokens, pug, offsets, depth) {
                 if (!tokenOfCurrentNode) {
                     return [];
                 }
-                const lineOffset = Math.max((_b = offsets[tokenOfCurrentNode.loc.start.line - 2]) !== null && _b !== void 0 ? _b : 0, 0);
+                const lineOffset = Math.max(offsets[tokenOfCurrentNode.loc.start.line - 2] ?? 0, 0);
                 const offset = lineOffset + tokenOfCurrentNode.loc.start.column - 1;
                 const length = tokenOfCurrentNode.loc.end.column - tokenOfCurrentNode.loc.start.column;
                 const endOffset = offset + length;
@@ -390,7 +381,7 @@ tokens, pug, offsets, depth) {
 function getLocationFromToken(offset, line, column, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 tokens, tokenType) {
-    const tokenTypes = typeof tokenType === 'string' ? (tokenType !== '' ? [tokenType] : null) : tokenType !== null && tokenType !== void 0 ? tokenType : null;
+    const tokenTypes = typeof tokenType === 'string' ? (tokenType === '' ? null : [tokenType]) : tokenType ?? null;
     let tokenOfCurrentNode = null;
     for (const token of tokens) {
         if ((tokenTypes == null || tokenTypes.includes(token.type)) &&
@@ -416,10 +407,9 @@ function getAttrs(
 originalAttrs, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 tokens, offsets, pug) {
-    var _a;
     const attrs = [];
     for (const attr of originalAttrs) {
-        const attrLineOffset = (_a = offsets[attr.line - 2]) !== null && _a !== void 0 ? _a : 0;
+        const attrLineOffset = offsets[attr.line - 2] ?? 0;
         const attrOffset = attrLineOffset + attr.column - 1;
         let tokenOfCurrentAttr = null;
         for (const token of tokens) {
@@ -452,7 +442,6 @@ tokens, offsets, pug) {
 function getEndAttributeLocation(nodeName, offset, line, column, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 tokens, offsets) {
-    var _a;
     let beforeNewlineToken = null;
     for (const token of tokens) {
         // Searching token after the tag node.
@@ -463,7 +452,7 @@ tokens, offsets) {
             token.type !== 'end-attributes' &&
             token.type !== 'id' &&
             token.type !== 'class') {
-            const endAttrLineOffset = Math.max((_a = offsets[beforeNewlineToken.loc.end.line - 2]) !== null && _a !== void 0 ? _a : 0, 0);
+            const endAttrLineOffset = Math.max(offsets[beforeNewlineToken.loc.end.line - 2] ?? 0, 0);
             const endAttrOffset = endAttrLineOffset + beforeNewlineToken.loc.end.column - 1;
             return {
                 endOffset: endAttrOffset,
@@ -500,8 +489,8 @@ tokens) {
     if (startPipelessText.loc.start.line < node.line && node.line < endPipelessText.loc.start.line) {
         const { line, column } = startPipelessText.loc.start;
         const { line: endLine, column: endColumn } = endPipelessText.loc.end;
-        const offset = (0, get_offset_from_line_and_col_1.getOffsetFromLineAndCol)(pug, line, column);
-        const endOffset = (0, get_offset_from_line_and_col_1.getOffsetFromLineAndCol)(pug, endLine, endColumn);
+        const offset = getOffsetFromLineAndCol(pug, line, column);
+        const endOffset = getOffsetFromLineAndCol(pug, endLine, endColumn);
         const raw = pug.slice(offset, endOffset);
         return {
             raw,
@@ -518,7 +507,6 @@ tokens) {
 function getRawTextAndLocationEnd(val, offset, line, column, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 tokens, offsets, pug) {
-    var _a;
     let beforeNewlineToken = null;
     for (const token of tokens) {
         // Searching token after the text.
@@ -528,7 +516,7 @@ tokens, offsets, pug) {
             token.type !== 'text-html' &&
             token.type !== 'indent' &&
             token.type !== 'outdent') {
-            const endAttrLineOffset = Math.max((_a = offsets[beforeNewlineToken.loc.end.line - 2]) !== null && _a !== void 0 ? _a : 0, 0);
+            const endAttrLineOffset = Math.max(offsets[beforeNewlineToken.loc.end.line - 2] ?? 0, 0);
             const endAttrOffset = endAttrLineOffset + beforeNewlineToken.loc.end.column - 1;
             return {
                 endOffset: endAttrOffset,

package/lib/utils/get-offset-from-line-and-col.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOffsetFromLineAndCol = void 0;
-function getOffsetFromLineAndCol(str, line, col) {
+export function getOffsetFromLineAndCol(str, line, col) {
     const lines = str.split('\n').slice(0, line);
     const lastLine = lines.pop();
     if (lastLine) {
-        lines.push(lastLine.split('').slice(0, col).join(''));
+        lines.push([...lastLine].slice(0, col).join(''));
     }
     return lines.join('\n').length;
 }
-exports.getOffsetFromLineAndCol = getOffsetFromLineAndCol;