@markuplint/selector 3.0.0-alpha.2105 → 3.0.0-alpha.3

package/lib/selector.js

@@ -1,8 +1,9 @@
 "use strict";
-var _Selector_ruleset, _Ruleset_selectorGroup, _StructuredSelector_selector, _StructuredSelector_edge, _SelectorTarget_extended, _SelectorTarget_combinatedFrom, _SelectorTarget_isAdded;
+var _Selector_ruleset, _Ruleset_selectorGroup, _StructuredSelector_edge, _StructuredSelector_selector, _SelectorTarget_combinedFrom, _SelectorTarget_extended, _SelectorTarget_isAdded;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Selector = void 0;
 const tslib_1 = require("tslib");
+const ml_spec_1 = require("@markuplint/ml-spec");
 const postcss_selector_parser_1 = tslib_1.__importStar(require("postcss-selector-parser"));
 const compare_specificity_1 = require("./compare-specificity");
 const debug_1 = require("./debug");
@@ -16,7 +17,7 @@ class Selector {
         tslib_1.__classPrivateFieldSet(this, _Selector_ruleset, Ruleset.parse(selector, extended), "f");
     }
     match(el, scope = (0, is_1.isElement)(el) ? el : null) {
-        const results = tslib_1.__classPrivateFieldGet(this, _Selector_ruleset, "f").match(el, scope);
+        const results = this.search(el, scope);
         for (const result of results) {
             if (result.matched) {
                 return result.specificity;
@@ -24,6 +25,9 @@ class Selector {
         }
         return false;
     }
+    search(el, scope = (0, is_1.isElement)(el) ? el : null) {
+        return tslib_1.__classPrivateFieldGet(this, _Selector_ruleset, "f").match(el, scope);
+    }
 }
 exports.Selector = Selector;
 _Selector_ruleset = new WeakMap();
@@ -41,9 +45,17 @@ class Ruleset {
     }
     static parse(selector, extended) {
         const selectors = [];
-        (0, postcss_selector_parser_1.default)(root => {
-            selectors.push(...root.nodes);
-        }).processSync(selector);
+        try {
+            (0, postcss_selector_parser_1.default)(root => {
+                selectors.push(...root.nodes);
+            }).processSync(selector);
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                throw new Error(`${e.message} At the selector: "${selector}"`);
+            }
+            throw e;
+        }
         return new Ruleset(selectors, extended, 0);
     }
     match(el, scope) {
@@ -59,8 +71,8 @@ class Ruleset {
 _Ruleset_selectorGroup = new WeakMap();
 class StructuredSelector {
     constructor(selector, depth, extended) {
-        _StructuredSelector_selector.set(this, void 0);
         _StructuredSelector_edge.set(this, void 0);
+        _StructuredSelector_selector.set(this, void 0);
         tslib_1.__classPrivateFieldSet(this, _StructuredSelector_selector, selector, "f");
         tslib_1.__classPrivateFieldSet(this, _StructuredSelector_edge, new SelectorTarget(extended, depth), "f");
         this.headCombinator =
@@ -71,9 +83,9 @@ class StructuredSelector {
         tslib_1.__classPrivateFieldGet(this, _StructuredSelector_selector, "f").nodes.forEach(node => {
             switch (node.type) {
                 case 'combinator': {
-                    const combinatedTarget = new SelectorTarget(extended, depth);
-                    combinatedTarget.from(tslib_1.__classPrivateFieldGet(this, _StructuredSelector_edge, "f"), node);
-                    tslib_1.__classPrivateFieldSet(this, _StructuredSelector_edge, combinatedTarget, "f");
+                    const combinedTarget = new SelectorTarget(extended, depth);
+                    combinedTarget.from(tslib_1.__classPrivateFieldGet(this, _StructuredSelector_edge, "f"), node);
+                    tslib_1.__classPrivateFieldSet(this, _StructuredSelector_edge, combinedTarget, "f");
                     break;
                 }
                 case 'root':
@@ -99,15 +111,15 @@ class StructuredSelector {
         return tslib_1.__classPrivateFieldGet(this, _StructuredSelector_edge, "f").match(el, scope, 0);
     }
 }
-_StructuredSelector_selector = new WeakMap(), _StructuredSelector_edge = new WeakMap();
+_StructuredSelector_edge = new WeakMap(), _StructuredSelector_selector = new WeakMap();
 class SelectorTarget {
     constructor(extended, depth) {
-        _SelectorTarget_extended.set(this, void 0);
-        _SelectorTarget_combinatedFrom.set(this, null);
-        _SelectorTarget_isAdded.set(this, false);
         this.attr = [];
         this.class = [];
+        _SelectorTarget_combinedFrom.set(this, null);
+        _SelectorTarget_extended.set(this, void 0);
         this.id = [];
+        _SelectorTarget_isAdded.set(this, false);
         this.pseudo = [];
         this.tag = null;
         tslib_1.__classPrivateFieldSet(this, _SelectorTarget_extended, extended, "f");
@@ -140,14 +152,14 @@ class SelectorTarget {
         }
     }
     from(target, combinator) {
-        tslib_1.__classPrivateFieldSet(this, _SelectorTarget_combinatedFrom, { target, combinator }, "f");
+        tslib_1.__classPrivateFieldSet(this, _SelectorTarget_combinedFrom, { target, combinator }, "f");
     }
     match(el, scope, count) {
         var _a;
         const result = this._match(el, scope, count);
         if (selLog.enabled) {
             const nodeName = el.nodeName;
-            const selector = ((_a = tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinatedFrom, "f")) === null || _a === void 0 ? void 0 : _a.target.toString()) || this.toString();
+            const selector = ((_a = tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f")) === null || _a === void 0 ? void 0 : _a.target.toString()) || this.toString();
             const combinator = result.combinator ? ` ${result.combinator}` : '';
             selLog('The %s element by "%s" => %s (%d)', nodeName, `${selector}${combinator}`, result.matched, count);
             if (selector === ':scope') {
@@ -157,23 +169,35 @@ class SelectorTarget {
         delete result.combinator;
         return result;
     }
+    toString() {
+        var _a, _b;
+        return [
+            (_b = (_a = this.tag) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '',
+            this.id.map(id => `#${id.value}`).join(''),
+            this.class.map(c => `.${c.value}`).join(''),
+            this.attr.map(attr => `[${attr.toString()}]`).join(''),
+            this.pseudo.map(pseudo => pseudo.value).join(''),
+        ].join('');
+    }
     _match(el, scope, count) {
-        const unitCheck = this._matchWithoutCombinateChecking(el, scope);
+        const unitCheck = this._matchWithoutCombineChecking(el, scope);
         if (!unitCheck.matched) {
             return unitCheck;
         }
-        if (!tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinatedFrom, "f")) {
+        if (!tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f")) {
             return unitCheck;
         }
         if (!(0, is_1.isNonDocumentTypeChildNode)(el)) {
             return unitCheck;
         }
-        const { target, combinator } = tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinatedFrom, "f");
+        const { target, combinator } = tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f");
         switch (combinator.value) {
             // Descendant combinator
             case ' ': {
+                const matchedNodes = [];
+                const has = [];
+                const not = [];
                 let ancestor = el.parentElement;
-                let matched = false;
                 let specificity;
                 while (ancestor) {
                     const res = target.match(ancestor, scope, count + 1);
@@ -185,7 +209,13 @@ class SelectorTarget {
                         ];
                     }
                     if (res.matched) {
-                        matched = true;
+                        matchedNodes.push(...res.nodes);
+                        has.push(...res.has);
+                    }
+                    else {
+                        if (res.not) {
+                            not.push(...res.not);
+                        }
                     }
                     ancestor = ancestor.parentElement;
                 }
@@ -197,15 +227,27 @@ class SelectorTarget {
                         unitCheck.specificity[2] + res.specificity[2],
                     ];
                 }
+                if (matchedNodes.length) {
+                    return {
+                        combinator: '␣',
+                        specificity,
+                        matched: true,
+                        nodes: matchedNodes,
+                        has,
+                    };
+                }
                 return {
                     combinator: '␣',
                     specificity,
-                    matched,
+                    matched: false,
+                    not,
                 };
             }
             // Child combinator
             case '>': {
-                let matched;
+                const matchedNodes = [];
+                const has = [];
+                const not = [];
                 const specificity = unitCheck.specificity;
                 const parentNode = el.parentElement;
                 if (parentNode) {
@@ -213,49 +255,87 @@ class SelectorTarget {
                     specificity[0] += res.specificity[0];
                     specificity[1] += res.specificity[1];
                     specificity[2] += res.specificity[2];
-                    matched = res.matched;
+                    if (res.matched) {
+                        matchedNodes.push(...res.nodes);
+                        has.push(...res.has);
+                    }
+                    else {
+                        if (res.not) {
+                            not.push(...res.not);
+                        }
+                    }
                 }
                 else {
                     const res = target.match(el, scope, count + 1);
                     specificity[0] += res.specificity[0];
                     specificity[1] += res.specificity[1];
                     specificity[2] += res.specificity[2];
-                    matched = false;
+                }
+                if (matchedNodes.length) {
+                    return {
+                        combinator: '>',
+                        specificity,
+                        matched: true,
+                        nodes: matchedNodes,
+                        has,
+                    };
                 }
                 return {
                     combinator: '>',
                     specificity,
-                    matched,
+                    matched: false,
+                    not,
                 };
             }
             // Next-sibling combinator
             case '+': {
-                let matched;
+                const matchedNodes = [];
+                const has = [];
+                const not = [];
                 const specificity = unitCheck.specificity;
                 if (el.previousElementSibling) {
                     const res = target.match(el.previousElementSibling, scope, count + 1);
                     specificity[0] += res.specificity[0];
                     specificity[1] += res.specificity[1];
                     specificity[2] += res.specificity[2];
-                    matched = res.matched;
+                    if (res.matched) {
+                        matchedNodes.push(...res.nodes);
+                        has.push(...res.has);
+                    }
+                    else {
+                        if (res.not) {
+                            not.push(...res.not);
+                        }
+                    }
                 }
                 else {
                     const res = target.match(el, scope, count + 1);
                     specificity[0] += res.specificity[0];
                     specificity[1] += res.specificity[1];
                     specificity[2] += res.specificity[2];
-                    matched = false;
+                }
+                if (matchedNodes.length) {
+                    return {
+                        combinator: '+',
+                        specificity,
+                        matched: true,
+                        nodes: matchedNodes,
+                        has,
+                    };
                 }
                 return {
                     combinator: '+',
                     specificity,
-                    matched,
+                    matched: false,
+                    not,
                 };
             }
             // Subsequent-sibling combinator
             case '~': {
+                const matchedNodes = [];
+                const has = [];
+                const not = [];
                 let prev = el.previousElementSibling;
-                let matched = false;
                 let specificity;
                 while (prev) {
                     const res = target.match(prev, scope, count + 1);
@@ -267,7 +347,13 @@ class SelectorTarget {
                         ];
                     }
                     if (res.matched) {
-                        matched = true;
+                        matchedNodes.push(...res.nodes);
+                        has.push(...res.has);
+                    }
+                    else {
+                        if (res.not) {
+                            not.push(...res.not);
+                        }
                     }
                     prev = prev.previousElementSibling;
                 }
@@ -279,10 +365,20 @@ class SelectorTarget {
                         unitCheck.specificity[2] + res.specificity[2],
                     ];
                 }
+                if (matchedNodes.length) {
+                    return {
+                        combinator: '~',
+                        specificity,
+                        matched: true,
+                        nodes: matchedNodes,
+                        has,
+                    };
+                }
                 return {
                     combinator: '~',
                     specificity,
-                    matched,
+                    matched: false,
+                    not,
                 };
             }
             // Column combinator
@@ -290,21 +386,12 @@ class SelectorTarget {
                 throw new Error('Unsupported column combinator yet. If you want it, please request it as the issue (https://github.com/markuplint/markuplint/issues/new).');
             }
             default: {
-                throw new Error(`Unsupported ${tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinatedFrom, "f").combinator.value} combinator in selector`);
+                throw new Error(`Unsupported ${tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinedFrom, "f").combinator.value} combinator in selector`);
             }
         }
     }
-    toString() {
-        var _a, _b;
-        return [
-            (_b = (_a = this.tag) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '',
-            this.id.map(id => `#${id.value}`).join(''),
-            this.class.map(c => `.${c.value}`).join(''),
-            this.attr.map(attr => `[${attr.toString()}]`).join(''),
-            this.pseudo.map(pseudo => pseudo.value).join(''),
-        ].join('');
-    }
-    _matchWithoutCombinateChecking(el, scope) {
+    _matchWithoutCombineChecking(el, scope) {
+        var _a;
         const specificity = [0, 0, 0];
         if (!(0, is_1.isElement)(el)) {
             return {
@@ -312,6 +399,8 @@ class SelectorTarget {
                 matched: false,
             };
         }
+        const has = [];
+        const not = [];
         // @ts-ignore
         if (this.tag && this.tag._namespace) {
             // @ts-ignore
@@ -356,7 +445,11 @@ class SelectorTarget {
             specificity[0] += pseudoRes.specificity[0];
             specificity[1] += pseudoRes.specificity[1];
             specificity[2] += pseudoRes.specificity[2];
-            if (!pseudoRes.matched) {
+            if (pseudoRes.matched) {
+                has.push(...pseudoRes.has);
+            }
+            else {
+                not.push(...((_a = pseudoRes.not) !== null && _a !== void 0 ? _a : []));
                 matched = false;
             }
         }
@@ -372,18 +465,33 @@ class SelectorTarget {
                 matched = false;
             }
         }
+        if (matched) {
+            return {
+                specificity,
+                matched,
+                nodes: [el],
+                has,
+            };
+        }
         return {
             specificity,
             matched,
+            not,
         };
     }
 }
-_SelectorTarget_extended = new WeakMap(), _SelectorTarget_combinatedFrom = new WeakMap(), _SelectorTarget_isAdded = new WeakMap();
+_SelectorTarget_combinedFrom = new WeakMap(), _SelectorTarget_extended = new WeakMap(), _SelectorTarget_isAdded = new WeakMap();
 function attrMatch(attr, el) {
     return Array.from(el.attributes).some(attrOfEl => {
-        if (attr.attribute !== attrOfEl.name) {
+        if (attr.attribute !== attrOfEl.localName) {
             return false;
         }
+        if (attr.namespace != null && attr.namespace !== true && attr.namespace !== '*') {
+            const ns = (0, ml_spec_1.resolveNamespace)(attrOfEl.localName, attrOfEl.namespaceURI);
+            if (attr.namespace !== ns.namespace) {
+                return false;
+            }
+        }
         if (attr.value != null) {
             let value = attr.value;
             let valueOfEl = attrOfEl.value;
@@ -444,10 +552,13 @@ function pseudoMatch(pseudo, el, scope, extended, depth) {
             const specificity = getSpecificity(ruleset.match(el, scope));
             let parent = el.parentElement;
             while (parent) {
-                if (ruleset.match(parent, scope).some(r => r.matched)) {
+                const matched = ruleset.match(parent, scope).filter((r) => r.matched);
+                if (matched.length) {
                     return {
                         specificity,
                         matched: true,
+                        nodes: [el],
+                        has: matched,
                     };
                 }
                 parent = parent.parentElement;
@@ -464,20 +575,31 @@ function pseudoMatch(pseudo, el, scope, extended, depth) {
             const ruleset = new Ruleset(pseudo.nodes, extended, depth + 1);
             const resList = ruleset.match(el, scope);
             const specificity = getSpecificity(resList);
-            const matched = resList.every(r => !r.matched);
+            const not = resList.filter((r) => r.matched);
+            if (not.length === 0) {
+                return {
+                    specificity,
+                    matched: true,
+                    nodes: [el],
+                    has: [],
+                };
+            }
             return {
                 specificity,
-                matched,
+                matched: false,
+                not,
             };
         }
         case ':is': {
             const ruleset = new Ruleset(pseudo.nodes, extended, depth + 1);
             const resList = ruleset.match(el, scope);
             const specificity = getSpecificity(resList);
-            const matched = resList.some(r => r.matched);
+            const matched = resList.filter((r) => r.matched);
             return {
                 specificity,
-                matched,
+                matched: !!matched.length,
+                nodes: matched.map(m => m.nodes).flat(),
+                has: matched.map(m => m.has).flat(),
             };
         }
         case ':has': {
@@ -486,17 +608,37 @@ function pseudoMatch(pseudo, el, scope, extended, depth) {
             switch (ruleset.headCombinator) {
                 case '+':
                 case '~': {
-                    const matched = getSiblings(el).some(sib => ruleset.match(sib, el).some(m => m.matched));
+                    const has = getSiblings(el)
+                        .map(sib => ruleset.match(sib, el).filter((m) => m.matched))
+                        .flat();
+                    if (has.length) {
+                        return {
+                            specificity,
+                            matched: true,
+                            nodes: [el],
+                            has,
+                        };
+                    }
                     return {
                         specificity,
-                        matched,
+                        matched: false,
                     };
                 }
                 default: {
-                    const matched = getDescendants(el).some(desc => ruleset.match(desc, el).some(m => m.matched));
+                    const has = getDescendants(el)
+                        .map(sib => ruleset.match(sib, el).filter((m) => m.matched))
+                        .flat();
+                    if (has.length) {
+                        return {
+                            specificity,
+                            matched: true,
+                            nodes: [el],
+                            has,
+                        };
+                    }
                     return {
                         specificity,
-                        matched,
+                        matched: false,
                     };
                 }
             }
@@ -504,10 +646,12 @@ function pseudoMatch(pseudo, el, scope, extended, depth) {
         case ':where': {
             const ruleset = new Ruleset(pseudo.nodes, extended, depth + 1);
             const resList = ruleset.match(el, scope);
-            const matched = resList.some(r => r.matched);
+            const matched = resList.filter((r) => r.matched);
             return {
                 specificity: [0, 0, 0],
-                matched,
+                matched: !!matched.length,
+                nodes: matched.map(m => m.nodes).flat(),
+                has: matched.map(m => m.has).flat(),
             };
         }
         case ':scope': {
@@ -515,6 +659,8 @@ function pseudoMatch(pseudo, el, scope, extended, depth) {
                 return {
                     specificity: [0, 1, 0],
                     matched: true,
+                    nodes: [el],
+                    has: [],
                 };
             }
             return {
@@ -527,6 +673,8 @@ function pseudoMatch(pseudo, el, scope, extended, depth) {
                 return {
                     specificity: [0, 1, 0],
                     matched: true,
+                    nodes: [el],
+                    has: [],
                 };
             }
             return {
@@ -612,17 +760,17 @@ function getSiblings(el) {
     var _a;
     return Array.from(((_a = el.parentElement) === null || _a === void 0 ? void 0 : _a.children) || []);
 }
-function getSpecificity(result) {
+function getSpecificity(results) {
     let specificity;
-    for (const res of result) {
+    for (const result of results) {
         if (specificity) {
-            const order = (0, compare_specificity_1.compareSpecificity)(specificity, res.specificity);
+            const order = (0, compare_specificity_1.compareSpecificity)(specificity, result.specificity);
             if (order === -1) {
-                specificity = res.specificity;
+                specificity = result.specificity;
             }
         }
         else {
-            specificity = res.specificity;
+            specificity = result.specificity;
         }
     }
     if (!specificity) {

package/lib/types.d.ts

@@ -1,15 +1,23 @@
 export declare type Specificity = [number, number, number];
-export declare type SelectorResult = {
+export declare type SelectorResult = SelectorMatchedResult | SelectorUnmatchedResult;
+export declare type SelectorMatchedResult = {
     specificity: Specificity;
-    matched: boolean;
+    matched: true;
+    nodes: (Element | Text)[];
+    has: SelectorMatchedResult[];
 };
-export declare type RegexSelector = RegexSelectorWithoutCompination & {
+export declare type SelectorUnmatchedResult = {
+    specificity: Specificity;
+    matched: false;
+    not?: SelectorMatchedResult[];
+};
+export declare type RegexSelector = RegexSelectorWithoutCombination & {
     combination?: {
         combinator: RegexSelectorCombinator;
     } & RegexSelector;
 };
 export declare type RegexSelectorCombinator = ' ' | '>' | '+' | '~' | ':has(+)' | ':has(~)';
-export declare type RegexSelectorWithoutCompination = {
+export declare type RegexSelectorWithoutCombination = {
     nodeName?: string;
     attrName?: string;
     attrValue?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/selector",
-	"version": "3.0.0-alpha.2105+6cde1134",
+	"version": "3.0.0-alpha.3",
 	"description": "W3C Selector and Regex selector",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -22,10 +22,10 @@
 		"tslib": "^2.4.0"
 	},
 	"devDependencies": {
-		"@markuplint/ml-spec": "3.0.0-alpha.82+6cde1134",
+		"@markuplint/ml-spec": "3.0.0-alpha.3",
 		"@types/debug": "^4.1.7",
-		"@types/jsdom": "^16.2.14",
-		"jsdom": "^19.0.0"
+		"@types/jsdom": "16",
+		"jsdom": "19"
 	},
-	"gitHead": "6cde113402758a8fdbd6a0fcf98e78efd2cdb778"
+	"gitHead": "884b1a6a7385e86cca7796b0b927a886ee90140e"
 }