@markuplint/selector 3.0.0-alpha.0

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

package/lib/selector.js

@@ -0,0 +1,647 @@
+"use strict";
+var _Selector_ruleset, _Ruleset_selectorGroup, _StructuredSelector_selector, _StructuredSelector_edge, _SelectorTarget_extended, _SelectorTarget_combinatedFrom, _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");
+const invalid_selector_error_1 = require("./invalid-selector-error");
+const is_1 = require("./is");
+const selLog = debug_1.log.extend('selector');
+const resLog = debug_1.log.extend('result');
+class Selector {
+    constructor(selector, extended = {}) {
+        _Selector_ruleset.set(this, void 0);
+        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);
+        for (const result of results) {
+            if (result.matched) {
+                return result.specificity;
+            }
+        }
+        return false;
+    }
+}
+exports.Selector = Selector;
+_Selector_ruleset = new WeakMap();
+class Ruleset {
+    constructor(selectors, extended, depth) {
+        _Ruleset_selectorGroup.set(this, []);
+        tslib_1.__classPrivateFieldGet(this, _Ruleset_selectorGroup, "f").push(...selectors.map(selector => new StructuredSelector(selector, depth, extended)));
+        const head = tslib_1.__classPrivateFieldGet(this, _Ruleset_selectorGroup, "f")[0];
+        this.headCombinator = (head === null || head === void 0 ? void 0 : head.headCombinator) || null;
+        if (this.headCombinator) {
+            if (depth <= 0) {
+                throw new invalid_selector_error_1.InvalidSelectorError(`'${tslib_1.__classPrivateFieldGet(this, _Ruleset_selectorGroup, "f")[0].selector}' is not a valid selector`);
+            }
+        }
+    }
+    static parse(selector, extended) {
+        const selectors = [];
+        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) {
+        (0, debug_1.log)('<%s> (%s)', (0, is_1.isElement)(el) ? el.localName : el.nodeName, scope ? ((0, is_1.isElement)(scope) ? scope.localName : scope.nodeName) : null);
+        return tslib_1.__classPrivateFieldGet(this, _Ruleset_selectorGroup, "f").map(selector => {
+            selLog('"%s"', selector.selector);
+            const res = selector.match(el, scope);
+            resLog('%s "%s" => %o', (0, is_1.isElement)(el) ? el.localName : el.nodeName, selector.selector, res);
+            return res;
+        });
+    }
+}
+_Ruleset_selectorGroup = new WeakMap();
+class StructuredSelector {
+    constructor(selector, depth, extended) {
+        _StructuredSelector_selector.set(this, void 0);
+        _StructuredSelector_edge.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 =
+            tslib_1.__classPrivateFieldGet(this, _StructuredSelector_selector, "f").nodes[0].type === 'combinator' ? tslib_1.__classPrivateFieldGet(this, _StructuredSelector_selector, "f").nodes[0].value || null : null;
+        if (0 < depth && this.headCombinator) {
+            tslib_1.__classPrivateFieldGet(this, _StructuredSelector_selector, "f").nodes.unshift((0, postcss_selector_parser_1.pseudo)({ value: ':scope' }));
+        }
+        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");
+                    break;
+                }
+                case 'root':
+                case 'string': {
+                    throw new Error(`Unsupported selector: ${selector.toString()}`);
+                }
+                case 'nesting': {
+                    throw new Error(`Unsupported nested selector: ${selector.toString()}`);
+                }
+                case 'comment': {
+                    throw new Error(`Unsupported comment in selector: ${selector.toString()}`);
+                }
+                default: {
+                    tslib_1.__classPrivateFieldGet(this, _StructuredSelector_edge, "f").add(node);
+                }
+            }
+        });
+    }
+    get selector() {
+        return tslib_1.__classPrivateFieldGet(this, _StructuredSelector_selector, "f").nodes.join('');
+    }
+    match(el, scope) {
+        return tslib_1.__classPrivateFieldGet(this, _StructuredSelector_edge, "f").match(el, scope, 0);
+    }
+}
+_StructuredSelector_selector = new WeakMap(), _StructuredSelector_edge = 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 = [];
+        this.id = [];
+        this.pseudo = [];
+        this.tag = null;
+        tslib_1.__classPrivateFieldSet(this, _SelectorTarget_extended, extended, "f");
+        this.depth = depth;
+    }
+    add(selector) {
+        tslib_1.__classPrivateFieldSet(this, _SelectorTarget_isAdded, true, "f");
+        switch (selector.type) {
+            case 'tag':
+            case 'universal': {
+                this.tag = selector;
+                break;
+            }
+            case 'id': {
+                this.id.push(selector);
+                break;
+            }
+            case 'class': {
+                this.class.push(selector);
+                break;
+            }
+            case 'attribute': {
+                this.attr.push(selector);
+                break;
+            }
+            case 'pseudo': {
+                this.pseudo.push(selector);
+                break;
+            }
+        }
+    }
+    from(target, combinator) {
+        tslib_1.__classPrivateFieldSet(this, _SelectorTarget_combinatedFrom, { 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 combinator = result.combinator ? ` ${result.combinator}` : '';
+            selLog('The %s element by "%s" => %s (%d)', nodeName, `${selector}${combinator}`, result.matched, count);
+            if (selector === ':scope') {
+                selLog(`† Scope is the ${(scope === null || scope === void 0 ? void 0 : scope.nodeName) || null}`);
+            }
+        }
+        delete result.combinator;
+        return result;
+    }
+    _match(el, scope, count) {
+        const unitCheck = this._matchWithoutCombinateChecking(el, scope);
+        if (!unitCheck.matched) {
+            return unitCheck;
+        }
+        if (!tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinatedFrom, "f")) {
+            return unitCheck;
+        }
+        if (!(0, is_1.isNonDocumentTypeChildNode)(el)) {
+            return unitCheck;
+        }
+        const { target, combinator } = tslib_1.__classPrivateFieldGet(this, _SelectorTarget_combinatedFrom, "f");
+        switch (combinator.value) {
+            // Descendant combinator
+            case ' ': {
+                let ancestor = el.parentElement;
+                let matched = false;
+                let specificity;
+                while (ancestor) {
+                    const res = target.match(ancestor, scope, count + 1);
+                    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.parentElement;
+                }
+                if (!specificity) {
+                    const res = target.match(el, scope, count + 1);
+                    specificity = [
+                        unitCheck.specificity[0] + res.specificity[0],
+                        unitCheck.specificity[1] + res.specificity[1],
+                        unitCheck.specificity[2] + res.specificity[2],
+                    ];
+                }
+                return {
+                    combinator: '␣',
+                    specificity,
+                    matched,
+                };
+            }
+            // Child combinator
+            case '>': {
+                let matched;
+                const specificity = unitCheck.specificity;
+                const parentNode = el.parentElement;
+                if (parentNode) {
+                    const res = target.match(parentNode, scope, count + 1);
+                    specificity[0] += res.specificity[0];
+                    specificity[1] += res.specificity[1];
+                    specificity[2] += res.specificity[2];
+                    matched = res.matched;
+                }
+                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;
+                }
+                return {
+                    combinator: '>',
+                    specificity,
+                    matched,
+                };
+            }
+            // Next-sibling combinator
+            case '+': {
+                let matched;
+                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;
+                }
+                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;
+                }
+                return {
+                    combinator: '+',
+                    specificity,
+                    matched,
+                };
+            }
+            // Subsequent-sibling combinator
+            case '~': {
+                let prev = el.previousElementSibling;
+                let matched = false;
+                let specificity;
+                while (prev) {
+                    const res = target.match(prev, scope, count + 1);
+                    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;
+                }
+                if (!specificity) {
+                    const res = target.match(el, scope, count + 1);
+                    specificity = [
+                        unitCheck.specificity[0] + res.specificity[0],
+                        unitCheck.specificity[1] + res.specificity[1],
+                        unitCheck.specificity[2] + res.specificity[2],
+                    ];
+                }
+                return {
+                    combinator: '~',
+                    specificity,
+                    matched,
+                };
+            }
+            // Column combinator
+            case '||': {
+                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`);
+            }
+        }
+    }
+    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) {
+        const specificity = [0, 0, 0];
+        if (!(0, is_1.isElement)(el)) {
+            return {
+                specificity,
+                matched: false,
+            };
+        }
+        // @ts-ignore
+        if (this.tag && this.tag._namespace) {
+            // @ts-ignore
+            const namespace = `${this.tag._namespace}`.toLowerCase();
+            switch (namespace) {
+                case '*':
+                case 'true': {
+                    break;
+                }
+                case 'svg': {
+                    if (el.namespaceURI !== 'http://www.w3.org/2000/svg') {
+                        return {
+                            specificity,
+                            matched: false,
+                        };
+                    }
+                    break;
+                }
+                default: {
+                    throw new invalid_selector_error_1.InvalidSelectorError(`The ${namespace} namespace is not supported`);
+                }
+            }
+        }
+        let matched = true;
+        if (!tslib_1.__classPrivateFieldGet(this, _SelectorTarget_isAdded, "f") && !isScope(el, scope)) {
+            matched = false;
+        }
+        if (!this.id.every(id => id.value === el.id)) {
+            matched = false;
+        }
+        specificity[0] += this.id.length;
+        if (!this.class.every(className => el.classList.contains(className.value))) {
+            matched = false;
+        }
+        specificity[1] += this.class.length;
+        if (!this.attr.every(attr => attrMatch(attr, el))) {
+            matched = false;
+        }
+        specificity[1] += this.attr.length;
+        for (const pseudo of this.pseudo) {
+            const pseudoRes = pseudoMatch(pseudo, el, scope, tslib_1.__classPrivateFieldGet(this, _SelectorTarget_extended, "f"), this.depth);
+            specificity[0] += pseudoRes.specificity[0];
+            specificity[1] += pseudoRes.specificity[1];
+            specificity[2] += pseudoRes.specificity[2];
+            if (!pseudoRes.matched) {
+                matched = false;
+            }
+        }
+        if (this.tag && this.tag.type === 'tag') {
+            specificity[2] += 1;
+            let a = this.tag.value;
+            let b = el.localName;
+            if ((0, is_1.isPureHTMLElement)(el)) {
+                a = a.toLowerCase();
+                b = b.toLowerCase();
+            }
+            if (a !== b) {
+                matched = false;
+            }
+        }
+        return {
+            specificity,
+            matched,
+        };
+    }
+}
+_SelectorTarget_extended = new WeakMap(), _SelectorTarget_combinatedFrom = new WeakMap(), _SelectorTarget_isAdded = new WeakMap();
+function attrMatch(attr, el) {
+    return Array.from(el.attributes).some(attrOfEl => {
+        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;
+            if (attr.insensitive) {
+                value = value.toLowerCase();
+                valueOfEl = valueOfEl.toLowerCase();
+            }
+            switch (attr.operator) {
+                case '=': {
+                    if (value !== valueOfEl) {
+                        return false;
+                    }
+                    break;
+                }
+                case '~=': {
+                    if (!valueOfEl.split(/\s+/).includes(value)) {
+                        return false;
+                    }
+                    break;
+                }
+                case '|=': {
+                    if (!new RegExp(`^${value}(?:$|-)`).test(valueOfEl)) {
+                        return false;
+                    }
+                    break;
+                }
+                case '*=': {
+                    if (valueOfEl.indexOf(value) === -1) {
+                        return false;
+                    }
+                    break;
+                }
+                case '^=': {
+                    if (valueOfEl.indexOf(value) !== 0) {
+                        return false;
+                    }
+                    break;
+                }
+                case '$=': {
+                    if (valueOfEl.lastIndexOf(value) !== valueOfEl.length - value.length) {
+                        return false;
+                    }
+                    break;
+                }
+            }
+        }
+        return true;
+    });
+}
+function pseudoMatch(pseudo, el, scope, extended, depth) {
+    switch (pseudo.value) {
+        //
+        /**
+         * Below, markuplint Specific Selector
+         */
+        case ':closest': {
+            const ruleset = new Ruleset(pseudo.nodes, extended, depth + 1);
+            const specificity = getSpecificity(ruleset.match(el, scope));
+            let parent = el.parentElement;
+            while (parent) {
+                if (ruleset.match(parent, scope).some(r => r.matched)) {
+                    return {
+                        specificity,
+                        matched: true,
+                    };
+                }
+                parent = parent.parentElement;
+            }
+            return {
+                specificity,
+                matched: false,
+            };
+        }
+        /**
+         * Below, Selector Level 4
+         */
+        case ':not': {
+            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);
+            return {
+                specificity,
+                matched,
+            };
+        }
+        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);
+            return {
+                specificity,
+                matched,
+            };
+        }
+        case ':has': {
+            const ruleset = new Ruleset(pseudo.nodes, extended, depth + 1);
+            const specificity = getSpecificity(ruleset.match(el, scope));
+            switch (ruleset.headCombinator) {
+                case '+':
+                case '~': {
+                    const matched = getSiblings(el).some(sib => ruleset.match(sib, el).some(m => m.matched));
+                    return {
+                        specificity,
+                        matched,
+                    };
+                }
+                default: {
+                    const matched = getDescendants(el).some(desc => ruleset.match(desc, el).some(m => m.matched));
+                    return {
+                        specificity,
+                        matched,
+                    };
+                }
+            }
+        }
+        case ':where': {
+            const ruleset = new Ruleset(pseudo.nodes, extended, depth + 1);
+            const resList = ruleset.match(el, scope);
+            const matched = resList.some(r => r.matched);
+            return {
+                specificity: [0, 0, 0],
+                matched,
+            };
+        }
+        case ':scope': {
+            if (isScope(el, scope)) {
+                return {
+                    specificity: [0, 1, 0],
+                    matched: true,
+                };
+            }
+            return {
+                specificity: [0, 1, 0],
+                matched: false,
+            };
+        }
+        case ':root': {
+            if (el.localName === 'html') {
+                return {
+                    specificity: [0, 1, 0],
+                    matched: true,
+                };
+            }
+            return {
+                specificity: [0, 1, 0],
+                matched: false,
+            };
+        }
+        case ':enable':
+        case ':disable':
+        case ':read-write':
+        case ':read-only':
+        case ':placeholder-shown':
+        case ':default':
+        case ':checked':
+        case ':indeterminate':
+        case ':valid':
+        case ':invalid':
+        case ':in-range':
+        case ':out-of-range':
+        case ':required':
+        case ':optional':
+        case ':blank':
+        case ':user-invalid':
+        case ':empty':
+        case ':nth-child':
+        case ':nth-last-child':
+        case ':first-child':
+        case ':last-child':
+        case ':only-child':
+        case ':nth-of-type':
+        case ':nth-last-of-type':
+        case ':first-of-type':
+        case ':last-of-type':
+        case ':only-of-type':
+        case ':nth-last-col':
+        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 ':dir':
+        case ':lang':
+        case ':any-link':
+        case ':link':
+        case ':visited':
+        case ':local-link':
+        case ':target':
+        case ':target-within':
+        case ':current':
+        case ':past':
+        case ':future':
+        case ':active':
+        case ':hover':
+        case ':focus':
+        case ':focus-within':
+        case ':focus-visible':
+        case '::before':
+        case '::after':
+        default: {
+            for (const ext of Object.keys(extended)) {
+                if (pseudo.value !== `:${ext}`) {
+                    continue;
+                }
+                const content = pseudo.nodes.map(node => node.toString()).join('');
+                const hook = extended[ext];
+                const matcher = hook(content);
+                return matcher(el);
+            }
+            throw new Error(`Unsupported pseudo ${pseudo.toString()} selector.`);
+        }
+    }
+}
+function isScope(el, scope) {
+    return el === scope || el.parentNode === null;
+}
+function getDescendants(el, includeSelf = false) {
+    return [
+        ...Array.from(el.children)
+            .map(child => getDescendants(child, true))
+            .flat(),
+        ...(includeSelf ? [el] : []),
+    ];
+}
+function getSiblings(el) {
+    var _a;
+    return Array.from(((_a = el.parentElement) === null || _a === void 0 ? void 0 : _a.children) || []);
+}
+function getSpecificity(result) {
+    let specificity;
+    for (const res of result) {
+        if (specificity) {
+            const order = (0, compare_specificity_1.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/types.d.ts

@@ -0,0 +1,16 @@
+export declare type Specificity = [number, number, number];
+export declare type SelectorResult = {
+    specificity: Specificity;
+    matched: boolean;
+};
+export declare type RegexSelector = RegexSelectorWithoutCompination & {
+    combination?: {
+        combinator: RegexSelectorCombinator;
+    } & RegexSelector;
+};
+export declare type RegexSelectorCombinator = ' ' | '>' | '+' | '~' | ':has(+)' | ':has(~)';
+export declare type RegexSelectorWithoutCompination = {
+    nodeName?: string;
+    attrName?: string;
+    attrValue?: string;
+};

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/utils/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;