@markuplint/ml-core 2.0.0-dev.26 → 2.0.0-rc.5

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();
+                }
+                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 +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,41 +380,94 @@ function attrMatch(attr, el) {
         return true;
     });
 }
-function pseudoMatch(pseudo, el, caller) {
+function pseudoMatch(pseudo, el, caller, tagNameCaseSensitive) {
     switch (pseudo.value) {
-        case ':not': {
-            const ruleset = new Ruleset(pseudo.nodes);
-            if (ruleset.match(el, caller)) {
-                return false;
+        /**
+         * Below, markuplint Specific Selector
+         */
+        case ':closest': {
+            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).some(r => r.matched)) {
+                    return {
+                        specificity,
+                        matched: true,
+                    };
+                }
+                parent = parent.getParentElement();
             }
-            break;
+            return {
+                specificity,
+                matched: false,
+            };
+        }
+        /**
+         * Below, Selector Level 4
+         */
+        case ':not': {
+            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':
@@ -320,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':
@@ -343,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);
@@ -351,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/helper/walkers.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncWalk = void 0;
 function syncWalk(nodeList, walker) {
     for (const node of nodeList) {
-        if (node.type === 'Element' || node.type === 'OmittedElement') {
+        if (node.type === 'Element' || node.type === 'OmittedElement' || node.type === 'PSBlock') {
             syncWalk(node.childNodes, walker);
         }
         walker(node);

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

@@ -0,0 +1,16 @@
+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;
+    specificity: Specificity;
+    rule: AnyRule;
+};
+export declare class RuleMapper<N extends AnonymousNode<any, any> = AnonymousNode<any, any>> {
+    #private;
+    constructor(nodeList: ReadonlyArray<N>);
+    set(node: N, ruleName: string, rule: MappingLayer): void;
+    apply(): void;
+}
+export {};

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

@@ -0,0 +1,57 @@
+"use strict";
+var _RuleMapper_nodeList, _RuleMapper_ruleMap;
+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');
+class RuleMapper {
+    constructor(nodeList) {
+        _RuleMapper_nodeList.set(this, void 0);
+        _RuleMapper_ruleMap.set(this, new Map());
+        (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) {
+            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);
+        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:');
+        (0, tslib_1.__classPrivateFieldGet)(this, _RuleMapper_nodeList, "f").forEach(node => {
+            const rules = (0, tslib_1.__classPrivateFieldGet)(this, _RuleMapper_ruleMap, "f").get(node.uuid);
+            if (!rules) {
+                return;
+            }
+            const slash = node.type === 'ElementCloseTag' ? '/' : '';
+            const nodeName = 'nodeName' in node ? node.nodeName : `#${node.type}`;
+            ruleMapperNodeLog('<%s%s>', slash, nodeName);
+            Object.keys(rules).forEach(ruleName => {
+                const rule = rules[ruleName];
+                node.rules[ruleName] = rule.rule;
+                ruleMapperNodeRuleLog('[from: %s(%s)] %s: %o', rule.from, rule.specificity, ruleName, rule.rule);
+            });
+        });
+    }
+}
+exports.RuleMapper = RuleMapper;
+_RuleMapper_nodeList = new WeakMap(), _RuleMapper_ruleMap = new WeakMap();

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;
 }