rebrowser-playwright-core 1.52.0 → 1.64.100

package/lib/server/dispatchers/browserContextDispatcher.js

@@ -1,328 +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 browserContextDispatcher_exports = {};
-__export(browserContextDispatcher_exports, {
-  BrowserContextDispatcher: () => BrowserContextDispatcher
-});
-module.exports = __toCommonJS(browserContextDispatcher_exports);
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_browserContext = require("../browserContext");
-var import_artifactDispatcher = require("./artifactDispatcher");
-var import_cdpSessionDispatcher = require("./cdpSessionDispatcher");
-var import_dialogDispatcher = require("./dialogDispatcher");
-var import_dispatcher = require("./dispatcher");
-var import_elementHandlerDispatcher = require("./elementHandlerDispatcher");
-var import_networkDispatchers = require("./networkDispatchers");
-var import_pageDispatcher = require("./pageDispatcher");
-var import_crBrowser = require("../chromium/crBrowser");
-var import_errors = require("../errors");
-var import_recorder = require("../recorder");
-var import_tracingDispatcher = require("./tracingDispatcher");
-var import_webSocketRouteDispatcher = require("./webSocketRouteDispatcher");
-var import_writableStreamDispatcher = require("./writableStreamDispatcher");
-var import_crypto = require("../utils/crypto");
-var import_urlMatch = require("../../utils/isomorphic/urlMatch");
-var import_recorderApp = require("../recorder/recorderApp");
-class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
-  constructor(parentScope, context) {
-    const requestContext = import_networkDispatchers.APIRequestContextDispatcher.from(parentScope, context.fetchRequest);
-    const tracing = import_tracingDispatcher.TracingDispatcher.from(parentScope, context.tracing);
-    super(parentScope, context, "BrowserContext", {
-      isChromium: context._browser.options.isChromium,
-      isLocalBrowserOnServer: context._browser._isCollocatedWithServer,
-      requestContext,
-      tracing
-    });
-    this._type_EventTarget = true;
-    this._type_BrowserContext = true;
-    this._subscriptions = /* @__PURE__ */ new Set();
-    this._webSocketInterceptionPatterns = [];
-    this.adopt(requestContext);
-    this.adopt(tracing);
-    this._context = context;
-    const onVideo = (artifact) => {
-      const artifactDispatcher = import_artifactDispatcher.ArtifactDispatcher.from(parentScope, artifact);
-      this._dispatchEvent("video", { artifact: artifactDispatcher });
-    };
-    this.addObjectListener(import_browserContext.BrowserContext.Events.VideoStarted, onVideo);
-    for (const video of context._browser._idToVideo.values()) {
-      if (video.context === context)
-        onVideo(video.artifact);
-    }
-    for (const page of context.pages())
-      this._dispatchEvent("page", { page: import_pageDispatcher.PageDispatcher.from(this, page) });
-    this.addObjectListener(import_browserContext.BrowserContext.Events.Page, (page) => {
-      this._dispatchEvent("page", { page: import_pageDispatcher.PageDispatcher.from(this, page) });
-    });
-    this.addObjectListener(import_browserContext.BrowserContext.Events.Close, () => {
-      this._dispatchEvent("close");
-      this._dispose();
-    });
-    this.addObjectListener(import_browserContext.BrowserContext.Events.PageError, (error, page) => {
-      this._dispatchEvent("pageError", { error: (0, import_errors.serializeError)(error), page: import_pageDispatcher.PageDispatcher.from(this, page) });
-    });
-    this.addObjectListener(import_browserContext.BrowserContext.Events.Console, (message) => {
-      const page = message.page();
-      if (this._shouldDispatchEvent(page, "console")) {
-        const pageDispatcher = import_pageDispatcher.PageDispatcher.from(this, page);
-        this._dispatchEvent("console", {
-          page: pageDispatcher,
-          type: message.type(),
-          text: message.text(),
-          args: message.args().map((a) => import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(pageDispatcher, a)),
-          location: message.location()
-        });
-      }
-    });
-    this.addObjectListener(import_browserContext.BrowserContext.Events.Dialog, (dialog) => {
-      if (this._shouldDispatchEvent(dialog.page(), "dialog"))
-        this._dispatchEvent("dialog", { dialog: new import_dialogDispatcher.DialogDispatcher(this, dialog) });
-      else
-        dialog.close().catch(() => {
-        });
-    });
-    if (context._browser.options.name === "chromium") {
-      for (const page of context.backgroundPages())
-        this._dispatchEvent("backgroundPage", { page: import_pageDispatcher.PageDispatcher.from(this, page) });
-      this.addObjectListener(import_crBrowser.CRBrowserContext.CREvents.BackgroundPage, (page) => this._dispatchEvent("backgroundPage", { page: import_pageDispatcher.PageDispatcher.from(this, page) }));
-      for (const serviceWorker of context.serviceWorkers())
-        this._dispatchEvent("serviceWorker", { worker: new import_pageDispatcher.WorkerDispatcher(this, serviceWorker) });
-      this.addObjectListener(import_crBrowser.CRBrowserContext.CREvents.ServiceWorker, (serviceWorker) => this._dispatchEvent("serviceWorker", { worker: new import_pageDispatcher.WorkerDispatcher(this, serviceWorker) }));
-    }
-    this.addObjectListener(import_browserContext.BrowserContext.Events.Request, (request) => {
-      const redirectFromDispatcher = request.redirectedFrom() && (0, import_dispatcher.existingDispatcher)(request.redirectedFrom());
-      if (!redirectFromDispatcher && !this._shouldDispatchNetworkEvent(request, "request") && !request.isNavigationRequest())
-        return;
-      const requestDispatcher = import_networkDispatchers.RequestDispatcher.from(this, request);
-      this._dispatchEvent("request", {
-        request: requestDispatcher,
-        page: import_pageDispatcher.PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined())
-      });
-    });
-    this.addObjectListener(import_browserContext.BrowserContext.Events.Response, (response) => {
-      const requestDispatcher = (0, import_dispatcher.existingDispatcher)(response.request());
-      if (!requestDispatcher && !this._shouldDispatchNetworkEvent(response.request(), "response"))
-        return;
-      this._dispatchEvent("response", {
-        response: import_networkDispatchers.ResponseDispatcher.from(this, response),
-        page: import_pageDispatcher.PageDispatcher.fromNullable(this, response.frame()?._page.initializedOrUndefined())
-      });
-    });
-    this.addObjectListener(import_browserContext.BrowserContext.Events.RequestFailed, (request) => {
-      const requestDispatcher = (0, import_dispatcher.existingDispatcher)(request);
-      if (!requestDispatcher && !this._shouldDispatchNetworkEvent(request, "requestFailed"))
-        return;
-      this._dispatchEvent("requestFailed", {
-        request: import_networkDispatchers.RequestDispatcher.from(this, request),
-        failureText: request._failureText || void 0,
-        responseEndTiming: request._responseEndTiming,
-        page: import_pageDispatcher.PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined())
-      });
-    });
-    this.addObjectListener(import_browserContext.BrowserContext.Events.RequestFinished, ({ request, response }) => {
-      const requestDispatcher = (0, import_dispatcher.existingDispatcher)(request);
-      if (!requestDispatcher && !this._shouldDispatchNetworkEvent(request, "requestFinished"))
-        return;
-      this._dispatchEvent("requestFinished", {
-        request: import_networkDispatchers.RequestDispatcher.from(this, request),
-        response: import_networkDispatchers.ResponseDispatcher.fromNullable(this, response),
-        responseEndTiming: request._responseEndTiming,
-        page: import_pageDispatcher.PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined())
-      });
-    });
-  }
-  _shouldDispatchNetworkEvent(request, event) {
-    return this._shouldDispatchEvent(request.frame()?._page?.initializedOrUndefined(), event);
-  }
-  _shouldDispatchEvent(page, event) {
-    if (this._subscriptions.has(event))
-      return true;
-    const pageDispatcher = page ? (0, import_dispatcher.existingDispatcher)(page) : void 0;
-    if (pageDispatcher?._subscriptions.has(event))
-      return true;
-    return false;
-  }
-  async createTempFiles(params) {
-    const dir = this._context._browser.options.artifactsDir;
-    const tmpDir = import_path.default.join(dir, "upload-" + (0, import_crypto.createGuid)());
-    const tempDirWithRootName = params.rootDirName ? import_path.default.join(tmpDir, import_path.default.basename(params.rootDirName)) : tmpDir;
-    await import_fs.default.promises.mkdir(tempDirWithRootName, { recursive: true });
-    this._context._tempDirs.push(tmpDir);
-    return {
-      rootDir: params.rootDirName ? new import_writableStreamDispatcher.WritableStreamDispatcher(this, tempDirWithRootName) : void 0,
-      writableStreams: await Promise.all(params.items.map(async (item) => {
-        await import_fs.default.promises.mkdir(import_path.default.dirname(import_path.default.join(tempDirWithRootName, item.name)), { recursive: true });
-        const file = import_fs.default.createWriteStream(import_path.default.join(tempDirWithRootName, item.name));
-        return new import_writableStreamDispatcher.WritableStreamDispatcher(this, file, item.lastModifiedMs);
-      }))
-    };
-  }
-  async setDefaultNavigationTimeoutNoReply(params) {
-    this._context.setDefaultNavigationTimeout(params.timeout);
-  }
-  async setDefaultTimeoutNoReply(params) {
-    this._context.setDefaultTimeout(params.timeout);
-  }
-  async exposeBinding(params) {
-    await this._context.exposeBinding(params.name, !!params.needsHandle, (source, ...args) => {
-      if (this._disposed)
-        return;
-      const pageDispatcher = import_pageDispatcher.PageDispatcher.from(this, source.page);
-      const binding = new import_pageDispatcher.BindingCallDispatcher(pageDispatcher, params.name, !!params.needsHandle, source, args);
-      this._dispatchEvent("bindingCall", { binding });
-      return binding.promise();
-    });
-  }
-  async newPage(params, metadata) {
-    return { page: import_pageDispatcher.PageDispatcher.from(this, await this._context.newPage(metadata)) };
-  }
-  async cookies(params) {
-    return { cookies: await this._context.cookies(params.urls) };
-  }
-  async addCookies(params) {
-    await this._context.addCookies(params.cookies);
-  }
-  async clearCookies(params) {
-    const nameRe = params.nameRegexSource !== void 0 && params.nameRegexFlags !== void 0 ? new RegExp(params.nameRegexSource, params.nameRegexFlags) : void 0;
-    const domainRe = params.domainRegexSource !== void 0 && params.domainRegexFlags !== void 0 ? new RegExp(params.domainRegexSource, params.domainRegexFlags) : void 0;
-    const pathRe = params.pathRegexSource !== void 0 && params.pathRegexFlags !== void 0 ? new RegExp(params.pathRegexSource, params.pathRegexFlags) : void 0;
-    await this._context.clearCookies({
-      name: nameRe || params.name,
-      domain: domainRe || params.domain,
-      path: pathRe || params.path
-    });
-  }
-  async grantPermissions(params) {
-    await this._context.grantPermissions(params.permissions, params.origin);
-  }
-  async clearPermissions() {
-    await this._context.clearPermissions();
-  }
-  async setGeolocation(params) {
-    await this._context.setGeolocation(params.geolocation);
-  }
-  async setExtraHTTPHeaders(params) {
-    await this._context.setExtraHTTPHeaders(params.headers);
-  }
-  async setOffline(params) {
-    await this._context.setOffline(params.offline);
-  }
-  async setHTTPCredentials(params) {
-    await this._context.setHTTPCredentials(params.httpCredentials);
-  }
-  async addInitScript(params) {
-    await this._context.addInitScript(params.source);
-  }
-  async setNetworkInterceptionPatterns(params) {
-    if (!params.patterns.length) {
-      await this._context.setRequestInterceptor(void 0);
-      return;
-    }
-    const urlMatchers = params.patterns.map((pattern) => pattern.regexSource ? new RegExp(pattern.regexSource, pattern.regexFlags) : pattern.glob);
-    await this._context.setRequestInterceptor((route, request) => {
-      const matchesSome = urlMatchers.some((urlMatch) => (0, import_urlMatch.urlMatches)(this._context._options.baseURL, request.url(), urlMatch));
-      if (!matchesSome)
-        return false;
-      this._dispatchEvent("route", { route: import_networkDispatchers.RouteDispatcher.from(import_networkDispatchers.RequestDispatcher.from(this, request), route) });
-      return true;
-    });
-  }
-  async setWebSocketInterceptionPatterns(params, metadata) {
-    this._webSocketInterceptionPatterns = params.patterns;
-    if (params.patterns.length)
-      await import_webSocketRouteDispatcher.WebSocketRouteDispatcher.installIfNeeded(this._context);
-  }
-  async storageState(params, metadata) {
-    return await this._context.storageState(params.indexedDB);
-  }
-  async close(params, metadata) {
-    metadata.potentiallyClosesScope = true;
-    await this._context.close(params);
-  }
-  async enableRecorder(params) {
-    await import_recorder.Recorder.show(this._context, import_recorderApp.RecorderApp.factory(this._context), params);
-  }
-  async pause(params, metadata) {
-  }
-  async newCDPSession(params) {
-    if (!this._object._browser.options.isChromium)
-      throw new Error(`CDP session is only available in Chromium`);
-    if (!params.page && !params.frame || params.page && params.frame)
-      throw new Error(`CDP session must be initiated with either Page or Frame, not none or both`);
-    const crBrowserContext = this._object;
-    return { session: new import_cdpSessionDispatcher.CDPSessionDispatcher(this, await crBrowserContext.newCDPSession((params.page ? params.page : params.frame)._object)) };
-  }
-  async harStart(params) {
-    const harId = await this._context._harStart(params.page ? params.page._object : null, params.options);
-    return { harId };
-  }
-  async harExport(params) {
-    const artifact = await this._context._harExport(params.harId);
-    if (!artifact)
-      throw new Error("No HAR artifact. Ensure record.harPath is set.");
-    return { artifact: import_artifactDispatcher.ArtifactDispatcher.from(this, artifact) };
-  }
-  async clockFastForward(params, metadata) {
-    await this._context.clock.fastForward(params.ticksString ?? params.ticksNumber ?? 0);
-  }
-  async clockInstall(params, metadata) {
-    await this._context.clock.install(params.timeString ?? params.timeNumber ?? void 0);
-  }
-  async clockPauseAt(params, metadata) {
-    await this._context.clock.pauseAt(params.timeString ?? params.timeNumber ?? 0);
-  }
-  async clockResume(params, metadata) {
-    await this._context.clock.resume();
-  }
-  async clockRunFor(params, metadata) {
-    await this._context.clock.runFor(params.ticksString ?? params.ticksNumber ?? 0);
-  }
-  async clockSetFixedTime(params, metadata) {
-    await this._context.clock.setFixedTime(params.timeString ?? params.timeNumber ?? 0);
-  }
-  async clockSetSystemTime(params, metadata) {
-    await this._context.clock.setSystemTime(params.timeString ?? params.timeNumber ?? 0);
-  }
-  async updateSubscription(params) {
-    if (params.enabled)
-      this._subscriptions.add(params.event);
-    else
-      this._subscriptions.delete(params.event);
-  }
-  _onDispose() {
-    if (!this._context.isClosingOrClosed())
-      this._context.setRequestInterceptor(void 0).catch(() => {
-      });
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BrowserContextDispatcher
-});

