phantomwright-driver-core 1.58.0

package/lib/utils/isomorphic/oldUtilityScriptSerializers.js

@@ -0,0 +1,248 @@
+"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 oldUtilityScriptSerializers_exports = {};
+__export(oldUtilityScriptSerializers_exports, {
+  source: () => source
+});
+module.exports = __toCommonJS(oldUtilityScriptSerializers_exports);
+function source() {
+  function isRegExp(obj) {
+    try {
+      return obj instanceof RegExp || Object.prototype.toString.call(obj) === "[object RegExp]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isDate(obj) {
+    try {
+      return obj instanceof Date || Object.prototype.toString.call(obj) === "[object Date]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isURL(obj) {
+    try {
+      return obj instanceof URL || Object.prototype.toString.call(obj) === "[object URL]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isError(obj) {
+    try {
+      return obj instanceof Error || obj && Object.getPrototypeOf(obj)?.name === "Error";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isTypedArray(obj, constructor) {
+    try {
+      return obj instanceof constructor || Object.prototype.toString.call(obj) === `[object ${constructor.name}]`;
+    } catch (error) {
+      return false;
+    }
+  }
+  const typedArrayConstructors = {
+    i8: Int8Array,
+    ui8: Uint8Array,
+    ui8c: Uint8ClampedArray,
+    i16: Int16Array,
+    ui16: Uint16Array,
+    i32: Int32Array,
+    ui32: Uint32Array,
+    // TODO: add Float16Array once it's in baseline
+    f32: Float32Array,
+    f64: Float64Array,
+    bi64: BigInt64Array,
+    bui64: BigUint64Array
+  };
+  function typedArrayToBase64(array) {
+    if ("toBase64" in array)
+      return array.toBase64();
+    const binary = Array.from(new Uint8Array(array.buffer, array.byteOffset, array.byteLength)).map((b) => String.fromCharCode(b)).join("");
+    return btoa(binary);
+  }
+  function base64ToTypedArray(base64, TypedArrayConstructor) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+      bytes[i] = binary.charCodeAt(i);
+    return new TypedArrayConstructor(bytes.buffer);
+  }
+  function parseEvaluationResultValue(value, handles = [], refs = /* @__PURE__ */ new Map()) {
+    if (Object.is(value, void 0))
+      return void 0;
+    if (typeof value === "object" && value) {
+      if ("ref" in value)
+        return refs.get(value.ref);
+      if ("v" in value) {
+        if (value.v === "undefined")
+          return void 0;
+        if (value.v === "null")
+          return null;
+        if (value.v === "NaN")
+          return NaN;
+        if (value.v === "Infinity")
+          return Infinity;
+        if (value.v === "-Infinity")
+          return -Infinity;
+        if (value.v === "-0")
+          return -0;
+        return void 0;
+      }
+      if ("d" in value)
+        return new Date(value.d);
+      if ("u" in value)
+        return new URL(value.u);
+      if ("bi" in value)
+        return BigInt(value.bi);
+      if ("e" in value) {
+        const error = new Error(value.e.m);
+        error.name = value.e.n;
+        error.stack = value.e.s;
+        return error;
+      }
+      if ("r" in value)
+        return new RegExp(value.r.p, value.r.f);
+      if ("a" in value) {
+        const result = [];
+        refs.set(value.id, result);
+        for (const a of value.a)
+          result.push(parseEvaluationResultValue(a, handles, refs));
+        return result;
+      }
+      if ("o" in value) {
+        const result = {};
+        refs.set(value.id, result);
+        for (const { k, v } of value.o)
+          result[k] = parseEvaluationResultValue(v, handles, refs);
+        return result;
+      }
+      if ("h" in value)
+        return handles[value.h];
+      if ("ta" in value)
+        return base64ToTypedArray(value.ta.b, typedArrayConstructors[value.ta.k]);
+    }
+    return value;
+  }
+  function serializeAsCallArgument(value, handleSerializer) {
+    return serialize(value, handleSerializer, { visited: /* @__PURE__ */ new Map(), lastId: 0 });
+  }
+  function serialize(value, handleSerializer, visitorInfo) {
+    if (value && typeof value === "object") {
+      if (typeof globalThis.Window === "function" && value instanceof globalThis.Window)
+        return "ref: <Window>";
+      if (typeof globalThis.Document === "function" && value instanceof globalThis.Document)
+        return "ref: <Document>";
+      if (typeof globalThis.Node === "function" && value instanceof globalThis.Node)
+        return "ref: <Node>";
+    }
+    return innerSerialize(value, handleSerializer, visitorInfo);
+  }
+  function innerSerialize(value, handleSerializer, visitorInfo) {
+    const result = handleSerializer(value);
+    if ("fallThrough" in result)
+      value = result.fallThrough;
+    else
+      return result;
+    if (typeof value === "symbol")
+      return { v: "undefined" };
+    if (Object.is(value, void 0))
+      return { v: "undefined" };
+    if (Object.is(value, null))
+      return { v: "null" };
+    if (Object.is(value, NaN))
+      return { v: "NaN" };
+    if (Object.is(value, Infinity))
+      return { v: "Infinity" };
+    if (Object.is(value, -Infinity))
+      return { v: "-Infinity" };
+    if (Object.is(value, -0))
+      return { v: "-0" };
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number")
+      return value;
+    if (typeof value === "string")
+      return value;
+    if (typeof value === "bigint")
+      return { bi: value.toString() };
+    if (isError(value)) {
+      let stack;
+      if (value.stack?.startsWith(value.name + ": " + value.message)) {
+        stack = value.stack;
+      } else {
+        stack = `${value.name}: ${value.message}
+${value.stack}`;
+      }
+      return { e: { n: value.name, m: value.message, s: stack } };
+    }
+    if (isDate(value))
+      return { d: value.toJSON() };
+    if (isURL(value))
+      return { u: value.toJSON() };
+    if (isRegExp(value))
+      return { r: { p: value.source, f: value.flags } };
+    for (const [k, ctor] of Object.entries(typedArrayConstructors)) {
+      if (isTypedArray(value, ctor))
+        return { ta: { b: typedArrayToBase64(value), k } };
+    }
+    const id = visitorInfo.visited.get(value);
+    if (id)
+      return { ref: id };
+    if (Array.isArray(value)) {
+      const a = [];
+      const id2 = ++visitorInfo.lastId;
+      visitorInfo.visited.set(value, id2);
+      for (let i = 0; i < value.length; ++i)
+        a.push(serialize(value[i], handleSerializer, visitorInfo));
+      return { a, id: id2 };
+    }
+    if (typeof value === "object") {
+      const o = [];
+      const id2 = ++visitorInfo.lastId;
+      visitorInfo.visited.set(value, id2);
+      for (const name of Object.keys(value)) {
+        let item;
+        try {
+          item = value[name];
+        } catch (e) {
+          continue;
+        }
+        if (name === "toJSON" && typeof item === "function")
+          o.push({ k: name, v: { o: [], id: 0 } });
+        else
+          o.push({ k: name, v: serialize(item, handleSerializer, visitorInfo) });
+      }
+      let jsonWrapper;
+      try {
+        if (o.length === 0 && value.toJSON && typeof value.toJSON === "function")
+          jsonWrapper = { value: value.toJSON() };
+      } catch (e) {
+      }
+      if (jsonWrapper)
+        return innerSerialize(jsonWrapper.value, handleSerializer, visitorInfo);
+      return { o, id: id2 };
+    }
+  }
+  return { parseEvaluationResultValue, serializeAsCallArgument };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  source
+});

package/lib/utils/isomorphic/protocolFormatter.js

@@ -0,0 +1,81 @@
+"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 protocolFormatter_exports = {};
+__export(protocolFormatter_exports, {
+  formatProtocolParam: () => formatProtocolParam,
+  getActionGroup: () => getActionGroup,
+  renderTitleForCall: () => renderTitleForCall
+});
+module.exports = __toCommonJS(protocolFormatter_exports);
+var import_protocolMetainfo = require("./protocolMetainfo");
+function formatProtocolParam(params, alternatives) {
+  return _formatProtocolParam(params, alternatives)?.replaceAll("\n", "\\n");
+}
+function _formatProtocolParam(params, alternatives) {
+  if (!params)
+    return void 0;
+  for (const name of alternatives.split("|")) {
+    if (name === "url") {
+      try {
+        const urlObject = new URL(params[name]);
+        if (urlObject.protocol === "data:")
+          return urlObject.protocol;
+        if (urlObject.protocol === "about:")
+          return params[name];
+        return urlObject.pathname + urlObject.search;
+      } catch (error) {
+        if (params[name] !== void 0)
+          return params[name];
+      }
+    }
+    if (name === "timeNumber" && params[name] !== void 0) {
+      return new Date(params[name]).toString();
+    }
+    const value = deepParam(params, name);
+    if (value !== void 0)
+      return value;
+  }
+}
+function deepParam(params, name) {
+  const tokens = name.split(".");
+  let current = params;
+  for (const token of tokens) {
+    if (typeof current !== "object" || current === null)
+      return void 0;
+    current = current[token];
+  }
+  if (current === void 0)
+    return void 0;
+  return String(current);
+}
+function renderTitleForCall(metadata) {
+  const titleFormat = metadata.title ?? import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method)?.title ?? metadata.method;
+  return titleFormat.replace(/\{([^}]+)\}/g, (fullMatch, p1) => {
+    return formatProtocolParam(metadata.params, p1) ?? fullMatch;
+  });
+}
+function getActionGroup(metadata) {
+  return import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method)?.group;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatProtocolParam,
+  getActionGroup,
+  renderTitleForCall
+});

