rubycrawl 0.1.1 → 0.1.3

data/node/node_modules/playwright-core/lib/server/fileUploadUtils.js

@@ -1,84 +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 fileUploadUtils_exports = {};
-__export(fileUploadUtils_exports, {
-  fileUploadSizeLimit: () => fileUploadSizeLimit,
-  prepareFilesForUpload: () => prepareFilesForUpload
-});
-module.exports = __toCommonJS(fileUploadUtils_exports);
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_assert = require("../utils/isomorphic/assert");
-var import_utilsBundle = require("../utilsBundle");
-const fileUploadSizeLimit = 50 * 1024 * 1024;
-async function filesExceedUploadLimit(files) {
-  const sizes = await Promise.all(files.map(async (file) => (await import_fs.default.promises.stat(file)).size));
-  return sizes.reduce((total, size) => total + size, 0) >= fileUploadSizeLimit;
-}
-async function prepareFilesForUpload(frame, params) {
-  const { payloads, streams, directoryStream } = params;
-  let { localPaths, localDirectory } = params;
-  if ([payloads, localPaths, localDirectory, streams, directoryStream].filter(Boolean).length !== 1)
-    throw new Error("Exactly one of payloads, localPaths and streams must be provided");
-  if (streams)
-    localPaths = streams.map((c) => c.path());
-  if (directoryStream)
-    localDirectory = directoryStream.path();
-  if (localPaths) {
-    for (const p of localPaths)
-      (0, import_assert.assert)(import_path.default.isAbsolute(p) && import_path.default.resolve(p) === p, "Paths provided to localPaths must be absolute and fully resolved.");
-  }
-  let fileBuffers = payloads;
-  if (!frame._page.browserContext._browser._isCollocatedWithServer) {
-    if (localPaths) {
-      if (await filesExceedUploadLimit(localPaths))
-        throw new Error("Cannot transfer files larger than 50Mb to a browser not co-located with the server");
-      fileBuffers = await Promise.all(localPaths.map(async (item) => {
-        return {
-          name: import_path.default.basename(item),
-          buffer: await import_fs.default.promises.readFile(item),
-          lastModifiedMs: (await import_fs.default.promises.stat(item)).mtimeMs
-        };
-      }));
-      localPaths = void 0;
-    }
-  }
-  const filePayloads = fileBuffers?.map((payload) => ({
-    name: payload.name,
-    mimeType: payload.mimeType || import_utilsBundle.mime.getType(payload.name) || "application/octet-stream",
-    buffer: payload.buffer.toString("base64"),
-    lastModifiedMs: payload.lastModifiedMs
-  }));
-  return { localPaths, localDirectory, filePayloads };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  fileUploadSizeLimit,
-  prepareFilesForUpload
-});

data/node/node_modules/playwright-core/lib/server/firefox/ffBrowser.js

