playwright-ui5 1.5.0 → 1.6.0

package/dist/browser/main.js

@@ -1,1474 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-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 === "_";
-    }
-    exports.isIdentStart = isIdentStart;
-    function isIdent(c) {
-      return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "-" || c === "_";
-    }
-    exports.isIdent = isIdent;
-    function isHex(c) {
-      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 = "";
-      var i = 0;
-      while (i < len) {
-        var chr = s.charAt(i);
-        if (exports.identSpecialChars[chr]) {
-          result += "\\" + chr;
-        } else {
-          if (!(chr === "_" || chr === "-" || chr >= "A" && chr <= "Z" || chr >= "a" && chr <= "z" || i !== 0 && chr >= "0" && chr <= "9")) {
-            var charCode = chr.charCodeAt(0);
-            if ((charCode & 63488) === 55296) {
-              var extraCharCode = s.charCodeAt(i++);
-              if ((charCode & 64512) !== 55296 || (extraCharCode & 64512) !== 56320) {
-                throw Error("UCS-2(decode): illegal sequence");
-              }
-              charCode = ((charCode & 1023) << 10) + (extraCharCode & 1023) + 65536;
-            }
-            result += "\\" + charCode.toString(16) + " ";
-          } else {
-            result += chr;
-          }
-        }
-        i++;
-      }
-      return result.trim();
-    }
-    exports.escapeIdentifier = escapeIdentifier;
-    function escapeStr(s) {
-      var len = s.length;
-      var result = "";
-      var i = 0;
-      var replacement;
-      while (i < len) {
-        var chr = s.charAt(i);
-        if (chr === '"') {
-          chr = '\\"';
-        } else if (chr === "\\") {
-          chr = "\\\\";
-        } else if ((replacement = exports.strReplacementsRev[chr]) !== void 0) {
-          chr = replacement;
-        }
-        result += chr;
-        i++;
-      }
-      return '"'.concat(result, '"');
-    }
-    exports.escapeStr = escapeStr;
-    var escapePseudoClassString = function(s) {
-      return s.replace(/([\\)])/g, "\\$1");
-    };
-    exports.escapePseudoClassString = escapePseudoClassString;
-  }
-});
-
-// 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();
-    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 = "";
-      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 (is(quote)) {
-            next();
-            return result;
-          } else if (is("\\")) {
-            next();
-            var esc = void 0;
-            if (is(quote)) {
-              result += quote;
-            } else if ((esc = utils_1.stringEscapeChars[chr]) !== void 0) {
-              result += esc;
-            } else if ((0, utils_1.isHex)(chr)) {
-              result += parseHex();
-              continue;
-            } else {
-              result += chr;
-            }
-          } else {
-            result += chr;
-          }
-          next();
-        }
-        return result;
-      }
-      function parseIdentifier() {
-        var result = "";
-        while (pos < l) {
-          if ((0, utils_1.isIdent)(chr)) {
-            result += readAndNext();
-          } else if (is("\\")) {
-            next();
-            assertNonEof();
-            if ((0, utils_1.isHex)(chr)) {
-              result += parseHex();
-            } else {
-              result += readAndNext();
-            }
-          } else {
-            return result;
-          }
-        }
-        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() {
-        while (utils_1.whitespaceChars[chr]) {
-          next();
-        }
-      }
-      function parseSelector2(relative) {
-        if (relative === void 0) {
-          relative = false;
-        }
-        skipWhitespace();
-        var rules = [parseRule(relative)];
-        while (is(",")) {
-          next();
-          skipWhitespace();
-          rules.push(parseRule(relative));
-        }
-        return {
-          type: "Selector",
-          rules
-        };
-      }
-      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);
-            }
-          }
-        }
-        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();
-          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.");
-          }
-          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;
-            }
-          }
-          pass("]");
-        }
-        return attr;
-      }
-      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();
-        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 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();
-          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 = parseSelector2(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()
-                };
-              }
-            }
-          } else {
-            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 pseudo;
-      }
-      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();
-          }
-        }
-        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 {
-              rewind(savedPos);
-              break;
-            }
-          } 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.");
-              }
-            } else {
-              assert(pseudoClassesEnabled, "Pseudo classes are not enabled.");
-              (rule.pseudoClasses = rule.pseudoClasses || []).push(parsePseudoClass(pseudoName));
-            }
-          } 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 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 parseSelector2();
-      };
-    }
-    exports.createParser = createParser2;
-  }
-});
-
-// node_modules/css-selector-parser/lib/render.js
-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 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 (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 (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 (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 {
-                throw new Error("Unknown attribute value type: ".concat(value.type, "."));
-              }
-              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 {
-                throw new Error("Unknown pseudo-class argument type: ".concat(argument.type, "."));
-              }
-              result += ")";
-            }
-          }
-        }
-        if (pseudoElement) {
-          result += "::".concat((0, utils_1.escapeIdentifier)(pseudoElement));
-        }
-        if (nestedRule) {
-          if (nestedRule.combinator) {
-            result += " ".concat(nestedRule.combinator);
-          }
-          result += " ".concat(render(nestedRule));
-        }
-        return result;
-      }
-      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.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"));
-  }
-});
-
-// node_modules/css-selector-parser/lib/index.js
-var require_lib = __commonJS({
-  "node_modules/css-selector-parser/lib/index.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    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();
-    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;
-    };
-  }
-});
-
-// src/browser/main.ts
-var main_exports = {};
-__export(main_exports, {
-  default: () => main_default
-});
-module.exports = __toCommonJS(main_exports);
-var import_css_selector_parser = __toESM(require_lib());
-var import_throw_expression = __toESM(require_throw_expression());
-var getAllParents = (element) => {
-  const getParents = (class_) => {
-    const parent = class_.getParent();
-    if (parent !== void 0) {
-      return [class_, ...getParents(parent)];
-    }
-    return [class_];
-  };
-  return getParents(element.getMetadata()).map((parent) => parent.getName());
-};
-var parseSelector = (selector) => {
-  if (selector === "") {
-    throw new Error("ui5 selector is empty");
-  }
-  const parsedSelector = parse(selector);
-  parsedSelector.rules.forEach((rule) => {
-    var _a;
-    if (rule.ids && rule.ids.length > 1) {
-      throw new Error("multiple ids are not supported");
-    }
-    if (rule.pseudoElement === "subclass" && ((_a = rule.tag) == null ? void 0 : _a.type) !== "TagName") {
-      throw new Error(
-        "subclass pseudo-selector cannot be used without specifying a control type"
-      );
-    }
-  });
-  return parsedSelector;
-};
-var parse = (0, import_css_selector_parser.createParser)({
-  syntax: {
-    combinators: [],
-    namespace: false,
-    attributes: { operators: ["=", "^=", "$=", "*=", "~=", "|="] },
-    pseudoElements: { definitions: ["subclass"] },
-    pseudoClasses: { definitions: { Selector: ["has"] } },
-    tag: { wildcard: true },
-    ids: true,
-    classNames: true
-  }
-});
-var querySelector = (root, selector) => selector.rules.flatMap((rule) => {
-  var _a;
-  if (((_a = rule.tag) == null ? void 0 : _a.type) === "TagName" && rule.classNames) {
-    const sapNamespace = "sap";
-    if (rule.tag.name !== sapNamespace) {
-      rule.tag.name = `${sapNamespace}.${rule.tag.name}`;
-    }
-    rule.tag.name = [rule.tag.name, ...rule.classNames].join(".");
-    delete rule.classNames;
-  }
-  const controls = sap.ui.core.Element.registry.filter((element) => {
-    var _a2, _b;
-    if (((_a2 = rule.tag) == null ? void 0 : _a2.type) === "TagName" && rule.tag.name !== element.getMetadata().getName() && (rule.pseudoElement !== "subclass" || !getAllParents(element).includes(rule.tag.name)) || rule.ids && rule.ids[0] !== element.getId()) {
-      return false;
-    }
-    return ((_b = rule.attributes) != null ? _b : []).every((attr) => {
-      let actualValue;
-      try {
-        actualValue = String(element.getProperty(attr.name));
-      } catch {
-        return false;
-      }
-      if (!("value" in attr)) {
-        return true;
-      }
-      const expectedValue = attr.value.value;
-      return {
-        "=": actualValue === expectedValue,
-        "^=": actualValue.startsWith(expectedValue),
-        "$=": actualValue.endsWith(expectedValue),
-        "*=": actualValue.includes(expectedValue),
-        "~=": actualValue.trim() === 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((element) => {
-    if (element === null || root.querySelector(`[id='${element.id}']`) === null) {
-      return false;
-    }
-    if (rule.pseudoClasses && querySelector(
-      element,
-      (0, import_throw_expression.throwIfUndefined)(
-        rule.pseudoClasses[0],
-        '":has" pseudo-class was specified without an argument'
-      ).argument
-    ).length === 0) {
-      return false;
-    }
-    return true;
-  });
-});
-var queryAll = (root, selector) => {
-  try {
-    const parsedSelector = parseSelector(selector);
-    if (typeof sap === "undefined" || typeof sap.ui === "undefined") {
-      return [];
-    }
-    return querySelector(root, parsedSelector);
-  } catch (e) {
-    throw new Error(`ui5 selector engine failed on selector: "${selector}"
-
-${String(e)}`);
-  }
-};
-var main_default = {
-  queryAll,
-  query: (root, selector) => queryAll(root, selector)[0]
-};