rebrowser-playwright-core 1.49.0 → 1.52.0

package/lib/utils/isomorphic/stackTrace.js

@@ -0,0 +1,158 @@
+"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 stackTrace_exports = {};
+__export(stackTrace_exports, {
+  captureRawStack: () => captureRawStack,
+  parseErrorStack: () => parseErrorStack,
+  parseStackFrame: () => parseStackFrame,
+  rewriteErrorMessage: () => rewriteErrorMessage,
+  splitErrorMessage: () => splitErrorMessage,
+  stringifyStackFrames: () => stringifyStackFrames
+});
+module.exports = __toCommonJS(stackTrace_exports);
+function captureRawStack() {
+  const stackTraceLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 50;
+  const error = new Error();
+  const stack = error.stack || "";
+  Error.stackTraceLimit = stackTraceLimit;
+  return stack.split("\n");
+}
+function parseStackFrame(text, pathSeparator, showInternalStackFrames) {
+  const match = text && text.match(re);
+  if (!match)
+    return null;
+  let fname = match[2];
+  let file = match[7];
+  if (!file)
+    return null;
+  if (!showInternalStackFrames && (file.startsWith("internal") || file.startsWith("node:")))
+    return null;
+  const line = match[8];
+  const column = match[9];
+  const closeParen = match[11] === ")";
+  const frame = {
+    file: "",
+    line: 0,
+    column: 0
+  };
+  if (line)
+    frame.line = Number(line);
+  if (column)
+    frame.column = Number(column);
+  if (closeParen && file) {
+    let closes = 0;
+    for (let i = file.length - 1; i > 0; i--) {
+      if (file.charAt(i) === ")") {
+        closes++;
+      } else if (file.charAt(i) === "(" && file.charAt(i - 1) === " ") {
+        closes--;
+        if (closes === -1 && file.charAt(i - 1) === " ") {
+          const before = file.slice(0, i - 1);
+          const after = file.slice(i + 1);
+          file = after;
+          fname += ` (${before}`;
+          break;
+        }
+      }
+    }
+  }
+  if (fname) {
+    const methodMatch = fname.match(methodRe);
+    if (methodMatch)
+      fname = methodMatch[1];
+  }
+  if (file) {
+    if (file.startsWith("file://"))
+      file = fileURLToPath(file, pathSeparator);
+    frame.file = file;
+  }
+  if (fname)
+    frame.function = fname;
+  return frame;
+}
+function rewriteErrorMessage(e, newMessage) {
+  const lines = (e.stack?.split("\n") || []).filter((l) => l.startsWith("    at "));
+  e.message = newMessage;
+  const errorTitle = `${e.name}: ${e.message}`;
+  if (lines.length)
+    e.stack = `${errorTitle}
+${lines.join("\n")}`;
+  return e;
+}
+function stringifyStackFrames(frames) {
+  const stackLines = [];
+  for (const frame of frames) {
+    if (frame.function)
+      stackLines.push(`    at ${frame.function} (${frame.file}:${frame.line}:${frame.column})`);
+    else
+      stackLines.push(`    at ${frame.file}:${frame.line}:${frame.column}`);
+  }
+  return stackLines;
+}
+function splitErrorMessage(message) {
+  const separationIdx = message.indexOf(":");
+  return {
+    name: separationIdx !== -1 ? message.slice(0, separationIdx) : "",
+    message: separationIdx !== -1 && separationIdx + 2 <= message.length ? message.substring(separationIdx + 2) : message
+  };
+}
+function parseErrorStack(stack, pathSeparator, showInternalStackFrames = false) {
+  const lines = stack.split("\n");
+  let firstStackLine = lines.findIndex((line) => line.startsWith("    at "));
+  if (firstStackLine === -1)
+    firstStackLine = lines.length;
+  const message = lines.slice(0, firstStackLine).join("\n");
+  const stackLines = lines.slice(firstStackLine);
+  let location;
+  for (const line of stackLines) {
+    const frame = parseStackFrame(line, pathSeparator, showInternalStackFrames);
+    if (!frame || !frame.file)
+      continue;
+    if (belongsToNodeModules(frame.file, pathSeparator))
+      continue;
+    location = { file: frame.file, column: frame.column || 0, line: frame.line || 0 };
+    break;
+  }
+  return { message, stackLines, location };
+}
+function belongsToNodeModules(file, pathSeparator) {
+  return file.includes(`${pathSeparator}node_modules${pathSeparator}`);
+}
+const re = new RegExp(
+  "^(?:\\s*at )?(?:(new) )?(?:(.*?) \\()?(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?(?:(.+?):(\\d+):(\\d+)|(native))(\\)?)$"
+);
+const methodRe = /^(.*?) \[as (.*?)\]$/;
+function fileURLToPath(fileUrl, pathSeparator) {
+  if (!fileUrl.startsWith("file://"))
+    return fileUrl;
+  let path = decodeURIComponent(fileUrl.slice(7));
+  if (path.startsWith("/") && /^[a-zA-Z]:/.test(path.slice(1)))
+    path = path.slice(1);
+  return path.replace(/\//g, pathSeparator);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureRawStack,
+  parseErrorStack,
+  parseStackFrame,
+  rewriteErrorMessage,
+  splitErrorMessage,
+  stringifyStackFrames
+});

