rebrowser-playwright-core 1.52.0 → 1.64.1

package/lib/server/javascript.js

@@ -1,299 +0,0 @@
-"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,
-  parseEvaluationResultValue: () => parseEvaluationResultValue,
-  parseUnserializableValue: () => parseUnserializableValue,
-  serializeAsCallArgument: () => serializeAsCallArgument,
-  sparseArrayToString: () => sparseArrayToString
-});
-module.exports = __toCommonJS(javascript_exports);
-var import_instrumentation = require("./instrumentation");
-var utilityScriptSource = __toESM(require("../generated/utilityScriptSource"));
-var import_utils = require("../utils");
-var import_builtins = require("../utils/isomorphic/builtins");
-var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
-var import_manualPromise = require("../utils/isomorphic/manualPromise");
-const utilityScriptSerializers = (0, import_utilityScriptSerializers.source)((0, import_builtins.builtins)());
-const parseEvaluationResultValue = utilityScriptSerializers.parseEvaluationResultValue;
-const serializeAsCallArgument = utilityScriptSerializers.serializeAsCallArgument;
-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 source2 = `
-      (() => {
-        const module = {};
-        ${utilityScriptSource.source}
-        return new (module.exports.UtilityScript())(${(0, import_utils.isUnderTest)()});
-      })();`;
-      this._utilityScriptPromise = this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, source2)).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) => 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,
-  parseEvaluationResultValue,
-  parseUnserializableValue,
-  serializeAsCallArgument,
-  sparseArrayToString
-});

package/lib/server/launchApp.js

@@ -1,110 +0,0 @@
-"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_instrumentation = require("./instrumentation");
-var import_registry = require("./registry");
-var import_registry2 = require("./registry");
-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.findChromiumChannel)(options.sdkLanguage);
-  }
-  const context = await browserType.launchPersistentContext((0, import_instrumentation.serverSideCallMetadata)(), "", {
-    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
-  });
-  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((0, import_instrumentation.serverSideCallMetadata)());
-      }
-    });
-  }
-  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`);
-  await page.exposeBinding("_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(
-    `(${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/lib/server/localUtils.js

@@ -1,211 +0,0 @@
-"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(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 stackSession.writer;
-    if (process.env.PW_LIVE_TRACE_STACKS) {
-      zipFile.addFile(stackSession.file, "trace.stacks");
-    } else {
-      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 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 promise;
-    await deleteStackSession(stackSessions, params.stacksId);
-    return;
-  }
-  const tempFile = params.zipFile + ".tmp";
-  await 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 promise;
-  await deleteStackSession(stackSessions, params.stacksId);
-}
-async function deleteStackSession(stackSessions, stacksId) {
-  const session = stacksId ? stackSessions.get(stacksId) : void 0;
-  if (!session)
-    return;
-  await session.writer;
-  if (session.tmpDir)
-    await (0, import_fileUtils.removeFolders)([session.tmpDir]);
-  stackSessions.delete(stacksId);
-}
-async function harOpen(harBackends, params) {
-  let harBackend;
-  if (params.file.endsWith(".zip")) {
-    const zipFile = new import_zipFile.ZipFile(params.file);
-    const entryNames = await 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 zipFile.read(harEntryName);
-    const harFile = JSON.parse(har.toString());
-    harBackend = new import_harBackend.HarBackend(harFile, null, zipFile);
-  } else {
-    const harFile = JSON.parse(await 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(harBackends, params) {
-  const harBackend = harBackends.get(params.harId);
-  if (!harBackend)
-    return { action: "error", message: `Internal error: har was not opened` };
-  return await harBackend.lookup(params.url, params.method, params.headers, params.postData, params.isNavigationRequest);
-}
-async function harClose(harBackends, params) {
-  const harBackend = harBackends.get(params.harId);
-  if (harBackend) {
-    harBackends.delete(harBackend.id);
-    harBackend.dispose();
-  }
-}
-async function harUnzip(params) {
-  const dir = import_path.default.dirname(params.zipFile);
-  const zipFile = new import_zipFile.ZipFile(params.zipFile);
-  for (const entry of await zipFile.entries()) {
-    const buffer = await zipFile.read(entry);
-    if (entry === "har.har")
-      await import_fs.default.promises.writeFile(params.harFile, buffer);
-    else
-      await import_fs.default.promises.writeFile(import_path.default.join(dir, entry), buffer);
-  }
-  zipFile.close();
-  await import_fs.default.promises.unlink(params.zipFile);
-}
-async function tracingStarted(stackSessions, params) {
-  let tmpDir = void 0;
-  if (!params.tracesDir)
-    tmpDir = await 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 });
-  return { stacksId: traceStacksFile };
-}
-async function traceDiscarded(stackSessions, params) {
-  await deleteStackSession(stackSessions, params.stacksId);
-}
-async function addStackToTracingNoReply(stackSessions, params) {
-  for (const session of stackSessions.values()) {
-    session.callStacks.push(params.callData);
-    if (process.env.PW_LIVE_TRACE_STACKS) {
-      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
-});