@@ -1,418 +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 ffBrowser_exports = {};
-__export(ffBrowser_exports, {
-  FFBrowser: () => FFBrowser,
-  FFBrowserContext: () => FFBrowserContext
-});
-module.exports = __toCommonJS(ffBrowser_exports);
-var import_utils = require("../../utils");
-var import_browser = require("../browser");
-var import_browserContext = require("../browserContext");
-var import_errors = require("../errors");
-var network = __toESM(require("../network"));
-var import_ffConnection = require("./ffConnection");
-var import_ffPage = require("./ffPage");
-var import_page = require("../page");
-class FFBrowser extends import_browser.Browser {
-  constructor(parent, connection, options) {
-    super(parent, options);
-    this._version = "";
-    this._userAgent = "";
-    this._connection = connection;
-    this.session = connection.rootSession;
-    this._ffPages = /* @__PURE__ */ new Map();
-    this._contexts = /* @__PURE__ */ new Map();
-    this._connection.on(import_ffConnection.ConnectionEvents.Disconnected, () => this._onDisconnect());
-    this.session.on("Browser.attachedToTarget", this._onAttachedToTarget.bind(this));
-    this.session.on("Browser.detachedFromTarget", this._onDetachedFromTarget.bind(this));
-    this.session.on("Browser.downloadCreated", this._onDownloadCreated.bind(this));
-    this.session.on("Browser.downloadFinished", this._onDownloadFinished.bind(this));
-  }
-  static async connect(parent, transport, options) {
-    const connection = new import_ffConnection.FFConnection(transport, options.protocolLogger, options.browserLogsCollector);
-    const browser = new FFBrowser(parent, connection, options);
-    if (options.__testHookOnConnectToBrowser)
-      await options.__testHookOnConnectToBrowser();
-    let firefoxUserPrefs = options.originalLaunchOptions.firefoxUserPrefs ?? {};
-    if (Object.keys(kBandaidFirefoxUserPrefs).length)
-      firefoxUserPrefs = { ...kBandaidFirefoxUserPrefs, ...firefoxUserPrefs };
-    const promises = [
-      browser.session.send("Browser.enable", {
-        attachToDefaultContext: !!options.persistent,
-        userPrefs: Object.entries(firefoxUserPrefs).map(([name, value]) => ({ name, value }))
-      }),
-      browser._initVersion()
-    ];
-    if (options.persistent) {
-      browser._defaultContext = new FFBrowserContext(browser, void 0, options.persistent);
-      promises.push(browser._defaultContext._initialize());
-    }
-    const proxy = options.originalLaunchOptions.proxyOverride || options.proxy;
-    if (proxy)
-      promises.push(browser.session.send("Browser.setBrowserProxy", toJugglerProxyOptions(proxy)));
-    await Promise.all(promises);
-    return browser;
-  }
-  async _initVersion() {
-    const result = await this.session.send("Browser.getInfo");
-    this._version = result.version.substring(result.version.indexOf("/") + 1);
-    this._userAgent = result.userAgent;
-  }
-  isConnected() {
-    return !this._connection._closed;
-  }
-  async doCreateNewContext(options) {
-    if (options.isMobile)
-      throw new Error("options.isMobile is not supported in Firefox");
-    const { browserContextId } = await this.session.send("Browser.createBrowserContext", { removeOnDetach: true });
-    const context = new FFBrowserContext(this, browserContextId, options);
-    await context._initialize();
-    this._contexts.set(browserContextId, context);
-    return context;
-  }
-  contexts() {
-    return Array.from(this._contexts.values());
-  }
-  version() {
-    return this._version;
-  }
-  userAgent() {
-    return this._userAgent;
-  }
-  _onDetachedFromTarget(payload) {
-    const ffPage = this._ffPages.get(payload.targetId);
-    this._ffPages.delete(payload.targetId);
-    ffPage.didClose();
-  }
-  _onAttachedToTarget(payload) {
-    const { targetId, browserContextId, openerId, type } = payload.targetInfo;
-    (0, import_utils.assert)(type === "page");
-    const context = browserContextId ? this._contexts.get(browserContextId) : this._defaultContext;
-    (0, import_utils.assert)(context, `Unknown context id:${browserContextId}, _defaultContext: ${this._defaultContext}`);
-    const session = this._connection.createSession(payload.sessionId);
-    const opener = openerId ? this._ffPages.get(openerId) : null;
-    const ffPage = new import_ffPage.FFPage(session, context, opener);
-    this._ffPages.set(targetId, ffPage);
-  }
-  _onDownloadCreated(payload) {
-    const ffPage = this._ffPages.get(payload.pageTargetId);
-    if (!ffPage)
-      return;
-    ffPage._page.frameManager.frameAbortedNavigation(payload.frameId, "Download is starting");
-    let originPage = ffPage._page.initializedOrUndefined();
-    if (!originPage) {
-      ffPage._markAsError(new Error("Starting new page download"));
-      if (ffPage._opener)
-        originPage = ffPage._opener._page.initializedOrUndefined();
-    }
-    if (!originPage)
-      return;
-    this._downloadCreated(originPage, payload.uuid, payload.url, payload.suggestedFileName);
-  }
-  _onDownloadFinished(payload) {
-    const error = payload.canceled ? "canceled" : payload.error;
-    this._downloadFinished(payload.uuid, error);
-  }
-  _onDisconnect() {
-    for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
-    this._idToVideo.clear();
-    for (const ffPage of this._ffPages.values())
-      ffPage.didClose();
-    this._ffPages.clear();
-    this._didClose();
-  }
-}
-class FFBrowserContext extends import_browserContext.BrowserContext {
-  constructor(browser, browserContextId, options) {
-    super(browser, options, browserContextId);
-  }
-  async _initialize() {
-    (0, import_utils.assert)(!this._ffPages().length);
-    const browserContextId = this._browserContextId;
-    const promises = [
-      super._initialize(),
-      this._updateInitScripts()
-    ];
-    if (this._options.acceptDownloads !== "internal-browser-default") {
-      promises.push(this._browser.session.send("Browser.setDownloadOptions", {
-        browserContextId,
-        downloadOptions: {
-          behavior: this._options.acceptDownloads === "accept" ? "saveToDisk" : "cancel",
-          downloadsDir: this._browser.options.downloadsPath
-        }
-      }));
-    }
-    promises.push(this.doUpdateDefaultViewport());
-    if (this._options.hasTouch)
-      promises.push(this._browser.session.send("Browser.setTouchOverride", { browserContextId, hasTouch: true }));
-    if (this._options.userAgent)
-      promises.push(this._browser.session.send("Browser.setUserAgentOverride", { browserContextId, userAgent: this._options.userAgent }));
-    if (this._options.bypassCSP)
-      promises.push(this._browser.session.send("Browser.setBypassCSP", { browserContextId, bypassCSP: true }));
-    if (this._options.ignoreHTTPSErrors || this._options.internalIgnoreHTTPSErrors)
-      promises.push(this._browser.session.send("Browser.setIgnoreHTTPSErrors", { browserContextId, ignoreHTTPSErrors: true }));
-    if (this._options.javaScriptEnabled === false)
-      promises.push(this._browser.session.send("Browser.setJavaScriptDisabled", { browserContextId, javaScriptDisabled: true }));
-    if (this._options.locale)
-      promises.push(this._browser.session.send("Browser.setLocaleOverride", { browserContextId, locale: this._options.locale }));
-    if (this._options.timezoneId)
-      promises.push(this._browser.session.send("Browser.setTimezoneOverride", { browserContextId, timezoneId: this._options.timezoneId }));
-    if (this._options.extraHTTPHeaders || this._options.locale)
-      promises.push(this.doUpdateExtraHTTPHeaders());
-    if (this._options.httpCredentials)
-      promises.push(this.setHTTPCredentials(this._options.httpCredentials));
-    if (this._options.geolocation)
-      promises.push(this.setGeolocation(this._options.geolocation));
-    if (this._options.offline)
-      promises.push(this.doUpdateOffline());
-    promises.push(this.doUpdateDefaultEmulatedMedia());
-    if (this._options.recordVideo) {
-      promises.push(this._browser.session.send("Browser.setScreencastOptions", {
-        // validateBrowserContextOptions ensures correct video size.
-        options: {
-          ...this._options.recordVideo.size,
-          quality: 90
-        },
-        browserContextId: this._browserContextId
-      }));
-    }
-    const proxy = this._options.proxyOverride || this._options.proxy;
-    if (proxy) {
-      promises.push(this._browser.session.send("Browser.setContextProxy", {
-        browserContextId: this._browserContextId,
-        ...toJugglerProxyOptions(proxy)
-      }));
-    }
-    await Promise.all(promises);
-  }
-  _ffPages() {
-    return Array.from(this._browser._ffPages.values()).filter((ffPage) => ffPage._browserContext === this);
-  }
-  possiblyUninitializedPages() {
-    return this._ffPages().map((ffPage) => ffPage._page);
-  }
-  async doCreateNewPage() {
-    const { targetId } = await this._browser.session.send("Browser.newPage", {
-      browserContextId: this._browserContextId
-    }).catch((e) => {
-      if (e.message.includes("Failed to override timezone"))
-        throw new Error(`Invalid timezone ID: ${this._options.timezoneId}`);
-      throw e;
-    });
-    return this._browser._ffPages.get(targetId)._page;
-  }
-  async doGetCookies(urls) {
-    const { cookies } = await this._browser.session.send("Browser.getCookies", { browserContextId: this._browserContextId });
-    return network.filterCookies(cookies.map((c) => {
-      const { name, value, domain, path, expires, httpOnly, secure, sameSite } = c;
-      return {
-        name,
-        value,
-        domain,
-        path,
-        expires,
-        httpOnly,
-        secure,
-        sameSite
-      };
-    }), urls);
-  }
-  async addCookies(cookies) {
-    const cc = network.rewriteCookies(cookies).map((c) => {
-      const { name, value, url, domain, path, expires, httpOnly, secure, sameSite } = c;
-      return {
-        name,
-        value,
-        url,
-        domain,
-        path,
-        expires: expires === -1 ? void 0 : expires,
-        httpOnly,
-        secure,
-        sameSite
-      };
-    });
-    await this._browser.session.send("Browser.setCookies", { browserContextId: this._browserContextId, cookies: cc });
-  }
-  async doClearCookies() {
-    await this._browser.session.send("Browser.clearCookies", { browserContextId: this._browserContextId });
-  }
-  async doGrantPermissions(origin, permissions) {
-    const webPermissionToProtocol = /* @__PURE__ */ new Map([
-      ["geolocation", "geo"],
-      ["persistent-storage", "persistent-storage"],
-      ["push", "push"],
-      ["notifications", "desktop-notification"]
-    ]);
-    const filtered = permissions.map((permission) => {
-      const protocolPermission = webPermissionToProtocol.get(permission);
-      if (!protocolPermission)
-        throw new Error("Unknown permission: " + permission);
-      return protocolPermission;
-    });
-    await this._browser.session.send("Browser.grantPermissions", { origin, browserContextId: this._browserContextId, permissions: filtered });
-  }
-  async doClearPermissions() {
-    await this._browser.session.send("Browser.resetPermissions", { browserContextId: this._browserContextId });
-  }
-  async setGeolocation(geolocation) {
-    (0, import_browserContext.verifyGeolocation)(geolocation);
-    this._options.geolocation = geolocation;
-    await this._browser.session.send("Browser.setGeolocationOverride", { browserContextId: this._browserContextId, geolocation: geolocation || null });
-  }
-  async doUpdateExtraHTTPHeaders() {
-    let allHeaders = this._options.extraHTTPHeaders || [];
-    if (this._options.locale)
-      allHeaders = network.mergeHeaders([allHeaders, network.singleHeader("Accept-Language", this._options.locale)]);
-    await this._browser.session.send("Browser.setExtraHTTPHeaders", { browserContextId: this._browserContextId, headers: allHeaders });
-  }
-  async setUserAgent(userAgent) {
-    await this._browser.session.send("Browser.setUserAgentOverride", { browserContextId: this._browserContextId, userAgent: userAgent || null });
-  }
-  async doUpdateOffline() {
-    await this._browser.session.send("Browser.setOnlineOverride", { browserContextId: this._browserContextId, override: this._options.offline ? "offline" : "online" });
-  }
-  async doSetHTTPCredentials(httpCredentials) {
-    this._options.httpCredentials = httpCredentials;
-    let credentials = null;
-    if (httpCredentials) {
-      const { username, password, origin } = httpCredentials;
-      credentials = { username, password, origin };
-    }
-    await this._browser.session.send("Browser.setHTTPCredentials", { browserContextId: this._browserContextId, credentials });
-  }
-  async doAddInitScript(initScript) {
-    await this._updateInitScripts();
-  }
-  async doRemoveInitScripts(initScripts) {
-    await this._updateInitScripts();
-  }
-  async _updateInitScripts() {
-    const bindingScripts = [...this._pageBindings.values()].map((binding) => binding.initScript.source);
-    if (this.bindingsInitScript)
-      bindingScripts.unshift(this.bindingsInitScript.source);
-    const initScripts = this.initScripts.map((script) => script.source);
-    await this._browser.session.send("Browser.setInitScripts", { browserContextId: this._browserContextId, scripts: [...bindingScripts, ...initScripts].map((script) => ({ script })) });
-  }
-  async doUpdateRequestInterception() {
-    await Promise.all([
-      this._browser.session.send("Browser.setRequestInterception", { browserContextId: this._browserContextId, enabled: this.requestInterceptors.length > 0 }),
-      this._browser.session.send("Browser.setCacheDisabled", { browserContextId: this._browserContextId, cacheDisabled: this.requestInterceptors.length > 0 })
-    ]);
-  }
-  async doUpdateDefaultViewport() {
-    if (!this._options.viewport)
-      return;
-    const viewport = {
-      viewportSize: { width: this._options.viewport.width, height: this._options.viewport.height },
-      deviceScaleFactor: this._options.deviceScaleFactor || 1
-    };
-    await this._browser.session.send("Browser.setDefaultViewport", { browserContextId: this._browserContextId, viewport });
-  }
-  async doUpdateDefaultEmulatedMedia() {
-    if (this._options.colorScheme !== "no-override") {
-      await this._browser.session.send("Browser.setColorScheme", {
-        browserContextId: this._browserContextId,
-        colorScheme: this._options.colorScheme !== void 0 ? this._options.colorScheme : "light"
-      });
-    }
-    if (this._options.reducedMotion !== "no-override") {
-      await this._browser.session.send("Browser.setReducedMotion", {
-        browserContextId: this._browserContextId,
-        reducedMotion: this._options.reducedMotion !== void 0 ? this._options.reducedMotion : "no-preference"
-      });
-    }
-    if (this._options.forcedColors !== "no-override") {
-      await this._browser.session.send("Browser.setForcedColors", {
-        browserContextId: this._browserContextId,
-        forcedColors: this._options.forcedColors !== void 0 ? this._options.forcedColors : "none"
-      });
-    }
-    if (this._options.contrast !== "no-override") {
-      await this._browser.session.send("Browser.setContrast", {
-        browserContextId: this._browserContextId,
-        contrast: this._options.contrast !== void 0 ? this._options.contrast : "no-preference"
-      });
-    }
-  }
-  async doExposePlaywrightBinding() {
-    this._browser.session.send("Browser.addBinding", { browserContextId: this._browserContextId, name: import_page.PageBinding.kBindingName, script: "" });
-  }
-  onClosePersistent() {
-  }
-  async clearCache() {
-    await this._browser.session.send("Browser.clearCache");
-  }
-  async doClose(reason) {
-    if (!this._browserContextId) {
-      if (this._options.recordVideo)
-        await Promise.all(this._ffPages().map((ffPage) => ffPage._page.screencast.stopVideoRecording()));
-      await this._browser.close({ reason });
-    } else {
-      await this._browser.session.send("Browser.removeBrowserContext", { browserContextId: this._browserContextId });
-      this._browser._contexts.delete(this._browserContextId);
-    }
-  }
-  async cancelDownload(uuid) {
-    await this._browser.session.send("Browser.cancelDownload", { uuid });
-  }
-}
-function toJugglerProxyOptions(proxy) {
-  const proxyServer = new URL(proxy.server);
-  let port = parseInt(proxyServer.port, 10);
-  let type = "http";
-  if (proxyServer.protocol === "socks5:")
-    type = "socks";
-  else if (proxyServer.protocol === "socks4:")
-    type = "socks4";
-  else if (proxyServer.protocol === "https:")
-    type = "https";
-  if (proxyServer.port === "") {
-    if (proxyServer.protocol === "http:")
-      port = 80;
-    else if (proxyServer.protocol === "https:")
-      port = 443;
-  }
-  return {
-    type,
-    bypass: proxy.bypass ? proxy.bypass.split(",").map((domain) => domain.trim()) : [],
-    host: proxyServer.hostname,
-    port,
-    username: proxy.username,
-    password: proxy.password
-  };
-}
-const kBandaidFirefoxUserPrefs = {};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FFBrowser,
-  FFBrowserContext
-});

