@markuplint/ml-core 2.2.3 → 2.3.2

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

@@ -0,0 +1,66 @@
+import type { MLElement } from './element';
+import type { MLASTAbstructNode } from '@markuplint/ml-ast';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+import { MLNode } from './node';
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#interface-parentnode
+ */
+export declare abstract class MLParentNode<T extends RuleConfigValue, O = null, A extends MLASTAbstructNode = MLASTAbstructNode> extends MLNode<T, O, A> implements ParentNode {
+    #private;
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#dom-parentnode-childelementcount
+     */
+    get childElementCount(): number;
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-children%E2%91%A0
+     */
+    get children(): HTMLCollectionOf<MLElement<T, O>>;
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-firstelementchild%E2%91%A0
+     */
+    get firstElementChild(): MLElement<T, O>;
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-lastelementchild%E2%91%A0
+     */
+    get lastElementChild(): MLElement<T, O>;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-append%E2%91%A0
+     */
+    append(...nodes: (string | Node)[]): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-prepend%E2%91%A0
+     */
+    prepend(...nodes: (string | Node)[]): void;
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-queryselector%E2%91%A0
+     */
+    querySelector(selectors: string): MLElement<T, O> | null;
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-queryselectorall%E2%91%A0
+     */
+    querySelectorAll(selectors: string): NodeListOf<MLElement<T, O>>;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-replacechildren%E2%91%A0
+     */
+    replaceChildren(...nodes: (string | Node)[]): void;
+    protected _descendantsToArray<N extends MLNode<T, O>>(filter?: (node: MLNode<T, O>) => N | null | void): ReadonlyArray<N>;
+}

package/lib/ml-dom/node/parent-node.js

