@browsermation/browser-engine 0.0.12 → 0.0.16

package/dist/node_modules/playwright-core/lib/server/bidi/bidiPdf.js

@@ -0,0 +1,106 @@
+"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 bidiPdf_exports = {};
+__export(bidiPdf_exports, {
+  BidiPDF: () => BidiPDF
+});
+module.exports = __toCommonJS(bidiPdf_exports);
+var import_utils = require("../../utils");
+const PagePaperFormats = {
+  letter: { width: 8.5, height: 11 },
+  legal: { width: 8.5, height: 14 },
+  tabloid: { width: 11, height: 17 },
+  ledger: { width: 17, height: 11 },
+  a0: { width: 33.1, height: 46.8 },
+  a1: { width: 23.4, height: 33.1 },
+  a2: { width: 16.54, height: 23.4 },
+  a3: { width: 11.7, height: 16.54 },
+  a4: { width: 8.27, height: 11.7 },
+  a5: { width: 5.83, height: 8.27 },
+  a6: { width: 4.13, height: 5.83 }
+};
+const unitToPixels = {
+  "px": 1,
+  "in": 96,
+  "cm": 37.8,
+  "mm": 3.78
+};
+function convertPrintParameterToInches(text) {
+  if (text === void 0)
+    return void 0;
+  let unit = text.substring(text.length - 2).toLowerCase();
+  let valueText = "";
+  if (unitToPixels.hasOwnProperty(unit)) {
+    valueText = text.substring(0, text.length - 2);
+  } else {
+    unit = "px";
+    valueText = text;
+  }
+  const value = Number(valueText);
+  (0, import_utils.assert)(!isNaN(value), "Failed to parse parameter value: " + text);
+  const pixels = value * unitToPixels[unit];
+  return pixels / 96;
+}
+class BidiPDF {
+  constructor(session) {
+    this._session = session;
+  }
+  async generate(options) {
+    const {
+      scale = 1,
+      printBackground = false,
+      landscape = false,
+      pageRanges = "",
+      margin = {}
+    } = options;
+    let paperWidth = 8.5;
+    let paperHeight = 11;
+    if (options.format) {
+      const format = PagePaperFormats[options.format.toLowerCase()];
+      (0, import_utils.assert)(format, "Unknown paper format: " + options.format);
+      paperWidth = format.width;
+      paperHeight = format.height;
+    } else {
+      paperWidth = convertPrintParameterToInches(options.width) || paperWidth;
+      paperHeight = convertPrintParameterToInches(options.height) || paperHeight;
+    }
+    const { data } = await this._session.send("browsingContext.print", {
+      context: this._session.sessionId,
+      background: printBackground,
+      margin: {
+        bottom: convertPrintParameterToInches(margin.bottom) || 0,
+        left: convertPrintParameterToInches(margin.left) || 0,
+        right: convertPrintParameterToInches(margin.right) || 0,
+        top: convertPrintParameterToInches(margin.top) || 0
+      },
+      orientation: landscape ? "landscape" : "portrait",
+      page: {
+        width: paperWidth,
+        height: paperHeight
+      },
+      pageRanges: pageRanges ? pageRanges.split(",").map((r) => r.trim()) : void 0,
+      scale
+    });
+    return Buffer.from(data, "base64");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BidiPDF
+});

package/dist/node_modules/playwright-core/lib/server/bidi/third_party/bidiCommands.d.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 bidiCommands_d_exports = {};
+module.exports = __toCommonJS(bidiCommands_d_exports);
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * Modifications copyright (c) Microsoft Corporation.
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/node_modules/playwright-core/lib/server/bidi/third_party/bidiDeserializer.js

