patchright-core 1.48.2

package/lib/utils/isomorphic/selectorParser.js

@@ -0,0 +1,397 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "InvalidSelectorError", {
+  enumerable: true,
+  get: function () {
+    return _cssParser.InvalidSelectorError;
+  }
+});
+exports.customCSSNames = void 0;
+Object.defineProperty(exports, "isInvalidSelectorError", {
+  enumerable: true,
+  get: function () {
+    return _cssParser.isInvalidSelectorError;
+  }
+});
+exports.parseAttributeSelector = parseAttributeSelector;
+exports.parseSelector = parseSelector;
+exports.splitSelectorByFrame = splitSelectorByFrame;
+exports.stringifySelector = stringifySelector;
+exports.visitAllSelectorParts = visitAllSelectorParts;
+var _cssParser = require("./cssParser");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const kNestedSelectorNames = new Set(['internal:has', 'internal:has-not', 'internal:and', 'internal:or', 'internal:chain', 'left-of', 'right-of', 'above', 'below', 'near']);
+const kNestedSelectorNamesWithDistance = new Set(['left-of', 'right-of', 'above', 'below', 'near']);
+const customCSSNames = exports.customCSSNames = new Set(['not', 'is', 'where', 'has', 'scope', 'light', 'visible', 'text', 'text-matches', 'text-is', 'has-text', 'above', 'below', 'right-of', 'left-of', 'near', 'nth-match']);
+function parseSelector(selector) {
+  const parsedStrings = parseSelectorString(selector);
+  const parts = [];
+  for (const part of parsedStrings.parts) {
+    if (part.name === 'css' || part.name === 'css:light') {
+      if (part.name === 'css:light') part.body = ':light(' + part.body + ')';
+      const parsedCSS = (0, _cssParser.parseCSS)(part.body, customCSSNames);
+      parts.push({
+        name: 'css',
+        body: parsedCSS.selector,
+        source: part.body
+      });
+      continue;
+    }
+    if (kNestedSelectorNames.has(part.name)) {
+      let innerSelector;
+      let distance;
+      try {
+        const unescaped = JSON.parse('[' + part.body + ']');
+        if (!Array.isArray(unescaped) || unescaped.length < 1 || unescaped.length > 2 || typeof unescaped[0] !== 'string') throw new _cssParser.InvalidSelectorError(`Malformed selector: ${part.name}=` + part.body);
+        innerSelector = unescaped[0];
+        if (unescaped.length === 2) {
+          if (typeof unescaped[1] !== 'number' || !kNestedSelectorNamesWithDistance.has(part.name)) throw new _cssParser.InvalidSelectorError(`Malformed selector: ${part.name}=` + part.body);
+          distance = unescaped[1];
+        }
+      } catch (e) {
+        throw new _cssParser.InvalidSelectorError(`Malformed selector: ${part.name}=` + part.body);
+      }
+      const nested = {
+        name: part.name,
+        source: part.body,
+        body: {
+          parsed: parseSelector(innerSelector),
+          distance
+        }
+      };
+      const lastFrame = [...nested.body.parsed.parts].reverse().find(part => part.name === 'internal:control' && part.body === 'enter-frame');
+      const lastFrameIndex = lastFrame ? nested.body.parsed.parts.indexOf(lastFrame) : -1;
+      // Allow nested selectors to start with the same frame selector.
+      if (lastFrameIndex !== -1 && selectorPartsEqual(nested.body.parsed.parts.slice(0, lastFrameIndex + 1), parts.slice(0, lastFrameIndex + 1))) nested.body.parsed.parts.splice(0, lastFrameIndex + 1);
+      parts.push(nested);
+      continue;
+    }
+    parts.push({
+      ...part,
+      source: part.body
+    });
+  }
+  if (kNestedSelectorNames.has(parts[0].name)) throw new _cssParser.InvalidSelectorError(`"${parts[0].name}" selector cannot be first`);
+  return {
+    capture: parsedStrings.capture,
+    parts
+  };
+}
+function splitSelectorByFrame(selectorText) {
+  const selector = parseSelector(selectorText);
+  const result = [];
+  let chunk = {
+    parts: []
+  };
+  let chunkStartIndex = 0;
+  for (let i = 0; i < selector.parts.length; ++i) {
+    const part = selector.parts[i];
+    if (part.name === 'internal:control' && part.body === 'enter-frame') {
+      if (!chunk.parts.length) throw new _cssParser.InvalidSelectorError('Selector cannot start with entering frame, select the iframe first');
+      result.push(chunk);
+      chunk = {
+        parts: []
+      };
+      chunkStartIndex = i + 1;
+      continue;
+    }
+    if (selector.capture === i) chunk.capture = i - chunkStartIndex;
+    chunk.parts.push(part);
+  }
+  if (!chunk.parts.length) throw new _cssParser.InvalidSelectorError(`Selector cannot end with entering frame, while parsing selector ${selectorText}`);
+  result.push(chunk);
+  if (typeof selector.capture === 'number' && typeof result[result.length - 1].capture !== 'number') throw new _cssParser.InvalidSelectorError(`Can not capture the selector before diving into the frame. Only use * after the last frame has been selected`);
+  return result;
+}
+function selectorPartsEqual(list1, list2) {
+  return stringifySelector({
+    parts: list1
+  }) === stringifySelector({
+    parts: list2
+  });
+}
+function stringifySelector(selector, forceEngineName) {
+  if (typeof selector === 'string') return selector;
+  return selector.parts.map((p, i) => {
+    let includeEngine = true;
+    if (!forceEngineName && i !== selector.capture) {
+      if (p.name === 'css') includeEngine = false;else if (p.name === 'xpath' && p.source.startsWith('//') || p.source.startsWith('..')) includeEngine = false;
+    }
+    const prefix = includeEngine ? p.name + '=' : '';
+    return `${i === selector.capture ? '*' : ''}${prefix}${p.source}`;
+  }).join(' >> ');
+}
+function visitAllSelectorParts(selector, visitor) {
+  const visit = (selector, nested) => {
+    for (const part of selector.parts) {
+      visitor(part, nested);
+      if (kNestedSelectorNames.has(part.name)) visit(part.body.parsed, true);
+    }
+  };
+  visit(selector, false);
+}
+function parseSelectorString(selector) {
+  let index = 0;
+  let quote;
+  let start = 0;
+  const result = {
+    parts: []
+  };
+  const append = () => {
+    const part = selector.substring(start, index).trim();
+    const eqIndex = part.indexOf('=');
+    let name;
+    let body;
+    if (eqIndex !== -1 && part.substring(0, eqIndex).trim().match(/^[a-zA-Z_0-9-+:*]+$/)) {
+      name = part.substring(0, eqIndex).trim();
+      body = part.substring(eqIndex + 1);
+    } else if (part.length > 1 && part[0] === '"' && part[part.length - 1] === '"') {
+      name = 'text';
+      body = part;
+    } else if (part.length > 1 && part[0] === "'" && part[part.length - 1] === "'") {
+      name = 'text';
+      body = part;
+    } else if (/^\(*\/\//.test(part) || part.startsWith('..')) {
+      // If selector starts with '//' or '//' prefixed with multiple opening
+      // parenthesis, consider xpath. @see https://github.com/microsoft/playwright/issues/817
+      // If selector starts with '..', consider xpath as well.
+      name = 'xpath';
+      body = part;
+    } else {
+      name = 'css';
+      body = part;
+    }
+    let capture = false;
+    if (name[0] === '*') {
+      capture = true;
+      name = name.substring(1);
+    }
+    result.parts.push({
+      name,
+      body
+    });
+    if (capture) {
+      if (result.capture !== undefined) throw new _cssParser.InvalidSelectorError(`Only one of the selectors can capture using * modifier`);
+      result.capture = result.parts.length - 1;
+    }
+  };
+  if (!selector.includes('>>')) {
+    index = selector.length;
+    append();
+    return result;
+  }
+  const shouldIgnoreTextSelectorQuote = () => {
+    const prefix = selector.substring(start, index);
+    const match = prefix.match(/^\s*text\s*=(.*)$/);
+    // Must be a text selector with some text before the quote.
+    return !!match && !!match[1];
+  };
+  while (index < selector.length) {
+    const c = selector[index];
+    if (c === '\\' && index + 1 < selector.length) {
+      index += 2;
+    } else if (c === quote) {
+      quote = undefined;
+      index++;
+    } else if (!quote && (c === '"' || c === '\'' || c === '`') && !shouldIgnoreTextSelectorQuote()) {
+      quote = c;
+      index++;
+    } else if (!quote && c === '>' && selector[index + 1] === '>') {
+      append();
+      index += 2;
+      start = index;
+    } else {
+      index++;
+    }
+  }
+  append();
+  return result;
+}
+function parseAttributeSelector(selector, allowUnquotedStrings) {
+  let wp = 0;
+  let EOL = selector.length === 0;
+  const next = () => selector[wp] || '';
+  const eat1 = () => {
+    const result = next();
+    ++wp;
+    EOL = wp >= selector.length;
+    return result;
+  };
+  const syntaxError = stage => {
+    if (EOL) throw new _cssParser.InvalidSelectorError(`Unexpected end of selector while parsing selector \`${selector}\``);
+    throw new _cssParser.InvalidSelectorError(`Error while parsing selector \`${selector}\` - unexpected symbol "${next()}" at position ${wp}` + (stage ? ' during ' + stage : ''));
+  };
+  function skipSpaces() {
+    while (!EOL && /\s/.test(next())) eat1();
+  }
+  function isCSSNameChar(char) {
+    // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
+    return char >= '\u0080' // non-ascii
+    || char >= '\u0030' && char <= '\u0039' // digit
+    || char >= '\u0041' && char <= '\u005a' // uppercase letter
+    || char >= '\u0061' && char <= '\u007a' // lowercase letter
+    || char >= '\u0030' && char <= '\u0039' // digit
+    || char === '\u005f' // "_"
+    || char === '\u002d'; // "-"
+  }
+  function readIdentifier() {
+    let result = '';
+    skipSpaces();
+    while (!EOL && isCSSNameChar(next())) result += eat1();
+    return result;
+  }
+  function readQuotedString(quote) {
+    let result = eat1();
+    if (result !== quote) syntaxError('parsing quoted string');
+    while (!EOL && next() !== quote) {
+      if (next() === '\\') eat1();
+      result += eat1();
+    }
+    if (next() !== quote) syntaxError('parsing quoted string');
+    result += eat1();
+    return result;
+  }
+  function readRegularExpression() {
+    if (eat1() !== '/') syntaxError('parsing regular expression');
+    let source = '';
+    let inClass = false;
+    // https://262.ecma-international.org/11.0/#sec-literals-regular-expression-literals
+    while (!EOL) {
+      if (next() === '\\') {
+        source += eat1();
+        if (EOL) syntaxError('parsing regular expression');
+      } else if (inClass && next() === ']') {
+        inClass = false;
+      } else if (!inClass && next() === '[') {
+        inClass = true;
+      } else if (!inClass && next() === '/') {
+        break;
+      }
+      source += eat1();
+    }
+    if (eat1() !== '/') syntaxError('parsing regular expression');
+    let flags = '';
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
+    while (!EOL && next().match(/[dgimsuy]/)) flags += eat1();
+    try {
+      return new RegExp(source, flags);
+    } catch (e) {
+      throw new _cssParser.InvalidSelectorError(`Error while parsing selector \`${selector}\`: ${e.message}`);
+    }
+  }
+  function readAttributeToken() {
+    let token = '';
+    skipSpaces();
+    if (next() === `'` || next() === `"`) token = readQuotedString(next()).slice(1, -1);else token = readIdentifier();
+    if (!token) syntaxError('parsing property path');
+    return token;
+  }
+  function readOperator() {
+    skipSpaces();
+    let op = '';
+    if (!EOL) op += eat1();
+    if (!EOL && op !== '=') op += eat1();
+    if (!['=', '*=', '^=', '$=', '|=', '~='].includes(op)) syntaxError('parsing operator');
+    return op;
+  }
+  function readAttribute() {
+    // skip leading [
+    eat1();
+
+    // read attribute name:
+    // foo.bar
+    // 'foo'  . "ba zz"
+    const jsonPath = [];
+    jsonPath.push(readAttributeToken());
+    skipSpaces();
+    while (next() === '.') {
+      eat1();
+      jsonPath.push(readAttributeToken());
+      skipSpaces();
+    }
+    // check property is truthy: [enabled]
+    if (next() === ']') {
+      eat1();
+      return {
+        name: jsonPath.join('.'),
+        jsonPath,
+        op: '<truthy>',
+        value: null,
+        caseSensitive: false
+      };
+    }
+    const operator = readOperator();
+    let value = undefined;
+    let caseSensitive = true;
+    skipSpaces();
+    if (next() === '/') {
+      if (operator !== '=') throw new _cssParser.InvalidSelectorError(`Error while parsing selector \`${selector}\` - cannot use ${operator} in attribute with regular expression`);
+      value = readRegularExpression();
+    } else if (next() === `'` || next() === `"`) {
+      value = readQuotedString(next()).slice(1, -1);
+      skipSpaces();
+      if (next() === 'i' || next() === 'I') {
+        caseSensitive = false;
+        eat1();
+      } else if (next() === 's' || next() === 'S') {
+        caseSensitive = true;
+        eat1();
+      }
+    } else {
+      value = '';
+      while (!EOL && (isCSSNameChar(next()) || next() === '+' || next() === '.')) value += eat1();
+      if (value === 'true') {
+        value = true;
+      } else if (value === 'false') {
+        value = false;
+      } else {
+        if (!allowUnquotedStrings) {
+          value = +value;
+          if (Number.isNaN(value)) syntaxError('parsing attribute value');
+        }
+      }
+    }
+    skipSpaces();
+    if (next() !== ']') syntaxError('parsing attribute value');
+    eat1();
+    if (operator !== '=' && typeof value !== 'string') throw new _cssParser.InvalidSelectorError(`Error while parsing selector \`${selector}\` - cannot use ${operator} in attribute with non-string matching value - ${value}`);
+    return {
+      name: jsonPath.join('.'),
+      jsonPath,
+      op: operator,
+      value,
+      caseSensitive
+    };
+  }
+  const result = {
+    name: '',
+    attributes: []
+  };
+  result.name = readIdentifier();
+  skipSpaces();
+  while (next() === '[') {
+    result.attributes.push(readAttribute());
+    skipSpaces();
+  }
+  if (!EOL) syntaxError(undefined);
+  if (!result.name && !result.attributes.length) throw new _cssParser.InvalidSelectorError(`Error while parsing selector \`${selector}\` - selector cannot be empty`);
+  return result;
+}

package/lib/utils/isomorphic/stringUtils.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cacheNormalizedWhitespaces = cacheNormalizedWhitespaces;
+exports.cssEscape = cssEscape;
+exports.escapeForAttributeSelector = escapeForAttributeSelector;
+exports.escapeForTextSelector = escapeForTextSelector;
+exports.escapeHTML = escapeHTML;
+exports.escapeHTMLAttribute = escapeHTMLAttribute;
+exports.escapeRegExp = escapeRegExp;
+exports.escapeWithQuotes = escapeWithQuotes;
+exports.isString = isString;
+exports.normalizeEscapedRegexQuotes = normalizeEscapedRegexQuotes;
+exports.normalizeWhiteSpace = normalizeWhiteSpace;
+exports.quoteCSSAttributeValue = quoteCSSAttributeValue;
+exports.toSnakeCase = toSnakeCase;
+exports.toTitleCase = toTitleCase;
+exports.trimString = trimString;
+exports.trimStringWithEllipsis = trimStringWithEllipsis;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// NOTE: this function should not be used to escape any selectors.
+function escapeWithQuotes(text, char = '\'') {
+  const stringified = JSON.stringify(text);
+  const escapedText = stringified.substring(1, stringified.length - 1).replace(/\\"/g, '"');
+  if (char === '\'') return char + escapedText.replace(/[']/g, '\\\'') + char;
+  if (char === '"') return char + escapedText.replace(/["]/g, '\\"') + char;
+  if (char === '`') return char + escapedText.replace(/[`]/g, '`') + char;
+  throw new Error('Invalid escape char');
+}
+function isString(obj) {
+  return typeof obj === 'string' || obj instanceof String;
+}
+function toTitleCase(name) {
+  return name.charAt(0).toUpperCase() + name.substring(1);
+}
+function toSnakeCase(name) {
+  // E.g. ignoreHTTPSErrors => ignore_https_errors.
+  return name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/([A-Z])([A-Z][a-z])/g, '$1_$2').toLowerCase();
+}
+function cssEscape(s) {
+  let result = '';
+  for (let i = 0; i < s.length; i++) result += cssEscapeOne(s, i);
+  return result;
+}
+function quoteCSSAttributeValue(text) {
+  return `"${cssEscape(text).replace(/\\ /g, ' ')}"`;
+}
+function cssEscapeOne(s, i) {
+  // https://drafts.csswg.org/cssom/#serialize-an-identifier
+  const c = s.charCodeAt(i);
+  if (c === 0x0000) return '\uFFFD';
+  if (c >= 0x0001 && c <= 0x001f || c >= 0x0030 && c <= 0x0039 && (i === 0 || i === 1 && s.charCodeAt(0) === 0x002d)) return '\\' + c.toString(16) + ' ';
+  if (i === 0 && c === 0x002d && s.length === 1) return '\\' + s.charAt(i);
+  if (c >= 0x0080 || c === 0x002d || c === 0x005f || c >= 0x0030 && c <= 0x0039 || c >= 0x0041 && c <= 0x005a || c >= 0x0061 && c <= 0x007a) return s.charAt(i);
+  return '\\' + s.charAt(i);
+}
+let normalizedWhitespaceCache;
+function cacheNormalizedWhitespaces() {
+  normalizedWhitespaceCache = new Map();
+}
+function normalizeWhiteSpace(text) {
+  var _normalizedWhitespace;
+  let result = (_normalizedWhitespace = normalizedWhitespaceCache) === null || _normalizedWhitespace === void 0 ? void 0 : _normalizedWhitespace.get(text);
+  if (result === undefined) {
+    var _normalizedWhitespace2;
+    result = text.replace(/\u200b/g, '').trim().replace(/\s+/g, ' ');
+    (_normalizedWhitespace2 = normalizedWhitespaceCache) === null || _normalizedWhitespace2 === void 0 || _normalizedWhitespace2.set(text, result);
+  }
+  return result;
+}
+function normalizeEscapedRegexQuotes(source) {
+  // This function reverses the effect of escapeRegexForSelector below.
+  // Odd number of backslashes followed by the quote -> remove unneeded backslash.
+  return source.replace(/(^|[^\\])(\\\\)*\\(['"`])/g, '$1$2$3');
+}
+function escapeRegexForSelector(re) {
+  // Unicode mode does not allow "identity character escapes", so we do not escape and
+  // hope that it does not contain quotes and/or >> signs.
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Character_escape
+  // TODO: rework RE usages in internal selectors away from literal representation to json, e.g. {source,flags}.
+  if (re.unicode || re.unicodeSets) return String(re);
+  // Even number of backslashes followed by the quote -> insert a backslash.
+  return String(re).replace(/(^|[^\\])(\\\\)*(["'`])/g, '$1$2\\$3').replace(/>>/g, '\\>\\>');
+}
+function escapeForTextSelector(text, exact) {
+  if (typeof text !== 'string') return escapeRegexForSelector(text);
+  return `${JSON.stringify(text)}${exact ? 's' : 'i'}`;
+}
+function escapeForAttributeSelector(value, exact) {
+  if (typeof value !== 'string') return escapeRegexForSelector(value);
+  // TODO: this should actually be
+  //   cssEscape(value).replace(/\\ /g, ' ')
+  // However, our attribute selectors do not conform to CSS parsing spec,
+  // so we escape them differently.
+  return `"${value.replace(/\\/g, '\\\\').replace(/["]/g, '\\"')}"${exact ? 's' : 'i'}`;
+}
+function trimString(input, cap, suffix = '') {
+  if (input.length <= cap) return input;
+  const chars = [...input];
+  if (chars.length > cap) return chars.slice(0, cap - suffix.length).join('') + suffix;
+  return chars.join('');
+}
+function trimStringWithEllipsis(input, cap) {
+  return trimString(input, cap, '\u2026');
+}
+function escapeRegExp(s) {
+  // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+const escaped = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  '\'': '&#39;'
+};
+function escapeHTMLAttribute(s) {
+  return s.replace(/[&<>"']/ug, char => escaped[char]);
+}
+function escapeHTML(s) {
+  return s.replace(/[&<]/ug, char => escaped[char]);
+}

package/lib/utils/isomorphic/traceUtils.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseClientSideCallMetadata = parseClientSideCallMetadata;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function parseClientSideCallMetadata(data) {
+  const result = new Map();
+  const {
+    files,
+    stacks
+  } = data;
+  for (const s of stacks) {
+    const [id, ff] = s;
+    result.set(`call@${id}`, ff.map(f => ({
+      file: files[f[0]],
+      line: f[1],
+      column: f[2],
+      function: f[3]
+    })));
+  }
+  return result;
+}

package/lib/utils/isomorphic/urlMatch.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.constructURLBasedOnBaseURL = constructURLBasedOnBaseURL;
+exports.globToRegex = globToRegex;
+exports.urlMatches = urlMatches;
+exports.urlMatchesEqual = urlMatchesEqual;
+var _stringUtils = require("./stringUtils");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping
+const escapedChars = new Set(['$', '^', '+', '.', '*', '(', ')', '|', '\\', '?', '{', '}', '[', ']']);
+function globToRegex(glob) {
+  const tokens = ['^'];
+  let inGroup = false;
+  for (let i = 0; i < glob.length; ++i) {
+    const c = glob[i];
+    if (c === '\\' && i + 1 < glob.length) {
+      const char = glob[++i];
+      tokens.push(escapedChars.has(char) ? '\\' + char : char);
+      continue;
+    }
+    if (c === '*') {
+      const beforeDeep = glob[i - 1];
+      let starCount = 1;
+      while (glob[i + 1] === '*') {
+        starCount++;
+        i++;
+      }
+      const afterDeep = glob[i + 1];
+      const isDeep = starCount > 1 && (beforeDeep === '/' || beforeDeep === undefined) && (afterDeep === '/' || afterDeep === undefined);
+      if (isDeep) {
+        tokens.push('((?:[^/]*(?:\/|$))*)');
+        i++;
+      } else {
+        tokens.push('([^/]*)');
+      }
+      continue;
+    }
+    switch (c) {
+      case '?':
+        tokens.push('.');
+        break;
+      case '[':
+        tokens.push('[');
+        break;
+      case ']':
+        tokens.push(']');
+        break;
+      case '{':
+        inGroup = true;
+        tokens.push('(');
+        break;
+      case '}':
+        inGroup = false;
+        tokens.push(')');
+        break;
+      case ',':
+        if (inGroup) {
+          tokens.push('|');
+          break;
+        }
+        tokens.push('\\' + c);
+        break;
+      default:
+        tokens.push(escapedChars.has(c) ? '\\' + c : c);
+    }
+  }
+  tokens.push('$');
+  return new RegExp(tokens.join(''));
+}
+function isRegExp(obj) {
+  return obj instanceof RegExp || Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+function urlMatchesEqual(match1, match2) {
+  if (isRegExp(match1) && isRegExp(match2)) return match1.source === match2.source && match1.flags === match2.flags;
+  return match1 === match2;
+}
+function urlMatches(baseURL, urlString, match) {
+  if (match === undefined || match === '') return true;
+  if ((0, _stringUtils.isString)(match) && !match.startsWith('*')) match = constructURLBasedOnBaseURL(baseURL, match);
+  if ((0, _stringUtils.isString)(match)) match = globToRegex(match);
+  if (isRegExp(match)) return match.test(urlString);
+  if (typeof match === 'string' && match === urlString) return true;
+  const url = parsedURL(urlString);
+  if (!url) return false;
+  if (typeof match === 'string') return url.pathname === match;
+  if (typeof match !== 'function') throw new Error('url parameter should be string, RegExp or function');
+  return match(url);
+}
+function parsedURL(url) {
+  try {
+    return new URL(url);
+  } catch (e) {
+    return null;
+  }
+}
+function constructURLBasedOnBaseURL(baseURL, givenURL) {
+  try {
+    return new URL(givenURL, baseURL).toString();
+  } catch (e) {
+    return givenURL;
+  }
+}