@markuplint/ml-core 2.0.0-dev.20211213.0 → 2.0.0-dev.20220105.1

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,124 @@ 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 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;
                 }
-                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;
+                if (el.parentNode) {
+                    const res = target.match(el.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 +249,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 +378,87 @@ function pseudoMatch(pseudo, el, caller) {
          */
         case ':closest': {
             const ruleset = new Ruleset(pseudo.nodes);
+            const specificity = getSpecificity(ruleset.match(el, caller));
             let parent = el.parentNode;
             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;
             }
-            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 +491,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 +513,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 +520,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.js

@@ -145,7 +145,7 @@ 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");

package/markuplint-recommended.json

@@ -28,19 +28,19 @@
 	},
 	"nodeRules": [
 		{
-			"selector": "html",
+			"selector": ":where(html)",
 			"rules": {
 				"required-attr": ["lang"]
 			}
 		},
 		{
-			"selector": "script[src]",
+			"selector": ":where(script[src])",
 			"rules": {
 				"required-attr": ["defer"]
 			}
 		},
 		{
-			"selector": "img",
+			"selector": ":where(img)",
 			"rules": {
 				"required-attr": [
 					"width",
@@ -54,7 +54,7 @@
 			}
 		},
 		{
-			"selector": "iframe",
+			"selector": ":where(iframe)",
 			"rules": {
 				"required-attr": [
 					"title",
@@ -66,7 +66,7 @@
 			}
 		},
 		{
-			"selector": "a[target=_blank], area[target=_blank]",
+			"selector": ":where(a[target=_blank], area[target=_blank])",
 			"rules": {
 				"required-attr": [
 					{
@@ -77,19 +77,19 @@
 			}
 		},
 		{
-			"selector": "abbr",
+			"selector": ":where(abbr)",
 			"rules": {
 				"required-attr": ["title"]
 			}
 		},
 		{
-			"selector": "video[autoplay]",
+			"selector": ":where(video[autoplay])",
 			"rules": {
 				"required-attr": ["muted"]
 			}
 		},
 		{
-			"selector": "th, td",
+			"selector": ":where(th, td)",
 			"rules": {
 				"invalid-attr": {
 					"option": {
@@ -103,7 +103,7 @@
 			}
 		},
 		{
-			"selector": ":not(button)",
+			"selector": ":where(:not(button))",
 			"rules": {
 				"invalid-attr": {
 					"option": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-core",
-	"version": "2.0.0-dev.20211213.0",
+	"version": "2.0.0-dev.20220105.1",
 	"description": "The core module of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -17,17 +17,17 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/i18n": "2.0.0-dev.20211213.0",
-		"@markuplint/ml-ast": "2.0.0-dev.20211115.1",
-		"@markuplint/ml-config": "2.0.0-dev.2021116.1",
-		"@markuplint/ml-spec": "2.0.0-dev.20211213.0",
+		"@markuplint/i18n": "2.0.0-dev.20220105.1",
+		"@markuplint/ml-ast": "2.0.0-dev.20211115.3",
+		"@markuplint/ml-config": "2.0.0-dev.2021116.3",
+		"@markuplint/ml-spec": "2.0.0-dev.20211227.1",
 		"debug": "^4.3.2",
 		"postcss-selector-parser": "^6.0.6",
 		"tslib": "^2.3.1"
 	},
 	"devDependencies": {
-		"@markuplint/html-parser": "2.0.0-dev.20211213.0",
+		"@markuplint/html-parser": "2.0.0-dev.20220105.1",
 		"@types/debug": "^4.1.7"
 	},
-	"gitHead": "8f4682ca3e0937082af8c39b999443afa4a1aef3"
+	"gitHead": "73fab2765c080b0a42e71bdc1eed09bae0ed360e"
 }