rebrowser-playwright-core 1.52.0 → 1.64.1

package/lib/protocol/validatorPrimitives.js

@@ -1,179 +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 validatorPrimitives_exports = {};
-__export(validatorPrimitives_exports, {
-  ValidationError: () => ValidationError,
-  createMetadataValidator: () => createMetadataValidator,
-  findValidator: () => findValidator,
-  maybeFindValidator: () => maybeFindValidator,
-  scheme: () => scheme,
-  tAny: () => tAny,
-  tArray: () => tArray,
-  tBinary: () => tBinary,
-  tBoolean: () => tBoolean,
-  tChannel: () => tChannel,
-  tEnum: () => tEnum,
-  tNumber: () => tNumber,
-  tObject: () => tObject,
-  tOptional: () => tOptional,
-  tString: () => tString,
-  tType: () => tType,
-  tUndefined: () => tUndefined
-});
-module.exports = __toCommonJS(validatorPrimitives_exports);
-class ValidationError extends Error {
-}
-const scheme = {};
-function findValidator(type, method, kind) {
-  const validator = maybeFindValidator(type, method, kind);
-  if (!validator)
-    throw new ValidationError(`Unknown scheme for ${kind}: ${type}.${method}`);
-  return validator;
-}
-function maybeFindValidator(type, method, kind) {
-  const schemeName = type + (kind === "Initializer" ? "" : method[0].toUpperCase() + method.substring(1)) + kind;
-  return scheme[schemeName];
-}
-function createMetadataValidator() {
-  return tOptional(scheme["Metadata"]);
-}
-const tNumber = (arg, path, context) => {
-  if (arg instanceof Number)
-    return arg.valueOf();
-  if (typeof arg === "number")
-    return arg;
-  throw new ValidationError(`${path}: expected number, got ${typeof arg}`);
-};
-const tBoolean = (arg, path, context) => {
-  if (arg instanceof Boolean)
-    return arg.valueOf();
-  if (typeof arg === "boolean")
-    return arg;
-  throw new ValidationError(`${path}: expected boolean, got ${typeof arg}`);
-};
-const tString = (arg, path, context) => {
-  if (arg instanceof String)
-    return arg.valueOf();
-  if (typeof arg === "string")
-    return arg;
-  throw new ValidationError(`${path}: expected string, got ${typeof arg}`);
-};
-const tBinary = (arg, path, context) => {
-  if (context.binary === "fromBase64") {
-    if (arg instanceof String)
-      return Buffer.from(arg.valueOf(), "base64");
-    if (typeof arg === "string")
-      return Buffer.from(arg, "base64");
-    throw new ValidationError(`${path}: expected base64-encoded buffer, got ${typeof arg}`);
-  }
-  if (context.binary === "toBase64") {
-    if (!(arg instanceof Buffer))
-      throw new ValidationError(`${path}: expected Buffer, got ${typeof arg}`);
-    return arg.toString("base64");
-  }
-  if (context.binary === "buffer") {
-    if (!(arg instanceof Buffer))
-      throw new ValidationError(`${path}: expected Buffer, got ${typeof arg}`);
-    return arg;
-  }
-  throw new ValidationError(`Unsupported binary behavior "${context.binary}"`);
-};
-const tUndefined = (arg, path, context) => {
-  if (Object.is(arg, void 0))
-    return arg;
-  throw new ValidationError(`${path}: expected undefined, got ${typeof arg}`);
-};
-const tAny = (arg, path, context) => {
-  return arg;
-};
-const tOptional = (v) => {
-  return (arg, path, context) => {
-    if (Object.is(arg, void 0))
-      return arg;
-    return v(arg, path, context);
-  };
-};
-const tArray = (v) => {
-  return (arg, path, context) => {
-    if (!Array.isArray(arg))
-      throw new ValidationError(`${path}: expected array, got ${typeof arg}`);
-    return arg.map((x, index) => v(x, path + "[" + index + "]", context));
-  };
-};
-const tObject = (s) => {
-  return (arg, path, context) => {
-    if (Object.is(arg, null))
-      throw new ValidationError(`${path}: expected object, got null`);
-    if (typeof arg !== "object")
-      throw new ValidationError(`${path}: expected object, got ${typeof arg}`);
-    const result = {};
-    for (const [key, v] of Object.entries(s)) {
-      const value = v(arg[key], path ? path + "." + key : key, context);
-      if (!Object.is(value, void 0))
-        result[key] = value;
-    }
-    if (context.isUnderTest()) {
-      for (const [key, value] of Object.entries(arg)) {
-        if (key.startsWith("__testHook"))
-          result[key] = value;
-      }
-    }
-    return result;
-  };
-};
-const tEnum = (e) => {
-  return (arg, path, context) => {
-    if (!e.includes(arg))
-      throw new ValidationError(`${path}: expected one of (${e.join("|")})`);
-    return arg;
-  };
-};
-const tChannel = (names) => {
-  return (arg, path, context) => {
-    return context.tChannelImpl(names, arg, path, context);
-  };
-};
-const tType = (name) => {
-  return (arg, path, context) => {
-    const v = scheme[name];
-    if (!v)
-      throw new ValidationError(path + ': unknown type "' + name + '"');
-    return v(arg, path, context);
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ValidationError,
-  createMetadataValidator,
-  findValidator,
-  maybeFindValidator,
-  scheme,
-  tAny,
-  tArray,
-  tBinary,
-  tBoolean,
-  tChannel,
-  tEnum,
-  tNumber,
-  tObject,
-  tOptional,
-  tString,
-  tType,
-  tUndefined
-});