@@ -0,0 +1,98 @@
+"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 bidiDeserializer_exports = {};
+__export(bidiDeserializer_exports, {
+  BidiDeserializer: () => BidiDeserializer
+});
+module.exports = __toCommonJS(bidiDeserializer_exports);
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * Modifications copyright (c) Microsoft Corporation.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BidiDeserializer {
+  static deserialize(result) {
+    if (!result)
+      return void 0;
+    switch (result.type) {
+      case "array":
+        return result.value?.map((value) => {
+          return BidiDeserializer.deserialize(value);
+        });
+      case "set":
+        return result.value?.reduce((acc, value) => {
+          return acc.add(BidiDeserializer.deserialize(value));
+        }, /* @__PURE__ */ new Set());
+      case "object":
+        return result.value?.reduce((acc, tuple) => {
+          const { key, value } = BidiDeserializer._deserializeTuple(tuple);
+          acc[key] = value;
+          return acc;
+        }, {});
+      case "map":
+        return result.value?.reduce((acc, tuple) => {
+          const { key, value } = BidiDeserializer._deserializeTuple(tuple);
+          return acc.set(key, value);
+        }, /* @__PURE__ */ new Map());
+      case "promise":
+        return {};
+      case "regexp":
+        return new RegExp(result.value.pattern, result.value.flags);
+      case "date":
+        return new Date(result.value);
+      case "undefined":
+        return void 0;
+      case "null":
+        return null;
+      case "number":
+        return BidiDeserializer._deserializeNumber(result.value);
+      case "bigint":
+        return BigInt(result.value);
+      case "boolean":
+        return Boolean(result.value);
+      case "string":
+        return result.value;
+    }
+    throw new Error(`Deserialization of type ${result.type} not supported.`);
+  }
+  static _deserializeNumber(value) {
+    switch (value) {
+      case "-0":
+        return -0;
+      case "NaN":
+        return NaN;
+      case "Infinity":
+        return Infinity;
+      case "-Infinity":
+        return -Infinity;
+      default:
+        return value;
+    }
+  }
+  static _deserializeTuple([serializedKey, serializedValue]) {
+    const key = typeof serializedKey === "string" ? serializedKey : BidiDeserializer.deserialize(serializedKey);
+    const value = BidiDeserializer.deserialize(serializedValue);
+    return { key, value };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BidiDeserializer
+});

package/dist/node_modules/playwright-core/lib/server/bidi/third_party/bidiKeyboard.js

