@limrun/playwright-core 1.56.1-lim.1 → 1.61.0-lim.1

package/lib/client/browserType.js

@@ -1,184 +0,0 @@
-"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 browserType_exports = {};
-__export(browserType_exports, {
-  BrowserType: () => BrowserType
-});
-module.exports = __toCommonJS(browserType_exports);
-var import_browser = require("./browser");
-var import_browserContext = require("./browserContext");
-var import_channelOwner = require("./channelOwner");
-var import_clientHelper = require("./clientHelper");
-var import_events = require("./events");
-var import_assert = require("../utils/isomorphic/assert");
-var import_headers = require("../utils/isomorphic/headers");
-var import_time = require("../utils/isomorphic/time");
-var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
-var import_webSocket = require("./webSocket");
-var import_timeoutSettings = require("./timeoutSettings");
-class BrowserType extends import_channelOwner.ChannelOwner {
-  constructor() {
-    super(...arguments);
-    this._contexts = /* @__PURE__ */ new Set();
-  }
-  static from(browserType) {
-    return browserType._object;
-  }
-  executablePath() {
-    if (!this._initializer.executablePath)
-      throw new Error("Browser is not supported on current platform");
-    return this._initializer.executablePath;
-  }
-  name() {
-    return this._initializer.name;
-  }
-  async launch(options = {}) {
-    (0, import_assert.assert)(!options.userDataDir, "userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead");
-    (0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
-    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
-    options = { ...this._playwright._defaultLaunchOptions, ...options };
-    const launchOptions = {
-      ...options,
-      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
-      ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
-      env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0,
-      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
-    };
-    return await this._wrapApiCall(async () => {
-      const browser = import_browser.Browser.from((await this._channel.launch(launchOptions)).browser);
-      browser._connectToBrowserType(this, options, logger);
-      return browser;
-    });
-  }
-  async launchServer(options = {}) {
-    if (!this._serverLauncher)
-      throw new Error("Launching server is not supported");
-    options = { ...this._playwright._defaultLaunchOptions, ...options };
-    return await this._serverLauncher.launchServer(options);
-  }
-  async launchPersistentContext(userDataDir, options = {}) {
-    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
-    (0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
-    options = this._playwright.selectors._withSelectorOptions({
-      ...this._playwright._defaultLaunchOptions,
-      ...this._playwright._defaultContextOptions,
-      ...options
-    });
-    const contextParams = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
-    const persistentParams = {
-      ...contextParams,
-      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
-      ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
-      env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0,
-      channel: options.channel,
-      userDataDir: this._platform.path().isAbsolute(userDataDir) || !userDataDir ? userDataDir : this._platform.path().resolve(userDataDir),
-      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
-    };
-    const context = await this._wrapApiCall(async () => {
-      const result = await this._channel.launchPersistentContext(persistentParams);
-      const browser = import_browser.Browser.from(result.browser);
-      browser._connectToBrowserType(this, options, logger);
-      const context2 = import_browserContext.BrowserContext.from(result.context);
-      await context2._initializeHarFromOptions(options.recordHar);
-      return context2;
-    });
-    await this._instrumentation.runAfterCreateBrowserContext(context);
-    return context;
-  }
-  async connect(optionsOrWsEndpoint, options) {
-    if (typeof optionsOrWsEndpoint === "string")
-      return await this._connect({ ...options, wsEndpoint: optionsOrWsEndpoint });
-    (0, import_assert.assert)(optionsOrWsEndpoint.wsEndpoint, "options.wsEndpoint is required");
-    return await this._connect(optionsOrWsEndpoint);
-  }
-  async _connect(params) {
-    const logger = params.logger;
-    return await this._wrapApiCall(async () => {
-      const deadline = params.timeout ? (0, import_time.monotonicTime)() + params.timeout : 0;
-      const headers = { "x-playwright-browser": this.name(), ...params.headers };
-      const connectParams = {
-        wsEndpoint: params.wsEndpoint,
-        headers,
-        exposeNetwork: params.exposeNetwork ?? params._exposeNetwork,
-        slowMo: params.slowMo,
-        timeout: params.timeout || 0
-      };
-      if (params.__testHookRedirectPortForwarding)
-        connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
-      const connection = await (0, import_webSocket.connectOverWebSocket)(this._connection, connectParams);
-      let browser;
-      connection.on("close", () => {
-        for (const context of browser?.contexts() || []) {
-          for (const page of context.pages())
-            page._onClose();
-          context._onClose();
-        }
-        setTimeout(() => browser?._didClose(), 0);
-      });
-      const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
-        if (params.__testHookBeforeCreateBrowser)
-          await params.__testHookBeforeCreateBrowser();
-        const playwright = await connection.initializePlaywright();
-        if (!playwright._initializer.preLaunchedBrowser) {
-          connection.close();
-          throw new Error("Malformed endpoint. Did you use BrowserType.launchServer method?");
-        }
-        playwright.selectors = this._playwright.selectors;
-        browser = import_browser.Browser.from(playwright._initializer.preLaunchedBrowser);
-        browser._connectToBrowserType(this, {}, logger);
-        browser._shouldCloseConnectionOnClose = true;
-        browser.on(import_events.Events.Browser.Disconnected, () => connection.close());
-        return browser;
-      }, deadline);
-      if (!result.timedOut) {
-        return result.result;
-      } else {
-        connection.close();
-        throw new Error(`Timeout ${params.timeout}ms exceeded`);
-      }
-    });
-  }
-  async connectOverCDP(endpointURLOrOptions, options) {
-    if (typeof endpointURLOrOptions === "string")
-      return await this._connectOverCDP(endpointURLOrOptions, options);
-    const endpointURL = "endpointURL" in endpointURLOrOptions ? endpointURLOrOptions.endpointURL : endpointURLOrOptions.wsEndpoint;
-    (0, import_assert.assert)(endpointURL, "Cannot connect over CDP without wsEndpoint.");
-    return await this.connectOverCDP(endpointURL, endpointURLOrOptions);
-  }
-  async _connectOverCDP(endpointURL, params = {}) {
-    if (this.name() !== "chromium")
-      throw new Error("Connecting over CDP is only supported in Chromium.");
-    const headers = params.headers ? (0, import_headers.headersObjectToArray)(params.headers) : void 0;
-    const result = await this._channel.connectOverCDP({
-      endpointURL,
-      headers,
-      slowMo: params.slowMo,
-      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).timeout(params)
-    });
-    const browser = import_browser.Browser.from(result.browser);
-    browser._connectToBrowserType(this, {}, params.logger);
-    if (result.defaultContext)
-      await this._instrumentation.runAfterCreateBrowserContext(import_browserContext.BrowserContext.from(result.defaultContext));
-    return browser;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BrowserType
-});

