@markuplint/selector 3.0.0-alpha.2105

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2019 Yusuke Hirao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,102 @@
+# @markuplint/selector
+
+[![npm version](https://badge.fury.io/js/%40markuplint%2Fselector.svg)](https://www.npmjs.com/package/@markuplint/selector)
+[![Build Status](https://travis-ci.org/markuplint/markuplint.svg?branch=main)](https://travis-ci.org/markuplint/markuplint)
+[![Coverage Status](https://coveralls.io/repos/github/markuplint/markuplint/badge.svg?branch=main)](https://coveralls.io/github/markuplint/markuplint?branch=main)
+
+## Install
+
+```sh
+$ npm install @markuplint/selector
+
+$ yarn add @markuplint/selector
+```
+
+## [W3C Selectors](https://www.w3.org/TR/selectors-4/) matcher
+
+Supported selectors and operators:
+
+| Selector Type                                    | Code Example                                                                              | Support |
+| ------------------------------------------------ | ----------------------------------------------------------------------------------------- | ------- |
+| Universal selector                               | `*`                                                                                       | ✅      |
+| Type selector                                    | `div`                                                                                     | ✅      |
+| ID selector                                      | `#id`                                                                                     | ✅      |
+| Class selector                                   | `.class`                                                                                  | ✅      |
+| Attribute selector                               | `[data-attr]`                                                                             | ✅      |
+| Attribute selector, Exact match                  | `[data-attr=value]` `[data-attr=value i]`                                                 | ✅      |
+| Attribute selector, Include whitespace separated | `[data-attr~=value]` `[data-attr~=value i]`                                               | ✅      |
+| Attribute selector, Subcode match                | <code>[data-attr\|=value]</code> <code>[data-attr\|=value i]</code>                       | ✅      |
+| Attribute selector, Partial match                | `[data-attr*=value]` `[data-attr*=value i]`                                               | ✅      |
+| Attribute selector, Forward match                | `[data-attr^=value]` `[data-attr^=value i]`                                               | ✅      |
+| Attribute selector, Backward match               | `[data-attr$=value]` `[data-attr$=value i]`                                               | ✅      |
+| Negation pseudo-class                            | `:not(div)`                                                                               | ✅      |
+| Matches-Any pseudo-class                         | `:is(div)`                                                                                | ✅      |
+| Specificity-adjustment pseudo-class              | `:where(div)`                                                                             | ✅      |
+| Relational pseudo-class                          | `:has(div)` `:has(> div)` `:has(+ div)` `:has(~ div)`                                     | ✅      |
+| Directionality pseudo-class                      | `:dir(ltr)`                                                                               | ❌      |
+| Language pseudo-class                            | `:lang(en)`                                                                               | ❌      |
+| Hyperlink pseudo-class                           | `:any-link`                                                                               | ❌      |
+| Link History pseudo-class                        | `:link` `:visited`                                                                        | ❌      |
+| Local link pseudo-class                          | `:local-link`                                                                             | ❌      |
+| Target pseudo-class                              | `:target`                                                                                 | ❌      |
+| Target container pseudo-class                    | `:target-within`                                                                          | ❌      |
+| Reference element pseudo-class                   | `:scope`                                                                                  | ✅      |
+| Current-element pseudo-class                     | `:current` `:current(div)`                                                                | ❌      |
+| Past pseudo-class                                | `:past`                                                                                   | ❌      |
+| Future pseudo-class                              | `:future`                                                                                 | ❌      |
+| Interactive pseudo-class                         | `:active` `:hover` `:focus` `:focus-within` `:focus-visible`                              | ❌      |
+| Enable and disable pseudo-class                  | `:enable` `:disable`                                                                      | ❌      |
+| Mutability pseudo-class                          | `:read-write` `:read-only`                                                                | ❌      |
+| Placeholder-shown pseudo-class                   | `:placeholder-shown`                                                                      | ❌      |
+| Default-option pseudo-class                      | `:default`                                                                                | ❌      |
+| Selected-option pseudo-class                     | `:checked`                                                                                | ❌      |
+| Indeterminate value pseudo-class                 | `:indeterminate`                                                                          | ❌      |
+| Validity pseudo-class                            | `:valid` `:invalid`                                                                       | ❌      |
+| Range pseudo-class                               | `:in-range` `:out-of-range`                                                               | ❌      |
+| Optionality pseudo-class                         | `:required` `:optional`                                                                   | ❌      |
+| Empty-Value pseudo-class                         | `:blank`                                                                                  | ❌      |
+| User-interaction pseudo-class                    | `:user-invalid`                                                                           | ❌      |
+| Root pseudo-class                                | `:root`                                                                                   | ✅      |
+| Empty pseudo-class                               | `:empty`                                                                                  | ❌      |
+| Nth-child pseudo-class                           | `:nth-child(2)` `:nth-last-child(2)` `:first-child` `:last-child` `:only-child`           | ❌      |
+| Nth-child pseudo-class (`of El` Syntax)          | `:nth-child(2 of div)` `:nth-last-child(2 of div)`                                        | ❌      |
+| Nth-of-type pseudo-class                         | `:nth-of-type(2)` `:nth-last-of-type(2)` `:first-of-type` `:last-of-type` `:only-of-type` | ❌      |
+| Nth-col pseudo-class                             | `:nth-col(2)` `:nth-last-col(2)`                                                          | ❌      |
+| Pseudo elements                                  | `::before` `::after`                                                                      | ❌      |
+| Descendant combinator                            | `div span`                                                                                | ✅      |
+| Child combinator                                 | `div > span` (`:has(> span)`)                                                             | ✅      |
+| Next-sibling combinator                          | `div + span` (`:has(+ span)`)                                                             | ✅      |
+| Subsequent-sibling combinator                    | `div ~ span` (`:has(~ span)`)                                                             | ✅      |
+| Column combinator                                | <code>div \|\| span</code>                                                                | ❌      |
+| Multiple selectors                               | `div, span`                                                                               | ✅      |
+
+## Extended Selector
+
+The below is selectors that are extended by markuplint:
+
+| Selector Type     | Code Example      |
+| ----------------- | ----------------- |
+| ARIA pseudo-class | `:aria(has name)` |
+
+### ARIA pseudo-class
+
+```
+:aria(syntax)
+:aria(syntax/version)
+```
+
+| Syntax         | Example                                                 | Description                     |
+| -------------- | ------------------------------------------------------- | ------------------------------- |
+| `has name`     | `:aria(has name)`<br>`:aria(has name/1.1)`              | It has accessible name          |
+| `has no name`  | `:aria(has no name)`<br>`:aria(has no name/1.1)`        | It does'nt have accessible name |
+| `role is Role` | `:aria(role is banner)`<br>`:aria(role is generic/1.2)` | It matches the specfied role    |
+
+## Regex Selector
+
+```json
+{
+  "nodeName": "/^[a-z]+$/",
+  "attrName": "/^[a-z]+$/",
+  "attrValue": "/^[a-z]+$/"
+}
+```

package/lib/compare-specificity.d.ts

@@ -0,0 +1,2 @@
+import type { Specificity } from './types';
+export declare function compareSpecificity(a: Specificity, b: Specificity): 0 | 1 | -1;

package/lib/compare-specificity.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSpecificity = void 0;
+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;

package/lib/create-selector.d.ts

@@ -0,0 +1,3 @@
+import type { MLMLSpec } from '@markuplint/ml-spec';
+import { Selector } from './selector';
+export declare function createSelector(selector: string, specs: MLMLSpec): Selector;

package/lib/create-selector.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSelector = void 0;
+const aria_pseudo_class_1 = require("./extended-selector/aria-pseudo-class");
+const selector_1 = require("./selector");
+const caches = new Map();
+function createSelector(selector, specs) {
+    let instance = caches.get(selector);
+    if (instance) {
+        return instance;
+    }
+    instance = new selector_1.Selector(selector, {
+        aria: (0, aria_pseudo_class_1.ariaPseudoClass)(specs),
+    });
+    caches.set(selector, instance);
+    return instance;
+}
+exports.createSelector = createSelector;

package/lib/debug.d.ts

@@ -0,0 +1,3 @@
+import debug from 'debug';
+export declare const log: debug.Debugger;
+export declare function enableDebug(): void;

package/lib/debug.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableDebug = exports.log = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const CLI_NS = 'markuplint-cli';
+exports.log = (0, debug_1.default)('selector');
+function enableDebug() {
+    if (!exports.log.enabled) {
+        debug_1.default.enable(`${exports.log.namespace}*`);
+        (0, exports.log)(`Debug enable: ${exports.log.namespace}`);
+        if (!debug_1.default.enabled(CLI_NS)) {
+            debug_1.default.enable(`${exports.log.namespace}*,${CLI_NS}*`);
+            (0, exports.log)(`Debug enable: ${exports.log.namespace}, ${CLI_NS}`);
+        }
+    }
+}
+exports.enableDebug = enableDebug;

package/lib/extended-selector/aria-pseudo-class.d.ts

@@ -0,0 +1,3 @@
+import type { SelectorResult } from '../types';
+import type { MLMLSpec } from '@markuplint/ml-spec';
+export declare function ariaPseudoClass(specs: MLMLSpec): (content: string) => (el: Element) => SelectorResult;

package/lib/extended-selector/aria-pseudo-class.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ariaPseudoClass = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+const roleIsRegxp = /^roleis/gi;
+function ariaPseudoClass(specs) {
+    return (content) => (el) => {
+        var _a, _b;
+        const aria = ariaPseudoClassParser(content);
+        switch (aria.type) {
+            case 'hasName': {
+                const name = (0, ml_spec_1.getAccname)(el);
+                return {
+                    specificity: [0, 1, 0],
+                    matched: !!name,
+                };
+            }
+            case 'hasNoName': {
+                const name = (0, ml_spec_1.getAccname)(el);
+                return {
+                    specificity: [0, 1, 0],
+                    matched: !name,
+                };
+            }
+            case 'roleIs': {
+                const computed = (0, ml_spec_1.getComputedRole)(specs, el, (_a = aria.version) !== null && _a !== void 0 ? _a : '1.2');
+                return {
+                    specificity: [0, 1, 0],
+                    matched: ((_b = computed.role) === null || _b === void 0 ? void 0 : _b.name) === aria.role,
+                };
+            }
+        }
+    };
+}
+exports.ariaPseudoClass = ariaPseudoClass;
+function ariaPseudoClassParser(syntax) {
+    const [_query, _version] = syntax.split('|');
+    const query = _query.replace(/\s+/g, '').toLowerCase();
+    const version = _version === '1.1' ? '1.1' : '1.2';
+    switch (query) {
+        case 'hasname': {
+            return {
+                type: 'hasName',
+                version,
+            };
+        }
+        case 'hasnoname': {
+            return {
+                type: 'hasNoName',
+                version,
+            };
+        }
+    }
+    if (roleIsRegxp.test(query)) {
+        const role = query.replace(roleIsRegxp, '');
+        if (!role) {
+            throw new SyntaxError(`Unsupported syntax: ${syntax}`);
+        }
+        return {
+            type: 'roleIs',
+            role,
+            version,
+        };
+    }
+    throw new SyntaxError(`Unsupported syntax: ${syntax}`);
+}

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export { compareSpecificity } from './compare-specificity';
+export { matchSelector } from './match-selector';
+export { createSelector } from './create-selector';
+export * from './types';

package/lib/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSelector = exports.matchSelector = exports.compareSpecificity = void 0;
+const tslib_1 = require("tslib");
+var compare_specificity_1 = require("./compare-specificity");
+Object.defineProperty(exports, "compareSpecificity", { enumerable: true, get: function () { return compare_specificity_1.compareSpecificity; } });
+var match_selector_1 = require("./match-selector");
+Object.defineProperty(exports, "matchSelector", { enumerable: true, get: function () { return match_selector_1.matchSelector; } });
+var create_selector_1 = require("./create-selector");
+Object.defineProperty(exports, "createSelector", { enumerable: true, get: function () { return create_selector_1.createSelector; } });
+tslib_1.__exportStar(require("./types"), exports);

package/lib/invalid-selector-error.d.ts

@@ -0,0 +1,3 @@
+export declare class InvalidSelectorError extends Error {
+    name: string;
+}

package/lib/invalid-selector-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidSelectorError = void 0;
+class InvalidSelectorError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'InvalidSelectorError';
+    }
+}
+exports.InvalidSelectorError = InvalidSelectorError;

package/lib/is-pure-html-element.d.ts

@@ -0,0 +1 @@
+export declare function isPureHTMLElement(el: Element): boolean;

package/lib/is-pure-html-element.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPureHTMLElement = void 0;
+function isPureHTMLElement(el) {
+    return el.localName !== el.nodeName;
+}
+exports.isPureHTMLElement = isPureHTMLElement;

package/lib/is.d.ts

@@ -0,0 +1,3 @@
+export declare function isElement(node: Node): node is Element;
+export declare function isNonDocumentTypeChildNode(node: Node): node is Element | CharacterData;
+export declare function isPureHTMLElement(el: Element): boolean;

package/lib/is.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPureHTMLElement = exports.isNonDocumentTypeChildNode = exports.isElement = void 0;
+function isElement(node) {
+    return node.nodeType === node.ELEMENT_NODE;
+}
+exports.isElement = isElement;
+function isNonDocumentTypeChildNode(node) {
+    return 'previousElementSibling' in node && 'nextElementSibling' in node;
+}
+exports.isNonDocumentTypeChildNode = isNonDocumentTypeChildNode;
+function isPureHTMLElement(el) {
+    return el.localName !== el.nodeName;
+}
+exports.isPureHTMLElement = isPureHTMLElement;

package/lib/match-selector.d.ts

@@ -0,0 +1,13 @@
+import type { Specificity, RegexSelector } from './types';
+export declare type SelectorMatches = SelectorMatched | SelectorUnmatched;
+declare type SelectorMatched = {
+    matched: true;
+    selector: string;
+    specificity: Specificity;
+    data?: Record<string, string>;
+};
+declare type SelectorUnmatched = {
+    matched: false;
+};
+export declare function matchSelector(el: Node, selector: string | RegexSelector | undefined): SelectorMatches;
+export {};

package/lib/match-selector.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchSelector = void 0;
+const is_1 = require("./is");
+const regex_selector_matches_1 = require("./regex-selector-matches");
+const selector_1 = require("./selector");
+function matchSelector(el, selector) {
+    if (!selector) {
+        return {
+            matched: false,
+        };
+    }
+    if (typeof selector === 'string') {
+        const sel = new selector_1.Selector(selector);
+        const specificity = sel.match(el);
+        if (specificity) {
+            return {
+                matched: true,
+                selector,
+                specificity,
+            };
+        }
+        return {
+            matched: false,
+        };
+    }
+    return regexSelect(el, selector);
+}
+exports.matchSelector = matchSelector;
+function regexSelect(el, selector) {
+    let edge = new SelectorTarget(selector);
+    let edgeSelector = selector.combination;
+    while (edgeSelector) {
+        const child = new SelectorTarget(edgeSelector);
+        child.from(edge, edgeSelector.combinator);
+        edge = child;
+        edgeSelector = edgeSelector.combination;
+    }
+    return edge.match(el);
+}
+class SelectorTarget {
+    constructor(selector) {
+        this._combinatedFrom = null;
+        this._selector = selector;
+    }
+    from(target, combinator) {
+        this._combinatedFrom = { target, combinator };
+    }
+    match(el) {
+        const unitCheck = this._matchWithoutCombinateChecking(el);
+        if (!unitCheck.matched) {
+            return unitCheck;
+        }
+        if (!this._combinatedFrom) {
+            return unitCheck;
+        }
+        if (!(0, is_1.isNonDocumentTypeChildNode)(el)) {
+            return unitCheck;
+        }
+        const { target, combinator } = this._combinatedFrom;
+        switch (combinator) {
+            // Descendant combinator
+            case ' ': {
+                let ancestor = el.parentElement;
+                while (ancestor) {
+                    const matches = target.match(ancestor);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ' ');
+                    }
+                    ancestor = ancestor.parentElement;
+                }
+                return {
+                    matched: false,
+                };
+            }
+            // Child combinator
+            case '>': {
+                const parentNode = el.parentElement;
+                if (!parentNode) {
+                    return { matched: false };
+                }
+                const matches = target.match(parentNode);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ' > ');
+                }
+                return { matched: false };
+            }
+            // Next-sibling combinator
+            case '+': {
+                if (!el.previousElementSibling) {
+                    return { matched: false };
+                }
+                const matches = target.match(el.previousElementSibling);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ' + ');
+                }
+                return { matched: false };
+            }
+            // Subsequent-sibling combinator
+            case '~': {
+                let prev = el.previousElementSibling;
+                while (prev) {
+                    const matches = target.match(prev);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ' ~ ');
+                    }
+                    prev = prev.previousElementSibling;
+                }
+                return { matched: false };
+            }
+            // Prev-sibling combinator
+            case ':has(+)': {
+                if (!el.nextElementSibling) {
+                    return { matched: false };
+                }
+                const matches = target.match(el.nextElementSibling);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ':has(+ ', true);
+                }
+                return { matched: false };
+            }
+            // Subsequent-sibling (in front) combinator
+            case ':has(~)': {
+                let next = el.nextElementSibling;
+                while (next) {
+                    const matches = target.match(next);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ':has(~ ', true);
+                    }
+                    next = next.nextElementSibling;
+                }
+                return { matched: false };
+            }
+            default: {
+                throw new Error(`Unsupported ${this._combinatedFrom.combinator} combinator in selector`);
+            }
+        }
+    }
+    _matchWithoutCombinateChecking(el) {
+        return uncombinatedRegexSelect(el, this._selector);
+    }
+}
+function uncombinatedRegexSelect(el, selector) {
+    if (!(0, is_1.isElement)(el)) {
+        return {
+            matched: false,
+        };
+    }
+    let matched = true;
+    let data = {};
+    let tagSelector = '';
+    const specificity = [0, 0, 0];
+    const specifiedAttr = new Map();
+    if (selector.nodeName) {
+        const matchedNodeName = (0, regex_selector_matches_1.regexSelectorMatches)(selector.nodeName, el.localName, (0, is_1.isPureHTMLElement)(el));
+        if (matchedNodeName) {
+            delete matchedNodeName.$0;
+        }
+        else {
+            matched = false;
+        }
+        data = {
+            ...data,
+            ...matchedNodeName,
+        };
+        tagSelector = el.localName;
+        specificity[2] = 1;
+    }
+    if (selector.attrName) {
+        const selectorAttrName = selector.attrName;
+        const matchedAttrNameList = Array.from(el.attributes).map(attr => {
+            const attrName = attr.name;
+            const matchedAttrName = (0, regex_selector_matches_1.regexSelectorMatches)(selectorAttrName, attrName, (0, is_1.isPureHTMLElement)(el));
+            if (matchedAttrName) {
+                delete matchedAttrName.$0;
+                data = {
+                    ...data,
+                    ...matchedAttrName,
+                };
+                specifiedAttr.set(attrName, '');
+            }
+            return matchedAttrName;
+        });
+        if (!matchedAttrNameList.some(_ => !!_)) {
+            matched = false;
+        }
+    }
+    if (selector.attrValue) {
+        const selectorAttrValue = selector.attrValue;
+        const matchedAttrValueList = Array.from(el.attributes).map(attr => {
+            const attrName = attr.name;
+            const attrValue = attr.value;
+            const matchedAttrValue = (0, regex_selector_matches_1.regexSelectorMatches)(selectorAttrValue, attrValue, (0, is_1.isPureHTMLElement)(el));
+            if (matchedAttrValue) {
+                delete matchedAttrValue.$0;
+                data = {
+                    ...data,
+                    ...matchedAttrValue,
+                };
+                specifiedAttr.set(attrName, attrValue);
+            }
+            return matchedAttrValue;
+        });
+        if (!matchedAttrValueList.some(_ => !!_)) {
+            matched = false;
+        }
+    }
+    const attrSelector = Array.from(specifiedAttr.entries())
+        .map(([name, value]) => {
+        return `[${name}${value ? `="${value}"` : ''}]`;
+    })
+        .join('');
+    specificity[1] += specifiedAttr.size;
+    if (matched) {
+        return {
+            matched,
+            selector: `${tagSelector}${attrSelector}`,
+            specificity,
+            data,
+        };
+    }
+    return { matched };
+}
+function mergeMatches(a, b, sep, close = false) {
+    return {
+        matched: true,
+        selector: `${a.selector}${sep}${b.selector}${close ? ')' : ''}`,
+        specificity: [
+            a.specificity[0] + b.specificity[0],
+            a.specificity[1] + b.specificity[1],
+            a.specificity[2] + b.specificity[2],
+        ],
+        data: {
+            ...a.data,
+            ...b.data,
+        },
+    };
+}