package/lib/server/dispatchers/browserDispatcher.js

@@ -1,151 +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 browserDispatcher_exports = {};
-__export(browserDispatcher_exports, {
-  BrowserDispatcher: () => BrowserDispatcher,
-  ConnectedBrowserDispatcher: () => ConnectedBrowserDispatcher
-});
-module.exports = __toCommonJS(browserDispatcher_exports);
-var import_browser = require("../browser");
-var import_browserContextDispatcher = require("./browserContextDispatcher");
-var import_cdpSessionDispatcher = require("./cdpSessionDispatcher");
-var import_dispatcher = require("./dispatcher");
-var import_dispatcher2 = require("./dispatcher");
-var import_browserContext = require("../browserContext");
-var import_selectors = require("../selectors");
-var import_artifactDispatcher = require("./artifactDispatcher");
-class BrowserDispatcher extends import_dispatcher2.Dispatcher {
-  constructor(scope, browser) {
-    super(scope, browser, "Browser", { version: browser.version(), name: browser.options.name });
-    this._type_Browser = true;
-    this.addObjectListener(import_browser.Browser.Events.Disconnected, () => this._didClose());
-  }
-  _didClose() {
-    this._dispatchEvent("close");
-    this._dispose();
-  }
-  async newContext(params, metadata) {
-    const context = await this._object.newContext(metadata, params);
-    return { context: new import_browserContextDispatcher.BrowserContextDispatcher(this, context) };
-  }
-  async newContextForReuse(params, metadata) {
-    return await newContextForReuse(this._object, this, params, null, metadata);
-  }
-  async stopPendingOperations(params, metadata) {
-    await this._object.stopPendingOperations(params.reason);
-  }
-  async close(params, metadata) {
-    metadata.potentiallyClosesScope = true;
-    await this._object.close(params);
-  }
-  async killForTests(_, metadata) {
-    metadata.potentiallyClosesScope = true;
-    await this._object.killForTests();
-  }
-  async defaultUserAgentForTest() {
-    return { userAgent: this._object.userAgent() };
-  }
-  async newBrowserCDPSession() {
-    if (!this._object.options.isChromium)
-      throw new Error(`CDP session is only available in Chromium`);
-    const crBrowser = this._object;
-    return { session: new import_cdpSessionDispatcher.CDPSessionDispatcher(this, await crBrowser.newBrowserCDPSession()) };
-  }
-  async startTracing(params) {
-    if (!this._object.options.isChromium)
-      throw new Error(`Tracing is only available in Chromium`);
-    const crBrowser = this._object;
-    await crBrowser.startTracing(params.page ? params.page._object : void 0, params);
-  }
-  async stopTracing() {
-    if (!this._object.options.isChromium)
-      throw new Error(`Tracing is only available in Chromium`);
-    const crBrowser = this._object;
-    return { artifact: import_artifactDispatcher.ArtifactDispatcher.from(this, await crBrowser.stopTracing()) };
-  }
-}
-class ConnectedBrowserDispatcher extends import_dispatcher2.Dispatcher {
-  constructor(scope, browser) {
-    super(scope, browser, "Browser", { version: browser.version(), name: browser.options.name });
-    this._type_Browser = true;
-    this._contexts = /* @__PURE__ */ new Set();
-    this.selectors = new import_selectors.Selectors();
-  }
-  async newContext(params, metadata) {
-    if (params.recordVideo)
-      params.recordVideo.dir = this._object.options.artifactsDir;
-    const context = await this._object.newContext(metadata, params);
-    this._contexts.add(context);
-    context.setSelectors(this.selectors);
-    context.on(import_browserContext.BrowserContext.Events.Close, () => this._contexts.delete(context));
-    return { context: new import_browserContextDispatcher.BrowserContextDispatcher(this, context) };
-  }
-  async newContextForReuse(params, metadata) {
-    return await newContextForReuse(this._object, this, params, this.selectors, metadata);
-  }
-  async stopPendingOperations(params, metadata) {
-    await this._object.stopPendingOperations(params.reason);
-  }
-  async close() {
-  }
-  async killForTests() {
-  }
-  async defaultUserAgentForTest() {
-    throw new Error("Client should not send us Browser.defaultUserAgentForTest");
-  }
-  async newBrowserCDPSession() {
-    if (!this._object.options.isChromium)
-      throw new Error(`CDP session is only available in Chromium`);
-    const crBrowser = this._object;
-    return { session: new import_cdpSessionDispatcher.CDPSessionDispatcher(this, await crBrowser.newBrowserCDPSession()) };
-  }
-  async startTracing(params) {
-    if (!this._object.options.isChromium)
-      throw new Error(`Tracing is only available in Chromium`);
-    const crBrowser = this._object;
-    await crBrowser.startTracing(params.page ? params.page._object : void 0, params);
-  }
-  async stopTracing() {
-    if (!this._object.options.isChromium)
-      throw new Error(`Tracing is only available in Chromium`);
-    const crBrowser = this._object;
-    return { artifact: import_artifactDispatcher.ArtifactDispatcher.from(this, await crBrowser.stopTracing()) };
-  }
-  async cleanupContexts() {
-    await Promise.all(Array.from(this._contexts).map((context) => context.close({ reason: "Global context cleanup (connection terminated)" })));
-  }
-}
-async function newContextForReuse(browser, scope, params, selectors, metadata) {
-  const { context, needsReset } = await browser.newContextForReuse(params, metadata);
-  if (needsReset) {
-    const oldContextDispatcher = (0, import_dispatcher.existingDispatcher)(context);
-    if (oldContextDispatcher)
-      oldContextDispatcher._dispose();
-    await context.resetForReuse(metadata, params);
-  }
-  if (selectors)
-    context.setSelectors(selectors);
-  const contextDispatcher = new import_browserContextDispatcher.BrowserContextDispatcher(scope, context);
-  return { context: contextDispatcher };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BrowserDispatcher,
-  ConnectedBrowserDispatcher
-});

