@markuplint/ml-core 2.3.0 → 3.0.0-alpha.66

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

@@ -1,5 +1,5 @@
 "use strict";
-var _MLDOMIndentation_node, _MLDOMIndentation_parent, _MLDOMIndentation_fixed;
+var _MLDOMIndentation_fixed, _MLDOMIndentation_node, _MLDOMIndentation_parent;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIndent = void 0;
 const tslib_1 = require("tslib");
@@ -13,8 +13,8 @@ function getIndent(node) {
     if (!prevToken) {
         return null;
     }
-    if (node.type === 'Text') {
-        if (node.isRawText) {
+    if (node.is(node.TEXT_NODE)) {
+        if (node.isRawTextElementContent()) {
             return null;
         }
         const matched = node.raw.match(/^(\s*(?:\r?\n)+\s*)(?:[^\s]+)/);
@@ -31,7 +31,7 @@ function getIndent(node) {
         }
         return null;
     }
-    if (prevToken.type !== 'Text') {
+    if (!prevToken.is(node.TEXT_NODE)) {
         return null;
     }
     // One or more newlines and zero or more spaces or tabs.
@@ -52,33 +52,33 @@ function getIndent(node) {
 exports.getIndent = getIndent;
 class MLDOMIndentation {
     constructor(originTextNode, raw, line, parentNode) {
+        _MLDOMIndentation_fixed.set(this, void 0);
         _MLDOMIndentation_node.set(this, void 0);
         _MLDOMIndentation_parent.set(this, void 0);
-        _MLDOMIndentation_fixed.set(this, void 0);
         this.line = line;
         tslib_1.__classPrivateFieldSet(this, _MLDOMIndentation_node, originTextNode, "f");
         tslib_1.__classPrivateFieldSet(this, _MLDOMIndentation_parent, parentNode, "f");
         tslib_1.__classPrivateFieldSet(this, _MLDOMIndentation_fixed, raw, "f");
     }
+    get raw() {
+        if (!tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").is(tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").TEXT_NODE) && this.line !== tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_node, "f").endLine) {
+            return '';
+        }
+        return tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f");
+    }
     get type() {
-        if (tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").type !== 'Text' && this.line !== tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_node, "f").endLine) {
+        if (!tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").is(tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").TEXT_NODE) && this.line !== tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_node, "f").endLine) {
             return 'none';
         }
         const raw = tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f");
         return raw === '' ? 'none' : /^\t+$/.test(raw) ? 'tab' : /^[^\t]+$/.test(raw) ? 'space' : 'mixed';
     }
     get width() {
-        if (tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").type !== 'Text' && this.line !== tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_node, "f").endLine) {
+        if (!tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").is(tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").TEXT_NODE) && this.line !== tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_node, "f").endLine) {
             return 0;
         }
         return tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f").length;
     }
-    get raw() {
-        if (tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_parent, "f").type !== 'Text' && this.line !== tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_node, "f").endLine) {
-            return '';
-        }
-        return tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f");
-    }
     fix(raw) {
         const current = tslib_1.__classPrivateFieldGet(this, _MLDOMIndentation_fixed, "f");
         tslib_1.__classPrivateFieldSet(this, _MLDOMIndentation_fixed, raw, "f");
@@ -94,7 +94,7 @@ class MLDOMIndentation {
         }
     }
 }
-_MLDOMIndentation_node = new WeakMap(), _MLDOMIndentation_parent = new WeakMap(), _MLDOMIndentation_fixed = new WeakMap();
+_MLDOMIndentation_fixed = new WeakMap(), _MLDOMIndentation_node = new WeakMap(), _MLDOMIndentation_parent = new WeakMap();
 function isFirstToken(node) {
     return !node.prevToken;
 }

package/lib/ml-dom/helper/mapped-nodes.d.ts

