playwright-ui5 1.1.2 → 1.1.3

package/dist/browser/main.js

@@ -26,11 +26,392 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/css-selector-parser/lib/indexes.js
+var require_indexes = __commonJS({
+  "node_modules/css-selector-parser/lib/indexes.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createRegularIndex = exports.createMulticharIndex = exports.emptyRegularIndex = exports.emptyMulticharIndex = void 0;
+    exports.emptyMulticharIndex = {};
+    exports.emptyRegularIndex = {};
+    function extendIndex(item, index) {
+      var currentIndex = index;
+      for (var pos = 0; pos < item.length; pos++) {
+        var isLast = pos === item.length - 1;
+        var char = item.charAt(pos);
+        var charIndex = currentIndex[char] || (currentIndex[char] = { chars: {} });
+        if (isLast) {
+          charIndex.self = item;
+        }
+        currentIndex = charIndex.chars;
+      }
+    }
+    function createMulticharIndex(items) {
+      if (items.length === 0) {
+        return exports.emptyMulticharIndex;
+      }
+      var index = {};
+      for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+        var item = items_1[_i];
+        extendIndex(item, index);
+      }
+      return index;
+    }
+    exports.createMulticharIndex = createMulticharIndex;
+    function createRegularIndex(items) {
+      if (items.length === 0) {
+        return exports.emptyRegularIndex;
+      }
+      var result = {};
+      for (var _i = 0, items_2 = items; _i < items_2.length; _i++) {
+        var item = items_2[_i];
+        result[item] = true;
+      }
+      return result;
+    }
+    exports.createRegularIndex = createRegularIndex;
+  }
+});
+
+// node_modules/css-selector-parser/lib/pseudo-class-signatures.js
+var require_pseudo_class_signatures = __commonJS({
+  "node_modules/css-selector-parser/lib/pseudo-class-signatures.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.calculatePseudoClassSignatures = exports.inverseCategories = exports.defaultPseudoClassSignature = exports.emptyPseudoClassSignatures = void 0;
+    exports.emptyPseudoClassSignatures = {};
+    exports.defaultPseudoClassSignature = {
+      type: "String",
+      optional: true
+    };
+    function calculatePseudoClassSignature(types) {
+      var result = {
+        optional: false
+      };
+      function setResultType(type2) {
+        if (result.type && result.type !== type2) {
+          throw new Error('Conflicting pseudo-class argument type: "'.concat(result.type, '" vs "').concat(type2, '".'));
+        }
+        result.type = type2;
+      }
+      for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
+        var type = types_1[_i];
+        if (type === "NoArgument") {
+          result.optional = true;
+        }
+        if (type === "Formula") {
+          setResultType("Formula");
+        }
+        if (type === "FormulaOfSelector") {
+          setResultType("Formula");
+          result.ofSelector = true;
+        }
+        if (type === "String") {
+          setResultType("String");
+        }
+        if (type === "Selector") {
+          setResultType("Selector");
+        }
+      }
+      return result;
+    }
+    function inverseCategories(obj) {
+      var result = {};
+      for (var _i = 0, _a = Object.keys(obj); _i < _a.length; _i++) {
+        var category = _a[_i];
+        var items = obj[category];
+        if (items) {
+          for (var _b = 0, _c = items; _b < _c.length; _b++) {
+            var item = _c[_b];
+            (result[item] || (result[item] = [])).push(category);
+          }
+        }
+      }
+      return result;
+    }
+    exports.inverseCategories = inverseCategories;
+    function calculatePseudoClassSignatures(definitions) {
+      var pseudoClassesToArgumentTypes = inverseCategories(definitions);
+      var result = {};
+      for (var _i = 0, _a = Object.keys(pseudoClassesToArgumentTypes); _i < _a.length; _i++) {
+        var pseudoClass = _a[_i];
+        var argumentTypes = pseudoClassesToArgumentTypes[pseudoClass];
+        if (argumentTypes) {
+          result[pseudoClass] = calculatePseudoClassSignature(argumentTypes);
+        }
+      }
+      return result;
+    }
+    exports.calculatePseudoClassSignatures = calculatePseudoClassSignatures;
+  }
+});
+
+// node_modules/css-selector-parser/lib/syntax-definitions.js
+var require_syntax_definitions = __commonJS({
+  "node_modules/css-selector-parser/lib/syntax-definitions.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.cssSyntaxDefinitions = exports.extendSyntaxDefinition = exports.getXmlOptions = void 0;
+    var emptyXmlOptions = {};
+    var defaultXmlOptions = { wildcard: true };
+    function getXmlOptions(param) {
+      if (param) {
+        if (typeof param === "boolean") {
+          return defaultXmlOptions;
+        } else {
+          return param;
+        }
+      } else {
+        return emptyXmlOptions;
+      }
+    }
+    exports.getXmlOptions = getXmlOptions;
+    function extendSyntaxDefinition(base, extension) {
+      var result = __assign({}, base);
+      if ("tag" in extension) {
+        if (extension.tag) {
+          result.tag = __assign({}, getXmlOptions(base.tag));
+          var extensionOptions = getXmlOptions(extension.tag);
+          if ("wildcard" in extensionOptions) {
+            result.tag.wildcard = extensionOptions.wildcard;
+          }
+        } else {
+          result.tag = void 0;
+        }
+      }
+      if ("ids" in extension) {
+        result.ids = extension.ids;
+      }
+      if ("classNames" in extension) {
+        result.classNames = extension.classNames;
+      }
+      if ("namespace" in extension) {
+        if (extension.namespace) {
+          result.namespace = __assign({}, getXmlOptions(base.namespace));
+          var extensionOptions = getXmlOptions(extension.namespace);
+          if ("wildcard" in extensionOptions) {
+            result.namespace.wildcard = extensionOptions.wildcard;
+          }
+        } else {
+          result.namespace = void 0;
+        }
+      }
+      if ("combinators" in extension) {
+        if (extension.combinators) {
+          result.combinators = result.combinators ? result.combinators.concat(extension.combinators) : extension.combinators;
+        } else {
+          result.combinators = void 0;
+        }
+      }
+      if ("attributes" in extension) {
+        if (extension.attributes) {
+          result.attributes = __assign({}, base.attributes);
+          if ("unknownCaseSensitivityModifiers" in extension.attributes) {
+            result.attributes.unknownCaseSensitivityModifiers = extension.attributes.unknownCaseSensitivityModifiers;
+          }
+          if ("operators" in extension.attributes) {
+            result.attributes.operators = extension.attributes.operators ? result.attributes.operators ? result.attributes.operators.concat(extension.attributes.operators) : extension.attributes.operators : void 0;
+          }
+          if ("caseSensitivityModifiers" in extension.attributes) {
+            result.attributes.caseSensitivityModifiers = extension.attributes.caseSensitivityModifiers ? result.attributes.caseSensitivityModifiers ? result.attributes.caseSensitivityModifiers.concat(extension.attributes.caseSensitivityModifiers) : extension.attributes.caseSensitivityModifiers : void 0;
+          }
+        } else {
+          result.attributes = void 0;
+        }
+      }
+      if ("pseudoElements" in extension) {
+        if (extension.pseudoElements) {
+          result.pseudoElements = __assign({}, base.pseudoElements);
+          if ("unknown" in extension.pseudoElements) {
+            result.pseudoElements.unknown = extension.pseudoElements.unknown;
+          }
+          if ("notation" in extension.pseudoElements) {
+            result.pseudoElements.notation = extension.pseudoElements.notation;
+          }
+          if ("definitions" in extension.pseudoElements) {
+            result.pseudoElements.definitions = extension.pseudoElements.definitions ? result.pseudoElements.definitions ? result.pseudoElements.definitions.concat(extension.pseudoElements.definitions) : extension.pseudoElements.definitions : void 0;
+          }
+        } else {
+          result.pseudoElements = void 0;
+        }
+      }
+      if ("pseudoClasses" in extension) {
+        if (extension.pseudoClasses) {
+          result.pseudoClasses = __assign({}, base.pseudoClasses);
+          if ("unknown" in extension.pseudoClasses) {
+            result.pseudoClasses.unknown = extension.pseudoClasses.unknown;
+          }
+          if ("definitions" in extension.pseudoClasses) {
+            var newDefinitions = extension.pseudoClasses.definitions;
+            if (newDefinitions) {
+              result.pseudoClasses.definitions = __assign({}, result.pseudoClasses.definitions);
+              var existingDefinitions = result.pseudoClasses.definitions;
+              for (var _i = 0, _a = Object.keys(newDefinitions); _i < _a.length; _i++) {
+                var key = _a[_i];
+                var newDefinitionForNotation = newDefinitions[key];
+                var existingDefinitionForNotation = existingDefinitions[key];
+                if (newDefinitionForNotation) {
+                  existingDefinitions[key] = existingDefinitionForNotation ? existingDefinitionForNotation.concat(newDefinitionForNotation) : newDefinitionForNotation;
+                } else {
+                  existingDefinitions[key] = void 0;
+                }
+              }
+            } else {
+              result.pseudoClasses.definitions = void 0;
+            }
+          }
+        } else {
+          result.pseudoClasses = void 0;
+        }
+      }
+      return result;
+    }
+    exports.extendSyntaxDefinition = extendSyntaxDefinition;
+    var css1SyntaxDefinition = {
+      tag: {},
+      ids: true,
+      classNames: true,
+      combinators: [],
+      pseudoElements: {
+        unknown: "reject",
+        notation: "singleColon",
+        definitions: ["first-letter", "first-line"]
+      },
+      pseudoClasses: {
+        unknown: "reject",
+        definitions: {
+          NoArgument: ["link", "visited", "active"]
+        }
+      }
+    };
+    var css2SyntaxDefinition = extendSyntaxDefinition(css1SyntaxDefinition, {
+      tag: { wildcard: true },
+      combinators: [">", "+"],
+      attributes: {
+        unknownCaseSensitivityModifiers: "reject",
+        operators: ["=", "~=", "|="]
+      },
+      pseudoElements: {
+        definitions: ["before", "after"]
+      },
+      pseudoClasses: {
+        unknown: "reject",
+        definitions: {
+          NoArgument: ["hover", "focus", "first-child"],
+          String: ["lang"]
+        }
+      }
+    });
+    var selectors3SyntaxDefinition = extendSyntaxDefinition(css2SyntaxDefinition, {
+      namespace: {
+        wildcard: true
+      },
+      combinators: ["~"],
+      attributes: {
+        operators: ["^=", "$=", "*="]
+      },
+      pseudoElements: {
+        notation: "both"
+      },
+      pseudoClasses: {
+        definitions: {
+          NoArgument: [
+            "root",
+            "last-child",
+            "first-of-type",
+            "last-of-type",
+            "only-child",
+            "only-of-type",
+            "empty",
+            "target",
+            "enabled",
+            "disabled",
+            "checked",
+            "indeterminate"
+          ],
+          Formula: ["nth-child", "nth-last-child", "nth-of-type", "nth-last-of-type"],
+          Selector: ["not"]
+        }
+      }
+    });
+    var selectors4SyntaxDefinition = extendSyntaxDefinition(selectors3SyntaxDefinition, {
+      combinators: ["||"],
+      attributes: {
+        caseSensitivityModifiers: ["i", "I", "s", "S"]
+      },
+      pseudoClasses: {
+        definitions: {
+          NoArgument: [
+            "any-link",
+            "local-link",
+            "target-within",
+            "scope",
+            "current",
+            "past",
+            "future",
+            "focus-within",
+            "focus-visible",
+            "read-write",
+            "read-only",
+            "placeholder-shown",
+            "default",
+            "valid",
+            "invalid",
+            "in-range",
+            "out-of-range",
+            "required",
+            "optional",
+            "blank",
+            "user-invalid"
+          ],
+          Formula: ["nth-col", "nth-last-col"],
+          String: ["dir"],
+          FormulaOfSelector: ["nth-child", "nth-last-child"],
+          Selector: ["current", "is", "where", "has"]
+        }
+      }
+    });
+    var progressiveSyntaxDefinition = extendSyntaxDefinition(selectors4SyntaxDefinition, {
+      pseudoElements: {
+        unknown: "accept"
+      },
+      pseudoClasses: {
+        unknown: "accept"
+      },
+      attributes: {
+        unknownCaseSensitivityModifiers: "accept"
+      }
+    });
+    exports.cssSyntaxDefinitions = {
+      css1: css1SyntaxDefinition,
+      css2: css2SyntaxDefinition,
+      css3: selectors3SyntaxDefinition,
+      "selectors-3": selectors3SyntaxDefinition,
+      "selectors-4": selectors4SyntaxDefinition,
+      latest: selectors4SyntaxDefinition,
+      progressive: progressiveSyntaxDefinition
+    };
+  }
+});
+
 // node_modules/css-selector-parser/lib/utils.js
 var require_utils = __commonJS({
   "node_modules/css-selector-parser/lib/utils.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    exports.escapePseudoClassString = exports.escapeStr = exports.escapeIdentifier = exports.digitsChars = exports.quoteChars = exports.whitespaceChars = exports.stringEscapeChars = exports.strReplacementsRev = exports.identSpecialChars = exports.isHex = exports.isIdent = exports.isIdentStart = void 0;
     function isIdentStart(c) {
       return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "-" || c === "_";
     }
@@ -43,6 +424,74 @@ var require_utils = __commonJS({
       return c >= "a" && c <= "f" || c >= "A" && c <= "F" || c >= "0" && c <= "9";
     }
     exports.isHex = isHex;
+    exports.identSpecialChars = {
+      "!": true,
+      '"': true,
+      "#": true,
+      $: true,
+      "%": true,
+      "&": true,
+      "'": true,
+      "(": true,
+      ")": true,
+      "*": true,
+      "+": true,
+      ",": true,
+      ".": true,
+      "/": true,
+      ";": true,
+      "<": true,
+      "=": true,
+      ">": true,
+      "?": true,
+      "@": true,
+      "[": true,
+      "\\": true,
+      "]": true,
+      "^": true,
+      "`": true,
+      "{": true,
+      "|": true,
+      "}": true,
+      "~": true
+    };
+    exports.strReplacementsRev = {
+      "\n": "\\n",
+      "\r": "\\r",
+      "	": "\\t",
+      "\f": "\\f",
+      "\v": "\\v"
+    };
+    exports.stringEscapeChars = {
+      n: "\n",
+      r: "\r",
+      t: "	",
+      f: "\f",
+      "\\": "\\"
+    };
+    exports.whitespaceChars = {
+      " ": true,
+      "	": true,
+      "\n": true,
+      "\r": true,
+      "\f": true
+    };
+    exports.quoteChars = {
+      '"': true,
+      "'": true
+    };
+    exports.digitsChars = {
+      0: true,
+      1: true,
+      2: true,
+      3: true,
+      4: true,
+      5: true,
+      6: true,
+      7: true,
+      8: true,
+      9: true
+    };
     function escapeIdentifier(s) {
       var len = s.length;
       var result = "";
@@ -68,7 +517,7 @@ var require_utils = __commonJS({
         }
         i++;
       }
-      return result;
+      return result.trim();
     }
     exports.escapeIdentifier = escapeIdentifier;
     function escapeStr(s) {
@@ -88,105 +537,160 @@ var require_utils = __commonJS({
         result += chr;
         i++;
       }
-      return '"' + result + '"';
+      return '"'.concat(result, '"');
     }
     exports.escapeStr = escapeStr;
-    exports.identSpecialChars = {
-      "!": true,
-      '"': true,
-      "#": true,
-      "$": true,
-      "%": true,
-      "&": true,
-      "'": true,
-      "(": true,
-      ")": true,
-      "*": true,
-      "+": true,
-      ",": true,
-      ".": true,
-      "/": true,
-      ";": true,
-      "<": true,
-      "=": true,
-      ">": true,
-      "?": true,
-      "@": true,
-      "[": true,
-      "\\": true,
-      "]": true,
-      "^": true,
-      "`": true,
-      "{": true,
-      "|": true,
-      "}": true,
-      "~": true
-    };
-    exports.strReplacementsRev = {
-      "\n": "\\n",
-      "\r": "\\r",
-      "	": "\\t",
-      "\f": "\\f",
-      "\v": "\\v"
-    };
-    exports.singleQuoteEscapeChars = {
-      n: "\n",
-      r: "\r",
-      t: "	",
-      f: "\f",
-      "\\": "\\",
-      "'": "'"
-    };
-    exports.doubleQuotesEscapeChars = {
-      n: "\n",
-      r: "\r",
-      t: "	",
-      f: "\f",
-      "\\": "\\",
-      '"': '"'
+    var escapePseudoClassString = function(s) {
+      return s.replace(/([\\)])/g, "\\$1");
     };
+    exports.escapePseudoClassString = escapePseudoClassString;
   }
 });
 
-// node_modules/css-selector-parser/lib/parser-context.js
-var require_parser_context = __commonJS({
-  "node_modules/css-selector-parser/lib/parser-context.js"(exports) {
+// node_modules/css-selector-parser/lib/parser.js
+var require_parser = __commonJS({
+  "node_modules/css-selector-parser/lib/parser.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createParser = void 0;
+    var indexes_1 = require_indexes();
+    var pseudo_class_signatures_1 = require_pseudo_class_signatures();
+    var syntax_definitions_1 = require_syntax_definitions();
     var utils_1 = require_utils();
-    function parseCssSelector(str, pos, pseudos, attrEqualityMods, ruleNestingOperators, substitutesEnabled) {
+    var errorPrefix = "css-selector-parser parse error: ";
+    function createParser2(options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.syntax, syntax = _a === void 0 ? "latest" : _a, substitutes = options.substitutes, _b = options.strict, strict = _b === void 0 ? true : _b;
+      var syntaxDefinition = typeof syntax === "string" ? syntax_definitions_1.cssSyntaxDefinitions[syntax] : syntax;
+      if (syntaxDefinition.baseSyntax) {
+        syntaxDefinition = (0, syntax_definitions_1.extendSyntaxDefinition)(syntax_definitions_1.cssSyntaxDefinitions[syntaxDefinition.baseSyntax], syntaxDefinition);
+      }
+      var _c = syntaxDefinition.tag ? [true, Boolean((0, syntax_definitions_1.getXmlOptions)(syntaxDefinition.tag).wildcard)] : [false, false], tagNameEnabled = _c[0], tagNameWildcardEnabled = _c[1];
+      var idEnabled = Boolean(syntaxDefinition.ids);
+      var classNamesEnabled = Boolean(syntaxDefinition.classNames);
+      var namespaceEnabled = Boolean(syntaxDefinition.namespace);
+      var namespaceWildcardEnabled = syntaxDefinition.namespace && (syntaxDefinition.namespace === true || syntaxDefinition.namespace.wildcard === true);
+      if (namespaceEnabled && !tagNameEnabled) {
+        throw new Error("".concat(errorPrefix, "Namespaces cannot be enabled while tags are disabled."));
+      }
+      var substitutesEnabled = Boolean(substitutes);
+      var combinatorsIndex = syntaxDefinition.combinators ? (0, indexes_1.createMulticharIndex)(syntaxDefinition.combinators) : indexes_1.emptyMulticharIndex;
+      var _d = syntaxDefinition.attributes ? [
+        true,
+        syntaxDefinition.attributes.operators ? (0, indexes_1.createMulticharIndex)(syntaxDefinition.attributes.operators) : indexes_1.emptyMulticharIndex,
+        syntaxDefinition.attributes.caseSensitivityModifiers ? (0, indexes_1.createRegularIndex)(syntaxDefinition.attributes.caseSensitivityModifiers) : indexes_1.emptyRegularIndex,
+        syntaxDefinition.attributes.unknownCaseSensitivityModifiers === "accept"
+      ] : [false, indexes_1.emptyMulticharIndex, indexes_1.emptyRegularIndex, false], attributesEnabled = _d[0], attributesOperatorsIndex = _d[1], attributesCaseSensitivityModifiers = _d[2], attributesAcceptUnknownCaseSensitivityModifiers = _d[3];
+      var attributesCaseSensitivityModifiersEnabled = attributesAcceptUnknownCaseSensitivityModifiers || Object.keys(attributesCaseSensitivityModifiers).length > 0;
+      var _e = syntaxDefinition.pseudoClasses ? [
+        true,
+        syntaxDefinition.pseudoClasses.definitions ? (0, pseudo_class_signatures_1.calculatePseudoClassSignatures)(syntaxDefinition.pseudoClasses.definitions) : pseudo_class_signatures_1.emptyPseudoClassSignatures,
+        syntaxDefinition.pseudoClasses.unknown === "accept"
+      ] : [false, pseudo_class_signatures_1.emptyPseudoClassSignatures, false], pseudoClassesEnabled = _e[0], paeudoClassesDefinitions = _e[1], pseudoClassesAcceptUnknown = _e[2];
+      var _f = syntaxDefinition.pseudoElements ? [
+        true,
+        syntaxDefinition.pseudoElements.notation === "singleColon" || syntaxDefinition.pseudoElements.notation === "both",
+        !syntaxDefinition.pseudoElements.notation || syntaxDefinition.pseudoElements.notation === "doubleColon" || syntaxDefinition.pseudoElements.notation === "both",
+        syntaxDefinition.pseudoElements.definitions ? (0, indexes_1.createRegularIndex)(syntaxDefinition.pseudoElements.definitions) : indexes_1.emptyRegularIndex,
+        syntaxDefinition.pseudoElements.unknown === "accept"
+      ] : [false, false, false, indexes_1.emptyRegularIndex, false], pseudoElementsEnabled = _f[0], pseudoElementsSingleColonNotationEnabled = _f[1], pseudoElementsDoubleColonNotationEnabled = _f[2], pseudoElementsIndex = _f[3], pseudoElementsAcceptUnknown = _f[4];
+      var str = "";
       var l = str.length;
+      var pos = 0;
       var chr = "";
-      function getStr(quote, escapeTable) {
-        var result = "";
+      var is = function(comparison) {
+        return chr === comparison;
+      };
+      var isTagStart = function() {
+        return is("*") || (0, utils_1.isIdentStart)(chr) || is("\\");
+      };
+      var rewind = function(newPos) {
+        pos = newPos;
+        chr = str.charAt(pos);
+      };
+      var next = function() {
         pos++;
         chr = str.charAt(pos);
+      };
+      var readAndNext = function() {
+        var current = chr;
+        pos++;
+        chr = str.charAt(pos);
+        return current;
+      };
+      function fail(errorMessage) {
+        var position = Math.min(l - 1, pos);
+        var error = new Error("".concat(errorPrefix).concat(errorMessage, " Pos: ").concat(position, "."));
+        error.position = position;
+        error.name = "ParserError";
+        throw error;
+      }
+      function assert(condition, errorMessage) {
+        if (!condition) {
+          return fail(errorMessage);
+        }
+      }
+      var assertNonEof = function() {
+        assert(pos < l, "Unexpected end of input.");
+      };
+      var isEof = function() {
+        return pos >= l;
+      };
+      var pass = function(character) {
+        assert(pos < l, 'Expected "'.concat(character, '" but end of input reached.'));
+        assert(chr === character, 'Expected "'.concat(character, '" but "').concat(chr, '" found.'));
+        pos++;
+        chr = str.charAt(pos);
+      };
+      function matchMulticharIndex(index) {
+        var match = matchMulticharIndexPos(index, pos);
+        if (match) {
+          pos += match.length;
+          chr = str.charAt(pos);
+          return match;
+        }
+      }
+      function matchMulticharIndexPos(index, subPos) {
+        var char = str.charAt(subPos);
+        var charIndex = index[char];
+        if (charIndex) {
+          var subMatch = matchMulticharIndexPos(charIndex.chars, subPos + 1);
+          if (subMatch) {
+            return subMatch;
+          }
+          if (charIndex.self) {
+            return charIndex.self;
+          }
+        }
+      }
+      function parseHex() {
+        var hex = readAndNext();
+        while ((0, utils_1.isHex)(chr)) {
+          hex += readAndNext();
+        }
+        if (is(" ")) {
+          next();
+        }
+        return String.fromCharCode(parseInt(hex, 16));
+      }
+      function parseString(quote) {
+        var result = "";
+        pass(quote);
         while (pos < l) {
-          if (chr === quote) {
-            pos++;
+          if (is(quote)) {
+            next();
             return result;
-          } else if (chr === "\\") {
-            pos++;
-            chr = str.charAt(pos);
+          } else if (is("\\")) {
+            next();
             var esc = void 0;
-            if (chr === quote) {
+            if (is(quote)) {
               result += quote;
-            } else if ((esc = escapeTable[chr]) !== void 0) {
+            } else if ((esc = utils_1.stringEscapeChars[chr]) !== void 0) {
               result += esc;
-            } else if (utils_1.isHex(chr)) {
-              var hex = chr;
-              pos++;
-              chr = str.charAt(pos);
-              while (utils_1.isHex(chr)) {
-                hex += chr;
-                pos++;
-                chr = str.charAt(pos);
-              }
-              if (chr === " ") {
-                pos++;
-                chr = str.charAt(pos);
-              }
-              result += String.fromCharCode(parseInt(hex, 16));
+            } else if ((0, utils_1.isHex)(chr)) {
+              result += parseHex();
               continue;
             } else {
               result += chr;
@@ -194,259 +698,442 @@ var require_parser_context = __commonJS({
           } else {
             result += chr;
           }
-          pos++;
-          chr = str.charAt(pos);
+          next();
         }
         return result;
       }
-      function getIdent() {
+      function parseIdentifier() {
         var result = "";
-        chr = str.charAt(pos);
         while (pos < l) {
-          if (utils_1.isIdent(chr)) {
-            result += chr;
-          } else if (chr === "\\") {
-            pos++;
-            if (pos >= l) {
-              throw Error("Expected symbol but end of file reached.");
-            }
-            chr = str.charAt(pos);
-            if (utils_1.identSpecialChars[chr]) {
-              result += chr;
-            } else if (utils_1.isHex(chr)) {
-              var hex = chr;
-              pos++;
-              chr = str.charAt(pos);
-              while (utils_1.isHex(chr)) {
-                hex += chr;
-                pos++;
-                chr = str.charAt(pos);
-              }
-              if (chr === " ") {
-                pos++;
-                chr = str.charAt(pos);
-              }
-              result += String.fromCharCode(parseInt(hex, 16));
-              continue;
+          if ((0, utils_1.isIdent)(chr)) {
+            result += readAndNext();
+          } else if (is("\\")) {
+            next();
+            assertNonEof();
+            if ((0, utils_1.isHex)(chr)) {
+              result += parseHex();
             } else {
-              result += chr;
+              result += readAndNext();
             }
           } else {
             return result;
           }
-          pos++;
-          chr = str.charAt(pos);
         }
         return result;
       }
+      function parsePseudoClassString() {
+        var result = "";
+        while (pos < l) {
+          if (is(")")) {
+            break;
+          } else if (is("\\")) {
+            next();
+            if (isEof() && !strict) {
+              return (result + "\\").trim();
+            }
+            assertNonEof();
+            if ((0, utils_1.isHex)(chr)) {
+              result += parseHex();
+            } else {
+              result += readAndNext();
+            }
+          } else {
+            result += readAndNext();
+          }
+        }
+        return result.trim();
+      }
       function skipWhitespace() {
-        chr = str.charAt(pos);
-        var result = false;
-        while (chr === " " || chr === "	" || chr === "\n" || chr === "\r" || chr === "\f") {
-          result = true;
-          pos++;
-          chr = str.charAt(pos);
+        while (utils_1.whitespaceChars[chr]) {
+          next();
         }
-        return result;
       }
-      function parse() {
-        var res = parseSelector();
-        if (pos < l) {
-          throw Error('Rule expected but "' + str.charAt(pos) + '" found.');
+      function parseSelector(relative) {
+        if (relative === void 0) {
+          relative = false;
+        }
+        skipWhitespace();
+        var rules = [parseRule(relative)];
+        while (is(",")) {
+          next();
+          skipWhitespace();
+          rules.push(parseRule(relative));
         }
-        return res;
+        return {
+          type: "Selector",
+          rules
+        };
       }
-      function parseSelector() {
-        var selector = parseSingleSelector();
-        if (!selector) {
-          return null;
+      function parseAttribute() {
+        pass("[");
+        skipWhitespace();
+        var attr;
+        if (is("|")) {
+          assert(namespaceEnabled, "Namespaces are not enabled.");
+          next();
+          attr = {
+            type: "Attribute",
+            name: parseIdentifier(),
+            namespace: { type: "NoNamespace" }
+          };
+        } else if (is("*")) {
+          assert(namespaceEnabled, "Namespaces are not enabled.");
+          assert(namespaceWildcardEnabled, "Wildcard namespace is not enabled.");
+          next();
+          pass("|");
+          attr = {
+            type: "Attribute",
+            name: parseIdentifier(),
+            namespace: { type: "WildcardNamespace" }
+          };
+        } else {
+          var identifier = parseIdentifier();
+          attr = {
+            type: "Attribute",
+            name: identifier
+          };
+          if (is("|")) {
+            var savedPos = pos;
+            next();
+            if ((0, utils_1.isIdentStart)(chr) || is("\\")) {
+              assert(namespaceEnabled, "Namespaces are not enabled.");
+              attr = {
+                type: "Attribute",
+                name: parseIdentifier(),
+                namespace: { type: "NamespaceName", name: identifier }
+              };
+            } else {
+              rewind(savedPos);
+            }
+          }
         }
-        var res = selector;
-        chr = str.charAt(pos);
-        while (chr === ",") {
-          pos++;
+        assert(attr.name, "Expected attribute name.");
+        skipWhitespace();
+        if (isEof() && !strict) {
+          return attr;
+        }
+        if (is("]")) {
+          next();
+        } else {
+          attr.operator = matchMulticharIndex(attributesOperatorsIndex);
+          assert(attr.operator, "Expected a valid attribute selector operator.");
           skipWhitespace();
-          if (res.type !== "selectors") {
-            res = {
-              type: "selectors",
-              selectors: [selector]
+          assertNonEof();
+          if (utils_1.quoteChars[chr]) {
+            attr.value = {
+              type: "String",
+              value: parseString(chr)
+            };
+          } else if (substitutesEnabled && is("$")) {
+            next();
+            attr.value = {
+              type: "Substitution",
+              name: parseIdentifier()
+            };
+            assert(attr.value.name, "Expected substitute name.");
+          } else {
+            attr.value = {
+              type: "String",
+              value: parseIdentifier()
             };
+            assert(attr.value.value, "Expected attribute value.");
           }
-          selector = parseSingleSelector();
-          if (!selector) {
-            throw Error('Rule expected after ",".');
+          skipWhitespace();
+          if (isEof() && !strict) {
+            return attr;
+          }
+          if (!is("]")) {
+            attr.caseSensitivityModifier = parseIdentifier();
+            assert(attr.caseSensitivityModifier, "Expected end of attribute selector.");
+            assert(attributesCaseSensitivityModifiersEnabled, "Attribute case sensitivity modifiers are not enabled.");
+            assert(attributesAcceptUnknownCaseSensitivityModifiers || attributesCaseSensitivityModifiers[attr.caseSensitivityModifier], "Unknown attribute case sensitivity modifier.");
+            skipWhitespace();
+            if (isEof() && !strict) {
+              return attr;
+            }
           }
-          res.selectors.push(selector);
+          pass("]");
         }
-        return res;
+        return attr;
       }
-      function parseSingleSelector() {
+      function parseNumber(signed) {
+        var result = "";
+        if (signed && is("-")) {
+          result = readAndNext();
+        }
+        while (utils_1.digitsChars[chr]) {
+          result += readAndNext();
+        }
+        assert(result !== "" && result !== "-", "Formula parse error.");
+        return parseInt(result);
+      }
+      var isNumberStart = function() {
+        return is("-") || is("+") || utils_1.digitsChars[chr];
+      };
+      function parseFormula() {
+        var firstNumber = null;
+        if (isNumberStart()) {
+          if (is("+")) {
+            next();
+            assert(!is("-"), "Formula parse error.");
+          }
+          firstNumber = parseNumber(true);
+          if (!is("\\") && !is("n")) {
+            return [0, firstNumber];
+          }
+        }
+        if (firstNumber === null) {
+          firstNumber = 1;
+        }
+        var ident = parseIdentifier();
+        if (ident === "even") {
+          skipWhitespace();
+          return [2, 0];
+        }
+        if (ident === "odd") {
+          skipWhitespace();
+          return [2, 1];
+        }
+        assert(ident === "n", "Formula parse error");
         skipWhitespace();
-        var selector = {
-          type: "ruleSet"
+        if (is("+") || is("-")) {
+          var sign = is("+") ? 1 : -1;
+          next();
+          skipWhitespace();
+          return [firstNumber, sign * parseNumber(false)];
+        } else {
+          return [firstNumber, 0];
+        }
+      }
+      function parsePseudoClass(pseudoName) {
+        var pseudo = {
+          type: "PseudoClass",
+          name: pseudoName
         };
-        var rule = parseRule();
-        if (!rule) {
-          return null;
-        }
-        var currentRule = selector;
-        while (rule) {
-          rule.type = "rule";
-          currentRule.rule = rule;
-          currentRule = rule;
+        var pseudoDefinition = paeudoClassesDefinitions[pseudoName];
+        if (!pseudoDefinition && pseudoClassesAcceptUnknown) {
+          pseudoDefinition = pseudo_class_signatures_1.defaultPseudoClassSignature;
+        }
+        assert(pseudoDefinition, 'Unknown pseudo-class: "'.concat(pseudoName, '".'));
+        pseudoDefinition = pseudoDefinition;
+        if (is("(")) {
+          next();
           skipWhitespace();
-          chr = str.charAt(pos);
-          if (pos >= l || chr === "," || chr === ")") {
-            break;
-          }
-          if (ruleNestingOperators[chr]) {
-            var op = chr;
-            pos++;
-            skipWhitespace();
-            rule = parseRule();
-            if (!rule) {
-              throw Error('Rule expected after "' + op + '".');
+          if (substitutesEnabled && is("$")) {
+            next();
+            pseudo.argument = {
+              type: "Substitution",
+              name: parseIdentifier()
+            };
+            assert(pseudo.argument.name, "Expected substitute name.");
+          } else if (pseudoDefinition.type === "String") {
+            pseudo.argument = {
+              type: "String",
+              value: parsePseudoClassString()
+            };
+            assert(pseudo.argument.value, "Expected pseudo-class argument value.");
+          } else if (pseudoDefinition.type === "Selector") {
+            pseudo.argument = parseSelector(true);
+          } else if (pseudoDefinition.type === "Formula") {
+            var _a2 = parseFormula(), a = _a2[0], b = _a2[1];
+            pseudo.argument = {
+              type: "Formula",
+              a,
+              b
+            };
+            if (pseudoDefinition.ofSelector) {
+              skipWhitespace();
+              if (is("o") || is("\\")) {
+                var ident = parseIdentifier();
+                assert(ident === "of", "Formula of selector parse error.");
+                skipWhitespace();
+                pseudo.argument = {
+                  type: "FormulaOfSelector",
+                  a,
+                  b,
+                  selector: parseRule()
+                };
+              }
             }
-            rule.nestingOperator = op;
           } else {
-            rule = parseRule();
-            if (rule) {
-              rule.nestingOperator = null;
-            }
+            return fail("Invalid pseudo-class signature.");
+          }
+          skipWhitespace();
+          if (isEof() && !strict) {
+            return pseudo;
           }
+          pass(")");
+        } else {
+          assert(pseudoDefinition.optional, 'Argument is required for pseudo-class "'.concat(pseudoName, '".'));
         }
-        return selector;
+        return pseudo;
       }
-      function parseRule() {
-        var rule = null;
-        while (pos < l) {
-          chr = str.charAt(pos);
-          if (chr === "*") {
-            pos++;
-            (rule = rule || {}).tagName = "*";
-          } else if (utils_1.isIdentStart(chr) || chr === "\\") {
-            (rule = rule || {}).tagName = getIdent();
-          } else if (chr === ".") {
-            pos++;
-            rule = rule || {};
-            (rule.classNames = rule.classNames || []).push(getIdent());
-          } else if (chr === "#") {
-            pos++;
-            (rule = rule || {}).id = getIdent();
-          } else if (chr === "[") {
-            pos++;
-            skipWhitespace();
-            var attr = {
-              name: getIdent()
+      function parseTagName() {
+        if (is("*")) {
+          assert(tagNameWildcardEnabled, "Wildcard tag name is not enabled.");
+          next();
+          return { type: "WildcardTag" };
+        } else if ((0, utils_1.isIdentStart)(chr) || is("\\")) {
+          assert(tagNameEnabled, "Tag names are not enabled.");
+          return {
+            type: "TagName",
+            name: parseIdentifier()
+          };
+        } else {
+          return fail("Expected tag name.");
+        }
+      }
+      function parseTagNameWithNamespace() {
+        if (is("*")) {
+          var savedPos = pos;
+          next();
+          if (!is("|")) {
+            rewind(savedPos);
+            return parseTagName();
+          }
+          next();
+          if (!isTagStart()) {
+            rewind(savedPos);
+            return parseTagName();
+          }
+          assert(namespaceEnabled, "Namespaces are not enabled.");
+          assert(namespaceWildcardEnabled, "Wildcard namespace is not enabled.");
+          var tagName = parseTagName();
+          tagName.namespace = { type: "WildcardNamespace" };
+          return tagName;
+        } else if (is("|")) {
+          assert(namespaceEnabled, "Namespaces are not enabled.");
+          next();
+          var tagName = parseTagName();
+          tagName.namespace = { type: "NoNamespace" };
+          return tagName;
+        } else if ((0, utils_1.isIdentStart)(chr) || is("\\")) {
+          var identifier = parseIdentifier();
+          if (!is("|")) {
+            assert(tagNameEnabled, "Tag names are not enabled.");
+            return {
+              type: "TagName",
+              name: identifier
+            };
+          }
+          var savedPos = pos;
+          next();
+          if (!isTagStart()) {
+            rewind(savedPos);
+            return {
+              type: "TagName",
+              name: identifier
             };
+          }
+          assert(namespaceEnabled, "Namespaces are not enabled.");
+          var tagName = parseTagName();
+          tagName.namespace = { type: "NamespaceName", name: identifier };
+          return tagName;
+        } else {
+          return fail("Expected tag name.");
+        }
+      }
+      function parseRule(relative) {
+        if (relative === void 0) {
+          relative = false;
+        }
+        var rule = {};
+        var isRuleStart = true;
+        if (relative) {
+          var combinator = matchMulticharIndex(combinatorsIndex);
+          if (combinator) {
+            rule.combinator = combinator;
             skipWhitespace();
-            if (chr === "]") {
-              pos++;
+          }
+        }
+        while (pos < l) {
+          if (isTagStart()) {
+            assert(isRuleStart, "Unexpected tag/namespace start.");
+            rule.tag = parseTagNameWithNamespace();
+          } else if (is("|")) {
+            var savedPos = pos;
+            next();
+            if (isTagStart()) {
+              assert(isRuleStart, "Unexpected tag/namespace start.");
+              rewind(savedPos);
+              rule.tag = parseTagNameWithNamespace();
             } else {
-              var operator = "";
-              if (attrEqualityMods[chr]) {
-                operator = chr;
-                pos++;
-                chr = str.charAt(pos);
-              }
-              if (pos >= l) {
-                throw Error('Expected "=" but end of file reached.');
-              }
-              if (chr !== "=") {
-                throw Error('Expected "=" but "' + chr + '" found.');
-              }
-              attr.operator = operator + "=";
-              pos++;
-              skipWhitespace();
-              var attrValue = "";
-              attr.valueType = "string";
-              if (chr === '"') {
-                attrValue = getStr('"', utils_1.doubleQuotesEscapeChars);
-              } else if (chr === "'") {
-                attrValue = getStr("'", utils_1.singleQuoteEscapeChars);
-              } else if (substitutesEnabled && chr === "$") {
-                pos++;
-                attrValue = getIdent();
-                attr.valueType = "substitute";
-              } else {
-                while (pos < l) {
-                  if (chr === "]") {
-                    break;
-                  }
-                  attrValue += chr;
-                  pos++;
-                  chr = str.charAt(pos);
-                }
-                attrValue = attrValue.trim();
-              }
-              skipWhitespace();
-              if (pos >= l) {
-                throw Error('Expected "]" but end of file reached.');
-              }
-              if (chr !== "]") {
-                throw Error('Expected "]" but "' + chr + '" found.');
-              }
-              pos++;
-              attr.value = attrValue;
+              rewind(savedPos);
+              break;
             }
-            rule = rule || {};
-            (rule.attrs = rule.attrs || []).push(attr);
-          } else if (chr === ":") {
-            pos++;
-            var pseudoName = getIdent();
-            var pseudo = {
-              name: pseudoName
-            };
-            if (chr === "(") {
-              pos++;
-              var value = "";
-              skipWhitespace();
-              if (pseudos[pseudoName] === "selector") {
-                pseudo.valueType = "selector";
-                value = parseSelector();
-              } else {
-                pseudo.valueType = pseudos[pseudoName] || "string";
-                if (chr === '"') {
-                  value = getStr('"', utils_1.doubleQuotesEscapeChars);
-                } else if (chr === "'") {
-                  value = getStr("'", utils_1.singleQuoteEscapeChars);
-                } else if (substitutesEnabled && chr === "$") {
-                  pos++;
-                  value = getIdent();
-                  pseudo.valueType = "substitute";
-                } else {
-                  while (pos < l) {
-                    if (chr === ")") {
-                      break;
-                    }
-                    value += chr;
-                    pos++;
-                    chr = str.charAt(pos);
-                  }
-                  value = value.trim();
-                }
-                skipWhitespace();
-              }
-              if (pos >= l) {
-                throw Error('Expected ")" but end of file reached.');
-              }
-              if (chr !== ")") {
-                throw Error('Expected ")" but "' + chr + '" found.');
+          } else if (is(".")) {
+            assert(classNamesEnabled, "Class names are not enabled.");
+            next();
+            var className = parseIdentifier();
+            assert(className, "Expected class name.");
+            (rule.classNames = rule.classNames || []).push(className);
+          } else if (is("#")) {
+            assert(idEnabled, "IDs are not enabled.");
+            next();
+            var idName = parseIdentifier();
+            assert(idName, "Expected ID name.");
+            (rule.ids = rule.ids || []).push(idName);
+          } else if (is("[")) {
+            assert(attributesEnabled, "Attributes are not enabled.");
+            (rule.attributes = rule.attributes || []).push(parseAttribute());
+          } else if (is(":")) {
+            var isDoubleColon = false;
+            var isPseudoElement = false;
+            next();
+            if (is(":")) {
+              assert(pseudoElementsEnabled, "Pseudo elements are not enabled.");
+              assert(pseudoElementsDoubleColonNotationEnabled, "Pseudo elements double colon notation is not enabled.");
+              isDoubleColon = true;
+              next();
+            }
+            var pseudoName = parseIdentifier();
+            assert(isDoubleColon || pseudoName, "Expected pseudo-class name.");
+            assert(!isDoubleColon || pseudoName, "Expected pseudo-element name.");
+            assert(!isDoubleColon || pseudoElementsAcceptUnknown || pseudoElementsIndex[pseudoName], 'Unknown pseudo-element "'.concat(pseudoName, '".'));
+            isPseudoElement = pseudoElementsEnabled && (isDoubleColon || !isDoubleColon && pseudoElementsSingleColonNotationEnabled && pseudoElementsIndex[pseudoName]);
+            if (isPseudoElement) {
+              rule.pseudoElement = pseudoName;
+              if (!utils_1.whitespaceChars[chr] && !is(",") && !is(")") && !isEof()) {
+                return fail("Pseudo-element should be the last component of a CSS selector rule.");
               }
-              pos++;
-              pseudo.value = value;
+            } else {
+              assert(pseudoClassesEnabled, "Pseudo classes are not enabled.");
+              (rule.pseudoClasses = rule.pseudoClasses || []).push(parsePseudoClass(pseudoName));
             }
-            rule = rule || {};
-            (rule.pseudos = rule.pseudos || []).push(pseudo);
           } else {
             break;
           }
+          isRuleStart = false;
+        }
+        if (isRuleStart) {
+          if (isEof()) {
+            return fail("Expected rule but end of input reached.");
+          } else {
+            return fail('Expected rule but "'.concat(chr, '" found.'));
+          }
+        }
+        rule.type = "Rule";
+        skipWhitespace();
+        if (!isEof() && !is(",") && !is(")")) {
+          var combinator = matchMulticharIndex(combinatorsIndex);
+          skipWhitespace();
+          rule.nestedRule = parseRule();
+          rule.nestedRule.combinator = combinator;
         }
         return rule;
       }
-      return parse();
+      return function(input) {
+        if (typeof input !== "string") {
+          throw new Error("".concat(errorPrefix, "Expected string input."));
+        }
+        str = input;
+        l = str.length;
+        pos = 0;
+        chr = str.charAt(0);
+        return parseSelector();
+      };
     }
-    exports.parseCssSelector = parseCssSelector;
+    exports.createParser = createParser2;
   }
 });
 
@@ -455,78 +1142,159 @@ var require_render = __commonJS({
   "node_modules/css-selector-parser/lib/render.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    exports.render = void 0;
     var utils_1 = require_utils();
-    function renderEntity(entity) {
-      var res = "";
-      switch (entity.type) {
-        case "ruleSet":
-          var currentEntity = entity.rule;
-          var parts = [];
-          while (currentEntity) {
-            if (currentEntity.nestingOperator) {
-              parts.push(currentEntity.nestingOperator);
-            }
-            parts.push(renderEntity(currentEntity));
-            currentEntity = currentEntity.rule;
-          }
-          res = parts.join(" ");
-          break;
-        case "selectors":
-          res = entity.selectors.map(renderEntity).join(", ");
-          break;
-        case "rule":
-          if (entity.tagName) {
-            if (entity.tagName === "*") {
-              res = "*";
-            } else {
-              res = utils_1.escapeIdentifier(entity.tagName);
-            }
+    function renderNamespace(namespace) {
+      if (namespace.type === "WildcardNamespace") {
+        return "*|";
+      } else if (namespace.type === "NamespaceName") {
+        return "".concat((0, utils_1.escapeIdentifier)(namespace.name), "|");
+      } else if (namespace.type === "NoNamespace") {
+        return "|";
+      }
+      throw new Error("Unknown namespace type: ".concat(namespace.type, "."));
+    }
+    function renderSubstitution(sub) {
+      return "$".concat((0, utils_1.escapeIdentifier)(sub.name));
+    }
+    function renderFormula(a, b) {
+      if (a) {
+        var result = "".concat(a === 1 ? "" : a, "n");
+        if (b) {
+          result += "".concat(b > 0 ? "+" : "").concat(b);
+        }
+        return result;
+      } else {
+        return String(b);
+      }
+    }
+    function render(entity) {
+      if (entity.type === "Selector") {
+        return entity.rules.map(render).join(", ");
+      }
+      if (entity.type === "Rule") {
+        var result = "";
+        var tag = entity.tag, ids = entity.ids, classNames = entity.classNames, attributes = entity.attributes, pseudoClasses = entity.pseudoClasses, pseudoElement = entity.pseudoElement, nestedRule = entity.nestedRule;
+        if (tag) {
+          var namespace = tag.namespace;
+          if (namespace) {
+            result += renderNamespace(namespace);
           }
-          if (entity.id) {
-            res += "#" + utils_1.escapeIdentifier(entity.id);
+          if (tag.type === "TagName") {
+            result += (0, utils_1.escapeIdentifier)(tag.name);
+          } else if (tag.type === "WildcardTag") {
+            result += "*";
+          } else {
+            throw new Error("Unknown tagName type: ".concat(tag.type, "."));
           }
-          if (entity.classNames) {
-            res += entity.classNames.map(function(cn) {
-              return "." + utils_1.escapeIdentifier(cn);
-            }).join("");
+        }
+        if (ids) {
+          for (var _i = 0, ids_1 = ids; _i < ids_1.length; _i++) {
+            var id = ids_1[_i];
+            result += "#".concat((0, utils_1.escapeIdentifier)(id));
           }
-          if (entity.attrs) {
-            res += entity.attrs.map(function(attr) {
-              if ("operator" in attr) {
-                if (attr.valueType === "substitute") {
-                  return "[" + utils_1.escapeIdentifier(attr.name) + attr.operator + "$" + attr.value + "]";
-                } else {
-                  return "[" + utils_1.escapeIdentifier(attr.name) + attr.operator + utils_1.escapeStr(attr.value) + "]";
-                }
+        }
+        if (classNames) {
+          for (var _a = 0, classNames_1 = classNames; _a < classNames_1.length; _a++) {
+            var className = classNames_1[_a];
+            result += ".".concat((0, utils_1.escapeIdentifier)(className));
+          }
+        }
+        if (attributes) {
+          for (var _b = 0, attributes_1 = attributes; _b < attributes_1.length; _b++) {
+            var _c = attributes_1[_b], name_1 = _c.name, namespace = _c.namespace, operator = _c.operator, value = _c.value, caseSensitivityModifier = _c.caseSensitivityModifier;
+            result += "[";
+            if (namespace) {
+              result += renderNamespace(namespace);
+            }
+            result += (0, utils_1.escapeIdentifier)(name_1);
+            if (operator && value) {
+              result += operator;
+              if (value.type === "String") {
+                result += (0, utils_1.escapeStr)(value.value);
+              } else if (value.type === "Substitution") {
+                result += renderSubstitution(value);
               } else {
-                return "[" + utils_1.escapeIdentifier(attr.name) + "]";
+                throw new Error("Unknown attribute value type: ".concat(value.type, "."));
               }
-            }).join("");
-          }
-          if (entity.pseudos) {
-            res += entity.pseudos.map(function(pseudo) {
-              if (pseudo.valueType) {
-                if (pseudo.valueType === "selector") {
-                  return ":" + utils_1.escapeIdentifier(pseudo.name) + "(" + renderEntity(pseudo.value) + ")";
-                } else if (pseudo.valueType === "substitute") {
-                  return ":" + utils_1.escapeIdentifier(pseudo.name) + "($" + pseudo.value + ")";
-                } else if (pseudo.valueType === "numeric") {
-                  return ":" + utils_1.escapeIdentifier(pseudo.name) + "(" + pseudo.value + ")";
-                } else {
-                  return ":" + utils_1.escapeIdentifier(pseudo.name) + "(" + utils_1.escapeIdentifier(pseudo.value) + ")";
-                }
+              if (caseSensitivityModifier) {
+                result += " ".concat((0, utils_1.escapeIdentifier)(caseSensitivityModifier));
+              }
+            }
+            result += "]";
+          }
+        }
+        if (pseudoClasses) {
+          for (var _d = 0, pseudoClasses_1 = pseudoClasses; _d < pseudoClasses_1.length; _d++) {
+            var _e = pseudoClasses_1[_d], name_2 = _e.name, argument = _e.argument;
+            result += ":".concat((0, utils_1.escapeIdentifier)(name_2));
+            if (argument) {
+              result += "(";
+              if (argument.type === "Selector") {
+                result += render(argument);
+              } else if (argument.type === "String") {
+                result += (0, utils_1.escapePseudoClassString)(argument.value);
+              } else if (argument.type === "Formula") {
+                result += renderFormula(argument.a, argument.b);
+              } else if (argument.type === "FormulaOfSelector") {
+                result += renderFormula(argument.a, argument.b);
+                result += " of ";
+                result += render(argument.selector);
+              } else if (argument.type === "Substitution") {
+                result += renderSubstitution(argument);
               } else {
-                return ":" + utils_1.escapeIdentifier(pseudo.name);
+                throw new Error("Unknown pseudo-class argument type: ".concat(argument.type, "."));
               }
-            }).join("");
+              result += ")";
+            }
           }
-          break;
-        default:
-          throw Error('Unknown entity type: "' + entity.type + '".');
+        }
+        if (pseudoElement) {
+          result += "::".concat((0, utils_1.escapeIdentifier)(pseudoElement));
+        }
+        if (nestedRule) {
+          if (nestedRule.combinator) {
+            result += " ".concat(nestedRule.combinator);
+          }
+          result += " ".concat(render(nestedRule));
+        }
+        return result;
       }
-      return res;
+      throw new Error("Render method accepts only Selector, Rule and RuleList.");
+    }
+    exports.render = render;
+  }
+});
+
+// node_modules/css-selector-parser/lib/ast.js
+var require_ast = __commonJS({
+  "node_modules/css-selector-parser/lib/ast.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ast = void 0;
+    function astMethods(type) {
+      return function(generatorName, checkerName) {
+        var _a;
+        return _a = {}, _a[generatorName] = function(props) {
+          return __assign({ type }, props);
+        }, _a[checkerName] = function(entity) {
+          return typeof entity === "object" && entity !== null && entity.type === type;
+        }, _a;
+      };
     }
-    exports.renderEntity = renderEntity;
+    exports.ast = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, astMethods("Selector")("selector", "isSelector")), astMethods("Rule")("rule", "isRule")), astMethods("TagName")("tagName", "isTagName")), astMethods("WildcardTag")("wildcardTag", "isWildcardTag")), astMethods("NamespaceName")("namespaceName", "isNamespaceName")), astMethods("WildcardNamespace")("wildcardNamespace", "isWildcardNamespace")), astMethods("NoNamespace")("noNamespace", "isNoNamespace")), astMethods("Attribute")("attribute", "isAttribute")), astMethods("PseudoClass")("pseudoClass", "isPseudoClass")), astMethods("String")("string", "isString")), astMethods("Formula")("formula", "isFormula")), astMethods("FormulaOfSelector")("formulaOfSelector", "isFormulaOfSelector")), astMethods("Substitution")("substitution", "isSubstitution"));
   }
 });
 
@@ -535,120 +1303,52 @@ var require_lib = __commonJS({
   "node_modules/css-selector-parser/lib/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    var parser_context_1 = require_parser_context();
+    exports.ast = exports.render = exports.createParser = void 0;
+    var parser_1 = require_parser();
+    Object.defineProperty(exports, "createParser", { enumerable: true, get: function() {
+      return parser_1.createParser;
+    } });
     var render_1 = require_render();
-    var CssSelectorParser2 = function() {
-      function CssSelectorParser3() {
-        this.pseudos = {};
-        this.attrEqualityMods = {};
-        this.ruleNestingOperators = {};
-        this.substitutesEnabled = false;
-      }
-      CssSelectorParser3.prototype.registerSelectorPseudos = function() {
-        var pseudos = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          pseudos[_i] = arguments[_i];
-        }
-        for (var _a = 0, pseudos_1 = pseudos; _a < pseudos_1.length; _a++) {
-          var pseudo = pseudos_1[_a];
-          this.pseudos[pseudo] = "selector";
-        }
-        return this;
-      };
-      CssSelectorParser3.prototype.unregisterSelectorPseudos = function() {
-        var pseudos = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          pseudos[_i] = arguments[_i];
-        }
-        for (var _a = 0, pseudos_2 = pseudos; _a < pseudos_2.length; _a++) {
-          var pseudo = pseudos_2[_a];
-          delete this.pseudos[pseudo];
-        }
-        return this;
-      };
-      CssSelectorParser3.prototype.registerNumericPseudos = function() {
-        var pseudos = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          pseudos[_i] = arguments[_i];
-        }
-        for (var _a = 0, pseudos_3 = pseudos; _a < pseudos_3.length; _a++) {
-          var pseudo = pseudos_3[_a];
-          this.pseudos[pseudo] = "numeric";
-        }
-        return this;
-      };
-      CssSelectorParser3.prototype.unregisterNumericPseudos = function() {
-        var pseudos = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          pseudos[_i] = arguments[_i];
-        }
-        for (var _a = 0, pseudos_4 = pseudos; _a < pseudos_4.length; _a++) {
-          var pseudo = pseudos_4[_a];
-          delete this.pseudos[pseudo];
-        }
-        return this;
-      };
-      CssSelectorParser3.prototype.registerNestingOperators = function() {
-        var operators = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          operators[_i] = arguments[_i];
-        }
-        for (var _a = 0, operators_1 = operators; _a < operators_1.length; _a++) {
-          var operator = operators_1[_a];
-          this.ruleNestingOperators[operator] = true;
-        }
-        return this;
-      };
-      CssSelectorParser3.prototype.unregisterNestingOperators = function() {
-        var operators = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          operators[_i] = arguments[_i];
-        }
-        for (var _a = 0, operators_2 = operators; _a < operators_2.length; _a++) {
-          var operator = operators_2[_a];
-          delete this.ruleNestingOperators[operator];
-        }
-        return this;
-      };
-      CssSelectorParser3.prototype.registerAttrEqualityMods = function() {
-        var mods = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          mods[_i] = arguments[_i];
-        }
-        for (var _a = 0, mods_1 = mods; _a < mods_1.length; _a++) {
-          var mod = mods_1[_a];
-          this.attrEqualityMods[mod] = true;
-        }
-        return this;
-      };
-      CssSelectorParser3.prototype.unregisterAttrEqualityMods = function() {
-        var mods = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-          mods[_i] = arguments[_i];
-        }
-        for (var _a = 0, mods_2 = mods; _a < mods_2.length; _a++) {
-          var mod = mods_2[_a];
-          delete this.attrEqualityMods[mod];
-        }
-        return this;
-      };
-      CssSelectorParser3.prototype.enableSubstitutes = function() {
-        this.substitutesEnabled = true;
-        return this;
-      };
-      CssSelectorParser3.prototype.disableSubstitutes = function() {
-        this.substitutesEnabled = false;
-        return this;
-      };
-      CssSelectorParser3.prototype.parse = function(str) {
-        return parser_context_1.parseCssSelector(str, 0, this.pseudos, this.attrEqualityMods, this.ruleNestingOperators, this.substitutesEnabled);
-      };
-      CssSelectorParser3.prototype.render = function(path) {
-        return render_1.renderEntity(path).trim();
-      };
-      return CssSelectorParser3;
-    }();
-    exports.CssSelectorParser = CssSelectorParser2;
+    Object.defineProperty(exports, "render", { enumerable: true, get: function() {
+      return render_1.render;
+    } });
+    var ast_1 = require_ast();
+    Object.defineProperty(exports, "ast", { enumerable: true, get: function() {
+      return ast_1.ast;
+    } });
+  }
+});
+
+// node_modules/throw-expression/index.js
+var require_throw_expression = __commonJS({
+  "node_modules/throw-expression/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.throwIfFalsy = exports.throwIfUndefined = exports.throwIfNull = exports.Throw = void 0;
+    exports.Throw = function(error) {
+      if (typeof error === "string") {
+        throw new Error(error);
+      }
+      throw error;
+    };
+    exports.throwIfNull = function(value, error) {
+      if (error === void 0) {
+        error = "value is null";
+      }
+      return value === null ? exports.Throw(error) : value;
+    };
+    exports.throwIfUndefined = function(value, error) {
+      if (error === void 0) {
+        error = "value is undefined";
+      }
+      return value === void 0 ? exports.Throw(error) : value;
+    };
+    exports.throwIfFalsy = function(value, error) {
+      if (error === void 0) {
+        error = "value is undefined";
+      }
+      return value === void 0 || value === null ? exports.Throw(error) : value;
+    };
   }
 });
 
@@ -659,34 +1359,48 @@ __export(main_exports, {
 });
 module.exports = __toCommonJS(main_exports);
 var import_css_selector_parser = __toESM(require_lib());
-var parser = new import_css_selector_parser.CssSelectorParser();
-parser.registerAttrEqualityMods("^", "$", "*", "~", "|");
-var queryAll = (root, selector) => {
-  if (typeof sap === "undefined") {
-    return [];
+var import_throw_expression = __toESM(require_throw_expression());
+var parse = (0, import_css_selector_parser.createParser)({
+  syntax: {
+    combinators: [],
+    namespace: false,
+    attributes: { operators: ["=", "^=", "$=", "*=", "~=", "|="] },
+    pseudoElements: false,
+    tag: { wildcard: true },
+    ids: true,
+    classNames: true
   }
-  const parsedSelector = parser.parse(selector);
+});
+var queryAll = (root, selector) => {
+  var _a;
+  const parsedSelector = parse(selector);
   if (selector === "") {
     throw new Error("ui5 selector is empty");
   }
-  if (parsedSelector.type === "selectors") {
+  if (parsedSelector.rules.length > 1) {
     throw new Error("comma-separated selectors not supported");
   }
-  const { rule } = parsedSelector;
-  if (rule.tagName && rule.classNames) {
+  if (typeof sap === "undefined") {
+    return [];
+  }
+  const rule = (0, import_throw_expression.throwIfUndefined)(parsedSelector.rules[0], "rules array was empty");
+  if (((_a = rule.tag) == null ? void 0 : _a.type) === "TagName" && rule.classNames) {
     const sapNamespace = "sap";
-    if (rule.tagName !== sapNamespace) {
-      rule.tagName = `${sapNamespace}.${rule.tagName}`;
+    if (rule.tag.name !== sapNamespace) {
+      rule.tag.name = `${sapNamespace}.${rule.tag.name}`;
     }
-    rule.tagName = [rule.tagName, ...rule.classNames].join(".");
+    rule.tag.name = [rule.tag.name, ...rule.classNames].join(".");
     delete rule.classNames;
   }
   const controls = sap.ui.core.Element.registry.filter((element) => {
-    var _a;
-    if (![element.getMetadata().getName(), "*", void 0].includes(rule.tagName) || rule.id && element.getId() !== rule.id) {
+    var _a2, _b;
+    if (rule.ids && rule.ids.length > 1) {
+      throw new Error("multiple ids are not supported");
+    }
+    if (((_a2 = rule.tag) == null ? void 0 : _a2.type) === "TagName" && rule.tag.name !== element.getMetadata().getName() || rule.ids && rule.ids[0] !== element.getId()) {
       return false;
     }
-    return ((_a = rule.attrs) != null ? _a : []).every((attr) => {
+    return ((_b = rule.attributes) != null ? _b : []).every((attr) => {
       let actualValue;
       try {
         actualValue = String(element.getProperty(attr.name));
@@ -696,14 +1410,18 @@ var queryAll = (root, selector) => {
       if (!("value" in attr)) {
         return true;
       }
+      const expectedValue = attr.value.value;
       return {
-        "=": actualValue === attr.value,
-        "^=": actualValue.startsWith(attr.value),
-        "$=": actualValue.endsWith(attr.value),
-        "*=": actualValue.includes(attr.value),
-        "~=": actualValue.split(/\s+/u).includes(attr.value),
-        "|=": actualValue.split("-")[0] === attr.value
-      }[attr.operator];
+        "=": actualValue === expectedValue,
+        "^=": actualValue.startsWith(expectedValue),
+        "$=": actualValue.endsWith(expectedValue),
+        "*=": actualValue.includes(expectedValue),
+        "~=": actualValue.split(/\s+/u).includes(expectedValue),
+        "|=": actualValue.split("-")[0] === expectedValue
+      }[(0, import_throw_expression.throwIfUndefined)(
+        attr.operator,
+        "attribute operator was undefined when value was set (this should NEVER happen)"
+      )];
     });
   });
   return controls.map((control) => control.getDomRef()).filter(