package/lib/server/dispatchers/browserTypeDispatcher.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 browserTypeDispatcher_exports = {};
-__export(browserTypeDispatcher_exports, {
-  BrowserTypeDispatcher: () => BrowserTypeDispatcher
-});
-module.exports = __toCommonJS(browserTypeDispatcher_exports);
-var import_browserContextDispatcher = require("./browserContextDispatcher");
-var import_browserDispatcher = require("./browserDispatcher");
-var import_dispatcher = require("./dispatcher");
-class BrowserTypeDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, browserType) {
-    super(scope, browserType, "BrowserType", {
-      executablePath: browserType.executablePath(),
-      name: browserType.name()
-    });
-    this._type_BrowserType = true;
-  }
-  async launch(params, metadata) {
-    const browser = await this._object.launch(metadata, params);
-    return { browser: new import_browserDispatcher.BrowserDispatcher(this, browser) };
-  }
-  async launchPersistentContext(params, metadata) {
-    const browserContext = await this._object.launchPersistentContext(metadata, params.userDataDir, params);
-    return { context: new import_browserContextDispatcher.BrowserContextDispatcher(this, browserContext) };
-  }
-  async connectOverCDP(params, metadata) {
-    const browser = await this._object.connectOverCDP(metadata, params.endpointURL, params);
-    const browserDispatcher = new import_browserDispatcher.BrowserDispatcher(this, browser);
-    return {
-      browser: browserDispatcher,
-      defaultContext: browser._defaultContext ? new import_browserContextDispatcher.BrowserContextDispatcher(browserDispatcher, browser._defaultContext) : void 0
-    };
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BrowserTypeDispatcher
-});

