rebrowser-playwright-core 1.52.0 → 1.64.1

package/lib/server/dispatchers/networkDispatchers.js

@@ -1,204 +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 networkDispatchers_exports = {};
-__export(networkDispatchers_exports, {
-  APIRequestContextDispatcher: () => APIRequestContextDispatcher,
-  RequestDispatcher: () => RequestDispatcher,
-  ResponseDispatcher: () => ResponseDispatcher,
-  RouteDispatcher: () => RouteDispatcher,
-  WebSocketDispatcher: () => WebSocketDispatcher
-});
-module.exports = __toCommonJS(networkDispatchers_exports);
-var import_network = require("../network");
-var import_dispatcher = require("./dispatcher");
-var import_frameDispatcher = require("./frameDispatcher");
-var import_pageDispatcher = require("./pageDispatcher");
-var import_tracingDispatcher = require("./tracingDispatcher");
-class RequestDispatcher extends import_dispatcher.Dispatcher {
-  static from(scope, request) {
-    const result = (0, import_dispatcher.existingDispatcher)(request);
-    return result || new RequestDispatcher(scope, request);
-  }
-  static fromNullable(scope, request) {
-    return request ? RequestDispatcher.from(scope, request) : void 0;
-  }
-  constructor(scope, request) {
-    const postData = request.postDataBuffer();
-    const frame = request.frame();
-    const page = request.frame()?._page;
-    const pageDispatcher = page ? (0, import_dispatcher.existingDispatcher)(page) : null;
-    const frameDispatcher = frame ? import_frameDispatcher.FrameDispatcher.from(scope, frame) : null;
-    super(pageDispatcher || frameDispatcher || scope, request, "Request", {
-      frame: import_frameDispatcher.FrameDispatcher.fromNullable(scope, request.frame()),
-      serviceWorker: import_pageDispatcher.WorkerDispatcher.fromNullable(scope, request.serviceWorker()),
-      url: request.url(),
-      resourceType: request.resourceType(),
-      method: request.method(),
-      postData: postData === null ? void 0 : postData,
-      headers: request.headers(),
-      isNavigationRequest: request.isNavigationRequest(),
-      redirectedFrom: RequestDispatcher.fromNullable(scope, request.redirectedFrom())
-    });
-    this._type_Request = true;
-    this._browserContextDispatcher = scope;
-  }
-  async rawRequestHeaders(params) {
-    return { headers: await this._object.rawRequestHeaders() };
-  }
-  async response() {
-    return { response: ResponseDispatcher.fromNullable(this._browserContextDispatcher, await this._object.response()) };
-  }
-}
-class ResponseDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, response) {
-    super(scope, response, "Response", {
-      // TODO: responses in popups can point to non-reported requests.
-      request: scope,
-      url: response.url(),
-      status: response.status(),
-      statusText: response.statusText(),
-      headers: response.headers(),
-      timing: response.timing(),
-      fromServiceWorker: response.fromServiceWorker()
-    });
-    this._type_Response = true;
-  }
-  static from(scope, response) {
-    const result = (0, import_dispatcher.existingDispatcher)(response);
-    const requestDispatcher = RequestDispatcher.from(scope, response.request());
-    return result || new ResponseDispatcher(requestDispatcher, response);
-  }
-  static fromNullable(scope, response) {
-    return response ? ResponseDispatcher.from(scope, response) : void 0;
-  }
-  async body() {
-    return { binary: await this._object.body() };
-  }
-  async securityDetails() {
-    return { value: await this._object.securityDetails() || void 0 };
-  }
-  async serverAddr() {
-    return { value: await this._object.serverAddr() || void 0 };
-  }
-  async rawResponseHeaders(params) {
-    return { headers: await this._object.rawResponseHeaders() };
-  }
-  async sizes(params) {
-    return { sizes: await this._object.sizes() };
-  }
-}
-class RouteDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, route) {
-    super(scope, route, "Route", {
-      // Context route can point to a non-reported request, so we send the request in the initializer.
-      request: scope
-    });
-    this._type_Route = true;
-  }
-  static from(scope, route) {
-    const result = (0, import_dispatcher.existingDispatcher)(route);
-    return result || new RouteDispatcher(scope, route);
-  }
-  async continue(params, metadata) {
-    await this._object.continue({
-      url: params.url,
-      method: params.method,
-      headers: params.headers,
-      postData: params.postData,
-      isFallback: params.isFallback
-    });
-  }
-  async fulfill(params, metadata) {
-    await this._object.fulfill(params);
-  }
-  async abort(params, metadata) {
-    await this._object.abort(params.errorCode || "failed");
-  }
-  async redirectNavigationRequest(params) {
-    await this._object.redirectNavigationRequest(params.url);
-  }
-}
-class WebSocketDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, webSocket) {
-    super(scope, webSocket, "WebSocket", {
-      url: webSocket.url()
-    });
-    this._type_EventTarget = true;
-    this._type_WebSocket = true;
-    this.addObjectListener(import_network.WebSocket.Events.FrameSent, (event) => this._dispatchEvent("frameSent", event));
-    this.addObjectListener(import_network.WebSocket.Events.FrameReceived, (event) => this._dispatchEvent("frameReceived", event));
-    this.addObjectListener(import_network.WebSocket.Events.SocketError, (error) => this._dispatchEvent("socketError", { error }));
-    this.addObjectListener(import_network.WebSocket.Events.Close, () => this._dispatchEvent("close", {}));
-  }
-}
-class APIRequestContextDispatcher extends import_dispatcher.Dispatcher {
-  constructor(parentScope, request) {
-    const tracing = import_tracingDispatcher.TracingDispatcher.from(parentScope, request.tracing());
-    super(parentScope, request, "APIRequestContext", {
-      tracing
-    });
-    this._type_APIRequestContext = true;
-    this.adopt(tracing);
-  }
-  static from(scope, request) {
-    const result = (0, import_dispatcher.existingDispatcher)(request);
-    return result || new APIRequestContextDispatcher(scope, request);
-  }
-  static fromNullable(scope, request) {
-    return request ? APIRequestContextDispatcher.from(scope, request) : void 0;
-  }
-  async storageState(params) {
-    return this._object.storageState(params.indexedDB);
-  }
-  async dispose(params, metadata) {
-    metadata.potentiallyClosesScope = true;
-    await this._object.dispose(params);
-    this._dispose();
-  }
-  async fetch(params, metadata) {
-    const fetchResponse = await this._object.fetch(params, metadata);
-    return {
-      response: {
-        url: fetchResponse.url,
-        status: fetchResponse.status,
-        statusText: fetchResponse.statusText,
-        headers: fetchResponse.headers,
-        fetchUid: fetchResponse.fetchUid
-      }
-    };
-  }
-  async fetchResponseBody(params) {
-    return { binary: this._object.fetchResponses.get(params.fetchUid) };
-  }
-  async fetchLog(params) {
-    const log = this._object.fetchLog.get(params.fetchUid) || [];
-    return { log };
-  }
-  async disposeAPIResponse(params) {
-    this._object.disposeResponse(params.fetchUid);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  APIRequestContextDispatcher,
-  RequestDispatcher,
-  ResponseDispatcher,
-  RouteDispatcher,
-  WebSocketDispatcher
-});

