@nativescript/core 8.9.0-alpha.3 → 8.9.0-napi-es5.0

package/ui/styling/css-selector.js

@@ -3,7 +3,7 @@ import '../../globals';
 import { isCssVariable } from '../core/properties';
 import { isNullOrUndefined } from '../../utils/types';
 import { checkIfMediaQueryMatches } from '../../media-query-list';
-export const MEDIA_QUERY_SEPARATOR = '&&';
+export var MEDIA_QUERY_SEPARATOR = '&&';
 var Combinator;
 (function (Combinator) {
     Combinator["descendant"] = " ";
@@ -39,14 +39,14 @@ function eachNodePreviousGeneralSibling(node, callback) {
     if (!node.parent || !node.parent.getChildIndex || !node.parent.getChildAt || !node.parent.getChildrenCount) {
         return;
     }
-    const nodeIndex = node.parent.getChildIndex(node);
+    var 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);
+    var count = node.parent.getChildrenCount();
+    var retVal = true;
+    for (var i = nodeIndex - 1; i >= 0 && retVal; i--) {
+        var sibling = node.parent.getChildAt(i);
         retVal = callback(sibling);
     }
 }
@@ -54,14 +54,15 @@ function getNodePreviousDirectSibling(node) {
     if (!node.parent || !node.parent.getChildIndex || !node.parent.getChildAt) {
         return null;
     }
-    const nodeIndex = node.parent.getChildIndex(node);
+    var nodeIndex = node.parent.getChildIndex(node);
     if (nodeIndex === 0) {
         return null;
     }
     return node.parent.getChildAt(nodeIndex - 1);
 }
-function SelectorProperties(specificity, rarity, dynamic = false) {
-    return (cls) => {
+function SelectorProperties(specificity, rarity, dynamic) {
+    if (dynamic === void 0) { dynamic = false; }
+    return function (cls) {
         cls.prototype.specificity = specificity;
         cls.prototype.rarity = rarity;
         cls.prototype.combinator = undefined;
@@ -70,7 +71,7 @@ function SelectorProperties(specificity, rarity, dynamic = false) {
     };
 }
 function FunctionalPseudoClassProperties(specificity, rarity, pseudoSelectorListType) {
-    return (cls) => {
+    return function (cls) {
         cls.prototype.specificity = specificity;
         cls.prototype.rarity = rarity;
         cls.prototype.combinator = undefined;
@@ -79,19 +80,32 @@ function FunctionalPseudoClassProperties(specificity, rarity, pseudoSelectorList
         return cls;
     };
 }
-export class SelectorBase {
-}
-let SelectorCore = class SelectorCore extends SelectorBase {
-    lookupSort(sorter, base) {
+var SelectorBase = /** @class */ (function () {
+    function SelectorBase() {
+    }
+    return SelectorBase;
+}());
+export { SelectorBase };
+var SelectorCore = /** @class */ (function (_super) {
+    __extends(SelectorCore, _super);
+    function SelectorCore() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SelectorCore.prototype.lookupSort = function (sorter, base) {
         sorter.sortAsUniversal(base || this);
-    }
-};
-SelectorCore = __decorate([
-    SelectorProperties(0 /* Specificity.Universal */, 0 /* Rarity.Universal */, Match.Static)
-], SelectorCore);
+    };
+    SelectorCore = __decorate([
+        SelectorProperties(0 /* Specificity.Universal */, 0 /* Rarity.Universal */, Match.Static)
+    ], SelectorCore);
+    return SelectorCore;
+}(SelectorBase));
 export { SelectorCore };
-export class SimpleSelector extends SelectorCore {
-    accumulateChanges(node, map) {
+var SimpleSelector = /** @class */ (function (_super) {
+    __extends(SimpleSelector, _super);
+    function SimpleSelector() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SimpleSelector.prototype.accumulateChanges = function (node, map) {
         if (!this.dynamic) {
             return this.match(node);
         }
@@ -100,125 +114,147 @@ export class SimpleSelector extends SelectorCore {
             return true;
         }
         return false;
-    }
-    mayMatch(node) {
+    };
+    SimpleSelector.prototype.mayMatch = function (node) {
         return this.match(node);
-    }
-    trackChanges(node, map) {
+    };
+    SimpleSelector.prototype.trackChanges = function (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.
-    }
-}
+    };
+    return SimpleSelector;
+}(SelectorCore));
+export { SimpleSelector };
 function wrap(text) {
-    return text ? ` ${text} ` : '';
+    return text ? " ".concat(text, " ") : '';
 }
-let InvalidSelector = class InvalidSelector extends SimpleSelector {
-    constructor(e) {
-        super();
-        this.e = e;
-    }
-    toString() {
-        return `<${this.e}>`;
-    }
-    match(node) {
+var InvalidSelector = /** @class */ (function (_super) {
+    __extends(InvalidSelector, _super);
+    function InvalidSelector(e) {
+        var _this = _super.call(this) || this;
+        _this.e = e;
+        return _this;
+    }
+    InvalidSelector.prototype.toString = function () {
+        return "<".concat(this.e, ">");
+    };
+    InvalidSelector.prototype.match = function (node) {
         return false;
-    }
-    lookupSort(sorter, base) {
+    };
+    InvalidSelector.prototype.lookupSort = function (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);
+    };
+    InvalidSelector = __decorate([
+        SelectorProperties(0 /* Specificity.Invalid */, 4 /* Rarity.Invalid */, Match.Static),
+        __metadata("design:paramtypes", [Error])
+    ], InvalidSelector);
+    return InvalidSelector;
+}(SimpleSelector));
 export { InvalidSelector };
-let UniversalSelector = class UniversalSelector extends SimpleSelector {
-    toString() {
-        return `*${wrap(this.combinator)}`;
+var UniversalSelector = /** @class */ (function (_super) {
+    __extends(UniversalSelector, _super);
+    function UniversalSelector() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    match(node) {
+    UniversalSelector.prototype.toString = function () {
+        return "*".concat(wrap(this.combinator));
+    };
+    UniversalSelector.prototype.match = function (node) {
         return true;
-    }
-};
-UniversalSelector = __decorate([
-    SelectorProperties(0 /* Specificity.Universal */, 0 /* Rarity.Universal */, Match.Static)
-], UniversalSelector);
+    };
+    UniversalSelector = __decorate([
+        SelectorProperties(0 /* Specificity.Universal */, 0 /* Rarity.Universal */, Match.Static)
+    ], UniversalSelector);
+    return UniversalSelector;
+}(SimpleSelector));
 export { UniversalSelector };
-let IdSelector = class IdSelector extends SimpleSelector {
-    constructor(id) {
-        super();
-        this.id = id;
-    }
-    toString() {
-        return `#${this.id}${wrap(this.combinator)}`;
-    }
-    match(node) {
+var IdSelector = /** @class */ (function (_super) {
+    __extends(IdSelector, _super);
+    function IdSelector(id) {
+        var _this = _super.call(this) || this;
+        _this.id = id;
+        return _this;
+    }
+    IdSelector.prototype.toString = function () {
+        return "#".concat(this.id).concat(wrap(this.combinator));
+    };
+    IdSelector.prototype.match = function (node) {
         return node.id === this.id;
-    }
-    lookupSort(sorter, base) {
+    };
+    IdSelector.prototype.lookupSort = function (sorter, base) {
         sorter.sortById(this.id, base || this);
-    }
-};
-IdSelector = __decorate([
-    SelectorProperties(100 /* Specificity.Id */, 3 /* Rarity.Id */, Match.Static),
-    __metadata("design:paramtypes", [String])
-], IdSelector);
+    };
+    IdSelector = __decorate([
+        SelectorProperties(100 /* Specificity.Id */, 3 /* Rarity.Id */, Match.Static),
+        __metadata("design:paramtypes", [String])
+    ], IdSelector);
+    return IdSelector;
+}(SimpleSelector));
 export { IdSelector };
-let TypeSelector = class TypeSelector extends SimpleSelector {
-    constructor(cssType) {
-        super();
-        this.cssType = cssType;
-    }
-    toString() {
-        return `${this.cssType}${wrap(this.combinator)}`;
-    }
-    match(node) {
+var TypeSelector = /** @class */ (function (_super) {
+    __extends(TypeSelector, _super);
+    function TypeSelector(cssType) {
+        var _this = _super.call(this) || this;
+        _this.cssType = cssType;
+        return _this;
+    }
+    TypeSelector.prototype.toString = function () {
+        return "".concat(this.cssType).concat(wrap(this.combinator));
+    };
+    TypeSelector.prototype.match = function (node) {
         return node.cssType === this.cssType;
-    }
-    lookupSort(sorter, base) {
+    };
+    TypeSelector.prototype.lookupSort = function (sorter, base) {
         sorter.sortByType(this.cssType, base || this);
-    }
-};
-TypeSelector = __decorate([
-    SelectorProperties(1 /* Specificity.Type */, 1 /* Rarity.Type */, Match.Static),
-    __metadata("design:paramtypes", [String])
-], TypeSelector);
+    };
+    TypeSelector = __decorate([
+        SelectorProperties(1 /* Specificity.Type */, 1 /* Rarity.Type */, Match.Static),
+        __metadata("design:paramtypes", [String])
+    ], TypeSelector);
+    return TypeSelector;
+}(SimpleSelector));
 export { TypeSelector };
-let ClassSelector = class ClassSelector extends SimpleSelector {
-    constructor(cssClass) {
-        super();
-        this.cssClass = cssClass;
-    }
-    toString() {
-        return `.${this.cssClass}${wrap(this.combinator)}`;
-    }
-    match(node) {
+var ClassSelector = /** @class */ (function (_super) {
+    __extends(ClassSelector, _super);
+    function ClassSelector(cssClass) {
+        var _this = _super.call(this) || this;
+        _this.cssClass = cssClass;
+        return _this;
+    }
+    ClassSelector.prototype.toString = function () {
+        return ".".concat(this.cssClass).concat(wrap(this.combinator));
+    };
+    ClassSelector.prototype.match = function (node) {
         return node.cssClasses && node.cssClasses.has(this.cssClass);
-    }
-    lookupSort(sorter, base) {
+    };
+    ClassSelector.prototype.lookupSort = function (sorter, base) {
         sorter.sortByClass(this.cssClass, base || this);
-    }
-};
-ClassSelector = __decorate([
-    SelectorProperties(10 /* Specificity.Class */, 2 /* Rarity.Class */, Match.Static),
-    __metadata("design:paramtypes", [String])
-], ClassSelector);
+    };
+    ClassSelector = __decorate([
+        SelectorProperties(10 /* Specificity.Class */, 2 /* Rarity.Class */, Match.Static),
+        __metadata("design:paramtypes", [String])
+    ], ClassSelector);
+    return ClassSelector;
+}(SimpleSelector));
 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];
+var AttributeSelector = /** @class */ (function (_super) {
+    __extends(AttributeSelector, _super);
+    function AttributeSelector(attribute, test, value, ignoreCase) {
+        var _this = _super.call(this) || this;
+        _this.attribute = attribute;
+        _this.test = test;
+        _this.value = value;
+        _this.ignoreCase = ignoreCase;
+        return _this;
+    }
+    AttributeSelector.prototype.toString = function () {
+        var _a;
+        return "[".concat(this.attribute).concat(wrap((_a = AttributeSelectorOperator[this.test]) !== null && _a !== void 0 ? _a : this.test)).concat(this.value || '', "]").concat(wrap(this.combinator));
+    };
+    AttributeSelector.prototype.match = function (node) {
+        var attr = node[this.attribute];
         if (this.test === 'exists') {
             return !isNullOrUndefined(attr);
         }
@@ -249,7 +285,7 @@ let AttributeSelector = class AttributeSelector extends SimpleSelector {
         }
         // ~=
         if (this.test === 'element') {
-            const words = attr.split(' ');
+            var words = attr.split(' ');
             return words && words.indexOf(this.value) !== -1;
         }
         // |=
@@ -257,54 +293,60 @@ let AttributeSelector = class AttributeSelector extends SimpleSelector {
             return attr === this.value || attr.startsWith(this.value + '-');
         }
         return false;
-    }
-    mayMatch(node) {
+    };
+    AttributeSelector.prototype.mayMatch = function (node) {
         return true;
-    }
-    trackChanges(node, map) {
+    };
+    AttributeSelector.prototype.trackChanges = function (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);
+    };
+    AttributeSelector = __decorate([
+        SelectorProperties(10 /* Specificity.Attribute */, 0 /* Rarity.Attribute */, Match.Dynamic),
+        __metadata("design:paramtypes", [String, String, String, Boolean])
+    ], AttributeSelector);
+    return AttributeSelector;
+}(SimpleSelector));
 export { AttributeSelector };
-let PseudoClassSelector = class PseudoClassSelector extends SimpleSelector {
-    constructor(cssPseudoClass) {
-        super();
-        this.cssPseudoClass = cssPseudoClass;
-    }
-    toString() {
-        return `:${this.cssPseudoClass}${wrap(this.combinator)}`;
-    }
-    match(node) {
+var PseudoClassSelector = /** @class */ (function (_super) {
+    __extends(PseudoClassSelector, _super);
+    function PseudoClassSelector(cssPseudoClass) {
+        var _this = _super.call(this) || this;
+        _this.cssPseudoClass = cssPseudoClass;
+        return _this;
+    }
+    PseudoClassSelector.prototype.toString = function () {
+        return ":".concat(this.cssPseudoClass).concat(wrap(this.combinator));
+    };
+    PseudoClassSelector.prototype.match = function (node) {
         return node.cssPseudoClasses && node.cssPseudoClasses.has(this.cssPseudoClass);
-    }
-    mayMatch(node) {
+    };
+    PseudoClassSelector.prototype.mayMatch = function (node) {
         return true;
-    }
-    trackChanges(node, map) {
+    };
+    PseudoClassSelector.prototype.trackChanges = function (node, map) {
         map.addPseudoClass(node, this.cssPseudoClass);
-    }
-};
-PseudoClassSelector = __decorate([
-    SelectorProperties(10 /* Specificity.PseudoClass */, 0 /* Rarity.PseudoClass */, Match.Dynamic),
-    __metadata("design:paramtypes", [String])
-], PseudoClassSelector);
+    };
+    PseudoClassSelector = __decorate([
+        SelectorProperties(10 /* Specificity.PseudoClass */, 0 /* Rarity.PseudoClass */, Match.Dynamic),
+        __metadata("design:paramtypes", [String])
+    ], PseudoClassSelector);
+    return PseudoClassSelector;
+}(SimpleSelector));
 export { PseudoClassSelector };
-export class FunctionalPseudoClassSelector extends PseudoClassSelector {
-    constructor(cssPseudoClass, dataType) {
-        super(cssPseudoClass);
-        const selectors = [];
-        const needsHighestSpecificity = this.specificity === -1 /* Specificity.SelectorListHighest */;
-        let specificity = 0;
+var FunctionalPseudoClassSelector = /** @class */ (function (_super) {
+    __extends(FunctionalPseudoClassSelector, _super);
+    function FunctionalPseudoClassSelector(cssPseudoClass, dataType) {
+        var _this = _super.call(this, cssPseudoClass) || this;
+        var selectors = [];
+        var needsHighestSpecificity = _this.specificity === -1 /* Specificity.SelectorListHighest */;
+        var specificity = 0;
         if (Array.isArray(dataType)) {
-            for (const asts of dataType) {
-                const selector = createSelectorFromAst(asts);
+            for (var _i = 0, dataType_1 = dataType; _i < dataType_1.length; _i++) {
+                var asts = dataType_1[_i];
+                var selector = createSelectorFromAst(asts);
                 if (selector instanceof InvalidSelector) {
                     // Only forgiving selector list can ignore invalid selectors
-                    if (this.selectorListType !== 1 /* PseudoClassSelectorList.Forgiving */) {
+                    if (_this.selectorListType !== 1 /* PseudoClassSelectorList.Forgiving */) {
                         selectors.splice(0);
                         specificity = 0;
                         break;
@@ -318,104 +360,127 @@ export class FunctionalPseudoClassSelector extends PseudoClassSelector {
                 selectors.push(selector);
             }
         }
-        this.selectors = selectors;
-        this.specificity = specificity;
+        _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);
+        _this.dynamic = _this.selectors.some(function (sel) { return sel.dynamic; });
+        return _this;
     }
-    toString() {
-        return `:${this.cssPseudoClass}(${this.selectors.join(', ')})${wrap(this.combinator)}`;
-    }
-    match(node) {
+    FunctionalPseudoClassSelector.prototype.toString = function () {
+        return ":".concat(this.cssPseudoClass, "(").concat(this.selectors.join(', '), ")").concat(wrap(this.combinator));
+    };
+    FunctionalPseudoClassSelector.prototype.match = function (node) {
         return false;
-    }
-    mayMatch(node) {
+    };
+    FunctionalPseudoClassSelector.prototype.mayMatch = function (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);
+    };
+    FunctionalPseudoClassSelector.prototype.trackChanges = function (node, map) {
+        this.selectors.forEach(function (sel) { return sel.trackChanges(node, map); });
+    };
+    return FunctionalPseudoClassSelector;
+}(PseudoClassSelector));
+export { FunctionalPseudoClassSelector };
+var NotFunctionalPseudoClassSelector = /** @class */ (function (_super) {
+    __extends(NotFunctionalPseudoClassSelector, _super);
+    function NotFunctionalPseudoClassSelector() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NotFunctionalPseudoClassSelector.prototype.match = function (node) {
+        return !this.selectors.some(function (sel) { return sel.match(node); });
+    };
+    NotFunctionalPseudoClassSelector = __decorate([
+        FunctionalPseudoClassProperties(-1 /* Specificity.SelectorListHighest */, 0 /* Rarity.PseudoClass */, 0 /* PseudoClassSelectorList.Regular */)
+    ], NotFunctionalPseudoClassSelector);
+    return NotFunctionalPseudoClassSelector;
+}(FunctionalPseudoClassSelector));
 export { NotFunctionalPseudoClassSelector };
-let IsFunctionalPseudoClassSelector = class IsFunctionalPseudoClassSelector extends FunctionalPseudoClassSelector {
-    match(node) {
-        return this.selectors.some((sel) => sel.match(node));
+var IsFunctionalPseudoClassSelector = /** @class */ (function (_super) {
+    __extends(IsFunctionalPseudoClassSelector, _super);
+    function IsFunctionalPseudoClassSelector() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    lookupSort(sorter, base) {
+    IsFunctionalPseudoClassSelector.prototype.match = function (node) {
+        return this.selectors.some(function (sel) { return sel.match(node); });
+    };
+    IsFunctionalPseudoClassSelector.prototype.lookupSort = function (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);
+            _super.prototype.lookupSort.call(this, sorter, base || this);
         }
-    }
-};
-IsFunctionalPseudoClassSelector = __decorate([
-    FunctionalPseudoClassProperties(-1 /* Specificity.SelectorListHighest */, 0 /* Rarity.PseudoClass */, 1 /* PseudoClassSelectorList.Forgiving */)
-], IsFunctionalPseudoClassSelector);
+    };
+    IsFunctionalPseudoClassSelector = __decorate([
+        FunctionalPseudoClassProperties(-1 /* Specificity.SelectorListHighest */, 0 /* Rarity.PseudoClass */, 1 /* PseudoClassSelectorList.Forgiving */)
+    ], IsFunctionalPseudoClassSelector);
+    return IsFunctionalPseudoClassSelector;
+}(FunctionalPseudoClassSelector));
 export { IsFunctionalPseudoClassSelector };
-let WhereFunctionalPseudoClassSelector = class WhereFunctionalPseudoClassSelector extends FunctionalPseudoClassSelector {
-    match(node) {
-        return this.selectors.some((sel) => sel.match(node));
+var WhereFunctionalPseudoClassSelector = /** @class */ (function (_super) {
+    __extends(WhereFunctionalPseudoClassSelector, _super);
+    function WhereFunctionalPseudoClassSelector() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    lookupSort(sorter, base) {
+    WhereFunctionalPseudoClassSelector.prototype.match = function (node) {
+        return this.selectors.some(function (sel) { return sel.match(node); });
+    };
+    WhereFunctionalPseudoClassSelector.prototype.lookupSort = function (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);
+            _super.prototype.lookupSort.call(this, sorter, base || this);
         }
-    }
-};
-WhereFunctionalPseudoClassSelector = __decorate([
-    FunctionalPseudoClassProperties(0 /* Specificity.Zero */, 0 /* Rarity.PseudoClass */, 1 /* PseudoClassSelectorList.Forgiving */)
-], WhereFunctionalPseudoClassSelector);
+    };
+    WhereFunctionalPseudoClassSelector = __decorate([
+        FunctionalPseudoClassProperties(0 /* Specificity.Zero */, 0 /* Rarity.PseudoClass */, 1 /* PseudoClassSelectorList.Forgiving */)
+    ], WhereFunctionalPseudoClassSelector);
+    return WhereFunctionalPseudoClassSelector;
+}(FunctionalPseudoClassSelector));
 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) {
+var SimpleSelectorSequence = /** @class */ (function (_super) {
+    __extends(SimpleSelectorSequence, _super);
+    function SimpleSelectorSequence(selectors) {
+        var _this = _super.call(this) || this;
+        _this.selectors = selectors;
+        _this.specificity = selectors.reduce(function (sum, sel) { return sel.specificity + sum; }, 0);
+        _this.head = selectors.reduce(function (prev, curr) { return (!prev || curr.rarity > prev.rarity ? curr : prev); }, null);
+        _this.dynamic = selectors.some(function (sel) { return sel.dynamic; });
+        return _this;
+    }
+    SimpleSelectorSequence.prototype.toString = function () {
+        return "".concat(this.selectors.join('')).concat(wrap(this.combinator));
+    };
+    SimpleSelectorSequence.prototype.match = function (node) {
+        return this.selectors.every(function (sel) { return sel.match(node); });
+    };
+    SimpleSelectorSequence.prototype.mayMatch = function (node) {
+        return this.selectors.every(function (sel) { return sel.mayMatch(node); });
+    };
+    SimpleSelectorSequence.prototype.trackChanges = function (node, map) {
+        this.selectors.forEach(function (sel) { return sel.trackChanges(node, map); });
+    };
+    SimpleSelectorSequence.prototype.lookupSort = function (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];
+    };
+    return SimpleSelectorSequence;
+}(SimpleSelector));
+export { SimpleSelectorSequence };
+var ComplexSelector = /** @class */ (function (_super) {
+    __extends(ComplexSelector, _super);
+    function ComplexSelector(selectors) {
+        var _this = _super.call(this) || this;
+        _this.selectors = selectors;
+        var siblingsToGroup;
+        var currentGroup;
+        var groups = [];
+        _this.specificity = 0;
+        _this.dynamic = false;
+        for (var i = selectors.length - 1; i >= 0; i--) {
+            var sel = selectors[i];
             switch (sel.combinator) {
                 case undefined:
                 case Combinator.descendant:
@@ -431,29 +496,31 @@ export class ComplexSelector extends SelectorCore {
                 case Combinator.sibling:
                     break;
                 default:
-                    throw new Error(`Unsupported combinator "${sel.combinator}" for selector ${sel}.`);
+                    throw new Error("Unsupported combinator \"".concat(sel.combinator, "\" for selector ").concat(sel, "."));
             }
-            this.specificity += sel.specificity;
+            _this.specificity += sel.specificity;
             if (sel.dynamic) {
-                this.dynamic = true;
+                _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];
+        _this.groups = groups.map(function (g) { return new Selector.ChildGroup(g.map(function (selectors) { return (selectors.length > 1 ? new Selector.SiblingGroup(selectors) : selectors[0]); })); });
+        _this.last = selectors[selectors.length - 1];
+        return _this;
     }
-    toString() {
+    ComplexSelector.prototype.toString = function () {
         return this.selectors.join('');
-    }
-    match(node) {
-        return this.groups.every((group, i) => {
+    };
+    ComplexSelector.prototype.match = function (node) {
+        return this.groups.every(function (group, i) {
+            var _a;
             if (i === 0) {
                 node = group.getMatchingNode(node, true);
                 return !!node;
             }
             else {
-                let ancestor = node;
-                while ((ancestor = ancestor.parent ?? ancestor._modalParent)) {
+                var ancestor = node;
+                while ((ancestor = (_a = ancestor.parent) !== null && _a !== void 0 ? _a : ancestor._modalParent)) {
                     if ((node = group.getMatchingNode(ancestor, true))) {
                         return true;
                     }
@@ -461,32 +528,32 @@ export class ComplexSelector extends SelectorCore {
                 return false;
             }
         });
-    }
-    mayMatch(node) {
+    };
+    ComplexSelector.prototype.mayMatch = function (node) {
         return false;
-    }
-    trackChanges(node, map) {
-        this.selectors.forEach((sel) => sel.trackChanges(node, map));
-    }
-    lookupSort(sorter, base) {
+    };
+    ComplexSelector.prototype.trackChanges = function (node, map) {
+        this.selectors.forEach(function (sel) { return sel.trackChanges(node, map); });
+    };
+    ComplexSelector.prototype.lookupSort = function (sorter, base) {
         this.last.lookupSort(sorter, base || this);
-    }
-    accumulateChanges(node, map) {
+    };
+    ComplexSelector.prototype.accumulateChanges = function (node, map) {
         if (!this.dynamic) {
             return this.match(node);
         }
-        const bounds = [];
-        const mayMatch = this.groups.every((group, i) => {
+        var bounds = [];
+        var mayMatch = this.groups.every(function (group, i) {
             if (i === 0) {
-                const nextNode = group.getMatchingNode(node, false);
+                var nextNode = group.getMatchingNode(node, false);
                 bounds.push({ left: node, right: node });
                 node = nextNode;
                 return !!node;
             }
             else {
-                let ancestor = node;
+                var ancestor = node;
                 while ((ancestor = ancestor.parent)) {
-                    const nextNode = group.getMatchingNode(ancestor, false);
+                    var nextNode = group.getMatchingNode(ancestor, false);
                     if (nextNode) {
                         bounds.push({ left: ancestor, right: null });
                         node = nextNode;
@@ -503,43 +570,47 @@ export class ComplexSelector extends SelectorCore {
         if (!map) {
             return mayMatch;
         }
-        for (let i = 0; i < this.groups.length; i++) {
-            const group = this.groups[i];
-            if (!group.dynamic) {
+        for (var i = 0; i < this.groups.length; i++) {
+            var group_1 = this.groups[i];
+            if (!group_1.dynamic) {
                 continue;
             }
-            const bound = bounds[i];
-            let node = bound.left;
+            var bound = bounds[i];
+            var node_1 = bound.left;
             do {
-                if (group.mayMatch(node)) {
-                    group.trackChanges(node, map);
+                if (group_1.mayMatch(node_1)) {
+                    group_1.trackChanges(node_1, map);
                 }
-            } while (node !== bound.right && (node = node.parent));
+            } while (node_1 !== bound.right && (node_1 = node_1.parent));
         }
         return mayMatch;
-    }
-}
+    };
+    return ComplexSelector;
+}(SelectorCore));
+export { ComplexSelector };
 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;
+    var ChildGroup = /** @class */ (function (_super) {
+        __extends(ChildGroup, _super);
+        function ChildGroup(selectors) {
+            var _this = _super.call(this) || this;
+            _this.selectors = selectors;
+            _this.dynamic = selectors.some(function (sel) { return sel.dynamic; });
+            return _this;
         }
-        match(node) {
+        ChildGroup.prototype.getMatchingNode = function (node, strict) {
+            var funcName = strict ? 'match' : 'mayMatch';
+            return this.selectors.every(function (sel, i) { return (node = i === 0 ? node : node.parent) && sel[funcName](node); }) ? node : null;
+        };
+        ChildGroup.prototype.match = function (node) {
             return this.getMatchingNode(node, true) != null;
-        }
-        mayMatch(node) {
+        };
+        ChildGroup.prototype.mayMatch = function (node) {
             return this.getMatchingNode(node, false) != null;
-        }
-        trackChanges(node, map) {
-            this.selectors.forEach((sel, i) => {
+        };
+        ChildGroup.prototype.trackChanges = function (node, map) {
+            this.selectors.forEach(function (sel, i) {
                 if (i === 0) {
                     node && sel.trackChanges(node, map);
                 }
@@ -550,17 +621,20 @@ export var Selector;
                     }
                 }
             });
-        }
-    }
+        };
+        return ChildGroup;
+    }(SelectorBase));
     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) => {
+    var SiblingGroup = /** @class */ (function (_super) {
+        __extends(SiblingGroup, _super);
+        function SiblingGroup(selectors) {
+            var _this = _super.call(this) || this;
+            _this.selectors = selectors;
+            _this.dynamic = selectors.some(function (sel) { return sel.dynamic; });
+            return _this;
+        }
+        SiblingGroup.prototype.match = function (node) {
+            return this.selectors.every(function (sel, i) {
                 if (i === 0) {
                     return node && sel.match(node);
                 }
@@ -569,16 +643,16 @@ export var Selector;
                     return node && sel.match(node);
                 }
                 // Sibling combinator
-                let isMatching = false;
-                eachNodePreviousGeneralSibling(node, (sibling) => {
+                var isMatching = false;
+                eachNodePreviousGeneralSibling(node, function (sibling) {
                     isMatching = sel.match(sibling);
                     return !isMatching;
                 });
                 return isMatching;
             });
-        }
-        mayMatch(node) {
-            return this.selectors.every((sel, i) => {
+        };
+        SiblingGroup.prototype.mayMatch = function (node) {
+            return this.selectors.every(function (sel, i) {
                 if (i === 0) {
                     return node && sel.mayMatch(node);
                 }
@@ -587,16 +661,16 @@ export var Selector;
                     return node && sel.mayMatch(node);
                 }
                 // Sibling combinator
-                let isMatching = false;
-                eachNodePreviousGeneralSibling(node, (sibling) => {
+                var isMatching = false;
+                eachNodePreviousGeneralSibling(node, function (sibling) {
                     isMatching = sel.mayMatch(sibling);
                     return !isMatching;
                 });
                 return isMatching;
             });
-        }
-        trackChanges(node, map) {
-            this.selectors.forEach((sel, i) => {
+        };
+        SiblingGroup.prototype.trackChanges = function (node, map) {
+            this.selectors.forEach(function (sel, i) {
                 if (i === 0) {
                     if (node) {
                         sel.trackChanges(node, map);
@@ -611,44 +685,48 @@ export var Selector;
                     }
                     else {
                         // Sibling combinator
-                        let matchingSibling;
-                        eachNodePreviousGeneralSibling(node, (sibling) => {
-                            const isMatching = sel.mayMatch(sibling);
+                        var matchingSibling_1;
+                        eachNodePreviousGeneralSibling(node, function (sibling) {
+                            var isMatching = sel.mayMatch(sibling);
                             if (isMatching) {
-                                matchingSibling = sibling;
+                                matchingSibling_1 = sibling;
                             }
                             return !isMatching;
                         });
-                        if (matchingSibling) {
-                            sel.trackChanges(matchingSibling, map);
+                        if (matchingSibling_1) {
+                            sel.trackChanges(matchingSibling_1, map);
                         }
                     }
                 }
             });
-        }
-    }
+        };
+        return SiblingGroup;
+    }(SelectorBase));
     Selector.SiblingGroup = SiblingGroup;
 })(Selector || (Selector = {}));
-export class RuleSet {
-    constructor(selectors, declarations) {
+var RuleSet = /** @class */ (function () {
+    function RuleSet(selectors, declarations) {
+        var _this = this;
         this.selectors = selectors;
         this.declarations = declarations;
-        this.selectors.forEach((sel) => (sel.ruleset = this));
+        this.selectors.forEach(function (sel) { return (sel.ruleset = _this); });
     }
-    toString() {
-        let desc = `${this.selectors.join(', ')} {${this.declarations.map((d, i) => `${i === 0 ? ' ' : ''}${d.property}: ${d.value}`).join('; ')} }`;
+    RuleSet.prototype.toString = function () {
+        var desc = "".concat(this.selectors.join(', '), " {").concat(this.declarations.map(function (d, i) { return "".concat(i === 0 ? ' ' : '').concat(d.property, ": ").concat(d.value); }).join('; '), " }");
         if (this.mediaQueryString) {
-            desc = `@media ${this.mediaQueryString} { ${desc} }`;
+            desc = "@media ".concat(this.mediaQueryString, " { ").concat(desc, " }");
         }
         return desc;
-    }
-    lookupSort(sorter) {
-        this.selectors.forEach((sel) => sel.lookupSort(sorter));
-    }
-}
+    };
+    RuleSet.prototype.lookupSort = function (sorter) {
+        this.selectors.forEach(function (sel) { return sel.lookupSort(sorter); });
+    };
+    return RuleSet;
+}());
+export { RuleSet };
 export function fromAstNode(astRule) {
-    const declarations = astRule.declarations.filter(isDeclaration).map(createDeclaration);
-    const selectors = astRule.selectors.map(createSelector);
+    var declarations = astRule.declarations.filter(isDeclaration).map(createDeclaration);
+    var selectors = astRule.selectors.map(createSelector);
     return new RuleSet(selectors, declarations);
 }
 function createDeclaration(decl) {
@@ -691,9 +769,10 @@ function createSimpleSelectorSequenceFromAst(asts) {
     if (asts.length === 1) {
         return createSimpleSelectorFromAst(asts[0]);
     }
-    const sequenceSelectors = [];
-    for (const ast of asts) {
-        const selector = createSimpleSelectorFromAst(ast);
+    var sequenceSelectors = [];
+    for (var _i = 0, asts_1 = asts; _i < asts_1.length; _i++) {
+        var ast = asts_1[_i];
+        var selector = createSimpleSelectorFromAst(ast);
         if (selector instanceof InvalidSelector) {
             return selector;
         }
@@ -702,21 +781,22 @@ function createSimpleSelectorSequenceFromAst(asts) {
     return new SimpleSelectorSequence(sequenceSelectors);
 }
 function createSelectorFromAst(asts) {
-    let result;
+    var 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];
+    var simpleSelectorSequences = [];
+    var sequenceAsts = [];
+    var combinatorCount = 0;
+    for (var _i = 0, asts_2 = asts; _i < asts_2.length; _i++) {
+        var ast = asts_2[_i];
+        var combinator = Combinator[ast.type];
         // Combinator means the end of a sequence
         if (combinator != null) {
-            const selector = createSimpleSelectorSequenceFromAst(sequenceAsts);
+            var selector = createSimpleSelectorSequenceFromAst(sequenceAsts);
             if (selector instanceof InvalidSelector) {
                 return selector;
             }
@@ -733,7 +813,7 @@ function createSelectorFromAst(asts) {
     if (combinatorCount > 0) {
         // Create a sequence using the remaining selectors after the last combinator
         if (sequenceAsts.length) {
-            const selector = createSimpleSelectorSequenceFromAst(sequenceAsts);
+            var selector = createSimpleSelectorSequenceFromAst(sequenceAsts);
             if (selector instanceof InvalidSelector) {
                 return selector;
             }
@@ -745,8 +825,8 @@ function createSelectorFromAst(asts) {
 }
 export function createSelector(sel) {
     try {
-        const result = convertToCSSWhatSelector(sel);
-        if (!result?.length) {
+        var result = convertToCSSWhatSelector(sel);
+        if (!(result === null || result === void 0 ? void 0 : result.length)) {
             return new InvalidSelector(new Error('Empty selector'));
         }
         return createSelectorFromAst(result[0]);
@@ -760,9 +840,9 @@ function isDeclaration(node) {
 }
 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;
+    var mediaQueryStrings = mediaQueryString.split(MEDIA_QUERY_SEPARATOR);
+    return mediaQueryStrings.every(function (mq) {
+        var isMatching;
         // Query has already been validated
         if (cachedQueries.includes(mq)) {
             isMatching = true;
@@ -776,61 +856,74 @@ export function matchMediaQueryString(mediaQueryString, cachedQueries) {
         return isMatching;
     });
 }
-export class SelectorScope {
-    constructor() {
+var SelectorScope = /** @class */ (function () {
+    function SelectorScope() {
         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]];
+    SelectorScope.prototype.getSelectorCandidates = function (node) {
+        var _this = this;
+        var cssClasses = node.cssClasses, id = node.id, cssType = node.cssType;
+        var selectorClasses = [this.universal, this.id[id], this.type[cssType]];
         if (cssClasses && cssClasses.size) {
-            cssClasses.forEach((c) => selectorClasses.push(this.class[c]));
+            cssClasses.forEach(function (c) { return selectorClasses.push(_this.class[c]); });
         }
-        return selectorClasses.reduce((cur, next) => cur.concat(next || []), []);
-    }
-    sortById(id, sel) {
+        return selectorClasses.reduce(function (cur, next) { return cur.concat(next || []); }, []);
+    };
+    SelectorScope.prototype.sortById = function (id, sel) {
         this.addToMap(this.id, id, sel);
-    }
-    sortByClass(cssClass, sel) {
+    };
+    SelectorScope.prototype.sortByClass = function (cssClass, sel) {
         this.addToMap(this.class, cssClass, sel);
-    }
-    sortByType(cssType, sel) {
+    };
+    SelectorScope.prototype.sortByType = function (cssType, sel) {
         this.addToMap(this.type, cssType, sel);
-    }
-    sortAsUniversal(sel) {
+    };
+    SelectorScope.prototype.sortAsUniversal = function (sel) {
         this.universal.push(this.makeDocSelector(sel));
-    }
-    addToMap(map, head, sel) {
+    };
+    SelectorScope.prototype.addToMap = function (map, head, sel) {
         if (!map[head]) {
             map[head] = [];
         }
         map[head].push(this.makeDocSelector(sel));
-    }
-    makeDocSelector(sel) {
+    };
+    SelectorScope.prototype.makeDocSelector = function (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);
+    };
+    return SelectorScope;
+}());
+export { SelectorScope };
+var MediaQuerySelectorScope = /** @class */ (function (_super) {
+    __extends(MediaQuerySelectorScope, _super);
+    function MediaQuerySelectorScope(mediaQueryString) {
+        var _this = _super.call(this) || this;
+        _this._mediaQueryString = mediaQueryString;
+        return _this;
+    }
+    Object.defineProperty(MediaQuerySelectorScope.prototype, "mediaQueryString", {
+        get: function () {
+            return this._mediaQueryString;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return MediaQuerySelectorScope;
+}(SelectorScope));
+export { MediaQuerySelectorScope };
+var StyleSheetSelectorScope = /** @class */ (function (_super) {
+    __extends(StyleSheetSelectorScope, _super);
+    function StyleSheetSelectorScope(rulesets) {
+        var _this = _super.call(this) || this;
+        _this.lookupRulesets(rulesets);
+        return _this;
+    }
+    StyleSheetSelectorScope.prototype.createMediaQuerySelectorScope = function (mediaQueryString) {
+        var selectorScope = new MediaQuerySelectorScope(mediaQueryString);
         selectorScope.position = this.position;
         if (this.mediaQuerySelectorScopes) {
             this.mediaQuerySelectorScopes.push(selectorScope);
@@ -839,11 +932,11 @@ export class StyleSheetSelectorScope extends SelectorScope {
             this.mediaQuerySelectorScopes = [selectorScope];
         }
         return selectorScope;
-    }
-    lookupRulesets(rulesets) {
-        let lastMediaSelectorScope;
-        for (let i = 0, length = rulesets.length; i < length; i++) {
-            const ruleset = rulesets[i];
+    };
+    StyleSheetSelectorScope.prototype.lookupRulesets = function (rulesets) {
+        var lastMediaSelectorScope;
+        for (var i = 0, length_1 = rulesets.length; i < length_1; i++) {
+            var ruleset = rulesets[i];
             if (lastMediaSelectorScope && lastMediaSelectorScope.mediaQueryString !== ruleset.mediaQueryString) {
                 // Once done with current media query scope, update stylesheet scope position
                 this.position = lastMediaSelectorScope.position;
@@ -865,70 +958,74 @@ export class StyleSheetSelectorScope extends SelectorScope {
             this.position = lastMediaSelectorScope.position;
             lastMediaSelectorScope = null;
         }
-    }
-    query(node) {
-        const selectorsMatch = new SelectorsMatch();
-        const selectors = this.getSelectorCandidates(node);
+    };
+    StyleSheetSelectorScope.prototype.query = function (node) {
+        var selectorsMatch = new SelectorsMatch();
+        var 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);
+            var validatedMediaQueries = [];
+            for (var i = 0, length_2 = this.mediaQuerySelectorScopes.length; i < length_2; i++) {
+                var selectorScope = this.mediaQuerySelectorScopes[i];
+                var isMatchingAllQueries = matchMediaQueryString(selectorScope.mediaQueryString, validatedMediaQueries);
                 if (isMatchingAllQueries) {
-                    const mediaQuerySelectors = selectorScope.getSelectorCandidates(node);
-                    selectors.push(...mediaQuerySelectors);
+                    var mediaQuerySelectors = selectorScope.getSelectorCandidates(node);
+                    selectors.push.apply(selectors, mediaQuerySelectors);
                 }
             }
         }
-        selectorsMatch.selectors = selectors.filter((sel) => sel.accumulateChanges(node, selectorsMatch)).sort((a, b) => a.specificity - b.specificity || a.pos - b.pos);
+        selectorsMatch.selectors = selectors.filter(function (sel) { return sel.accumulateChanges(node, selectorsMatch); }).sort(function (a, b) { return a.specificity - b.specificity || a.pos - b.pos; });
         return selectorsMatch;
-    }
-}
-export class SelectorsMatch {
-    constructor() {
+    };
+    return StyleSheetSelectorScope;
+}(SelectorScope));
+export { StyleSheetSelectorScope };
+var SelectorsMatch = /** @class */ (function () {
+    function SelectorsMatch() {
         this.changeMap = new Map();
     }
-    addAttribute(node, attribute) {
-        const deps = this.properties(node);
+    SelectorsMatch.prototype.addAttribute = function (node, attribute) {
+        var deps = this.properties(node);
         if (!deps.attributes) {
             deps.attributes = new Set();
         }
         deps.attributes.add(attribute);
-    }
-    addPseudoClass(node, pseudoClass) {
-        const deps = this.properties(node);
+    };
+    SelectorsMatch.prototype.addPseudoClass = function (node, pseudoClass) {
+        var deps = this.properties(node);
         if (!deps.pseudoClasses) {
             deps.pseudoClasses = new Set();
         }
         deps.pseudoClasses.add(pseudoClass);
-    }
-    properties(node) {
-        let set = this.changeMap.get(node);
+    };
+    SelectorsMatch.prototype.properties = function (node) {
+        var 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,
+    };
+    return SelectorsMatch;
+}());
+export { SelectorsMatch };
+export var CSSHelper = {
+    createSelector: createSelector,
+    SelectorCore: SelectorCore,
+    SimpleSelector: SimpleSelector,
+    InvalidSelector: InvalidSelector,
+    UniversalSelector: UniversalSelector,
+    TypeSelector: TypeSelector,
+    ClassSelector: ClassSelector,
+    AttributeSelector: AttributeSelector,
+    PseudoClassSelector: PseudoClassSelector,
+    SimpleSelectorSequence: SimpleSelectorSequence,
+    Selector: Selector,
+    RuleSet: RuleSet,
+    SelectorScope: SelectorScope,
+    MediaQuerySelectorScope: MediaQuerySelectorScope,
+    StyleSheetSelectorScope: StyleSheetSelectorScope,
+    fromAstNode: fromAstNode,
+    SelectorsMatch: SelectorsMatch,
 };
 //# sourceMappingURL=css-selector.js.map