package/lib/server/dispatchers/cdpSessionDispatcher.js

@@ -1,44 +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 cdpSessionDispatcher_exports = {};
-__export(cdpSessionDispatcher_exports, {
-  CDPSessionDispatcher: () => CDPSessionDispatcher
-});
-module.exports = __toCommonJS(cdpSessionDispatcher_exports);
-var import_dispatcher = require("./dispatcher");
-var import_crConnection = require("../chromium/crConnection");
-class CDPSessionDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, cdpSession) {
-    super(scope, cdpSession, "CDPSession", {});
-    this._type_CDPSession = true;
-    this.addObjectListener(import_crConnection.CDPSession.Events.Event, ({ method, params }) => this._dispatchEvent("event", { method, params }));
-    this.addObjectListener(import_crConnection.CDPSession.Events.Closed, () => this._dispose());
-  }
-  async send(params) {
-    return { result: await this._object.send(params.method, params.params) };
-  }
-  async detach(_, metadata) {
-    metadata.potentiallyClosesScope = true;
-    await this._object.detach();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CDPSessionDispatcher
-});

package/lib/server/dispatchers/debugControllerDispatcher.js

@@ -1,87 +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 debugControllerDispatcher_exports = {};
-__export(debugControllerDispatcher_exports, {
-  DebugControllerDispatcher: () => DebugControllerDispatcher
-});
-module.exports = __toCommonJS(debugControllerDispatcher_exports);
-var import_utils = require("../../utils");
-var import_debugController = require("../debugController");
-var import_dispatcher = require("./dispatcher");
-class DebugControllerDispatcher extends import_dispatcher.Dispatcher {
-  constructor(connection, debugController) {
-    super(connection, debugController, "DebugController", {});
-    this._type_DebugController = true;
-    this._listeners = [
-      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.StateChanged, (params) => {
-        this._dispatchEvent("stateChanged", params);
-      }),
-      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.InspectRequested, ({ selector, locator, ariaSnapshot }) => {
-        this._dispatchEvent("inspectRequested", { selector, locator, ariaSnapshot });
-      }),
-      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.SourceChanged, ({ text, header, footer, actions }) => {
-        this._dispatchEvent("sourceChanged", { text, header, footer, actions });
-      }),
-      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.Paused, ({ paused }) => {
-        this._dispatchEvent("paused", { paused });
-      }),
-      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.SetModeRequested, ({ mode }) => {
-        this._dispatchEvent("setModeRequested", { mode });
-      })
-    ];
-  }
-  async initialize(params) {
-    this._object.initialize(params.codegenId, params.sdkLanguage);
-  }
-  async setReportStateChanged(params) {
-    this._object.setReportStateChanged(params.enabled);
-  }
-  async resetForReuse() {
-    await this._object.resetForReuse();
-  }
-  async navigate(params) {
-    await this._object.navigate(params.url);
-  }
-  async setRecorderMode(params) {
-    await this._object.setRecorderMode(params);
-  }
-  async highlight(params) {
-    await this._object.highlight(params);
-  }
-  async hideHighlight() {
-    await this._object.hideHighlight();
-  }
-  async resume() {
-    await this._object.resume();
-  }
-  async kill() {
-    await this._object.kill();
-  }
-  async closeAllBrowsers() {
-    await this._object.closeAllBrowsers();
-  }
-  _onDispose() {
-    import_utils.eventsHelper.removeEventListeners(this._listeners);
-    this._object.dispose();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DebugControllerDispatcher
-});