@@ -1,4 +1,52 @@
-import type { MLDOMAttribute, MLDOMComment, MLDOMDoctype, MLDOMElement, MLDOMElementCloseTag, MLDOMNode, MLDOMOmittedElement, MLDOMPreprocessorSpecificBlock, MLDOMText, MLDOMToken } from '../tokens';
-import type { MLASTAbstructNode, MLASTAttr, MLASTComment, MLASTDoctype, MLASTElement, MLASTElementCloseTag, MLASTNode, MLASTOmittedElement, MLASTParentNode, MLASTPreprocessorSpecificBlock, MLASTText, MLToken } from '@markuplint/ml-ast/';
+import type {
+	MLDOMAttribute,
+	MLDOMComment,
+	MLDOMDoctype,
+	MLDOMElement,
+	MLDOMElementCloseTag,
+	MLDOMNode,
+	MLDOMOmittedElement,
+	MLDOMPreprocessorSpecificBlock,
+	MLDOMText,
+	MLDOMToken,
+} from '../tokens';
+import type {
+	MLASTAbstructNode,
+	MLASTAttr,
+	MLASTComment,
+	MLASTDoctype,
+	MLASTElement,
+	MLASTElementCloseTag,
+	MLASTNode,
+	MLASTOmittedElement,
+	MLASTParentNode,
+	MLASTPreprocessorSpecificBlock,
+	MLASTText,
+	MLToken,
+} from '@markuplint/ml-ast/';
 import type { RuleConfigValue } from '@markuplint/ml-config';
-export declare type MappedNode<N, T extends RuleConfigValue, O = null> = N extends MLASTElement ? MLDOMElement<T, O> : N extends MLASTElementCloseTag ? MLDOMElementCloseTag<T, O> : N extends MLASTOmittedElement ? MLDOMOmittedElement<T, O> : N extends MLASTParentNode ? (MLDOMElement<T, O> | MLDOMOmittedElement<T, O>) : N extends MLASTComment ? MLDOMComment<T, O> : N extends MLASTText ? MLDOMText<T, O> : N extends MLASTDoctype ? MLDOMDoctype<T, O> : N extends MLASTNode ? MLDOMNode<T, O, MLASTNode> : N extends MLASTPreprocessorSpecificBlock ? MLDOMPreprocessorSpecificBlock<T, O> : N extends MLASTAbstructNode ? MLDOMNode<T, O, MLASTAbstructNode> : N extends MLASTAttr ? MLDOMAttribute : N extends MLToken ? MLDOMToken<MLToken> : never;
+export declare type MappedNode<N, T extends RuleConfigValue, O = null> = N extends MLASTElement
+	? MLDOMElement<T, O>
+	: N extends MLASTElementCloseTag
+	? MLDOMElementCloseTag<T, O>
+	: N extends MLASTOmittedElement
+	? MLDOMOmittedElement<T, O>
+	: N extends MLASTParentNode
+	? MLDOMElement<T, O> | MLDOMOmittedElement<T, O>
+	: N extends MLASTComment
+	? MLDOMComment<T, O>
+	: N extends MLASTText
+	? MLDOMText<T, O>
+	: N extends MLASTDoctype
+	? MLDOMDoctype<T, O>
+	: N extends MLASTNode
+	? MLDOMNode<T, O, MLASTNode>
+	: N extends MLASTPreprocessorSpecificBlock
+	? MLDOMPreprocessorSpecificBlock<T, O>
+	: N extends MLASTAbstructNode
+	? MLDOMNode<T, O, MLASTAbstructNode>
+	: N extends MLASTAttr
+	? MLDOMAttribute
+	: N extends MLToken
+	? MLDOMToken<MLToken>
+	: never;

package/lib/ml-dom/helper/match-selector.d.ts

@@ -3,14 +3,18 @@ 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>;
+	matched: true;
+	selector: string;
+	specificity: Specificity;
+	data?: Record<string, string>;
 };
 declare type SelectorUnmatched = {
-    matched: false;
+	matched: false;
 };
 declare type TargetElement = MLDOMAbstractElement<any, any>;
-export declare function matchSelector(el: TargetElement, selector: string | RegexSelector | undefined, tagNameCaseSensitive?: boolean): SelectorMatches;
+export declare function matchSelector(
+	el: TargetElement,
+	selector: string | RegexSelector | undefined,
+	tagNameCaseSensitive?: boolean,
+): SelectorMatches;
 export {};

package/lib/ml-dom/helper/node-store.d.ts

@@ -3,7 +3,10 @@ import type { MappedNode } from './mapped-nodes';
 import type { MLASTAbstructNode } from '@markuplint/ml-ast';
 import type { RuleConfigValue } from '@markuplint/ml-config';
 export default class NodeStore {
-    #private;
-    setNode<A extends MLASTAbstructNode, T extends RuleConfigValue, O = null>(astNode: A, node: MLDOMNode<T, O, A>): void;
-    getNode<N extends MLASTAbstructNode, T extends RuleConfigValue, O = null>(astNode: N): MappedNode<N, T, O>;
+	#private;
+	setNode<A extends MLASTAbstructNode, T extends RuleConfigValue, O = null>(
+		astNode: A,
+		node: MLDOMNode<T, O, A>,
+	): void;
+	getNode<N extends MLASTAbstructNode, T extends RuleConfigValue, O = null>(astNode: N): MappedNode<N, T, O>;
 }

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