package/lib/utils/isomorphic/protocolMetainfo.js

@@ -0,0 +1,330 @@
+"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 protocolMetainfo_exports = {};
+__export(protocolMetainfo_exports, {
+  methodMetainfo: () => methodMetainfo
+});
+module.exports = __toCommonJS(protocolMetainfo_exports);
+const methodMetainfo = /* @__PURE__ */ new Map([
+  ["APIRequestContext.fetch", { title: '{method} "{url}"' }],
+  ["APIRequestContext.fetchResponseBody", { title: "Get response body", group: "getter" }],
+  ["APIRequestContext.fetchLog", { internal: true }],
+  ["APIRequestContext.storageState", { title: "Get storage state" }],
+  ["APIRequestContext.disposeAPIResponse", { internal: true }],
+  ["APIRequestContext.dispose", { internal: true }],
+  ["LocalUtils.zip", { internal: true }],
+  ["LocalUtils.harOpen", { internal: true }],
+  ["LocalUtils.harLookup", { internal: true }],
+  ["LocalUtils.harClose", { internal: true }],
+  ["LocalUtils.harUnzip", { internal: true }],
+  ["LocalUtils.connect", { internal: true }],
+  ["LocalUtils.tracingStarted", { internal: true }],
+  ["LocalUtils.addStackToTracingNoReply", { internal: true }],
+  ["LocalUtils.traceDiscarded", { internal: true }],
+  ["LocalUtils.globToRegex", { internal: true }],
+  ["Root.initialize", { internal: true }],
+  ["Playwright.newRequest", { title: "Create request context" }],
+  ["DebugController.initialize", { internal: true }],
+  ["DebugController.setReportStateChanged", { internal: true }],
+  ["DebugController.setRecorderMode", { internal: true }],
+  ["DebugController.highlight", { internal: true }],
+  ["DebugController.hideHighlight", { internal: true }],
+  ["DebugController.resume", { internal: true }],
+  ["DebugController.kill", { internal: true }],
+  ["SocksSupport.socksConnected", { internal: true }],
+  ["SocksSupport.socksFailed", { internal: true }],
+  ["SocksSupport.socksData", { internal: true }],
+  ["SocksSupport.socksError", { internal: true }],
+  ["SocksSupport.socksEnd", { internal: true }],
+  ["BrowserType.launch", { title: "Launch browser" }],
+  ["BrowserType.launchPersistentContext", { title: "Launch persistent context" }],
+  ["BrowserType.connectOverCDP", { title: "Connect over CDP" }],
+  ["Browser.close", { title: "Close browser", pausesBeforeAction: true }],
+  ["Browser.killForTests", { internal: true }],
+  ["Browser.defaultUserAgentForTest", { internal: true }],
+  ["Browser.newContext", { title: "Create context" }],
+  ["Browser.newContextForReuse", { internal: true }],
+  ["Browser.disconnectFromReusedContext", { internal: true }],
+  ["Browser.newBrowserCDPSession", { title: "Create CDP session", group: "configuration" }],
+  ["Browser.startTracing", { title: "Start browser tracing", group: "configuration" }],
+  ["Browser.stopTracing", { title: "Stop browser tracing", group: "configuration" }],
+  ["EventTarget.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
+  ["BrowserContext.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
+  ["Page.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
+  ["Worker.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
+  ["WebSocket.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
+  ["ElectronApplication.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
+  ["AndroidDevice.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
+  ["PageAgent.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
+  ["BrowserContext.addCookies", { title: "Add cookies", group: "configuration" }],
+  ["BrowserContext.addInitScript", { title: "Add init script", group: "configuration" }],
+  ["BrowserContext.clearCookies", { title: "Clear cookies", group: "configuration" }],
+  ["BrowserContext.clearPermissions", { title: "Clear permissions", group: "configuration" }],
+  ["BrowserContext.close", { title: "Close context", pausesBeforeAction: true }],
+  ["BrowserContext.cookies", { title: "Get cookies", group: "getter" }],
+  ["BrowserContext.exposeBinding", { title: "Expose binding", group: "configuration" }],
+  ["BrowserContext.grantPermissions", { title: "Grant permissions", group: "configuration" }],
+  ["BrowserContext.newPage", { title: "Create page" }],
+  ["BrowserContext.registerSelectorEngine", { internal: true }],
+  ["BrowserContext.setTestIdAttributeName", { internal: true }],
+  ["BrowserContext.setExtraHTTPHeaders", { title: "Set extra HTTP headers", group: "configuration" }],
+  ["BrowserContext.setGeolocation", { title: "Set geolocation", group: "configuration" }],
+  ["BrowserContext.setHTTPCredentials", { title: "Set HTTP credentials", group: "configuration" }],
+  ["BrowserContext.setNetworkInterceptionPatterns", { title: "Route requests", group: "route" }],
+  ["BrowserContext.setWebSocketInterceptionPatterns", { title: "Route WebSockets", group: "route" }],
+  ["BrowserContext.setOffline", { title: "Set offline mode" }],
+  ["BrowserContext.storageState", { title: "Get storage state" }],
+  ["BrowserContext.pause", { title: "Pause" }],
+  ["BrowserContext.enableRecorder", { internal: true }],
+  ["BrowserContext.disableRecorder", { internal: true }],
+  ["BrowserContext.exposeConsoleApi", { internal: true }],
+  ["BrowserContext.newCDPSession", { title: "Create CDP session", group: "configuration" }],
+  ["BrowserContext.harStart", { internal: true }],
+  ["BrowserContext.harExport", { internal: true }],
+  ["BrowserContext.createTempFiles", { internal: true }],
+  ["BrowserContext.updateSubscription", { internal: true }],
+  ["BrowserContext.clockFastForward", { title: 'Fast forward clock "{ticksNumber|ticksString}"' }],
+  ["BrowserContext.clockInstall", { title: 'Install clock "{timeNumber|timeString}"' }],
+  ["BrowserContext.clockPauseAt", { title: 'Pause clock "{timeNumber|timeString}"' }],
+  ["BrowserContext.clockResume", { title: "Resume clock" }],
+  ["BrowserContext.clockRunFor", { title: 'Run clock "{ticksNumber|ticksString}"' }],
+  ["BrowserContext.clockSetFixedTime", { title: 'Set fixed time "{timeNumber|timeString}"' }],
+  ["BrowserContext.clockSetSystemTime", { title: 'Set system time "{timeNumber|timeString}"' }],
+  ["Page.addInitScript", { title: "Add init script", group: "configuration" }],
+  ["Page.close", { title: "Close page", pausesBeforeAction: true }],
+  ["Page.consoleMessages", { title: "Get console messages", group: "getter" }],
+  ["Page.emulateMedia", { title: "Emulate media", snapshot: true, pausesBeforeAction: true }],
+  ["Page.exposeBinding", { title: "Expose binding", group: "configuration" }],
+  ["Page.goBack", { title: "Go back", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.goForward", { title: "Go forward", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.requestGC", { title: "Request garbage collection", group: "configuration" }],
+  ["Page.registerLocatorHandler", { title: "Register locator handler" }],
+  ["Page.resolveLocatorHandlerNoReply", { internal: true }],
+  ["Page.unregisterLocatorHandler", { title: "Unregister locator handler" }],
+  ["Page.reload", { title: "Reload", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.expectScreenshot", { title: "Expect screenshot", snapshot: true, pausesBeforeAction: true }],
+  ["Page.screenshot", { title: "Screenshot", snapshot: true, pausesBeforeAction: true }],
+  ["Page.setExtraHTTPHeaders", { title: "Set extra HTTP headers", group: "configuration" }],
+  ["Page.setNetworkInterceptionPatterns", { title: "Route requests", group: "route" }],
+  ["Page.setWebSocketInterceptionPatterns", { title: "Route WebSockets", group: "route" }],
+  ["Page.setViewportSize", { title: "Set viewport size", snapshot: true, pausesBeforeAction: true }],
+  ["Page.keyboardDown", { title: 'Key down "{key}"', slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.keyboardUp", { title: 'Key up "{key}"', slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.keyboardInsertText", { title: 'Insert "{text}"', slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.keyboardType", { title: 'Type "{text}"', slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.keyboardPress", { title: 'Press "{key}"', slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.mouseMove", { title: "Mouse move", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.mouseDown", { title: "Mouse down", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.mouseUp", { title: "Mouse up", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.mouseClick", { title: "Click", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.mouseWheel", { title: "Mouse wheel", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.touchscreenTap", { title: "Tap", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Page.pageErrors", { title: "Get page errors", group: "getter" }],
+  ["Page.pdf", { title: "PDF" }],
+  ["Page.requests", { title: "Get network requests", group: "getter" }],
+  ["Page.snapshotForAI", { internal: true }],
+  ["Page.startJSCoverage", { title: "Start JS coverage", group: "configuration" }],
+  ["Page.stopJSCoverage", { title: "Stop JS coverage", group: "configuration" }],
+  ["Page.startCSSCoverage", { title: "Start CSS coverage", group: "configuration" }],
+  ["Page.stopCSSCoverage", { title: "Stop CSS coverage", group: "configuration" }],
+  ["Page.bringToFront", { title: "Bring to front" }],
+  ["Page.updateSubscription", { internal: true }],
+  ["Page.agent", { internal: true }],
+  ["Frame.evalOnSelector", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.evalOnSelectorAll", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.addScriptTag", { title: "Add script tag", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.addStyleTag", { title: "Add style tag", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.ariaSnapshot", { title: "Aria snapshot", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.blur", { title: "Blur", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Frame.check", { title: "Check", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.click", { title: "Click", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.content", { title: "Get content", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.dragAndDrop", { title: "Drag and drop", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.dblclick", { title: "Double click", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.dispatchEvent", { title: 'Dispatch "{type}"', slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Frame.evaluateExpression", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.evaluateExpressionHandle", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.fill", { title: 'Fill "{value}"', slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.focus", { title: "Focus", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Frame.frameElement", { title: "Get frame element", group: "getter" }],
+  ["Frame.resolveSelector", { internal: true }],
+  ["Frame.highlight", { title: "Highlight element", group: "configuration" }],
+  ["Frame.getAttribute", { title: 'Get attribute "{name}"', snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.goto", { title: 'Navigate to "{url}"', slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["Frame.hover", { title: "Hover", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.innerHTML", { title: "Get HTML", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.innerText", { title: "Get inner text", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.inputValue", { title: "Get input value", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.isChecked", { title: "Is checked", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.isDisabled", { title: "Is disabled", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.isEnabled", { title: "Is enabled", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.isHidden", { title: "Is hidden", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.isVisible", { title: "Is visible", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.isEditable", { title: "Is editable", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.press", { title: 'Press "{key}"', slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.querySelector", { title: "Query selector", snapshot: true }],
+  ["Frame.querySelectorAll", { title: "Query selector all", snapshot: true }],
+  ["Frame.queryCount", { title: "Query count", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.selectOption", { title: "Select option", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.setContent", { title: "Set content", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.setInputFiles", { title: "Set input files", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.tap", { title: "Tap", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.textContent", { title: "Get text content", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["Frame.title", { title: "Get page title", group: "getter" }],
+  ["Frame.type", { title: 'Type "{text}"', slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.uncheck", { title: "Uncheck", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["Frame.waitForTimeout", { title: "Wait for timeout", snapshot: true }],
+  ["Frame.waitForFunction", { title: "Wait for function", snapshot: true, pausesBeforeAction: true }],
+  ["Frame.waitForSelector", { title: "Wait for selector", snapshot: true }],
+  ["Frame.expect", { title: 'Expect "{expression}"', snapshot: true, pausesBeforeAction: true }],
+  ["Worker.evaluateExpression", { title: "Evaluate" }],
+  ["Worker.evaluateExpressionHandle", { title: "Evaluate" }],
+  ["Worker.updateSubscription", { internal: true }],
+  ["JSHandle.dispose", { internal: true }],
+  ["ElementHandle.dispose", { internal: true }],
+  ["JSHandle.evaluateExpression", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.evaluateExpression", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["JSHandle.evaluateExpressionHandle", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.evaluateExpressionHandle", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["JSHandle.getPropertyList", { title: "Get property list", group: "getter" }],
+  ["ElementHandle.getPropertyList", { title: "Get property list", group: "getter" }],
+  ["JSHandle.getProperty", { title: "Get JS property", group: "getter" }],
+  ["ElementHandle.getProperty", { title: "Get JS property", group: "getter" }],
+  ["JSHandle.jsonValue", { title: "Get JSON value", group: "getter" }],
+  ["ElementHandle.jsonValue", { title: "Get JSON value", group: "getter" }],
+  ["ElementHandle.evalOnSelector", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.evalOnSelectorAll", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.boundingBox", { title: "Get bounding box", snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.check", { title: "Check", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.click", { title: "Click", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.contentFrame", { title: "Get content frame", group: "getter" }],
+  ["ElementHandle.dblclick", { title: "Double click", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.dispatchEvent", { title: "Dispatch event", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.fill", { title: 'Fill "{value}"', slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.focus", { title: "Focus", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.getAttribute", { title: "Get attribute", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.hover", { title: "Hover", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.innerHTML", { title: "Get HTML", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.innerText", { title: "Get inner text", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.inputValue", { title: "Get input value", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.isChecked", { title: "Is checked", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.isDisabled", { title: "Is disabled", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.isEditable", { title: "Is editable", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.isEnabled", { title: "Is enabled", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.isHidden", { title: "Is hidden", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.isVisible", { title: "Is visible", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.ownerFrame", { title: "Get owner frame", group: "getter" }],
+  ["ElementHandle.press", { title: 'Press "{key}"', slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.querySelector", { title: "Query selector", snapshot: true }],
+  ["ElementHandle.querySelectorAll", { title: "Query selector all", snapshot: true }],
+  ["ElementHandle.screenshot", { title: "Screenshot", snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.scrollIntoViewIfNeeded", { title: "Scroll into view", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.selectOption", { title: "Select option", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.selectText", { title: "Select text", slowMo: true, snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.setInputFiles", { title: "Set input files", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.tap", { title: "Tap", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.textContent", { title: "Get text content", snapshot: true, pausesBeforeAction: true, group: "getter" }],
+  ["ElementHandle.type", { title: "Type", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.uncheck", { title: "Uncheck", slowMo: true, snapshot: true, pausesBeforeInput: true }],
+  ["ElementHandle.waitForElementState", { title: "Wait for state", snapshot: true, pausesBeforeAction: true }],
+  ["ElementHandle.waitForSelector", { title: "Wait for selector", snapshot: true }],
+  ["Request.response", { internal: true }],
+  ["Request.rawRequestHeaders", { internal: true }],
+  ["Route.redirectNavigationRequest", { internal: true }],
+  ["Route.abort", { title: "Abort request", group: "route" }],
+  ["Route.continue", { title: "Continue request", group: "route" }],
+  ["Route.fulfill", { title: "Fulfill request", group: "route" }],
+  ["WebSocketRoute.connect", { title: "Connect WebSocket to server", group: "route" }],
+  ["WebSocketRoute.ensureOpened", { internal: true }],
+  ["WebSocketRoute.sendToPage", { title: "Send WebSocket message", group: "route" }],
+  ["WebSocketRoute.sendToServer", { title: "Send WebSocket message", group: "route" }],
+  ["WebSocketRoute.closePage", { internal: true }],
+  ["WebSocketRoute.closeServer", { internal: true }],
+  ["Response.body", { title: "Get response body", group: "getter" }],
+  ["Response.securityDetails", { internal: true }],
+  ["Response.serverAddr", { internal: true }],
+  ["Response.rawResponseHeaders", { internal: true }],
+  ["Response.sizes", { internal: true }],
+  ["BindingCall.reject", { internal: true }],
+  ["BindingCall.resolve", { internal: true }],
+  ["Dialog.accept", { title: "Accept dialog" }],
+  ["Dialog.dismiss", { title: "Dismiss dialog" }],
+  ["Tracing.tracingStart", { title: "Start tracing", group: "configuration" }],
+  ["Tracing.tracingStartChunk", { title: "Start tracing", group: "configuration" }],
+  ["Tracing.tracingGroup", { title: 'Trace "{name}"' }],
+  ["Tracing.tracingGroupEnd", { title: "Group end" }],
+  ["Tracing.tracingStopChunk", { title: "Stop tracing", group: "configuration" }],
+  ["Tracing.tracingStop", { title: "Stop tracing", group: "configuration" }],
+  ["Artifact.pathAfterFinished", { internal: true }],
+  ["Artifact.saveAs", { internal: true }],
+  ["Artifact.saveAsStream", { internal: true }],
+  ["Artifact.failure", { internal: true }],
+  ["Artifact.stream", { internal: true }],
+  ["Artifact.cancel", { internal: true }],
+  ["Artifact.delete", { internal: true }],
+  ["Stream.read", { internal: true }],
+  ["Stream.close", { internal: true }],
+  ["WritableStream.write", { internal: true }],
+  ["WritableStream.close", { internal: true }],
+  ["CDPSession.send", { title: "Send CDP command", group: "configuration" }],
+  ["CDPSession.detach", { title: "Detach CDP session", group: "configuration" }],
+  ["Electron.launch", { title: "Launch electron" }],
+  ["ElectronApplication.browserWindow", { internal: true }],
+  ["ElectronApplication.evaluateExpression", { title: "Evaluate" }],
+  ["ElectronApplication.evaluateExpressionHandle", { title: "Evaluate" }],
+  ["ElectronApplication.updateSubscription", { internal: true }],
+  ["Android.devices", { internal: true }],
+  ["AndroidSocket.write", { internal: true }],
+  ["AndroidSocket.close", { internal: true }],
+  ["AndroidDevice.wait", { title: "Wait" }],
+  ["AndroidDevice.fill", { title: 'Fill "{text}"' }],
+  ["AndroidDevice.tap", { title: "Tap" }],
+  ["AndroidDevice.drag", { title: "Drag" }],
+  ["AndroidDevice.fling", { title: "Fling" }],
+  ["AndroidDevice.longTap", { title: "Long tap" }],
+  ["AndroidDevice.pinchClose", { title: "Pinch close" }],
+  ["AndroidDevice.pinchOpen", { title: "Pinch open" }],
+  ["AndroidDevice.scroll", { title: "Scroll" }],
+  ["AndroidDevice.swipe", { title: "Swipe" }],
+  ["AndroidDevice.info", { internal: true }],
+  ["AndroidDevice.screenshot", { title: "Screenshot" }],
+  ["AndroidDevice.inputType", { title: "Type" }],
+  ["AndroidDevice.inputPress", { title: "Press" }],
+  ["AndroidDevice.inputTap", { title: "Tap" }],
+  ["AndroidDevice.inputSwipe", { title: "Swipe" }],
+  ["AndroidDevice.inputDrag", { title: "Drag" }],
+  ["AndroidDevice.launchBrowser", { title: "Launch browser" }],
+  ["AndroidDevice.open", { title: "Open app" }],
+  ["AndroidDevice.shell", { title: "Execute shell command", group: "configuration" }],
+  ["AndroidDevice.installApk", { title: "Install apk" }],
+  ["AndroidDevice.push", { title: "Push" }],
+  ["AndroidDevice.connectToWebView", { title: "Connect to Web View" }],
+  ["AndroidDevice.close", { internal: true }],
+  ["JsonPipe.send", { internal: true }],
+  ["JsonPipe.close", { internal: true }],
+  ["PageAgent.perform", { title: 'Perform "{task}"' }],
+  ["PageAgent.expect", { title: 'Expect "{expectation}"' }],
+  ["PageAgent.extract", { title: 'Extract "{query}"' }],
+  ["PageAgent.dispose", { internal: true }],
+  ["PageAgent.usage", { title: "Get agent usage", group: "configuration" }]
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  methodMetainfo
+});