rebrowser-playwright-core 1.49.0 → 1.52.0

package/lib/utils/isomorphic/urlMatch.js

@@ -1,114 +1,149 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var urlMatch_exports = {};
+__export(urlMatch_exports, {
+  constructURLBasedOnBaseURL: () => constructURLBasedOnBaseURL,
+  globToRegexPattern: () => globToRegexPattern,
+  resolveGlobToRegexPattern: () => resolveGlobToRegexPattern,
+  urlMatches: () => urlMatches,
+  urlMatchesEqual: () => urlMatchesEqual
 });
-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 = ['^'];
+module.exports = __toCommonJS(urlMatch_exports);
+var import_builtins = require("./builtins");
+var import_stringUtils = require("./stringUtils");
+const escapedChars = new import_builtins.Set(["$", "^", "+", ".", "*", "(", ")", "|", "\\", "?", "{", "}", "[", "]"]);
+function globToRegexPattern(glob) {
+  const tokens = ["^"];
   let inGroup = false;
   for (let i = 0; i < glob.length; ++i) {
     const c = glob[i];
-    if (c === '\\' && i + 1 < glob.length) {
+    if (c === "\\" && i + 1 < glob.length) {
       const char = glob[++i];
-      tokens.push(escapedChars.has(char) ? '\\' + char : char);
+      tokens.push(escapedChars.has(char) ? "\\" + char : char);
       continue;
     }
-    if (c === '*') {
+    if (c === "*") {
       const beforeDeep = glob[i - 1];
       let starCount = 1;
-      while (glob[i + 1] === '*') {
+      while (glob[i + 1] === "*") {
         starCount++;
         i++;
       }
       const afterDeep = glob[i + 1];
-      const isDeep = starCount > 1 && (beforeDeep === '/' || beforeDeep === undefined) && (afterDeep === '/' || afterDeep === undefined);
+      const isDeep = starCount > 1 && (beforeDeep === "/" || beforeDeep === void 0) && (afterDeep === "/" || afterDeep === void 0);
       if (isDeep) {
-        tokens.push('((?:[^/]*(?:\/|$))*)');
+        tokens.push("((?:[^/]*(?:/|$))*)");
         i++;
       } else {
-        tokens.push('([^/]*)');
+        tokens.push("([^/]*)");
       }
       continue;
     }
     switch (c) {
-      case '?':
-        tokens.push('.');
-        break;
-      case '[':
-        tokens.push('[');
-        break;
-      case ']':
-        tokens.push(']');
-        break;
-      case '{':
+      case "{":
         inGroup = true;
-        tokens.push('(');
+        tokens.push("(");
         break;
-      case '}':
+      case "}":
         inGroup = false;
-        tokens.push(')');
+        tokens.push(")");
         break;
-      case ',':
+      case ",":
         if (inGroup) {
-          tokens.push('|');
+          tokens.push("|");
           break;
         }
-        tokens.push('\\' + c);
+        tokens.push("\\" + c);
         break;
       default:
-        tokens.push(escapedChars.has(c) ? '\\' + c : c);
+        tokens.push(escapedChars.has(c) ? "\\" + c : c);
     }
   }
-  tokens.push('$');
-  return new RegExp(tokens.join(''));
+  tokens.push("$");
+  return tokens.join("");
 }
 function isRegExp(obj) {
-  return obj instanceof RegExp || Object.prototype.toString.call(obj) === '[object RegExp]';
+  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;
+  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('*')) {
-    // Allow http(s) baseURL to match ws(s) urls.
-    if (baseURL && /^https?:\/\//.test(baseURL) && /^wss?:\/\//.test(urlString)) baseURL = baseURL.replace(/^http/, 'ws');
-    match = constructURLBasedOnBaseURL(baseURL, match);
+function urlMatches(baseURL, urlString, match, webSocketUrl) {
+  if (match === void 0 || match === "")
+    return true;
+  if ((0, import_stringUtils.isString)(match))
+    match = new RegExp(resolveGlobToRegexPattern(baseURL, match, webSocketUrl));
+  if (isRegExp(match)) {
+    const r = match.test(urlString);
+    return r;
   }
-  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');
+  const url = parseURL(urlString);
+  if (!url)
+    return false;
+  if (typeof match !== "function")
+    throw new Error("url parameter should be string, RegExp or function");
   return match(url);
 }
-function parsedURL(url) {
+function resolveGlobToRegexPattern(baseURL, glob, webSocketUrl) {
+  if (webSocketUrl)
+    baseURL = toWebSocketBaseUrl(baseURL);
+  glob = resolveGlobBase(baseURL, glob);
+  return globToRegexPattern(glob);
+}
+function toWebSocketBaseUrl(baseURL) {
+  if (baseURL && /^https?:\/\//.test(baseURL))
+    baseURL = baseURL.replace(/^http/, "ws");
+  return baseURL;
+}
+function resolveGlobBase(baseURL, match) {
+  if (!match.startsWith("*")) {
+    let mapToken2 = function(original, replacement) {
+      if (original.length === 0)
+        return "";
+      tokenMap.set(replacement, original);
+      return replacement;
+    };
+    var mapToken = mapToken2;
+    const tokenMap = new import_builtins.Map();
+    match = match.replaceAll(/\\\\\?/g, "?");
+    const relativePath = match.split("/").map((token, index) => {
+      if (token === "." || token === ".." || token === "")
+        return token;
+      if (index === 0 && token.endsWith(":"))
+        return mapToken2(token, "http:");
+      const questionIndex = token.indexOf("?");
+      if (questionIndex === -1)
+        return mapToken2(token, `$_${index}_$`);
+      const newPrefix = mapToken2(token.substring(0, questionIndex), `$_${index}_$`);
+      const newSuffix = mapToken2(token.substring(questionIndex), `?$_${index}_$`);
+      return newPrefix + newSuffix;
+    }).join("/");
+    let resolved = constructURLBasedOnBaseURL(baseURL, relativePath);
+    for (const [token, original] of tokenMap)
+      resolved = resolved.replace(token, original);
+    match = resolved;
+  }
+  return match;
+}
+function parseURL(url) {
   try {
     return new URL(url);
   } catch (e) {
@@ -121,4 +156,12 @@ function constructURLBasedOnBaseURL(baseURL, givenURL) {
   } catch (e) {
     return givenURL;
   }
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  constructURLBasedOnBaseURL,
+  globToRegexPattern,
+  resolveGlobToRegexPattern,
+  urlMatches,
+  urlMatchesEqual
+});

package/lib/utils/isomorphic/utilityScriptSerializers.js

@@ -0,0 +1,248 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utilityScriptSerializers_exports = {};
+__export(utilityScriptSerializers_exports, {
+  source: () => source
+});
+module.exports = __toCommonJS(utilityScriptSerializers_exports);
+function source(builtins) {
+  function isRegExp(obj) {
+    try {
+      return obj instanceof RegExp || Object.prototype.toString.call(obj) === "[object RegExp]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isDate(obj) {
+    try {
+      return obj instanceof builtins.Date || Object.prototype.toString.call(obj) === "[object Date]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isURL(obj) {
+    try {
+      return obj instanceof URL || Object.prototype.toString.call(obj) === "[object URL]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isError(obj) {
+    try {
+      return obj instanceof Error || obj && Object.getPrototypeOf(obj)?.name === "Error";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isTypedArray(obj, constructor) {
+    try {
+      return obj instanceof constructor || Object.prototype.toString.call(obj) === `[object ${constructor.name}]`;
+    } catch (error) {
+      return false;
+    }
+  }
+  const typedArrayConstructors = {
+    i8: Int8Array,
+    ui8: Uint8Array,
+    ui8c: Uint8ClampedArray,
+    i16: Int16Array,
+    ui16: Uint16Array,
+    i32: Int32Array,
+    ui32: Uint32Array,
+    // TODO: add Float16Array once it's in baseline
+    f32: Float32Array,
+    f64: Float64Array,
+    bi64: BigInt64Array,
+    bui64: BigUint64Array
+  };
+  function typedArrayToBase64(array) {
+    if ("toBase64" in array)
+      return array.toBase64();
+    const binary = Array.from(new Uint8Array(array.buffer, array.byteOffset, array.byteLength)).map((b) => String.fromCharCode(b)).join("");
+    return btoa(binary);
+  }
+  function base64ToTypedArray(base64, TypedArrayConstructor) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+      bytes[i] = binary.charCodeAt(i);
+    return new TypedArrayConstructor(bytes.buffer);
+  }
+  function parseEvaluationResultValue(value, handles = [], refs = new builtins.Map()) {
+    if (Object.is(value, void 0))
+      return void 0;
+    if (typeof value === "object" && value) {
+      if ("ref" in value)
+        return refs.get(value.ref);
+      if ("v" in value) {
+        if (value.v === "undefined")
+          return void 0;
+        if (value.v === "null")
+          return null;
+        if (value.v === "NaN")
+          return NaN;
+        if (value.v === "Infinity")
+          return Infinity;
+        if (value.v === "-Infinity")
+          return -Infinity;
+        if (value.v === "-0")
+          return -0;
+        return void 0;
+      }
+      if ("d" in value)
+        return new builtins.Date(value.d);
+      if ("u" in value)
+        return new URL(value.u);
+      if ("bi" in value)
+        return BigInt(value.bi);
+      if ("e" in value) {
+        const error = new Error(value.e.m);
+        error.name = value.e.n;
+        error.stack = value.e.s;
+        return error;
+      }
+      if ("r" in value)
+        return new RegExp(value.r.p, value.r.f);
+      if ("a" in value) {
+        const result = [];
+        refs.set(value.id, result);
+        for (const a of value.a)
+          result.push(parseEvaluationResultValue(a, handles, refs));
+        return result;
+      }
+      if ("o" in value) {
+        const result = {};
+        refs.set(value.id, result);
+        for (const { k, v } of value.o)
+          result[k] = parseEvaluationResultValue(v, handles, refs);
+        return result;
+      }
+      if ("h" in value)
+        return handles[value.h];
+      if ("ta" in value)
+        return base64ToTypedArray(value.ta.b, typedArrayConstructors[value.ta.k]);
+    }
+    return value;
+  }
+  function serializeAsCallArgument(value, handleSerializer) {
+    return serialize(value, handleSerializer, { visited: new builtins.Map(), lastId: 0 });
+  }
+  function serialize(value, handleSerializer, visitorInfo) {
+    if (value && typeof value === "object") {
+      if (typeof globalThis.Window === "function" && value instanceof globalThis.Window)
+        return "ref: <Window>";
+      if (typeof globalThis.Document === "function" && value instanceof globalThis.Document)
+        return "ref: <Document>";
+      if (typeof globalThis.Node === "function" && value instanceof globalThis.Node)
+        return "ref: <Node>";
+    }
+    return innerSerialize(value, handleSerializer, visitorInfo);
+  }
+  function innerSerialize(value, handleSerializer, visitorInfo) {
+    const result = handleSerializer(value);
+    if ("fallThrough" in result)
+      value = result.fallThrough;
+    else
+      return result;
+    if (typeof value === "symbol")
+      return { v: "undefined" };
+    if (Object.is(value, void 0))
+      return { v: "undefined" };
+    if (Object.is(value, null))
+      return { v: "null" };
+    if (Object.is(value, NaN))
+      return { v: "NaN" };
+    if (Object.is(value, Infinity))
+      return { v: "Infinity" };
+    if (Object.is(value, -Infinity))
+      return { v: "-Infinity" };
+    if (Object.is(value, -0))
+      return { v: "-0" };
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number")
+      return value;
+    if (typeof value === "string")
+      return value;
+    if (typeof value === "bigint")
+      return { bi: value.toString() };
+    if (isError(value)) {
+      let stack;
+      if (value.stack?.startsWith(value.name + ": " + value.message)) {
+        stack = value.stack;
+      } else {
+        stack = `${value.name}: ${value.message}
+${value.stack}`;
+      }
+      return { e: { n: value.name, m: value.message, s: stack } };
+    }
+    if (isDate(value))
+      return { d: value.toJSON() };
+    if (isURL(value))
+      return { u: value.toJSON() };
+    if (isRegExp(value))
+      return { r: { p: value.source, f: value.flags } };
+    for (const [k, ctor] of Object.entries(typedArrayConstructors)) {
+      if (isTypedArray(value, ctor))
+        return { ta: { b: typedArrayToBase64(value), k } };
+    }
+    const id = visitorInfo.visited.get(value);
+    if (id)
+      return { ref: id };
+    if (Array.isArray(value)) {
+      const a = [];
+      const id2 = ++visitorInfo.lastId;
+      visitorInfo.visited.set(value, id2);
+      for (let i = 0; i < value.length; ++i)
+        a.push(serialize(value[i], handleSerializer, visitorInfo));
+      return { a, id: id2 };
+    }
+    if (typeof value === "object") {
+      const o = [];
+      const id2 = ++visitorInfo.lastId;
+      visitorInfo.visited.set(value, id2);
+      for (const name of Object.keys(value)) {
+        let item;
+        try {
+          item = value[name];
+        } catch (e) {
+          continue;
+        }
+        if (name === "toJSON" && typeof item === "function")
+          o.push({ k: name, v: { o: [], id: 0 } });
+        else
+          o.push({ k: name, v: serialize(item, handleSerializer, visitorInfo) });
+      }
+      let jsonWrapper;
+      try {
+        if (o.length === 0 && value.toJSON && typeof value.toJSON === "function")
+          jsonWrapper = { value: value.toJSON() };
+      } catch (e) {
+      }
+      if (jsonWrapper)
+        return innerSerialize(jsonWrapper.value, handleSerializer, visitorInfo);
+      return { o, id: id2 };
+    }
+  }
+  return { parseEvaluationResultValue, serializeAsCallArgument };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  source
+});

package/lib/utils.js

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  colors: () => import_utilsBundle.colors
+});
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./utils/isomorphic/colors"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/assert"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/headers"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/locatorGenerators"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/manualPromise"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/mimeType"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/multimap"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/rtti"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/semaphore"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/stackTrace"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/stringUtils"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/time"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/timeoutRunner"), module.exports);
+__reExport(utils_exports, require("./utils/isomorphic/urlMatch"), module.exports);
+__reExport(utils_exports, require("./server/utils/ascii"), module.exports);
+__reExport(utils_exports, require("./server/utils/comparators"), module.exports);
+__reExport(utils_exports, require("./server/utils/crypto"), module.exports);
+__reExport(utils_exports, require("./server/utils/debug"), module.exports);
+__reExport(utils_exports, require("./server/utils/debugLogger"), module.exports);
+__reExport(utils_exports, require("./server/utils/env"), module.exports);
+__reExport(utils_exports, require("./server/utils/eventsHelper"), module.exports);
+__reExport(utils_exports, require("./server/utils/expectUtils"), module.exports);
+__reExport(utils_exports, require("./server/utils/fileUtils"), module.exports);
+__reExport(utils_exports, require("./server/utils/hostPlatform"), module.exports);
+__reExport(utils_exports, require("./server/utils/httpServer"), module.exports);
+__reExport(utils_exports, require("./server/utils/network"), module.exports);
+__reExport(utils_exports, require("./server/utils/nodePlatform"), module.exports);
+__reExport(utils_exports, require("./server/utils/processLauncher"), module.exports);
+__reExport(utils_exports, require("./server/utils/profiler"), module.exports);
+__reExport(utils_exports, require("./server/utils/socksProxy"), module.exports);
+__reExport(utils_exports, require("./server/utils/spawnAsync"), module.exports);
+__reExport(utils_exports, require("./server/utils/task"), module.exports);
+__reExport(utils_exports, require("./server/utils/userAgent"), module.exports);
+__reExport(utils_exports, require("./server/utils/wsServer"), module.exports);
+__reExport(utils_exports, require("./server/utils/zipFile"), module.exports);
+__reExport(utils_exports, require("./server/utils/zones"), module.exports);
+var import_utilsBundle = require("./utilsBundle");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  colors,
+  ...require("./utils/isomorphic/colors"),
+  ...require("./utils/isomorphic/assert"),
+  ...require("./utils/isomorphic/headers"),
+  ...require("./utils/isomorphic/locatorGenerators"),
+  ...require("./utils/isomorphic/manualPromise"),
+  ...require("./utils/isomorphic/mimeType"),
+  ...require("./utils/isomorphic/multimap"),
+  ...require("./utils/isomorphic/rtti"),
+  ...require("./utils/isomorphic/semaphore"),
+  ...require("./utils/isomorphic/stackTrace"),
+  ...require("./utils/isomorphic/stringUtils"),
+  ...require("./utils/isomorphic/time"),
+  ...require("./utils/isomorphic/timeoutRunner"),
+  ...require("./utils/isomorphic/urlMatch"),
+  ...require("./server/utils/ascii"),
+  ...require("./server/utils/comparators"),
+  ...require("./server/utils/crypto"),
+  ...require("./server/utils/debug"),
+  ...require("./server/utils/debugLogger"),
+  ...require("./server/utils/env"),
+  ...require("./server/utils/eventsHelper"),
+  ...require("./server/utils/expectUtils"),
+  ...require("./server/utils/fileUtils"),
+  ...require("./server/utils/hostPlatform"),
+  ...require("./server/utils/httpServer"),
+  ...require("./server/utils/network"),
+  ...require("./server/utils/nodePlatform"),
+  ...require("./server/utils/processLauncher"),
+  ...require("./server/utils/profiler"),
+  ...require("./server/utils/socksProxy"),
+  ...require("./server/utils/spawnAsync"),
+  ...require("./server/utils/task"),
+  ...require("./server/utils/userAgent"),
+  ...require("./server/utils/wsServer"),
+  ...require("./server/utils/zipFile"),
+  ...require("./server/utils/zones")
+});