@zohodesk/testinglibrary 3.2.11 → 3.2.13

package/playwright-mcp-test/node_modules/playwright-core/lib/server/utils/wsServer.js

@@ -0,0 +1,121 @@
+"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 wsServer_exports = {};
+__export(wsServer_exports, {
+  WSServer: () => WSServer,
+  perMessageDeflate: () => perMessageDeflate
+});
+module.exports = __toCommonJS(wsServer_exports);
+var import_network = require("./network");
+var import_utilsBundle = require("../../utilsBundle");
+var import_debugLogger = require("./debugLogger");
+let lastConnectionId = 0;
+const kConnectionSymbol = Symbol("kConnection");
+const perMessageDeflate = {
+  serverNoContextTakeover: true,
+  zlibDeflateOptions: {
+    level: 3
+  },
+  zlibInflateOptions: {
+    chunkSize: 10 * 1024
+  },
+  threshold: 10 * 1024
+};
+class WSServer {
+  constructor(delegate) {
+    this._delegate = delegate;
+  }
+  async listen(port = 0, hostname, path) {
+    import_debugLogger.debugLogger.log("server", `Server started at ${/* @__PURE__ */ new Date()}`);
+    const server = (0, import_network.createHttpServer)(this._delegate.onRequest);
+    server.on("error", (error) => import_debugLogger.debugLogger.log("server", String(error)));
+    this.server = server;
+    const wsEndpoint = await new Promise((resolve, reject) => {
+      server.listen(port, hostname, () => {
+        const address = server.address();
+        if (!address) {
+          reject(new Error("Could not bind server socket"));
+          return;
+        }
+        const wsEndpoint2 = typeof address === "string" ? `${address}${path}` : `ws://${hostname || "localhost"}:${address.port}${path}`;
+        resolve(wsEndpoint2);
+      }).on("error", reject);
+    });
+    import_debugLogger.debugLogger.log("server", "Listening at " + wsEndpoint);
+    this._wsServer = new import_utilsBundle.wsServer({
+      noServer: true,
+      perMessageDeflate
+    });
+    this._wsServer.on("headers", (headers) => this._delegate.onHeaders(headers));
+    server.on("upgrade", (request, socket, head) => {
+      const pathname = new URL("http://localhost" + request.url).pathname;
+      if (pathname !== path) {
+        socket.write(`HTTP/${request.httpVersion} 400 Bad Request\r
+\r
+`);
+        socket.destroy();
+        return;
+      }
+      const upgradeResult = this._delegate.onUpgrade(request, socket);
+      if (upgradeResult) {
+        socket.write(upgradeResult.error);
+        socket.destroy();
+        return;
+      }
+      this._wsServer.handleUpgrade(request, socket, head, (ws) => this._wsServer.emit("connection", ws, request));
+    });
+    this._wsServer.on("connection", (ws, request) => {
+      import_debugLogger.debugLogger.log("server", "Connected client ws.extension=" + ws.extensions);
+      const url = new URL("http://localhost" + (request.url || ""));
+      const id = String(++lastConnectionId);
+      import_debugLogger.debugLogger.log("server", `[${id}] serving connection: ${request.url}`);
+      const connection = this._delegate.onConnection(request, url, ws, id);
+      ws[kConnectionSymbol] = connection;
+    });
+    return wsEndpoint;
+  }
+  async close() {
+    const server = this._wsServer;
+    if (!server)
+      return;
+    import_debugLogger.debugLogger.log("server", "closing websocket server");
+    const waitForClose = new Promise((f) => server.close(f));
+    await Promise.all(Array.from(server.clients).map(async (ws) => {
+      const connection = ws[kConnectionSymbol];
+      if (connection)
+        await connection.close();
+      try {
+        ws.terminate();
+      } catch (e) {
+      }
+    }));
+    await waitForClose;
+    import_debugLogger.debugLogger.log("server", "closing http server");
+    if (this.server)
+      await new Promise((f) => this.server.close(f));
+    this._wsServer = void 0;
+    this.server = void 0;
+    import_debugLogger.debugLogger.log("server", "closed server");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WSServer,
+  perMessageDeflate
+});

package/playwright-mcp-test/node_modules/playwright-core/lib/server/utils/zipFile.js