package/lib/server/dispatchers/pageDispatcher.js

@@ -1,328 +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 pageDispatcher_exports = {};
-__export(pageDispatcher_exports, {
-  BindingCallDispatcher: () => BindingCallDispatcher,
-  PageDispatcher: () => PageDispatcher,
-  WorkerDispatcher: () => WorkerDispatcher
-});
-module.exports = __toCommonJS(pageDispatcher_exports);
-var import_page = require("../page");
-var import_dispatcher = require("./dispatcher");
-var import_errors = require("../errors");
-var import_artifactDispatcher = require("./artifactDispatcher");
-var import_elementHandlerDispatcher = require("./elementHandlerDispatcher");
-var import_frameDispatcher = require("./frameDispatcher");
-var import_jsHandleDispatcher = require("./jsHandleDispatcher");
-var import_networkDispatchers = require("./networkDispatchers");
-var import_networkDispatchers2 = require("./networkDispatchers");
-var import_networkDispatchers3 = require("./networkDispatchers");
-var import_webSocketRouteDispatcher = require("./webSocketRouteDispatcher");
-var import_crypto = require("../utils/crypto");
-var import_urlMatch = require("../../utils/isomorphic/urlMatch");
-class PageDispatcher extends import_dispatcher.Dispatcher {
-  constructor(parentScope, page) {
-    const mainFrame = import_frameDispatcher.FrameDispatcher.from(parentScope, page.mainFrame());
-    super(parentScope, page, "Page", {
-      mainFrame,
-      viewportSize: page.viewportSize() || void 0,
-      isClosed: page.isClosed(),
-      opener: PageDispatcher.fromNullable(parentScope, page.opener())
-    });
-    this._type_EventTarget = true;
-    this._type_Page = true;
-    this._subscriptions = /* @__PURE__ */ new Set();
-    this._webSocketInterceptionPatterns = [];
-    this.adopt(mainFrame);
-    this._page = page;
-    this.addObjectListener(import_page.Page.Events.Close, () => {
-      this._dispatchEvent("close");
-      this._dispose();
-    });
-    this.addObjectListener(import_page.Page.Events.Crash, () => this._dispatchEvent("crash"));
-    this.addObjectListener(import_page.Page.Events.Download, (download) => {
-      this._dispatchEvent("download", { url: download.url, suggestedFilename: download.suggestedFilename(), artifact: import_artifactDispatcher.ArtifactDispatcher.from(parentScope, download.artifact) });
-    });
-    this.addObjectListener(import_page.Page.Events.FileChooser, (fileChooser) => this._dispatchEvent("fileChooser", {
-      element: import_elementHandlerDispatcher.ElementHandleDispatcher.from(mainFrame, fileChooser.element()),
-      isMultiple: fileChooser.isMultiple()
-    }));
-    this.addObjectListener(import_page.Page.Events.FrameAttached, (frame) => this._onFrameAttached(frame));
-    this.addObjectListener(import_page.Page.Events.FrameDetached, (frame) => this._onFrameDetached(frame));
-    this.addObjectListener(import_page.Page.Events.LocatorHandlerTriggered, (uid) => this._dispatchEvent("locatorHandlerTriggered", { uid }));
-    this.addObjectListener(import_page.Page.Events.WebSocket, (webSocket) => this._dispatchEvent("webSocket", { webSocket: new import_networkDispatchers3.WebSocketDispatcher(this, webSocket) }));
-    this.addObjectListener(import_page.Page.Events.Worker, (worker) => this._dispatchEvent("worker", { worker: new WorkerDispatcher(this, worker) }));
-    this.addObjectListener(import_page.Page.Events.Video, (artifact) => this._dispatchEvent("video", { artifact: import_artifactDispatcher.ArtifactDispatcher.from(parentScope, artifact) }));
-    if (page._video)
-      this._dispatchEvent("video", { artifact: import_artifactDispatcher.ArtifactDispatcher.from(this.parentScope(), page._video) });
-    const frames = page._frameManager.frames();
-    for (let i = 1; i < frames.length; i++)
-      this._onFrameAttached(frames[i]);
-  }
-  static from(parentScope, page) {
-    return PageDispatcher.fromNullable(parentScope, page);
-  }
-  static fromNullable(parentScope, page) {
-    if (!page)
-      return void 0;
-    const result = (0, import_dispatcher.existingDispatcher)(page);
-    return result || new PageDispatcher(parentScope, page);
-  }
-  page() {
-    return this._page;
-  }
-  async setDefaultNavigationTimeoutNoReply(params, metadata) {
-    this._page.setDefaultNavigationTimeout(params.timeout);
-  }
-  async setDefaultTimeoutNoReply(params, metadata) {
-    this._page.setDefaultTimeout(params.timeout);
-  }
-  async exposeBinding(params, metadata) {
-    await this._page.exposeBinding(params.name, !!params.needsHandle, (source, ...args) => {
-      if (this._disposed)
-        return;
-      const binding = new BindingCallDispatcher(this, params.name, !!params.needsHandle, source, args);
-      this._dispatchEvent("bindingCall", { binding });
-      return binding.promise();
-    });
-  }
-  async setExtraHTTPHeaders(params, metadata) {
-    await this._page.setExtraHTTPHeaders(params.headers);
-  }
-  async reload(params, metadata) {
-    return { response: import_networkDispatchers2.ResponseDispatcher.fromNullable(this.parentScope(), await this._page.reload(metadata, params)) };
-  }
-  async goBack(params, metadata) {
-    return { response: import_networkDispatchers2.ResponseDispatcher.fromNullable(this.parentScope(), await this._page.goBack(metadata, params)) };
-  }
-  async goForward(params, metadata) {
-    return { response: import_networkDispatchers2.ResponseDispatcher.fromNullable(this.parentScope(), await this._page.goForward(metadata, params)) };
-  }
-  async requestGC(params, metadata) {
-    await this._page.requestGC();
-  }
-  async registerLocatorHandler(params, metadata) {
-    const uid = this._page.registerLocatorHandler(params.selector, params.noWaitAfter);
-    return { uid };
-  }
-  async resolveLocatorHandlerNoReply(params, metadata) {
-    this._page.resolveLocatorHandler(params.uid, params.remove);
-  }
-  async unregisterLocatorHandler(params, metadata) {
-    this._page.unregisterLocatorHandler(params.uid);
-  }
-  async emulateMedia(params, metadata) {
-    await this._page.emulateMedia({
-      media: params.media,
-      colorScheme: params.colorScheme,
-      reducedMotion: params.reducedMotion,
-      forcedColors: params.forcedColors,
-      contrast: params.contrast
-    });
-  }
-  async setViewportSize(params, metadata) {
-    await this._page.setViewportSize(params.viewportSize);
-  }
-  async addInitScript(params, metadata) {
-    await this._page.addInitScript(params.source);
-  }
-  async setNetworkInterceptionPatterns(params, metadata) {
-    if (!params.patterns.length) {
-      await this._page.setClientRequestInterceptor(void 0);
-      return;
-    }
-    const urlMatchers = params.patterns.map((pattern) => pattern.regexSource ? new RegExp(pattern.regexSource, pattern.regexFlags) : pattern.glob);
-    await this._page.setClientRequestInterceptor((route, request) => {
-      const matchesSome = urlMatchers.some((urlMatch) => (0, import_urlMatch.urlMatches)(this._page._browserContext._options.baseURL, request.url(), urlMatch));
-      if (!matchesSome)
-        return false;
-      this._dispatchEvent("route", { route: import_networkDispatchers3.RouteDispatcher.from(import_networkDispatchers.RequestDispatcher.from(this.parentScope(), request), route) });
-      return true;
-    });
-  }
-  async setWebSocketInterceptionPatterns(params, metadata) {
-    this._webSocketInterceptionPatterns = params.patterns;
-    if (params.patterns.length)
-      await import_webSocketRouteDispatcher.WebSocketRouteDispatcher.installIfNeeded(this._page);
-  }
-  async expectScreenshot(params, metadata) {
-    const mask = (params.mask || []).map(({ frame, selector }) => ({
-      frame: frame._object,
-      selector
-    }));
-    const locator = params.locator ? {
-      frame: params.locator.frame._object,
-      selector: params.locator.selector
-    } : void 0;
-    return await this._page.expectScreenshot(metadata, {
-      ...params,
-      locator,
-      mask
-    });
-  }
-  async screenshot(params, metadata) {
-    const mask = (params.mask || []).map(({ frame, selector }) => ({
-      frame: frame._object,
-      selector
-    }));
-    return { binary: await this._page.screenshot(metadata, { ...params, mask }) };
-  }
-  async close(params, metadata) {
-    if (!params.runBeforeUnload)
-      metadata.potentiallyClosesScope = true;
-    await this._page.close(metadata, params);
-  }
-  async updateSubscription(params) {
-    if (params.event === "fileChooser")
-      await this._page.setFileChooserIntercepted(params.enabled);
-    if (params.enabled)
-      this._subscriptions.add(params.event);
-    else
-      this._subscriptions.delete(params.event);
-  }
-  async keyboardDown(params, metadata) {
-    await this._page.keyboard.down(params.key);
-  }
-  async keyboardUp(params, metadata) {
-    await this._page.keyboard.up(params.key);
-  }
-  async keyboardInsertText(params, metadata) {
-    await this._page.keyboard.insertText(params.text);
-  }
-  async keyboardType(params, metadata) {
-    await this._page.keyboard.type(params.text, params);
-  }
-  async keyboardPress(params, metadata) {
-    await this._page.keyboard.press(params.key, params);
-  }
-  async mouseMove(params, metadata) {
-    await this._page.mouse.move(params.x, params.y, params, metadata);
-  }
-  async mouseDown(params, metadata) {
-    await this._page.mouse.down(params, metadata);
-  }
-  async mouseUp(params, metadata) {
-    await this._page.mouse.up(params, metadata);
-  }
-  async mouseClick(params, metadata) {
-    await this._page.mouse.click(params.x, params.y, params, metadata);
-  }
-  async mouseWheel(params, metadata) {
-    await this._page.mouse.wheel(params.deltaX, params.deltaY);
-  }
-  async touchscreenTap(params, metadata) {
-    await this._page.touchscreen.tap(params.x, params.y, metadata);
-  }
-  async accessibilitySnapshot(params, metadata) {
-    const rootAXNode = await this._page.accessibility.snapshot({
-      interestingOnly: params.interestingOnly,
-      root: params.root ? params.root._elementHandle : void 0
-    });
-    return { rootAXNode: rootAXNode || void 0 };
-  }
-  async pdf(params, metadata) {
-    if (!this._page.pdf)
-      throw new Error("PDF generation is only supported for Headless Chromium");
-    const buffer = await this._page.pdf(params);
-    return { pdf: buffer };
-  }
-  async bringToFront(params, metadata) {
-    await this._page.bringToFront();
-  }
-  async startJSCoverage(params, metadata) {
-    const coverage = this._page.coverage;
-    await coverage.startJSCoverage(params);
-  }
-  async stopJSCoverage(params, metadata) {
-    const coverage = this._page.coverage;
-    return await coverage.stopJSCoverage();
-  }
-  async startCSSCoverage(params, metadata) {
-    const coverage = this._page.coverage;
-    await coverage.startCSSCoverage(params);
-  }
-  async stopCSSCoverage(params, metadata) {
-    const coverage = this._page.coverage;
-    return await coverage.stopCSSCoverage();
-  }
-  _onFrameAttached(frame) {
-    this._dispatchEvent("frameAttached", { frame: import_frameDispatcher.FrameDispatcher.from(this.parentScope(), frame) });
-  }
-  _onFrameDetached(frame) {
-    this._dispatchEvent("frameDetached", { frame: import_frameDispatcher.FrameDispatcher.from(this.parentScope(), frame) });
-  }
-  _onDispose() {
-    if (!this._page.isClosedOrClosingOrCrashed())
-      this._page.setClientRequestInterceptor(void 0).catch(() => {
-      });
-  }
-}
-class WorkerDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, worker) {
-    super(scope, worker, "Worker", {
-      url: worker.url()
-    });
-    this._type_Worker = true;
-    this.addObjectListener(import_page.Worker.Events.Close, () => this._dispatchEvent("close"));
-  }
-  static fromNullable(scope, worker) {
-    if (!worker)
-      return void 0;
-    const result = (0, import_dispatcher.existingDispatcher)(worker);
-    return result || new WorkerDispatcher(scope, worker);
-  }
-  async evaluateExpression(params, metadata) {
-    return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._object.evaluateExpression(params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
-  }
-  async evaluateExpressionHandle(params, metadata) {
-    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, await this._object.evaluateExpressionHandle(params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
-  }
-}
-class BindingCallDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, name, needsHandle, source, args) {
-    super(scope, { guid: "bindingCall@" + (0, import_crypto.createGuid)() }, "BindingCall", {
-      frame: import_frameDispatcher.FrameDispatcher.from(scope.parentScope(), source.frame),
-      name,
-      args: needsHandle ? void 0 : args.map(import_jsHandleDispatcher.serializeResult),
-      handle: needsHandle ? import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(scope, args[0]) : void 0
-    });
-    this._type_BindingCall = true;
-    this._promise = new Promise((resolve, reject) => {
-      this._resolve = resolve;
-      this._reject = reject;
-    });
-  }
-  promise() {
-    return this._promise;
-  }
-  async resolve(params, metadata) {
-    this._resolve((0, import_jsHandleDispatcher.parseArgument)(params.result));
-    this._dispose();
-  }
-  async reject(params, metadata) {
-    this._reject((0, import_errors.parseError)(params.error));
-    this._dispose();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BindingCallDispatcher,
-  PageDispatcher,
-  WorkerDispatcher
-});

