@stablyai/internal-playwright-core 0.1.0

package/lib/server/utils/comparators.js

@@ -0,0 +1,161 @@
+"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 comparators_exports = {};
+__export(comparators_exports, {
+  compareBuffersOrStrings: () => compareBuffersOrStrings,
+  getComparator: () => getComparator
+});
+module.exports = __toCommonJS(comparators_exports);
+var import_compare = require("./image_tools/compare");
+var import_pixelmatch = __toESM(require("../../third_party/pixelmatch"));
+var import_utilsBundle = require("../../utilsBundle");
+var import_utilsBundle2 = require("../../utilsBundle");
+var import_utilsBundle3 = require("../../utilsBundle");
+function getComparator(mimeType) {
+  if (mimeType === "image/png")
+    return compareImages.bind(null, "image/png");
+  if (mimeType === "image/jpeg")
+    return compareImages.bind(null, "image/jpeg");
+  if (mimeType === "text/plain")
+    return compareText;
+  return compareBuffersOrStrings;
+}
+const JPEG_JS_MAX_BUFFER_SIZE_IN_MB = 5 * 1024;
+function compareBuffersOrStrings(actualBuffer, expectedBuffer) {
+  if (typeof actualBuffer === "string")
+    return compareText(actualBuffer, expectedBuffer);
+  if (!actualBuffer || !(actualBuffer instanceof Buffer))
+    return { errorMessage: "Actual result should be a Buffer or a string." };
+  if (Buffer.compare(actualBuffer, expectedBuffer))
+    return { errorMessage: "Buffers differ" };
+  return null;
+}
+function compareImages(mimeType, actualBuffer, expectedBuffer, options = {}) {
+  if (!actualBuffer || !(actualBuffer instanceof Buffer))
+    return { errorMessage: "Actual result should be a Buffer." };
+  validateBuffer(expectedBuffer, mimeType);
+  let actual = mimeType === "image/png" ? import_utilsBundle3.PNG.sync.read(actualBuffer) : import_utilsBundle.jpegjs.decode(actualBuffer, { maxMemoryUsageInMB: JPEG_JS_MAX_BUFFER_SIZE_IN_MB });
+  let expected = mimeType === "image/png" ? import_utilsBundle3.PNG.sync.read(expectedBuffer) : import_utilsBundle.jpegjs.decode(expectedBuffer, { maxMemoryUsageInMB: JPEG_JS_MAX_BUFFER_SIZE_IN_MB });
+  const size = { width: Math.max(expected.width, actual.width), height: Math.max(expected.height, actual.height) };
+  let sizesMismatchError = "";
+  if (expected.width !== actual.width || expected.height !== actual.height) {
+    sizesMismatchError = `Expected an image ${expected.width}px by ${expected.height}px, received ${actual.width}px by ${actual.height}px. `;
+    actual = resizeImage(actual, size);
+    expected = resizeImage(expected, size);
+  }
+  const diff2 = new import_utilsBundle3.PNG({ width: size.width, height: size.height });
+  let count;
+  if (options.comparator === "ssim-cie94") {
+    count = (0, import_compare.compare)(expected.data, actual.data, diff2.data, size.width, size.height, {
+      // All ΔE* formulae are originally designed to have the difference of 1.0 stand for a "just noticeable difference" (JND).
+      // See https://en.wikipedia.org/wiki/Color_difference#CIELAB_%CE%94E*
+      maxColorDeltaE94: 1
+    });
+  } else if ((options.comparator ?? "pixelmatch") === "pixelmatch") {
+    count = (0, import_pixelmatch.default)(expected.data, actual.data, diff2.data, size.width, size.height, {
+      threshold: options.threshold ?? 0.2
+    });
+  } else {
+    throw new Error(`Configuration specifies unknown comparator "${options.comparator}"`);
+  }
+  const maxDiffPixels1 = options.maxDiffPixels;
+  const maxDiffPixels2 = options.maxDiffPixelRatio !== void 0 ? expected.width * expected.height * options.maxDiffPixelRatio : void 0;
+  let maxDiffPixels;
+  if (maxDiffPixels1 !== void 0 && maxDiffPixels2 !== void 0)
+    maxDiffPixels = Math.min(maxDiffPixels1, maxDiffPixels2);
+  else
+    maxDiffPixels = maxDiffPixels1 ?? maxDiffPixels2 ?? 0;
+  const ratio = Math.ceil(count / (expected.width * expected.height) * 100) / 100;
+  const pixelsMismatchError = count > maxDiffPixels ? `${count} pixels (ratio ${ratio.toFixed(2)} of all image pixels) are different.` : "";
+  if (pixelsMismatchError || sizesMismatchError)
+    return { errorMessage: sizesMismatchError + pixelsMismatchError, diff: import_utilsBundle3.PNG.sync.write(diff2) };
+  return null;
+}
+function validateBuffer(buffer, mimeType) {
+  if (mimeType === "image/png") {
+    const pngMagicNumber = [137, 80, 78, 71, 13, 10, 26, 10];
+    if (buffer.length < pngMagicNumber.length || !pngMagicNumber.every((byte, index) => buffer[index] === byte))
+      throw new Error("Could not decode expected image as PNG.");
+  } else if (mimeType === "image/jpeg") {
+    const jpegMagicNumber = [255, 216];
+    if (buffer.length < jpegMagicNumber.length || !jpegMagicNumber.every((byte, index) => buffer[index] === byte))
+      throw new Error("Could not decode expected image as JPEG.");
+  }
+}
+function compareText(actual, expectedBuffer) {
+  if (typeof actual !== "string")
+    return { errorMessage: "Actual result should be a string" };
+  let expected = expectedBuffer.toString("utf-8");
+  if (expected === actual)
+    return null;
+  if (!actual.endsWith("\n"))
+    actual += "\n";
+  if (!expected.endsWith("\n"))
+    expected += "\n";
+  const lines = import_utilsBundle2.diff.createPatch("file", expected, actual, void 0, void 0, { context: 5 }).split("\n");
+  const coloredLines = lines.slice(4).map((line) => {
+    if (line.startsWith("-"))
+      return import_utilsBundle2.colors.green(line);
+    if (line.startsWith("+"))
+      return import_utilsBundle2.colors.red(line);
+    if (line.startsWith("@@"))
+      return import_utilsBundle2.colors.dim(line);
+    return line;
+  });
+  const errorMessage = coloredLines.join("\n");
+  return { errorMessage };
+}
+function resizeImage(image, size) {
+  if (image.width === size.width && image.height === size.height)
+    return image;
+  const buffer = new Uint8Array(size.width * size.height * 4);
+  for (let y = 0; y < size.height; y++) {
+    for (let x = 0; x < size.width; x++) {
+      const to = (y * size.width + x) * 4;
+      if (y < image.height && x < image.width) {
+        const from = (y * image.width + x) * 4;
+        buffer[to] = image.data[from];
+        buffer[to + 1] = image.data[from + 1];
+        buffer[to + 2] = image.data[from + 2];
+        buffer[to + 3] = image.data[from + 3];
+      } else {
+        buffer[to] = 0;
+        buffer[to + 1] = 0;
+        buffer[to + 2] = 0;
+        buffer[to + 3] = 0;
+      }
+    }
+  }
+  return { data: Buffer.from(buffer), width: size.width, height: size.height };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compareBuffersOrStrings,
+  getComparator
+});

