rebrowser-playwright-core 1.52.0 → 1.64.100

package/lib/server/dispatchers/dialogDispatcher.js

@@ -1,47 +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 dialogDispatcher_exports = {};
-__export(dialogDispatcher_exports, {
-  DialogDispatcher: () => DialogDispatcher
-});
-module.exports = __toCommonJS(dialogDispatcher_exports);
-var import_dispatcher = require("./dispatcher");
-var import_pageDispatcher = require("./pageDispatcher");
-class DialogDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, dialog) {
-    const page = import_pageDispatcher.PageDispatcher.fromNullable(scope, dialog.page().initializedOrUndefined());
-    super(page || scope, dialog, "Dialog", {
-      page,
-      type: dialog.type(),
-      message: dialog.message(),
-      defaultValue: dialog.defaultValue()
-    });
-    this._type_Dialog = true;
-  }
-  async accept(params) {
-    await this._object.accept(params.promptText);
-  }
-  async dismiss() {
-    await this._object.dismiss();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DialogDispatcher
-});

package/lib/server/dispatchers/dispatcher.js

@@ -1,346 +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 dispatcher_exports = {};
-__export(dispatcher_exports, {
-  Dispatcher: () => Dispatcher,
-  DispatcherConnection: () => DispatcherConnection,
-  RootDispatcher: () => RootDispatcher,
-  dispatcherSymbol: () => dispatcherSymbol,
-  existingDispatcher: () => existingDispatcher,
-  setMaxDispatchersForTest: () => setMaxDispatchersForTest
-});
-module.exports = __toCommonJS(dispatcher_exports);
-var import_events = require("events");
-var import_eventsHelper = require("../utils/eventsHelper");
-var import_validator = require("../../protocol/validator");
-var import_utils = require("../../utils");
-var import_debug = require("../utils/debug");
-var import_errors = require("../errors");
-var import_instrumentation = require("../instrumentation");
-var import_protocolError = require("../protocolError");
-var import_callLog = require("../callLog");
-const dispatcherSymbol = Symbol("dispatcher");
-const metadataValidator = (0, import_validator.createMetadataValidator)();
-function existingDispatcher(object) {
-  return object[dispatcherSymbol];
-}
-let maxDispatchersOverride;
-function setMaxDispatchersForTest(value) {
-  maxDispatchersOverride = value;
-}
-function maxDispatchersForBucket(gcBucket) {
-  return maxDispatchersOverride ?? {
-    "JSHandle": 1e5,
-    "ElementHandle": 1e5
-  }[gcBucket] ?? 1e4;
-}
-class Dispatcher extends import_events.EventEmitter {
-  constructor(parent, object, type, initializer, gcBucket) {
-    super();
-    // Only "isScope" channel owners have registered dispatchers inside.
-    this._dispatchers = /* @__PURE__ */ new Map();
-    this._disposed = false;
-    this._eventListeners = [];
-    this._openScope = new import_utils.LongStandingScope();
-    this._connection = parent instanceof DispatcherConnection ? parent : parent._connection;
-    this._parent = parent instanceof DispatcherConnection ? void 0 : parent;
-    const guid = object.guid;
-    this._guid = guid;
-    this._type = type;
-    this._object = object;
-    this._gcBucket = gcBucket ?? type;
-    object[dispatcherSymbol] = this;
-    this._connection.registerDispatcher(this);
-    if (this._parent) {
-      (0, import_utils.assert)(!this._parent._dispatchers.has(guid));
-      this._parent._dispatchers.set(guid, this);
-    }
-    if (this._parent)
-      this._connection.sendCreate(this._parent, type, guid, initializer);
-    this._connection.maybeDisposeStaleDispatchers(this._gcBucket);
-  }
-  parentScope() {
-    return this._parent;
-  }
-  addObjectListener(eventName, handler) {
-    this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(this._object, eventName, handler));
-  }
-  adopt(child) {
-    if (child._parent === this)
-      return;
-    const oldParent = child._parent;
-    oldParent._dispatchers.delete(child._guid);
-    this._dispatchers.set(child._guid, child);
-    child._parent = this;
-    this._connection.sendAdopt(this, child);
-  }
-  async _handleCommand(callMetadata, method, validParams) {
-    const commandPromise = this[method](validParams, callMetadata);
-    try {
-      return await this._openScope.race(commandPromise);
-    } catch (e) {
-      if (callMetadata.potentiallyClosesScope && (0, import_errors.isTargetClosedError)(e))
-        return await commandPromise;
-      throw e;
-    }
-  }
-  _dispatchEvent(method, params) {
-    if (this._disposed) {
-      if ((0, import_debug.isUnderTest)())
-        throw new Error(`${this._guid} is sending "${String(method)}" event after being disposed`);
-      return;
-    }
-    this._connection.sendEvent(this, method, params);
-  }
-  _dispose(reason) {
-    this._disposeRecursively(new import_errors.TargetClosedError());
-    this._connection.sendDispose(this, reason);
-  }
-  _onDispose() {
-  }
-  _disposeRecursively(error) {
-    (0, import_utils.assert)(!this._disposed, `${this._guid} is disposed more than once`);
-    this._onDispose();
-    this._disposed = true;
-    import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
-    this._parent?._dispatchers.delete(this._guid);
-    const list = this._connection._dispatchersByBucket.get(this._gcBucket);
-    list?.delete(this._guid);
-    this._connection._dispatchers.delete(this._guid);
-    for (const dispatcher of [...this._dispatchers.values()])
-      dispatcher._disposeRecursively(error);
-    this._dispatchers.clear();
-    delete this._object[dispatcherSymbol];
-    this._openScope.close(error);
-  }
-  _debugScopeState() {
-    return {
-      _guid: this._guid,
-      objects: Array.from(this._dispatchers.values()).map((o) => o._debugScopeState())
-    };
-  }
-  async waitForEventInfo() {
-  }
-}
-class RootDispatcher extends Dispatcher {
-  constructor(connection, createPlaywright) {
-    super(connection, { guid: "" }, "Root", {});
-    this.createPlaywright = createPlaywright;
-    this._initialized = false;
-  }
-  async initialize(params) {
-    (0, import_utils.assert)(this.createPlaywright);
-    (0, import_utils.assert)(!this._initialized);
-    this._initialized = true;
-    return {
-      playwright: await this.createPlaywright(this, params)
-    };
-  }
-}
-class DispatcherConnection {
-  constructor(isLocal) {
-    this._dispatchers = /* @__PURE__ */ new Map();
-    this._dispatchersByBucket = /* @__PURE__ */ new Map();
-    this.onmessage = (message) => {
-    };
-    this._waitOperations = /* @__PURE__ */ new Map();
-    this._isLocal = !!isLocal;
-  }
-  sendEvent(dispatcher, event, params) {
-    const validator = (0, import_validator.findValidator)(dispatcher._type, event, "Event");
-    params = validator(params, "", this._validatorToWireContext());
-    this.onmessage({ guid: dispatcher._guid, method: event, params });
-  }
-  sendCreate(parent, type, guid, initializer) {
-    const validator = (0, import_validator.findValidator)(type, "", "Initializer");
-    initializer = validator(initializer, "", this._validatorToWireContext());
-    this.onmessage({ guid: parent._guid, method: "__create__", params: { type, initializer, guid } });
-  }
-  sendAdopt(parent, dispatcher) {
-    this.onmessage({ guid: parent._guid, method: "__adopt__", params: { guid: dispatcher._guid } });
-  }
-  sendDispose(dispatcher, reason) {
-    this.onmessage({ guid: dispatcher._guid, method: "__dispose__", params: { reason } });
-  }
-  _validatorToWireContext() {
-    return {
-      tChannelImpl: this._tChannelImplToWire.bind(this),
-      binary: this._isLocal ? "buffer" : "toBase64",
-      isUnderTest: import_debug.isUnderTest
-    };
-  }
-  _validatorFromWireContext() {
-    return {
-      tChannelImpl: this._tChannelImplFromWire.bind(this),
-      binary: this._isLocal ? "buffer" : "fromBase64",
-      isUnderTest: import_debug.isUnderTest
-    };
-  }
-  _tChannelImplFromWire(names, arg, path, context) {
-    if (arg && typeof arg === "object" && typeof arg.guid === "string") {
-      const guid = arg.guid;
-      const dispatcher = this._dispatchers.get(guid);
-      if (!dispatcher)
-        throw new import_validator.ValidationError(`${path}: no object with guid ${guid}`);
-      if (names !== "*" && !names.includes(dispatcher._type))
-        throw new import_validator.ValidationError(`${path}: object with guid ${guid} has type ${dispatcher._type}, expected ${names.toString()}`);
-      return dispatcher;
-    }
-    throw new import_validator.ValidationError(`${path}: expected guid for ${names.toString()}`);
-  }
-  _tChannelImplToWire(names, arg, path, context) {
-    if (arg instanceof Dispatcher) {
-      if (names !== "*" && !names.includes(arg._type))
-        throw new import_validator.ValidationError(`${path}: dispatcher with guid ${arg._guid} has type ${arg._type}, expected ${names.toString()}`);
-      return { guid: arg._guid };
-    }
-    throw new import_validator.ValidationError(`${path}: expected dispatcher ${names.toString()}`);
-  }
-  registerDispatcher(dispatcher) {
-    (0, import_utils.assert)(!this._dispatchers.has(dispatcher._guid));
-    this._dispatchers.set(dispatcher._guid, dispatcher);
-    let list = this._dispatchersByBucket.get(dispatcher._gcBucket);
-    if (!list) {
-      list = /* @__PURE__ */ new Set();
-      this._dispatchersByBucket.set(dispatcher._gcBucket, list);
-    }
-    list.add(dispatcher._guid);
-  }
-  maybeDisposeStaleDispatchers(gcBucket) {
-    const maxDispatchers = maxDispatchersForBucket(gcBucket);
-    const list = this._dispatchersByBucket.get(gcBucket);
-    if (!list || list.size <= maxDispatchers)
-      return;
-    const dispatchersArray = [...list];
-    const disposeCount = maxDispatchers / 10 | 0;
-    this._dispatchersByBucket.set(gcBucket, new Set(dispatchersArray.slice(disposeCount)));
-    for (let i = 0; i < disposeCount; ++i) {
-      const d = this._dispatchers.get(dispatchersArray[i]);
-      if (!d)
-        continue;
-      d._dispose("gc");
-    }
-  }
-  async dispatch(message) {
-    const { id, guid, method, params, metadata } = message;
-    const dispatcher = this._dispatchers.get(guid);
-    if (!dispatcher) {
-      this.onmessage({ id, error: (0, import_errors.serializeError)(new import_errors.TargetClosedError()) });
-      return;
-    }
-    let validParams;
-    let validMetadata;
-    try {
-      const validator = (0, import_validator.findValidator)(dispatcher._type, method, "Params");
-      const validatorContext = this._validatorFromWireContext();
-      validParams = validator(params, "", validatorContext);
-      validMetadata = metadataValidator(metadata, "", validatorContext);
-      if (typeof dispatcher[method] !== "function")
-        throw new Error(`Mismatching dispatcher: "${dispatcher._type}" does not implement "${method}"`);
-    } catch (e) {
-      this.onmessage({ id, error: (0, import_errors.serializeError)(e) });
-      return;
-    }
-    const sdkObject = dispatcher._object instanceof import_instrumentation.SdkObject ? dispatcher._object : void 0;
-    const callMetadata = {
-      id: `call@${id}`,
-      location: validMetadata.location,
-      apiName: validMetadata.apiName,
-      internal: validMetadata.internal,
-      stepId: validMetadata.stepId,
-      objectId: sdkObject?.guid,
-      pageId: sdkObject?.attribution?.page?.guid,
-      frameId: sdkObject?.attribution?.frame?.guid,
-      startTime: (0, import_utils.monotonicTime)(),
-      endTime: 0,
-      type: dispatcher._type,
-      method,
-      params: params || {},
-      log: []
-    };
-    if (sdkObject && params?.info?.waitId) {
-      const info = params.info;
-      switch (info.phase) {
-        case "before": {
-          this._waitOperations.set(info.waitId, callMetadata);
-          await sdkObject.instrumentation.onBeforeCall(sdkObject, callMetadata);
-          this.onmessage({ id });
-          return;
-        }
-        case "log": {
-          const originalMetadata = this._waitOperations.get(info.waitId);
-          originalMetadata.log.push(info.message);
-          sdkObject.instrumentation.onCallLog(sdkObject, originalMetadata, "api", info.message);
-          this.onmessage({ id });
-          return;
-        }
-        case "after": {
-          const originalMetadata = this._waitOperations.get(info.waitId);
-          originalMetadata.endTime = (0, import_utils.monotonicTime)();
-          originalMetadata.error = info.error ? { error: { name: "Error", message: info.error } } : void 0;
-          this._waitOperations.delete(info.waitId);
-          await sdkObject.instrumentation.onAfterCall(sdkObject, originalMetadata);
-          this.onmessage({ id });
-          return;
-        }
-      }
-    }
-    await sdkObject?.instrumentation.onBeforeCall(sdkObject, callMetadata);
-    const response = { id };
-    try {
-      const result = await dispatcher._handleCommand(callMetadata, method, validParams);
-      const validator = (0, import_validator.findValidator)(dispatcher._type, method, "Result");
-      response.result = validator(result, "", this._validatorToWireContext());
-      callMetadata.result = result;
-    } catch (e) {
-      if ((0, import_errors.isTargetClosedError)(e) && sdkObject) {
-        const reason = closeReason(sdkObject);
-        if (reason)
-          (0, import_utils.rewriteErrorMessage)(e, reason);
-      } else if ((0, import_protocolError.isProtocolError)(e)) {
-        if (e.type === "closed") {
-          const reason = sdkObject ? closeReason(sdkObject) : void 0;
-          e = new import_errors.TargetClosedError(reason, e.browserLogMessage());
-        } else if (e.type === "crashed") {
-          (0, import_utils.rewriteErrorMessage)(e, "Target crashed " + e.browserLogMessage());
-        }
-      }
-      response.error = (0, import_errors.serializeError)(e);
-      callMetadata.error = response.error;
-    } finally {
-      callMetadata.endTime = (0, import_utils.monotonicTime)();
-      await sdkObject?.instrumentation.onAfterCall(sdkObject, callMetadata);
-    }
-    if (response.error)
-      response.log = (0, import_callLog.compressCallLog)(callMetadata.log);
-    this.onmessage(response);
-  }
-}
-function closeReason(sdkObject) {
-  return sdkObject.attribution.page?._closeReason || sdkObject.attribution.context?._closeReason || sdkObject.attribution.browser?._closeReason;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Dispatcher,
-  DispatcherConnection,
-  RootDispatcher,
-  dispatcherSymbol,
-  existingDispatcher,
-  setMaxDispatchersForTest
-});

