@nativescript/core 9.0.12-next.0 → 9.0.12-next.1

package/ui/styling/css-selector.js

@@ -0,0 +1,934 @@
+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