@markuplint/html-parser 3.13.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/get-namespace.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNamespace = void 0;
-const parse5_1 = require("parse5");
+import { parse, parseFragment } from 'parse5';
 const DEFAULT_NAMESPACE = 'http://www.w3.org/1999/xhtml';
-function getNamespace(tagName, parentNamespace = DEFAULT_NAMESPACE) {
+export function getNamespace(tagName, parentNamespace = DEFAULT_NAMESPACE) {
     switch (parentNamespace) {
         case 'http://www.w3.org/2000/svg':
         case 'http://www.w3.org/1998/Math/MathML': {
             const parent = parentNamespace === 'http://www.w3.org/2000/svg' ? 'svg' : 'math';
             const tag = `<${parent}><${tagName}></${parent}>`;
-            const frag = (0, parse5_1.parseFragment)(tag);
+            const frag = parseFragment(tag);
             const node = frag.childNodes[0];
             if (!node) {
                 return DEFAULT_NAMESPACE;
@@ -21,10 +18,10 @@ function getNamespace(tagName, parentNamespace = DEFAULT_NAMESPACE) {
         }
     }
     const tag = `<${tagName}>`;
-    const frag = (0, parse5_1.parseFragment)(tag);
+    const frag = parseFragment(tag);
     let node = frag.childNodes[0];
     if (!node) {
-        const doc = (0, parse5_1.parse)(tag);
+        const doc = parse(tag);
         node = doc.childNodes[0];
     }
     if (node && 'namespaceURI' in node) {
@@ -32,4 +29,3 @@ function getNamespace(tagName, parentNamespace = DEFAULT_NAMESPACE) {
     }
     return DEFAULT_NAMESPACE;
 }
-exports.getNamespace = getNamespace;

package/lib/index.d.ts

@@ -1,6 +1,2 @@
-export { default as attrTokenizer } from './attr-tokenizer';
-export { default as isDocumentFragment } from './is-document-fragment';
-export { default as parseRawTag } from './parse-raw-tag';
-export { getNamespace } from './get-namespace';
-export { parse } from './parse';
-export { createTree } from './create-tree';
+export { getNamespace } from './get-namespace.js';
+export { parser, HtmlParser } from './parser.js';

package/lib/index.js

@@ -1,18 +1,2 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTree = exports.parse = exports.getNamespace = exports.parseRawTag = exports.isDocumentFragment = exports.attrTokenizer = void 0;
-var attr_tokenizer_1 = require("./attr-tokenizer");
-Object.defineProperty(exports, "attrTokenizer", { enumerable: true, get: function () { return __importDefault(attr_tokenizer_1).default; } });
-var is_document_fragment_1 = require("./is-document-fragment");
-Object.defineProperty(exports, "isDocumentFragment", { enumerable: true, get: function () { return __importDefault(is_document_fragment_1).default; } });
-var parse_raw_tag_1 = require("./parse-raw-tag");
-Object.defineProperty(exports, "parseRawTag", { enumerable: true, get: function () { return __importDefault(parse_raw_tag_1).default; } });
-var get_namespace_1 = require("./get-namespace");
-Object.defineProperty(exports, "getNamespace", { enumerable: true, get: function () { return get_namespace_1.getNamespace; } });
-var parse_1 = require("./parse");
-Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parse_1.parse; } });
-var create_tree_1 = require("./create-tree");
-Object.defineProperty(exports, "createTree", { enumerable: true, get: function () { return create_tree_1.createTree; } });
+export { getNamespace } from './get-namespace.js';
+export { parser, HtmlParser } from './parser.js';

package/lib/is-document-fragment.d.ts

@@ -1 +1 @@
-export default function isDocumentFragment(html: string): boolean;
+export declare function isDocumentFragment(html: string): boolean;

package/lib/is-document-fragment.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function isDocumentFragment(html) {
-    return !/^\s*(<!doctype html(?:\s*.+)?>|<html(?:\s|>))/im.test(html);
+export function isDocumentFragment(html) {
+    return !/^\s*(?:<!doctype html(?:\s*(?:\S.*|[\t\v\f \u00A0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))?>|<html[\s>])/im.test(html);
 }
-exports.default = isDocumentFragment;

package/lib/optimize-starts-head-or-body.d.ts

@@ -1,11 +1,10 @@
-import type { MLASTNode } from '@markuplint/ml-ast';
-export declare function isStartsHeadTagOrBodyTag(rawCode: string): boolean;
-export declare function optimizeStartsHeadTagOrBodyTagSetup(rawCode: string): {
-	code: string;
-	heads: string[];
-	bodies: string[];
+import type { HtmlParser } from './parser.js';
+import type { MLASTNodeTreeItem } from '@markuplint/ml-ast';
+export type Replacements = {
+    readonly code: string;
+    readonly heads: readonly string[];
+    readonly bodies: readonly string[];
 };
-export declare function optimizeStartsHeadTagOrBodyTagResume(
-	nodeList: MLASTNode[],
-	replacements: ReturnType<typeof optimizeStartsHeadTagOrBodyTagSetup>,
-): void;
+export declare function isStartsHeadTagOrBodyTag(rawCode: string): boolean;
+export declare function optimizeStartsHeadTagOrBodyTagSetup(rawCode: string): Replacements;
+export declare function optimizeStartsHeadTagOrBodyTagResume(parser: HtmlParser, nodeList: readonly MLASTNodeTreeItem[], replacements: Replacements): readonly MLASTNodeTreeItem[];

package/lib/optimize-starts-head-or-body.js

@@ -1,17 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.optimizeStartsHeadTagOrBodyTagResume = exports.optimizeStartsHeadTagOrBodyTagSetup = exports.isStartsHeadTagOrBodyTag = void 0;
 const UNDUPLICATED_CHAR = '\uFFFD';
-function isStartsHeadTagOrBodyTag(rawCode) {
-    return /^\s*<(?:head|body)>/i.test(rawCode);
+export function isStartsHeadTagOrBodyTag(rawCode) {
+    return /^\s*<(?:head|body)[\s>]/i.test(rawCode);
 }
-exports.isStartsHeadTagOrBodyTag = isStartsHeadTagOrBodyTag;
-function optimizeStartsHeadTagOrBodyTagSetup(rawCode) {
+export function optimizeStartsHeadTagOrBodyTagSetup(rawCode) {
+    if (!isStartsHeadTagOrBodyTag(rawCode)) {
+        return {
+            code: rawCode,
+            heads: [],
+            bodies: [],
+        };
+    }
     const heads = [];
     const bodies = [];
-    const code = rawCode.replace(
-    // eslint-disable-next-line no-control-regex
-    /(?<=<\/?)(?:head|body)(?=\u0009|\u000A|\u000C|\u0020|\/|>|\u0000)/gi, tag => {
+    const code = rawCode.replaceAll(/(?<=<\/?)(?:head|body)(?=[\0\t\n\f />])/gi, tag => {
         const prefix = `x-${UNDUPLICATED_CHAR}`;
         let name;
         if (/^head$/i.test(tag)) {
@@ -33,25 +34,34 @@ function optimizeStartsHeadTagOrBodyTagSetup(rawCode) {
         bodies,
     };
 }
-exports.optimizeStartsHeadTagOrBodyTagSetup = optimizeStartsHeadTagOrBodyTagSetup;
-function optimizeStartsHeadTagOrBodyTagResume(
+export function optimizeStartsHeadTagOrBodyTagResume(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeList, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-replacements) {
-    nodeList.forEach(node => {
+parser, nodeList, replacements) {
+    const heads = [...replacements.heads];
+    const bodies = [...replacements.bodies];
+    for (const node of nodeList) {
         if (!node.nodeName.startsWith(`x-${UNDUPLICATED_CHAR}`)) {
-            return;
+            continue;
         }
-        const realName = node.nodeName === `x-${UNDUPLICATED_CHAR}h` ? replacements.heads.shift() : replacements.bodies.shift();
+        const realName = node.nodeName === `x-${UNDUPLICATED_CHAR}h` ? heads.shift() : bodies.shift();
         if (!realName) {
-            return;
+            continue;
+        }
+        if (node.type !== 'starttag' && node.type !== 'endtag') {
+            continue;
         }
-        node.raw = node.raw.replace(node.nodeName, realName);
-        node.nodeName = realName;
+        parser.updateRaw(node, node.raw.replace(node.nodeName, realName));
         if (node.type === 'starttag') {
-            node.elementType = 'html';
+            parser.updateElement(node, {
+                nodeName: realName,
+                elementType: 'html',
+            });
+            continue;
         }
-    });
+        parser.updateElement(node, {
+            nodeName: realName,
+        });
+        continue;
+    }
+    return nodeList;
 }
-exports.optimizeStartsHeadTagOrBodyTagResume = optimizeStartsHeadTagOrBodyTagResume;

package/lib/parser.d.ts

@@ -0,0 +1,33 @@
+import type { Replacements } from './optimize-starts-head-or-body.js';
+import type { Node } from './types.js';
+import type { MLASTNodeTreeItem, MLASTParentNode } from '@markuplint/ml-ast';
+import type { ChildToken, ParseOptions, ParserOptions } from '@markuplint/parser-utils';
+import { Parser } from '@markuplint/parser-utils';
+type State = {
+    startsHeadTagOrBodyTag: Replacements | null;
+    afterPosition: {
+        endOffset: number;
+        endLine: number;
+        endCol: number;
+        depth: number;
+    };
+};
+type ExtendsOptions = Pick<ParserOptions, 'ignoreTags' | 'maskChar'>;
+export declare class HtmlParser extends Parser<Node, State> {
+    constructor(options?: ExtendsOptions);
+    tokenize(): {
+        ast: import("node_modules/parse5/dist/tree-adapters/default.js").ChildNode[];
+        isFragment: boolean;
+    };
+    beforeParse(rawCode: string, options?: ParseOptions): string;
+    afterParse(nodeList: readonly MLASTNodeTreeItem[], options?: ParseOptions): readonly MLASTNodeTreeItem[];
+    nodeize(originNode: Node, parentNode: MLASTParentNode | null, depth: number): readonly MLASTNodeTreeItem[];
+    afterNodeize(siblings: readonly MLASTNodeTreeItem[], parentNode: MLASTParentNode | null, depth: number): {
+        siblings: import("@markuplint/ml-ast").MLASTChildNode[];
+        ancestors: MLASTNodeTreeItem[];
+    };
+    visitText(token: ChildToken): readonly MLASTNodeTreeItem[];
+    visitSpreadAttr(): null;
+}
+export declare const parser: HtmlParser;
+export {};

package/lib/parser.js

@@ -0,0 +1,162 @@
+import { Parser } from '@markuplint/parser-utils';
+import { parse, parseFragment } from 'parse5';
+import { isDocumentFragment } from './is-document-fragment.js';
+import { optimizeStartsHeadTagOrBodyTagResume, optimizeStartsHeadTagOrBodyTagSetup, } from './optimize-starts-head-or-body.js';
+export class HtmlParser extends Parser {
+    constructor(options) {
+        super(options, {
+            startsHeadTagOrBodyTag: null,
+            afterPosition: {
+                endOffset: 0,
+                endLine: 1,
+                endCol: 1,
+                depth: 0,
+            },
+        });
+    }
+    tokenize() {
+        const isFragment = isDocumentFragment(this.rawCode);
+        const parseFn = isFragment ? parseFragment : parse;
+        const doc = parseFn(this.rawCode, {
+            scriptingEnabled: false,
+            sourceCodeLocationInfo: true,
+        });
+        const childNodes = doc.childNodes;
+        return {
+            ast: childNodes,
+            isFragment,
+        };
+    }
+    beforeParse(rawCode, options) {
+        rawCode = super.beforeParse(rawCode, options);
+        const replacements = optimizeStartsHeadTagOrBodyTagSetup(rawCode);
+        if (replacements?.code) {
+            this.state.startsHeadTagOrBodyTag = replacements;
+            return replacements.code;
+        }
+        this.state.afterPosition = {
+            endOffset: (options?.offsetOffset ?? 0) + this.state.afterPosition.endOffset,
+            endLine: (options?.offsetLine ?? 0) + this.state.afterPosition.endLine,
+            endCol: (options?.offsetColumn ?? 0) + this.state.afterPosition.endCol,
+            depth: this.state.afterPosition.depth,
+        };
+        return rawCode;
+    }
+    afterParse(nodeList, options) {
+        nodeList = super.afterParse(nodeList, options);
+        if (this.state.startsHeadTagOrBodyTag) {
+            return optimizeStartsHeadTagOrBodyTagResume(this, nodeList, this.state.startsHeadTagOrBodyTag);
+        }
+        return nodeList;
+    }
+    nodeize(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    originNode, parentNode, depth) {
+        const namespace = 'namespaceURI' in originNode ? originNode.namespaceURI : '';
+        const location = originNode.sourceCodeLocation;
+        if (!location) {
+            // Ghost element
+            const afterNode = this.state.afterPosition.depth === depth ? this.state.afterPosition : parentNode;
+            const startOffset = afterNode?.endOffset ?? 0;
+            const startLine = afterNode?.endLine ?? 0;
+            const startCol = afterNode?.endCol ?? 0;
+            const childNodes = 'childNodes' in originNode ? originNode.childNodes : [];
+            return this.visitElement({
+                raw: '',
+                startOffset,
+                startLine,
+                startCol,
+                depth,
+                parentNode,
+                nodeName: originNode.nodeName,
+                namespace,
+            }, childNodes);
+        }
+        const { startOffset, endOffset } = location;
+        const token = this.sliceFragment(startOffset, endOffset ?? startOffset);
+        switch (originNode.nodeName) {
+            case '#documentType': {
+                if (!('name' in originNode)) {
+                    throw new TypeError("DocumentType doesn't have name");
+                }
+                return this.visitDoctype({
+                    ...token,
+                    depth,
+                    name: originNode.name ?? '',
+                    publicId: originNode.publicId ?? '',
+                    systemId: originNode.systemId ?? '',
+                    parentNode,
+                });
+            }
+            case '#text': {
+                return this.visitText({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case '#comment': {
+                return this.visitComment({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            default: {
+                const tagLoc = 'startTag' in location ? location.startTag : null;
+                const offset = tagLoc?.startOffset ?? startOffset;
+                const endOffset = tagLoc?.endOffset ?? offset;
+                const startTagToken = this.sliceFragment(offset, endOffset);
+                const childNodes = 'childNodes' in originNode
+                    ? originNode.nodeName === 'template' && 'content' in originNode
+                        ? originNode.content.childNodes
+                        : originNode.childNodes
+                    : [];
+                return this.visitElement({
+                    ...startTagToken,
+                    depth,
+                    parentNode,
+                    nodeName: originNode.nodeName,
+                    namespace,
+                }, childNodes, {
+                    createEndTagToken: () => {
+                        const endTagLoc = 'endTag' in location ? location.endTag : null;
+                        if (!endTagLoc) {
+                            return null;
+                        }
+                        const { startOffset, endOffset } = endTagLoc;
+                        const endTagToken = this.sliceFragment(startOffset, endOffset);
+                        return {
+                            ...endTagToken,
+                            depth,
+                            parentNode,
+                        };
+                    },
+                });
+            }
+        }
+    }
+    afterNodeize(siblings, parentNode, depth) {
+        const after = super.afterNodeize(siblings, parentNode, depth);
+        const prevNode = after.siblings.at(-1) ?? after.ancestors.findLast(n => n.depth === depth);
+        if (prevNode) {
+            this.state.afterPosition = {
+                endOffset: prevNode.endOffset,
+                endLine: prevNode.endLine,
+                endCol: prevNode.endCol,
+                depth,
+            };
+        }
+        return after;
+    }
+    visitText(token) {
+        return super.visitText(token, {
+            researchTags: true,
+            invalidTagAsText: true,
+        });
+    }
+    visitSpreadAttr() {
+        return null;
+    }
+}
+export const parser = new HtmlParser();

package/lib/types.d.ts

@@ -0,0 +1,9 @@
+export type { ParserOptions, DefaultTreeAdapterMap } from 'parse5';
+import type { DefaultTreeAdapterMap } from 'parse5';
+export type Node = DefaultTreeAdapterMap['node'];
+export type TextNode = DefaultTreeAdapterMap['textNode'];
+export type Element = DefaultTreeAdapterMap['element'];
+export type CommentNode = DefaultTreeAdapterMap['commentNode'];
+export type Document = DefaultTreeAdapterMap['document'];
+export type DocumentFragment = DefaultTreeAdapterMap['documentFragment'];
+export type ChildNode = DefaultTreeAdapterMap['childNode'];

package/lib/types.js

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

package/package.json

@@ -1,12 +1,17 @@
 {
 	"name": "@markuplint/html-parser",
-	"version": "3.13.0",
+	"version": "4.0.0-alpha.10",
 	"description": "HTML parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
 	"private": false,
-	"main": "lib/index.js",
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./lib/index.js"
+		}
+	},
 	"types": "lib/index.d.ts",
 	"publishConfig": {
 		"access": "public"
@@ -20,11 +25,10 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "3.2.0",
-		"@markuplint/parser-utils": "3.13.0",
+		"@markuplint/ml-ast": "4.0.0-alpha.10",
+		"@markuplint/parser-utils": "4.0.0-alpha.10",
 		"parse5": "7.1.2",
-		"tslib": "^2.6.2",
-		"type-fest": "^4.8.2"
+		"type-fest": "^4.10.1"
 	},
-	"gitHead": "b37b749d7ac0f9e6cbd022ee7031bc020c6677d3"
+	"gitHead": "b41153ea665aa8f091daf6114a06047f4ccb8350"
 }

package/lib/attr-tokenizer.d.ts

@@ -1,2 +0,0 @@
-import type { MLASTHTMLAttr } from '@markuplint/ml-ast';
-export default function attrTokenizer(raw: string, line: number, col: number, startOffset: number): MLASTHTMLAttr;

package/lib/attr-tokenizer.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const parser_utils_1 = require("@markuplint/parser-utils");
-const reAttrsInStartTag = 
-// eslint-disable-next-line no-control-regex
-/(\s*)([^\x00-\x1f\x7f-\x9f "'>/=]+)(?:(\s*)(=)(\s*)(?:(?:"([^"]*)")|(?:'([^']*)')|([^\s]*)))?/;
-function attrTokenizer(raw, line, col, startOffset) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const attrMatchedMap = raw.match(reAttrsInStartTag);
-    if (!attrMatchedMap) {
-        throw new SyntaxError('Illegal attribute token');
-    }
-    const spacesBeforeAttrString = (_a = attrMatchedMap[1]) !== null && _a !== void 0 ? _a : '';
-    const nameChars = (_b = attrMatchedMap[2]) !== null && _b !== void 0 ? _b : '';
-    const spacesBeforeEqualChars = (_c = attrMatchedMap[3]) !== null && _c !== void 0 ? _c : '';
-    const equalChars = (_d = attrMatchedMap[4]) !== null && _d !== void 0 ? _d : null;
-    const spacesAfterEqualChars = (_e = attrMatchedMap[5]) !== null && _e !== void 0 ? _e : '';
-    const quoteChars = attrMatchedMap[6] != null ? '"' : attrMatchedMap[7] != null ? "'" : null;
-    const valueChars = (_h = (_g = (_f = attrMatchedMap[6]) !== null && _f !== void 0 ? _f : attrMatchedMap[7]) !== null && _g !== void 0 ? _g : attrMatchedMap[8]) !== null && _h !== void 0 ? _h : (quoteChars ? '' : null);
-    let offset = startOffset;
-    const spacesBeforeName = (0, parser_utils_1.tokenizer)(spacesBeforeAttrString, line, col, offset);
-    line = spacesBeforeName.endLine;
-    col = spacesBeforeName.endCol;
-    offset = spacesBeforeName.endOffset;
-    const name = (0, parser_utils_1.tokenizer)(nameChars, line, col, offset);
-    line = name.endLine;
-    col = name.endCol;
-    offset = name.endOffset;
-    const spacesBeforeEqual = (0, parser_utils_1.tokenizer)(spacesBeforeEqualChars, line, col, offset);
-    line = spacesBeforeEqual.endLine;
-    col = spacesBeforeEqual.endCol;
-    offset = spacesBeforeEqual.endOffset;
-    const equal = (0, parser_utils_1.tokenizer)(equalChars, line, col, offset);
-    line = equal.endLine;
-    col = equal.endCol;
-    offset = equal.endOffset;
-    const spacesAfterEqual = (0, parser_utils_1.tokenizer)(spacesAfterEqualChars, line, col, offset);
-    line = spacesAfterEqual.endLine;
-    col = spacesAfterEqual.endCol;
-    offset = spacesAfterEqual.endOffset;
-    const startQuote = (0, parser_utils_1.tokenizer)(quoteChars, line, col, offset);
-    line = startQuote.endLine;
-    col = startQuote.endCol;
-    offset = startQuote.endOffset;
-    const value = (0, parser_utils_1.tokenizer)(valueChars, line, col, offset);
-    line = value.endLine;
-    col = value.endCol;
-    offset = value.endOffset;
-    const endQuote = (0, parser_utils_1.tokenizer)(quoteChars, line, col, offset);
-    const attrToken = (0, parser_utils_1.tokenizer)(nameChars +
-        spacesBeforeEqualChars +
-        (equalChars !== null && equalChars !== void 0 ? equalChars : '') +
-        spacesAfterEqualChars +
-        (quoteChars !== null && quoteChars !== void 0 ? quoteChars : '') +
-        (valueChars !== null && valueChars !== void 0 ? valueChars : '') +
-        (quoteChars !== null && quoteChars !== void 0 ? quoteChars : ''), name.startLine, name.startCol, name.startOffset);
-    return {
-        type: 'html-attr',
-        uuid: (0, parser_utils_1.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,
-        isDuplicatable: false,
-        nodeName: name.raw,
-        parentNode: null,
-        prevNode: null,
-        nextNode: null,
-        isFragment: false,
-        isGhost: false,
-    };
-}
-exports.default = attrTokenizer;

package/lib/create-tree.d.ts

@@ -1,8 +0,0 @@
-import type { MLASTNode } from '@markuplint/ml-ast';
-export declare function createTree(
-	rawCode: string,
-	isFragment: boolean,
-	offsetOffset: number,
-	offsetLine: number,
-	offsetColumn: number,
-): MLASTNode[];