@@ -1,11 +1,11 @@
 import type MLDOMAbstractElement from '../tokens/abstract-element';
 export declare type Specificity = [number, number, number];
 export declare function createSelector(selector: string, tagNameCaseSensitive?: boolean): Selector;
-export declare function compareSpecificity(a: Specificity, b: Specificity): 1 | 0 | -1;
+export declare function compareSpecificity(a: Specificity, b: Specificity): 0 | 1 | -1;
 declare type TargetElement = MLDOMAbstractElement<any, any>;
 declare class Selector {
-    #private;
-    constructor(selector: string, tagNameCaseSensitive: boolean);
-    match(el: TargetElement, caller?: TargetElement | null): Specificity | false;
+	#private;
+	constructor(selector: string, tagNameCaseSensitive: boolean);
+	match(el: TargetElement, caller?: TargetElement | null): Specificity | false;
 }
 export {};

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

@@ -1,5 +1,6 @@
-import type { AnonymousNode } from '../types';
+import type { MLNode } from '../node/node';
 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 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 type Walker<T extends RuleConfigValue, O = null, N = MLNode<T, O>> = (node: N) => void | Promise<void> | Promise<void>[];
+export declare type SyncWalker<T extends RuleConfigValue, O = null, N = MLNode<T, O>> = (node: N) => void;
+export declare function syncWalk<T extends RuleConfigValue, O = null>(nodeList: ReadonlyArray<MLNode<T, O>>, walker: SyncWalker<T, O>): void;
+export declare function sequentialWalker<T extends RuleConfigValue, O = null, N = MLNode<T, O>>(list: ReadonlyArray<N>, walker: Walker<T, O, N>): Promise<void>;

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

@@ -1,12 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncWalk = void 0;
+exports.sequentialWalker = exports.syncWalk = void 0;
 function syncWalk(nodeList, walker) {
     for (const node of nodeList) {
-        if (node.type === 'Element' || node.type === 'OmittedElement' || node.type === 'PSBlock') {
-            syncWalk(node.childNodes, walker);
+        if (node.is(node.ELEMENT_NODE) || node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+            syncWalk(Array.from(node.childNodes), walker);
         }
         walker(node);
     }
 }
 exports.syncWalk = syncWalk;
+function sequentialWalker(list, walker) {
+    if (list.length === 0) {
+        return Promise.resolve();
+    }
+    /**
+     * The following pattern is used to ensure that all rules run sequentially,
+     * no matter it runs asynchronously or synchronously.
+     */
+    let _resolve;
+    let _reject;
+    const promise = new Promise((resolve, reject) => {
+        _resolve = resolve;
+        _reject = reject;
+    });
+    const loop = (index = 0) => {
+        if (index >= list.length) {
+            _resolve();
+            return;
+        }
+        const node = list[index];
+        if (!node) {
+            _resolve();
+            return;
+        }
+        const result = walker(node);
+        if (result instanceof Promise) {
+            result.then(() => loop(index + 1)).catch(_reject);
+        }
+        else {
+            loop(index + 1);
+        }
+    };
+    loop();
+    return promise;
+}
+exports.sequentialWalker = sequentialWalker;

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

@@ -1,3 +1,8 @@
-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 type { MLAttr as Attr } from './node/attr';
+export type { MLBlock as Block } from './node/block';
+export type { MLComment as Comment } from './node/comment';
+export type { MLDocumentFragment as DocumentFragment } from './node/document-fragment';
+export type { MLDocumentType as DocumentType } from './node/document-type';
+export type { MLElement as Element } from './node/element';
+export type { MLText as Text } from './node/text';
+export { MLDocument as Document } from './node/document';

package/lib/ml-dom/index.js

@@ -1,17 +1,5 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Text = exports.OmittedElement = exports.Node = exports.ElementCloseTag = exports.Element = exports.Doctype = exports.Comment = exports.Attribute = exports.Document = void 0;
-var document_1 = require("./document");
-Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return __importDefault(document_1).default; } });
-var tokens_1 = require("./tokens");
-Object.defineProperty(exports, "Attribute", { enumerable: true, get: function () { return tokens_1.MLDOMAttribute; } });
-Object.defineProperty(exports, "Comment", { enumerable: true, get: function () { return tokens_1.MLDOMComment; } });
-Object.defineProperty(exports, "Doctype", { enumerable: true, get: function () { return tokens_1.MLDOMDoctype; } });
-Object.defineProperty(exports, "Element", { enumerable: true, get: function () { return tokens_1.MLDOMElement; } });
-Object.defineProperty(exports, "ElementCloseTag", { enumerable: true, get: function () { return tokens_1.MLDOMElementCloseTag; } });
-Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return tokens_1.MLDOMNode; } });
-Object.defineProperty(exports, "OmittedElement", { enumerable: true, get: function () { return tokens_1.MLDOMOmittedElement; } });
-Object.defineProperty(exports, "Text", { enumerable: true, get: function () { return tokens_1.MLDOMText; } });
+exports.Document = void 0;
+var document_1 = require("./node/document");
+Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return document_1.MLDocument; } });