package/lib/utils/isomorphic/stringUtils.js

@@ -1,157 +1,145 @@
 "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 stringUtils_exports = {};
+__export(stringUtils_exports, {
+  cacheNormalizedWhitespaces: () => cacheNormalizedWhitespaces,
+  cssEscape: () => cssEscape,
+  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
 });
-exports.cacheNormalizedWhitespaces = cacheNormalizedWhitespaces;
-exports.cssEscape = cssEscape;
-exports.escapeForAttributeSelector = escapeForAttributeSelector;
-exports.escapeForTextSelector = escapeForTextSelector;
-exports.escapeHTML = escapeHTML;
-exports.escapeHTMLAttribute = escapeHTMLAttribute;
-exports.escapeRegExp = escapeRegExp;
-exports.escapeTemplateString = escapeTemplateString;
-exports.escapeWithQuotes = escapeWithQuotes;
-exports.isString = isString;
-exports.longestCommonSubstring = longestCommonSubstring;
-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 = '\'') {
+module.exports = __toCommonJS(stringUtils_exports);
+var import_builtins = require("./builtins");
+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');
+  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, '\\${');
+  return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
 }
 function isString(obj) {
-  return typeof obj === 'string' || obj instanceof String;
+  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();
+  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);
+  let result = "";
+  for (let i = 0; i < s.length; i++)
+    result += cssEscapeOne(s, i);
   return result;
 }
 function quoteCSSAttributeValue(text) {
-  return `"${cssEscape(text).replace(/\\ /g, ' ')}"`;
+  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);
+  if (c === 0)
+    return "\uFFFD";
+  if (c >= 1 && c <= 31 || c >= 48 && c <= 57 && (i === 0 || i === 1 && s.charCodeAt(0) === 45))
+    return "\\" + c.toString(16) + " ";
+  if (i === 0 && c === 45 && s.length === 1)
+    return "\\" + s.charAt(i);
+  if (c >= 128 || c === 45 || c === 95 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122)
+    return s.charAt(i);
+  return "\\" + s.charAt(i);
 }
 let normalizedWhitespaceCache;
 function cacheNormalizedWhitespaces() {
-  normalizedWhitespaceCache = new Map();
+  normalizedWhitespaceCache = new import_builtins.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);
+  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) {
-  // 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');
+  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, '\\>\\>');
+  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'}`;
+  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;
+  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('');
+  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');
+  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;'
-};
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const escaped = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
 function escapeHTMLAttribute(s) {
-  return s.replace(/[&<>"']/ug, char => escaped[char]);
+  return s.replace(/[&<>"']/ug, (char) => escaped[char]);
 }
 function escapeHTML(s) {
-  return s.replace(/[&<]/ug, char => escaped[char]);
+  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;
-
-  // Initialize a 2D array with zeros
   const dp = Array(n + 1).fill(null).map(() => Array(m + 1).fill(0));
-
-  // Build the dp table
   for (let i = 1; i <= n; i++) {
     for (let j = 1; j <= m; j++) {
       if (s1[i - 1] === s2[j - 1]) {
@@ -163,7 +151,26 @@ function longestCommonSubstring(s1, s2) {
       }
     }
   }
-
-  // Extract the longest common substring
   return s1.slice(endingIndex - maxLen, endingIndex);
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheNormalizedWhitespaces,
+  cssEscape,
+  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,44 @@
+"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, {
+  monotonicTime: () => monotonicTime,
+  setTimeOrigin: () => setTimeOrigin,
+  timeOrigin: () => timeOrigin
+});
+module.exports = __toCommonJS(time_exports);
+var import_builtins = require("./builtins");
+let _timeOrigin = import_builtins.performance.timeOrigin;
+let _timeShift = 0;
+function setTimeOrigin(origin) {
+  _timeOrigin = origin;
+  _timeShift = import_builtins.performance.timeOrigin - origin;
+}
+function timeOrigin() {
+  return _timeOrigin;
+}
+function monotonicTime() {
+  return Math.floor((import_builtins.performance.now() + _timeShift) * 1e3) / 1e3;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  monotonicTime,
+  setTimeOrigin,
+  timeOrigin
+});

package/lib/utils/isomorphic/timeoutRunner.js

@@ -0,0 +1,67 @@
+"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_builtins = require("./builtins");
+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 = (0, import_builtins.setTimeout)(() => resolve({ timedOut: true }), timeout);
+    })
+  ]).finally(() => {
+    (0, import_builtins.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) => (0, import_builtins.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

@@ -1,39 +1,59 @@
 "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 traceUtils_exports = {};
+__export(traceUtils_exports, {
+  parseClientSideCallMetadata: () => parseClientSideCallMetadata,
+  serializeClientSideCallMetadata: () => serializeClientSideCallMetadata
 });
-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.
- */
-
+module.exports = __toCommonJS(traceUtils_exports);
+var import_builtins = require("./builtins");
 function parseClientSideCallMetadata(data) {
-  const result = new Map();
-  const {
-    files,
-    stacks
-  } = data;
+  const result = new import_builtins.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]
-    })));
+    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 = new import_builtins.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);