package/lib/server/dispatchers/electronDispatcher.js

@@ -1,90 +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 electronDispatcher_exports = {};
-__export(electronDispatcher_exports, {
-  ElectronApplicationDispatcher: () => ElectronApplicationDispatcher,
-  ElectronDispatcher: () => ElectronDispatcher
-});
-module.exports = __toCommonJS(electronDispatcher_exports);
-var import_browserContextDispatcher = require("./browserContextDispatcher");
-var import_dispatcher = require("./dispatcher");
-var import_elementHandlerDispatcher = require("./elementHandlerDispatcher");
-var import_jsHandleDispatcher = require("./jsHandleDispatcher");
-var import_electron = require("../electron/electron");
-class ElectronDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, electron) {
-    super(scope, electron, "Electron", {});
-    this._type_Electron = true;
-  }
-  async launch(params) {
-    const electronApplication = await this._object.launch(params);
-    return { electronApplication: new ElectronApplicationDispatcher(this, electronApplication) };
-  }
-}
-class ElectronApplicationDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, electronApplication) {
-    super(scope, electronApplication, "ElectronApplication", {
-      context: new import_browserContextDispatcher.BrowserContextDispatcher(scope, electronApplication.context())
-    });
-    this._type_EventTarget = true;
-    this._type_ElectronApplication = true;
-    this._subscriptions = /* @__PURE__ */ new Set();
-    this.addObjectListener(import_electron.ElectronApplication.Events.Close, () => {
-      this._dispatchEvent("close");
-      this._dispose();
-    });
-    this.addObjectListener(import_electron.ElectronApplication.Events.Console, (message) => {
-      if (!this._subscriptions.has("console"))
-        return;
-      this._dispatchEvent("console", {
-        type: message.type(),
-        text: message.text(),
-        args: message.args().map((a) => import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, a)),
-        location: message.location()
-      });
-    });
-  }
-  async browserWindow(params) {
-    const handle = await this._object.browserWindow(params.page.page());
-    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, handle) };
-  }
-  async evaluateExpression(params) {
-    const handle = await this._object._nodeElectronHandlePromise;
-    return { value: (0, import_jsHandleDispatcher.serializeResult)(await handle.evaluateExpression(params.expression, { isFunction: params.isFunction }, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
-  }
-  async evaluateExpressionHandle(params) {
-    const handle = await this._object._nodeElectronHandlePromise;
-    const result = await handle.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, (0, import_jsHandleDispatcher.parseArgument)(params.arg));
-    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, result) };
-  }
-  async updateSubscription(params) {
-    if (params.enabled)
-      this._subscriptions.add(params.event);
-    else
-      this._subscriptions.delete(params.event);
-  }
-  async close() {
-    await this._object.close();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ElectronApplicationDispatcher,
-  ElectronDispatcher
-});

