@markuplint/pug-parser 4.6.15 → 4.6.16

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.6.16](https://github.com/markuplint/markuplint/compare/@markuplint/pug-parser@4.6.15...@markuplint/pug-parser@4.6.16) (2025-02-11)
+
+### Bug Fixes
+
+- **pug-parser:** implemented previously unsupported nodes, including `InterpolatedTag` ([a89e39a](https://github.com/markuplint/markuplint/commit/a89e39ab5bc09bfef2c7bc7fdcba65f6b672eb34)), closes [#2440](https://github.com/markuplint/markuplint/issues/2440)
+
 ## [4.6.15](https://github.com/markuplint/markuplint/compare/@markuplint/pug-parser@4.6.14...@markuplint/pug-parser@4.6.15) (2025-02-04)
 
 **Note:** Version bump only for package @markuplint/pug-parser

package/lib/parser.d.ts

@@ -1,4 +1,4 @@
-import type { ASTNode } from './pug-parser/index.js';
+import type { ASTNode } from './types.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';

package/lib/parser.js

@@ -27,8 +27,9 @@ class PugParser extends Parser {
     }
     tokenize(options) {
         const offsetOffset = options?.offsetOffset ?? 0;
+        const ast = pugParse(this.rawCode, offsetOffset >= 1).nodes;
         return {
-            ast: pugParse(this.rawCode, offsetOffset >= 1).nodes,
+            ast: [...ast],
             isFragment: true,
         };
     }
@@ -53,7 +54,7 @@ class PugParser extends Parser {
                     ...token,
                     depth,
                     parentNode,
-                    name: originNode.val ?? '',
+                    name: originNode.raw ?? '',
                     publicId: '',
                     systemId: '',
                 });
@@ -72,7 +73,7 @@ class PugParser extends Parser {
                 const htmlDoc = new HtmlInPugParser().parse(originNode.raw, {
                     offsetOffset: originNode.offset,
                     offsetLine: originNode.line,
-                    offsetColumn: originNode.column,
+                    offsetColumn: originNode.column ?? parentNode?.endCol,
                     depth,
                 });
                 const newNodeList = [];
@@ -103,7 +104,7 @@ class PugParser extends Parser {
                 });
             }
             case 'BlockComment': {
-                const lastBlock = originNode.block.nodes.at(-1);
+                const lastBlock = originNode.block?.nodes.at(-1);
                 const endOffset = lastBlock ? lastBlock.endOffset : originNode.endOffset;
                 const token = this.sliceFragment(originNode.offset, endOffset);
                 return this.visitComment({
@@ -154,7 +155,7 @@ class PugParser extends Parser {
                     nodeName: originNode.name,
                     namespace,
                     isFragment: false,
-                }, originNode.block.nodes, {
+                }, originNode.block?.nodes ?? [], {
                     overwriteProps: {
                         attributes: [...attrs, ...andAttr],
                     },
@@ -162,7 +163,7 @@ class PugParser extends Parser {
             }
             default: {
                 let tokenIncludesFile = token;
-                if ('file' in originNode) {
+                if ('file' in originNode && originNode.file.column != null) {
                     const interval = originNode.file.column - originNode.endColumn;
                     const fileOffset = originNode.endOffset + interval;
                     const fileEndOffset = fileOffset + originNode.file.path.length;

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

@@ -1,178 +1,2 @@
+import type { ASTBlock } from '../types.js';
 export declare function pugParse(pug: string, useOffset?: boolean): ASTBlock;
-export type ASTBlock = PugAST<ASTNode>;
-export type ASTNode = ASTTagNode | ASTTextNode | ASTCodeNode | ASTComment | ASTBlockComment | ASTDoctype | ASTIncludeNode | ASTRawIncludeNode | ASTMixinNode | ASTMixinSlotNode | ASTNamedBlockNode | ASTFilterNode | ASTEachNode | ASTConditionalNode | ASTCaseNode | ASTCaseWhenNode;
-export type ASTTagNode = Omit<PugASTTagNode<ASTAttr, ASTBlock>, 'selfClosing' | 'isInline'> & AdditionalASTData;
-export type ASTTextNode = Omit<PugASTTextNode, 'val'> & AdditionalASTData;
-export type ASTCodeNode = PugASTCodeNode & AdditionalASTData;
-export type ASTComment = PugASTCommentNode & AdditionalASTData;
-export type ASTBlockComment = PugASTBlockCommentNode<ASTBlock> & AdditionalASTData;
-export type ASTDoctype = PugASTDoctypeNode & AdditionalASTData;
-export type ASTIncludeNode = PugASTIncludeNode<ASTBlock> & AdditionalASTData;
-export type ASTRawIncludeNode = PugASTRawIncludeNode & AdditionalASTData;
-export type ASTMixinNode = Omit<PugASTMixinNode<ASTAttr, ASTBlock>, 'attributeBlocks'> & AdditionalASTData;
-export type ASTMixinSlotNode = PugASTMixinSlotNode & AdditionalASTData;
-export type ASTNamedBlockNode = PugASTNamedBlockNode<ASTNode> & AdditionalASTData;
-export type ASTFilterNode = PugASTFilterNode<ASTAttr, ASTBlock> & AdditionalASTData;
-export type ASTEachNode = PugASTEachNode<ASTBlock> & AdditionalASTData;
-export type ASTConditionalNode = Omit<PugASTConditionalNode<ASTBlock>, 'consequent' | 'alternate'> & {
-    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;
-};
-interface PugAST<N> {
-    type: 'Block';
-    nodes: N[];
-    line: number;
-}
-type PugASTTagNode<A, B> = {
-    type: 'Tag';
-    name: string;
-    selfClosing: boolean;
-    attrs: A[];
-    attributeBlocks: {
-        type: 'AttributeBlock';
-        val: string;
-        line: number;
-        column: number;
-    }[];
-    isInline: boolean;
-    line: number;
-    column: number;
-    block: B;
-};
-type PugASTTextNode = {
-    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 PugASTCommentNode = {
-    type: 'Comment';
-    val: string;
-    buffer: boolean;
-    line: number;
-    column: number;
-};
-type PugASTBlockCommentNode<B> = {
-    type: 'BlockComment';
-    val: string;
-    block: B;
-    buffer: boolean;
-    line: number;
-    column: number;
-};
-type PugASTDoctypeNode = {
-    type: 'Doctype';
-    val: string;
-    line: number;
-    column: number;
-};
-type PugASTIncludeNode<B> = {
-    type: 'Include';
-    file: RugASTIncludeFile;
-    block: B;
-    line: number;
-    column: number;
-};
-type PugASTRawIncludeNode = {
-    type: 'RawInclude';
-    file: RugASTIncludeFile;
-    line: number;
-    column: number;
-    filters: unknown[];
-};
-type RugASTIncludeFile = {
-    type: 'FileReference';
-    path: string;
-    line: number;
-    column: number;
-};
-type PugASTEachNode<B> = {
-    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 PugASTMixinSlotNode = {
-    type: 'MixinBlock';
-    line: number;
-    column: number;
-};
-interface PugASTNamedBlockNode<N> {
-    type: 'NamedBlock';
-    name: string;
-    mode: 'replace' | 'append' | 'prepend';
-    nodes: N[];
-    line: number;
-    column: number;
-}
-type PugASTFilterNode<A, B> = {
-    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 PugASTCaseNode<B> = {
-    type: 'Case';
-    expr: string;
-    block: B;
-    line: number;
-    column: number;
-};
-type PugASTCaseWhenNode<B> = {
-    type: 'When';
-    expr: string;
-    block: B;
-    line: number;
-    column: number;
-};
-type PugASTAttr = {
-    name: string;
-    val: string | true;
-    mustEscape: boolean;
-    line: number;
-    column: number;
-};
-export {};

package/lib/pug-parser/index.js

@@ -61,15 +61,27 @@ originalAST,
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 tokens, pug) {
     const nodes = [];
+    if (!originalAST) {
+        return {
+            type: 'Block',
+            nodes: [],
+            line: 0,
+        };
+    }
     for (const node of originalAST.nodes) {
         const line = node.line;
-        const column = node.column;
+        const column = node.column ?? 0;
         const offsets = getOffsetsFromLines(pug);
         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);
         switch (node.type) {
+            case 'Block': {
+                const block = optimizeAST(node, tokens, pug);
+                nodes.push(...block.nodes);
+                continue;
+            }
             case 'Tag': {
                 const attrs = getAttrs(node.attrs, tokens, offsets, pug);
                 const { endOffset, endLine, endColumn } = getEndAttributeLocation(node.name, offset, line, column, tokens, offsets);
@@ -87,7 +99,10 @@ tokens, pug) {
                     endColumn,
                     block,
                     attrs,
-                    attributeBlocks: node.attributeBlocks,
+                    attributeBlocks: node.attributeBlocks ?? [],
+                    selfClosing: node.selfClosing,
+                    isInline: node.isInline,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(tagNode);
                 continue;
@@ -105,6 +120,7 @@ tokens, pug) {
                     column,
                     endColumn,
                     block,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(condNode);
                 const altNodes = optimizeASTOfConditionalNode(node, tokens, pug, offsets, 0);
@@ -126,6 +142,7 @@ tokens, pug) {
                     column,
                     endColumn,
                     block,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(eachNode);
                 continue;
@@ -143,6 +160,7 @@ tokens, pug) {
                     column,
                     endColumn,
                     block,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(includeNode);
                 continue;
@@ -159,6 +177,7 @@ tokens, pug) {
                     column,
                     endColumn,
                     filters: node.filters,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(includeNode);
                 continue;
@@ -187,6 +206,8 @@ tokens, pug) {
                     endColumn,
                     block,
                     attrs,
+                    attributeBlocks: node.attributeBlocks ?? [],
+                    filename: node.filename ?? null,
                 };
                 nodes.push(mixinNode);
                 continue;
@@ -201,6 +222,7 @@ tokens, pug) {
                     endLine,
                     column,
                     endColumn,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(mixinNode);
                 continue;
@@ -235,6 +257,7 @@ tokens, pug) {
                     endLine,
                     column,
                     endColumn,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(commentNode);
                 continue;
@@ -253,11 +276,13 @@ tokens, pug) {
                     endLine,
                     column,
                     endColumn,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(commentNode);
                 continue;
             }
             case 'Code': {
+                const block = optimizeAST(node.block, tokens, pug);
                 const newNode = {
                     type: node.type,
                     raw,
@@ -271,6 +296,8 @@ tokens, pug) {
                     endLine,
                     column,
                     endColumn,
+                    block,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(newNode);
                 continue;
@@ -279,7 +306,7 @@ tokens, pug) {
                 const pipelessText = getPipelessText(node, pug, tokens);
                 if (pipelessText) {
                     const textNode = {
-                        type: node.type,
+                        ...node,
                         ...pipelessText,
                     };
                     nodes.push(textNode);
@@ -292,7 +319,6 @@ tokens, pug) {
             case 'Doctype': {
                 const commentNode = {
                     type: node.type,
-                    val: node.val,
                     raw,
                     offset,
                     endOffset,
@@ -300,6 +326,7 @@ tokens, pug) {
                     endLine,
                     column,
                     endColumn,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(commentNode);
                 continue;
@@ -318,6 +345,7 @@ tokens, pug) {
                     column,
                     endColumn,
                     block,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(caseNode);
                 continue;
@@ -339,14 +367,100 @@ tokens, pug) {
                     endColumn,
                     block,
                     attrs,
+                    filename: node.filename ?? null,
                 };
                 nodes.push(filterNode);
                 continue;
             }
+            case 'Extends': {
+                const optimizedNode = {
+                    ...node,
+                    raw,
+                    offset,
+                    endOffset,
+                    line,
+                    endLine,
+                    column,
+                    endColumn,
+                };
+                nodes.push(optimizedNode);
+                continue;
+            }
+            case 'FileReference': {
+                const optimizedNode = {
+                    ...node,
+                    raw,
+                    offset,
+                    endOffset,
+                    line,
+                    endLine,
+                    column,
+                    endColumn,
+                };
+                nodes.push(optimizedNode);
+                continue;
+            }
+            case 'IncludeFilter': {
+                const optimizedNode = {
+                    ...node,
+                    raw,
+                    offset,
+                    endOffset,
+                    line,
+                    endLine,
+                    column,
+                    endColumn,
+                };
+                nodes.push(optimizedNode);
+                continue;
+            }
+            case 'InterpolatedTag': {
+                const block = optimizeAST(node.block, tokens, pug);
+                const optimizedNode = {
+                    ...node,
+                    raw,
+                    offset,
+                    endOffset,
+                    line,
+                    endLine,
+                    column,
+                    endColumn,
+                    block,
+                };
+                nodes.push(optimizedNode);
+                continue;
+            }
+            case 'While': {
+                const optimizedNode = {
+                    ...node,
+                    raw,
+                    offset,
+                    endOffset,
+                    line,
+                    endLine,
+                    column,
+                    endColumn,
+                };
+                nodes.push(optimizedNode);
+                continue;
+            }
+            case 'YieldBlock': {
+                const optimizedNode = {
+                    ...node,
+                    raw,
+                    offset,
+                    endOffset,
+                    line,
+                    endLine,
+                    column,
+                    endColumn,
+                };
+                nodes.push(optimizedNode);
+                continue;
+            }
             default: {
-                throw new Error(`Unsupported syntax: The "${
-                // @ts-ignore
-                node.type}" node\n${JSON.stringify(node, null, 2)}`);
+                // @ts-expect-error
+                throw new Error(`Unsupported syntax: The "${node.type}" node\n${JSON.stringify(node, null, 2)}`);
             }
         }
     }
@@ -373,7 +487,7 @@ tokens, pug, offsets, depth) {
     if (tokenOfCurrentNode) {
         // console.log(JSON.stringify(node, null, 2));
         const lineOffset = Math.max(offsets[node.line - 2] ?? 0, 0);
-        const offset = lineOffset + node.column - 1;
+        const offset = lineOffset + (node.column ?? 0) - 1;
         const length = tokenOfCurrentNode.loc.end.column - tokenOfCurrentNode.loc.start.column;
         const endOffset = offset + length;
         const raw = pug.slice(offset, endOffset);
@@ -389,6 +503,7 @@ tokens, pug, offsets, depth) {
             column: tokenOfCurrentNode.loc.start.column,
             endColumn: tokenOfCurrentNode.loc.end.column,
             block,
+            filename: node.filename ?? null,
         });
     }
     if ('alternate' in node && node.alternate) {
@@ -421,6 +536,7 @@ tokens, pug, offsets, depth) {
                     column: tokenOfCurrentNode.loc.start.column,
                     endColumn: tokenOfCurrentNode.loc.end.column,
                     block,
+                    filename: node.filename ?? null,
                 });
                 break;
             }
@@ -605,12 +721,14 @@ tokens, pug) {
             result.push({
                 type: 'Text',
                 raw,
+                val: raw,
                 offset,
                 endOffset: rawLoc.endOffset,
                 line,
                 endLine,
                 column,
                 endColumn,
+                filename: null,
             });
         }
         offset = rawLoc.endOffset;

package/lib/types.d.ts

@@ -0,0 +1,342 @@
+export type AdditionalASTData = {
+    raw: string;
+    offset: number;
+    endOffset: number;
+    endLine: number;
+    endColumn: number;
+};
+export type ASTNode = ASTDoctype | ASTComment | ASTBlockComment | ASTText | ASTTag | ASTInterpolatedTag | ASTCode | ASTConditional | ASTCase | ASTWhen | ASTWhile | ASTEach | ASTMixin | ASTMixinBlock | ASTYieldBlock | ASTFileReference | ASTInclude | ASTRawInclude | ASTIncludeFilter | ASTExtends | ASTNamedBlock | ASTFilter;
+export type ASTBlock = {
+    type: 'Block';
+    nodes: readonly ASTNode[];
+    line: number;
+};
+export type ASTDoctype = PugAST.Doctype & AdditionalASTData;
+export type ASTComment = PugAST.Comments.Comment & AdditionalASTData;
+export type ASTBlockComment = Omit<PugAST.Comments.BlockComment, 'block'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTText = PugAST.Text & AdditionalASTData;
+export type ASTTag = Omit<PugAST.Tag, 'attrs' | 'block'> & {
+    attrs: readonly ASTAttr[];
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTInterpolatedTag = Omit<PugAST.InterpolatedTag, 'block'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTCode = Omit<PugAST.Code, 'block'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTConditional = Omit<PugAST.CodeHelpers.Conditional, 'consequent' | 'alternate'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTCase = Omit<PugAST.CodeHelpers.CaseWhen.Case, 'block'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTWhen = Omit<PugAST.CodeHelpers.CaseWhen.When, 'block'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTWhile = PugAST.While & AdditionalASTData;
+export type ASTEach = Omit<PugAST.Each, 'block' | 'alternate'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTMixin = Omit<PugAST.Mixin, 'block'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTMixinBlock = PugAST.MixinBlock & AdditionalASTData;
+export type ASTYieldBlock = PugAST.YieldBlock & AdditionalASTData;
+export type ASTFileReference = PugAST.FileOperations.FileReference & AdditionalASTData;
+export type ASTInclude = Omit<PugAST.FileOperations.Include, 'block'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTRawInclude = PugAST.FileOperations.RawInclude & AdditionalASTData;
+export type ASTIncludeFilter = PugAST.FileOperations.IncludeFilter & AdditionalASTData;
+export type ASTExtends = PugAST.FileOperations.Extends & AdditionalASTData;
+export type ASTNamedBlock = Omit<PugAST.FileOperations.NamedBlock, 'nodes'> & {
+    nodes: readonly ASTNode[];
+} & AdditionalASTData;
+export type ASTFilter = Omit<PugAST.Filter, 'block'> & {
+    block: ASTBlock | null;
+} & AdditionalASTData;
+export type ASTAttr = PugAST.AbstractNodeTypes.Attribute & AdditionalASTData;
+export declare namespace PugAST {
+    /**
+     * Node objects
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#node-objects
+     */
+    interface _Node {
+        type: string;
+        line: number;
+        column: number | null;
+        filename: string | null;
+    }
+    /**
+     * Block
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#blocks
+     */
+    export interface Block extends _Node {
+        type: 'Block';
+        nodes: Node[];
+    }
+    /**
+     * Abstract Node Types
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#abstract-node-types
+     */
+    export namespace AbstractNodeTypes {
+        interface AttributedNode extends _Node {
+            attrs: Attribute[];
+            attributeBlocks: AttributeBlock[];
+        }
+        interface BlockNode extends _Node {
+            block: Block | null;
+        }
+        interface ExpressionNode extends _Node {
+            expr: JavaScriptExpression;
+        }
+        interface PlaceholderNode extends _Node {
+        }
+        interface ValueNode extends _Node {
+            val: string;
+        }
+        interface Attribute {
+            name: string;
+            val: JavaScriptExpression;
+            mustEscape: boolean;
+            line: number;
+            column: number;
+        }
+        type JavaScriptExpression = string & {};
+        type JavaScriptIdentifier = string & {};
+        interface AttributeBlock {
+            type: 'AttributeBlock';
+            val: JavaScriptExpression;
+            line: number;
+            column: number;
+        }
+    }
+    /**
+     * Doctypes
+     *
+     * https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#doctypes
+     */
+    export interface Doctype extends _Node {
+        type: 'Doctype';
+    }
+    /**
+     * Comments
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#comments
+     */
+    export namespace Comments {
+        interface CommonComment extends AbstractNodeTypes.ValueNode {
+            buffer: boolean;
+        }
+        export interface Comment extends CommonComment {
+            type: 'Comment';
+        }
+        export interface BlockComment extends AbstractNodeTypes.BlockNode, CommonComment {
+            type: 'BlockComment';
+        }
+        export {};
+    }
+    /**
+     * Text
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#text
+     */
+    export interface Text extends AbstractNodeTypes.ValueNode {
+        type: 'Text';
+    }
+    /**
+     * Tag
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#tag
+     */
+    export interface CommonTag extends AbstractNodeTypes.AttributedNode, AbstractNodeTypes.BlockNode {
+        selfClosing: boolean;
+        isInline: boolean;
+    }
+    /**
+     * Regular Tag
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#regular-tag
+     */
+    export interface Tag extends CommonTag {
+        type: 'Tag';
+        name: string;
+    }
+    /**
+     * Interpolated Tag
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#interpolated-tag
+     */
+    export interface InterpolatedTag extends CommonTag, AbstractNodeTypes.ExpressionNode {
+        type: 'InterpolatedTag';
+    }
+    /**
+     * Code
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#code
+     */
+    export interface Code extends AbstractNodeTypes.BlockNode, AbstractNodeTypes.ValueNode {
+        type: 'Code';
+        buffer: boolean;
+        mustEscape: boolean;
+        isInline: boolean;
+    }
+    /**
+     * Code Helpers
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#code-helpers
+     */
+    export namespace CodeHelpers {
+        /**
+         * Conditional
+         *
+         * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#conditional
+         */
+        interface Conditional extends _Node {
+            type: 'Conditional';
+            test: AbstractNodeTypes.JavaScriptExpression;
+            consequent: Block;
+            alternate: Conditional | Block | null;
+        }
+        /**
+         * Case/When
+         *
+         * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#casewhen
+         */
+        namespace CaseWhen {
+            export interface Case extends AbstractNodeTypes.BlockNode, AbstractNodeTypes.ExpressionNode {
+                type: 'Case';
+                block: WhenBlock;
+            }
+            interface WhenBlock extends Block {
+            }
+            export interface When extends AbstractNodeTypes.BlockNode, AbstractNodeTypes.ExpressionNode {
+                type: 'When';
+                expr: AbstractNodeTypes.JavaScriptExpression | 'default';
+            }
+            export {};
+        }
+    }
+    /**
+     * While
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#while
+     */
+    export interface While extends _Node {
+        type: 'While';
+        test: AbstractNodeTypes.JavaScriptExpression;
+    }
+    /**
+     * Each
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#each
+     */
+    export interface Each extends AbstractNodeTypes.BlockNode {
+        type: 'Each';
+        obj: AbstractNodeTypes.JavaScriptExpression;
+        val: AbstractNodeTypes.JavaScriptIdentifier;
+        key: AbstractNodeTypes.JavaScriptIdentifier | null;
+        alternate: Block | null;
+    }
+    /**
+     * Mixin
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#mixin
+     */
+    export interface Mixin extends AbstractNodeTypes.AttributedNode, AbstractNodeTypes.BlockNode {
+        type: 'Mixin';
+        name: AbstractNodeTypes.JavaScriptIdentifier;
+        call: boolean;
+        args: string;
+    }
+    /**
+     * MixinBlock
+     *
+     * @see
+     */
+    export interface MixinBlock extends AbstractNodeTypes.PlaceholderNode {
+        type: 'MixinBlock';
+    }
+    /**
+     * Yield
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#yield
+     */
+    export interface YieldBlock extends AbstractNodeTypes.PlaceholderNode {
+        type: 'YieldBlock';
+    }
+    /**
+     * File Operations
+     *
+     * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#file-operations
+     */
+    export namespace FileOperations {
+        /**
+         * FileReference
+         *
+         * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#filereference
+         */
+        export interface FileReference extends _Node {
+            type: 'FileReference';
+            path: string;
+        }
+        interface FileNode extends _Node {
+            file: FileReference;
+        }
+        /**
+         * Pug Include
+         *
+         * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#pug-include
+         */
+        export interface Include extends AbstractNodeTypes.BlockNode, FileNode {
+            type: 'Include';
+        }
+        /**
+         * Raw Include
+         *
+         * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#raw-include
+         */
+        export interface RawInclude extends FileNode {
+            type: 'RawInclude';
+            filters: IncludeFilter[];
+        }
+        export interface IncludeFilter extends FilterNode {
+            type: 'IncludeFilter';
+        }
+        /**
+         * Extends/NamedBlock
+         *
+         * @see https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#extendsnamedblock
+         */
+        export interface Extends extends FileNode {
+            type: 'Extends';
+        }
+        export interface NamedBlock extends AbstractNodeTypes.PlaceholderNode {
+            type: 'NamedBlock';
+            name: string;
+            mode: 'replace' | 'append' | 'prepend';
+            nodes: Node[];
+        }
+        export {};
+    }
+    interface FilterNode extends _Node {
+        name: string;
+        attrs: AbstractNodeTypes.Attribute[];
+    }
+    /**
+     * Filters
+     *
+     * @see	https://github.com/pugjs/pug-ast-spec/blob/master/parser.md#filter
+     */
+    export interface Filter extends FilterNode, AbstractNodeTypes.BlockNode {
+        type: 'Filter';
+    }
+    export type Node = Block | Doctype | Comments.Comment | Comments.BlockComment | Text | Tag | InterpolatedTag | Code | CodeHelpers.Conditional | CodeHelpers.CaseWhen.Case | CodeHelpers.CaseWhen.When | While | Each | Mixin | MixinBlock | YieldBlock | FileOperations.FileReference | FileOperations.Include | FileOperations.RawInclude | FileOperations.IncludeFilter | FileOperations.Extends | FileOperations.NamedBlock | Filter;
+    export {};
+}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/pug-parser",
-	"version": "4.6.15",
+	"version": "4.6.16",
 	"description": "Pug parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -22,11 +22,11 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "4.6.15",
+		"@markuplint/html-parser": "4.6.16",
 		"@markuplint/ml-ast": "4.4.9",
-		"@markuplint/parser-utils": "4.8.3",
+		"@markuplint/parser-utils": "4.8.4",
 		"pug-lexer": "5.0.1",
 		"pug-parser": "6.0.0"
 	},
-	"gitHead": "687a84e00546b8f1f2ed88125fe507239723c8d8"
+	"gitHead": "f9f6c415b8a3a231aac56181892bb393aeb8ae1a"
 }