package/lib/ml-dom/manipulations/child-node-methods.d.ts

@@ -0,0 +1,33 @@
+import type { MLElement } from '../node/element';
+import type { MLNode } from '../node/node';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-childnode-before%E2%91%A0
+ */
+export declare function before<T extends RuleConfigValue, O = null>(node: MLNode<T, O>, ...additionalNodes: ReadonlyArray<MLNode<T, O> | string>): void;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-childnode-after%E2%91%A0
+ */
+export declare function after<T extends RuleConfigValue, O = null>(node: MLNode<T, O>, ...additionalNodes: ReadonlyArray<MLNode<T, O> | string>): void;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-childnode-replacewith%E2%91%A0
+ */
+export declare function replaceWith<T extends RuleConfigValue, O = null>(node: MLNode<T, O>, ...additionalNodes: ReadonlyArray<MLNode<T, O> | string>): void;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-childnode-remove%E2%91%A0
+ */
+export declare function remove<T extends RuleConfigValue, O = null>(node: MLNode<T, O>): void;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-nondocumenttypechildnode-previouselementsibling%E2%91%A0
+ */
+export declare function previousElementSibling<T extends RuleConfigValue, O = null>(node: MLNode<T, O>): MLElement<T, O> | null;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-nondocumenttypechildnode-nextelementsibling%E2%91%A0
+ */
+export declare function nextElementSibling<T extends RuleConfigValue, O = null>(node: MLNode<T, O>): MLElement<T, O> | null;

package/lib/ml-dom/manipulations/child-node-methods.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextElementSibling = exports.previousElementSibling = exports.remove = exports.replaceWith = exports.after = exports.before = void 0;
+const tslib_1 = require("tslib");
+const unexpected_call_error_1 = tslib_1.__importDefault(require("../node/unexpected-call-error"));
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-childnode-before%E2%91%A0
+ */
+function before(node, ...additionalNodes) {
+    throw new unexpected_call_error_1.default('Not supported "before" method');
+}
+exports.before = before;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-childnode-after%E2%91%A0
+ */
+function after(node, ...additionalNodes) {
+    throw new unexpected_call_error_1.default('Not supported "after" method');
+}
+exports.after = after;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-childnode-replacewith%E2%91%A0
+ */
+function replaceWith(node, ...additionalNodes) {
+    throw new unexpected_call_error_1.default('Not supported "replaceWith" method');
+}
+exports.replaceWith = replaceWith;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-childnode-remove%E2%91%A0
+ */
+function remove(node) {
+    throw new unexpected_call_error_1.default('Not supported "remove" method');
+}
+exports.remove = remove;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-nondocumenttypechildnode-previouselementsibling%E2%91%A0
+ */
+function previousElementSibling(node) {
+    var _a, _b;
+    let prevNode = node.prevNode;
+    while (prevNode) {
+        if (((node.parentNode === null && prevNode.parentNode === null) ||
+            ((_a = node.parentNode) === null || _a === void 0 ? void 0 : _a.uuid) === ((_b = prevNode.parentNode) === null || _b === void 0 ? void 0 : _b.uuid)) &&
+            prevNode.is(prevNode.ELEMENT_NODE)) {
+            return prevNode;
+        }
+        prevNode = prevNode.prevNode;
+    }
+    return null;
+}
+exports.previousElementSibling = previousElementSibling;
+/**
+ *
+ * @see https://dom.spec.whatwg.org/#ref-for-dom-nondocumenttypechildnode-nextelementsibling%E2%91%A0
+ */
+function nextElementSibling(node) {
+    var _a, _b;
+    let nextNode = node.nextNode;
+    while (nextNode) {
+        if (((node.parentNode === null && nextNode.parentNode === null) ||
+            ((_a = node.parentNode) === null || _a === void 0 ? void 0 : _a.uuid) === ((_b = nextNode.parentNode) === null || _b === void 0 ? void 0 : _b.uuid)) &&
+            nextNode.is(nextNode.ELEMENT_NODE)) {
+            return nextNode;
+        }
+        nextNode = nextNode.nextNode;
+    }
+    return null;
+}
+exports.nextElementSibling = nextElementSibling;

