playwright-core 1.56.0-alpha-2025-09-09 → 1.56.0-alpha-1757456950000

package/bin/install_webkit_wsl.ps1

@@ -0,0 +1,35 @@
+$ErrorActionPreference = 'Stop'
+
+# WebKit WSL Installation Script
+# See webkit-wsl-transport-server.ts for the complete architecture diagram.
+# This script sets up a WSL distribution that will be used to run WebKit.
+
+$Distribution = "playwright"
+$Username = "pwuser"
+
+$distributions = (wsl --list --quiet) -split "\r?\n"
+if ($distributions -contains $Distribution) {
+    Write-Host "WSL distribution '$Distribution' already exists. Skipping installation."
+} else {
+    Write-Host "Installing new WSL distribution '$Distribution'..."
+    $VhdSize = "10GB"
+    wsl --install -d Ubuntu-24.04 --name $Distribution --no-launch --vhd-size $VhdSize
+    wsl -d $Distribution -u root adduser --gecos GECOS --disabled-password $Username
+}
+
+$pwshDirname = (Resolve-Path -Path $PSScriptRoot).Path;
+$playwrightCoreRoot = Resolve-Path (Join-Path $pwshDirname "..")
+
+$initScript = @"
+if [ ! -f "/home/$Username/node/bin/node" ]; then
+  mkdir -p /home/$Username/node
+  curl -fsSL https://nodejs.org/dist/v22.17.0/node-v22.17.0-linux-x64.tar.xz -o /home/$Username/node/node-v22.17.0-linux-x64.tar.xz
+  tar -xJf /home/$Username/node/node-v22.17.0-linux-x64.tar.xz -C /home/$Username/node --strip-components=1
+fi
+/home/$Username/node/bin/node cli.js install-deps webkit
+cp lib/server/webkit/wsl/webkit-wsl-transport-client.js /home/$Username/
+sudo -u $Username PLAYWRIGHT_SKIP_BROWSER_GC=1 /home/$Username/node/bin/node cli.js install webkit
+"@ -replace "\r\n", "`n"
+
+wsl -d $Distribution --cd $playwrightCoreRoot -u root -- bash -c "$initScript"
+Write-Host "Done!"

package/lib/server/bidi/bidiChromium.js

@@ -86,7 +86,7 @@ class BidiChromium extends import_browserType.BrowserType {
   supportsPipeTransport() {
     return false;
   }
-  defaultArgs(options, isPersistent, userDataDir) {
+  async defaultArgs(options, isPersistent, userDataDir) {
     const chromeArguments = this._innerDefaultArgs(options);
     chromeArguments.push(`--user-data-dir=${userDataDir}`);
     chromeArguments.push("--remote-debugging-port=0");

package/lib/server/bidi/bidiFirefox.js

@@ -85,7 +85,7 @@ Workaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ?
       preferences: options.firefoxUserPrefs || {}
     });
   }
-  defaultArgs(options, isPersistent, userDataDir) {
+  async defaultArgs(options, isPersistent, userDataDir) {
     const { args = [], headless } = options;
     const userDataDirArg = args.find((arg) => arg.startsWith("-profile") || arg.startsWith("--profile"));
     if (userDataDirArg)

package/lib/server/bidi/bidiNetworkManager.js

@@ -148,7 +148,7 @@ class BidiNetworkManager {
   _onAuthRequired(params) {
     const isBasic = params.response.authChallenges?.some((challenge) => challenge.scheme.startsWith("Basic"));
     const credentials = this._page.browserContext._options.httpCredentials;
-    if (isBasic && credentials) {
+    if (isBasic && credentials && (!credentials.origin || new URL(params.request.url).origin.toLowerCase() === credentials.origin.toLowerCase())) {
       if (this._attemptedAuthentications.has(params.request.request)) {
         this._session.sendMayFail("network.continueWithAuth", {
           request: params.request.request,
@@ -169,7 +169,7 @@ class BidiNetworkManager {
     } else {
       this._session.sendMayFail("network.continueWithAuth", {
         request: params.request.request,
-        action: "default"
+        action: "cancel"
       });
     }
   }

package/lib/server/browserType.js

@@ -169,9 +169,9 @@ class BrowserType extends import_instrumentation.SdkObject {
     if (ignoreAllDefaultArgs)
       browserArguments.push(...args);
     else if (ignoreDefaultArgs)
-      browserArguments.push(...this.defaultArgs(options, isPersistent, userDataDir).filter((arg) => ignoreDefaultArgs.indexOf(arg) === -1));
+      browserArguments.push(...(await this.defaultArgs(options, isPersistent, userDataDir)).filter((arg) => ignoreDefaultArgs.indexOf(arg) === -1));
     else
-      browserArguments.push(...this.defaultArgs(options, isPersistent, userDataDir));
+      browserArguments.push(...await this.defaultArgs(options, isPersistent, userDataDir));
     let executable;
     if (executablePath) {
       if (!await (0, import_fileUtils.existsAsync)(executablePath))
@@ -200,7 +200,7 @@ class BrowserType extends import_instrumentation.SdkObject {
     const { launchedProcess, gracefullyClose, kill } = await (0, import_processLauncher.launchProcess)({
       command: prepared.executable,
       args: prepared.browserArguments,
-      env: this.amendEnvironment(env, prepared.userDataDir, isPersistent),
+      env: this.amendEnvironment(env, prepared.userDataDir, isPersistent, options),
       handleSIGINT,
       handleSIGTERM,
       handleSIGHUP,

package/lib/server/chromium/chromium.js

@@ -250,7 +250,7 @@ class Chromium extends import_browserType.BrowserType {
       throw e;
     }
   }
-  defaultArgs(options, isPersistent, userDataDir) {
+  async defaultArgs(options, isPersistent, userDataDir) {
     const chromeArguments = this._innerDefaultArgs(options);
     chromeArguments.push(`--user-data-dir=${userDataDir}`);
     if (options.cdpPort !== void 0)

package/lib/server/firefox/firefox.js

@@ -67,7 +67,7 @@ Workaround: Set the HOME=/root environment variable${process.env.GITHUB_ACTION ?
     const message = { method: "Browser.close", params: {}, id: import_ffConnection.kBrowserCloseMessageId };
     transport.send(message);
   }
-  defaultArgs(options, isPersistent, userDataDir) {
+  async defaultArgs(options, isPersistent, userDataDir) {
     const { args = [], headless } = options;
     const userDataDirArg = args.find((arg) => arg.startsWith("-profile") || arg.startsWith("--profile"));
     if (userDataDirArg)

package/lib/server/registry/index.js

@@ -749,6 +749,33 @@ ${(0, import_ascii.wrapInASCIIBox)(prettyMessage, 1)}`);
       _dependencyGroup: "webkit",
       _isHermeticInstallation: true
     });