package/lib/client/cdpSession.js

@@ -1,51 +0,0 @@
-"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 cdpSession_exports = {};
-__export(cdpSession_exports, {
-  CDPSession: () => CDPSession
-});
-module.exports = __toCommonJS(cdpSession_exports);
-var import_channelOwner = require("./channelOwner");
-class CDPSession extends import_channelOwner.ChannelOwner {
-  static from(cdpSession) {
-    return cdpSession._object;
-  }
-  constructor(parent, type, guid, initializer) {
-    super(parent, type, guid, initializer);
-    this._channel.on("event", ({ method, params }) => {
-      this.emit(method, params);
-    });
-    this.on = super.on;
-    this.addListener = super.addListener;
-    this.off = super.removeListener;
-    this.removeListener = super.removeListener;
-    this.once = super.once;
-  }
-  async send(method, params) {
-    const result = await this._channel.send({ method, params });
-    return result.result;
-  }
-  async detach() {
-    return await this._channel.detach();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CDPSession
-});

package/lib/client/channelOwner.js

@@ -1,194 +0,0 @@
-"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 channelOwner_exports = {};
-__export(channelOwner_exports, {
-  ChannelOwner: () => ChannelOwner
-});
-module.exports = __toCommonJS(channelOwner_exports);
-var import_eventEmitter = require("./eventEmitter");
-var import_validator = require("../protocol/validator");
-var import_protocolMetainfo = require("../utils/isomorphic/protocolMetainfo");
-var import_clientStackTrace = require("./clientStackTrace");
-var import_stackTrace = require("../utils/isomorphic/stackTrace");
-class ChannelOwner extends import_eventEmitter.EventEmitter {
-  constructor(parent, type, guid, initializer) {
-    const connection = parent instanceof ChannelOwner ? parent._connection : parent;
-    super(connection._platform);
-    this._objects = /* @__PURE__ */ new Map();
-    this._eventToSubscriptionMapping = /* @__PURE__ */ new Map();
-    this._wasCollected = false;
-    this.setMaxListeners(0);
-    this._connection = connection;
-    this._type = type;
-    this._guid = guid;
-    this._parent = parent instanceof ChannelOwner ? parent : void 0;
-    this._instrumentation = this._connection._instrumentation;
-    this._connection._objects.set(guid, this);
-    if (this._parent) {
-      this._parent._objects.set(guid, this);
-      this._logger = this._parent._logger;
-    }
-    this._channel = this._createChannel(new import_eventEmitter.EventEmitter(connection._platform));
-    this._initializer = initializer;
-  }
-  _setEventToSubscriptionMapping(mapping) {
-    this._eventToSubscriptionMapping = mapping;
-  }
-  _updateSubscription(event, enabled) {
-    const protocolEvent = this._eventToSubscriptionMapping.get(String(event));
-    if (protocolEvent)
-      this._channel.updateSubscription({ event: protocolEvent, enabled }).catch(() => {
-      });
-  }
-  on(event, listener) {
-    if (!this.listenerCount(event))
-      this._updateSubscription(event, true);
-    super.on(event, listener);
-    return this;
-  }
-  addListener(event, listener) {
-    if (!this.listenerCount(event))
-      this._updateSubscription(event, true);
-    super.addListener(event, listener);
-    return this;
-  }
-  prependListener(event, listener) {
-    if (!this.listenerCount(event))
-      this._updateSubscription(event, true);
-    super.prependListener(event, listener);
-    return this;
-  }
-  off(event, listener) {
-    super.off(event, listener);
-    if (!this.listenerCount(event))
-      this._updateSubscription(event, false);
-    return this;
-  }
-  removeListener(event, listener) {
-    super.removeListener(event, listener);
-    if (!this.listenerCount(event))
-      this._updateSubscription(event, false);
-    return this;
-  }
-  _adopt(child) {
-    child._parent._objects.delete(child._guid);
-    this._objects.set(child._guid, child);
-    child._parent = this;
-  }
-  _dispose(reason) {
-    if (this._parent)
-      this._parent._objects.delete(this._guid);
-    this._connection._objects.delete(this._guid);
-    this._wasCollected = reason === "gc";
-    for (const object of [...this._objects.values()])
-      object._dispose(reason);
-    this._objects.clear();
-  }
-  _debugScopeState() {
-    return {
-      _guid: this._guid,
-      objects: Array.from(this._objects.values()).map((o) => o._debugScopeState())
-    };
-  }
-  _validatorToWireContext() {
-    return {
-      tChannelImpl: tChannelImplToWire,
-      binary: this._connection.rawBuffers() ? "buffer" : "toBase64",
-      isUnderTest: () => this._platform.isUnderTest()
-    };
-  }
-  _createChannel(base) {
-    const channel = new Proxy(base, {
-      get: (obj, prop) => {
-        if (typeof prop === "string") {
-          const validator = (0, import_validator.maybeFindValidator)(this._type, prop, "Params");
-          const { internal } = import_protocolMetainfo.methodMetainfo.get(this._type + "." + prop) || {};
-          if (validator) {
-            return async (params) => {
-              return await this._wrapApiCall(async (apiZone) => {
-                const validatedParams = validator(params, "", this._validatorToWireContext());
-                if (!apiZone.internal && !apiZone.reported) {
-                  apiZone.reported = true;
-                  this._instrumentation.onApiCallBegin(apiZone, { type: this._type, method: prop, params });
-                  logApiCall(this._platform, this._logger, `=> ${apiZone.apiName} started`);
-                  return await this._connection.sendMessageToServer(this, prop, validatedParams, apiZone);
-                }
-                return await this._connection.sendMessageToServer(this, prop, validatedParams, { internal: true });
-              }, { internal });
-            };
-          }
-        }
-        return obj[prop];
-      }
-    });
-    channel._object = this;
-    return channel;
-  }
-  async _wrapApiCall(func, options) {
-    const logger = this._logger;
-    const existingApiZone = this._platform.zones.current().data();
-    if (existingApiZone)
-      return await func(existingApiZone);
-    const stackTrace = (0, import_clientStackTrace.captureLibraryStackTrace)(this._platform);
-    const apiZone = { title: options?.title, apiName: stackTrace.apiName, frames: stackTrace.frames, internal: options?.internal ?? false, reported: false, userData: void 0, stepId: void 0 };
-    try {
-      const result = await this._platform.zones.current().push(apiZone).run(async () => await func(apiZone));
-      if (!options?.internal) {
-        logApiCall(this._platform, logger, `<= ${apiZone.apiName} succeeded`);
-        this._instrumentation.onApiCallEnd(apiZone);
-      }
-      return result;
-    } catch (e) {
-      const innerError = (this._platform.showInternalStackFrames() || this._platform.isUnderTest()) && e.stack ? "\n<inner error>\n" + e.stack : "";
-      if (apiZone.apiName && !apiZone.apiName.includes("<anonymous>"))
-        e.message = apiZone.apiName + ": " + e.message;
-      const stackFrames = "\n" + (0, import_stackTrace.stringifyStackFrames)(stackTrace.frames).join("\n") + innerError;
-      if (stackFrames.trim())
-        e.stack = e.message + stackFrames;
-      else
-        e.stack = "";
-      if (!options?.internal) {
-        apiZone.error = e;
-        logApiCall(this._platform, logger, `<= ${apiZone.apiName} failed`);
-        this._instrumentation.onApiCallEnd(apiZone);
-      }
-      throw e;
-    }
-  }
-  toJSON() {
-    return {
-      _type: this._type,
-      _guid: this._guid
-    };
-  }
-}
-function logApiCall(platform, logger, message) {
-  if (logger && logger.isEnabled("api", "info"))
-    logger.log("api", "info", message, [], { color: "cyan" });
-  platform.log("api", message);
-}
-function tChannelImplToWire(names, arg, path, context) {
-  if (arg._object instanceof ChannelOwner && (names === "*" || names.includes(arg._object._type)))
-    return { guid: arg._object._guid };
-  throw new import_validator.ValidationError(`${path}: expected channel ${names.toString()}`);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ChannelOwner
-});