package/lib/regex-selector-matches.d.ts

@@ -0,0 +1,3 @@
+export declare function regexSelectorMatches(reg: string, raw: string, ignoreCase: boolean): {
+    [x: string]: string;
+} | null;

package/lib/regex-selector-matches.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regexSelectorMatches = void 0;
+function regexSelectorMatches(reg, raw, ignoreCase) {
+    const res = {};
+    const pattern = toRegxp(reg);
+    const regex = new RegExp(pattern instanceof RegExp ? pattern : `^${pattern.trim()}$`, ignoreCase ? 'i' : undefined);
+    const matched = regex.exec(raw);
+    if (!matched) {
+        return null;
+    }
+    matched.forEach((val, i) => (res[`$${i}`] = val));
+    return {
+        ...res,
+        ...matched.groups,
+    };
+}
+exports.regexSelectorMatches = regexSelectorMatches;
+function toRegxp(pattern) {
+    const matched = pattern.match(/^\/(.+)\/([ig]*)$/i);
+    if (matched) {
+        return new RegExp(matched[1], matched[2]);
+    }
+    return pattern;
+}

package/lib/selector.d.ts

@@ -0,0 +1,8 @@
+import type { SelectorResult, Specificity } from './types';
+declare type ExtendedPseudoClass = Record<string, (content: string) => (el: Element) => SelectorResult>;
+export declare class Selector {
+    #private;
+    constructor(selector: string, extended?: ExtendedPseudoClass);
+    match(el: Node, scope?: ParentNode | null): Specificity | false;
+}
+export {};