@markuplint/parser-utils 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/attr-tokenizer.d.ts

@@ -0,0 +1,18 @@
+import type { QuoteSet } from './types.js';
+import { AttrState } from './enums.js';
+/**
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#tag-name-state
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#before-attribute-name-state
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#attribute-name-state
+ */
+export declare function attrTokenizer(raw: string, quoteSet?: readonly QuoteSet[], startState?: AttrState, quoteInValueChars?: ReadonlyArray<QuoteSet>, endOfUnquotedValueChars?: ReadonlyArray<string>): {
+    spacesBeforeAttrName: string;
+    attrName: string;
+    spacesBeforeEqual: string;
+    equal: string;
+    spacesAfterEqual: string;
+    quoteStart: string;
+    attrValue: string;
+    quoteEnd: string;
+    leftover: string;
+};

package/lib/attr-tokenizer.js

@@ -0,0 +1,169 @@
+import { defaultSpaces } from './const.js';
+import { AttrState } from './enums.js';
+const defaultQuoteSet = [
+    { start: '"', end: '"' },
+    { start: "'", end: "'" },
+];
+const defaultQuoteInValueChars = [];
+const spaces = defaultSpaces;
+const EQUAL = '=';
+/**
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#tag-name-state
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#before-attribute-name-state
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#attribute-name-state
+ */
+export function attrTokenizer(raw, quoteSet = defaultQuoteSet, startState = AttrState.BeforeName, quoteInValueChars = defaultQuoteInValueChars, endOfUnquotedValueChars = [...defaultSpaces, '/', '>']) {
+    let state = startState;
+    let spacesBeforeAttrName = '';
+    let attrName = '';
+    let spacesBeforeEqual = '';
+    let equal = '';
+    let spacesAfterEqual = '';
+    let quoteTypeIndex = -1;
+    let quoteStart = '';
+    let attrValue = '';
+    let quoteEnd = '';
+    const isBeforeValueStarted = startState === AttrState.BeforeValue;
+    const quoteModeStack = [];
+    const chars = [...raw];
+    while (chars.length > 0) {
+        if (state === AttrState.AfterValue) {
+            break;
+        }
+        const char = chars.shift();
+        switch (state) {
+            case AttrState.BeforeName: {
+                if (char === '>') {
+                    chars.unshift(char);
+                    state = AttrState.AfterValue;
+                    break;
+                }
+                if (char === '/') {
+                    chars.unshift(char);
+                    state = AttrState.AfterValue;
+                    break;
+                }
+                if (spaces.includes(char)) {
+                    spacesBeforeAttrName += char;
+                    break;
+                }
+                attrName += char;
+                state = AttrState.Name;
+                break;
+            }
+            case AttrState.Name: {
+                if (char === '>') {
+                    chars.unshift(char);
+                    state = AttrState.AfterValue;
+                    break;
+                }
+                if (char === '/') {
+                    chars.unshift(char);
+                    state = AttrState.AfterValue;
+                    break;
+                }
+                if (spaces.includes(char)) {
+                    spacesBeforeEqual += char;
+                    state = AttrState.Equal;
+                    break;
+                }
+                if (char === EQUAL) {
+                    equal += char;
+                    state = AttrState.BeforeValue;
+                    break;
+                }
+                attrName += char;
+                break;
+            }
+            case AttrState.Equal: {
+                if (spaces.includes(char)) {
+                    spacesBeforeEqual += char;
+                    break;
+                }
+                if (char === EQUAL) {
+                    equal += char;
+                    state = AttrState.BeforeValue;
+                    break;
+                }
+                // End of attribute
+                chars.unshift(spacesBeforeEqual, char);
+                spacesBeforeEqual = '';
+                state = AttrState.AfterValue;
+                break;
+            }
+            case AttrState.BeforeValue: {
+                if (endOfUnquotedValueChars.includes(char) && spaces.includes(char)) {
+                    if (isBeforeValueStarted) {
+                        spacesBeforeAttrName += char;
+                        break;
+                    }
+                    spacesAfterEqual += char;
+                    break;
+                }
+                quoteTypeIndex = quoteSet.findIndex(quote => quote.start === char);
+                const quote = quoteSet[quoteTypeIndex];
+                if (quote) {
+                    quoteStart = quote.start;
+                    state = AttrState.Value;
+                    break;
+                }
+                const raw = char + chars.join('');
+                const inQuote = quoteInValueChars.find(quote => raw.startsWith(quote.start));
+                if (inQuote) {
+                    quoteModeStack.push(inQuote);
+                    attrValue += inQuote.start;
+                    chars.splice(0, inQuote.start.length - 1);
+                    state = AttrState.Value;
+                    break;
+                }
+                chars.unshift(char);
+                state = AttrState.Value;
+                break;
+            }
+            case AttrState.Value: {
+                if (!quoteSet[quoteTypeIndex] && endOfUnquotedValueChars.includes(char)) {
+                    chars.unshift(char);
+                    state = AttrState.AfterValue;
+                    break;
+                }
+                if (quoteModeStack.length === 0 && char === quoteSet[quoteTypeIndex]?.end) {
+                    quoteEnd = char;
+                    state = AttrState.AfterValue;
+                    break;
+                }
+                const raw = char + chars.join('');
+                const inQuoteEnd = quoteModeStack.at(-1);
+                if (inQuoteEnd && raw.startsWith(inQuoteEnd.end)) {
+                    quoteModeStack.pop();
+                    attrValue += inQuoteEnd.end;
+                    chars.splice(0, inQuoteEnd.end.length - 1);
+                    break;
+                }
+                const inQuoteStart = quoteInValueChars.find(quote => raw.startsWith(quote.start));
+                if (inQuoteStart) {
+                    quoteModeStack.push(inQuoteStart);
+                    attrValue += inQuoteStart.start;
+                    chars.splice(0, inQuoteStart.start.length - 1);
+                    break;
+                }
+                attrValue += char;
+                break;
+            }
+        }
+    }
+    if (state === AttrState.Value && quoteTypeIndex !== -1) {
+        throw new SyntaxError(`Unclosed attribute value: ${raw}`);
+    }
+    const leftover = chars.join('');
+    return {
+        spacesBeforeAttrName,
+        attrName,
+        spacesBeforeEqual,
+        equal,
+        spacesAfterEqual,
+        quoteStart,
+        attrValue,
+        quoteEnd,
+        leftover,
+    };
+}