data/node/node_modules/playwright-core/lib/server/firefox/ffConnection.js

@@ -1,142 +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 ffConnection_exports = {};
-__export(ffConnection_exports, {
-  ConnectionEvents: () => ConnectionEvents,
-  FFConnection: () => FFConnection,
-  FFSession: () => FFSession,
-  kBrowserCloseMessageId: () => kBrowserCloseMessageId
-});
-module.exports = __toCommonJS(ffConnection_exports);
-var import_events = require("events");
-var import_debugLogger = require("../utils/debugLogger");
-var import_helper = require("../helper");
-var import_protocolError = require("../protocolError");
-const ConnectionEvents = {
-  Disconnected: Symbol("Disconnected")
-};
-const kBrowserCloseMessageId = -9999;
-class FFConnection extends import_events.EventEmitter {
-  constructor(transport, protocolLogger, browserLogsCollector) {
-    super();
-    this.setMaxListeners(0);
-    this._transport = transport;
-    this._protocolLogger = protocolLogger;
-    this._browserLogsCollector = browserLogsCollector;
-    this._lastId = 0;
-    this._sessions = /* @__PURE__ */ new Map();
-    this._closed = false;
-    this.rootSession = new FFSession(this, "", (message) => this._rawSend(message));
-    this._sessions.set("", this.rootSession);
-    this._transport.onmessage = this._onMessage.bind(this);
-    this._transport.onclose = this._onClose.bind(this);
-  }
-  nextMessageId() {
-    return ++this._lastId;
-  }
-  _rawSend(message) {
-    this._protocolLogger("send", message);
-    this._transport.send(message);
-  }
-  async _onMessage(message) {
-    this._protocolLogger("receive", message);
-    if (message.id === kBrowserCloseMessageId)
-      return;
-    const session = this._sessions.get(message.sessionId || "");
-    if (session)
-      session.dispatchMessage(message);
-  }
-  _onClose(reason) {
-    this._closed = true;
-    this._transport.onmessage = void 0;
-    this._transport.onclose = void 0;
-    this._browserDisconnectedLogs = import_helper.helper.formatBrowserLogs(this._browserLogsCollector.recentLogs(), reason);
-    this.rootSession.dispose();
-    Promise.resolve().then(() => this.emit(ConnectionEvents.Disconnected));
-  }
-  close() {
-    if (!this._closed)
-      this._transport.close();
-  }
-  createSession(sessionId) {
-    const session = new FFSession(this, sessionId, (message) => this._rawSend({ ...message, sessionId }));
-    this._sessions.set(sessionId, session);
-    return session;
-  }
-}
-class FFSession extends import_events.EventEmitter {
-  constructor(connection, sessionId, rawSend) {
-    super();
-    this._disposed = false;
-    this._crashed = false;
-    this.setMaxListeners(0);
-    this._callbacks = /* @__PURE__ */ new Map();
-    this._connection = connection;
-    this._sessionId = sessionId;
-    this._rawSend = rawSend;
-  }
-  markAsCrashed() {
-    this._crashed = true;
-  }
-  async send(method, params) {
-    if (this._crashed || this._disposed || this._connection._closed || this._connection._browserDisconnectedLogs)
-      throw new import_protocolError.ProtocolError(this._crashed ? "crashed" : "closed", void 0, this._connection._browserDisconnectedLogs);
-    const id = this._connection.nextMessageId();
-    this._rawSend({ method, params, id });
-    return new Promise((resolve, reject) => {
-      this._callbacks.set(id, { resolve, reject, error: new import_protocolError.ProtocolError("error", method) });
-    });
-  }
-  sendMayFail(method, params) {
-    return this.send(method, params).catch((error) => import_debugLogger.debugLogger.log("error", error));
-  }
-  dispatchMessage(object) {
-    if (object.id) {
-      const callback = this._callbacks.get(object.id);
-      if (callback) {
-        this._callbacks.delete(object.id);
-        if (object.error) {
-          callback.error.setMessage(object.error.message);
-          callback.reject(callback.error);
-        } else {
-          callback.resolve(object.result);
-        }
-      }
-    } else {
-      Promise.resolve().then(() => this.emit(object.method, object.params));
-    }
-  }
-  dispose() {
-    this._disposed = true;
-    this._connection._sessions.delete(this._sessionId);
-    for (const callback of this._callbacks.values()) {
-      callback.error.type = this._crashed ? "crashed" : "closed";
-      callback.error.logs = this._connection._browserDisconnectedLogs;
-      callback.reject(callback.error);
-    }
-    this._callbacks.clear();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ConnectionEvents,
-  FFConnection,
-  FFSession,
-  kBrowserCloseMessageId
-});