@nativescript/core 8.9.0-napi-es5.0 → 8.9.0-napi.1

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