@@ -0,0 +1,74 @@
+"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 zipFile_exports = {};
+__export(zipFile_exports, {
+  ZipFile: () => ZipFile
+});
+module.exports = __toCommonJS(zipFile_exports);
+var import_zipBundle = require("../../zipBundle");
+class ZipFile {
+  constructor(fileName) {
+    this._entries = /* @__PURE__ */ new Map();
+    this._fileName = fileName;
+    this._openedPromise = this._open();
+  }
+  async _open() {
+    await new Promise((fulfill, reject) => {
+      import_zipBundle.yauzl.open(this._fileName, { autoClose: false }, (e, z) => {
+        if (e) {
+          reject(e);
+          return;
+        }
+        this._zipFile = z;
+        this._zipFile.on("entry", (entry) => {
+          this._entries.set(entry.fileName, entry);
+        });
+        this._zipFile.on("end", fulfill);
+      });
+    });
+  }
+  async entries() {
+    await this._openedPromise;
+    return [...this._entries.keys()];
+  }
+  async read(entryPath) {
+    await this._openedPromise;
+    const entry = this._entries.get(entryPath);
+    if (!entry)
+      throw new Error(`${entryPath} not found in file ${this._fileName}`);
+    return new Promise((resolve, reject) => {
+      this._zipFile.openReadStream(entry, (error, readStream) => {
+        if (error || !readStream) {
+          reject(error || "Entry not found");
+          return;
+        }
+        const buffers = [];
+        readStream.on("data", (data) => buffers.push(data));
+        readStream.on("end", () => resolve(Buffer.concat(buffers)));
+      });
+    });
+  }
+  close() {
+    this._zipFile?.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZipFile
+});

package/playwright-mcp-test/node_modules/playwright-core/lib/server/utils/zones.js

@@ -0,0 +1,57 @@
+"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 zones_exports = {};
+__export(zones_exports, {
+  Zone: () => Zone,
+  currentZone: () => currentZone,
+  emptyZone: () => emptyZone
+});
+module.exports = __toCommonJS(zones_exports);
+var import_async_hooks = require("async_hooks");
+const asyncLocalStorage = new import_async_hooks.AsyncLocalStorage();
+class Zone {
+  constructor(asyncLocalStorage2, store) {
+    this._asyncLocalStorage = asyncLocalStorage2;
+    this._data = store;
+  }
+  with(type, data) {
+    return new Zone(this._asyncLocalStorage, new Map(this._data).set(type, data));
+  }
+  without(type) {
+    const data = type ? new Map(this._data) : /* @__PURE__ */ new Map();
+    data.delete(type);
+    return new Zone(this._asyncLocalStorage, data);
+  }
+  run(func) {
+    return this._asyncLocalStorage.run(this, func);
+  }
+  data(type) {
+    return this._data.get(type);
+  }
+}
+const emptyZone = new Zone(asyncLocalStorage, /* @__PURE__ */ new Map());
+function currentZone() {
+  return asyncLocalStorage.getStore() ?? emptyZone;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Zone,
+  currentZone,
+  emptyZone
+});

package/playwright-mcp-test/node_modules/playwright-core/lib/server/webkit/protocol.d.js

@@ -0,0 +1,16 @@
+"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 protocol_d_exports = {};
+module.exports = __toCommonJS(protocol_d_exports);

package/playwright-mcp-test/node_modules/playwright-core/lib/server/webkit/webkit.js