package/lib/const.d.ts

@@ -1,10 +1,17 @@
-export declare const MASK_CHAR = '\uE000';
+export declare const MASK_CHAR = "\uE000";
 /**
  * SVG Element list
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Element
  */
 export declare const svgElementList: string[];
-export declare const reTag: RegExp;
 export declare const reTagName: RegExp;
 export declare const reSplitterTag: RegExp;
+/**
+ * - U+0009 CHARACTER TABULATION (tab) => `\t`
+ * - U+000A LINE FEED (LF) => `\n`
+ * - U+000C FORM FEED (FF) => `\f`
+ * - U+000D CARRIAGE RETURN (CR) => `\r`
+ * - U+0020 SPACE => ` `
+ */
+export declare const defaultSpaces: readonly ["\t", "\n", "\f", "\r", " "];

package/lib/const.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reSplitterTag = exports.reTagName = exports.reTag = exports.svgElementList = exports.MASK_CHAR = void 0;
-exports.MASK_CHAR = '\uE000';
+export const MASK_CHAR = '\uE000';
 /**
  * SVG Element list
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Element
  */
-exports.svgElementList = [
+export const svgElementList = [
     'a',
     'animate',
     'animateMotion',
@@ -97,7 +94,13 @@ exports.svgElementList = [
     'tref',
     'vkern',
 ];
-exports.reTag = /^<((?:.|\s|\n)+)>\s*$/;
-// eslint-disable-next-line no-control-regex
-exports.reTagName = /^(?:[a-z][^\u0000\u0009\u000A\u000C\u0020/>]*)/i;
-exports.reSplitterTag = /<[^>]+>/g;
+export const reTagName = /^[a-z][^\0\t\n\f />]*/i;
+export const reSplitterTag = /<[^>]+>/g;
+/**
+ * - U+0009 CHARACTER TABULATION (tab) => `\t`
+ * - U+000A LINE FEED (LF) => `\n`
+ * - U+000C FORM FEED (FF) => `\f`
+ * - U+000D CARRIAGE RETURN (CR) => `\r`
+ * - U+0020 SPACE => ` `
+ */
+export const defaultSpaces = ['\t', '\n', '\f', '\r', ' '];

package/lib/debugger.d.ts

@@ -1,3 +1,4 @@
 import type { MLASTAttr, MLASTNode } from '@markuplint/ml-ast';
-export declare function nodeListToDebugMaps(nodeList: MLASTNode[], withAttr?: boolean): string[];
-export declare function attributesToDebugMaps(attributes: MLASTAttr[]): string[][];
+export declare function nodeListToDebugMaps(nodeList: readonly (MLASTNode | null)[], withAttr?: boolean): string[];
+export declare function attributesToDebugMaps(attributes: readonly MLASTAttr[]): string[][];
+export declare function nodeTreeDebugView(nodeTree: readonly MLASTNode[]): (string | undefined)[];

package/lib/debugger.js

@@ -1,64 +1,63 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attributesToDebugMaps = exports.nodeListToDebugMaps = void 0;
-function nodeListToDebugMaps(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeList, withAttr = false) {
-    return nodeList
-        .map(n => {
+export function nodeListToDebugMaps(nodeList, withAttr = false) {
+    return nodeList.flatMap(n => {
         const r = [];
-        if (!n.isGhost) {
-            r.push(tokenDebug(n));
-            if (withAttr && 'attributes' in n) {
-                r.push(...attributesToDebugMaps(n.attributes).flat());
-            }
-        }
-        else {
-            r.push(`[N/A]>[N/A](N/A)${n.nodeName}: ${visibleWhiteSpace(n.raw)}`);
+        r.push(tokenDebug(n));
+        if (withAttr && n && n.type === 'starttag') {
+            r.push(...attributesToDebugMaps(n.attributes).flat());
         }
         return r;
-    })
-        .flat();
+    });
 }
-exports.nodeListToDebugMaps = nodeListToDebugMaps;
-function attributesToDebugMaps(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-attributes) {
+export function attributesToDebugMaps(attributes) {
     return attributes.map(n => {
         const r = [
             tokenDebug({
                 ...n,
-                name: n.type === 'html-attr' ? n.name.raw : n.raw,
+                name: n.type === 'attr' ? n.name.raw : n.raw,
             }),
         ];
-        if (n.type === 'html-attr') {
-            r.push(`  ${tokenDebug(n.spacesBeforeName, 'bN')}`);
-            r.push(`  ${tokenDebug(n.name, 'name')}`);
-            r.push(`  ${tokenDebug(n.spacesBeforeEqual, 'bE')}`);
-            r.push(`  ${tokenDebug(n.equal, 'equal')}`);
-            r.push(`  ${tokenDebug(n.spacesAfterEqual, 'aE')}`);
-            r.push(`  ${tokenDebug(n.startQuote, 'sQ')}`);
-            r.push(`  ${tokenDebug(n.value, 'value')}`);
-            r.push(`  ${tokenDebug(n.endQuote, 'eQ')}`);
-            r.push(`  isDirective: ${!!n.isDirective}`);
-            r.push(`  isDynamicValue: ${!!n.isDynamicValue}`);
+        if (n.type === 'spread') {
+            r.push(`  #spread: ${visibleWhiteSpace(n.raw)}`);
+            return r;
         }
+        r.push(`  ${tokenDebug(n.spacesBeforeName, 'bN')}`, `  ${tokenDebug(n.name, 'name')}`, `  ${tokenDebug(n.spacesBeforeEqual, 'bE')}`, `  ${tokenDebug(n.equal, 'equal')}`, `  ${tokenDebug(n.spacesAfterEqual, 'aE')}`, `  ${tokenDebug(n.startQuote, 'sQ')}`, `  ${tokenDebug(n.value, 'value')}`, `  ${tokenDebug(n.endQuote, 'eQ')}`, `  isDirective: ${!!n.isDirective}`, `  isDynamicValue: ${!!n.isDynamicValue}`);
         if (n.potentialName != null) {
             r.push(`  potentialName: ${visibleWhiteSpace(n.potentialName)}`);
         }
-        if (n.type === 'html-attr' && n.candidate) {
+        if (n.candidate) {
             r.push(`  candidate: ${visibleWhiteSpace(n.candidate)}`);
         }
         return r;
     });
 }
-exports.attributesToDebugMaps = attributesToDebugMaps;
+export function nodeTreeDebugView(nodeTree) {
+    return nodeTree
+        .map((n, i) => {
+        const lines = [];
+        if (n.type === 'attr' || n.type === 'spread') {
+            return;
+        }
+        lines.push(`${i.toString().padStart(3, '0')}: [${n.uuid.slice(0, 8)}] ${'  '.repeat(Math.max(n.depth, 0))}${n.type === 'endtag' ? '/' : ''}${n.nodeName}(${n.uuid.slice(0, 8)})${n.type === 'starttag' && n.isGhost ? '[👻]' : ''}${n.type === 'starttag'
+            ? ` => ${n.pairNode ? `/${n.pairNode.nodeName}(${n.pairNode.uuid.slice(0, 8)})` : '💀'}`
+            : ''}`);
+        if (n.type === 'starttag' || n.type === 'psblock') {
+            for (const c of n.childNodes ?? []) {
+                lines.push(`${' '.repeat(15)}   ${'  '.repeat(Math.max(n.depth, 0))}┗━ ${c.type === 'endtag' ? '/' : ''}${c.nodeName}(${c.uuid.slice(0, 8)})`);
+            }
+        }
+        return lines;
+    })
+        .filter(Boolean)
+        .flat();
+}
 function tokenDebug(n, type = '') {
-    var _a, _b, _c, _d;
+    if (!n) {
+        return 'NULL';
+    }
     return `[${n.startLine}:${n.startCol}]>[${n.endLine}:${n.endCol}](${n.startOffset},${n.endOffset})${
     // @ts-ignore
-    (_d = (_c = (_b = (_a = n.potentialName) !== null && _a !== void 0 ? _a : n.nodeName) !== null && _b !== void 0 ? _b : n.name) !== null && _c !== void 0 ? _c : n.type) !== null && _d !== void 0 ? _d : type}: ${visibleWhiteSpace(n.raw)}`;
+    n.potentialName ?? n.nodeName ?? n.name ?? n.type ?? type}${'isGhost' in n && n.isGhost ? '(👻)' : ''}${'isBogus' in n && n.isBogus ? '(👿)' : ''}: ${visibleWhiteSpace(n.raw)}`;
 }
 function visibleWhiteSpace(chars) {
-    return chars.replace(/\n/g, '⏎').replace(/\t/g, '→').replace(/\s/g, '␣');
+    return chars.replaceAll('\n', '⏎').replaceAll('\t', '→').replaceAll(/\s/g, '␣');
 }

package/lib/decision.js

@@ -1,20 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPotentialCustomElementName = exports.isSVGElement = void 0;
-const types_1 = require("@markuplint/types");
-const const_1 = require("./const");
+import { isCustomElementName } from '@markuplint/types';
+import { svgElementList } from './const.js';
 /**
  *
  *
  * @param nodeName
  * @returns
  */
-function isSVGElement(nodeName) {
-    return const_1.svgElementList.includes(nodeName);
+export function isSVGElement(nodeName) {
+    return svgElementList.includes(nodeName);
 }
-exports.isSVGElement = isSVGElement;
-const isCEN = (0, types_1.isCustomElementName)();
-function isPotentialCustomElementName(tagName) {
+const isCEN = isCustomElementName();
+export function isPotentialCustomElementName(tagName) {
     return isCEN(tagName);
 }
-exports.isPotentialCustomElementName = isPotentialCustomElementName;

package/lib/detect-element-type.d.ts

@@ -1,6 +1,2 @@
 import type { ElementType, ParserAuthoredElementNameDistinguishing } from '@markuplint/ml-ast';
-export declare function detectElementType(
-	name: string,
-	option?: ParserAuthoredElementNameDistinguishing,
-	defaultPattern?: ParserAuthoredElementNameDistinguishing,
-): ElementType;
+export declare function detectElementType(name: string, option?: ParserAuthoredElementNameDistinguishing, defaultPattern?: ParserAuthoredElementNameDistinguishing): ElementType;

package/lib/detect-element-type.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectElementType = void 0;
-const decision_1 = require("./decision");
-function detectElementType(name, option, defaultPattern) {
+import { isPotentialCustomElementName } from './decision.js';
+export function detectElementType(name, option, defaultPattern) {
     if (distinguishAuthoredName(name, option, defaultPattern)) {
         return 'authored';
     }
-    return (0, decision_1.isPotentialCustomElementName)(name) ? 'web-component' : 'html';
+    return isPotentialCustomElementName(name) ? 'web-component' : 'html';
 }
-exports.detectElementType = detectElementType;
 function distinguishAuthoredName(name, pattern, defaultPattern) {
     if (pattern != null) {
         return _distinguishAuthoredName(name, pattern);
@@ -29,7 +25,7 @@ function _distinguishAuthoredName(name, patterns) {
     });
 }
 function toRegexp(pattern) {
-    const matched = pattern.match(/^\/(.+)\/([ig]*)$/i);
+    const matched = pattern.match(/^\/(.+)\/([gi]*)$/i);
     if (matched && matched[1]) {
         return new RegExp(matched[1], matched[2]);
     }

package/lib/enums.d.ts

@@ -0,0 +1,16 @@
+export declare enum TagState {
+    BeforeOpenTag = 0,
+    FirstCharOfTagName = 1,
+    TagName = 2,
+    Attrs = 3,
+    AfterAttrs = 4,
+    AfterOpenTag = 5
+}
+export declare enum AttrState {
+    BeforeName = 0,
+    Name = 1,
+    Equal = 2,
+    BeforeValue = 3,
+    Value = 4,
+    AfterValue = 5
+}

package/lib/enums.js

@@ -0,0 +1,18 @@
+export var TagState;
+(function (TagState) {
+    TagState[TagState["BeforeOpenTag"] = 0] = "BeforeOpenTag";
+    TagState[TagState["FirstCharOfTagName"] = 1] = "FirstCharOfTagName";
+    TagState[TagState["TagName"] = 2] = "TagName";
+    TagState[TagState["Attrs"] = 3] = "Attrs";
+    TagState[TagState["AfterAttrs"] = 4] = "AfterAttrs";
+    TagState[TagState["AfterOpenTag"] = 5] = "AfterOpenTag";
+})(TagState || (TagState = {}));
+export var AttrState;
+(function (AttrState) {
+    AttrState[AttrState["BeforeName"] = 0] = "BeforeName";
+    AttrState[AttrState["Name"] = 1] = "Name";
+    AttrState[AttrState["Equal"] = 2] = "Equal";
+    AttrState[AttrState["BeforeValue"] = 3] = "BeforeValue";
+    AttrState[AttrState["Value"] = 4] = "Value";
+    AttrState[AttrState["AfterValue"] = 5] = "AfterValue";
+})(AttrState || (AttrState = {}));

package/lib/get-location.d.ts

@@ -1,17 +1,4 @@
-export declare function getLine(html: string, startOffset: number): number;
-export declare function getCol(html: string, startOffset: number): number;
-export declare function getEndLine(html: string, line: number): number;
-export declare function getEndCol(html: string, col: number): number;
-export declare function sliceFragment(
-	rawHtml: string,
-	start: number,
-	end: number,
-): {
-	startOffset: number;
-	endOffset: number;
-	startLine: number;
-	endLine: number;
-	startCol: number;
-	endCol: number;
-	raw: string;
-};
+export declare function getLine(rawCodeFragment: string, startOffset: number): number;
+export declare function getCol(rawCodeFragment: string, startOffset: number): number;
+export declare function getEndLine(rawCodeFragment: string, startLine: number): number;
+export declare function getEndCol(rawCodeFragment: string, startCol: number): number;

package/lib/get-location.js

@@ -1,37 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sliceFragment = exports.getEndCol = exports.getEndLine = exports.getCol = exports.getLine = void 0;
-function getLine(html, startOffset) {
-    return html.slice(0, startOffset).split(/\n/g).length;
+const LINE_BREAK = '\n';
+export function getLine(rawCodeFragment, startOffset) {
+    return rawCodeFragment.slice(0, startOffset).split(LINE_BREAK).length;
 }
-exports.getLine = getLine;
-function getCol(html, startOffset) {
-    var _a;
-    const lines = html.slice(0, startOffset).split(/\n/g);
-    return ((_a = lines[lines.length - 1]) !== null && _a !== void 0 ? _a : '').length + 1;
+export function getCol(rawCodeFragment, startOffset) {
+    const lines = rawCodeFragment.slice(0, startOffset).split(LINE_BREAK);
+    return (lines.at(-1) ?? '').length + 1;
 }
-exports.getCol = getCol;
-function getEndLine(html, line) {
-    return html.split(/\r?\n/).length - 1 + line;
+export function getEndLine(rawCodeFragment, startLine) {
+    return rawCodeFragment.split(LINE_BREAK).length - 1 + startLine;
 }
-exports.getEndLine = getEndLine;
-function getEndCol(html, col) {
-    const lines = html.split(/\r?\n/);
+export function getEndCol(rawCodeFragment, startCol) {
+    const lines = rawCodeFragment.split(LINE_BREAK);
     const lineCount = lines.length;
     const lastLine = lines.pop();
-    return lineCount > 1 ? lastLine.length + 1 : col + html.length;
+    return lineCount > 1 ? lastLine.length + 1 : startCol + rawCodeFragment.length;
 }
-exports.getEndCol = getEndCol;
-function sliceFragment(rawHtml, start, end) {
-    const raw = rawHtml.slice(start, end);
-    return {
-        startOffset: start,
-        endOffset: end,
-        startLine: getLine(rawHtml, start),
-        endLine: getLine(rawHtml, end),
-        startCol: getCol(rawHtml, start),
-        endCol: getCol(rawHtml, end),
-        raw,
-    };
-}
-exports.sliceFragment = sliceFragment;

package/lib/idl-attributes.d.ts

@@ -1,4 +1,4 @@
 export declare function searchIDLAttribute(name: string): {
-	idlPropName: string | undefined;
-	contentAttrName: string | undefined;
+    idlPropName: string | undefined;
+    contentAttrName: string | undefined;
 };

package/lib/idl-attributes.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchIDLAttribute = void 0;
 /**
  * IDL attributes VS Content attributes
  *
@@ -418,23 +415,21 @@ const idlContentMap = {
     credentialless: 'credentialless',
 };
 const list = Object.entries(idlContentMap);
-function searchIDLAttribute(name) {
-    var _a;
+export function searchIDLAttribute(name) {
     const camelizedName = camelize(name);
     const [idlPropName, contentAttrName] = /^on[a-z]/.test(name)
         ? [name.toLowerCase(), name.toLowerCase()]
-        : (_a = list.find(([idlPropName, contentAttrName]) => idlPropName.toLowerCase() === camelizedName.toLowerCase() ||
+        : list.find(([idlPropName, contentAttrName]) => idlPropName.toLowerCase() === camelizedName.toLowerCase() ||
             contentAttrName.toLowerCase() === name.toLowerCase() ||
-            hyphenize(idlPropName) === name.toLowerCase())) !== null && _a !== void 0 ? _a : [];
+            hyphenize(idlPropName) === name.toLowerCase()) ?? [];
     return {
         idlPropName,
         contentAttrName,
     };
 }
-exports.searchIDLAttribute = searchIDLAttribute;
 function camelize(str) {
-    return str.replace(/[:-][a-z]/g, $0 => { var _a, _b; return (_b = (_a = $0[1]) === null || _a === void 0 ? void 0 : _a.toUpperCase()) !== null && _b !== void 0 ? _b : ''; });
+    return str.replaceAll(/[:-][a-z]/g, $0 => $0[1]?.toUpperCase() ?? '');
 }
 function hyphenize(str) {
-    return str.replace(/[A-Z]/g, $0 => `-${$0.toLowerCase()}`);
+    return str.replaceAll(/[A-Z]/g, $0 => `-${$0.toLowerCase()}`);
 }

package/lib/ignore-block.d.ts

@@ -1,4 +1,5 @@
-import type { IgnoreBlock, IgnoreTag } from './types';
-import type { MLASTNode } from '@markuplint/ml-ast';
+import type { Parser } from './parser.js';
+import type { IgnoreBlock, IgnoreTag } from './types.js';
+import type { MLASTNodeTreeItem } from '@markuplint/ml-ast';
 export declare function ignoreBlock(source: string, tags: readonly IgnoreTag[], maskChar?: string): IgnoreBlock;
-export declare function restoreNode(nodeList: MLASTNode[], ignoreBlock: IgnoreBlock): MLASTNode[];
+export declare function restoreNode(parser: Parser<any, any>, nodeList: readonly MLASTNodeTreeItem[], ignoreBlock: IgnoreBlock, throwErrorWhenTagHasUnresolved?: boolean): MLASTNodeTreeItem[];