@markuplint/ml-core 2.0.0-rc.0 → 2.0.0-rc.6

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

@@ -1,50 +1,86 @@
 "use strict";
-var _Selector_ruleset, _Ruleset_selectorGroup, _StructuredSelector_edge, _StructuredSelector_selector, _SelectorTarget_isAdded, _SelectorTarget_combinatedFrom;
+var _Selector_ruleset, _Ruleset_selectorGroup, _StructuredSelector_edge, _StructuredSelector_selector, _SelectorTarget_tagNameCaseSensitive, _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"));
-function createSelector(selector) {
-    return new Selector(selector);
+const debug_1 = require("../../debug");
+const log = debug_1.log.extend('selector');
+const resLog = log.extend('result');
+function createSelector(selector, tagNameCaseSensitive) {
+    return new Selector(selector, !!tagNameCaseSensitive);
 }
 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) {
+    constructor(selector, tagNameCaseSensitive) {
         _Selector_ruleset.set(this, void 0);
-        (0, tslib_1.__classPrivateFieldSet)(this, _Selector_ruleset, Ruleset.parse(selector), "f");
+        (0, tslib_1.__classPrivateFieldSet)(this, _Selector_ruleset, Ruleset.parse(selector, tagNameCaseSensitive), "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();
 class Ruleset {
-    constructor(selectors) {
+    constructor(selectors, tagNameCaseSensitive) {
         _Ruleset_selectorGroup.set(this, []);
-        (0, tslib_1.__classPrivateFieldGet)(this, _Ruleset_selectorGroup, "f").push(...selectors.map(selector => new StructuredSelector(selector)));
+        (0, tslib_1.__classPrivateFieldGet)(this, _Ruleset_selectorGroup, "f").push(...selectors.map(selector => new StructuredSelector(selector, tagNameCaseSensitive)));
     }
-    static parse(selector) {
+    static parse(selector, tagNameCaseSensitive) {
         const selectors = [];
         (0, postcss_selector_parser_1.default)(root => {
             selectors.push(...root.nodes);
         }).processSync(selector);
-        return new Ruleset(selectors);
+        return new Ruleset(selectors, tagNameCaseSensitive);
     }
     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();
 class StructuredSelector {
-    constructor(selector) {
+    constructor(selector, tagNameCaseSensitive) {
         _StructuredSelector_edge.set(this, void 0);
         _StructuredSelector_selector.set(this, void 0);
         (0, tslib_1.__classPrivateFieldSet)(this, _StructuredSelector_selector, selector, "f");
-        (0, tslib_1.__classPrivateFieldSet)(this, _StructuredSelector_edge, new SelectorTarget(), "f");
+        (0, tslib_1.__classPrivateFieldSet)(this, _StructuredSelector_edge, new SelectorTarget(tagNameCaseSensitive), "f");
         (0, tslib_1.__classPrivateFieldGet)(this, _StructuredSelector_selector, "f").nodes.forEach(node => {
             switch (node.type) {
                 case 'combinator': {
-                    const combinatedTarget = new SelectorTarget();
+                    const combinatedTarget = new SelectorTarget(tagNameCaseSensitive);
                     combinatedTarget.from((0, tslib_1.__classPrivateFieldGet)(this, _StructuredSelector_edge, "f"), node);
                     (0, tslib_1.__classPrivateFieldSet)(this, _StructuredSelector_edge, combinatedTarget, "f");
                     break;
@@ -65,76 +101,146 @@ 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);
     }
 }
 _StructuredSelector_edge = new WeakMap(), _StructuredSelector_selector = new WeakMap();
 class SelectorTarget {
-    constructor() {
+    constructor(tagNameCaseSensitive) {
         this.tag = null;
         this.id = [];
         this.class = [];
         this.attr = [];
         this.pseudo = [];
+        _SelectorTarget_tagNameCaseSensitive.set(this, void 0);
         _SelectorTarget_isAdded.set(this, false);
         _SelectorTarget_combinatedFrom.set(this, null);
+        (0, tslib_1.__classPrivateFieldSet)(this, _SelectorTarget_tagNameCaseSensitive, tagNameCaseSensitive, "f");
     }
     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();
                 }
-                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,
+                };
             }
             // 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 +252,48 @@ 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, (0, tslib_1.__classPrivateFieldGet)(this, _SelectorTarget_tagNameCaseSensitive, "f"));
+            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;
+            let a = this.tag.value;
+            let b = el.nodeName;
+            if (!(0, tslib_1.__classPrivateFieldGet)(this, _SelectorTarget_tagNameCaseSensitive, "f")) {
+                a = a.toLowerCase();
+                b = b.toLowerCase();
+            }
+            if (a !== b) {
+                matched = false;
+            }
+        }
+        return {
+            specificity,
+            matched,
+        };
     }
     add(selector) {
         (0, tslib_1.__classPrivateFieldSet)(this, _SelectorTarget_isAdded, true, "f");
@@ -198,7 +325,7 @@ class SelectorTarget {
         (0, tslib_1.__classPrivateFieldSet)(this, _SelectorTarget_combinatedFrom, { target, combinator }, "f");
     }
 }
-_SelectorTarget_isAdded = new WeakMap(), _SelectorTarget_combinatedFrom = new WeakMap();
+_SelectorTarget_tagNameCaseSensitive = new WeakMap(), _SelectorTarget_isAdded = new WeakMap(), _SelectorTarget_combinatedFrom = new WeakMap();
 function attrMatch(attr, el) {
     return el.attributes.some(attrOfEl => {
         if (attr.attribute !== attrOfEl.getName().potential) {
@@ -253,58 +380,94 @@ function attrMatch(attr, el) {
         return true;
     });
 }
-function pseudoMatch(pseudo, el, caller) {
+function pseudoMatch(pseudo, el, caller, tagNameCaseSensitive) {
     switch (pseudo.value) {
         /**
          * Below, markuplint Specific Selector
          */
         case ':closest': {
-            const ruleset = new Ruleset(pseudo.nodes);
-            let parent = el.parentNode;
+            const ruleset = new Ruleset(pseudo.nodes, tagNameCaseSensitive);
+            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 ruleset = new Ruleset(pseudo.nodes, tagNameCaseSensitive);
+            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 ruleset = new Ruleset(pseudo.nodes, tagNameCaseSensitive);
+            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 ruleset = new Ruleset(pseudo.nodes, tagNameCaseSensitive);
+            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, tagNameCaseSensitive);
+            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 +500,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 +522,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 +529,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');
@@ -14,20 +15,25 @@ class RuleMapper {
         (0, tslib_1.__classPrivateFieldSet)(this, _RuleMapper_nodeList, nodeList, "f");
     }
     set(node, ruleName, rule) {
+        if (node.type === 'ElementCloseTag') {
+            return;
+        }
         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);
-        ruleMapperLog('Set %o to %s', rule, node);
+        if (node.type === 'Element' && node.closeTag) {
+            (0, tslib_1.__classPrivateFieldGet)(this, _RuleMapper_ruleMap, "f").set(node.closeTag.uuid, rules);
+        }
+        ruleMapperLog('Set to %s from %s (%o): %O', node.raw, rule.from, rule.specificity, rule.rule);
     }
     apply() {
         ruleMapperLog('ruleTree:');
@@ -36,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();