package/lib/server/dispatchers/playwrightDispatcher.js

@@ -1,100 +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 playwrightDispatcher_exports = {};
-__export(playwrightDispatcher_exports, {
-  PlaywrightDispatcher: () => PlaywrightDispatcher
-});
-module.exports = __toCommonJS(playwrightDispatcher_exports);
-var import_socksProxy = require("../utils/socksProxy");
-var import_fetch = require("../fetch");
-var import_androidDispatcher = require("./androidDispatcher");
-var import_androidDispatcher2 = require("./androidDispatcher");
-var import_browserDispatcher = require("./browserDispatcher");
-var import_browserTypeDispatcher = require("./browserTypeDispatcher");
-var import_dispatcher = require("./dispatcher");
-var import_electronDispatcher = require("./electronDispatcher");
-var import_localUtilsDispatcher = require("./localUtilsDispatcher");
-var import_networkDispatchers = require("./networkDispatchers");
-var import_selectorsDispatcher = require("./selectorsDispatcher");
-var import_crypto = require("../utils/crypto");
-var import_eventsHelper = require("../utils/eventsHelper");
-class PlaywrightDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, playwright, socksProxy, preLaunchedBrowser, prelaunchedAndroidDevice) {
-    const browserDispatcher = preLaunchedBrowser ? new import_browserDispatcher.ConnectedBrowserDispatcher(scope, preLaunchedBrowser) : void 0;
-    const android = new import_androidDispatcher.AndroidDispatcher(scope, playwright.android);
-    const prelaunchedAndroidDeviceDispatcher = prelaunchedAndroidDevice ? new import_androidDispatcher2.AndroidDeviceDispatcher(android, prelaunchedAndroidDevice) : void 0;
-    super(scope, playwright, "Playwright", {
-      chromium: new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.chromium),
-      firefox: new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.firefox),
-      webkit: new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.webkit),
-      bidiChromium: new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.bidiChromium),
-      bidiFirefox: new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.bidiFirefox),
-      android,
-      electron: new import_electronDispatcher.ElectronDispatcher(scope, playwright.electron),
-      utils: playwright.options.isServer ? void 0 : new import_localUtilsDispatcher.LocalUtilsDispatcher(scope, playwright),
-      selectors: new import_selectorsDispatcher.SelectorsDispatcher(scope, browserDispatcher?.selectors || playwright.selectors),
-      preLaunchedBrowser: browserDispatcher,
-      preConnectedAndroidDevice: prelaunchedAndroidDeviceDispatcher,
-      socksSupport: socksProxy ? new SocksSupportDispatcher(scope, socksProxy) : void 0
-    });
-    this._type_Playwright = true;
-    this._browserDispatcher = browserDispatcher;
-  }
-  async newRequest(params) {
-    const request = new import_fetch.GlobalAPIRequestContext(this._object, params);
-    return { request: import_networkDispatchers.APIRequestContextDispatcher.from(this.parentScope(), request) };
-  }
-  async cleanup() {
-    await this._browserDispatcher?.cleanupContexts();
-  }
-}
-class SocksSupportDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, socksProxy) {
-    super(scope, { guid: "socksSupport@" + (0, import_crypto.createGuid)() }, "SocksSupport", {});
-    this._type_SocksSupport = true;
-    this._socksProxy = socksProxy;
-    this._socksListeners = [
-      import_eventsHelper.eventsHelper.addEventListener(socksProxy, import_socksProxy.SocksProxy.Events.SocksRequested, (payload) => this._dispatchEvent("socksRequested", payload)),
-      import_eventsHelper.eventsHelper.addEventListener(socksProxy, import_socksProxy.SocksProxy.Events.SocksData, (payload) => this._dispatchEvent("socksData", payload)),
-      import_eventsHelper.eventsHelper.addEventListener(socksProxy, import_socksProxy.SocksProxy.Events.SocksClosed, (payload) => this._dispatchEvent("socksClosed", payload))
-    ];
-  }
-  async socksConnected(params) {
-    this._socksProxy?.socketConnected(params);
-  }
-  async socksFailed(params) {
-    this._socksProxy?.socketFailed(params);
-  }
-  async socksData(params) {
-    this._socksProxy?.sendSocketData(params);
-  }
-  async socksError(params) {
-    this._socksProxy?.sendSocketError(params);
-  }
-  async socksEnd(params) {
-    this._socksProxy?.sendSocketEnd(params);
-  }
-  _onDispose() {
-    import_eventsHelper.eventsHelper.removeEventListeners(this._socksListeners);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PlaywrightDispatcher
-});

package/lib/server/dispatchers/selectorsDispatcher.js

@@ -1,40 +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 selectorsDispatcher_exports = {};
-__export(selectorsDispatcher_exports, {
-  SelectorsDispatcher: () => SelectorsDispatcher
-});
-module.exports = __toCommonJS(selectorsDispatcher_exports);
-var import_dispatcher = require("./dispatcher");
-class SelectorsDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, selectors) {
-    super(scope, selectors, "Selectors", {});
-    this._type_Selectors = true;
-  }
-  async register(params) {
-    await this._object.register(params.name, params.source, params.contentScript);
-  }
-  async setTestIdAttributeName(params) {
-    this._object.setTestIdAttributeName(params.testIdAttributeName);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  SelectorsDispatcher
-});