@nativescript/core 9.0.10 → 9.0.11-next.1

package/ui/styling/css-selector.js

@@ -1,934 +0,0 @@
-import { parse as convertToCSSWhatSelector } from 'css-what';
-import '../../globals';
-import { isCssVariable } from '../core/properties';
-import { isNullOrUndefined } from '../../utils/types';
-import { checkIfMediaQueryMatches } from '../../media-query-list';
-export const MEDIA_QUERY_SEPARATOR = '&&';
-var Combinator;
-(function (Combinator) {
-    Combinator["descendant"] = " ";
-    Combinator["child"] = ">";
-    Combinator["adjacent"] = "+";
-    Combinator["sibling"] = "~";
-    // Not supported
-    Combinator["parent"] = "<";
-    Combinator["column-combinator"] = "||";
-})(Combinator || (Combinator = {}));
-var AttributeSelectorOperator;
-(function (AttributeSelectorOperator) {
-    AttributeSelectorOperator["exists"] = "";
-    AttributeSelectorOperator["equals"] = "=";
-    AttributeSelectorOperator["start"] = "^=";
-    AttributeSelectorOperator["end"] = "$=";
-    AttributeSelectorOperator["any"] = "*=";
-    AttributeSelectorOperator["element"] = "~=";
-    AttributeSelectorOperator["hyphen"] = "|=";
-})(AttributeSelectorOperator || (AttributeSelectorOperator = {}));
-var Match;
-(function (Match) {
-    /**
-     * Depends on attributes or pseudoclasses state;
-     */
-    Match.Dynamic = true;
-    /**
-     * Depends only on the tree structure.
-     */
-    Match.Static = false;
-})(Match || (Match = {}));
-function eachNodePreviousGeneralSibling(node, callback) {
-    if (!node.parent || !node.parent.getChildIndex || !node.parent.getChildAt || !node.parent.getChildrenCount) {
-        return;
-    }
-    const nodeIndex = node.parent.getChildIndex(node);
-    if (nodeIndex === 0) {
-        return;
-    }
-    const count = node.parent.getChildrenCount();
-    let retVal = true;
-    for (let i = nodeIndex - 1; i >= 0 && retVal; i--) {
-        const sibling = node.parent.getChildAt(i);
-        retVal = callback(sibling);
-    }
-}
-function getNodePreviousDirectSibling(node) {
-    if (!node.parent || !node.parent.getChildIndex || !node.parent.getChildAt) {
-        return null;
-    }
-    const nodeIndex = node.parent.getChildIndex(node);
-    if (nodeIndex === 0) {
-        return null;
-    }
-    return node.parent.getChildAt(nodeIndex - 1);
-}
-function SelectorProperties(specificity, rarity, dynamic = false) {
-    return (cls) => {
-        cls.prototype.specificity = specificity;
-        cls.prototype.rarity = rarity;
-        cls.prototype.combinator = undefined;
-        cls.prototype.dynamic = dynamic;
-        return cls;
-    };
-}
-function FunctionalPseudoClassProperties(specificity, rarity, pseudoSelectorListType) {
-    return (cls) => {
-        cls.prototype.specificity = specificity;
-        cls.prototype.rarity = rarity;
-        cls.prototype.combinator = undefined;
-        cls.prototype.dynamic = false;
-        cls.prototype.pseudoSelectorListType = pseudoSelectorListType;
-        return cls;
-    };
-}
-export class SelectorBase {
-}
-let SelectorCore = class SelectorCore extends SelectorBase {
-    lookupSort(sorter, base) {
-        sorter.sortAsUniversal(base || this);
-    }
-};
-SelectorCore = __decorate([
-    SelectorProperties(0 /* Specificity.Universal */, 0 /* Rarity.Universal */, Match.Static)
-], SelectorCore);
-export { SelectorCore };
-export class SimpleSelector extends SelectorCore {
-    accumulateChanges(node, map) {
-        if (!this.dynamic) {
-            return this.match(node);
-        }
-        else if (this.mayMatch(node)) {
-            this.trackChanges(node, map);
-            return true;
-        }
-        return false;
-    }
-    mayMatch(node) {
-        return this.match(node);
-    }
-    trackChanges(node, map) {
-        // No-op, silence the tslint 'block is empty'.
-        // Some derived classes (dynamic) will actually fill the map with stuff here, some (static) won't do anything.
-    }
-}
-function wrap(text) {
-    return text ? ` ${text} ` : '';
-}
-let InvalidSelector = class InvalidSelector extends SimpleSelector {
-    constructor(e) {
-        super();
-        this.e = e;
-    }
-    toString() {
-        return `<${this.e}>`;
-    }
-    match(node) {
-        return false;
-    }
-    lookupSort(sorter, base) {
-        // No-op, silence the tslint 'block is empty'.
-        // It feels like tslint has problems with simple polymorphism...
-        // This selector is invalid and will never match so we won't bother sorting it to further appear in queries.
-    }
-};
-InvalidSelector = __decorate([
-    SelectorProperties(0 /* Specificity.Invalid */, 4 /* Rarity.Invalid */, Match.Static),
-    __metadata("design:paramtypes", [Error])
-], InvalidSelector);
-export { InvalidSelector };
-let UniversalSelector = class UniversalSelector extends SimpleSelector {
-    toString() {
-        return `*${wrap(this.combinator)}`;
-    }
-    match(node) {
-        return true;
-    }
-};
-UniversalSelector = __decorate([
-    SelectorProperties(0 /* Specificity.Universal */, 0 /* Rarity.Universal */, Match.Static)
-], UniversalSelector);
-export { UniversalSelector };
-let IdSelector = class IdSelector extends SimpleSelector {
-    constructor(id) {
-        super();
-        this.id = id;
-    }
-    toString() {
-        return `#${this.id}${wrap(this.combinator)}`;
-    }
-    match(node) {
-        return node.id === this.id;
-    }
-    lookupSort(sorter, base) {
-        sorter.sortById(this.id, base || this);
-    }
-};
-IdSelector = __decorate([
-    SelectorProperties(100 /* Specificity.Id */, 3 /* Rarity.Id */, Match.Static),
-    __metadata("design:paramtypes", [String])
-], IdSelector);
-export { IdSelector };
-let TypeSelector = class TypeSelector extends SimpleSelector {
-    constructor(cssType) {
-        super();
-        this.cssType = cssType;
-    }
-    toString() {
-        return `${this.cssType}${wrap(this.combinator)}`;
-    }
-    match(node) {
-        return node.cssType === this.cssType;
-    }
-    lookupSort(sorter, base) {
-        sorter.sortByType(this.cssType, base || this);
-    }
-};
-TypeSelector = __decorate([
-    SelectorProperties(1 /* Specificity.Type */, 1 /* Rarity.Type */, Match.Static),
-    __metadata("design:paramtypes", [String])
-], TypeSelector);
-export { TypeSelector };
-let ClassSelector = class ClassSelector extends SimpleSelector {
-    constructor(cssClass) {
-        super();
-        this.cssClass = cssClass;
-    }
-    toString() {
-        return `.${this.cssClass}${wrap(this.combinator)}`;
-    }
-    match(node) {
-        return node.cssClasses && node.cssClasses.has(this.cssClass);
-    }
-    lookupSort(sorter, base) {
-        sorter.sortByClass(this.cssClass, base || this);
-    }
-};
-ClassSelector = __decorate([
-    SelectorProperties(10 /* Specificity.Class */, 2 /* Rarity.Class */, Match.Static),
-    __metadata("design:paramtypes", [String])
-], ClassSelector);
-export { ClassSelector };
-let AttributeSelector = class AttributeSelector extends SimpleSelector {
-    constructor(attribute, test, value, ignoreCase) {
-        super();
-        this.attribute = attribute;
-        this.test = test;
-        this.value = value;
-        this.ignoreCase = ignoreCase;
-    }
-    toString() {
-        return `[${this.attribute}${wrap(AttributeSelectorOperator[this.test] ?? this.test)}${this.value || ''}]${wrap(this.combinator)}`;
-    }
-    match(node) {
-        let attr = node[this.attribute];
-        if (this.test === 'exists') {
-            return !isNullOrUndefined(attr);
-        }
-        if (!this.value) {
-            return false;
-        }
-        // Now, convert value to string
-        attr += '';
-        if (this.ignoreCase) {
-            attr = attr.toLowerCase();
-            this.value = this.value.toLowerCase();
-        }
-        // =
-        if (this.test === 'equals') {
-            return attr === this.value;
-        }
-        // ^=
-        if (this.test === 'start') {
-            return attr.startsWith(this.value);
-        }
-        // $=
-        if (this.test === 'end') {
-            return attr.endsWith(this.value);
-        }
-        // *=
-        if (this.test === 'any') {
-            return attr.indexOf(this.value) !== -1;
-        }
-        // ~=
-        if (this.test === 'element') {
-            const words = attr.split(' ');
-            return words && words.indexOf(this.value) !== -1;
-        }
-        // |=
-        if (this.test === 'hyphen') {
-            return attr === this.value || attr.startsWith(this.value + '-');
-        }
-        return false;
-    }
-    mayMatch(node) {
-        return true;
-    }
-    trackChanges(node, map) {
-        map.addAttribute(node, this.attribute);
-    }
-};
-AttributeSelector = __decorate([
-    SelectorProperties(10 /* Specificity.Attribute */, 0 /* Rarity.Attribute */, Match.Dynamic),
-    __metadata("design:paramtypes", [String, String, String, Boolean])
-], AttributeSelector);
-export { AttributeSelector };
-let PseudoClassSelector = class PseudoClassSelector extends SimpleSelector {
-    constructor(cssPseudoClass) {
-        super();
-        this.cssPseudoClass = cssPseudoClass;
-    }
-    toString() {
-        return `:${this.cssPseudoClass}${wrap(this.combinator)}`;
-    }
-    match(node) {
-        return node.cssPseudoClasses && node.cssPseudoClasses.has(this.cssPseudoClass);
-    }
-    mayMatch(node) {
-        return true;
-    }
-    trackChanges(node, map) {
-        map.addPseudoClass(node, this.cssPseudoClass);
-    }
-};
-PseudoClassSelector = __decorate([
-    SelectorProperties(10 /* Specificity.PseudoClass */, 0 /* Rarity.PseudoClass */, Match.Dynamic),
-    __metadata("design:paramtypes", [String])
-], PseudoClassSelector);
-export { PseudoClassSelector };
-export class FunctionalPseudoClassSelector extends PseudoClassSelector {
-    constructor(cssPseudoClass, dataType) {
-        super(cssPseudoClass);
-        const selectors = [];
-        const needsHighestSpecificity = this.specificity === -1 /* Specificity.SelectorListHighest */;
-        let specificity = 0;
-        if (Array.isArray(dataType)) {
-            for (const asts of dataType) {
-                const selector = createSelectorFromAst(asts);
-                if (selector instanceof InvalidSelector) {
-                    // Only forgiving selector list can ignore invalid selectors
-                    if (this.selectorListType !== 1 /* PseudoClassSelectorList.Forgiving */) {
-                        selectors.splice(0);
-                        specificity = 0;
-                        break;
-                    }
-                    continue;
-                }
-                // The specificity of some pseudo-classes is replaced by the specificity of the most specific selector in its comma-separated argument of selectors
-                if (needsHighestSpecificity && selector.specificity > specificity) {
-                    specificity = selector.specificity;
-                }
-                selectors.push(selector);
-            }
-        }
-        this.selectors = selectors;
-        this.specificity = specificity;
-        // Functional pseudo-classes become dynamic based on selectors in selector list
-        this.dynamic = this.selectors.some((sel) => sel.dynamic);
-    }
-    toString() {
-        return `:${this.cssPseudoClass}(${this.selectors.join(', ')})${wrap(this.combinator)}`;
-    }
-    match(node) {
-        return false;
-    }
-    mayMatch(node) {
-        return true;
-    }
-    trackChanges(node, map) {
-        this.selectors.forEach((sel) => sel.trackChanges(node, map));
-    }
-}
-let NotFunctionalPseudoClassSelector = class NotFunctionalPseudoClassSelector extends FunctionalPseudoClassSelector {
-    match(node) {
-        return !this.selectors.some((sel) => sel.match(node));
-    }
-};
-NotFunctionalPseudoClassSelector = __decorate([
-    FunctionalPseudoClassProperties(-1 /* Specificity.SelectorListHighest */, 0 /* Rarity.PseudoClass */, 0 /* PseudoClassSelectorList.Regular */)
-], NotFunctionalPseudoClassSelector);
-export { NotFunctionalPseudoClassSelector };
-let IsFunctionalPseudoClassSelector = class IsFunctionalPseudoClassSelector extends FunctionalPseudoClassSelector {
-    match(node) {
-        return this.selectors.some((sel) => sel.match(node));
-    }
-    lookupSort(sorter, base) {
-        // A faster lookup can be performed when selector list contains just a single selector
-        if (this.selectors.length === 1) {
-            this.selectors[0].lookupSort(sorter, base || this);
-        }
-        else {
-            super.lookupSort(sorter, base || this);
-        }
-    }
-};
-IsFunctionalPseudoClassSelector = __decorate([
-    FunctionalPseudoClassProperties(-1 /* Specificity.SelectorListHighest */, 0 /* Rarity.PseudoClass */, 1 /* PseudoClassSelectorList.Forgiving */)
-], IsFunctionalPseudoClassSelector);
-export { IsFunctionalPseudoClassSelector };
-let WhereFunctionalPseudoClassSelector = class WhereFunctionalPseudoClassSelector extends FunctionalPseudoClassSelector {
-    match(node) {
-        return this.selectors.some((sel) => sel.match(node));
-    }
-    lookupSort(sorter, base) {
-        // A faster lookup can be performed when selector list contains just a single selector
-        if (this.selectors.length === 1) {
-            this.selectors[0].lookupSort(sorter, base || this);
-        }
-        else {
-            super.lookupSort(sorter, base || this);
-        }
-    }
-};
-WhereFunctionalPseudoClassSelector = __decorate([
-    FunctionalPseudoClassProperties(0 /* Specificity.Zero */, 0 /* Rarity.PseudoClass */, 1 /* PseudoClassSelectorList.Forgiving */)
-], WhereFunctionalPseudoClassSelector);
-export { WhereFunctionalPseudoClassSelector };
-export class SimpleSelectorSequence extends SimpleSelector {
-    constructor(selectors) {
-        super();
-        this.selectors = selectors;
-        this.specificity = selectors.reduce((sum, sel) => sel.specificity + sum, 0);
-        this.head = selectors.reduce((prev, curr) => (!prev || curr.rarity > prev.rarity ? curr : prev), null);
-        this.dynamic = selectors.some((sel) => sel.dynamic);
-    }
-    toString() {
-        return `${this.selectors.join('')}${wrap(this.combinator)}`;
-    }
-    match(node) {
-        return this.selectors.every((sel) => sel.match(node));
-    }
-    mayMatch(node) {
-        return this.selectors.every((sel) => sel.mayMatch(node));
-    }
-    trackChanges(node, map) {
-        this.selectors.forEach((sel) => sel.trackChanges(node, map));
-    }
-    lookupSort(sorter, base) {
-        this.head.lookupSort(sorter, base || this);
-    }
-}
-export class ComplexSelector extends SelectorCore {
-    constructor(selectors) {
-        super();
-        this.selectors = selectors;
-        let siblingsToGroup;
-        let currentGroup;
-        const groups = [];
-        this.specificity = 0;
-        this.dynamic = false;
-        for (let i = selectors.length - 1; i >= 0; i--) {
-            const sel = selectors[i];
-            switch (sel.combinator) {
-                case undefined:
-                case Combinator.descendant:
-                    siblingsToGroup = [];
-                    currentGroup = [siblingsToGroup];
-                    groups.push(currentGroup);
-                    break;
-                case Combinator.child:
-                    siblingsToGroup = [];
-                    currentGroup.push(siblingsToGroup);
-                    break;
-                case Combinator.adjacent:
-                case Combinator.sibling:
-                    break;
-                default:
-                    throw new Error(`Unsupported combinator "${sel.combinator}" for selector ${sel}.`);
-            }
-            this.specificity += sel.specificity;
-            if (sel.dynamic) {
-                this.dynamic = true;
-            }
-            siblingsToGroup.push(sel);
-        }
-        this.groups = groups.map((g) => new Selector.ChildGroup(g.map((selectors) => (selectors.length > 1 ? new Selector.SiblingGroup(selectors) : selectors[0]))));
-        this.last = selectors[selectors.length - 1];
-    }
-    toString() {
-        return this.selectors.join('');
-    }
-    match(node) {
-        return this.groups.every((group, i) => {
-            if (i === 0) {
-                node = group.getMatchingNode(node, true);
-                return !!node;
-            }
-            else {
-                let ancestor = node;
-                while ((ancestor = ancestor.parent ?? ancestor._modalParent)) {
-                    if ((node = group.getMatchingNode(ancestor, true))) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-        });
-    }
-    mayMatch(node) {
-        return false;
-    }
-    trackChanges(node, map) {
-        this.selectors.forEach((sel) => sel.trackChanges(node, map));
-    }
-    lookupSort(sorter, base) {
-        this.last.lookupSort(sorter, base || this);
-    }
-    accumulateChanges(node, map) {
-        if (!this.dynamic) {
-            return this.match(node);
-        }
-        const bounds = [];
-        const mayMatch = this.groups.every((group, i) => {
-            if (i === 0) {
-                const nextNode = group.getMatchingNode(node, false);
-                bounds.push({ left: node, right: node });
-                node = nextNode;
-                return !!node;
-            }
-            else {
-                let ancestor = node;
-                while ((ancestor = ancestor.parent)) {
-                    const nextNode = group.getMatchingNode(ancestor, false);
-                    if (nextNode) {
-                        bounds.push({ left: ancestor, right: null });
-                        node = nextNode;
-                        return true;
-                    }
-                }
-                return false;
-            }
-        });
-        // Calculating the right bounds for each selectors won't save much
-        if (!mayMatch) {
-            return false;
-        }
-        if (!map) {
-            return mayMatch;
-        }
-        for (let i = 0; i < this.groups.length; i++) {
-            const group = this.groups[i];
-            if (!group.dynamic) {
-                continue;
-            }
-            const bound = bounds[i];
-            let node = bound.left;
-            do {
-                if (group.mayMatch(node)) {
-                    group.trackChanges(node, map);
-                }
-            } while (node !== bound.right && (node = node.parent));
-        }
-        return mayMatch;
-    }
-}
-export var Selector;
-(function (Selector) {
-    // Non-spec. Selector sequences are grouped by ancestor then by child combinators for easier backtracking.
-    class ChildGroup extends SelectorBase {
-        constructor(selectors) {
-            super();
-            this.selectors = selectors;
-            this.dynamic = selectors.some((sel) => sel.dynamic);
-        }
-        getMatchingNode(node, strict) {
-            const funcName = strict ? 'match' : 'mayMatch';
-            return this.selectors.every((sel, i) => (node = i === 0 ? node : node.parent) && sel[funcName](node)) ? node : null;
-        }
-        match(node) {
-            return this.getMatchingNode(node, true) != null;
-        }
-        mayMatch(node) {
-            return this.getMatchingNode(node, false) != null;
-        }
-        trackChanges(node, map) {
-            this.selectors.forEach((sel, i) => {
-                if (i === 0) {
-                    node && sel.trackChanges(node, map);
-                }
-                else {
-                    node = node.parent;
-                    if (node && sel.mayMatch(node)) {
-                        sel.trackChanges(node, map);
-                    }
-                }
-            });
-        }
-    }
-    Selector.ChildGroup = ChildGroup;
-    class SiblingGroup extends SelectorBase {
-        constructor(selectors) {
-            super();
-            this.selectors = selectors;
-            this.dynamic = selectors.some((sel) => sel.dynamic);
-        }
-        match(node) {
-            return this.selectors.every((sel, i) => {
-                if (i === 0) {
-                    return node && sel.match(node);
-                }
-                if (sel.combinator === Combinator.adjacent) {
-                    node = getNodePreviousDirectSibling(node);
-                    return node && sel.match(node);
-                }
-                // Sibling combinator
-                let isMatching = false;
-                eachNodePreviousGeneralSibling(node, (sibling) => {
-                    isMatching = sel.match(sibling);
-                    return !isMatching;
-                });
-                return isMatching;
-            });
-        }
-        mayMatch(node) {
-            return this.selectors.every((sel, i) => {
-                if (i === 0) {
-                    return node && sel.mayMatch(node);
-                }
-                if (sel.combinator === Combinator.adjacent) {
-                    node = getNodePreviousDirectSibling(node);
-                    return node && sel.mayMatch(node);
-                }
-                // Sibling combinator
-                let isMatching = false;
-                eachNodePreviousGeneralSibling(node, (sibling) => {
-                    isMatching = sel.mayMatch(sibling);
-                    return !isMatching;
-                });
-                return isMatching;
-            });
-        }
-        trackChanges(node, map) {
-            this.selectors.forEach((sel, i) => {
-                if (i === 0) {
-                    if (node) {
-                        sel.trackChanges(node, map);
-                    }
-                }
-                else {
-                    if (sel.combinator === Combinator.adjacent) {
-                        node = getNodePreviousDirectSibling(node);
-                        if (node && sel.mayMatch(node)) {
-                            sel.trackChanges(node, map);
-                        }
-                    }
-                    else {
-                        // Sibling combinator
-                        let matchingSibling;
-                        eachNodePreviousGeneralSibling(node, (sibling) => {
-                            const isMatching = sel.mayMatch(sibling);
-                            if (isMatching) {
-                                matchingSibling = sibling;
-                            }
-                            return !isMatching;
-                        });
-                        if (matchingSibling) {
-                            sel.trackChanges(matchingSibling, map);
-                        }
-                    }
-                }
-            });
-        }
-    }
-    Selector.SiblingGroup = SiblingGroup;
-})(Selector || (Selector = {}));
-export class RuleSet {
-    constructor(selectors, declarations) {
-        this.selectors = selectors;
-        this.declarations = declarations;
-        this.selectors.forEach((sel) => (sel.ruleset = this));
-    }
-    toString() {
-        let desc = `${this.selectors.join(', ')} {${this.declarations.map((d, i) => `${i === 0 ? ' ' : ''}${d.property}: ${d.value}`).join('; ')} }`;
-        if (this.mediaQueryString) {
-            desc = `@media ${this.mediaQueryString} { ${desc} }`;
-        }
-        return desc;
-    }
-    lookupSort(sorter) {
-        this.selectors.forEach((sel) => sel.lookupSort(sorter));
-    }
-}
-export function fromAstNode(astRule) {
-    const declarations = astRule.declarations.filter(isDeclaration).map(createDeclaration);
-    const selectors = astRule.selectors.map(createSelector);
-    return new RuleSet(selectors, declarations);
-}
-function createDeclaration(decl) {
-    return { property: isCssVariable(decl.property) ? decl.property : decl.property.toLowerCase(), value: decl.value };
-}
-function createSimpleSelectorFromAst(ast) {
-    if (ast.type === 'attribute') {
-        if (ast.name === 'class') {
-            return new ClassSelector(ast.value);
-        }
-        if (ast.name === 'id') {
-            return new IdSelector(ast.value);
-        }
-        return new AttributeSelector(ast.name, ast.action, ast.value, !!ast.ignoreCase);
-    }
-    if (ast.type === 'tag') {
-        return new TypeSelector(ast.name.replace('-', '').toLowerCase());
-    }
-    if (ast.type === 'pseudo') {
-        if (ast.name === 'is') {
-            return new IsFunctionalPseudoClassSelector(ast.name, ast.data);
-        }
-        if (ast.name === 'where') {
-            return new WhereFunctionalPseudoClassSelector(ast.name, ast.data);
-        }
-        if (ast.name === 'not') {
-            return new NotFunctionalPseudoClassSelector(ast.name, ast.data);
-        }
-        return new PseudoClassSelector(ast.name);
-    }
-    if (ast.type === 'universal') {
-        return new UniversalSelector();
-    }
-    return new InvalidSelector(new Error(ast.type));
-}
-function createSimpleSelectorSequenceFromAst(asts) {
-    if (asts.length === 0) {
-        return new InvalidSelector(new Error('Empty simple selector sequence.'));
-    }
-    if (asts.length === 1) {
-        return createSimpleSelectorFromAst(asts[0]);
-    }
-    const sequenceSelectors = [];
-    for (const ast of asts) {
-        const selector = createSimpleSelectorFromAst(ast);
-        if (selector instanceof InvalidSelector) {
-            return selector;
-        }
-        sequenceSelectors.push(selector);
-    }
-    return new SimpleSelectorSequence(sequenceSelectors);
-}
-function createSelectorFromAst(asts) {
-    let result;
-    if (asts.length === 0) {
-        return new InvalidSelector(new Error('Empty selector.'));
-    }
-    if (asts.length === 1) {
-        return createSimpleSelectorFromAst(asts[0]);
-    }
-    const simpleSelectorSequences = [];
-    let sequenceAsts = [];
-    let combinatorCount = 0;
-    for (const ast of asts) {
-        const combinator = Combinator[ast.type];
-        // Combinator means the end of a sequence
-        if (combinator != null) {
-            const selector = createSimpleSelectorSequenceFromAst(sequenceAsts);
-            if (selector instanceof InvalidSelector) {
-                return selector;
-            }
-            selector.combinator = combinator;
-            simpleSelectorSequences.push(selector);
-            combinatorCount++;
-            // Cleanup stored selectors for the new sequence to take place
-            sequenceAsts = [];
-        }
-        else {
-            sequenceAsts.push(ast);
-        }
-    }
-    if (combinatorCount > 0) {
-        // Create a sequence using the remaining selectors after the last combinator
-        if (sequenceAsts.length) {
-            const selector = createSimpleSelectorSequenceFromAst(sequenceAsts);
-            if (selector instanceof InvalidSelector) {
-                return selector;
-            }
-            simpleSelectorSequences.push(selector);
-        }
-        return new ComplexSelector(simpleSelectorSequences);
-    }
-    return createSimpleSelectorSequenceFromAst(sequenceAsts);
-}
-export function createSelector(sel) {
-    try {
-        const result = convertToCSSWhatSelector(sel);
-        if (!result?.length) {
-            return new InvalidSelector(new Error('Empty selector'));
-        }
-        return createSelectorFromAst(result[0]);
-    }
-    catch (e) {
-        return new InvalidSelector(e);
-    }
-}
-function isDeclaration(node) {
-    return node.type === 'declaration';
-}
-export function matchMediaQueryString(mediaQueryString, cachedQueries) {
-    // It can be a single or multiple queries in case of nested media queries
-    const mediaQueryStrings = mediaQueryString.split(MEDIA_QUERY_SEPARATOR);
-    return mediaQueryStrings.every((mq) => {
-        let isMatching;
-        // Query has already been validated
-        if (cachedQueries.includes(mq)) {
-            isMatching = true;
-        }
-        else {
-            isMatching = checkIfMediaQueryMatches(mq);
-            if (isMatching) {
-                cachedQueries.push(mq);
-            }
-        }
-        return isMatching;
-    });
-}
-export class SelectorScope {
-    constructor() {
-        this.id = {};
-        this.class = {};
-        this.type = {};
-        this.universal = [];
-        this.position = 0;
-    }
-    getSelectorCandidates(node) {
-        const { cssClasses, id, cssType } = node;
-        const selectorClasses = [this.universal, this.id[id], this.type[cssType]];
-        if (cssClasses && cssClasses.size) {
-            cssClasses.forEach((c) => selectorClasses.push(this.class[c]));
-        }
-        return selectorClasses.reduce((cur, next) => cur.concat(next || []), []);
-    }
-    sortById(id, sel) {
-        this.addToMap(this.id, id, sel);
-    }
-    sortByClass(cssClass, sel) {
-        this.addToMap(this.class, cssClass, sel);
-    }
-    sortByType(cssType, sel) {
-        this.addToMap(this.type, cssType, sel);
-    }
-    sortAsUniversal(sel) {
-        this.universal.push(this.makeDocSelector(sel));
-    }
-    addToMap(map, head, sel) {
-        if (!map[head]) {
-            map[head] = [];
-        }
-        map[head].push(this.makeDocSelector(sel));
-    }
-    makeDocSelector(sel) {
-        sel.pos = this.position++;
-        return sel;
-    }
-}
-export class MediaQuerySelectorScope extends SelectorScope {
-    constructor(mediaQueryString) {
-        super();
-        this._mediaQueryString = mediaQueryString;
-    }
-    get mediaQueryString() {
-        return this._mediaQueryString;
-    }
-}
-export class StyleSheetSelectorScope extends SelectorScope {
-    constructor(rulesets) {
-        super();
-        this.lookupRulesets(rulesets);
-    }
-    createMediaQuerySelectorScope(mediaQueryString) {
-        const selectorScope = new MediaQuerySelectorScope(mediaQueryString);
-        selectorScope.position = this.position;
-        if (this.mediaQuerySelectorScopes) {
-            this.mediaQuerySelectorScopes.push(selectorScope);
-        }
-        else {
-            this.mediaQuerySelectorScopes = [selectorScope];
-        }
-        return selectorScope;
-    }
-    lookupRulesets(rulesets) {
-        let lastMediaSelectorScope;
-        for (let i = 0, length = rulesets.length; i < length; i++) {
-            const ruleset = rulesets[i];
-            if (lastMediaSelectorScope && lastMediaSelectorScope.mediaQueryString !== ruleset.mediaQueryString) {
-                // Once done with current media query scope, update stylesheet scope position
-                this.position = lastMediaSelectorScope.position;
-                lastMediaSelectorScope = null;
-            }
-            if (ruleset.mediaQueryString) {
-                // Create media query selector scope and register selector lookups there
-                if (!lastMediaSelectorScope) {
-                    lastMediaSelectorScope = this.createMediaQuerySelectorScope(ruleset.mediaQueryString);
-                }
-                ruleset.lookupSort(lastMediaSelectorScope);
-            }
-            else {
-                ruleset.lookupSort(this);
-            }
-        }
-        // If reference of last media selector scope is still kept, update stylesheet scope position
-        if (lastMediaSelectorScope) {
-            this.position = lastMediaSelectorScope.position;
-            lastMediaSelectorScope = null;
-        }
-    }
-    query(node) {
-        const selectorsMatch = new SelectorsMatch();
-        const selectors = this.getSelectorCandidates(node);
-        // Validate media queries and include their selectors if needed
-        if (this.mediaQuerySelectorScopes) {
-            // Cache media query results to avoid validations of other identical queries
-            const validatedMediaQueries = [];
-            for (let i = 0, length = this.mediaQuerySelectorScopes.length; i < length; i++) {
-                const selectorScope = this.mediaQuerySelectorScopes[i];
-                const isMatchingAllQueries = matchMediaQueryString(selectorScope.mediaQueryString, validatedMediaQueries);
-                if (isMatchingAllQueries) {
-                    const mediaQuerySelectors = selectorScope.getSelectorCandidates(node);
-                    selectors.push(...mediaQuerySelectors);
-                }
-            }
-        }
-        selectorsMatch.selectors = selectors.filter((sel) => sel.accumulateChanges(node, selectorsMatch)).sort((a, b) => a.specificity - b.specificity || a.pos - b.pos);
-        return selectorsMatch;
-    }
-}
-export class SelectorsMatch {
-    constructor() {
-        this.changeMap = new Map();
-    }
-    addAttribute(node, attribute) {
-        const deps = this.properties(node);
-        if (!deps.attributes) {
-            deps.attributes = new Set();
-        }
-        deps.attributes.add(attribute);
-    }
-    addPseudoClass(node, pseudoClass) {
-        const deps = this.properties(node);
-        if (!deps.pseudoClasses) {
-            deps.pseudoClasses = new Set();
-        }
-        deps.pseudoClasses.add(pseudoClass);
-    }
-    properties(node) {
-        let set = this.changeMap.get(node);
-        if (!set) {
-            this.changeMap.set(node, (set = {}));
-        }
-        return set;
-    }
-}
-export const CSSHelper = {
-    createSelector,
-    SelectorCore,
-    SimpleSelector,
-    InvalidSelector,
-    UniversalSelector,
-    TypeSelector,
-    ClassSelector,
-    AttributeSelector,
-    PseudoClassSelector,
-    SimpleSelectorSequence,
-    Selector,
-    RuleSet,
-    SelectorScope,
-    MediaQuerySelectorScope,
-    StyleSheetSelectorScope,
-    fromAstNode,
-    SelectorsMatch,
-};
-//# sourceMappingURL=css-selector.js.map