@markuplint/ml-core 2.0.0-rc.1 → 2.0.0

package/lib/ml-dom/helper/selector.js

@@ -1,5 +1,5 @@
 "use strict";
-var _Selector_ruleset, _Ruleset_selectorGroup, _StructuredSelector_edge, _StructuredSelector_selector, _SelectorTarget_isAdded, _SelectorTarget_combinatedFrom;
+var _Selector_ruleset, _Ruleset_selectorGroup, _StructuredSelector_edge, _StructuredSelector_selector, _SelectorTarget_tagNameCaseSensitive, _SelectorTarget_isAdded, _SelectorTarget_combinatedFrom;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compareSpecificity = exports.createSelector = void 0;
 const tslib_1 = require("tslib");
@@ -7,8 +7,8 @@ const postcss_selector_parser_1 = (0, tslib_1.__importDefault)(require("postcss-
 const debug_1 = require("../../debug");
 const log = debug_1.log.extend('selector');
 const resLog = log.extend('result');
-function createSelector(selector) {
-    return new Selector(selector);
+function createSelector(selector, tagNameCaseSensitive) {
+    return new Selector(selector, !!tagNameCaseSensitive);
 }
 exports.createSelector = createSelector;
 function compareSpecificity(a, b) {
@@ -34,9 +34,9 @@ function compareSpecificity(a, b) {
 }
 exports.compareSpecificity = compareSpecificity;
 class Selector {
-    constructor(selector) {
+    constructor(selector, tagNameCaseSensitive) {
         _Selector_ruleset.set(this, void 0);
-        (0, tslib_1.__classPrivateFieldSet)(this, _Selector_ruleset, Ruleset.parse(selector), "f");
+        (0, tslib_1.__classPrivateFieldSet)(this, _Selector_ruleset, Ruleset.parse(selector, tagNameCaseSensitive), "f");
     }
     match(el, caller = el) {
         const results = (0, tslib_1.__classPrivateFieldGet)(this, _Selector_ruleset, "f").match(el, caller);
@@ -50,16 +50,16 @@ class Selector {
 }
 _Selector_ruleset = new WeakMap();
 class Ruleset {
-    constructor(selectors) {
+    constructor(selectors, tagNameCaseSensitive) {
         _Ruleset_selectorGroup.set(this, []);
-        (0, tslib_1.__classPrivateFieldGet)(this, _Ruleset_selectorGroup, "f").push(...selectors.map(selector => new StructuredSelector(selector)));
+        (0, tslib_1.__classPrivateFieldGet)(this, _Ruleset_selectorGroup, "f").push(...selectors.map(selector => new StructuredSelector(selector, tagNameCaseSensitive)));
     }
-    static parse(selector) {
+    static parse(selector, tagNameCaseSensitive) {
         const selectors = [];
         (0, postcss_selector_parser_1.default)(root => {
             selectors.push(...root.nodes);
         }).processSync(selector);
-        return new Ruleset(selectors);
+        return new Ruleset(selectors, tagNameCaseSensitive);
     }
     match(el, caller) {
         log('%s', el.raw);
@@ -72,15 +72,15 @@ class Ruleset {
 }
 _Ruleset_selectorGroup = new WeakMap();
 class StructuredSelector {
-    constructor(selector) {
+    constructor(selector, tagNameCaseSensitive) {
         _StructuredSelector_edge.set(this, void 0);
         _StructuredSelector_selector.set(this, void 0);
         (0, tslib_1.__classPrivateFieldSet)(this, _StructuredSelector_selector, selector, "f");
-        (0, tslib_1.__classPrivateFieldSet)(this, _StructuredSelector_edge, new SelectorTarget(), "f");
+        (0, tslib_1.__classPrivateFieldSet)(this, _StructuredSelector_edge, new SelectorTarget(tagNameCaseSensitive), "f");
         (0, tslib_1.__classPrivateFieldGet)(this, _StructuredSelector_selector, "f").nodes.forEach(node => {
             switch (node.type) {
                 case 'combinator': {
-                    const combinatedTarget = new SelectorTarget();
+                    const combinatedTarget = new SelectorTarget(tagNameCaseSensitive);
                     combinatedTarget.from((0, tslib_1.__classPrivateFieldGet)(this, _StructuredSelector_edge, "f"), node);
                     (0, tslib_1.__classPrivateFieldSet)(this, _StructuredSelector_edge, combinatedTarget, "f");
                     break;
@@ -110,14 +110,16 @@ class StructuredSelector {
 }
 _StructuredSelector_edge = new WeakMap(), _StructuredSelector_selector = new WeakMap();
 class SelectorTarget {
-    constructor() {
+    constructor(tagNameCaseSensitive) {
         this.tag = null;
         this.id = [];
         this.class = [];
         this.attr = [];
         this.pseudo = [];
+        _SelectorTarget_tagNameCaseSensitive.set(this, void 0);
         _SelectorTarget_isAdded.set(this, false);
         _SelectorTarget_combinatedFrom.set(this, null);
+        (0, tslib_1.__classPrivateFieldSet)(this, _SelectorTarget_tagNameCaseSensitive, tagNameCaseSensitive, "f");
     }
     match(el, caller) {
         const unitCheck = this._matchWithoutCombinateChecking(el, caller);
@@ -268,7 +270,7 @@ class SelectorTarget {
         }
         specificity[1] += this.attr.length;
         for (const pseudo of this.pseudo) {
-            const pseudoRes = pseudoMatch(pseudo, el, caller);
+            const pseudoRes = pseudoMatch(pseudo, el, caller, (0, tslib_1.__classPrivateFieldGet)(this, _SelectorTarget_tagNameCaseSensitive, "f"));
             specificity[0] += pseudoRes.specificity[0];
             specificity[1] += pseudoRes.specificity[1];
             specificity[2] += pseudoRes.specificity[2];
@@ -278,7 +280,13 @@ class SelectorTarget {
         }
         if (this.tag && this.tag.type === 'tag') {
             specificity[2] += 1;
-            if (this.tag.value.toLowerCase() !== el.nodeName.toLowerCase()) {
+            let a = this.tag.value;
+            let b = el.nodeName;
+            if (!(0, tslib_1.__classPrivateFieldGet)(this, _SelectorTarget_tagNameCaseSensitive, "f")) {
+                a = a.toLowerCase();
+                b = b.toLowerCase();
+            }
+            if (a !== b) {
                 matched = false;
             }
         }
@@ -317,7 +325,7 @@ class SelectorTarget {
         (0, tslib_1.__classPrivateFieldSet)(this, _SelectorTarget_combinatedFrom, { target, combinator }, "f");
     }
 }
-_SelectorTarget_isAdded = new WeakMap(), _SelectorTarget_combinatedFrom = new WeakMap();
+_SelectorTarget_tagNameCaseSensitive = new WeakMap(), _SelectorTarget_isAdded = new WeakMap(), _SelectorTarget_combinatedFrom = new WeakMap();
 function attrMatch(attr, el) {
     return el.attributes.some(attrOfEl => {
         if (attr.attribute !== attrOfEl.getName().potential) {
@@ -372,13 +380,13 @@ function attrMatch(attr, el) {
         return true;
     });
 }
-function pseudoMatch(pseudo, el, caller) {
+function pseudoMatch(pseudo, el, caller, tagNameCaseSensitive) {
     switch (pseudo.value) {
         /**
          * Below, markuplint Specific Selector
          */
         case ':closest': {
-            const ruleset = new Ruleset(pseudo.nodes);
+            const ruleset = new Ruleset(pseudo.nodes, tagNameCaseSensitive);
             const specificity = getSpecificity(ruleset.match(el, caller));
             let parent = el.getParentElement();
             while (parent) {
@@ -399,7 +407,7 @@ function pseudoMatch(pseudo, el, caller) {
          * Below, Selector Level 4
          */
         case ':not': {
-            const ruleset = new Ruleset(pseudo.nodes);
+            const ruleset = new Ruleset(pseudo.nodes, tagNameCaseSensitive);
             const resList = ruleset.match(el, caller);
             const specificity = getSpecificity(resList);
             const matched = resList.every(r => !r.matched);
@@ -409,7 +417,7 @@ function pseudoMatch(pseudo, el, caller) {
             };
         }
         case ':is': {
-            const ruleset = new Ruleset(pseudo.nodes);
+            const ruleset = new Ruleset(pseudo.nodes, tagNameCaseSensitive);
             const resList = ruleset.match(el, caller);
             const specificity = getSpecificity(resList);
             const matched = resList.some(r => r.matched);
@@ -419,7 +427,7 @@ function pseudoMatch(pseudo, el, caller) {
             };
         }
         case ':has': {
-            const ruleset = new Ruleset(pseudo.nodes);
+            const ruleset = new Ruleset(pseudo.nodes, tagNameCaseSensitive);
             const specificity = getSpecificity(ruleset.match(el, caller));
             const descendants = getDescendants(el);
             const matched = descendants.some(desc => ruleset.match(desc, caller).some(m => m.matched));
@@ -429,7 +437,7 @@ function pseudoMatch(pseudo, el, caller) {
             };
         }
         case ':where': {
-            const ruleset = new Ruleset(pseudo.nodes);
+            const ruleset = new Ruleset(pseudo.nodes, tagNameCaseSensitive);
             const resList = ruleset.match(el, caller);
             const matched = resList.some(r => r.matched);
             return {

package/lib/ml-dom/helper/walkers.d.ts

@@ -1,5 +1,10 @@
 import type { AnonymousNode } from '../types';
 import type { RuleConfigValue } from '@markuplint/ml-config';
-export declare type Walker<T extends RuleConfigValue, O = null, N = AnonymousNode<T, O>> = (node: N) => void | Promise<void>;
+export declare type Walker<T extends RuleConfigValue, O = null, N = AnonymousNode<T, O>> = (
+	node: N,
+) => void | Promise<void>;
 export declare type SyncWalker<T extends RuleConfigValue, O = null, N = AnonymousNode<T, O>> = (node: N) => void;
-export declare function syncWalk<T extends RuleConfigValue, O = null>(nodeList: AnonymousNode<T, O>[], walker: SyncWalker<T, O>): void;
+export declare function syncWalk<T extends RuleConfigValue, O = null>(
+	nodeList: AnonymousNode<T, O>[],
+	walker: SyncWalker<T, O>,
+): void;

package/lib/ml-dom/index.d.ts

@@ -1,3 +1,12 @@
 export { default as Document } from './document';
 export { AnonymousNode, NodeType } from './types';
-export { MLDOMAttribute as Attribute, MLDOMComment as Comment, MLDOMDoctype as Doctype, MLDOMElement as Element, MLDOMElementCloseTag as ElementCloseTag, MLDOMNode as Node, MLDOMOmittedElement as OmittedElement, MLDOMText as Text, } from './tokens';
+export {
+	MLDOMAttribute as Attribute,
+	MLDOMComment as Comment,
+	MLDOMDoctype as Doctype,
+	MLDOMElement as Element,
+	MLDOMElementCloseTag as ElementCloseTag,
+	MLDOMNode as Node,
+	MLDOMOmittedElement as OmittedElement,
+	MLDOMText as Text,
+} from './tokens';

package/lib/ml-dom/rule-mapper.d.ts

@@ -3,14 +3,14 @@ import type { AnonymousNode } from './types';
 import type { AnyRule } from '@markuplint/ml-config';
 declare type RuleType = 'rules' | 'nodeRules' | 'childNodeRules';
 declare type MappingLayer = {
-    from: RuleType;
-    specificity: Specificity;
-    rule: AnyRule;
+	from: RuleType;
+	specificity: Specificity;
+	rule: AnyRule;
 };
 export declare class RuleMapper<N extends AnonymousNode<any, any> = AnonymousNode<any, any>> {
-    #private;
-    constructor(nodeList: ReadonlyArray<N>);
-    set(node: N, ruleName: string, rule: MappingLayer): void;
-    apply(): void;
+	#private;
+	constructor(nodeList: ReadonlyArray<N>);
+	set(node: N, ruleName: string, rule: MappingLayer): void;
+	apply(): void;
 }
 export {};

package/lib/ml-dom/tokens/abstract-element.d.ts

@@ -5,40 +5,44 @@ import type { MLASTElement, MLASTOmittedElement } from '@markuplint/ml-ast';
 import type { RuleConfigValue } from '@markuplint/ml-config';
 import type { ContentModel } from '@markuplint/ml-spec';
 import MLDOMNode from './node';
-export default abstract class MLDOMAbstractElement<T extends RuleConfigValue, O = null, E extends MLASTElement | MLASTOmittedElement = MLASTElement | MLASTOmittedElement> extends MLDOMNode<T, O, E> {
-    #private;
-    readonly nodeName: string;
-    readonly attributes: (MLDOMAttribute | MLDOMPreprocessorSpecificAttribute)[];
-    readonly hasSpreadAttr: boolean;
-    readonly namespaceURI: string;
-    readonly isForeignElement: boolean;
-    readonly ownModels: Set<ContentModel>;
-    readonly childModels: Set<ContentModel>;
-    readonly descendantModels: Set<ContentModel>;
-    readonly isCustomElement: boolean;
-    readonly isInFragmentDocument: boolean;
-    constructor(astNode: E, document: Document<T, O>);
-    get childNodes(): AnonymousNode<T, O>[];
-    get children(): (MLDOMElement<T, O> | MLDOMOmittedElement<T, O>)[];
-    get nextElementSibling(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | null;
-    get previousElementSibling(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | null;
-    get ns(): string;
-    get nameWithNS(): string;
-    get classList(): string[];
-    get id(): string;
-    get fixedNodeName(): string;
-    querySelectorAll(selector: string): (MLDOMElement<T, O> | MLDOMText<T, O>)[];
-    closest(selector: string): MLDOMAbstractElement<T, O> | null;
-    getAttributeToken(attrName: string): (MLDOMAttribute | MLDOMPreprocessorSpecificAttribute)[];
-    getAttribute(attrName: string): string | null;
-    hasAttribute(attrName: string): boolean;
-    matches(selector: string): boolean;
-    fixNodeName(name: string): void;
-    getChildElementsAndTextNodeWithoutWhitespaces(): (MLDOMElement<T, O> | MLDOMText<T, O>)[];
-    /**
-     * This element has "Preprocessor Specific Block". In other words, Its children are potentially mutable.
-     */
-    hasMutableChildren(): boolean;
-    isDescendantByUUIDList(uuidList: string[]): boolean;
-    toNormalizeString(): string;
+export default abstract class MLDOMAbstractElement<
+	T extends RuleConfigValue,
+	O = null,
+	E extends MLASTElement | MLASTOmittedElement = MLASTElement | MLASTOmittedElement,
+> extends MLDOMNode<T, O, E> {
+	#private;
+	readonly nodeName: string;
+	readonly attributes: (MLDOMAttribute | MLDOMPreprocessorSpecificAttribute)[];
+	readonly hasSpreadAttr: boolean;
+	readonly namespaceURI: string;
+	readonly isForeignElement: boolean;
+	readonly ownModels: Set<ContentModel>;
+	readonly childModels: Set<ContentModel>;
+	readonly descendantModels: Set<ContentModel>;
+	readonly isCustomElement: boolean;
+	readonly isInFragmentDocument: boolean;
+	constructor(astNode: E, document: Document<T, O>);
+	get childNodes(): AnonymousNode<T, O>[];
+	get children(): (MLDOMElement<T, O> | MLDOMOmittedElement<T, O>)[];
+	get nextElementSibling(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | null;
+	get previousElementSibling(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | null;
+	get ns(): string;
+	get nameWithNS(): string;
+	get classList(): string[];
+	get id(): string;
+	get fixedNodeName(): string;
+	querySelectorAll(selector: string): (MLDOMElement<T, O> | MLDOMText<T, O>)[];
+	closest(selector: string): MLDOMAbstractElement<T, O> | null;
+	getAttributeToken(attrName: string): (MLDOMAttribute | MLDOMPreprocessorSpecificAttribute)[];
+	getAttribute(attrName: string): string | null;
+	hasAttribute(attrName: string): boolean;
+	matches(selector: string): boolean;
+	fixNodeName(name: string): void;
+	getChildElementsAndTextNodeWithoutWhitespaces(): (MLDOMElement<T, O> | MLDOMText<T, O>)[];
+	/**
+	 * This element has "Preprocessor Specific Block". In other words, Its children are potentially mutable.
+	 */
+	hasMutableChildren(): boolean;
+	isDescendantByUUIDList(uuidList: string[]): boolean;
+	toNormalizeString(): string;
 }

package/lib/ml-dom/tokens/attribute.d.ts

@@ -1,40 +1,40 @@
 import type { MLASTHTMLAttr, MLToken } from '@markuplint/ml-ast';
 import MLDOMToken from './token';
 export default class MLDOMAttribute extends MLDOMToken<MLASTHTMLAttr> {
-    readonly attrType = "html-attr";
-    readonly name: MLDOMToken<MLToken>;
-    readonly spacesBeforeName: MLDOMToken<MLToken>;
-    readonly spacesBeforeEqual: MLDOMToken<MLToken>;
-    readonly equal: MLDOMToken<MLToken>;
-    readonly spacesAfterEqual: MLDOMToken<MLToken>;
-    readonly startQuote: MLDOMToken<MLToken>;
-    readonly value: MLDOMToken<MLToken>;
-    readonly endQuote: MLDOMToken<MLToken>;
-    readonly isDynamicValue?: true;
-    readonly isDirective?: true;
-    readonly potentialName: string;
-    readonly candidate?: string;
-    readonly isDuplicatable: boolean;
-    constructor(astToken: MLASTHTMLAttr);
-    get raw(): string;
-    get startOffset(): number;
-    get endOffset(): number;
-    get startLine(): number;
-    get endLine(): number;
-    get startCol(): number;
-    get endCol(): number;
-    getName(): {
-        line: number;
-        col: number;
-        potential: string;
-        raw: string;
-    };
-    getValue(): {
-        line: number;
-        col: number;
-        potential: string;
-        raw: string;
-    };
-    toString(withSpace?: boolean): string;
-    toNormalizeString(): string;
+	readonly attrType = 'html-attr';
+	readonly name: MLDOMToken<MLToken>;
+	readonly spacesBeforeName: MLDOMToken<MLToken>;
+	readonly spacesBeforeEqual: MLDOMToken<MLToken>;
+	readonly equal: MLDOMToken<MLToken>;
+	readonly spacesAfterEqual: MLDOMToken<MLToken>;
+	readonly startQuote: MLDOMToken<MLToken>;
+	readonly value: MLDOMToken<MLToken>;
+	readonly endQuote: MLDOMToken<MLToken>;
+	readonly isDynamicValue?: true;
+	readonly isDirective?: true;
+	readonly potentialName: string;
+	readonly candidate?: string;
+	readonly isDuplicatable: boolean;
+	constructor(astToken: MLASTHTMLAttr);
+	get raw(): string;
+	get startOffset(): number;
+	get endOffset(): number;
+	get startLine(): number;
+	get endLine(): number;
+	get startCol(): number;
+	get endCol(): number;
+	getName(): {
+		line: number;
+		col: number;
+		potential: string;
+		raw: string;
+	};
+	getValue(): {
+		line: number;
+		col: number;
+		potential: string;
+		raw: string;
+	};
+	toString(withSpace?: boolean): string;
+	toNormalizeString(): string;
 }

package/lib/ml-dom/tokens/comment.d.ts

@@ -2,6 +2,9 @@ import type { IMLDOMComment } from '../types';
 import type { MLASTComment } from '@markuplint/ml-ast';
 import type { RuleConfigValue } from '@markuplint/ml-config';
 import MLDOMNode from './node';
-export default class MLDOMComment<T extends RuleConfigValue, O = null> extends MLDOMNode<T, O, MLASTComment> implements IMLDOMComment {
-    readonly type = "Comment";
+export default class MLDOMComment<T extends RuleConfigValue, O = null>
+	extends MLDOMNode<T, O, MLASTComment>
+	implements IMLDOMComment
+{
+	readonly type = 'Comment';
 }

package/lib/ml-dom/tokens/doctype.d.ts

@@ -3,11 +3,14 @@ import type { IMLDOMDoctype } from '../types';
 import type { MLASTDoctype, MLASTNode } from '@markuplint/ml-ast';
 import type { RuleConfigValue } from '@markuplint/ml-config';
 import MLDOMNode from './node';
-export default class MLDOMDoctype<T extends RuleConfigValue, O = null> extends MLDOMNode<T, O, MLASTNode> implements IMLDOMDoctype {
-    #private;
-    readonly type = "Doctype";
-    constructor(astNode: MLASTDoctype, document: Document<T, O>);
-    get name(): string;
-    get publicId(): string;
-    get systemId(): string;
+export default class MLDOMDoctype<T extends RuleConfigValue, O = null>
+	extends MLDOMNode<T, O, MLASTNode>
+	implements IMLDOMDoctype
+{
+	#private;
+	readonly type = 'Doctype';
+	constructor(astNode: MLASTDoctype, document: Document<T, O>);
+	get name(): string;
+	get publicId(): string;
+	get systemId(): string;
 }

package/lib/ml-dom/tokens/element-close-tag.d.ts

@@ -4,20 +4,23 @@ import type { MLDOMElement } from './';
 import type { MLASTElementCloseTag } from '@markuplint/ml-ast';
 import type { RuleConfigValue } from '@markuplint/ml-config';
 import MLDOMNode from './node';
-export default class MLDOMElementCloseTag<T extends RuleConfigValue, O = null> extends MLDOMNode<T, O, MLASTElementCloseTag> implements IMLDOMElementCloseTag {
-    #private;
-    readonly type = "ElementCloseTag";
-    readonly nodeName: string;
-    readonly startTag: MLDOMElement<T, O>;
-    readonly isForeignElement: boolean;
-    readonly isCustomElement: boolean;
-    constructor(astNode: MLASTElementCloseTag, document: Document<T, O>, startTag: MLDOMElement<T, O>);
-    get raw(): string;
-    get rule(): import("@markuplint/ml-config").RuleInfo<T, O>;
-    fixNodeName(name: string): void;
-    getNameLocation(): {
-        offset: number;
-        line: number;
-        col: number;
-    };
+export default class MLDOMElementCloseTag<T extends RuleConfigValue, O = null>
+	extends MLDOMNode<T, O, MLASTElementCloseTag>
+	implements IMLDOMElementCloseTag
+{
+	#private;
+	readonly type = 'ElementCloseTag';
+	readonly nodeName: string;
+	readonly startTag: MLDOMElement<T, O>;
+	readonly isForeignElement: boolean;
+	readonly isCustomElement: boolean;
+	constructor(astNode: MLASTElementCloseTag, document: Document<T, O>, startTag: MLDOMElement<T, O>);
+	get raw(): string;
+	get rule(): import('@markuplint/ml-config').RuleInfo<T, O>;
+	fixNodeName(name: string): void;
+	getNameLocation(): {
+		offset: number;
+		line: number;
+		col: number;
+	};
 }

package/lib/ml-dom/tokens/element.d.ts

@@ -5,19 +5,22 @@ import type { MLASTElement, MLToken } from '@markuplint/ml-ast';
 import type { RuleConfigValue } from '@markuplint/ml-config';
 import MLDOMAbstractElement from './abstract-element';
 import MLDOMToken from './token';
-export default class MLDOMElement<T extends RuleConfigValue, O = null> extends MLDOMAbstractElement<T, O, MLASTElement> implements IMLDOMElement {
-    #private;
-    readonly type = "Element";
-    readonly hasSpreadAttr: boolean;
-    readonly closeTag: MLDOMElementCloseTag<T, O> | null;
-    readonly selfClosingSolidus: MLDOMToken<MLToken> | null;
-    readonly endSpace: MLDOMToken<MLToken> | null;
-    constructor(astNode: MLASTElement, document: Document<T, O>);
-    get raw(): string;
-    querySelectorAll(selector: string): (MLDOMElement<T, O> | MLDOMText<T, O>)[];
-    getNameLocation(): {
-        offset: number;
-        line: number;
-        col: number;
-    };
+export default class MLDOMElement<T extends RuleConfigValue, O = null>
+	extends MLDOMAbstractElement<T, O, MLASTElement>
+	implements IMLDOMElement
+{
+	#private;
+	readonly type = 'Element';
+	readonly hasSpreadAttr: boolean;
+	readonly closeTag: MLDOMElementCloseTag<T, O> | null;
+	readonly selfClosingSolidus: MLDOMToken<MLToken> | null;
+	readonly endSpace: MLDOMToken<MLToken> | null;
+	constructor(astNode: MLASTElement, document: Document<T, O>);
+	get raw(): string;
+	querySelectorAll(selector: string): (MLDOMElement<T, O> | MLDOMText<T, O>)[];
+	getNameLocation(): {
+		offset: number;
+		line: number;
+		col: number;
+	};
 }

package/lib/ml-dom/tokens/node.d.ts

@@ -5,20 +5,27 @@ import type { MLDOMElement, MLDOMOmittedElement, MLDOMPreprocessorSpecificBlock
 import type { MLASTAbstructNode } from '@markuplint/ml-ast';
 import type { AnyRule, RuleConfigValue } from '@markuplint/ml-config';
 import MLDOMToken from './token';
-export default abstract class MLDOMNode<T extends RuleConfigValue, O = null, A extends MLASTAbstructNode = MLASTAbstructNode> extends MLDOMToken<A> implements IMLDOMNode {
-    #private;
-    readonly type: NodeType;
-    readonly rules: Record<string, AnyRule>;
-    protected _astToken: A;
-    constructor(astNode: A, document: Document<T, O>);
-    get parentNode(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | MLDOMPreprocessorSpecificBlock<T, O> | null;
-    get prevNode(): AnonymousNode<T, O> | null;
-    get nextNode(): AnonymousNode<T, O> | null;
-    get syntaxicalParentNode(): MLDOMElement<T, O> | MLDOMPreprocessorSpecificBlock<T, O> | null;
-    get prevToken(): AnonymousNode<T, O> | null;
-    get nodeStore(): import("../helper").NodeStore;
-    get rule(): RuleInfo<T, O>;
-    getParentElement(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | null;
-    is(type: NodeType): boolean;
-    toString(): string;
+export default abstract class MLDOMNode<
+		T extends RuleConfigValue,
+		O = null,
+		A extends MLASTAbstructNode = MLASTAbstructNode,
+	>
+	extends MLDOMToken<A>
+	implements IMLDOMNode
+{
+	#private;
+	readonly type: NodeType;
+	readonly rules: Record<string, AnyRule>;
+	protected _astToken: A;
+	constructor(astNode: A, document: Document<T, O>);
+	get parentNode(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | MLDOMPreprocessorSpecificBlock<T, O> | null;
+	get prevNode(): AnonymousNode<T, O> | null;
+	get nextNode(): AnonymousNode<T, O> | null;
+	get syntaxicalParentNode(): MLDOMElement<T, O> | MLDOMPreprocessorSpecificBlock<T, O> | null;
+	get prevToken(): AnonymousNode<T, O> | null;
+	get nodeStore(): import('../helper').NodeStore;
+	get rule(): RuleInfo<T, O>;
+	getParentElement(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | null;
+	is(type: NodeType): boolean;
+	toString(): string;
 }

package/lib/ml-dom/tokens/omitted-element.d.ts

@@ -3,8 +3,11 @@ import type { IMLDOMOmittedElement } from '../types';
 import type { MLASTOmittedElement } from '@markuplint/ml-ast';
 import type { RuleConfigValue } from '@markuplint/ml-config';
 import MLDOMAbstractElement from './abstract-element';
-export default class MLDOMOmittedElement<T extends RuleConfigValue, O = null> extends MLDOMAbstractElement<T, O, MLASTOmittedElement> implements IMLDOMOmittedElement {
-    readonly type = "OmittedElement";
-    obsolete: boolean;
-    constructor(astNode: MLASTOmittedElement, document: Document<T, O>);
+export default class MLDOMOmittedElement<T extends RuleConfigValue, O = null>
+	extends MLDOMAbstractElement<T, O, MLASTOmittedElement>
+	implements IMLDOMOmittedElement
+{
+	readonly type = 'OmittedElement';
+	obsolete: boolean;
+	constructor(astNode: MLASTOmittedElement, document: Document<T, O>);
 }

package/lib/ml-dom/tokens/preprocessor-specific-attribute.d.ts

@@ -1,24 +1,24 @@
 import type { MLASTPreprocessorSpecificAttr } from '@markuplint/ml-ast';
 import MLDOMToken from './token';
 export default class MLDOMPreprocessorSpecificAttribute extends MLDOMToken<MLASTPreprocessorSpecificAttr> {
-    readonly attrType = "ps-attr";
-    readonly potentialName: string;
-    readonly potentialValue: string;
-    readonly valueType: 'string' | 'number' | 'boolean' | 'code';
-    readonly isDuplicatable: boolean;
-    constructor(astToken: MLASTPreprocessorSpecificAttr);
-    getName(): {
-        line: number;
-        col: number;
-        potential: string;
-        raw: string;
-    };
-    getValue(): {
-        line: number;
-        col: number;
-        potential: string;
-        raw: string;
-    };
-    toString(): string;
-    toNormalizeString(): string;
+	readonly attrType = 'ps-attr';
+	readonly potentialName: string;
+	readonly potentialValue: string;
+	readonly valueType: 'string' | 'number' | 'boolean' | 'code';
+	readonly isDuplicatable: boolean;
+	constructor(astToken: MLASTPreprocessorSpecificAttr);
+	getName(): {
+		line: number;
+		col: number;
+		potential: string;
+		raw: string;
+	};
+	getValue(): {
+		line: number;
+		col: number;
+		potential: string;
+		raw: string;
+	};
+	toString(): string;
+	toNormalizeString(): string;
 }

package/lib/ml-dom/tokens/preprocessor-specific-block.d.ts

@@ -3,9 +3,12 @@ import type { IMLDOMPreprocessorSpecificBlock } from '../types';
 import type { MLASTPreprocessorSpecificBlock } from '@markuplint/ml-ast';
 import type { RuleConfigValue } from '@markuplint/ml-config';
 import MLDOMNode from './node';
-export default class MLDOMPreprocessorSpecificBlock<T extends RuleConfigValue, O = null> extends MLDOMNode<T, O, MLASTPreprocessorSpecificBlock> implements IMLDOMPreprocessorSpecificBlock {
-    readonly type = "PSBlock";
-    readonly nodeName: string;
-    constructor(astNode: MLASTPreprocessorSpecificBlock, document: Document<T, O>);
-    get childNodes(): AnonymousNode<T, O>[];
+export default class MLDOMPreprocessorSpecificBlock<T extends RuleConfigValue, O = null>
+	extends MLDOMNode<T, O, MLASTPreprocessorSpecificBlock>
+	implements IMLDOMPreprocessorSpecificBlock
+{
+	readonly type = 'PSBlock';
+	readonly nodeName: string;
+	constructor(astNode: MLASTPreprocessorSpecificBlock, document: Document<T, O>);
+	get childNodes(): AnonymousNode<T, O>[];
 }