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

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);
+        _MLAttr_localName.set(this, void 0);
+        _MLAttr_namespaceURI.set(this, void 0);
+        _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");
+        }
+        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 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_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;
+    /**
+     * 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;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLComment = void 0;
+const character_data_1 = require("./character-data");
+class MLComment extends character_data_1.MLCharacterData {
+    /**
+     * 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() {
+        return '#comment';
+    }
+    /**
+     * Returns a number appropriate for the type of `Comment`
+     */
+    get nodeType() {
+        return this.COMMENT_NODE;
+    }
+    get textContent() {
+        return this.nodeValue;
+    }
+}
+exports.MLComment = MLComment;

package/lib/ml-dom/node/document-fragment.d.ts

@@ -0,0 +1,24 @@
+import type { DocumentFragmentNodeType } from './types';
+import type { MLASTAbstructNode } from '@markuplint/ml-ast';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+import { MLParentNode } from './parent-node';
+export declare class MLDocumentFragment<T extends RuleConfigValue, O = null> extends MLParentNode<T, O, MLASTAbstructNode> implements DocumentFragment {
+    /**
+     * Returns a string appropriate for the type of node as `DocumentFragment`
+     *
+     * @see https://dom.spec.whatwg.org/#ref-for-documentfragment%E2%91%A0%E2%91%A6
+     */
+    get nodeName(): "#document-fragment";
+    /**
+     * Returns a number appropriate for the type of `DocumentFragment`
+     */
+    get nodeType(): DocumentFragmentNodeType;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @deprecated
+     * @unsupported
+     * @implements DOM API: `DocumentFragment`
+     */
+    getElementById(elementId: string): HTMLElement | null;
+}

package/lib/ml-dom/node/document-fragment.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLDocumentFragment = void 0;
+const tslib_1 = require("tslib");
+const parent_node_1 = require("./parent-node");
+const unexpected_call_error_1 = tslib_1.__importDefault(require("./unexpected-call-error"));
+class MLDocumentFragment extends parent_node_1.MLParentNode {
+    /**
+     * Returns a string appropriate for the type of node as `DocumentFragment`
+     *
+     * @see https://dom.spec.whatwg.org/#ref-for-documentfragment%E2%91%A0%E2%91%A6
+     */
+    get nodeName() {
+        return '#document-fragment';
+    }
+    /**
+     * Returns a number appropriate for the type of `DocumentFragment`
+     */
+    get nodeType() {
+        return this.DOCUMENT_FRAGMENT_NODE;
+    }
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @deprecated
+     * @unsupported
+     * @implements DOM API: `DocumentFragment`
+     */
+    getElementById(elementId) {
+        throw new unexpected_call_error_1.default('Not supported "getElementById" method');
+    }
+}
+exports.MLDocumentFragment = MLDocumentFragment;

package/lib/ml-dom/node/document-type.d.ts

@@ -0,0 +1,38 @@
+import type { MLDocument } from './document';
+import type { MLElement } from './element';
+import type { DocumentTypeNodeType } from './types';
+import type { MLASTDoctype } from '@markuplint/ml-ast';
+import type { RuleConfigValue } from '@markuplint/ml-config';
+import { MLNode } from './node';
+export declare class MLDocumentType<T extends RuleConfigValue, O = null> extends MLNode<T, O, MLASTDoctype> implements DocumentType {
+    readonly name: string;
+    readonly publicId: string;
+    readonly systemId: string;
+    /**
+     * Returns a string appropriate for the type of node as `DocumentType`
+     *
+     * @see https://dom.spec.whatwg.org/#ref-for-documenttype%E2%91%A0%E2%93%AA
+     */
+    get nodeName(): string;
+    /**
+     * Returns a number appropriate for the type of `DocumentType`
+     */
+    get nodeType(): DocumentTypeNodeType;
+    constructor(astNode: MLASTDoctype, document: MLDocument<T, O>);
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    after(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    before(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    remove(): void;
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    replaceWith(...nodes: (string | MLElement<any, any>)[]): void;
+}

package/lib/ml-dom/node/document-type.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLDocumentType = void 0;
+const child_node_methods_1 = require("../manipulations/child-node-methods");
+const node_1 = require("./node");
+class MLDocumentType extends node_1.MLNode {
+    constructor(astNode, document) {
+        super(astNode, document);
+        this.name = astNode.name;
+        this.publicId = astNode.publicId;
+        this.systemId = astNode.systemId;
+    }
+    /**
+     * Returns a string appropriate for the type of node as `DocumentType`
+     *
+     * @see https://dom.spec.whatwg.org/#ref-for-documenttype%E2%91%A0%E2%93%AA
+     */
+    get nodeName() {
+        return this.name;
+    }
+    /**
+     * Returns a number appropriate for the type of `DocumentType`
+     */
+    get nodeType() {
+        return this.DOCUMENT_TYPE_NODE;
+    }
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    after(...nodes) {
+        (0, child_node_methods_1.after)(this, ...nodes);
+    }
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    before(...nodes) {
+        (0, child_node_methods_1.before)(this, ...nodes);
+    }
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    remove() {
+        (0, child_node_methods_1.remove)(this);
+    }
+    /**
+     * @implements DOM API: `CharacterData`
+     */
+    replaceWith(...nodes) {
+        (0, child_node_methods_1.replaceWith)(this, ...nodes);
+    }
+}
+exports.MLDocumentType = MLDocumentType;