package/lib/server/utils/crypto.js

@@ -0,0 +1,216 @@
+"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 crypto_exports = {};
+__export(crypto_exports, {
+  calculateSha1: () => calculateSha1,
+  createGuid: () => createGuid,
+  generateSelfSignedCertificate: () => generateSelfSignedCertificate
+});
+module.exports = __toCommonJS(crypto_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_assert = require("../../utils/isomorphic/assert");
+function createGuid() {
+  return import_crypto.default.randomBytes(16).toString("hex");
+}
+function calculateSha1(buffer) {
+  const hash = import_crypto.default.createHash("sha1");
+  hash.update(buffer);
+  return hash.digest("hex");
+}
+function encodeBase128(value) {
+  const bytes = [];
+  do {
+    let byte = value & 127;
+    value >>>= 7;
+    if (bytes.length > 0)
+      byte |= 128;
+    bytes.push(byte);
+  } while (value > 0);
+  return Buffer.from(bytes.reverse());
+}
+class DER {
+  static encodeSequence(data) {
+    return this._encode(48, Buffer.concat(data));
+  }
+  static encodeInteger(data) {
+    (0, import_assert.assert)(data >= -128 && data <= 127);
+    return this._encode(2, Buffer.from([data]));
+  }
+  static encodeObjectIdentifier(oid) {
+    const parts = oid.split(".").map((v) => Number(v));
+    const output = [encodeBase128(40 * parts[0] + parts[1])];
+    for (let i = 2; i < parts.length; i++)
+      output.push(encodeBase128(parts[i]));
+    return this._encode(6, Buffer.concat(output));
+  }
+  static encodeNull() {
+    return Buffer.from([5, 0]);
+  }
+  static encodeSet(data) {
+    (0, import_assert.assert)(data.length === 1, "Only one item in the set is supported. We'd need to sort the data to support more.");
+    return this._encode(49, Buffer.concat(data));
+  }
+  static encodeExplicitContextDependent(tag, data) {
+    return this._encode(160 + tag, data);
+  }
+  static encodePrintableString(data) {
+    return this._encode(19, Buffer.from(data));
+  }
+  static encodeBitString(data) {
+    const unusedBits = 0;
+    const content = Buffer.concat([Buffer.from([unusedBits]), data]);
+    return this._encode(3, content);
+  }
+  static encodeDate(date) {
+    const year = date.getUTCFullYear();
+    const isGeneralizedTime = year >= 2050;
+    const parts = [
+      isGeneralizedTime ? year.toString() : year.toString().slice(-2),
+      (date.getUTCMonth() + 1).toString().padStart(2, "0"),
+      date.getUTCDate().toString().padStart(2, "0"),
+      date.getUTCHours().toString().padStart(2, "0"),
+      date.getUTCMinutes().toString().padStart(2, "0"),
+      date.getUTCSeconds().toString().padStart(2, "0")
+    ];
+    const encodedDate = parts.join("") + "Z";
+    const tag = isGeneralizedTime ? 24 : 23;
+    return this._encode(tag, Buffer.from(encodedDate));
+  }
+  static _encode(tag, data) {
+    const lengthBytes = this._encodeLength(data.length);
+    return Buffer.concat([Buffer.from([tag]), lengthBytes, data]);
+  }
+  static _encodeLength(length) {
+    if (length < 128) {
+      return Buffer.from([length]);
+    } else {
+      const lengthBytes = [];
+      while (length > 0) {
+        lengthBytes.unshift(length & 255);
+        length >>= 8;
+      }
+      return Buffer.from([128 | lengthBytes.length, ...lengthBytes]);
+    }
+  }
+}
+function generateSelfSignedCertificate() {
+  const { privateKey, publicKey } = import_crypto.default.generateKeyPairSync("rsa", { modulusLength: 2048 });
+  const publicKeyDer = publicKey.export({ type: "pkcs1", format: "der" });
+  const oneYearInMilliseconds = 365 * 24 * 60 * 60 * 1e3;
+  const notBefore = new Date((/* @__PURE__ */ new Date()).getTime() - oneYearInMilliseconds);
+  const notAfter = new Date((/* @__PURE__ */ new Date()).getTime() + oneYearInMilliseconds);
+  const tbsCertificate = DER.encodeSequence([
+    DER.encodeExplicitContextDependent(0, DER.encodeInteger(1)),
+    // version
+    DER.encodeInteger(1),
+    // serialNumber
+    DER.encodeSequence([
+      DER.encodeObjectIdentifier("1.2.840.113549.1.1.11"),
+      // sha256WithRSAEncryption PKCS #1
+      DER.encodeNull()
+    ]),
+    // signature
+    DER.encodeSequence([
+      DER.encodeSet([
+        DER.encodeSequence([
+          DER.encodeObjectIdentifier("2.5.4.3"),
+          // commonName X.520 DN component
+          DER.encodePrintableString("localhost")
+        ])
+      ]),
+      DER.encodeSet([
+        DER.encodeSequence([
+          DER.encodeObjectIdentifier("2.5.4.10"),
+          // organizationName X.520 DN component
+          DER.encodePrintableString("Playwright Client Certificate Support")
+        ])
+      ])
+    ]),
+    // issuer
+    DER.encodeSequence([
+      DER.encodeDate(notBefore),
+      // notBefore
+      DER.encodeDate(notAfter)
+      // notAfter
+    ]),
+    // validity
+    DER.encodeSequence([
+      DER.encodeSet([
+        DER.encodeSequence([
+          DER.encodeObjectIdentifier("2.5.4.3"),
+          // commonName X.520 DN component
+          DER.encodePrintableString("localhost")
+        ])
+      ]),
+      DER.encodeSet([
+        DER.encodeSequence([
+          DER.encodeObjectIdentifier("2.5.4.10"),
+          // organizationName X.520 DN component
+          DER.encodePrintableString("Playwright Client Certificate Support")
+        ])
+      ])
+    ]),
+    // subject
+    DER.encodeSequence([
+      DER.encodeSequence([
+        DER.encodeObjectIdentifier("1.2.840.113549.1.1.1"),
+        // rsaEncryption PKCS #1
+        DER.encodeNull()
+      ]),
+      DER.encodeBitString(publicKeyDer)
+    ])
+    // SubjectPublicKeyInfo
+  ]);
+  const signature = import_crypto.default.sign("sha256", tbsCertificate, privateKey);
+  const certificate = DER.encodeSequence([
+    tbsCertificate,
+    DER.encodeSequence([
+      DER.encodeObjectIdentifier("1.2.840.113549.1.1.11"),
+      // sha256WithRSAEncryption PKCS #1
+      DER.encodeNull()
+    ]),
+    DER.encodeBitString(signature)
+  ]);
+  const certPem = [
+    "-----BEGIN CERTIFICATE-----",
+    // Split the base64 string into lines of 64 characters
+    certificate.toString("base64").match(/.{1,64}/g).join("\n"),
+    "-----END CERTIFICATE-----"
+  ].join("\n");
+  return {
+    cert: certPem,
+    key: privateKey.export({ type: "pkcs1", format: "pem" })
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateSha1,
+  createGuid,
+  generateSelfSignedCertificate
+});

package/lib/server/utils/debug.js

@@ -0,0 +1,42 @@
+"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 debug_exports = {};
+__export(debug_exports, {
+  debugMode: () => debugMode,
+  isUnderTest: () => isUnderTest
+});
+module.exports = __toCommonJS(debug_exports);
+var import_env = require("./env");
+const _debugMode = (0, import_env.getFromENV)("PWDEBUG") || "";
+function debugMode() {
+  if (_debugMode === "console")
+    return "console";
+  if (_debugMode === "0" || _debugMode === "false")
+    return "";
+  return _debugMode ? "inspector" : "";
+}
+const _isUnderTest = (0, import_env.getAsBooleanFromENV)("PWTEST_UNDER_TEST");
+function isUnderTest() {
+  return _isUnderTest;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debugMode,
+  isUnderTest
+});