@@ -0,0 +1,131 @@
+"use strict";
+var _MLParentNode_children, _MLParentNode_selectedElements;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLParentNode = void 0;
+const tslib_1 = require("tslib");
+const walkers_1 = require("../helper/walkers");
+const get_children_1 = require("../manipulations/get-children");
+const node_1 = require("./node");
+const node_list_1 = require("./node-list");
+const unexpected_call_error_1 = tslib_1.__importDefault(require("./unexpected-call-error"));
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#interface-parentnode
+ */
+class MLParentNode extends node_1.MLNode {
+    constructor() {
+        super(...arguments);
+        /**
+         * Cached `children`
+         */
+        _MLParentNode_children.set(this, null);
+        /**
+         * Cached elements that created from `querySelectorAll`
+         */
+        _MLParentNode_selectedElements.set(this, new Map());
+    }
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#dom-parentnode-childelementcount
+     */
+    get childElementCount() {
+        return this.children.length;
+    }
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-children%E2%91%A0
+     */
+    get children() {
+        if (tslib_1.__classPrivateFieldGet(this, _MLParentNode_children, "f")) {
+            return tslib_1.__classPrivateFieldGet(this, _MLParentNode_children, "f");
+        }
+        const children = (0, get_children_1.getChildren)(this);
+        tslib_1.__classPrivateFieldSet(this, _MLParentNode_children, children, "f");
+        return tslib_1.__classPrivateFieldGet(this, _MLParentNode_children, "f");
+    }
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-firstelementchild%E2%91%A0
+     */
+    get firstElementChild() {
+        return this.children[0] || null;
+    }
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-lastelementchild%E2%91%A0
+     */
+    get lastElementChild() {
+        return this.children[0] || null;
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-append%E2%91%A0
+     */
+    append(...nodes) {
+        throw new unexpected_call_error_1.default('Not supported "append" method');
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-prepend%E2%91%A0
+     */
+    prepend(...nodes) {
+        throw new unexpected_call_error_1.default('Not supported "prepend" method');
+    }
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-queryselector%E2%91%A0
+     */
+    querySelector(selectors) {
+        const selected = this.querySelectorAll(selectors);
+        return selected[0] || null;
+    }
+    /**
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-queryselectorall%E2%91%A0
+     */
+    querySelectorAll(selectors) {
+        const selected = tslib_1.__classPrivateFieldGet(this, _MLParentNode_selectedElements, "f").get(selectors);
+        if (selected) {
+            return selected;
+        }
+        const elements = (0, node_list_1.toNodeList)(this._descendantsToArray(node => {
+            if (node.is(node.ELEMENT_NODE) && node.matches(selectors)) {
+                return node;
+            }
+        }));
+        tslib_1.__classPrivateFieldGet(this, _MLParentNode_selectedElements, "f").set(selectors, elements);
+        return elements;
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Element`, `Document`, `DocumentFragment`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-parentnode-replacechildren%E2%91%A0
+     */
+    replaceChildren(...nodes) {
+        throw new unexpected_call_error_1.default('Not supported "replaceChildren" method');
+    }
+    _descendantsToArray(filter) {
+        const nodeList = [];
+        (0, walkers_1.syncWalk)(Array.from(this.childNodes), node => {
+            if (filter) {
+                const filtered = filter(node);
+                if (filtered) {
+                    nodeList.push(filtered);
+                }
+                return;
+            }
+            return node;
+        });
+        return Object.freeze(nodeList);
+    }
+}
+exports.MLParentNode = MLParentNode;
+_MLParentNode_children = new WeakMap(), _MLParentNode_selectedElements = new WeakMap();

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

@@ -0,0 +1,17 @@
+import type { MLDocument } from './document';
+import type { MLNode } from './node';
+import type { AnyRule } from '@markuplint/ml-config';
+import type { Specificity } from '@markuplint/selector';
+declare type RuleType = 'rules' | 'nodeRules' | 'childNodeRules';
+declare type MappingLayer = {
+    from: RuleType;
+    specificity: Specificity;
+    rule: AnyRule;
+};
+export declare class RuleMapper {
+    #private;
+    constructor(document: MLDocument<any, any>);
+    apply(): void;
+    set(node: MLNode<any, any>, ruleName: string, rule: MappingLayer): void;
+}
+export {};

package/lib/ml-dom/node/rule-mapper.js

@@ -0,0 +1,49 @@
+"use strict";
+var _RuleMapper_nodeList, _RuleMapper_ruleMap;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleMapper = void 0;
+const tslib_1 = require("tslib");
+const selector_1 = require("@markuplint/selector");
+const debug_1 = require("../../debug");
+const ruleMapperLog = debug_1.log.extend('rule-mapper');
+const ruleMapperNodeLog = ruleMapperLog.extend('node');
+const ruleMapperNodeRuleLog = ruleMapperNodeLog.extend('rule');
+class RuleMapper {
+    constructor(document) {
+        _RuleMapper_nodeList.set(this, void 0);
+        _RuleMapper_ruleMap.set(this, new Map());
+        tslib_1.__classPrivateFieldSet(this, _RuleMapper_nodeList, Object.freeze([document, ...document.nodeList]), "f");
+    }
+    apply() {
+        ruleMapperLog('ruleTree:');
+        tslib_1.__classPrivateFieldGet(this, _RuleMapper_nodeList, "f").forEach(node => {
+            const rules = tslib_1.__classPrivateFieldGet(this, _RuleMapper_ruleMap, "f").get(node.uuid);
+            if (!rules) {
+                return;
+            }
+            ruleMapperNodeLog('<%s>', node.nodeName);
+            Object.keys(rules).forEach(ruleName => {
+                const rule = rules[ruleName];
+                node.rules[ruleName] = rule.rule;
+                ruleMapperNodeRuleLog('[from: %s(%s)] %s: %o', rule.from, rule.specificity, ruleName, rule.rule);
+            });
+        });
+    }
+    set(node, ruleName, rule) {
+        const rules = tslib_1.__classPrivateFieldGet(this, _RuleMapper_ruleMap, "f").get(node.uuid) || {};
+        const currentRule = rules[ruleName];
+        if (currentRule) {
+            const order = (0, selector_1.compareSpecificity)(currentRule.specificity, rule.specificity);
+            if (order === 1) {
+                ruleMapperLog("Don't set %o ([%s] vs [%s])", rule, currentRule.specificity, rule.specificity);
+                return;
+            }
+            ruleMapperLog('Unset %o from %s', currentRule, node);
+        }
+        rules[ruleName] = rule;
+        tslib_1.__classPrivateFieldGet(this, _RuleMapper_ruleMap, "f").set(node.uuid, rules);
+        ruleMapperLog('Set to %s from %s (%o): %O', node.nodeName, rule.from, rule.specificity, rule.rule);
+    }
+}
+exports.RuleMapper = RuleMapper;
+_RuleMapper_nodeList = new WeakMap(), _RuleMapper_ruleMap = new WeakMap();

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

@@ -0,0 +1,51 @@
+import type { TextNodeType } from './types';
+import type { MLASTText } from '@markuplint/ml-ast';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+import { MLCharacterData } from './character-data';
+export declare class MLText<T extends RuleConfigValue, O = null> extends MLCharacterData<T, O, MLASTText> implements Text {
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Text`
+     */
+    get assignedSlot(): HTMLSlotElement;
+    /**
+     * Returns a string appropriate for the type of node as `Text`
+     *
+     * @see https://dom.spec.whatwg.org/#ref-for-attr%E2%91%A4
+     */
+    get nodeName(): "#text";
+    /**
+     * Returns a number appropriate for the type of `Text`
+     */
+    get nodeType(): TextNodeType;
+    get textContent(): string | null;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Text`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-text-splittext%E2%91%A0
+     */
+    get wholeText(): string;
+    /**
+     * Returns `true` if a parent element is `<script>` or `<style>`
+     *
+     * @implements `@markuplint/ml-core` API: `MLText`
+     * @see https://html.spec.whatwg.org/multipage/syntax.html#raw-text-elements
+     */
+    isRawTextElementContent(): boolean;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLText`
+     */
+    isWhitespace(): boolean;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Text`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-text-wholetext%E2%91%A0
+     */
+    splitText(offset: number): Text;
+}

package/lib/ml-dom/node/text.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLText = void 0;
+const tslib_1 = require("tslib");
+const character_data_1 = require("./character-data");
+const unexpected_call_error_1 = tslib_1.__importDefault(require("./unexpected-call-error"));
+/**
+ * Raw text elements
+ *
+ * @see https://html.spec.whatwg.org/multipage/syntax.html#raw-text-elements
+ */
+const rawTextElements = ['script', 'style'];
+class MLText extends character_data_1.MLCharacterData {
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Text`
+     */
+    get assignedSlot() {
+        throw new unexpected_call_error_1.default('Not supported  "assignedSlot" property');
+    }
+    /**
+     * Returns a string appropriate for the type of node as `Text`
+     *
+     * @see https://dom.spec.whatwg.org/#ref-for-attr%E2%91%A4
+     */
+    get nodeName() {
+        return '#text';
+    }
+    /**
+     * Returns a number appropriate for the type of `Text`
+     */
+    get nodeType() {
+        return this.TEXT_NODE;
+    }
+    get textContent() {
+        return this.nodeValue;
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Text`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-text-splittext%E2%91%A0
+     */
+    get wholeText() {
+        throw new unexpected_call_error_1.default('Not supported "wholeText" property');
+    }
+    /**
+     * Returns `true` if a parent element is `<script>` or `<style>`
+     *
+     * @implements `@markuplint/ml-core` API: `MLText`
+     * @see https://html.spec.whatwg.org/multipage/syntax.html#raw-text-elements
+     */
+    isRawTextElementContent() {
+        return this.parentElement ? rawTextElements.includes(this.parentElement.nodeName.toLowerCase()) : false;
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLText`
+     */
+    isWhitespace() {
+        return /^\s+$/.test(this.raw);
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Text`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-text-wholetext%E2%91%A0
+     */
+    splitText(offset) {
+        throw new unexpected_call_error_1.default('Not supported "splitText" method');
+    }
+}
+exports.MLText = MLText;

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

@@ -0,0 +1,25 @@
+import type { MLToken } from '../token/token';
+import type { MLAttr } from './attr';
+import type { MLBlock } from './block';
+import type { MLComment } from './comment';
+import type { MLDocument } from './document';
+import type { MLDocumentFragment } from './document-fragment';
+import type { MLDocumentType } from './document-type';
+import type { MLElement } from './element';
+import type { MLNode } from './node';
+import type { MLText } from './text';
+import type { MLASTAbstructNode, MLASTAttr, MLASTComment, MLASTDoctype, MLASTElement, MLASTParentNode, MLASTPreprocessorSpecificBlock, MLASTText, MLToken as MLASTToken } from '@markuplint/ml-ast/';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+export declare type MappedNode<N, T extends RuleConfigValue, O = null> = N extends MLASTElement ? MLElement<T, O> : N extends MLASTParentNode ? MLElement<T, O> : N extends MLASTComment ? MLComment<T, O> : N extends MLASTText ? MLText<T, O> : N extends MLASTDoctype ? MLDocumentType<T, O> : N extends MLASTPreprocessorSpecificBlock ? MLBlock<T, O> : N extends MLASTAbstructNode ? MLNode<T, O, MLASTAbstructNode> : N extends MLASTAttr ? MLAttr<T, O> : N extends MLASTToken ? MLToken : never;
+export declare type NodeTypeOf<NT extends NodeType, T extends RuleConfigValue, O = null> = NT extends ElementNodeType ? MLElement<T, O> : NT extends CommentNodeType ? MLComment<T, O> : NT extends TextNodeType ? MLText<T, O> : NT extends DocumentNodeType ? MLDocument<T, O> : NT extends DocumentTypeNodeType ? MLDocumentType<T, O> : NT extends DocumentFragmentNodeType ? MLDocumentFragment<T, O> : NT extends MarkuplintPreprocessorBlockType ? MLBlock<T, O> : NT extends AttributeNodeType ? MLAttr<T, O> : never;
+export declare type ElementNodeType = 1;
+export declare type AttributeNodeType = 2;
+export declare type TextNodeType = 3;
+export declare type CDATASectionNodeType = 4;
+export declare type ProcessingInstructionNodeType = 7;
+export declare type CommentNodeType = 8;
+export declare type DocumentNodeType = 9;
+export declare type DocumentTypeNodeType = 10;
+export declare type DocumentFragmentNodeType = 11;
+export declare type MarkuplintPreprocessorBlockType = 101;
+export declare type NodeType = ElementNodeType | AttributeNodeType | TextNodeType | CDATASectionNodeType | ProcessingInstructionNodeType | CommentNodeType | DocumentNodeType | DocumentTypeNodeType | DocumentFragmentNodeType | MarkuplintPreprocessorBlockType;

package/lib/ml-dom/node/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/ml-dom/node/unexpected-call-error.d.ts

@@ -0,0 +1,2 @@
+export default class UnexpectedCallError extends Error {
+}

package/lib/ml-dom/node/unexpected-call-error.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class UnexpectedCallError extends Error {
+}
+exports.default = UnexpectedCallError;

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

@@ -0,0 +1,47 @@
+import type { MLToken as MLASTToken } from '@markuplint/ml-ast';
+export declare class MLToken<A extends MLASTToken = MLASTToken> {
+    #private;
+    readonly uuid: string;
+    protected readonly _astToken: A;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get endCol(): number;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get endLine(): number;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get endOffset(): number;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get originRaw(): string;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get raw(): string;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get startCol(): number;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get startLine(): number;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get startOffset(): number;
+    constructor(astToken: A);
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    fix(raw: string): void;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    toString(): string;
+}

package/lib/ml-dom/token/token.js

@@ -0,0 +1,89 @@
+"use strict";
+var _MLToken_endCol, _MLToken_endLine, _MLToken_endOffset, _MLToken_fixed, _MLToken_raw, _MLToken_startCol, _MLToken_startLine, _MLToken_startOffset;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLToken = void 0;
+const tslib_1 = require("tslib");
+class MLToken {
+    constructor(astToken) {
+        _MLToken_endCol.set(this, void 0);
+        _MLToken_endLine.set(this, void 0);
+        _MLToken_endOffset.set(this, void 0);
+        _MLToken_fixed.set(this, void 0);
+        _MLToken_raw.set(this, void 0);
+        _MLToken_startCol.set(this, void 0);
+        _MLToken_startLine.set(this, void 0);
+        _MLToken_startOffset.set(this, void 0);
+        this._astToken = astToken;
+        tslib_1.__classPrivateFieldSet(this, _MLToken_raw, astToken.raw, "f");
+        tslib_1.__classPrivateFieldSet(this, _MLToken_fixed, astToken.raw, "f");
+        this.uuid = astToken.uuid;
+        tslib_1.__classPrivateFieldSet(this, _MLToken_startLine, astToken.startLine, "f");
+        tslib_1.__classPrivateFieldSet(this, _MLToken_endLine, astToken.endLine, "f");
+        tslib_1.__classPrivateFieldSet(this, _MLToken_startCol, astToken.startCol, "f");
+        tslib_1.__classPrivateFieldSet(this, _MLToken_endCol, astToken.endCol, "f");
+        tslib_1.__classPrivateFieldSet(this, _MLToken_startOffset, astToken.startOffset, "f");
+        tslib_1.__classPrivateFieldSet(this, _MLToken_endOffset, astToken.endOffset, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get endCol() {
+        return tslib_1.__classPrivateFieldGet(this, _MLToken_endCol, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get endLine() {
+        return tslib_1.__classPrivateFieldGet(this, _MLToken_endLine, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get endOffset() {
+        return tslib_1.__classPrivateFieldGet(this, _MLToken_endOffset, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get originRaw() {
+        return tslib_1.__classPrivateFieldGet(this, _MLToken_raw, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get raw() {
+        return tslib_1.__classPrivateFieldGet(this, _MLToken_fixed, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get startCol() {
+        return tslib_1.__classPrivateFieldGet(this, _MLToken_startCol, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get startLine() {
+        return tslib_1.__classPrivateFieldGet(this, _MLToken_startLine, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    get startOffset() {
+        return tslib_1.__classPrivateFieldGet(this, _MLToken_startOffset, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    fix(raw) {
+        tslib_1.__classPrivateFieldSet(this, _MLToken_fixed, raw, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     */
+    toString() {
+        return this.raw;
+    }
+}
+exports.MLToken = MLToken;
+_MLToken_endCol = new WeakMap(), _MLToken_endLine = new WeakMap(), _MLToken_endOffset = new WeakMap(), _MLToken_fixed = new WeakMap(), _MLToken_raw = new WeakMap(), _MLToken_startCol = new WeakMap(), _MLToken_startLine = new WeakMap(), _MLToken_startOffset = new WeakMap();

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

@@ -1,4 +1,4 @@
-import type { AnonymousNode, Document } from '../';
+import type { Document } from '../';
 import type { MLDOMAttribute, MLDOMElement, MLDOMOmittedElement, MLDOMText } from './';
 import type MLDOMPreprocessorSpecificAttribute from './preprocessor-specific-attribute';
 import type { MLASTElement, MLASTOmittedElement } from '@markuplint/ml-ast';
@@ -20,7 +20,6 @@ export default abstract class MLDOMAbstractElement<T extends RuleConfigValue, O
     readonly isInFragmentDocument: boolean;
     constructor(astNode: E, document: Document<T, O>);
     get tagName(): string;
-    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;

package/lib/ml-dom/tokens/abstract-element.js

@@ -29,10 +29,6 @@ class MLDOMAbstractElement extends node_1.default {
     get tagName() {
         return this.nodeName;
     }
-    get childNodes() {
-        const astChildren = this._astToken.childNodes || [];
-        return astChildren.map(node => this.nodeStore.getNode(node));
-    }
     get children() {
         return this.childNodes.filter((node) => {
             return node.type === 'Element' || node.type === 'OmittedElement';

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

@@ -24,6 +24,7 @@ export default abstract class MLDOMNode<T extends RuleConfigValue, O = null, A e
     readonly rules: Record<string, AnyRule>;
     protected _astToken: A;
     constructor(astNode: A, document: Document<T, O>);
+    get childNodes(): AnonymousNode<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;

package/lib/ml-dom/tokens/node.js

@@ -29,6 +29,14 @@ class MLDOMNode extends token_1.default {
         this.ownerDocument = document;
         this.ownerDocument.nodeStore.setNode(astNode, this);
     }
+    get childNodes() {
+        if (this._astToken.type === 'starttag' || this._astToken.type === 'omittedtag') {
+            // @ts-ignore
+            const astChildren = this._astToken.childNodes || [];
+            return astChildren.map(node => this.nodeStore.getNode(node));
+        }
+        return [];
+    }
     get parentNode() {
         if (!this._astToken.parentNode) {
             return null;

package/lib/selector/is-pure-html-element.d.ts

@@ -0,0 +1 @@
+export declare function isPureHTMLElement(el: Element): boolean;

package/lib/selector/is-pure-html-element.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPureHTMLElement = void 0;
+function isPureHTMLElement(el) {
+    return el.localName !== el.nodeName;
+}
+exports.isPureHTMLElement = isPureHTMLElement;

package/lib/selector/match-selector.d.ts

@@ -0,0 +1,14 @@
+import type { Specificity } from './selector';
+import type { RegexSelector } from '@markuplint/ml-config';
+export declare type SelectorMatches = SelectorMatched | SelectorUnmatched;
+declare type SelectorMatched = {
+    matched: true;
+    selector: string;
+    specificity: Specificity;
+    data?: Record<string, string>;
+};
+declare type SelectorUnmatched = {
+    matched: false;
+};
+export declare function matchSelector(el: Element, selector: string | RegexSelector | undefined): SelectorMatches;
+export {};