package/lib/client/clientHelper.js

@@ -1,64 +0,0 @@
-"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 clientHelper_exports = {};
-__export(clientHelper_exports, {
-  addSourceUrlToScript: () => addSourceUrlToScript,
-  envObjectToArray: () => envObjectToArray,
-  evaluationScript: () => evaluationScript
-});
-module.exports = __toCommonJS(clientHelper_exports);
-var import_rtti = require("../utils/isomorphic/rtti");
-function envObjectToArray(env) {
-  const result = [];
-  for (const name in env) {
-    if (!Object.is(env[name], void 0))
-      result.push({ name, value: String(env[name]) });
-  }
-  return result;
-}
-async function evaluationScript(platform, fun, arg, addSourceUrl = true) {
-  if (typeof fun === "function") {
-    const source = fun.toString();
-    const argString = Object.is(arg, void 0) ? "undefined" : JSON.stringify(arg);
-    return `(${source})(${argString})`;
-  }
-  if (arg !== void 0)
-    throw new Error("Cannot evaluate a string with arguments");
-  if ((0, import_rtti.isString)(fun))
-    return fun;
-  if (fun.content !== void 0)
-    return fun.content;
-  if (fun.path !== void 0) {
-    let source = await platform.fs().promises.readFile(fun.path, "utf8");
-    if (addSourceUrl)
-      source = addSourceUrlToScript(source, fun.path);
-    return source;
-  }
-  throw new Error("Either path or content property must be present");
-}
-function addSourceUrlToScript(source, path) {
-  return `${source}
-//# sourceURL=${path.replace(/\n/g, "")}`;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  addSourceUrlToScript,
-  envObjectToArray,
-  evaluationScript
-});

