@stablyai/internal-playwright-core 0.1.0

package/lib/utils/isomorphic/stringUtils.js

@@ -0,0 +1,155 @@
+"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 stringUtils_exports = {};
+__export(stringUtils_exports, {
+  cacheNormalizedWhitespaces: () => cacheNormalizedWhitespaces,
+  escapeForAttributeSelector: () => escapeForAttributeSelector,
+  escapeForTextSelector: () => escapeForTextSelector,
+  escapeHTML: () => escapeHTML,
+  escapeHTMLAttribute: () => escapeHTMLAttribute,
+  escapeRegExp: () => escapeRegExp,
+  escapeTemplateString: () => escapeTemplateString,
+  escapeWithQuotes: () => escapeWithQuotes,
+  isString: () => isString,
+  longestCommonSubstring: () => longestCommonSubstring,
+  normalizeEscapedRegexQuotes: () => normalizeEscapedRegexQuotes,
+  normalizeWhiteSpace: () => normalizeWhiteSpace,
+  quoteCSSAttributeValue: () => quoteCSSAttributeValue,
+  toSnakeCase: () => toSnakeCase,
+  toTitleCase: () => toTitleCase,
+  trimString: () => trimString,
+  trimStringWithEllipsis: () => trimStringWithEllipsis
+});
+module.exports = __toCommonJS(stringUtils_exports);
+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 escapeTemplateString(text) {
+  return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function isString(obj) {
+  return typeof obj === "string" || obj instanceof String;
+}
+function toTitleCase(name) {
+  return name.charAt(0).toUpperCase() + name.substring(1);
+}
+function toSnakeCase(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+function quoteCSSAttributeValue(text) {
+  return `"${text.replace(/["\\]/g, (char) => "\\" + char)}"`;
+}
+let normalizedWhitespaceCache;
+function cacheNormalizedWhitespaces() {
+  normalizedWhitespaceCache = /* @__PURE__ */ new Map();
+}
+function normalizeWhiteSpace(text) {
+  let result = normalizedWhitespaceCache?.get(text);
+  if (result === void 0) {
+    result = text.replace(/[\u200b\u00ad]/g, "").trim().replace(/\s+/g, " ");
+    normalizedWhitespaceCache?.set(text, result);
+  }
+  return result;
+}
+function normalizeEscapedRegexQuotes(source) {
+  return source.replace(/(^|[^\\])(\\\\)*\\(['"`])/g, "$1$2$3");
+}
+function escapeRegexForSelector(re) {
+  if (re.unicode || re.unicodeSets)
+    return String(re);
+  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);
+  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) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+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]);
+}
+function longestCommonSubstring(s1, s2) {
+  const n = s1.length;
+  const m = s2.length;
+  let maxLen = 0;
+  let endingIndex = 0;
+  const dp = Array(n + 1).fill(null).map(() => Array(m + 1).fill(0));
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) {
+      if (s1[i - 1] === s2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+        if (dp[i][j] > maxLen) {
+          maxLen = dp[i][j];
+          endingIndex = i;
+        }
+      }
+    }
+  }
+  return s1.slice(endingIndex - maxLen, endingIndex);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheNormalizedWhitespaces,
+  escapeForAttributeSelector,
+  escapeForTextSelector,
+  escapeHTML,
+  escapeHTMLAttribute,
+  escapeRegExp,
+  escapeTemplateString,
+  escapeWithQuotes,
+  isString,
+  longestCommonSubstring,
+  normalizeEscapedRegexQuotes,
+  normalizeWhiteSpace,
+  quoteCSSAttributeValue,
+  toSnakeCase,
+  toTitleCase,
+  trimString,
+  trimStringWithEllipsis
+});

package/lib/utils/isomorphic/time.js

@@ -0,0 +1,49 @@
+"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 time_exports = {};
+__export(time_exports, {
+  DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT: () => DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT,
+  DEFAULT_PLAYWRIGHT_TIMEOUT: () => DEFAULT_PLAYWRIGHT_TIMEOUT,
+  monotonicTime: () => monotonicTime,
+  setTimeOrigin: () => setTimeOrigin,
+  timeOrigin: () => timeOrigin
+});
+module.exports = __toCommonJS(time_exports);
+let _timeOrigin = performance.timeOrigin;
+let _timeShift = 0;
+function setTimeOrigin(origin) {
+  _timeOrigin = origin;
+  _timeShift = performance.timeOrigin - origin;
+}
+function timeOrigin() {
+  return _timeOrigin;
+}
+function monotonicTime() {
+  return Math.floor((performance.now() + _timeShift) * 1e3) / 1e3;
+}
+const DEFAULT_PLAYWRIGHT_TIMEOUT = 3e4;
+const DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT = 3 * 60 * 1e3;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT,
+  DEFAULT_PLAYWRIGHT_TIMEOUT,
+  monotonicTime,
+  setTimeOrigin,
+  timeOrigin
+});

package/lib/utils/isomorphic/timeoutRunner.js