package/lib/remote/playwrightConnection.js

@@ -1,266 +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 playwrightConnection_exports = {};
-__export(playwrightConnection_exports, {
-  PlaywrightConnection: () => PlaywrightConnection
-});
-module.exports = __toCommonJS(playwrightConnection_exports);
-var import_socksProxy = require("../server/utils/socksProxy");
-var import_server = require("../server");
-var import_android = require("../server/android/android");
-var import_browser = require("../server/browser");
-var import_debugControllerDispatcher = require("../server/dispatchers/debugControllerDispatcher");
-var import_instrumentation = require("../server/instrumentation");
-var import_assert = require("../utils/isomorphic/assert");
-var import_debug = require("../server/utils/debug");
-var import_profiler = require("../server/utils/profiler");
-var import_utils = require("../utils");
-var import_debugLogger = require("../server/utils/debugLogger");
-class PlaywrightConnection {
-  constructor(lock, clientType, ws, options, preLaunched, id, onClose) {
-    this._cleanups = [];
-    this._disconnected = false;
-    this._ws = ws;
-    this._preLaunched = preLaunched;
-    this._options = options;
-    options.launchOptions = filterLaunchOptions(options.launchOptions, options.allowFSPaths);
-    if (clientType === "reuse-browser" || clientType === "pre-launched-browser-or-android")
-      (0, import_assert.assert)(preLaunched.playwright);
-    if (clientType === "pre-launched-browser-or-android")
-      (0, import_assert.assert)(preLaunched.browser || preLaunched.androidDevice);
-    this._onClose = onClose;
-    this._id = id;
-    this._profileName = `${(/* @__PURE__ */ new Date()).toISOString()}-${clientType}`;
-    this._dispatcherConnection = new import_server.DispatcherConnection();
-    this._dispatcherConnection.onmessage = async (message) => {
-      await lock;
-      if (ws.readyState !== ws.CLOSING) {
-        const messageString = JSON.stringify(message);
-        if (import_debugLogger.debugLogger.isEnabled("server:channel"))
-          import_debugLogger.debugLogger.log("server:channel", `[${this._id}] ${(0, import_utils.monotonicTime)() * 1e3} SEND \u25BA ${messageString}`);
-        if (import_debugLogger.debugLogger.isEnabled("server:metadata"))
-          this.logServerMetadata(message, messageString, "SEND");
-        ws.send(messageString);
-      }
-    };
-    ws.on("message", async (message) => {
-      await lock;
-      const messageString = Buffer.from(message).toString();
-      const jsonMessage = JSON.parse(messageString);
-      if (import_debugLogger.debugLogger.isEnabled("server:channel"))
-        import_debugLogger.debugLogger.log("server:channel", `[${this._id}] ${(0, import_utils.monotonicTime)() * 1e3} \u25C0 RECV ${messageString}`);
-      if (import_debugLogger.debugLogger.isEnabled("server:metadata"))
-        this.logServerMetadata(jsonMessage, messageString, "RECV");
-      this._dispatcherConnection.dispatch(jsonMessage);
-    });
-    ws.on("close", () => this._onDisconnect());
-    ws.on("error", (error) => this._onDisconnect(error));
-    if (clientType === "controller") {
-      this._root = this._initDebugControllerMode();
-      return;
-    }
-    this._root = new import_server.RootDispatcher(this._dispatcherConnection, async (scope, options2) => {
-      await (0, import_profiler.startProfiling)();
-      if (clientType === "reuse-browser")
-        return await this._initReuseBrowsersMode(scope);
-      if (clientType === "pre-launched-browser-or-android")
-        return this._preLaunched.browser ? await this._initPreLaunchedBrowserMode(scope) : await this._initPreLaunchedAndroidMode(scope);
-      if (clientType === "launch-browser")
-        return await this._initLaunchBrowserMode(scope, options2);
-      throw new Error("Unsupported client type: " + clientType);
-    });
-  }
-  async _initLaunchBrowserMode(scope, options) {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged launch mode for "${this._options.browserName}"`);
-    const playwright = (0, import_server.createPlaywright)({ sdkLanguage: options.sdkLanguage, isServer: true });
-    const ownedSocksProxy = await this._createOwnedSocksProxy(playwright);
-    let browserName = this._options.browserName;
-    if ("bidi" === browserName) {
-      if (this._options.launchOptions?.channel?.toLocaleLowerCase().includes("firefox"))
-        browserName = "bidiFirefox";
-      else
-        browserName = "bidiChromium";
-    }
-    const browser = await playwright[browserName].launch((0, import_instrumentation.serverSideCallMetadata)(), this._options.launchOptions);
-    this._cleanups.push(async () => {
-      for (const browser2 of playwright.allBrowsers())
-        await browser2.close({ reason: "Connection terminated" });
-    });
-    browser.on(import_browser.Browser.Events.Disconnected, () => {
-      this.close({ code: 1001, reason: "Browser closed" });
-    });
-    return new import_server.PlaywrightDispatcher(scope, playwright, ownedSocksProxy, browser);
-  }
-  async _initPreLaunchedBrowserMode(scope) {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged pre-launched (browser) mode`);
-    const playwright = this._preLaunched.playwright;
-    this._preLaunched.socksProxy?.setPattern(this._options.socksProxyPattern);
-    const browser = this._preLaunched.browser;
-    browser.on(import_browser.Browser.Events.Disconnected, () => {
-      this.close({ code: 1001, reason: "Browser closed" });
-    });
-    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, playwright, this._preLaunched.socksProxy, browser);
-    for (const b of playwright.allBrowsers()) {
-      if (b !== browser)
-        await b.close({ reason: "Connection terminated" });
-    }
-    this._cleanups.push(() => playwrightDispatcher.cleanup());
-    return playwrightDispatcher;
-  }
-  async _initPreLaunchedAndroidMode(scope) {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged pre-launched (Android) mode`);
-    const playwright = this._preLaunched.playwright;
-    const androidDevice = this._preLaunched.androidDevice;
-    androidDevice.on(import_android.AndroidDevice.Events.Close, () => {
-      this.close({ code: 1001, reason: "Android device disconnected" });
-    });
-    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, playwright, void 0, void 0, androidDevice);
-    this._cleanups.push(() => playwrightDispatcher.cleanup());
-    return playwrightDispatcher;
-  }
-  _initDebugControllerMode() {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse controller mode`);
-    const playwright = this._preLaunched.playwright;
-    return new import_debugControllerDispatcher.DebugControllerDispatcher(this._dispatcherConnection, playwright.debugController);
-  }
-  async _initReuseBrowsersMode(scope) {
-    import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse browsers mode for ${this._options.browserName}`);
-    const playwright = this._preLaunched.playwright;
-    const requestedOptions = launchOptionsHash(this._options.launchOptions);
-    let browser = playwright.allBrowsers().find((b) => {
-      if (b.options.name !== this._options.browserName)
-        return false;
-      const existingOptions = launchOptionsHash(b.options.originalLaunchOptions);
-      return existingOptions === requestedOptions;
-    });
-    for (const b of playwright.allBrowsers()) {
-      if (b === browser)
-        continue;
-      if (b.options.name === this._options.browserName && b.options.channel === this._options.launchOptions.channel)
-        await b.close({ reason: "Connection terminated" });
-    }
-    if (!browser) {
-      browser = await playwright[this._options.browserName || "chromium"].launch((0, import_instrumentation.serverSideCallMetadata)(), {
-        ...this._options.launchOptions,
-        headless: !!process.env.PW_DEBUG_CONTROLLER_HEADLESS
-      });
-      browser.on(import_browser.Browser.Events.Disconnected, () => {
-        this.close({ code: 1001, reason: "Browser closed" });
-      });
-    }
-    this._cleanups.push(async () => {
-      for (const browser2 of playwright.allBrowsers()) {
-        for (const context of browser2.contexts()) {
-          if (!context.pages().length)
-            await context.close({ reason: "Connection terminated" });
-          else
-            await context.stopPendingOperations("Connection closed");
-        }
-        if (!browser2.contexts())
-          await browser2.close({ reason: "Connection terminated" });
-      }
-    });
-    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, playwright, void 0, browser);
-    return playwrightDispatcher;
-  }
-  async _createOwnedSocksProxy(playwright) {
-    if (!this._options.socksProxyPattern)
-      return;
-    const socksProxy = new import_socksProxy.SocksProxy();
-    socksProxy.setPattern(this._options.socksProxyPattern);
-    playwright.options.socksProxyPort = await socksProxy.listen(0);
-    import_debugLogger.debugLogger.log("server", `[${this._id}] started socks proxy on port ${playwright.options.socksProxyPort}`);
-    this._cleanups.push(() => socksProxy.close());
-    return socksProxy;
-  }
-  async _onDisconnect(error) {
-    this._disconnected = true;
-    import_debugLogger.debugLogger.log("server", `[${this._id}] disconnected. error: ${error}`);
-    this._root._dispose();
-    import_debugLogger.debugLogger.log("server", `[${this._id}] starting cleanup`);
-    for (const cleanup of this._cleanups)
-      await cleanup().catch(() => {
-      });
-    await (0, import_profiler.stopProfiling)(this._profileName);
-    this._onClose();
-    import_debugLogger.debugLogger.log("server", `[${this._id}] finished cleanup`);
-  }
-  logServerMetadata(message, messageString, direction) {
-    const serverLogMetadata = {
-      wallTime: Date.now(),
-      id: message.id,
-      guid: message.guid,
-      method: message.method,
-      payloadSizeInBytes: Buffer.byteLength(messageString, "utf-8")
-    };
-    import_debugLogger.debugLogger.log("server:metadata", (direction === "SEND" ? "SEND \u25BA " : "\u25C0 RECV ") + JSON.stringify(serverLogMetadata));
-  }
-  async close(reason) {
-    if (this._disconnected)
-      return;
-    import_debugLogger.debugLogger.log("server", `[${this._id}] force closing connection: ${reason?.reason || ""} (${reason?.code || 0})`);
-    try {
-      this._ws.close(reason?.code, reason?.reason);
-    } catch (e) {
-    }
-  }
-}
-function launchOptionsHash(options) {
-  const copy = { ...options };
-  for (const k of Object.keys(copy)) {
-    const key = k;
-    if (copy[key] === defaultLaunchOptions[key])
-      delete copy[key];
-  }
-  for (const key of optionsThatAllowBrowserReuse)
-    delete copy[key];
-  return JSON.stringify(copy);
-}
-function filterLaunchOptions(options, allowFSPaths) {
-  return {
-    channel: options.channel,
-    args: options.args,
-    ignoreAllDefaultArgs: options.ignoreAllDefaultArgs,
-    ignoreDefaultArgs: options.ignoreDefaultArgs,
-    timeout: options.timeout,
-    headless: options.headless,
-    proxy: options.proxy,
-    chromiumSandbox: options.chromiumSandbox,
-    firefoxUserPrefs: options.firefoxUserPrefs,
-    slowMo: options.slowMo,
-    executablePath: (0, import_debug.isUnderTest)() || allowFSPaths ? options.executablePath : void 0,
-    downloadsPath: allowFSPaths ? options.downloadsPath : void 0
-  };
-}
-const defaultLaunchOptions = {
-  ignoreAllDefaultArgs: false,
-  handleSIGINT: false,
-  handleSIGTERM: false,
-  handleSIGHUP: false,
-  headless: true,
-  devtools: false
-};
-const optionsThatAllowBrowserReuse = [
-  "headless",
-  "tracesDir"
-];
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PlaywrightConnection
-});

package/lib/remote/playwrightServer.js

@@ -1,139 +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 playwrightServer_exports = {};
-__export(playwrightServer_exports, {
-  PlaywrightServer: () => PlaywrightServer
-});
-module.exports = __toCommonJS(playwrightServer_exports);
-var import_playwrightConnection = require("./playwrightConnection");
-var import_playwright = require("../server/playwright");
-var import_debugLogger = require("../server/utils/debugLogger");
-var import_semaphore = require("../utils/isomorphic/semaphore");
-var import_wsServer = require("../server/utils/wsServer");
-var import_ascii = require("../server/utils/ascii");
-var import_userAgent = require("../server/utils/userAgent");
-class PlaywrightServer {
-  constructor(options) {
-    this._options = options;
-    if (options.preLaunchedBrowser)
-      this._preLaunchedPlaywright = options.preLaunchedBrowser.attribution.playwright;
-    if (options.preLaunchedAndroidDevice)
-      this._preLaunchedPlaywright = options.preLaunchedAndroidDevice._android.attribution.playwright;
-    const browserSemaphore = new import_semaphore.Semaphore(this._options.maxConnections);
-    const controllerSemaphore = new import_semaphore.Semaphore(1);
-    const reuseBrowserSemaphore = new import_semaphore.Semaphore(1);
-    this._wsServer = new import_wsServer.WSServer({
-      onUpgrade: (request, socket) => {
-        const uaError = userAgentVersionMatchesErrorMessage(request.headers["user-agent"] || "");
-        if (uaError)
-          return { error: `HTTP/${request.httpVersion} 428 Precondition Required\r
-\r
-${uaError}` };
-      },
-      onHeaders: (headers) => {
-        if (process.env.PWTEST_SERVER_WS_HEADERS)
-          headers.push(process.env.PWTEST_SERVER_WS_HEADERS);
-      },
-      onConnection: (request, url, ws, id) => {
-        const browserHeader = request.headers["x-playwright-browser"];
-        const browserName = url.searchParams.get("browser") || (Array.isArray(browserHeader) ? browserHeader[0] : browserHeader) || null;
-        const proxyHeader = request.headers["x-playwright-proxy"];
-        const proxyValue = url.searchParams.get("proxy") || (Array.isArray(proxyHeader) ? proxyHeader[0] : proxyHeader);
-        const launchOptionsHeader = request.headers["x-playwright-launch-options"] || "";
-        const launchOptionsHeaderValue = Array.isArray(launchOptionsHeader) ? launchOptionsHeader[0] : launchOptionsHeader;
-        const launchOptionsParam = url.searchParams.get("launch-options");
-        let launchOptions = {};
-        try {
-          launchOptions = JSON.parse(launchOptionsParam || launchOptionsHeaderValue);
-        } catch (e) {
-        }
-        const isExtension = this._options.mode === "extension";
-        if (isExtension) {
-          if (!this._preLaunchedPlaywright)
-            this._preLaunchedPlaywright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isServer: true });
-        }
-        let clientType = "launch-browser";
-        let semaphore = browserSemaphore;
-        if (isExtension && url.searchParams.has("debug-controller")) {
-          clientType = "controller";
-          semaphore = controllerSemaphore;
-        } else if (isExtension) {
-          clientType = "reuse-browser";
-          semaphore = reuseBrowserSemaphore;
-        } else if (this._options.mode === "launchServer") {
-          clientType = "pre-launched-browser-or-android";
-          semaphore = browserSemaphore;
-        }
-        return new import_playwrightConnection.PlaywrightConnection(
-          semaphore.acquire(),
-          clientType,
-          ws,
-          { socksProxyPattern: proxyValue, browserName, launchOptions, allowFSPaths: this._options.mode === "extension" },
-          {
-            playwright: this._preLaunchedPlaywright,
-            browser: this._options.preLaunchedBrowser,
-            androidDevice: this._options.preLaunchedAndroidDevice,
-            socksProxy: this._options.preLaunchedSocksProxy
-          },
-          id,
-          () => semaphore.release()
-        );
-      },
-      onClose: async () => {
-        import_debugLogger.debugLogger.log("server", "closing browsers");
-        if (this._preLaunchedPlaywright)
-          await Promise.all(this._preLaunchedPlaywright.allBrowsers().map((browser) => browser.close({ reason: "Playwright Server stopped" })));
-        import_debugLogger.debugLogger.log("server", "closed browsers");
-      }
-    });
-  }
-  async listen(port = 0, hostname) {
-    return this._wsServer.listen(port, hostname, this._options.path);
-  }
-  async close() {
-    await this._wsServer.close();
-  }
-}
-function userAgentVersionMatchesErrorMessage(userAgent) {
-  const match = userAgent.match(/^Playwright\/(\d+\.\d+\.\d+)/);
-  if (!match) {
-    return;
-  }
-  const received = match[1].split(".").slice(0, 2).join(".");
-  const expected = (0, import_userAgent.getPlaywrightVersion)(true);
-  if (received !== expected) {
-    return (0, import_ascii.wrapInASCIIBox)([
-      `Playwright version mismatch:`,
-      `  - server version: v${expected}`,
-      `  - client version: v${received}`,
-      ``,
-      `If you are using VSCode extension, restart VSCode.`,
-      ``,
-      `If you are connecting to a remote service,`,
-      `keep your local Playwright version in sync`,
-      `with the remote service version.`,
-      ``,
-      `<3 Playwright Team`
-    ].join("\n"), 1);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PlaywrightServer
-});

package/lib/server/accessibility.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 accessibility_exports = {};
-__export(accessibility_exports, {
-  Accessibility: () => Accessibility
-});
-module.exports = __toCommonJS(accessibility_exports);
-class Accessibility {
-  constructor(getAXTree) {
-    this._getAXTree = getAXTree;
-  }
-  async snapshot(options = {}) {
-    const {
-      interestingOnly = true,
-      root = null
-    } = options;
-    const { tree, needle } = await this._getAXTree(root || void 0);
-    if (!interestingOnly) {
-      if (root)
-        return needle && serializeTree(needle)[0];
-      return serializeTree(tree)[0];
-    }
-    const interestingNodes = /* @__PURE__ */ new Set();
-    collectInterestingNodes(interestingNodes, tree, false);
-    if (root && (!needle || !interestingNodes.has(needle)))
-      return null;
-    return serializeTree(needle || tree, interestingNodes)[0];
-  }
-}
-function collectInterestingNodes(collection, node, insideControl) {
-  if (node.isInteresting(insideControl))
-    collection.add(node);
-  if (node.isLeafNode())
-    return;
-  insideControl = insideControl || node.isControl();
-  for (const child of node.children())
-    collectInterestingNodes(collection, child, insideControl);
-}
-function serializeTree(node, whitelistedNodes) {
-  const children = [];
-  for (const child of node.children())
-    children.push(...serializeTree(child, whitelistedNodes));
-  if (whitelistedNodes && !whitelistedNodes.has(node))
-    return children;
-  const serializedNode = node.serialize();
-  if (children.length)
-    serializedNode.children = children;
-  return [serializedNode];
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Accessibility
-});