package/lib/ml-dom/manipulations/get-children.d.ts

@@ -0,0 +1,4 @@
+import type { MLElement } from '../node/element';
+import type { MLNode } from '../node/node';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+export declare function getChildren<T extends RuleConfigValue, O = null>(node: MLNode<T, O>): HTMLCollectionOf<MLElement<T, O>>;

package/lib/ml-dom/manipulations/get-children.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChildren = void 0;
+const node_list_1 = require("../node/node-list");
+function getChildren(node) {
+    return (0, node_list_1.toHTMLCollection)(Array.from(node.childNodes).filter((child) => {
+        return child.nodeType === child.ELEMENT_NODE;
+    }));
+}
+exports.getChildren = getChildren;

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

@@ -0,0 +1,98 @@
+import type { MLElement } from './element';
+import type { AttributeNodeType } from './types';
+import type { MLASTAttr } from '@markuplint/ml-ast';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+import { MLToken } from '../token/token';
+import { MLDomTokenList } from './dom-token-list';
+import { MLNode } from './node';
+export declare class MLAttr<T extends RuleConfigValue, O = null> extends MLNode<T, O, MLASTAttr> implements Attr {
+    #private;
+    readonly candidate?: string;
+    readonly endQuote: MLToken | null;
+    readonly equal: MLToken | null;
+    readonly isDirective?: true;
+    readonly isDuplicatable: boolean;
+    readonly isDynamicValue?: true;
+    readonly nameNode: MLToken | null;
+    /**
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-node-previoussibling%E2%91%A0
+     */
+    readonly ownerElement: MLElement<T, O>;
+    readonly spacesAfterEqual: MLToken | null;
+    readonly spacesBeforeEqual: MLToken | null;
+    readonly spacesBeforeName: MLToken | null;
+    readonly startQuote: MLToken | null;
+    readonly valueNode: MLToken | null;
+    /**
+     * Returns the "string" if HTML syntax. Otherwise, returns a type in its syntax.
+     *
+     * @default "string"
+     * @implements `@markuplint/ml-core` API: `MLAttr`
+     */
+    readonly valueType: 'string' | 'number' | 'boolean' | 'code';
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-attr-localname
+     */
+    get localName(): string;
+    /**
+     *
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#dom-attr-name
+     */
+    get name(): string;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-attr-namespaceuri
+     */
+    get namespaceURI(): string | null;
+    /**
+     * Returns a string appropriate for the type of node as `Attr`
+     *
+     * @see https://dom.spec.whatwg.org/#ref-for-attr%E2%91%A4
+     */
+    get nodeName(): string;
+    /**
+     * Returns a number appropriate for the type of `Attr`
+     */
+    get nodeType(): AttributeNodeType;
+    get nodeValue(): string;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-attr-prefix
+     */
+    get prefix(): string | null;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLAttr`
+     */
+    get rule(): import("@markuplint/ml-config").RuleInfo<T, O>;
+    /**
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#dom-attr-specified
+     */
+    get specified(): true;
+    /**
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#dom-attr-value
+     */
+    get value(): string;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLAttr`
+     */
+    get tokenList(): MLDomTokenList | null;
+    constructor(astToken: MLASTAttr, ownElement: MLElement<T, O>);
+    /**
+     * @implements `@markuplint/ml-core` API: `MLAttr`
+     */
+    toNormalizeString(): string;
+}

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