@@ -0,0 +1,66 @@
+"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 timeoutRunner_exports = {};
+__export(timeoutRunner_exports, {
+  pollAgainstDeadline: () => pollAgainstDeadline,
+  raceAgainstDeadline: () => raceAgainstDeadline
+});
+module.exports = __toCommonJS(timeoutRunner_exports);
+var import_time = require("./time");
+async function raceAgainstDeadline(cb, deadline) {
+  let timer;
+  return Promise.race([
+    cb().then((result) => {
+      return { result, timedOut: false };
+    }),
+    new Promise((resolve) => {
+      const kMaxDeadline = 2147483647;
+      const timeout = (deadline || kMaxDeadline) - (0, import_time.monotonicTime)();
+      timer = setTimeout(() => resolve({ timedOut: true }), timeout);
+    })
+  ]).finally(() => {
+    clearTimeout(timer);
+  });
+}
+async function pollAgainstDeadline(callback, deadline, pollIntervals = [100, 250, 500, 1e3]) {
+  const lastPollInterval = pollIntervals.pop() ?? 1e3;
+  let lastResult;
+  const wrappedCallback = () => Promise.resolve().then(callback);
+  while (true) {
+    const time = (0, import_time.monotonicTime)();
+    if (deadline && time >= deadline)
+      break;
+    const received = await raceAgainstDeadline(wrappedCallback, deadline);
+    if (received.timedOut)
+      break;
+    lastResult = received.result.result;
+    if (!received.result.continuePolling)
+      return { result: lastResult, timedOut: false };
+    const interval = pollIntervals.shift() ?? lastPollInterval;
+    if (deadline && deadline <= (0, import_time.monotonicTime)() + interval)
+      break;
+    await new Promise((x) => setTimeout(x, interval));
+  }
+  return { timedOut: true, result: lastResult };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pollAgainstDeadline,
+  raceAgainstDeadline
+});

package/lib/utils/isomorphic/traceUtils.js

@@ -0,0 +1,58 @@
+"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 traceUtils_exports = {};
+__export(traceUtils_exports, {
+  parseClientSideCallMetadata: () => parseClientSideCallMetadata,
+  serializeClientSideCallMetadata: () => serializeClientSideCallMetadata
+});
+module.exports = __toCommonJS(traceUtils_exports);
+function parseClientSideCallMetadata(data) {
+  const result = /* @__PURE__ */ 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;
+}
+function serializeClientSideCallMetadata(metadatas) {
+  const fileNames = /* @__PURE__ */ new Map();
+  const stacks = [];
+  for (const m of metadatas) {
+    if (!m.stack || !m.stack.length)
+      continue;
+    const stack = [];
+    for (const frame of m.stack) {
+      let ordinal = fileNames.get(frame.file);
+      if (typeof ordinal !== "number") {
+        ordinal = fileNames.size;
+        fileNames.set(frame.file, ordinal);
+      }
+      const stackFrame = [ordinal, frame.line || 0, frame.column || 0, frame.function || ""];
+      stack.push(stackFrame);
+    }
+    stacks.push([m.id, stack]);
+  }
+  return { files: [...fileNames.keys()], stacks };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseClientSideCallMetadata,
+  serializeClientSideCallMetadata
+});

package/lib/utils/isomorphic/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/utils/isomorphic/urlMatch.js

@@ -0,0 +1,176 @@
+"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 urlMatch_exports = {};
+__export(urlMatch_exports, {
+  constructURLBasedOnBaseURL: () => constructURLBasedOnBaseURL,
+  globToRegexPattern: () => globToRegexPattern,
+  resolveGlobToRegexPattern: () => resolveGlobToRegexPattern,
+  urlMatches: () => urlMatches,
+  urlMatchesEqual: () => urlMatchesEqual
+});
+module.exports = __toCommonJS(urlMatch_exports);
+var import_stringUtils = require("./stringUtils");
+const escapedChars = /* @__PURE__ */ new 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) {
+      const char = glob[++i];
+      tokens.push(escapedChars.has(char) ? "\\" + char : char);
+      continue;
+    }
+    if (c === "*") {
+      let starCount = 1;
+      while (glob[i + 1] === "*") {
+        starCount++;
+        i++;
+      }
+      if (starCount > 1)
+        tokens.push("(.*)");
+      else
+        tokens.push("([^/]*)");
+      continue;
+    }
+    switch (c) {
+      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 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, 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;
+  }
+  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 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 = /* @__PURE__ */ new Map();
+    match = match.replaceAll(/\\\\\?/g, "?");
+    if (match.startsWith("about:") || match.startsWith("data:") || match.startsWith("chrome:") || match.startsWith("edge:") || match.startsWith("file:"))
+      return match;
+    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("/");
+    const result = resolveBaseURL(baseURL, relativePath);
+    let resolved = result.resolved;
+    for (const [token, original] of tokenMap) {
+      const normalize = result.caseInsensitivePart?.includes(token);
+      resolved = resolved.replace(token, normalize ? original.toLowerCase() : original);
+    }
+    match = resolved;
+  }
+  return match;
+}
+function parseURL(url) {
+  try {
+    return new URL(url);
+  } catch (e) {
+    return null;
+  }
+}
+function constructURLBasedOnBaseURL(baseURL, givenURL) {
+  try {
+    return resolveBaseURL(baseURL, givenURL).resolved;
+  } catch (e) {
+    return givenURL;
+  }
+}
+function resolveBaseURL(baseURL, givenURL) {
+  try {
+    const url = new URL(givenURL, baseURL);
+    const resolved = url.toString();
+    const caseInsensitivePrefix = url.origin;
+    return { resolved, caseInsensitivePart: caseInsensitivePrefix };
+  } catch (e) {
+    return { resolved: givenURL };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  constructURLBasedOnBaseURL,
+  globToRegexPattern,
+  resolveGlobToRegexPattern,
+  urlMatches,
+  urlMatchesEqual
+});