@@ -0,0 +1,256 @@
+"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 bidiKeyboard_exports = {};
+__export(bidiKeyboard_exports, {
+  getBidiKeyValue: () => getBidiKeyValue
+});
+module.exports = __toCommonJS(bidiKeyboard_exports);
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * Modifications copyright (c) Microsoft Corporation.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const getBidiKeyValue = (keyName) => {
+  switch (keyName) {
+    case "\r":
+    case "\n":
+      keyName = "Enter";
+      break;
+  }
+  if ([...keyName].length === 1) {
+    return keyName;
+  }
+  switch (keyName) {
+    case "Cancel":
+      return "\uE001";
+    case "Help":
+      return "\uE002";
+    case "Backspace":
+      return "\uE003";
+    case "Tab":
+      return "\uE004";
+    case "Clear":
+      return "\uE005";
+    case "Enter":
+      return "\uE007";
+    case "Shift":
+    case "ShiftLeft":
+      return "\uE008";
+    case "Control":
+    case "ControlLeft":
+      return "\uE009";
+    case "Alt":
+    case "AltLeft":
+      return "\uE00A";
+    case "Pause":
+      return "\uE00B";
+    case "Escape":
+      return "\uE00C";
+    case "PageUp":
+      return "\uE00E";
+    case "PageDown":
+      return "\uE00F";
+    case "End":
+      return "\uE010";
+    case "Home":
+      return "\uE011";
+    case "ArrowLeft":
+      return "\uE012";
+    case "ArrowUp":
+      return "\uE013";
+    case "ArrowRight":
+      return "\uE014";
+    case "ArrowDown":
+      return "\uE015";
+    case "Insert":
+      return "\uE016";
+    case "Delete":
+      return "\uE017";
+    case "NumpadEqual":
+      return "\uE019";
+    case "Numpad0":
+      return "\uE01A";
+    case "Numpad1":
+      return "\uE01B";
+    case "Numpad2":
+      return "\uE01C";
+    case "Numpad3":
+      return "\uE01D";
+    case "Numpad4":
+      return "\uE01E";
+    case "Numpad5":
+      return "\uE01F";
+    case "Numpad6":
+      return "\uE020";
+    case "Numpad7":
+      return "\uE021";
+    case "Numpad8":
+      return "\uE022";
+    case "Numpad9":
+      return "\uE023";
+    case "NumpadMultiply":
+      return "\uE024";
+    case "NumpadAdd":
+      return "\uE025";
+    case "NumpadSubtract":
+      return "\uE027";
+    case "NumpadDecimal":
+      return "\uE028";
+    case "NumpadDivide":
+      return "\uE029";
+    case "F1":
+      return "\uE031";
+    case "F2":
+      return "\uE032";
+    case "F3":
+      return "\uE033";
+    case "F4":
+      return "\uE034";
+    case "F5":
+      return "\uE035";
+    case "F6":
+      return "\uE036";
+    case "F7":
+      return "\uE037";
+    case "F8":
+      return "\uE038";
+    case "F9":
+      return "\uE039";
+    case "F10":
+      return "\uE03A";
+    case "F11":
+      return "\uE03B";
+    case "F12":
+      return "\uE03C";
+    case "Meta":
+    case "MetaLeft":
+      return "\uE03D";
+    case "ShiftRight":
+      return "\uE050";
+    case "ControlRight":
+      return "\uE051";
+    case "AltRight":
+      return "\uE052";
+    case "MetaRight":
+      return "\uE053";
+    case "Space":
+      return " ";
+    case "Digit0":
+      return "0";
+    case "Digit1":
+      return "1";
+    case "Digit2":
+      return "2";
+    case "Digit3":
+      return "3";
+    case "Digit4":
+      return "4";
+    case "Digit5":
+      return "5";
+    case "Digit6":
+      return "6";
+    case "Digit7":
+      return "7";
+    case "Digit8":
+      return "8";
+    case "Digit9":
+      return "9";
+    case "KeyA":
+      return "a";
+    case "KeyB":
+      return "b";
+    case "KeyC":
+      return "c";
+    case "KeyD":
+      return "d";
+    case "KeyE":
+      return "e";
+    case "KeyF":
+      return "f";
+    case "KeyG":
+      return "g";
+    case "KeyH":
+      return "h";
+    case "KeyI":
+      return "i";
+    case "KeyJ":
+      return "j";
+    case "KeyK":
+      return "k";
+    case "KeyL":
+      return "l";
+    case "KeyM":
+      return "m";
+    case "KeyN":
+      return "n";
+    case "KeyO":
+      return "o";
+    case "KeyP":
+      return "p";
+    case "KeyQ":
+      return "q";
+    case "KeyR":
+      return "r";
+    case "KeyS":
+      return "s";
+    case "KeyT":
+      return "t";
+    case "KeyU":
+      return "u";
+    case "KeyV":
+      return "v";
+    case "KeyW":
+      return "w";
+    case "KeyX":
+      return "x";
+    case "KeyY":
+      return "y";
+    case "KeyZ":
+      return "z";
+    case "Semicolon":
+      return ";";
+    case "Equal":
+      return "=";
+    case "Comma":
+      return ",";
+    case "Minus":
+      return "-";
+    case "Period":
+      return ".";
+    case "Slash":
+      return "/";
+    case "Backquote":
+      return "`";
+    case "BracketLeft":
+      return "[";
+    case "Backslash":
+      return "\\";
+    case "BracketRight":
+      return "]";
+    case "Quote":
+      return '"';
+    default:
+      throw new Error(`Unknown key: "${keyName}"`);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBidiKeyValue
+});

package/dist/node_modules/playwright-core/lib/server/bidi/third_party/bidiProtocol.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bidiProtocol_exports = {};
+module.exports = __toCommonJS(bidiProtocol_exports);
+__reExport(bidiProtocol_exports, require("./bidiProtocolCore"), module.exports);
+__reExport(bidiProtocol_exports, require("./bidiProtocolPermissions"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./bidiProtocolCore"),
+  ...require("./bidiProtocolPermissions")
+});