@@ -0,0 +1,151 @@
+"use strict";
+var _MLAttr_potentialName, _MLAttr_potentialValue;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLAttr = void 0;
+const tslib_1 = require("tslib");
+const token_1 = require("../token/token");
+const dom_token_list_1 = require("./dom-token-list");
+const node_1 = require("./node");
+const unexpected_call_error_1 = tslib_1.__importDefault(require("./unexpected-call-error"));
+class MLAttr extends node_1.MLNode {
+    constructor(astToken, ownElement) {
+        var _a;
+        super(astToken, ownElement.ownerMLDocument);
+        _MLAttr_potentialName.set(this, void 0);
+        _MLAttr_potentialValue.set(this, void 0);
+        this.endQuote = null;
+        this.equal = null;
+        this.nameNode = null;
+        this.spacesAfterEqual = null;
+        this.spacesBeforeEqual = null;
+        this.spacesBeforeName = null;
+        this.startQuote = null;
+        this.valueNode = null;
+        /**
+         * Returns the "string" if HTML syntax. Otherwise, returns a type in its syntax.
+         *
+         * @default "string"
+         * @implements `@markuplint/ml-core` API: `MLAttr`
+         */
+        this.valueType = 'string';
+        if (this._astToken.type === 'html-attr') {
+            this.spacesBeforeName = new token_1.MLToken(this._astToken.spacesBeforeName);
+            this.nameNode = new token_1.MLToken(this._astToken.name);
+            this.spacesBeforeEqual = new token_1.MLToken(this._astToken.spacesBeforeEqual);
+            this.equal = new token_1.MLToken(this._astToken.equal);
+            this.spacesAfterEqual = new token_1.MLToken(this._astToken.spacesAfterEqual);
+            this.startQuote = new token_1.MLToken(this._astToken.startQuote);
+            this.valueNode = new token_1.MLToken(this._astToken.value);
+            this.endQuote = new token_1.MLToken(this._astToken.endQuote);
+            this.isDynamicValue = this._astToken.isDynamicValue;
+            this.isDirective = this._astToken.isDirective;
+            this.candidate = this._astToken.candidate;
+            tslib_1.__classPrivateFieldSet(this, _MLAttr_potentialName, this._astToken.potentialName || ((_a = this.nameNode) === null || _a === void 0 ? void 0 : _a.raw) || '', "f");
+            tslib_1.__classPrivateFieldSet(this, _MLAttr_potentialValue, this._astToken.value.raw || '', "f");
+        }
+        else {
+            this.valueType = this._astToken.valueType;
+            this.isDuplicatable = this._astToken.isDuplicatable;
+            tslib_1.__classPrivateFieldSet(this, _MLAttr_potentialName, this._astToken.potentialName, "f");
+            tslib_1.__classPrivateFieldSet(this, _MLAttr_potentialValue, this._astToken.potentialValue, "f");
+        }
+        this.ownerElement = ownElement;
+        this.isDuplicatable = this._astToken.isDuplicatable;
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-attr-localname
+     */
+    get localName() {
+        throw new unexpected_call_error_1.default('Not supported "localname" property');
+    }
+    /**
+     *
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#dom-attr-name
+     */
+    get name() {
+        return tslib_1.__classPrivateFieldGet(this, _MLAttr_potentialName, "f");
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-attr-namespaceuri
+     */
+    get namespaceURI() {
+        throw new unexpected_call_error_1.default('Not supported "namespaceURI" property');
+    }
+    /**
+     * Returns a string appropriate for the type of node as `Attr`
+     *
+     * @see https://dom.spec.whatwg.org/#ref-for-attr%E2%91%A4
+     */
+    get nodeName() {
+        return this.name;
+    }
+    /**
+     * Returns a number appropriate for the type of `Attr`
+     */
+    get nodeType() {
+        return this.ATTRIBUTE_NODE;
+    }
+    get nodeValue() {
+        return this.value;
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-attr-prefix
+     */
+    get prefix() {
+        throw new unexpected_call_error_1.default('Not supported "prefix" property');
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLAttr`
+     */
+    get rule() {
+        return this.ownerElement.rule;
+    }
+    /**
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#dom-attr-specified
+     */
+    get specified() {
+        return true;
+    }
+    /**
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#dom-attr-value
+     */
+    get value() {
+        return tslib_1.__classPrivateFieldGet(this, _MLAttr_potentialValue, "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLAttr`
+     */
+    get tokenList() {
+        return this.isDynamicValue ? null : new dom_token_list_1.MLDomTokenList(this.value, [this]);
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLAttr`
+     */
+    toNormalizeString() {
+        if (this.nameNode && this.equal && this.startQuote && this.valueNode && this.endQuote) {
+            return (this.nameNode.originRaw +
+                this.equal.originRaw +
+                this.startQuote.originRaw +
+                this.valueNode.originRaw +
+                this.endQuote.originRaw);
+        }
+        return this.raw;
+    }
+}
+exports.MLAttr = MLAttr;
+_MLAttr_potentialName = new WeakMap(), _MLAttr_potentialValue = new WeakMap();