@@ -0,0 +1,119 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webkit_exports = {};
+__export(webkit_exports, {
+  WebKit: () => WebKit,
+  translatePathToWSL: () => translatePathToWSL
+});
+module.exports = __toCommonJS(webkit_exports);
+var import_path = __toESM(require("path"));
+var import_wkConnection = require("./wkConnection");
+var import_ascii = require("../utils/ascii");
+var import_browserType = require("../browserType");
+var import_wkBrowser = require("../webkit/wkBrowser");
+var import_spawnAsync = require("../utils/spawnAsync");
+var import_registry = require("../registry");
+class WebKit extends import_browserType.BrowserType {
+  constructor(parent) {
+    super(parent, "webkit");
+  }
+  connectToTransport(transport, options) {
+    return import_wkBrowser.WKBrowser.connect(this.attribution.playwright, transport, options);
+  }
+  amendEnvironment(env, userDataDir, isPersistent, options) {
+    return {
+      ...env,
+      CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0,
+      WEBKIT_EXECUTABLE: options.channel === "webkit-wsl" ? import_registry.registry.findExecutable("webkit-wsl").wslExecutablePath : void 0
+    };
+  }
+  doRewriteStartupLog(error) {
+    if (!error.logs)
+      return error;
+    if (error.logs.includes("Failed to open display") || error.logs.includes("cannot open display"))
+      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return error;
+  }
+  attemptToGracefullyCloseBrowser(transport) {
+    transport.send({ method: "Playwright.close", params: {}, id: import_wkConnection.kBrowserCloseMessageId });
+  }
+  async defaultArgs(options, isPersistent, userDataDir) {
+    const { args = [], headless } = options;
+    const userDataDirArg = args.find((arg) => arg.startsWith("--user-data-dir"));
+    if (userDataDirArg)
+      throw this._createUserDataDirArgMisuseError("--user-data-dir");
+    if (args.find((arg) => !arg.startsWith("-")))
+      throw new Error("Arguments can not specify page to be opened");
+    const webkitArguments = ["--inspector-pipe"];
+    if (options.channel === "webkit-wsl") {
+      if (options.executablePath)
+        throw new Error('Cannot specify executablePath when using the "webkit-wsl" channel.');
+      webkitArguments.unshift(
+        import_path.default.join(__dirname, "wsl/webkit-wsl-transport-server.js")
+      );
+    }
+    if (process.platform === "win32" && options.channel !== "webkit-wsl")
+      webkitArguments.push("--disable-accelerated-compositing");
+    if (headless)
+      webkitArguments.push("--headless");
+    if (isPersistent)
+      webkitArguments.push(`--user-data-dir=${options.channel === "webkit-wsl" ? await translatePathToWSL(userDataDir) : userDataDir}`);
+    else
+      webkitArguments.push(`--no-startup-window`);
+    const proxy = options.proxyOverride || options.proxy;
+    if (proxy) {
+      if (process.platform === "darwin") {
+        webkitArguments.push(`--proxy=${proxy.server}`);
+        if (proxy.bypass)
+          webkitArguments.push(`--proxy-bypass-list=${proxy.bypass}`);
+      } else if (process.platform === "linux" || process.platform === "win32" && options.channel === "webkit-wsl") {
+        webkitArguments.push(`--proxy=${proxy.server}`);
+        if (proxy.bypass)
+          webkitArguments.push(...proxy.bypass.split(",").map((t) => `--ignore-host=${t}`));
+      } else if (process.platform === "win32") {
+        webkitArguments.push(`--curl-proxy=${proxy.server.replace(/^socks5:\/\//, "socks5h://")}`);
+        if (proxy.bypass)
+          webkitArguments.push(`--curl-noproxy=${proxy.bypass}`);
+      }
+    }
+    webkitArguments.push(...args);
+    if (isPersistent)
+      webkitArguments.push("about:blank");
+    return webkitArguments;
+  }
+}
+async function translatePathToWSL(path2) {
+  const { stdout } = await (0, import_spawnAsync.spawnAsync)("wsl.exe", ["-d", "playwright", "--cd", "/home/pwuser", "wslpath", path2.replace(/\\/g, "\\\\")]);
+  return stdout.toString().trim();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebKit,
+  translatePathToWSL
+});

package/playwright-mcp-test/node_modules/playwright-core/lib/server/webkit/wkAccessibility.js

