@browsermation/browser-engine 0.0.12 → 0.0.16

package/dist/node_modules/playwright-core/lib/server/javascript.js

@@ -0,0 +1,291 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var javascript_exports = {};
+__export(javascript_exports, {
+  ExecutionContext: () => ExecutionContext,
+  JSHandle: () => JSHandle,
+  JavaScriptErrorInEvaluate: () => JavaScriptErrorInEvaluate,
+  evaluate: () => evaluate,
+  evaluateExpression: () => evaluateExpression,
+  isJavaScriptErrorInEvaluate: () => isJavaScriptErrorInEvaluate,
+  normalizeEvaluationExpression: () => normalizeEvaluationExpression,
+  parseUnserializableValue: () => parseUnserializableValue,
+  sparseArrayToString: () => sparseArrayToString
+});
+module.exports = __toCommonJS(javascript_exports);
+var import_instrumentation = require("./instrumentation");
+var rawUtilityScriptSource = __toESM(require("../generated/utilityScriptSource"));
+var import_utils = require("../utils");
+var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+class ExecutionContext extends import_instrumentation.SdkObject {
+  constructor(parent, delegate, worldNameForTest) {
+    super(parent, "execution-context");
+    this._contextDestroyedScope = new import_manualPromise.LongStandingScope();
+    this.worldNameForTest = worldNameForTest;
+    this.delegate = delegate;
+  }
+  contextDestroyed(reason) {
+    this._contextDestroyedScope.close(new Error(reason));
+  }
+  async _raceAgainstContextDestroyed(promise) {
+    return this._contextDestroyedScope.race(promise);
+  }
+  rawEvaluateJSON(expression) {
+    return this._raceAgainstContextDestroyed(this.delegate.rawEvaluateJSON(expression));
+  }
+  rawEvaluateHandle(expression) {
+    return this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, expression));
+  }
+  async evaluateWithArguments(expression, returnByValue, values, handles) {
+    const utilityScript = await this.utilityScript();
+    return this._raceAgainstContextDestroyed(this.delegate.evaluateWithArguments(expression, returnByValue, utilityScript, values, handles));
+  }
+  getProperties(object) {
+    return this._raceAgainstContextDestroyed(this.delegate.getProperties(object));
+  }
+  releaseHandle(handle) {
+    return this.delegate.releaseHandle(handle);
+  }
+  adoptIfNeeded(handle) {
+    return null;
+  }
+  utilityScript() {
+    if (!this._utilityScriptPromise) {
+      const source = `
+      (() => {
+        const module = {};
+        ${rawUtilityScriptSource.source}
+        return new (module.exports.UtilityScript())(globalThis, ${(0, import_utils.isUnderTest)()});
+      })();`;
+      this._utilityScriptPromise = this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, source)).then((handle) => {
+        handle._setPreview("UtilityScript");
+        return handle;
+      });
+    }
+    return this._utilityScriptPromise;
+  }
+  async doSlowMo() {
+  }
+}
+class JSHandle extends import_instrumentation.SdkObject {
+  constructor(context, type, preview, objectId, value) {
+    super(context, "handle");
+    this.__jshandle = true;
+    this._disposed = false;
+    this._context = context;
+    this._objectId = objectId;
+    this._value = value;
+    this._objectType = type;
+    this._preview = this._objectId ? preview || `JSHandle@${this._objectType}` : String(value);
+    if (this._objectId && globalThis.leakedJSHandles)
+      globalThis.leakedJSHandles.set(this, new Error("Leaked JSHandle"));
+  }
+  async evaluate(pageFunction, arg) {
+    return evaluate(this._context, true, pageFunction, this, arg);
+  }
+  async evaluateHandle(pageFunction, arg) {
+    return evaluate(this._context, false, pageFunction, this, arg);
+  }
+  async evaluateExpression(expression, options, arg) {
+    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: true }, this, arg);
+    await this._context.doSlowMo();
+    return value;
+  }
+  async evaluateExpressionHandle(expression, options, arg) {
+    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: false }, this, arg);
+    await this._context.doSlowMo();
+    return value;
+  }
+  async getProperty(propertyName) {
+    const objectHandle = await this.evaluateHandle((object, propertyName2) => {
+      const result2 = { __proto__: null };
+      result2[propertyName2] = object[propertyName2];
+      return result2;
+    }, propertyName);
+    const properties = await objectHandle.getProperties();
+    const result = properties.get(propertyName);
+    objectHandle.dispose();
+    return result;
+  }
+  async getProperties() {
+    if (!this._objectId)
+      return /* @__PURE__ */ new Map();
+    return this._context.getProperties(this);
+  }
+  rawValue() {
+    return this._value;
+  }
+  async jsonValue() {
+    if (!this._objectId)
+      return this._value;
+    const script = `(utilityScript, ...args) => utilityScript.jsonValue(...args)`;
+    return this._context.evaluateWithArguments(script, true, [true], [this]);
+  }
+  asElement() {
+    return null;
+  }
+  dispose() {
+    if (this._disposed)
+      return;
+    this._disposed = true;
+    if (this._objectId) {
+      this._context.releaseHandle(this).catch((e) => {
+      });
+      if (globalThis.leakedJSHandles)
+        globalThis.leakedJSHandles.delete(this);
+    }
+  }
+  toString() {
+    return this._preview;
+  }
+  _setPreviewCallback(callback) {
+    this._previewCallback = callback;
+  }
+  preview() {
+    return this._preview;
+  }
+  worldNameForTest() {
+    return this._context.worldNameForTest;
+  }
+  _setPreview(preview) {
+    this._preview = preview;
+    if (this._previewCallback)
+      this._previewCallback(preview);
+  }
+}
+async function evaluate(context, returnByValue, pageFunction, ...args) {
+  return evaluateExpression(context, String(pageFunction), { returnByValue, isFunction: typeof pageFunction === "function" }, ...args);
+}
+async function evaluateExpression(context, expression, options, ...args) {
+  expression = normalizeEvaluationExpression(expression, options.isFunction);
+  const handles = [];
+  const toDispose = [];
+  const pushHandle = (handle) => {
+    handles.push(handle);
+    return handles.length - 1;
+  };
+  args = args.map((arg) => (0, import_utilityScriptSerializers.serializeAsCallArgument)(arg, (handle) => {
+    if (handle instanceof JSHandle) {
+      if (!handle._objectId)
+        return { fallThrough: handle._value };
+      if (handle._disposed)
+        throw new JavaScriptErrorInEvaluate("JSHandle is disposed!");
+      const adopted = context.adoptIfNeeded(handle);
+      if (adopted === null)
+        return { h: pushHandle(Promise.resolve(handle)) };
+      toDispose.push(adopted);
+      return { h: pushHandle(adopted) };
+    }
+    return { fallThrough: handle };
+  }));
+  const utilityScriptObjects = [];
+  for (const handle of await Promise.all(handles)) {
+    if (handle._context !== context)
+      throw new JavaScriptErrorInEvaluate("JSHandles can be evaluated only in the context they were created!");
+    utilityScriptObjects.push(handle);
+  }
+  const utilityScriptValues = [options.isFunction, options.returnByValue, expression, args.length, ...args];
+  const script = `(utilityScript, ...args) => utilityScript.evaluate(...args)`;
+  try {
+    return await context.evaluateWithArguments(script, options.returnByValue || false, utilityScriptValues, utilityScriptObjects);
+  } finally {
+    toDispose.map((handlePromise) => handlePromise.then((handle) => handle.dispose()));
+  }
+}
+function parseUnserializableValue(unserializableValue) {
+  if (unserializableValue === "NaN")
+    return NaN;
+  if (unserializableValue === "Infinity")
+    return Infinity;
+  if (unserializableValue === "-Infinity")
+    return -Infinity;
+  if (unserializableValue === "-0")
+    return -0;
+}
+function normalizeEvaluationExpression(expression, isFunction) {
+  expression = expression.trim();
+  if (isFunction) {
+    try {
+      new Function("(" + expression + ")");
+    } catch (e1) {
+      if (expression.startsWith("async "))
+        expression = "async function " + expression.substring("async ".length);
+      else
+        expression = "function " + expression;
+      try {
+        new Function("(" + expression + ")");
+      } catch (e2) {
+        throw new Error("Passed function is not well-serializable!");
+      }
+    }
+  }
+  if (/^(async)?\s*function(\s|\()/.test(expression))
+    expression = "(" + expression + ")";
+  return expression;
+}
+class JavaScriptErrorInEvaluate extends Error {
+}
+function isJavaScriptErrorInEvaluate(error) {
+  return error instanceof JavaScriptErrorInEvaluate;
+}
+function sparseArrayToString(entries) {
+  const arrayEntries = [];
+  for (const { name, value } of entries) {
+    const index = +name;
+    if (isNaN(index) || index < 0)
+      continue;
+    arrayEntries.push({ index, value });
+  }
+  arrayEntries.sort((a, b) => a.index - b.index);
+  let lastIndex = -1;
+  const tokens = [];
+  for (const { index, value } of arrayEntries) {
+    const emptyItems = index - lastIndex - 1;
+    if (emptyItems === 1)
+      tokens.push(`empty`);
+    else if (emptyItems > 1)
+      tokens.push(`empty x ${emptyItems}`);
+    tokens.push(String(value));
+    lastIndex = index;
+  }
+  return "[" + tokens.join(", ") + "]";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExecutionContext,
+  JSHandle,
+  JavaScriptErrorInEvaluate,
+  evaluate,
+  evaluateExpression,
+  isJavaScriptErrorInEvaluate,
+  normalizeEvaluationExpression,
+  parseUnserializableValue,
+  sparseArrayToString
+});