+    this._executables.push({
+      type: "channel",
+      name: "webkit-wsl",
+      browserName: "webkit",
+      directory: webkit.dir,
+      executablePath: () => process.execPath,
+      executablePathOrDie: () => process.execPath,
+      wslExecutablePath: `/home/pwuser/.cache/ms-playwright/webkit-${webkit.revision}/pw_run.sh`,
+      installType: "download-on-demand",
+      _validateHostRequirements: (sdkLanguage) => Promise.resolve(),
+      _isHermeticInstallation: true,
+      _install: async () => {
+        if (process.platform !== "win32")
+          throw new Error(`WebKit via WSL is only supported on Windows`);
+        const script = import_path.default.join(BIN_PATH, "install_webkit_wsl.ps1");
+        const { code } = await (0, import_spawnAsync.spawnAsync)("powershell.exe", [
+          "-ExecutionPolicy",
+          "Bypass",
+          "-File",
+          script
+        ], {
+          stdio: "inherit"
+        });
+        if (code !== 0)
+          throw new Error(`Failed to install WebKit via WSL`);
+      }
+    });
     const ffmpeg = descriptors.find((d) => d.name === "ffmpeg");
     const ffmpegExecutable = findExecutablePath(ffmpeg.dir, "ffmpeg");
     this._executables.push({

package/lib/server/webkit/webkit.js

@@ -28,7 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var webkit_exports = {};
 __export(webkit_exports, {
-  WebKit: () => WebKit
+  WebKit: () => WebKit,
+  translatePathToWSL: () => translatePathToWSL
 });
 module.exports = __toCommonJS(webkit_exports);
 var import_path = __toESM(require("path"));
@@ -36,6 +37,8 @@ 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");
@@ -43,10 +46,11 @@ class WebKit extends import_browserType.BrowserType {
   connectToTransport(transport, options) {
     return import_wkBrowser.WKBrowser.connect(this.attribution.playwright, transport, options);
   }
-  amendEnvironment(env, userDataDir, isPersistent) {
+  amendEnvironment(env, userDataDir, isPersistent, options) {
     return {
       ...env,
-      CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0
+      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) {
@@ -59,7 +63,7 @@ class WebKit extends import_browserType.BrowserType {
   attemptToGracefullyCloseBrowser(transport) {
     transport.send({ method: "Playwright.close", params: {}, id: import_wkConnection.kBrowserCloseMessageId });
   }
-  defaultArgs(options, isPersistent, userDataDir) {
+  async defaultArgs(options, isPersistent, userDataDir) {
     const { args = [], headless } = options;
     const userDataDirArg = args.find((arg) => arg.startsWith("--user-data-dir"));
     if (userDataDirArg)
@@ -67,12 +71,19 @@ class WebKit extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const webkitArguments = ["--inspector-pipe"];
-    if (process.platform === "win32")
+    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=${userDataDir}`);
+      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;
@@ -81,7 +92,7 @@ class WebKit extends import_browserType.BrowserType {
         webkitArguments.push(`--proxy=${proxy.server}`);
         if (proxy.bypass)
           webkitArguments.push(`--proxy-bypass-list=${proxy.bypass}`);
-      } else if (process.platform === "linux") {
+      } 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}`));
@@ -97,7 +108,12 @@ class WebKit extends import_browserType.BrowserType {
     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
+  WebKit,
+  translatePathToWSL
 });

package/lib/server/webkit/wkBrowser.js

@@ -39,6 +39,7 @@ var network = __toESM(require("../network"));
 var import_wkConnection = require("./wkConnection");
 var import_wkPage = require("./wkPage");
 var import_errors = require("../errors");
+var import_webkit = require("./webkit");
 const BROWSER_VERSION = "26.0";
 const DEFAULT_USER_AGENT = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/${BROWSER_VERSION} Safari/605.1.15`;
 class WKBrowser extends import_browser.Browser {
@@ -87,7 +88,7 @@ class WKBrowser extends import_browser.Browser {
     const createOptions = proxy ? {
       // Enable socks5 hostname resolution on Windows.
       // See https://github.com/microsoft/playwright/issues/20451
-      proxyServer: process.platform === "win32" ? proxy.server.replace(/^socks5:\/\//, "socks5h://") : proxy.server,
+      proxyServer: process.platform === "win32" && this.attribution.browser?.options.channel !== "webkit-wsl" ? proxy.server.replace(/^socks5:\/\//, "socks5h://") : proxy.server,
       proxyBypassList: proxy.bypass
     } : void 0;
     const { browserContextId } = await this._browserSession.send("Playwright.createContext", createOptions);
@@ -192,7 +193,7 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
     const promises = [super._initialize()];
     promises.push(this._browser._browserSession.send("Playwright.setDownloadBehavior", {
       behavior: this._options.acceptDownloads === "accept" ? "allow" : "deny",
-      downloadPath: this._browser.options.downloadsPath,
+      downloadPath: this._browser.options.channel === "webkit-wsl" ? await (0, import_webkit.translatePathToWSL)(this._browser.options.downloadsPath) : this._browser.options.downloadsPath,
       browserContextId
     }));
     if (this._options.ignoreHTTPSErrors || this._options.internalIgnoreHTTPSErrors)

package/lib/server/webkit/wkPage.js

@@ -54,6 +54,7 @@ var import_wkInterceptableRequest = require("./wkInterceptableRequest");
 var import_wkProvisionalPage = require("./wkProvisionalPage");
 var import_wkWorkers = require("./wkWorkers");
 var import_debugLogger = require("../utils/debugLogger");
+var import_webkit = require("./webkit");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
 class WKPage {
   constructor(browserContext, pageProxySession, opener) {
@@ -769,7 +770,7 @@ class WKPage {
   async _startVideo(options) {
     (0, import_utils.assert)(!this._recordingVideoFile);
     const { screencastId } = await this._pageProxySession.send("Screencast.startVideo", {
-      file: options.outputFile,
+      file: this._browserContext._browser.options.channel === "webkit-wsl" ? await (0, import_webkit.translatePathToWSL)(options.outputFile) : options.outputFile,
       width: options.width,
       height: options.height,
       toolbarHeight: this._toolbarHeight()
@@ -889,6 +890,8 @@ class WKPage {
   async setInputFilePaths(handle, paths) {
     const pageProxyId = this._pageProxySession.sessionId;
     const objectId = handle._objectId;
+    if (this._browserContext._browser?.options.channel === "webkit-wsl")
+      paths = await Promise.all(paths.map((path2) => (0, import_webkit.translatePathToWSL)(path2)));
     await Promise.all([
       this._pageProxySession.connection.browserSession.send("Playwright.grantFileReadAccess", { pageProxyId, paths }),
       this._session.send("DOM.setInputFiles", { objectId, paths })

package/lib/server/webkit/wsl/webkit-wsl-transport-client.js

@@ -0,0 +1,74 @@
+"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 __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 import_net = __toESM(require("net"));
+var import_fs = __toESM(require("fs"));
+var import_child_process = require("child_process");
+(async () => {
+  const { PW_WSL_BRIDGE_PORT: socketPort, ...childEnv } = process.env;
+  if (!socketPort)
+    throw new Error("PW_WSL_BRIDGE_PORT env var is not set");
+  const [executable, ...args] = process.argv.slice(2);
+  if (!(await import_fs.default.promises.stat(executable)).isFile())
+    throw new Error(`Executable does not exist. Did you update Playwright recently? Make sure to run npx playwright install webkit-wsl`);
+  const address = (() => {
+    const res = (0, import_child_process.spawnSync)("/usr/bin/wslinfo", ["--networking-mode"], { encoding: "utf8" });
+    if (res.error || res.status !== 0)
+      throw new Error(`Failed to run /usr/bin/wslinfo --networking-mode: ${res.error?.message || res.stderr || res.status}`);
+    if (res.stdout.trim() === "nat") {
+      const ipRes = (0, import_child_process.spawnSync)("/usr/sbin/ip", ["route", "show"], { encoding: "utf8" });
+      if (ipRes.error || ipRes.status !== 0)
+        throw new Error(`Failed to run ip route show: ${ipRes.error?.message || ipRes.stderr || ipRes.status}`);
+      const ip = ipRes.stdout.trim().split("\n").find((line) => line.includes("default"))?.split(" ")[2];
+      if (!ip)
+        throw new Error("Could not determine WSL IP address (NAT mode).");
+      return ip;
+    }
+    return "127.0.0.1";
+  })();
+  const socket = import_net.default.createConnection(parseInt(socketPort, 10), address);
+  socket.setNoDelay(true);
+  await new Promise((resolve, reject) => {
+    socket.on("connect", resolve);
+    socket.on("error", reject);
+  });
+  const child = (0, import_child_process.spawn)(executable, args, {
+    stdio: ["inherit", "inherit", "inherit", "pipe", "pipe"],
+    env: childEnv
+  });
+  const [childOutput, childInput] = [child.stdio[3], child.stdio[4]];
+  socket.pipe(childOutput);
+  childInput.pipe(socket);
+  socket.on("end", () => child.kill());
+  child.on("exit", (exitCode) => {
+    socket.end();
+    process.exit(exitCode || 0);
+  });
+  await new Promise((resolve, reject) => {
+    child.on("exit", resolve);
+    child.on("error", reject);
+  });
+})().catch((error) => {
+  console.error("Error occurred:", error);
+  process.exit(1);
+});

package/lib/server/webkit/wsl/webkit-wsl-transport-server.js

@@ -0,0 +1,113 @@
+"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 __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 import_net = __toESM(require("net"));
+var import_path = __toESM(require("path"));
+var import_child_process = require("child_process");
+(async () => {
+  const argv = process.argv.slice(2);
+  if (!argv.length) {
+    console.error(`Usage: node ${import_path.default.basename(__filename)} <executable> [args...]`);
+    process.exit(1);
+  }
+  const parentIn = new import_net.default.Socket({ fd: 3, readable: true, writable: false });
+  const parentOut = new import_net.default.Socket({ fd: 4, readable: false, writable: true });
+  const server = import_net.default.createServer();
+  let socket = null;
+  server.on("connection", (s) => {
+    if (socket) {
+      log("Extra connection received, destroying.");
+      socket.destroy();
+      return;
+    }
+    socket = s;
+    socket.setNoDelay(true);
+    log("Client connected, wiring pipes.");
+    socket.pipe(parentOut);
+    parentIn.pipe(socket);
+    socket.on("close", () => {
+      log("Socket closed");
+      socket = null;
+    });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, () => resolve(null));
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    console.error("Failed to obtain listening address");
+    process.exit(1);
+  }
+  const port = address.port;
+  log("Server listening on", port);
+  const env = {
+    ...process.env,
+    // WSLENV is a colon-delimited list of environment variables that should be included when launching WSL processes from Win32 or Win32 processes from WSL
+    WSLENV: "PW_WSL_BRIDGE_PORT",
+    PW_WSL_BRIDGE_PORT: String(port)
+  };
+  let shuttingDown = false;
+  const child = (0, import_child_process.spawn)("wsl.exe", [
+    "-d",
+    "playwright",
+    "--cd",
+    "/home/pwuser",
+    "/home/pwuser/node/bin/node",
+    "/home/pwuser/webkit-wsl-transport-client.js",
+    process.env.WEBKIT_EXECUTABLE || "",
+    ...argv
+  ], {
+    env,
+    stdio: ["inherit", "inherit", "inherit"]
+    // no fd3/fd4 here; they stay only in this wrapper
+  });
+  log("Spawned child pid", child.pid);
+  child.on("close", (code, signal) => {
+    log("Child exit", { code, signal });
+    const exitCode = code ?? (signal ? 128 : 0);
+    shutdown(exitCode);
+  });
+  child.on("error", (err) => {
+    console.error("Child process failed to start:", err);
+    shutdown(1);
+  });
+  await new Promise((resolve) => child.once("close", resolve));
+  async function shutdown(code = 0) {
+    if (shuttingDown)
+      return;
+    shuttingDown = true;
+    server.close();
+    parentIn.destroy();
+    parentOut.destroy();
+    socket?.destroy();
+    await new Promise((resolve) => server.once("close", resolve));
+    process.exit(code);
+  }
+  function log(...args) {
+    console.error(/* @__PURE__ */ new Date(), `[${import_path.default.basename(__filename)}]`, ...args);
+  }
+})().catch((error) => {
+  console.error("Error occurred:", error);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright-core",
-  "version": "1.56.0-alpha-2025-09-09",
+  "version": "1.56.0-alpha-1757456950000",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",