package/lib/server/utils/debugLogger.js

@@ -0,0 +1,122 @@
+"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 debugLogger_exports = {};
+__export(debugLogger_exports, {
+  RecentLogsCollector: () => RecentLogsCollector,
+  debugLogger: () => debugLogger
+});
+module.exports = __toCommonJS(debugLogger_exports);
+var import_fs = __toESM(require("fs"));
+var import_utilsBundle = require("../../utilsBundle");
+const debugLoggerColorMap = {
+  "api": 45,
+  // cyan
+  "protocol": 34,
+  // green
+  "install": 34,
+  // green
+  "download": 34,
+  // green
+  "browser": 0,
+  // reset
+  "socks": 92,
+  // purple
+  "client-certificates": 92,
+  // purple
+  "error": 160,
+  // red,
+  "channel": 33,
+  // blue
+  "server": 45,
+  // cyan
+  "server:channel": 34,
+  // green
+  "server:metadata": 33,
+  // blue,
+  "recorder": 45
+  // cyan
+};
+class DebugLogger {
+  constructor() {
+    this._debuggers = /* @__PURE__ */ new Map();
+    if (process.env.DEBUG_FILE) {
+      const ansiRegex = new RegExp([
+        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+      ].join("|"), "g");
+      const stream = import_fs.default.createWriteStream(process.env.DEBUG_FILE);
+      import_utilsBundle.debug.log = (data) => {
+        stream.write(data.replace(ansiRegex, ""));
+        stream.write("\n");
+      };
+    }
+  }
+  log(name, message) {
+    let cachedDebugger = this._debuggers.get(name);
+    if (!cachedDebugger) {
+      cachedDebugger = (0, import_utilsBundle.debug)(`pw:${name}`);
+      this._debuggers.set(name, cachedDebugger);
+      cachedDebugger.color = debugLoggerColorMap[name] || 0;
+    }
+    cachedDebugger(message);
+  }
+  isEnabled(name) {
+    return import_utilsBundle.debug.enabled(`pw:${name}`);
+  }
+}
+const debugLogger = new DebugLogger();
+const kLogCount = 150;
+class RecentLogsCollector {
+  constructor() {
+    this._logs = [];
+    this._listeners = [];
+  }
+  log(message) {
+    this._logs.push(message);
+    if (this._logs.length === kLogCount * 2)
+      this._logs.splice(0, kLogCount);
+    for (const listener of this._listeners)
+      listener(message);
+  }
+  recentLogs() {
+    if (this._logs.length > kLogCount)
+      return this._logs.slice(-kLogCount);
+    return this._logs;
+  }
+  onMessage(listener) {
+    for (const message of this._logs)
+      listener(message);
+    this._listeners.push(listener);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RecentLogsCollector,
+  debugLogger
+});

