🚀 Auto-deploy: BotVPS atualizado em 02/05/2026 15:37:40

node_modules/playwright-core/lib/server/browser.js

@@ -0,0 +1,212 @@
+"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 browser_exports = {};
+__export(browser_exports, {
+  Browser: () => Browser,
+  BrowserServer: () => BrowserServer
+});
+module.exports = __toCommonJS(browser_exports);
+var import_fs = __toESM(require("fs"));
+var import_browserContext = require("./browserContext");
+var import_download = require("./download");
+var import_instrumentation = require("./instrumentation");
+var import_socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
+var import_playwrightPipeServer = require("../remote/playwrightPipeServer");
+var import_playwrightWebSocketServer = require("../remote/playwrightWebSocketServer");
+var import_serverRegistry = require("../serverRegistry");
+var import_fileUtils = require("./utils/fileUtils");
+var import_utils = require("../utils");
+class Browser extends import_instrumentation.SdkObject {
+  constructor(parent, options) {
+    super(parent, "browser");
+    this._downloads = /* @__PURE__ */ new Map();
+    this._defaultContext = null;
+    this._startedClosing = false;
+    this._isCollocatedWithServer = true;
+    this.attribution.browser = this;
+    this.options = options;
+    this.instrumentation.onBrowserOpen(this);
+    this._server = new BrowserServer(this);
+  }
+  static {
+    this.Events = {
+      Context: "context",
+      Disconnected: "disconnected"
+    };
+  }
+  sdkLanguage() {
+    return this.options.sdkLanguage || this.attribution.playwright.options.sdkLanguage;
+  }
+  async newContext(progress, options) {
+    (0, import_browserContext.validateBrowserContextOptions)(options, this.options);
+    let clientCertificatesProxy;
+    let context;
+    try {
+      if (options.clientCertificates?.length) {
+        clientCertificatesProxy = await import_socksClientCertificatesInterceptor.ClientCertificatesProxy.create(progress, options);
+        options = { ...options };
+        options.proxyOverride = clientCertificatesProxy.proxySettings();
+        options.internalIgnoreHTTPSErrors = true;
+      }
+      context = await progress.race(this.doCreateNewContext(options));
+      context._clientCertificatesProxy = clientCertificatesProxy;
+      if (options.__testHookBeforeSetStorageState)
+        await progress.race(options.__testHookBeforeSetStorageState());
+      await context.setStorageState(progress, options.storageState, "initial");
+      this.emit(Browser.Events.Context, context);
+      return context;
+    } catch (error) {
+      await context?.close({ reason: "Failed to create context" }).catch(() => {
+      });
+      await clientCertificatesProxy?.close().catch(() => {
+      });
+      throw error;
+    }
+  }
+  async newContextForReuse(progress, params) {
+    const hash = import_browserContext.BrowserContext.reusableContextHash(params);
+    if (!this._contextForReuse || hash !== this._contextForReuse.hash || !this._contextForReuse.context.canResetForReuse()) {
+      if (this._contextForReuse)
+        await this._contextForReuse.context.close({ reason: "Context reused" });
+      this._contextForReuse = { context: await this.newContext(progress, params), hash };
+      return this._contextForReuse.context;
+    }
+    await this._contextForReuse.context.resetForReuse(progress, params);
+    return this._contextForReuse.context;
+  }
+  contextForReuse() {
+    return this._contextForReuse?.context;
+  }
+  _downloadCreated(page, uuid, url, suggestedFilename, downloadFilename) {
+    const download = new import_download.Download(page, this.options.downloadsPath || "", uuid, url, suggestedFilename, downloadFilename);
+    this._downloads.set(uuid, download);
+  }
+  _downloadFilenameSuggested(uuid, suggestedFilename) {
+    const download = this._downloads.get(uuid);
+    if (!download)
+      return;
+    download._filenameSuggested(suggestedFilename);
+  }
+  _downloadFinished(uuid, error) {
+    const download = this._downloads.get(uuid);
+    if (!download)
+      return;
+    download.artifact.reportFinished(error ? new Error(error) : void 0);
+    this._downloads.delete(uuid);
+  }
+  async startServer(title, options) {
+    return await this._server.start(title, options);
+  }
+  async stopServer() {
+    await this._server.stop();
+  }
+  _didClose() {
+    for (const context of this.contexts())
+      context._browserClosed();
+    if (this._defaultContext)
+      this._defaultContext._browserClosed();
+    this.stopServer().catch(() => {
+    });
+    this.emit(Browser.Events.Disconnected);
+    this.instrumentation.onBrowserClose(this);
+  }
+  async close(options) {
+    if (!this._startedClosing) {
+      if (options.reason)
+        this._closeReason = options.reason;
+      this._startedClosing = true;
+      await this.options.browserProcess.close();
+    }
+    if (this.isConnected())
+      await new Promise((x) => this.once(Browser.Events.Disconnected, x));
+  }
+  async killForTests() {
+    await this.options.browserProcess.kill();
+  }
+}
+class BrowserServer {
+  constructor(browser) {
+    this._isStarted = false;
+    this._browser = browser;
+  }
+  async start(title, options) {
+    if (this._isStarted)
+      throw new Error(`Server is already started.`);
+    this._isStarted = true;
+    let endpoint;
+    if (options.host !== void 0 || options.port !== void 0) {
+      this._wsServer = new import_playwrightWebSocketServer.PlaywrightWebSocketServer(this._browser, "/");
+      endpoint = await this._wsServer.listen(options.port ?? 0, options.host, (0, import_utils.createGuid)());
+    } else {
+      this._pipeServer = new import_playwrightPipeServer.PlaywrightPipeServer(this._browser);
+      this._pipeSocketPath = await this._socketPath();
+      await this._pipeServer.listen(this._pipeSocketPath);
+      endpoint = this._pipeSocketPath;
+    }
+    const browserInfo = {
+      guid: this._browser.guid,
+      browserName: this._browser.options.browserType,
+      launchOptions: asClientLaunchOptions(this._browser.options.originalLaunchOptions),
+      userDataDir: this._browser.options.userDataDir
+    };
+    await import_serverRegistry.serverRegistry.create(browserInfo, {
+      title,
+      endpoint,
+      workspaceDir: options.workspaceDir,
+      metadata: options.metadata
+    });
+    return { endpoint };
+  }
+  async stop() {
+    if (!this._browser.options.userDataDir)
+      await import_serverRegistry.serverRegistry.delete(this._browser.guid);
+    if (this._pipeSocketPath && process.platform !== "win32")
+      await import_fs.default.promises.unlink(this._pipeSocketPath).catch(() => {
+      });
+    await this._pipeServer?.close();
+    await this._wsServer?.close();
+    this._pipeServer = void 0;
+    this._wsServer = void 0;
+    this._isStarted = false;
+  }
+  async _socketPath() {
+    return (0, import_fileUtils.makeSocketPath)("browser", this._browser.guid.slice(0, 14));
+  }
+}
+function asClientLaunchOptions(serverOptions) {
+  return {
+    ...serverOptions,
+    env: serverOptions.env ? Object.fromEntries(serverOptions.env.map(({ name, value }) => [name, value])) : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Browser,
+  BrowserServer
+});