package/lib/client/clientInstrumentation.js

@@ -1,55 +0,0 @@
-"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 clientInstrumentation_exports = {};
-__export(clientInstrumentation_exports, {
-  createInstrumentation: () => createInstrumentation
-});
-module.exports = __toCommonJS(clientInstrumentation_exports);
-function createInstrumentation() {
-  const listeners = [];
-  return new Proxy({}, {
-    get: (obj, prop) => {
-      if (typeof prop !== "string")
-        return obj[prop];
-      if (prop === "addListener")
-        return (listener) => listeners.push(listener);
-      if (prop === "removeListener")
-        return (listener) => listeners.splice(listeners.indexOf(listener), 1);
-      if (prop === "removeAllListeners")
-        return () => listeners.splice(0, listeners.length);
-      if (prop.startsWith("run")) {
-        return async (...params) => {
-          for (const listener of listeners)
-            await listener[prop]?.(...params);
-        };
-      }
-      if (prop.startsWith("on")) {
-        return (...params) => {
-          for (const listener of listeners)
-            listener[prop]?.(...params);
-        };
-      }
-      return obj[prop];
-    }
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createInstrumentation
-});

package/lib/client/clientStackTrace.js

@@ -1,69 +0,0 @@
-"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 clientStackTrace_exports = {};
-__export(clientStackTrace_exports, {
-  captureLibraryStackTrace: () => captureLibraryStackTrace
-});
-module.exports = __toCommonJS(clientStackTrace_exports);
-var import_stackTrace = require("../utils/isomorphic/stackTrace");
-function captureLibraryStackTrace(platform) {
-  const stack = (0, import_stackTrace.captureRawStack)();
-  let parsedFrames = stack.map((line) => {
-    const frame = (0, import_stackTrace.parseStackFrame)(line, platform.pathSeparator, platform.showInternalStackFrames());
-    if (!frame || !frame.file)
-      return null;
-    const isPlaywrightLibrary = !!platform.coreDir && frame.file.startsWith(platform.coreDir);
-    const parsed = {
-      frame,
-      frameText: line,
-      isPlaywrightLibrary
-    };
-    return parsed;
-  }).filter(Boolean);
-  let apiName = "";
-  for (let i = 0; i < parsedFrames.length - 1; i++) {
-    const parsedFrame = parsedFrames[i];
-    if (parsedFrame.isPlaywrightLibrary && !parsedFrames[i + 1].isPlaywrightLibrary) {
-      apiName = apiName || normalizeAPIName(parsedFrame.frame.function);
-      break;
-    }
-  }
-  function normalizeAPIName(name) {
-    if (!name)
-      return "";
-    const match = name.match(/(API|JS|CDP|[A-Z])(.*)/);
-    if (!match)
-      return name;
-    return match[1].toLowerCase() + match[2];
-  }
-  const filterPrefixes = platform.boxedStackPrefixes();
-  parsedFrames = parsedFrames.filter((f) => {
-    if (filterPrefixes.some((prefix) => f.frame.file.startsWith(prefix)))
-      return false;
-    return true;
-  });
-  return {
-    frames: parsedFrames.map((p) => p.frame),
-    apiName
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  captureLibraryStackTrace
-});

package/lib/client/clock.js

@@ -1,68 +0,0 @@
-"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 clock_exports = {};
-__export(clock_exports, {
-  Clock: () => Clock
-});
-module.exports = __toCommonJS(clock_exports);
-class Clock {
-  constructor(browserContext) {
-    this._browserContext = browserContext;
-  }
-  async install(options = {}) {
-    await this._browserContext._channel.clockInstall(options.time !== void 0 ? parseTime(options.time) : {});
-  }
-  async fastForward(ticks) {
-    await this._browserContext._channel.clockFastForward(parseTicks(ticks));
-  }
-  async pauseAt(time) {
-    await this._browserContext._channel.clockPauseAt(parseTime(time));
-  }
-  async resume() {
-    await this._browserContext._channel.clockResume({});
-  }
-  async runFor(ticks) {
-    await this._browserContext._channel.clockRunFor(parseTicks(ticks));
-  }
-  async setFixedTime(time) {
-    await this._browserContext._channel.clockSetFixedTime(parseTime(time));
-  }
-  async setSystemTime(time) {
-    await this._browserContext._channel.clockSetSystemTime(parseTime(time));
-  }
-}
-function parseTime(time) {
-  if (typeof time === "number")
-    return { timeNumber: time };
-  if (typeof time === "string")
-    return { timeString: time };
-  if (!isFinite(time.getTime()))
-    throw new Error(`Invalid date: ${time}`);
-  return { timeNumber: time.getTime() };
-}
-function parseTicks(ticks) {
-  return {
-    ticksNumber: typeof ticks === "number" ? ticks : void 0,
-    ticksString: typeof ticks === "string" ? ticks : void 0
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Clock
-});