@markuplint/ml-core 2.0.0-dev.20211213.2 → 2.0.0-dev.20220107.0

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

@@ -1,20 +1,51 @@
 "use strict";
 var _Selector_ruleset, _Ruleset_selectorGroup, _StructuredSelector_edge, _StructuredSelector_selector, _SelectorTarget_isAdded, _SelectorTarget_combinatedFrom;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSelector = void 0;
+exports.compareSpecificity = exports.createSelector = void 0;
 const tslib_1 = require("tslib");
 const postcss_selector_parser_1 = (0, tslib_1.__importDefault)(require("postcss-selector-parser"));
+const debug_1 = require("../../debug");
+const log = debug_1.log.extend('selector');
+const resLog = log.extend('result');
 function createSelector(selector) {
     return new Selector(selector);
 }
 exports.createSelector = createSelector;
+function compareSpecificity(a, b) {
+    if (a[0] < b[0]) {
+        return -1;
+    }
+    else if (a[0] > b[0]) {
+        return 1;
+    }
+    else if (a[1] < b[1]) {
+        return -1;
+    }
+    else if (a[1] > b[1]) {
+        return 1;
+    }
+    else if (a[2] < b[2]) {
+        return -1;
+    }
+    else if (a[2] > b[2]) {
+        return 1;
+    }
+    return 0;
+}
+exports.compareSpecificity = compareSpecificity;
 class Selector {
     constructor(selector) {
         _Selector_ruleset.set(this, void 0);
         (0, tslib_1.__classPrivateFieldSet)(this, _Selector_ruleset, Ruleset.parse(selector), "f");
     }
     match(el, caller = el) {
-        return (0, tslib_1.__classPrivateFieldGet)(this, _Selector_ruleset, "f").match(el, caller);
+        const results = (0, tslib_1.__classPrivateFieldGet)(this, _Selector_ruleset, "f").match(el, caller);
+        for (const result of results) {
+            if (result.matched) {
+                return result.specificity;
+            }
+        }
+        return false;
     }
 }
 _Selector_ruleset = new WeakMap();
@@ -31,7 +62,12 @@ class Ruleset {
         return new Ruleset(selectors);
     }
     match(el, caller) {
-        return (0, tslib_1.__classPrivateFieldGet)(this, _Ruleset_selectorGroup, "f").some(selector => selector.match(el, caller));
+        log('%s', el.raw);
+        return (0, tslib_1.__classPrivateFieldGet)(this, _Ruleset_selectorGroup, "f").map(selector => {
+            const res = selector.match(el, caller);
+            resLog('%s => %o', selector.selector, res);
+            return res;
+        });
     }
 }
 _Ruleset_selectorGroup = new WeakMap();
@@ -65,6 +101,9 @@ class StructuredSelector {
             }
         });
     }
+    get selector() {
+        return (0, tslib_1.__classPrivateFieldGet)(this, _StructuredSelector_selector, "f").nodes.join('');
+    }
     match(el, caller) {
         return (0, tslib_1.__classPrivateFieldGet)(this, _StructuredSelector_edge, "f").match(el, caller);
     }
