@markuplint/ml-core 2.3.3 → 3.0.0-alpha.1

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';
+    constructor(astToken: MLASTAttr, ownElement: MLElement<T, O>);
+    /**
+     * **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 `@markuplint/ml-core` API: `MLAttr`
+     */
+    get tokenList(): MLDomTokenList | null;
+    /**
+     * @implements DOM API: `Attr`
+     * @see https://dom.spec.whatwg.org/#dom-attr-value
+     */
+    get value(): string;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLAttr`
+     */
+    toNormalizeString(): string;
+}

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

@@ -0,0 +1,157 @@
+"use strict";
+var _MLAttr_localName, _MLAttr_namespaceURI, _MLAttr_potentialName, _MLAttr_potentialValue;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLAttr = void 0;
+const tslib_1 = require("tslib");
+const ml_spec_1 = require("@markuplint/ml-spec");
+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);
+        this.endQuote = null;
+        this.equal = null;
+        _MLAttr_localName.set(this, void 0);
+        this.nameNode = null;
+        _MLAttr_namespaceURI.set(this, void 0);
+        _MLAttr_potentialName.set(this, void 0);
+        _MLAttr_potentialValue.set(this, void 0);
+        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");
+        }
+        const ns = (0, ml_spec_1.resolveNamespace)(tslib_1.__classPrivateFieldGet(this, _MLAttr_potentialName, "f"), ownElement.namespaceURI);
+        tslib_1.__classPrivateFieldSet(this, _MLAttr_localName, ns.localName, "f");
+        tslib_1.__classPrivateFieldSet(this, _MLAttr_namespaceURI, ns.namespaceURI, "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() {
+        return tslib_1.__classPrivateFieldGet(this, _MLAttr_localName, "f");
+    }
+    /**
+     *
+     * @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() {
+        return tslib_1.__classPrivateFieldGet(this, _MLAttr_namespaceURI, "f");
+    }
+    /**
+     * 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 `@markuplint/ml-core` API: `MLAttr`
+     */
+    get tokenList() {
+        return this.isDynamicValue ? null : new dom_token_list_1.MLDomTokenList(this.value, [this]);
+    }
+    /**
+     * @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_localName = new WeakMap(), _MLAttr_namespaceURI = new WeakMap(), _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;
+    constructor(astNode: MLASTPreprocessorSpecificBlock, document: MLDocument<T, O>);
+    /**
+     * 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;
+    /**
+     * @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 { MLASTAbstractNode } 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 MLASTAbstractNode = MLASTAbstractNode> 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;
+}