package/lib/server/dispatchers/elementHandlerDispatcher.js

@@ -1,191 +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 elementHandlerDispatcher_exports = {};
-__export(elementHandlerDispatcher_exports, {
-  ElementHandleDispatcher: () => ElementHandleDispatcher
-});
-module.exports = __toCommonJS(elementHandlerDispatcher_exports);
-var import_browserContextDispatcher = require("./browserContextDispatcher");
-var import_dispatcher = require("./dispatcher");
-var import_frameDispatcher = require("./frameDispatcher");
-var import_jsHandleDispatcher = require("./jsHandleDispatcher");
-var import_pageDispatcher = require("./pageDispatcher");
-class ElementHandleDispatcher extends import_jsHandleDispatcher.JSHandleDispatcher {
-  constructor(scope, elementHandle) {
-    super(scope, elementHandle);
-    this._type_ElementHandle = true;
-    this._elementHandle = elementHandle;
-  }
-  static from(scope, handle) {
-    return (0, import_dispatcher.existingDispatcher)(handle) || new ElementHandleDispatcher(scope, handle);
-  }
-  static fromNullable(scope, handle) {
-    if (!handle)
-      return void 0;
-    return (0, import_dispatcher.existingDispatcher)(handle) || new ElementHandleDispatcher(scope, handle);
-  }
-  static fromJSHandle(scope, handle) {
-    const result = (0, import_dispatcher.existingDispatcher)(handle);
-    if (result)
-      return result;
-    return handle.asElement() ? new ElementHandleDispatcher(scope, handle.asElement()) : new import_jsHandleDispatcher.JSHandleDispatcher(scope, handle);
-  }
-  async ownerFrame(params, metadata) {
-    const frame = await this._elementHandle.ownerFrame();
-    return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
-  }
-  async contentFrame(params, metadata) {
-    const frame = await this._elementHandle.contentFrame();
-    return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
-  }
-  async generateLocatorString(params, metadata) {
-    return { value: await this._elementHandle.generateLocatorString() };
-  }
-  async getAttribute(params, metadata) {
-    const value = await this._elementHandle.getAttribute(metadata, params.name);
-    return { value: value === null ? void 0 : value };
-  }
-  async inputValue(params, metadata) {
-    const value = await this._elementHandle.inputValue(metadata);
-    return { value };
-  }
-  async textContent(params, metadata) {
-    const value = await this._elementHandle.textContent(metadata);
-    return { value: value === null ? void 0 : value };
-  }
-  async innerText(params, metadata) {
-    return { value: await this._elementHandle.innerText(metadata) };
-  }
-  async innerHTML(params, metadata) {
-    return { value: await this._elementHandle.innerHTML(metadata) };
-  }
-  async isChecked(params, metadata) {
-    return { value: await this._elementHandle.isChecked(metadata) };
-  }
-  async isDisabled(params, metadata) {
-    return { value: await this._elementHandle.isDisabled(metadata) };
-  }
-  async isEditable(params, metadata) {
-    return { value: await this._elementHandle.isEditable(metadata) };
-  }
-  async isEnabled(params, metadata) {
-    return { value: await this._elementHandle.isEnabled(metadata) };
-  }
-  async isHidden(params, metadata) {
-    return { value: await this._elementHandle.isHidden(metadata) };
-  }
-  async isVisible(params, metadata) {
-    return { value: await this._elementHandle.isVisible(metadata) };
-  }
-  async dispatchEvent(params, metadata) {
-    await this._elementHandle.dispatchEvent(metadata, params.type, (0, import_jsHandleDispatcher.parseArgument)(params.eventInit));
-  }
-  async scrollIntoViewIfNeeded(params, metadata) {
-    await this._elementHandle.scrollIntoViewIfNeeded(metadata, params);
-  }
-  async hover(params, metadata) {
-    return await this._elementHandle.hover(metadata, params);
-  }
-  async click(params, metadata) {
-    return await this._elementHandle.click(metadata, params);
-  }
-  async dblclick(params, metadata) {
-    return await this._elementHandle.dblclick(metadata, params);
-  }
-  async tap(params, metadata) {
-    return await this._elementHandle.tap(metadata, params);
-  }
-  async selectOption(params, metadata) {
-    const elements = (params.elements || []).map((e) => e._elementHandle);
-    return { values: await this._elementHandle.selectOption(metadata, elements, params.options || [], params) };
-  }
-  async fill(params, metadata) {
-    return await this._elementHandle.fill(metadata, params.value, params);
-  }
-  async selectText(params, metadata) {
-    await this._elementHandle.selectText(metadata, params);
-  }
-  async setInputFiles(params, metadata) {
-    return await this._elementHandle.setInputFiles(metadata, params);
-  }
-  async focus(params, metadata) {
-    await this._elementHandle.focus(metadata);
-  }
-  async type(params, metadata) {
-    return await this._elementHandle.type(metadata, params.text, params);
-  }
-  async press(params, metadata) {
-    return await this._elementHandle.press(metadata, params.key, params);
-  }
-  async check(params, metadata) {
-    return await this._elementHandle.check(metadata, params);
-  }
-  async uncheck(params, metadata) {
-    return await this._elementHandle.uncheck(metadata, params);
-  }
-  async boundingBox(params, metadata) {
-    const value = await this._elementHandle.boundingBox();
-    return { value: value || void 0 };
-  }
-  async screenshot(params, metadata) {
-    const mask = (params.mask || []).map(({ frame, selector }) => ({
-      frame: frame._object,
-      selector
-    }));
-    return { binary: await this._elementHandle.screenshot(metadata, { ...params, mask }) };
-  }
-  async querySelector(params, metadata) {
-    const handle = await this._elementHandle.querySelector(params.selector, params);
-    return { element: ElementHandleDispatcher.fromNullable(this.parentScope(), handle) };
-  }
-  async querySelectorAll(params, metadata) {
-    const elements = await this._elementHandle.querySelectorAll(params.selector);
-    return { elements: elements.map((e) => ElementHandleDispatcher.from(this.parentScope(), e)) };
-  }
-  async evalOnSelector(params, metadata) {
-    return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._elementHandle.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
-  }
-  async evalOnSelectorAll(params, metadata) {
-    return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._elementHandle.evalOnSelectorAll(params.selector, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
-  }
-  async waitForElementState(params, metadata) {
-    await this._elementHandle.waitForElementState(metadata, params.state, params);
-  }
-  async waitForSelector(params, metadata) {
-    return { element: ElementHandleDispatcher.fromNullable(this.parentScope(), await this._elementHandle.waitForSelector(metadata, params.selector, params)) };
-  }
-  _browserContextDispatcher() {
-    const scope = this.parentScope();
-    if (scope instanceof import_browserContextDispatcher.BrowserContextDispatcher)
-      return scope;
-    if (scope instanceof import_pageDispatcher.PageDispatcher)
-      return scope.parentScope();
-    if (scope instanceof import_pageDispatcher.WorkerDispatcher || scope instanceof import_frameDispatcher.FrameDispatcher) {
-      const parentScope = scope.parentScope();
-      if (parentScope instanceof import_browserContextDispatcher.BrowserContextDispatcher)
-        return parentScope;
-      return parentScope.parentScope();
-    }
-    throw new Error("ElementHandle belongs to unexpected scope");
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ElementHandleDispatcher
-});