@@ -81,60 +120,125 @@ class SelectorTarget {
         _SelectorTarget_combinatedFrom.set(this, null);
     }
     match(el, caller) {
-        const matched = this._matchWithoutCombinateChecking(el, caller);
-        if (!matched) {
-            return false;
+        const unitCheck = this._matchWithoutCombinateChecking(el, caller);
+        if (!unitCheck.matched) {
+            return unitCheck;
         }
         if (!(0, tslib_1.__classPrivateFieldGet)(this, _SelectorTarget_combinatedFrom, "f")) {
-            return true;
+            return unitCheck;
         }
         const { target, combinator } = (0, tslib_1.__classPrivateFieldGet)(this, _SelectorTarget_combinatedFrom, "f");
         switch (combinator.value) {
             // Descendant combinator
             case ' ': {
-                let ancestor = el.parentNode;
+                let ancestor = el.getParentElement();
+                let matched = false;
+                let specificity;
                 while (ancestor) {
-                    const ancestorMatched = target._matchWithoutCombinateChecking(ancestor, caller);
-                    if (ancestorMatched) {
-                        return target.match(ancestor, caller);
+                    const res = target.match(ancestor, caller);
+                    if (!specificity) {
+                        specificity = [
+                            unitCheck.specificity[0] + res.specificity[0],
+                            unitCheck.specificity[1] + res.specificity[1],
+                            unitCheck.specificity[2] + res.specificity[2],
+                        ];
+                    }
+                    if (res.matched) {
+                        matched = true;
                     }
-                    ancestor = ancestor.parentNode;
+                    ancestor = ancestor.getParentElement();
+                }
+                if (!specificity) {
+                    const res = target.match(el, caller);
+                    specificity = [
+                        unitCheck.specificity[0] + res.specificity[0],
+                        unitCheck.specificity[1] + res.specificity[1],
+                        unitCheck.specificity[2] + res.specificity[2],
+                    ];
                 }
-                return false;
+                return {
+                    specificity,
+                    matched,
+                };
             }
             // Child combinator
             case '>': {
-                if (!el.parentNode) {
-                    return false;
+                let matched;
+                const specificity = unitCheck.specificity;
+                const parentNode = el.getParentElement();
+                if (parentNode) {
+                    const res = target.match(parentNode, caller);
+                    specificity[0] += res.specificity[0];
+                    specificity[1] += res.specificity[1];
+                    specificity[2] += res.specificity[2];
+                    matched = res.matched;
                 }
-                const parentMatched = target._matchWithoutCombinateChecking(el.parentNode, caller);
-                if (parentMatched) {
-                    return target.match(el.parentNode, caller);
+                else {
+                    const res = target.match(el, caller);
+                    specificity[0] += res.specificity[0];
+                    specificity[1] += res.specificity[1];
+                    specificity[2] += res.specificity[2];
+                    matched = false;
                 }
-                return false;
+                return {
+                    specificity,
+                    matched,
+                };
             }
             // Next-sibling combinator
             case '+': {
-                if (!el.previousElementSibling) {
-                    return false;
+                let matched;
+                const specificity = unitCheck.specificity;
+                if (el.previousElementSibling) {
+                    const res = target.match(el.previousElementSibling, caller);
+                    specificity[0] += res.specificity[0];
+                    specificity[1] += res.specificity[1];
+                    specificity[2] += res.specificity[2];
+                    matched = res.matched;
                 }
-                const prevMatched = target._matchWithoutCombinateChecking(el.previousElementSibling, caller);
-                if (prevMatched) {
-                    return target.match(el.previousElementSibling, caller);
+                else {
+                    const res = target.match(el, caller);
+                    specificity[0] += res.specificity[0];
+                    specificity[1] += res.specificity[1];
+                    specificity[2] += res.specificity[2];
+                    matched = false;
                 }
-                return false;
+                return {
+                    specificity,
+                    matched,
+                };
             }
-            // Subsequent-sibling combinator
+            // // Subsequent-sibling combinator
             case '~': {
                 let prev = el.previousElementSibling;
+                let matched = false;
+                let specificity;
                 while (prev) {
-                    const prevMatched = target._matchWithoutCombinateChecking(prev, caller);
-                    if (prevMatched) {
-                        return target.match(prev, caller);
+                    const res = target.match(prev, caller);
+                    if (!specificity) {
+                        specificity = [
+                            unitCheck.specificity[0] + res.specificity[0],
+                            unitCheck.specificity[1] + res.specificity[1],
+                            unitCheck.specificity[2] + res.specificity[2],
+                        ];
+                    }
+                    if (res.matched) {
+                        matched = true;
                     }
                     prev = prev.previousElementSibling;
                 }
-                return false;
+                if (!specificity) {
+                    const res = target.match(el, caller);
+                    specificity = [
+                        unitCheck.specificity[0] + res.specificity[0],
+                        unitCheck.specificity[1] + res.specificity[1],
+                        unitCheck.specificity[2] + res.specificity[2],
+                    ];
+                }
+                return {
+                    specificity,
+                    matched,
+                };
             }
             // Column combinator
             case '||': {
@@ -146,27 +250,42 @@ class SelectorTarget {
         }
     }
     _matchWithoutCombinateChecking(el, caller) {
-        if (!(0, tslib_1.__classPrivateFieldGet)(this, _SelectorTarget_isAdded, "f")) {
-            return isScope(el, caller);
-        }
-        if (this.tag && this.tag.type === 'tag') {
-            if (this.tag.value.toLowerCase() !== el.nodeName.toLowerCase()) {
-                return false;
-            }
+        const specificity = [0, 0, 0];
+        let matched = true;
+        if (!(0, tslib_1.__classPrivateFieldGet)(this, _SelectorTarget_isAdded, "f") && !isScope(el, caller)) {
+            matched = false;
         }
         if (!this.id.every(id => id.value === el.id)) {
-            return false;
+            matched = false;
         }
+        specificity[0] += this.id.length;
         if (!this.class.every(className => el.classList.includes(className.value))) {
-            return false;
+            matched = false;
         }
+        specificity[1] += this.class.length;
         if (!this.attr.every(attr => attrMatch(attr, el))) {
-            return false;
+            matched = false;
         }
-        if (!this.pseudo.every(pseudo => pseudoMatch(pseudo, el, caller))) {
-            return false;
+        specificity[1] += this.attr.length;
+        for (const pseudo of this.pseudo) {
+            const pseudoRes = pseudoMatch(pseudo, el, caller);
+            specificity[0] += pseudoRes.specificity[0];
+            specificity[1] += pseudoRes.specificity[1];
+            specificity[2] += pseudoRes.specificity[2];
+            if (!pseudoRes.matched) {
+                matched = false;
+            }
         }
-        return true;
+        if (this.tag && this.tag.type === 'tag') {
+            specificity[2] += 1;
+            if (this.tag.value.toLowerCase() !== el.nodeName.toLowerCase()) {
+                matched = false;
+            }
+        }
+        return {
+            specificity,
+            matched,
+        };
     }
     add(selector) {
         (0, tslib_1.__classPrivateFieldSet)(this, _SelectorTarget_isAdded, true, "f");
@@ -260,51 +379,87 @@ function pseudoMatch(pseudo, el, caller) {
          */
         case ':closest': {
             const ruleset = new Ruleset(pseudo.nodes);
-            let parent = el.parentNode;
+            const specificity = getSpecificity(ruleset.match(el, caller));
+            let parent = el.getParentElement();
             while (parent) {
-                if (ruleset.match(parent, caller)) {
-                    return true;
+                if (ruleset.match(parent, caller).some(r => r.matched)) {
+                    return {
+                        specificity,
+                        matched: true,
+                    };
                 }
-                parent = parent.parentNode;
+                parent = parent.getParentElement();
             }
-            return false;
+            return {
+                specificity,
+                matched: false,
+            };
         }
         /**
          * Below, Selector Level 4
          */
         case ':not': {
             const ruleset = new Ruleset(pseudo.nodes);
-            if (ruleset.match(el, caller)) {
-                return false;
-            }
-            break;
+            const resList = ruleset.match(el, caller);
+            const specificity = getSpecificity(resList);
+            const matched = resList.every(r => !r.matched);
+            return {
+                specificity,
+                matched,
+            };
         }
         case ':is': {
             const ruleset = new Ruleset(pseudo.nodes);
-            if (!ruleset.match(el, caller)) {
-                return false;
-            }
-            break;
+            const resList = ruleset.match(el, caller);
+            const specificity = getSpecificity(resList);
+            const matched = resList.some(r => r.matched);
+            return {
+                specificity,
+                matched,
+            };
         }
         case ':has': {
             const ruleset = new Ruleset(pseudo.nodes);
+            const specificity = getSpecificity(ruleset.match(el, caller));
             const descendants = getDescendants(el);
-            if (!descendants.some(desc => ruleset.match(desc, caller))) {
-                return false;
-            }
-            break;
+            const matched = descendants.some(desc => ruleset.match(desc, caller).some(m => m.matched));
+            return {
+                specificity,
+                matched,
+            };
+        }
+        case ':where': {
+            const ruleset = new Ruleset(pseudo.nodes);
+            const resList = ruleset.match(el, caller);
+            const matched = resList.some(r => r.matched);
+            return {
+                specificity: [0, 0, 0],
+                matched,
+            };
         }
         case ':scope': {
             if (!isScope(el, caller)) {
-                return false;
+                return {
+                    specificity: [0, 1, 0],
+                    matched: false,
+                };
             }
-            break;
+            return {
+                specificity: [0, 1, 0],
+                matched: true,
+            };
         }
         case ':root': {
             if (!(!el.isInFragmentDocument && el.parentNode === null)) {
-                return false;
+                return {
+                    specificity: [0, 1, 0],
+                    matched: false,
+                };
             }
-            break;
+            return {
+                specificity: [0, 1, 0],
+                matched: true,
+            };
         }
         case ':enable':
         case ':disable':
@@ -337,7 +492,6 @@ function pseudoMatch(pseudo, el, caller) {
         case ':nth-col': {
             throw new Error(`Unsupported pseudo ${pseudo.toString()} selector yet. If you want it, please request it as the issue (https://github.com/markuplint/markuplint/issues/new).`);
         }
-        case ':where':
         case ':dir':
         case ':lang':
         case ':any-link':
@@ -360,7 +514,6 @@ function pseudoMatch(pseudo, el, caller) {
             throw new Error(`Unsupported pseudo ${pseudo.toString()} selector.`);
         }
     }
-    return true;
 }
 function isScope(el, caller) {
     return el.uuid === (caller === null || caller === void 0 ? void 0 : caller.uuid) || (!el.isInFragmentDocument && el.parentNode === null);
@@ -368,3 +521,21 @@ function isScope(el, caller) {
 function getDescendants(el, includeSelf = false) {
     return [...el.children.map(child => getDescendants(child, true)).flat(), ...(includeSelf ? [el] : [])];
 }
+function getSpecificity(result) {
+    let specificity;
+    for (const res of result) {
+        if (specificity) {
+            const order = compareSpecificity(specificity, res.specificity);
+            if (order === -1) {
+                specificity = res.specificity;
+            }
+        }
+        else {
+            specificity = res.specificity;
+        }
+    }
+    if (!specificity) {
+        throw new Error('Result is empty');
+    }
+    return specificity;
+}

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

@@ -1,9 +1,10 @@
+import type { Specificity } from './helper/selector';
 import type { AnonymousNode } from './types';
 import type { AnyRule } from '@markuplint/ml-config';
 declare type RuleType = 'rules' | 'nodeRules' | 'childNodeRules';
 declare type MappingLayer = {
     from: RuleType;
-    index: number;
+    specificity: Specificity;
     rule: AnyRule;
 };
 export declare class RuleMapper<N extends AnonymousNode<any, any> = AnonymousNode<any, any>> {

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuleMapper = void 0;
 const tslib_1 = require("tslib");
 const debug_1 = require("../debug");
+const selector_1 = require("./helper/selector");
 const ruleMapperLog = debug_1.log.extend('rule-mapper');
 const ruleMapperNodeLog = ruleMapperLog.extend('node');
 const ruleMapperNodeRuleLog = ruleMapperNodeLog.extend('rule');
@@ -20,13 +21,12 @@ class RuleMapper {
         const rules = (0, tslib_1.__classPrivateFieldGet)(this, _RuleMapper_ruleMap, "f").get(node.uuid) || {};
         const currentRule = rules[ruleName];
         if (currentRule) {
-            if (currentRule.index <= rule.index) {
-                ruleMapperLog('Unset %o from %s', currentRule, node);
-            }
-            else {
-                ruleMapperLog("Don't set %o (%d vs %d)", rule, currentRule.index, rule.index);
+            const order = (0, selector_1.compareSpecificity)(currentRule.specificity, rule.specificity);
+            if (order === 1) {
+                ruleMapperLog("Don't set %o ([%s] vs [%s])", rule, currentRule.specificity, rule.specificity);
                 return;
             }
+            ruleMapperLog('Unset %o from %s', currentRule, node);
         }
         rules[ruleName] = rule;
         (0, tslib_1.__classPrivateFieldGet)(this, _RuleMapper_ruleMap, "f").set(node.uuid, rules);
@@ -42,13 +42,13 @@ class RuleMapper {
             if (!rules) {
                 return;
             }
-            const shash = node.type === 'ElementCloseTag' ? '/' : '';
+            const slash = node.type === 'ElementCloseTag' ? '/' : '';
             const nodeName = 'nodeName' in node ? node.nodeName : `#${node.type}`;
-            ruleMapperNodeLog('<%s%s>', shash, nodeName);
+            ruleMapperNodeLog('<%s%s>', slash, nodeName);
             Object.keys(rules).forEach(ruleName => {
                 const rule = rules[ruleName];
                 node.rules[ruleName] = rule.rule;
-                ruleMapperNodeRuleLog('[from: %s(%d)] %s: %o', rule.from, rule.index, ruleName, rule.rule);
+                ruleMapperNodeRuleLog('[from: %s(%s)] %s: %o', rule.from, rule.specificity, ruleName, rule.rule);
             });
         });
     }

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

@@ -40,4 +40,5 @@ export default abstract class MLDOMAbstractElement<T extends RuleConfigValue, O
      */
     hasMutableChildren(): boolean;
     isDescendantByUUIDList(uuidList: string[]): boolean;
+    toNormalizeString(): string;
 }

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

@@ -1,5 +1,5 @@
 "use strict";
-var _MLDOMAbstractElement_fixedNodeName;
+var _MLDOMAbstractElement_fixedNodeName, _MLDOMAbstractElement_getChildElementsAndTextNodeWithoutWhitespacesCache, _MLDOMAbstractElement_normalizedString;
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const ml_spec_1 = require("@markuplint/ml-spec");
@@ -15,6 +15,8 @@ class MLDOMAbstractElement extends node_1.default {
         this.childModels = new Set();
         this.descendantModels = new Set();
         _MLDOMAbstractElement_fixedNodeName.set(this, void 0);
+        _MLDOMAbstractElement_getChildElementsAndTextNodeWithoutWhitespacesCache.set(this, null);
+        _MLDOMAbstractElement_normalizedString.set(this, null);
         this.nodeName = astNode.nodeName;
         (0, tslib_1.__classPrivateFieldSet)(this, _MLDOMAbstractElement_fixedNodeName, astNode.nodeName, "f");
         this.namespaceURI = astNode.namespace;
@@ -113,7 +115,7 @@ class MLDOMAbstractElement extends node_1.default {
             if (selecor.match(el, this)) {
                 return el;
             }
-            el = el.parentNode;
+            el = el.getParentElement();
         } while (el !== null && el.type === 'Element');
         return null;
     }
@@ -145,12 +147,15 @@ class MLDOMAbstractElement extends node_1.default {
         return !!this.getAttributeToken(attrName).length;
     }
     matches(selector) {
-        return (0, helper_1.createSelector)(selector).match(this);
+        return !!(0, helper_1.createSelector)(selector).match(this);
     }
     fixNodeName(name) {
         (0, tslib_1.__classPrivateFieldSet)(this, _MLDOMAbstractElement_fixedNodeName, name, "f");
     }
     getChildElementsAndTextNodeWithoutWhitespaces() {
+        if ((0, tslib_1.__classPrivateFieldGet)(this, _MLDOMAbstractElement_getChildElementsAndTextNodeWithoutWhitespacesCache, "f")) {
+            return (0, tslib_1.__classPrivateFieldGet)(this, _MLDOMAbstractElement_getChildElementsAndTextNodeWithoutWhitespacesCache, "f");
+        }
         const filteredNodes = [];
         this.childNodes.forEach(node => {
             if (node.type === 'Element') {
@@ -164,6 +169,7 @@ class MLDOMAbstractElement extends node_1.default {
                 filteredNodes.push(...children);
             }
         });
+        (0, tslib_1.__classPrivateFieldSet)(this, _MLDOMAbstractElement_getChildElementsAndTextNodeWithoutWhitespacesCache, filteredNodes, "f");
         return filteredNodes;
     }
     /**
@@ -173,7 +179,7 @@ class MLDOMAbstractElement extends node_1.default {
         return this.childNodes.some(node => node.type === 'PSBlock');
     }
     isDescendantByUUIDList(uuidList) {
-        let el = this.parentNode;
+        let el = this.getParentElement();
         if (el === null) {
             return false;
         }
@@ -181,10 +187,29 @@ class MLDOMAbstractElement extends node_1.default {
             if (uuidList.includes(el.uuid)) {
                 return true;
             }
-            el = el.parentNode;
+            el = el.getParentElement();
         } while (el !== null && el.type === 'Element');
         return false;
     }
+    toNormalizeString() {
+        if ((0, tslib_1.__classPrivateFieldGet)(this, _MLDOMAbstractElement_normalizedString, "f")) {
+            return (0, tslib_1.__classPrivateFieldGet)(this, _MLDOMAbstractElement_normalizedString, "f");
+        }
+        const children = this.getChildElementsAndTextNodeWithoutWhitespaces();
+        const attrs = this.attributes.map(attr => attr.toNormalizeString());
+        const attrString = attrs.length ? ' ' + attrs.join('') : '';
+        const startTag = `<${this.nodeName}${attrString}>`;
+        const childNodes = children.map(node => {
+            if (node.type === 'Element') {
+                return node.toNormalizeString();
+            }
+            return node.originRaw;
+        });
+        const endTag = `</${this.nodeName}>`;
+        const normalizedString = `${startTag}${childNodes.join('')}${endTag}`;
+        (0, tslib_1.__classPrivateFieldSet)(this, _MLDOMAbstractElement_normalizedString, normalizedString, "f");
+        return normalizedString;
+    }
 }
 exports.default = MLDOMAbstractElement;
-_MLDOMAbstractElement_fixedNodeName = new WeakMap();
+_MLDOMAbstractElement_fixedNodeName = new WeakMap(), _MLDOMAbstractElement_getChildElementsAndTextNodeWithoutWhitespacesCache = new WeakMap(), _MLDOMAbstractElement_normalizedString = new WeakMap();

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

@@ -36,4 +36,5 @@ export default class MLDOMAttribute extends MLDOMToken<MLASTHTMLAttr> {
         raw: string;
     };
     toString(withSpace?: boolean): string;
+    toNormalizeString(): string;
 }

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

@@ -69,5 +69,12 @@ class MLDOMAttribute extends token_1.default {
     toString(withSpace = true) {
         return (withSpace ? this.spacesBeforeName.raw : '') + this.raw;
     }
+    toNormalizeString() {
+        return (this.name.originRaw +
+            this.equal.originRaw +
+            this.startQuote.originRaw +
+            this.value.originRaw +
+            this.endQuote.originRaw);
+    }
 }
 exports.default = MLDOMAttribute;

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

@@ -1,7 +1,7 @@
 import type { Document } from '../';
 import type { RuleInfo } from '../../';
 import type { AnonymousNode, IMLDOMNode, NodeType } from '../types';
-import type { MLDOMElement, MLDOMOmittedElement } from './';
+import type { MLDOMElement, MLDOMOmittedElement, MLDOMPreprocessorSpecificBlock } from './';
 import type { MLASTAbstructNode } from '@markuplint/ml-ast';
 import type { AnyRule, RuleConfigValue } from '@markuplint/ml-config';
 import MLDOMToken from './token';
@@ -11,13 +11,14 @@ export default abstract class MLDOMNode<T extends RuleConfigValue, O = null, A e
     readonly rules: Record<string, AnyRule>;
     protected _astToken: A;
     constructor(astNode: A, document: Document<T, O>);
-    get parentNode(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | null;
+    get parentNode(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | MLDOMPreprocessorSpecificBlock<T, O> | null;
     get prevNode(): AnonymousNode<T, O> | null;
     get nextNode(): AnonymousNode<T, O> | null;
-    get syntaxicalParentNode(): MLDOMElement<T, O> | null;
+    get syntaxicalParentNode(): MLDOMElement<T, O> | MLDOMPreprocessorSpecificBlock<T, O> | null;
     get prevToken(): AnonymousNode<T, O> | null;
     get nodeStore(): import("../helper").NodeStore;
-    toString(): string;
-    is(type: NodeType): boolean;
     get rule(): RuleInfo<T, O>;
+    getParentElement(): MLDOMElement<T, O> | MLDOMOmittedElement<T, O> | null;
+    is(type: NodeType): boolean;
+    toString(): string;
 }

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

@@ -70,12 +70,6 @@ class MLDOMNode extends token_1.default {
     get nodeStore() {
         return (0, tslib_1.__classPrivateFieldGet)(this, _MLDOMNode_doc, "f").nodeStore;
     }
-    toString() {
-        return this.raw;
-    }
-    is(type) {
-        return this.type === type;
-    }
     get rule() {
         if (!(0, tslib_1.__classPrivateFieldGet)(this, _MLDOMNode_doc, "f").currentRule) {
             throw new Error('Invalid call.');
@@ -87,6 +81,26 @@ class MLDOMNode extends token_1.default {
         }
         return (0, tslib_1.__classPrivateFieldGet)(this, _MLDOMNode_doc, "f").currentRule.optimizeOption(rule);
     }
+    getParentElement() {
+        let parent = this.parentNode;
+        if (!parent) {
+            return null;
+        }
+        while (parent) {
+            if (parent.type === 'PSBlock') {
+                parent = parent.parentNode;
+                continue;
+            }
+            return parent;
+        }
+        return null;
+    }
+    is(type) {
+        return this.type === type;
+    }
+    toString() {
+        return this.raw;
+    }
 }
 exports.default = MLDOMNode;
 _MLDOMNode_doc = new WeakMap(), _MLDOMNode_prevToken = new WeakMap();