package/dist/node_modules/playwright-core/lib/server/launchApp.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var launchApp_exports = {};
+__export(launchApp_exports, {
+  launchApp: () => launchApp,
+  syncLocalStorageWithSettings: () => syncLocalStorageWithSettings
+});
+module.exports = __toCommonJS(launchApp_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("../utils");
+var import_registry = require("./registry");
+var import_registry2 = require("./registry");
+var import_progress = require("./progress");
+async function launchApp(browserType, options) {
+  const args = [...options.persistentContextOptions?.args ?? []];
+  let channel = options.persistentContextOptions?.channel;
+  if (browserType.name() === "chromium") {
+    args.push(
+      "--app=data:text/html,",
+      `--window-size=${options.windowSize.width},${options.windowSize.height}`,
+      ...options.windowPosition ? [`--window-position=${options.windowPosition.x},${options.windowPosition.y}`] : [],
+      "--test-type="
+    );
+    if (!channel && !options.persistentContextOptions?.executablePath)
+      channel = (0, import_registry.findChromiumChannelBestEffort)(options.sdkLanguage);
+  }
+  const controller = new import_progress.ProgressController();
+  let context;
+  try {
+    context = await controller.run((progress) => browserType.launchPersistentContext(progress, "", {
+      ignoreDefaultArgs: ["--enable-automation"],
+      ...options?.persistentContextOptions,
+      channel,
+      noDefaultViewport: options.persistentContextOptions?.noDefaultViewport ?? true,
+      acceptDownloads: options?.persistentContextOptions?.acceptDownloads ?? ((0, import_utils.isUnderTest)() ? "accept" : "internal-browser-default"),
+      colorScheme: options?.persistentContextOptions?.colorScheme ?? "no-override",
+      args
+    }), 0);
+  } catch (error) {
+    if (channel) {
+      error = (0, import_utils.rewriteErrorMessage)(error, [
+        `Failed to launch "${channel}" channel.`,
+        "Using custom channels could lead to unexpected behavior due to Enterprise policies (chrome://policy).",
+        "Install the default browser instead:",
+        (0, import_utils.wrapInASCIIBox)(`${(0, import_registry.buildPlaywrightCLICommand)(options.sdkLanguage, "install")}`, 2)
+      ].join("\n"));
+    }
+    throw error;
+  }
+  const [page] = context.pages();
+  if (browserType.name() === "chromium" && process.platform === "darwin") {
+    context.on("page", async (newPage) => {
+      if (newPage.mainFrame().url() === "chrome://new-tab-page/") {
+        await page.bringToFront();
+        await newPage.close();
+      }
+    });
+  }
+  if (browserType.name() === "chromium")
+    await installAppIcon(page);
+  return { context, page };
+}
+async function installAppIcon(page) {
+  const icon = await import_fs.default.promises.readFile(require.resolve("./chromium/appIcon.png"));
+  const crPage = page.delegate;
+  await crPage._mainFrameSession._client.send("Browser.setDockTile", {
+    image: icon.toString("base64")
+  });
+}
+async function syncLocalStorageWithSettings(page, appName) {
+  if ((0, import_utils.isUnderTest)())
+    return;
+  const settingsFile = import_path.default.join(import_registry2.registryDirectory, ".settings", `${appName}.json`);
+  const controller = new import_progress.ProgressController();
+  await controller.run(async (progress) => {
+    await page.exposeBinding(progress, "_saveSerializedSettings", false, (_, settings2) => {
+      import_fs.default.mkdirSync(import_path.default.dirname(settingsFile), { recursive: true });
+      import_fs.default.writeFileSync(settingsFile, settings2);
+    });
+    const settings = await import_fs.default.promises.readFile(settingsFile, "utf-8").catch(() => "{}");
+    await page.addInitScript(
+      progress,
+      `(${String((settings2) => {
+        if (location && location.protocol === "data:")
+          return;
+        if (window.top !== window)
+          return;
+        Object.entries(settings2).map(([k, v]) => localStorage[k] = v);
+        window.saveSettings = () => {
+          window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+        };
+      })})(${settings});
+    `
+    );
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  launchApp,
+  syncLocalStorageWithSettings
+});

package/dist/node_modules/playwright-core/lib/server/localUtils.js

@@ -0,0 +1,214 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var localUtils_exports = {};
+__export(localUtils_exports, {
+  addStackToTracingNoReply: () => addStackToTracingNoReply,
+  harClose: () => harClose,
+  harLookup: () => harLookup,
+  harOpen: () => harOpen,
+  harUnzip: () => harUnzip,
+  traceDiscarded: () => traceDiscarded,
+  tracingStarted: () => tracingStarted,
+  zip: () => zip
+});
+module.exports = __toCommonJS(localUtils_exports);
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_crypto = require("./utils/crypto");
+var import_harBackend = require("./harBackend");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+var import_zipFile = require("./utils/zipFile");
+var import_zipBundle = require("../zipBundle");
+var import_traceUtils = require("../utils/isomorphic/traceUtils");
+var import_assert = require("../utils/isomorphic/assert");
+var import_fileUtils = require("./utils/fileUtils");
+async function zip(progress, stackSessions, params) {
+  const promise = new import_manualPromise.ManualPromise();
+  const zipFile = new import_zipBundle.yazl.ZipFile();
+  zipFile.on("error", (error) => promise.reject(error));
+  const addFile = (file, name) => {
+    try {
+      if (import_fs.default.statSync(file).isFile())
+        zipFile.addFile(file, name);
+    } catch (e) {
+    }
+  };
+  for (const entry of params.entries)
+    addFile(entry.value, entry.name);
+  const stackSession = params.stacksId ? stackSessions.get(params.stacksId) : void 0;
+  if (stackSession?.callStacks.length) {
+    await progress.race(stackSession.writer);
+    const buffer = Buffer.from(JSON.stringify((0, import_traceUtils.serializeClientSideCallMetadata)(stackSession.callStacks)));
+    zipFile.addBuffer(buffer, "trace.stacks");
+  }
+  if (params.includeSources) {
+    const sourceFiles = /* @__PURE__ */ new Set();
+    for (const { stack } of stackSession?.callStacks || []) {
+      if (!stack)
+        continue;
+      for (const { file } of stack)
+        sourceFiles.add(file);
+    }
+    for (const sourceFile of sourceFiles)
+      addFile(sourceFile, "resources/src@" + await (0, import_crypto.calculateSha1)(sourceFile) + ".txt");
+  }
+  if (params.mode === "write") {
+    await progress.race(import_fs.default.promises.mkdir(import_path.default.dirname(params.zipFile), { recursive: true }));
+    zipFile.end(void 0, () => {
+      zipFile.outputStream.pipe(import_fs.default.createWriteStream(params.zipFile)).on("close", () => promise.resolve()).on("error", (error) => promise.reject(error));
+    });
+    await progress.race(promise);
+    await deleteStackSession(progress, stackSessions, params.stacksId);
+    return;
+  }
+  const tempFile = params.zipFile + ".tmp";
+  await progress.race(import_fs.default.promises.rename(params.zipFile, tempFile));
+  import_zipBundle.yauzl.open(tempFile, (err, inZipFile) => {
+    if (err) {
+      promise.reject(err);
+      return;
+    }
+    (0, import_assert.assert)(inZipFile);
+    let pendingEntries = inZipFile.entryCount;
+    inZipFile.on("entry", (entry) => {
+      inZipFile.openReadStream(entry, (err2, readStream) => {
+        if (err2) {
+          promise.reject(err2);
+          return;
+        }
+        zipFile.addReadStream(readStream, entry.fileName);
+        if (--pendingEntries === 0) {
+          zipFile.end(void 0, () => {
+            zipFile.outputStream.pipe(import_fs.default.createWriteStream(params.zipFile)).on("close", () => {
+              import_fs.default.promises.unlink(tempFile).then(() => {
+                promise.resolve();
+              }).catch((error) => promise.reject(error));
+            });
+          });
+        }
+      });
+    });
+  });
+  await progress.race(promise);
+  await deleteStackSession(progress, stackSessions, params.stacksId);
+}
+async function deleteStackSession(progress, stackSessions, stacksId) {
+  const session = stacksId ? stackSessions.get(stacksId) : void 0;
+  if (!session)
+    return;
+  stackSessions.delete(stacksId);
+  if (session.tmpDir)
+    await progress.race((0, import_fileUtils.removeFolders)([session.tmpDir]));
+}
+async function harOpen(progress, harBackends, params) {
+  let harBackend;
+  if (params.file.endsWith(".zip")) {
+    const zipFile = new import_zipFile.ZipFile(params.file);
+    try {
+      const entryNames = await progress.race(zipFile.entries());
+      const harEntryName = entryNames.find((e) => e.endsWith(".har"));
+      if (!harEntryName)
+        return { error: "Specified archive does not have a .har file" };
+      const har = await progress.race(zipFile.read(harEntryName));
+      const harFile = JSON.parse(har.toString());
+      harBackend = new import_harBackend.HarBackend(harFile, null, zipFile);
+    } catch (error) {
+      zipFile.close();
+      throw error;
+    }
+  } else {
+    const harFile = JSON.parse(await progress.race(import_fs.default.promises.readFile(params.file, "utf-8")));
+    harBackend = new import_harBackend.HarBackend(harFile, import_path.default.dirname(params.file), null);
+  }
+  harBackends.set(harBackend.id, harBackend);
+  return { harId: harBackend.id };
+}
+async function harLookup(progress, harBackends, params) {
+  const harBackend = harBackends.get(params.harId);
+  if (!harBackend)
+    return { action: "error", message: `Internal error: har was not opened` };
+  return await progress.race(harBackend.lookup(params.url, params.method, params.headers, params.postData, params.isNavigationRequest));
+}
+function harClose(harBackends, params) {
+  const harBackend = harBackends.get(params.harId);
+  if (harBackend) {
+    harBackends.delete(harBackend.id);
+    harBackend.dispose();
+  }
+}
+async function harUnzip(progress, params) {
+  const dir = import_path.default.dirname(params.zipFile);
+  const zipFile = new import_zipFile.ZipFile(params.zipFile);
+  try {
+    for (const entry of await progress.race(zipFile.entries())) {
+      const buffer = await progress.race(zipFile.read(entry));
+      if (entry === "har.har")
+        await progress.race(import_fs.default.promises.writeFile(params.harFile, buffer));
+      else
+        await progress.race(import_fs.default.promises.writeFile(import_path.default.join(dir, entry), buffer));
+    }
+    await progress.race(import_fs.default.promises.unlink(params.zipFile));
+  } finally {
+    zipFile.close();
+  }
+}
+async function tracingStarted(progress, stackSessions, params) {
+  let tmpDir = void 0;
+  if (!params.tracesDir)
+    tmpDir = await progress.race(import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-tracing-")));
+  const traceStacksFile = import_path.default.join(params.tracesDir || tmpDir, params.traceName + ".stacks");
+  stackSessions.set(traceStacksFile, { callStacks: [], file: traceStacksFile, writer: Promise.resolve(), tmpDir, live: params.live });
+  return { stacksId: traceStacksFile };
+}
+async function traceDiscarded(progress, stackSessions, params) {
+  await deleteStackSession(progress, stackSessions, params.stacksId);
+}
+function addStackToTracingNoReply(stackSessions, params) {
+  for (const session of stackSessions.values()) {
+    session.callStacks.push(params.callData);
+    if (session.live) {
+      session.writer = session.writer.then(() => {
+        const buffer = Buffer.from(JSON.stringify((0, import_traceUtils.serializeClientSideCallMetadata)(session.callStacks)));
+        return import_fs.default.promises.writeFile(session.file, buffer);
+      });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addStackToTracingNoReply,
+  harClose,
+  harLookup,
+  harOpen,
+  harUnzip,
+  traceDiscarded,
+  tracingStarted,
+  zip
+});