@@ -0,0 +1,237 @@
+"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 wkAccessibility_exports = {};
+__export(wkAccessibility_exports, {
+  getAccessibilityTree: () => getAccessibilityTree
+});
+module.exports = __toCommonJS(wkAccessibility_exports);
+async function getAccessibilityTree(session, needle) {
+  const objectId = needle ? needle._objectId : void 0;
+  const { axNode } = await session.send("Page.accessibilitySnapshot", { objectId });
+  const tree = new WKAXNode(axNode);
+  return {
+    tree,
+    needle: needle ? tree._findNeedle() : null
+  };
+}
+const WKRoleToARIARole = new Map(Object.entries({
+  "TextField": "textbox"
+}));
+const WKUnhelpfulRoleDescriptions = new Map(Object.entries({
+  "WebArea": "HTML content",
+  "Summary": "summary",
+  "DescriptionList": "description list",
+  "ImageMap": "image map",
+  "ListMarker": "list marker",
+  "Video": "video playback",
+  "Mark": "highlighted",
+  "contentinfo": "content information",
+  "Details": "details",
+  "DescriptionListDetail": "description",
+  "DescriptionListTerm": "term",
+  "alertdialog": "web alert dialog",
+  "dialog": "web dialog",
+  "status": "application status",
+  "tabpanel": "tab panel",
+  "application": "web application"
+}));
+class WKAXNode {
+  constructor(payload) {
+    this._payload = payload;
+    this._children = [];
+    for (const payload2 of this._payload.children || [])
+      this._children.push(new WKAXNode(payload2));
+  }
+  children() {
+    return this._children;
+  }
+  _findNeedle() {
+    if (this._payload.found)
+      return this;
+    for (const child of this._children) {
+      const found = child._findNeedle();
+      if (found)
+        return found;
+    }
+    return null;
+  }
+  isControl() {
+    switch (this._payload.role) {
+      case "button":
+      case "checkbox":
+      case "ColorWell":
+      case "combobox":
+      case "DisclosureTriangle":
+      case "listbox":
+      case "menu":
+      case "menubar":
+      case "menuitem":
+      case "menuitemcheckbox":
+      case "menuitemradio":
+      case "radio":
+      case "scrollbar":
+      case "searchbox":
+      case "slider":
+      case "spinbutton":
+      case "switch":
+      case "tab":
+      case "textbox":
+      case "TextField":
+      case "tree":
+        return true;
+      default:
+        return false;
+    }
+  }
+  _isTextControl() {
+    switch (this._payload.role) {
+      case "combobox":
+      case "searchfield":
+      case "textbox":
+      case "TextField":
+        return true;
+    }
+    return false;
+  }
+  _name() {
+    if (this._payload.role === "text")
+      return this._payload.value || "";
+    return this._payload.name || "";
+  }
+  isInteresting(insideControl) {
+    const { role, focusable } = this._payload;
+    const name = this._name();
+    if (role === "ScrollArea")
+      return false;
+    if (role === "WebArea")
+      return true;
+    if (focusable || role === "MenuListOption")
+      return true;
+    if (this.isControl())
+      return true;
+    if (insideControl)
+      return false;
+    return this.isLeafNode() && !!name;
+  }
+  _hasRedundantTextChild() {
+    if (this._children.length !== 1)
+      return false;
+    const child = this._children[0];
+    return child._payload.role === "text" && this._payload.name === child._payload.value;
+  }
+  isLeafNode() {
+    if (!this._children.length)
+      return true;
+    if (this._isTextControl())
+      return true;
+    if (this._hasRedundantTextChild())
+      return true;
+    return false;
+  }
+  serialize() {
+    const node = {
+      role: WKRoleToARIARole.get(this._payload.role) || this._payload.role,
+      name: this._name()
+    };
+    if ("description" in this._payload && this._payload.description !== node.name)
+      node.description = this._payload.description;
+    if ("roledescription" in this._payload) {
+      const roledescription = this._payload.roledescription;
+      if (roledescription !== this._payload.role && WKUnhelpfulRoleDescriptions.get(this._payload.role) !== roledescription)
+        node.roledescription = roledescription;
+    }
+    if ("value" in this._payload && this._payload.role !== "text") {
+      if (typeof this._payload.value === "string")
+        node.valueString = this._payload.value;
+      else if (typeof this._payload.value === "number")
+        node.valueNumber = this._payload.value;
+    }
+    if ("checked" in this._payload)
+      node.checked = this._payload.checked === "true" ? "checked" : this._payload.checked === "false" ? "unchecked" : "mixed";
+    if ("pressed" in this._payload)
+      node.pressed = this._payload.pressed === "true" ? "pressed" : this._payload.pressed === "false" ? "released" : "mixed";
+    const userStringProperties = [
+      "keyshortcuts",
+      "valuetext"
+    ];
+    for (const userStringProperty of userStringProperties) {
+      if (!(userStringProperty in this._payload))
+        continue;
+      node[userStringProperty] = this._payload[userStringProperty];
+    }
+    const booleanProperties = [
+      "disabled",
+      "expanded",
+      "focused",
+      "modal",
+      "multiselectable",
+      "readonly",
+      "required",
+      "selected"
+    ];
+    for (const booleanProperty of booleanProperties) {
+      if (booleanProperty === "focused" && (this._payload.role === "WebArea" || this._payload.role === "ScrollArea"))
+        continue;
+      const value = this._payload[booleanProperty];
+      if (!value)
+        continue;
+      node[booleanProperty] = value;
+    }
+    const numericalProperties = [
+      "level",
+      "valuemax",
+      "valuemin"
+    ];
+    for (const numericalProperty of numericalProperties) {
+      if (!(numericalProperty in this._payload))
+        continue;
+      node[numericalProperty] = this._payload[numericalProperty];
+    }
+    const tokenProperties = [
+      "autocomplete",
+      "haspopup",
+      "invalid"
+    ];
+    for (const tokenProperty of tokenProperties) {
+      const value = this._payload[tokenProperty];
+      if (!value || value === "false")
+        continue;
+      node[tokenProperty] = value;
+    }
+    const orientationIsApplicable = /* @__PURE__ */ new Set([
+      "ScrollArea",
+      "scrollbar",
+      "listbox",
+      "combobox",
+      "menu",
+      "tree",
+      "separator",
+      "slider",
+      "tablist",
+      "toolbar"
+    ]);
+    if (this._payload.orientation && orientationIsApplicable.has(this._payload.role))
+      node.orientation = this._payload.orientation;
+    return node;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAccessibilityTree
+});