package/dist/node_modules/playwright-core/lib/server/bidi/third_party/bidiProtocolCore.js

@@ -0,0 +1,179 @@
+"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 bidiProtocolCore_exports = {};
+__export(bidiProtocolCore_exports, {
+  BrowsingContext: () => BrowsingContext,
+  Emulation: () => Emulation,
+  ErrorCode: () => ErrorCode,
+  Input: () => Input,
+  Log: () => Log,
+  Network: () => Network,
+  Script: () => Script,
+  Session: () => Session
+});
+module.exports = __toCommonJS(bidiProtocolCore_exports);
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["InvalidArgument"] = "invalid argument";
+  ErrorCode2["InvalidSelector"] = "invalid selector";
+  ErrorCode2["InvalidSessionId"] = "invalid session id";
+  ErrorCode2["InvalidWebExtension"] = "invalid web extension";
+  ErrorCode2["MoveTargetOutOfBounds"] = "move target out of bounds";
+  ErrorCode2["NoSuchAlert"] = "no such alert";
+  ErrorCode2["NoSuchNetworkCollector"] = "no such network collector";
+  ErrorCode2["NoSuchElement"] = "no such element";
+  ErrorCode2["NoSuchFrame"] = "no such frame";
+  ErrorCode2["NoSuchHandle"] = "no such handle";
+  ErrorCode2["NoSuchHistoryEntry"] = "no such history entry";
+  ErrorCode2["NoSuchIntercept"] = "no such intercept";
+  ErrorCode2["NoSuchNetworkData"] = "no such network data";
+  ErrorCode2["NoSuchNode"] = "no such node";
+  ErrorCode2["NoSuchRequest"] = "no such request";
+  ErrorCode2["NoSuchScript"] = "no such script";
+  ErrorCode2["NoSuchStoragePartition"] = "no such storage partition";
+  ErrorCode2["NoSuchUserContext"] = "no such user context";
+  ErrorCode2["NoSuchWebExtension"] = "no such web extension";
+  ErrorCode2["SessionNotCreated"] = "session not created";
+  ErrorCode2["UnableToCaptureScreen"] = "unable to capture screen";
+  ErrorCode2["UnableToCloseBrowser"] = "unable to close browser";
+  ErrorCode2["UnableToSetCookie"] = "unable to set cookie";
+  ErrorCode2["UnableToSetFileInput"] = "unable to set file input";
+  ErrorCode2["UnavailableNetworkData"] = "unavailable network data";
+  ErrorCode2["UnderspecifiedStoragePartition"] = "underspecified storage partition";
+  ErrorCode2["UnknownCommand"] = "unknown command";
+  ErrorCode2["UnknownError"] = "unknown error";
+  ErrorCode2["UnsupportedOperation"] = "unsupported operation";
+  return ErrorCode2;
+})(ErrorCode || {});
+var Session;
+((Session2) => {
+  let UserPromptHandlerType;
+  ((UserPromptHandlerType2) => {
+    UserPromptHandlerType2["Accept"] = "accept";
+    UserPromptHandlerType2["Dismiss"] = "dismiss";
+    UserPromptHandlerType2["Ignore"] = "ignore";
+  })(UserPromptHandlerType = Session2.UserPromptHandlerType || (Session2.UserPromptHandlerType = {}));
+})(Session || (Session = {}));
+var BrowsingContext;
+((BrowsingContext2) => {
+  let ReadinessState;
+  ((ReadinessState2) => {
+    ReadinessState2["None"] = "none";
+    ReadinessState2["Interactive"] = "interactive";
+    ReadinessState2["Complete"] = "complete";
+  })(ReadinessState = BrowsingContext2.ReadinessState || (BrowsingContext2.ReadinessState = {}));
+})(BrowsingContext || (BrowsingContext = {}));
+((BrowsingContext2) => {
+  let UserPromptType;
+  ((UserPromptType2) => {
+    UserPromptType2["Alert"] = "alert";
+    UserPromptType2["Beforeunload"] = "beforeunload";
+    UserPromptType2["Confirm"] = "confirm";
+    UserPromptType2["Prompt"] = "prompt";
+  })(UserPromptType = BrowsingContext2.UserPromptType || (BrowsingContext2.UserPromptType = {}));
+})(BrowsingContext || (BrowsingContext = {}));
+((BrowsingContext2) => {
+  let CreateType;
+  ((CreateType2) => {
+    CreateType2["Tab"] = "tab";
+    CreateType2["Window"] = "window";
+  })(CreateType = BrowsingContext2.CreateType || (BrowsingContext2.CreateType = {}));
+})(BrowsingContext || (BrowsingContext = {}));
+var Emulation;
+((Emulation2) => {
+  let ForcedColorsModeTheme;
+  ((ForcedColorsModeTheme2) => {
+    ForcedColorsModeTheme2["Light"] = "light";
+    ForcedColorsModeTheme2["Dark"] = "dark";
+  })(ForcedColorsModeTheme = Emulation2.ForcedColorsModeTheme || (Emulation2.ForcedColorsModeTheme = {}));
+})(Emulation || (Emulation = {}));
+((Emulation2) => {
+  let ScreenOrientationNatural;
+  ((ScreenOrientationNatural2) => {
+    ScreenOrientationNatural2["Portrait"] = "portrait";
+    ScreenOrientationNatural2["Landscape"] = "landscape";
+  })(ScreenOrientationNatural = Emulation2.ScreenOrientationNatural || (Emulation2.ScreenOrientationNatural = {}));
+})(Emulation || (Emulation = {}));
+var Network;
+((Network2) => {
+  let CollectorType;
+  ((CollectorType2) => {
+    CollectorType2["Blob"] = "blob";
+  })(CollectorType = Network2.CollectorType || (Network2.CollectorType = {}));
+})(Network || (Network = {}));
+((Network2) => {
+  let SameSite;
+  ((SameSite2) => {
+    SameSite2["Strict"] = "strict";
+    SameSite2["Lax"] = "lax";
+    SameSite2["None"] = "none";
+    SameSite2["Default"] = "default";
+  })(SameSite = Network2.SameSite || (Network2.SameSite = {}));
+})(Network || (Network = {}));
+((Network2) => {
+  let DataType;
+  ((DataType2) => {
+    DataType2["Response"] = "response";
+  })(DataType = Network2.DataType || (Network2.DataType = {}));
+})(Network || (Network = {}));
+((Network2) => {
+  let InterceptPhase;
+  ((InterceptPhase2) => {
+    InterceptPhase2["BeforeRequestSent"] = "beforeRequestSent";
+    InterceptPhase2["ResponseStarted"] = "responseStarted";
+    InterceptPhase2["AuthRequired"] = "authRequired";
+  })(InterceptPhase = Network2.InterceptPhase || (Network2.InterceptPhase = {}));
+})(Network || (Network = {}));
+var Script;
+((Script2) => {
+  let ResultOwnership;
+  ((ResultOwnership2) => {
+    ResultOwnership2["Root"] = "root";
+    ResultOwnership2["None"] = "none";
+  })(ResultOwnership = Script2.ResultOwnership || (Script2.ResultOwnership = {}));
+})(Script || (Script = {}));
+var Log;
+((Log2) => {
+  let Level;
+  ((Level2) => {
+    Level2["Debug"] = "debug";
+    Level2["Info"] = "info";
+    Level2["Warn"] = "warn";
+    Level2["Error"] = "error";
+  })(Level = Log2.Level || (Log2.Level = {}));
+})(Log || (Log = {}));
+var Input;
+((Input2) => {
+  let PointerType;
+  ((PointerType2) => {
+    PointerType2["Mouse"] = "mouse";
+    PointerType2["Pen"] = "pen";
+    PointerType2["Touch"] = "touch";
+  })(PointerType = Input2.PointerType || (Input2.PointerType = {}));
+})(Input || (Input = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowsingContext,
+  Emulation,
+  ErrorCode,
+  Input,
+  Log,
+  Network,
+  Script,
+  Session
+});