package/lib/server/utils/env.js

@@ -0,0 +1,73 @@
+"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 env_exports = {};
+__export(env_exports, {
+  getAsBooleanFromENV: () => getAsBooleanFromENV,
+  getFromENV: () => getFromENV,
+  getPackageManager: () => getPackageManager,
+  getPackageManagerExecCommand: () => getPackageManagerExecCommand,
+  isLikelyNpxGlobal: () => isLikelyNpxGlobal,
+  setPlaywrightTestProcessEnv: () => setPlaywrightTestProcessEnv
+});
+module.exports = __toCommonJS(env_exports);
+function getFromENV(name) {
+  let value = process.env[name];
+  value = value === void 0 ? process.env[`npm_config_${name.toLowerCase()}`] : value;
+  value = value === void 0 ? process.env[`npm_package_config_${name.toLowerCase()}`] : value;
+  return value;
+}
+function getAsBooleanFromENV(name, defaultValue) {
+  const value = getFromENV(name);
+  if (value === "false" || value === "0")
+    return false;
+  if (value)
+    return true;
+  return !!defaultValue;
+}
+function getPackageManager() {
+  const env = process.env.npm_config_user_agent || "";
+  if (env.includes("yarn"))
+    return "yarn";
+  if (env.includes("pnpm"))
+    return "pnpm";
+  return "npm";
+}
+function getPackageManagerExecCommand() {
+  const packageManager = getPackageManager();
+  if (packageManager === "yarn")
+    return "yarn";
+  if (packageManager === "pnpm")
+    return "pnpm exec";
+  return "npx";
+}
+function isLikelyNpxGlobal() {
+  return process.argv.length >= 2 && process.argv[1].includes("_npx");
+}
+function setPlaywrightTestProcessEnv() {
+  return process.env["PLAYWRIGHT_TEST"] = "1";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAsBooleanFromENV,
+  getFromENV,
+  getPackageManager,
+  getPackageManagerExecCommand,
+  isLikelyNpxGlobal,
+  setPlaywrightTestProcessEnv
+});

package/lib/server/utils/eventsHelper.js

@@ -0,0 +1,39 @@
+"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 eventsHelper_exports = {};
+__export(eventsHelper_exports, {
+  eventsHelper: () => eventsHelper
+});
+module.exports = __toCommonJS(eventsHelper_exports);
+class EventsHelper {
+  static addEventListener(emitter, eventName, handler) {
+    emitter.on(eventName, handler);
+    return { emitter, eventName, handler };
+  }
+  static removeEventListeners(listeners) {
+    for (const listener of listeners)
+      listener.emitter.removeListener(listener.eventName, listener.handler);
+    listeners.splice(0, listeners.length);
+  }
+}
+const eventsHelper = EventsHelper;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  eventsHelper
+});