@markuplint/ml-core 2.2.2 → 2.3.1

package/lib/ml-core.d.ts

@@ -10,7 +10,7 @@ export declare type MLCoreParams = {
 export declare class MLCore {
     #private;
     constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, filename, debug }: MLCoreParams);
-    get document(): ParserError | Document<RuleConfigValue, unknown>;
+    get document(): Document<RuleConfigValue, unknown> | ParserError;
     verify(fix?: boolean): Promise<Violation[]>;
     setCode(sourceCode: string): void;
     update({ parser, ruleset, rules, locale, schemas, parserOptions }: Partial<MLFabric>): void;

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

@@ -11,6 +11,7 @@ function getAccname(el) {
         return name;
     }
     catch (err) {
+        accnameLog('Raw: %s', el.raw);
         accnameLog('Error: %O', err);
         return '';
     }

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

@@ -1,7 +1,7 @@
 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;

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,93 @@
+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 { 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;
+    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,144 @@
+"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 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`
+     */
+    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();

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

@@ -0,0 +1,38 @@
+import type { MLDocument } from './document';
+import type { MLElement } from './element';
+import type { MarkuplintPreprocessorBlockType } from './types';
+import type { MLASTPreprocessorSpecificBlock } from '@markuplint/ml-ast';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+import { MLNode } from './node';
+export declare class MLBlock<T extends RuleConfigValue, O = null> extends MLNode<T, O, MLASTPreprocessorSpecificBlock> {
+    readonly isTransparent: boolean;
+    /**
+     * Returns a string appropriate for the type of node as `MLBlock`
+     *
+     * @implements `@markuplint/ml-core` API: `MLBlock`
+     */
+    get nodeName(): "#ml-block";
+    /**
+     * Returns a number appropriate for the type of `MLBlock`
+     *
+     * @implements `@markuplint/ml-core` API: `MLBlock`
+     */
+    get nodeType(): MarkuplintPreprocessorBlockType;
+    constructor(astNode: MLASTPreprocessorSpecificBlock, document: MLDocument<T, O>);
+    /**
+     * @implements DOM API: `ChildNode`
+     */
+    after(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * @implements DOM API: `ChildNode`
+     */
+    before(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * @implements DOM API: `ChildNode`
+     */
+    remove(): void;
+    /**
+     * @implements DOM API: `ChildNode`
+     */
+    replaceWith(...nodes: (string | MLElement<any, any>)[]): void;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLBlock = void 0;
+const child_node_methods_1 = require("../manipulations/child-node-methods");
+const node_1 = require("./node");
+class MLBlock extends node_1.MLNode {
+    constructor(astNode, document) {
+        super(astNode, document);
+        // TODO:
+        this.isTransparent = true;
+    }
+    /**
+     * Returns a string appropriate for the type of node as `MLBlock`
+     *
+     * @implements `@markuplint/ml-core` API: `MLBlock`
+     */
+    get nodeName() {
+        return '#ml-block';
+    }
+    /**
+     * Returns a number appropriate for the type of `MLBlock`
+     *
+     * @implements `@markuplint/ml-core` API: `MLBlock`
+     */
+    get nodeType() {
+        return this.MARKUPLINT_PREPROCESSOR_BLOCK;
+    }
+    /**
+     * @implements DOM API: `ChildNode`
+     */
+    after(...nodes) {
+        (0, child_node_methods_1.after)(this, ...nodes);
+    }
+    /**
+     * @implements DOM API: `ChildNode`
+     */
+    before(...nodes) {
+        (0, child_node_methods_1.before)(this, ...nodes);
+    }
+    /**
+     * @implements DOM API: `ChildNode`
+     */
+    remove() {
+        (0, child_node_methods_1.remove)(this);
+    }
+    /**
+     * @implements DOM API: `ChildNode`
+     */
+    replaceWith(...nodes) {
+        (0, child_node_methods_1.replaceWith)(this, ...nodes);
+    }
+}
+exports.MLBlock = MLBlock;

package/lib/ml-dom/node/character-data.d.ts

@@ -0,0 +1,57 @@
+import type { MLElement } from './element';
+import type { MLASTAbstructNode } from '@markuplint/ml-ast';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+import { MLNode } from './node';
+export declare abstract class MLCharacterData<T extends RuleConfigValue, O = null, A extends MLASTAbstructNode = MLASTAbstructNode> extends MLNode<T, O, A> implements CharacterData {
+    /**
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-data
+     */
+    get data(): string;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-length
+     */
+    get length(): number;
+    /**
+     * The element immediately following the specified one in its parent's children list.
+     *
+     * @readonly
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-nondocumenttypechildnode-nextelementsibling%E2%91%A1
+     */
+    get nextElementSibling(): MLElement<T, O> | null;
+    get nodeValue(): string | null;
+    /**
+     * The element immediately prior the specified one in its parent's children list.
+     *
+     * @readonly
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-nondocumenttypechildnode-previouselementsibling%E2%91%A1
+     */
+    get previousElementSibling(): MLElement<T, O> | null;
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    after(...nodes: (string | MLElement<any, any>)[]): void;
+    appendData(data: string): void;
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    before(...nodes: (string | MLElement<any, any>)[]): void;
+    deleteData(offset: number, count: number): void;
+    insertData(offset: number, data: string): void;
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    remove(): void;
+    replaceData(offset: number, count: number, data: string): void;
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    replaceWith(...nodes: (string | MLElement<any, any>)[]): void;
+    substringData(offset: number, count: number): string;
+}

package/lib/ml-dom/node/character-data.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLCharacterData = void 0;
+const tslib_1 = require("tslib");
+const child_node_methods_1 = require("../manipulations/child-node-methods");
+const node_1 = require("./node");
+const unexpected_call_error_1 = tslib_1.__importDefault(require("./unexpected-call-error"));
+class MLCharacterData extends node_1.MLNode {
+    /**
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-data
+     */
+    get data() {
+        // TODO:
+        return this.raw;
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-length
+     */
+    get length() {
+        throw new unexpected_call_error_1.default('Not supported "length" property');
+    }
+    /**
+     * The element immediately following the specified one in its parent's children list.
+     *
+     * @readonly
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-nondocumenttypechildnode-nextelementsibling%E2%91%A1
+     */
+    get nextElementSibling() {
+        return (0, child_node_methods_1.nextElementSibling)(this);
+    }
+    get nodeValue() {
+        return this.data;
+    }
+    /**
+     * The element immediately prior the specified one in its parent's children list.
+     *
+     * @readonly
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#ref-for-dom-nondocumenttypechildnode-previouselementsibling%E2%91%A1
+     */
+    get previousElementSibling() {
+        return (0, child_node_methods_1.previousElementSibling)(this);
+    }
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    after(...nodes) {
+        (0, child_node_methods_1.after)(this, ...nodes);
+    }
+    // TODO
+    appendData(data) { }
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    before(...nodes) {
+        (0, child_node_methods_1.before)(this, ...nodes);
+    }
+    // TODO
+    deleteData(offset, count) { }
+    // TODO
+    insertData(offset, data) { }
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    remove() {
+        (0, child_node_methods_1.remove)(this);
+    }
+    // TODO
+    replaceData(offset, count, data) { }
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    replaceWith(...nodes) {
+        (0, child_node_methods_1.replaceWith)(this, ...nodes);
+    }
+    // TODO
+    substringData(offset, count) {
+        return '';
+    }
+}
+exports.MLCharacterData = MLCharacterData;

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

@@ -0,0 +1,9 @@
+import type { MLBlock } from './block';
+import type { MLCharacterData } from './character-data';
+import type { MLDocumentType } from './document-type';
+import type { MLElement } from './element';
+import type { MLNode } from './node';
+import type { MLText } from './text';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+export declare type MLChildNode<T extends RuleConfigValue, O = null> = MLDocumentType<T, O> | MLCharacterData<T, O> | MLText<T, O> | MLElement<T, O> | MLBlock<T, O>;
+export declare function isChildNode<T extends RuleConfigValue, O = null>(node: MLNode<T, O>): node is MLChildNode<T, O>;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isChildNode = void 0;
+function isChildNode(node) {
+    return (node.is(node.DOCUMENT_TYPE_NODE) ||
+        node.is(node.TEXT_NODE) ||
+        node.is(node.ELEMENT_NODE) ||
+        node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK));
+}
+exports.isChildNode = isChildNode;

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

@@ -0,0 +1,17 @@
+import type { CommentNodeType } from './types';
+import type { MLASTComment } from '@markuplint/ml-ast';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+import { MLCharacterData } from './character-data';
+export declare class MLComment<T extends RuleConfigValue, O = null> extends MLCharacterData<T, O, MLASTComment> implements Comment {
+    /**
+     * Returns a string appropriate for the type of node as `Attr`
+     *
+     * @see https://dom.spec.whatwg.org/#ref-for-exclusive-text-node%E2%91%A0
+     */
+    get nodeName(): "#comment";
+    /**
+     * Returns a number appropriate for the type of `Comment`
+     */
+    get nodeType(): CommentNodeType;
+    get textContent(): string | null;
+}