patchright-bun-core 1.58.0

package/lib/server/trace/viewer/traceViewer.js

@@ -0,0 +1,245 @@
+"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 traceViewer_exports = {};
+__export(traceViewer_exports, {
+  installRootRedirect: () => installRootRedirect,
+  openTraceInBrowser: () => openTraceInBrowser,
+  openTraceViewerApp: () => openTraceViewerApp,
+  runTraceInBrowser: () => runTraceInBrowser,
+  runTraceViewerApp: () => runTraceViewerApp,
+  startTraceViewerServer: () => startTraceViewerServer
+});
+module.exports = __toCommonJS(traceViewer_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("../../../utils");
+var import_utils2 = require("../../../utils");
+var import_httpServer = require("../../utils/httpServer");
+var import_utilsBundle = require("../../../utilsBundle");
+var import_launchApp = require("../../launchApp");
+var import_launchApp2 = require("../../launchApp");
+var import_playwright = require("../../playwright");
+var import_progress = require("../../progress");
+const tracesDirMarker = "traces.dir";
+function validateTraceUrl(traceFileOrUrl) {
+  if (!traceFileOrUrl)
+    return traceFileOrUrl;
+  if (traceFileOrUrl.startsWith("http://") || traceFileOrUrl.startsWith("https://"))
+    return traceFileOrUrl;
+  let traceFile = traceFileOrUrl;
+  if (traceFile.endsWith(".json"))
+    return toFilePathUrl(traceFile);
+  try {
+    const stat = import_fs.default.statSync(traceFile);
+    if (stat.isDirectory())
+      traceFile = import_path.default.join(traceFile, tracesDirMarker);
+    return toFilePathUrl(traceFile);
+  } catch {
+    throw new Error(`Trace file ${traceFileOrUrl} does not exist!`);
+  }
+}
+async function startTraceViewerServer(options) {
+  const server = new import_httpServer.HttpServer();
+  server.routePrefix("/trace", (request, response) => {
+    const url = new URL("http://localhost" + request.url);
+    const relativePath = url.pathname.slice("/trace".length);
+    if (relativePath.startsWith("/file")) {
+      try {
+        const filePath = url.searchParams.get("path");
+        if (import_fs.default.existsSync(filePath))
+          return server.serveFile(request, response, url.searchParams.get("path"));
+        if (filePath.endsWith(".json")) {
+          const fullPrefix = filePath.substring(0, filePath.length - ".json".length);
+          return sendTraceDescriptor(response, import_path.default.dirname(fullPrefix), import_path.default.basename(fullPrefix));
+        }
+        if (filePath.endsWith(tracesDirMarker))
+          return sendTraceDescriptor(response, import_path.default.dirname(filePath));
+      } catch {
+      }
+      response.statusCode = 404;
+      response.end();
+      return true;
+    }
+    const absolutePath = import_path.default.join(__dirname, "..", "..", "..", "vite", "traceViewer", ...relativePath.split("/"));
+    return server.serveFile(request, response, absolutePath);
+  });
+  const transport = options?.transport || (options?.isServer ? new StdinServer() : void 0);
+  if (transport)
+    server.createWebSocket(transport);
+  const { host, port } = options || {};
+  await server.start({ preferredPort: port, host });
+  return server;
+}
+async function installRootRedirect(server, traceUrl, options) {
+  const params = new URLSearchParams();
+  if (import_path.default.sep !== import_path.default.posix.sep)
+    params.set("pathSeparator", import_path.default.sep);
+  if (traceUrl)
+    params.append("trace", traceUrl);
+  if (server.wsGuid())
+    params.append("ws", server.wsGuid());
+  if (options?.isServer)
+    params.append("isServer", "");
+  if ((0, import_utils2.isUnderTest)())
+    params.append("isUnderTest", "true");
+  for (const arg of options.args || [])
+    params.append("arg", arg);
+  if (options.grep)
+    params.append("grep", options.grep);
+  if (options.grepInvert)
+    params.append("grepInvert", options.grepInvert);
+  for (const project of options.project || [])
+    params.append("project", project);
+  for (const reporter of options.reporter || [])
+    params.append("reporter", reporter);
+  const urlPath = `./trace/${options.webApp || "index.html"}?${params.toString()}`;
+  server.routePath("/", (_, response) => {
+    response.statusCode = 302;
+    response.setHeader("Location", urlPath);
+    response.end();
+    return true;
+  });
+}
+async function runTraceViewerApp(traceUrl, browserName, options, exitOnClose) {
+  traceUrl = validateTraceUrl(traceUrl);
+  const server = await startTraceViewerServer(options);
+  await installRootRedirect(server, traceUrl, options);
+  const page = await openTraceViewerApp(server.urlPrefix("precise"), browserName, options);
+  if (exitOnClose)
+    page.on("close", () => (0, import_utils.gracefullyProcessExitDoNotHang)(0));
+  return page;
+}
+async function runTraceInBrowser(traceUrl, options) {
+  traceUrl = validateTraceUrl(traceUrl);
+  const server = await startTraceViewerServer(options);
+  await installRootRedirect(server, traceUrl, options);
+  await openTraceInBrowser(server.urlPrefix("human-readable"));
+}
+async function openTraceViewerApp(url, browserName, options) {
+  const traceViewerPlaywright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isInternalPlaywright: true });
+  const traceViewerBrowser = (0, import_utils2.isUnderTest)() ? "chromium" : browserName;
+  const { context, page } = await (0, import_launchApp2.launchApp)(traceViewerPlaywright[traceViewerBrowser], {
+    sdkLanguage: traceViewerPlaywright.options.sdkLanguage,
+    windowSize: { width: 1280, height: 800 },
+    persistentContextOptions: {
+      ...options?.persistentContextOptions,
+      cdpPort: (0, import_utils2.isUnderTest)() ? 0 : void 0,
+      headless: !!options?.headless,
+      colorScheme: (0, import_utils2.isUnderTest)() ? "light" : void 0
+    }
+  });
+  const controller = new import_progress.ProgressController();
+  await controller.run(async (progress) => {
+    await context._browser._defaultContext._loadDefaultContextAsIs(progress);
+    if (process.env.PWTEST_PRINT_WS_ENDPOINT) {
+      process.stderr.write("DevTools listening on: " + context._browser.options.wsEndpoint + "\n");
+    }
+    if (!(0, import_utils2.isUnderTest)())
+      await (0, import_launchApp.syncLocalStorageWithSettings)(page, "traceviewer");
+    if ((0, import_utils2.isUnderTest)())
+      page.on("close", () => context.close({ reason: "Trace viewer closed" }).catch(() => {
+      }));
+    await page.mainFrame().goto(progress, url);
+  });
+  return page;
+}
+async function openTraceInBrowser(url) {
+  console.log("\nListening on " + url);
+  if (!(0, import_utils2.isUnderTest)())
+    await (0, import_utilsBundle.open)(url.replace("0.0.0.0", "localhost")).catch(() => {
+    });
+}
+class StdinServer {
+  constructor() {
+    process.stdin.on("data", (data) => {
+      const url = data.toString().trim();
+      if (url === this._traceUrl)
+        return;
+      if (url.endsWith(".json"))
+        this._pollLoadTrace(url);
+      else
+        this._loadTrace(url);
+    });
+    process.stdin.on("close", () => (0, import_utils.gracefullyProcessExitDoNotHang)(0));
+  }
+  onconnect() {
+  }
+  async dispatch(method, params) {
+    if (method === "initialize") {
+      if (this._traceUrl)
+        this._loadTrace(this._traceUrl);
+    }
+  }
+  onclose() {
+  }
+  _loadTrace(traceUrl) {
+    this._traceUrl = traceUrl;
+    clearTimeout(this._pollTimer);
+    this.sendEvent?.("loadTraceRequested", { traceUrl });
+  }
+  _pollLoadTrace(url) {
+    this._loadTrace(url);
+    this._pollTimer = setTimeout(() => {
+      this._pollLoadTrace(url);
+    }, 500);
+  }
+}
+function sendTraceDescriptor(response, traceDir, tracePrefix) {
+  response.statusCode = 200;
+  response.setHeader("Content-Type", "application/json");
+  response.end(JSON.stringify(traceDescriptor(traceDir, tracePrefix)));
+  return true;
+}
+function traceDescriptor(traceDir, tracePrefix) {
+  const result = {
+    entries: []
+  };
+  for (const name of import_fs.default.readdirSync(traceDir)) {
+    if (!tracePrefix || name.startsWith(tracePrefix))
+      result.entries.push({ name, path: toFilePathUrl(import_path.default.join(traceDir, name)) });
+  }
+  const resourcesDir = import_path.default.join(traceDir, "resources");
+  if (import_fs.default.existsSync(resourcesDir)) {
+    for (const name of import_fs.default.readdirSync(resourcesDir))
+      result.entries.push({ name: "resources/" + name, path: toFilePathUrl(import_path.default.join(resourcesDir, name)) });
+  }
+  return result;
+}
+function toFilePathUrl(filePath) {
+  return `file?path=${encodeURIComponent(filePath)}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installRootRedirect,
+  openTraceInBrowser,
+  openTraceViewerApp,
+  runTraceInBrowser,
+  runTraceViewerApp,
+  startTraceViewerServer
+});

package/lib/server/transport.js

@@ -0,0 +1,254 @@
+"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 transport_exports = {};
+__export(transport_exports, {
+  WebSocketTransport: () => WebSocketTransport,
+  perMessageDeflate: () => perMessageDeflate
+});
+module.exports = __toCommonJS(transport_exports);
+var import_utils = require("../utils");
+var import_happyEyeballs = require("./utils/happyEyeballs");
+var import_utilsBundle = require("../utilsBundle");
+class BunWsAdapter {
+  constructor(url, _protocols, _opts) {
+    this.readyState = 0;
+    this._listeners = {};
+    const raw = new globalThis.WebSocket(url);
+    raw.binaryType = "arraybuffer";
+    this._rawWs = raw;
+    raw.onopen = () => {
+      this.readyState = 1;
+      this._emit("open");
+    };
+    raw.onclose = (e) => {
+      this.readyState = 3;
+      this._emit("close", { code: e.code, reason: e.reason });
+    };
+    raw.onerror = () => {
+      this._emit("error", { message: "WebSocket error", type: "error" });
+    };
+    raw.onmessage = (e) => {
+      this._emit("message", { data: e.data });
+    };
+  }
+  static {
+    this.CONNECTING = 0;
+  }
+  static {
+    this.OPEN = 1;
+  }
+  static {
+    this.CLOSING = 2;
+  }
+  static {
+    this.CLOSED = 3;
+  }
+  _emit(event, ...args) {
+    const listeners = this._listeners[event];
+    if (!listeners) return;
+    for (let i = 0; i < listeners.length; i++) {
+      const entry = listeners[i];
+      entry.fn(...args);
+      if (entry.once) {
+        listeners.splice(i, 1);
+        i--;
+      }
+    }
+  }
+  on(event, fn) {
+    (this._listeners[event] ??= []).push({ fn, once: false });
+    return this;
+  }
+  once(event, fn) {
+    (this._listeners[event] ??= []).push({ fn, once: true });
+    return this;
+  }
+  off(event, fn) {
+    const listeners = this._listeners[event];
+    if (listeners) this._listeners[event] = listeners.filter((e) => e.fn !== fn);
+    return this;
+  }
+  addEventListener(event, fn) {
+    return this.on(event, fn);
+  }
+  removeEventListener(event, fn) {
+    return this.off(event, fn);
+  }
+  send(data) {
+    this._rawWs.send(data);
+  }
+  close(code, reason) {
+    this._rawWs.close(code, reason);
+  }
+}
+const _useBunWs = typeof globalThis.WebSocket !== "undefined" && typeof globalThis.Bun !== "undefined";
+const perMessageDeflate = {
+  clientNoContextTakeover: true,
+  zlibDeflateOptions: {
+    level: 3
+  },
+  zlibInflateOptions: {
+    chunkSize: 10 * 1024
+  },
+  threshold: 10 * 1024
+};
+class WebSocketTransport {
+  constructor(progress, url, logUrl, options) {
+    this.headers = [];
+    this.wsEndpoint = url;
+    this._logUrl = logUrl;
+    this._ws = new (_useBunWs ? BunWsAdapter : import_utilsBundle.ws)(url, [], {
+      maxPayload: 256 * 1024 * 1024,
+      // 256Mb,
+      headers: options.headers,
+      followRedirects: options.followRedirects,
+      agent: /^(https|wss):\/\//.test(url) ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent,
+      perMessageDeflate
+    });
+    this._ws.on("upgrade", (response) => {
+      for (let i = 0; i < response.rawHeaders.length; i += 2) {
+        this.headers.push({ name: response.rawHeaders[i], value: response.rawHeaders[i + 1] });
+        if (options.debugLogHeader && response.rawHeaders[i] === options.debugLogHeader)
+          progress?.log(response.rawHeaders[i + 1]);
+      }
+    });
+    this._progress = progress;
+    const messageWrap = (0, import_utils.makeWaitForNextTask)();
+    this._ws.addEventListener("message", (event) => {
+      messageWrap(() => {
+        const eventData = event.data;
+        let parsedJson;
+        try {
+          parsedJson = JSON.parse(eventData);
+        } catch (e) {
+          this._progress?.log(`<closing ws> Closing websocket due to malformed JSON. eventData=${eventData} e=${e?.message}`);
+          this._ws.close();
+          return;
+        }
+        try {
+          if (this.onmessage)
+            this.onmessage.call(null, parsedJson);
+        } catch (e) {
+          this._progress?.log(`<closing ws> Closing websocket due to failed onmessage callback. eventData=${eventData} e=${e?.message}`);
+          this._ws.close();
+        }
+      });
+    });
+    this._ws.addEventListener("close", (event) => {
+      this._progress?.log(`<ws disconnected> ${logUrl} code=${event.code} reason=${event.reason}`);
+      if (this.onclose)
+        this.onclose.call(null, event.reason);
+    });
+    this._ws.addEventListener("error", (error) => this._progress?.log(`<ws error> ${logUrl} ${error.type} ${error.message}`));
+  }
+  static async connect(progress, url, options = {}) {
+    return await WebSocketTransport._connect(
+      progress,
+      url,
+      options,
+      false
+      /* hadRedirects */
+    );
+  }
+  static async _connect(progress, url, options, hadRedirects) {
+    const logUrl = stripQueryParams(url);
+    progress?.log(`<ws connecting> ${logUrl}`);
+    const transport = new WebSocketTransport(progress, url, logUrl, { ...options, followRedirects: !!options.followRedirects && hadRedirects });
+    const resultPromise = new Promise((fulfill, reject) => {
+      transport._ws.on("open", async () => {
+        progress?.log(`<ws connected> ${logUrl}`);
+        fulfill({});
+      });
+      transport._ws.on("error", (event) => {
+        progress?.log(`<ws connect error> ${logUrl} ${event.message}`);
+        reject(new Error("WebSocket error: " + event.message));
+        transport._ws.close();
+      });
+      transport._ws.on("unexpected-response", (request, response) => {
+        if (options.followRedirects && !hadRedirects && (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 307 || response.statusCode === 308)) {
+          fulfill({ redirect: response });
+          transport._ws.close();
+          return;
+        }
+        for (let i = 0; i < response.rawHeaders.length; i += 2) {
+          if (options.debugLogHeader && response.rawHeaders[i] === options.debugLogHeader)
+            progress?.log(response.rawHeaders[i + 1]);
+        }
+        const chunks = [];
+        const errorPrefix = `${logUrl} ${response.statusCode} ${response.statusMessage}`;
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("close", () => {
+          const error = chunks.length ? `${errorPrefix}
+${Buffer.concat(chunks)}` : errorPrefix;
+          progress?.log(`<ws unexpected response> ${error}`);
+          reject(new Error("WebSocket error: " + error));
+          transport._ws.close();
+        });
+      });
+    });
+    try {
+      const result = progress ? await progress.race(resultPromise) : await resultPromise;
+      if (result.redirect) {
+        const newHeaders = Object.fromEntries(Object.entries(options.headers || {}).filter(([name]) => {
+          return !name.includes("access-key") && name.toLowerCase() !== "authorization";
+        }));
+        return WebSocketTransport._connect(
+          progress,
+          result.redirect.headers.location,
+          { ...options, headers: newHeaders },
+          true
+          /* hadRedirects */
+        );
+      }
+      return transport;
+    } catch (error) {
+      await transport.closeAndWait();
+      throw error;
+    }
+  }
+  send(message) {
+    this._ws.send(JSON.stringify(message));
+  }
+  close() {
+    this._progress?.log(`<ws disconnecting> ${this._logUrl}`);
+    this._ws.close();
+  }
+  async closeAndWait() {
+    if (this._ws.readyState === (_useBunWs ? BunWsAdapter : import_utilsBundle.ws).CLOSED)
+      return;
+    const promise = new Promise((f) => this._ws.once("close", f));
+    this.close();
+    await promise;
+  }
+}
+function stripQueryParams(url) {
+  try {
+    const u = new URL(url);
+    u.search = "";
+    u.hash = "";
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebSocketTransport,
+  perMessageDeflate
+});

package/lib/server/types.js

@@ -0,0 +1,28 @@
+"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 types_exports = {};
+__export(types_exports, {
+  kLifecycleEvents: () => kLifecycleEvents
+});
+module.exports = __toCommonJS(types_exports);
+const kLifecycleEvents = /* @__PURE__ */ new Set(["load", "domcontentloaded", "networkidle", "commit"]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  kLifecycleEvents
+});

package/lib/server/usKeyboardLayout.js

@@ -0,0 +1,145 @@
+"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 usKeyboardLayout_exports = {};
+__export(usKeyboardLayout_exports, {
+  USKeyboardLayout: () => USKeyboardLayout,
+  keypadLocation: () => keypadLocation
+});
+module.exports = __toCommonJS(usKeyboardLayout_exports);
+const keypadLocation = 3;
+const USKeyboardLayout = {
+  // Functions row
+  "Escape": { "keyCode": 27, "key": "Escape" },
+  "F1": { "keyCode": 112, "key": "F1" },
+  "F2": { "keyCode": 113, "key": "F2" },
+  "F3": { "keyCode": 114, "key": "F3" },
+  "F4": { "keyCode": 115, "key": "F4" },
+  "F5": { "keyCode": 116, "key": "F5" },
+  "F6": { "keyCode": 117, "key": "F6" },
+  "F7": { "keyCode": 118, "key": "F7" },
+  "F8": { "keyCode": 119, "key": "F8" },
+  "F9": { "keyCode": 120, "key": "F9" },
+  "F10": { "keyCode": 121, "key": "F10" },
+  "F11": { "keyCode": 122, "key": "F11" },
+  "F12": { "keyCode": 123, "key": "F12" },
+  // Numbers row
+  "Backquote": { "keyCode": 192, "shiftKey": "~", "key": "`" },
+  "Digit1": { "keyCode": 49, "shiftKey": "!", "key": "1" },
+  "Digit2": { "keyCode": 50, "shiftKey": "@", "key": "2" },
+  "Digit3": { "keyCode": 51, "shiftKey": "#", "key": "3" },
+  "Digit4": { "keyCode": 52, "shiftKey": "$", "key": "4" },
+  "Digit5": { "keyCode": 53, "shiftKey": "%", "key": "5" },
+  "Digit6": { "keyCode": 54, "shiftKey": "^", "key": "6" },
+  "Digit7": { "keyCode": 55, "shiftKey": "&", "key": "7" },
+  "Digit8": { "keyCode": 56, "shiftKey": "*", "key": "8" },
+  "Digit9": { "keyCode": 57, "shiftKey": "(", "key": "9" },
+  "Digit0": { "keyCode": 48, "shiftKey": ")", "key": "0" },
+  "Minus": { "keyCode": 189, "shiftKey": "_", "key": "-" },
+  "Equal": { "keyCode": 187, "shiftKey": "+", "key": "=" },
+  "Backslash": { "keyCode": 220, "shiftKey": "|", "key": "\\" },
+  "Backspace": { "keyCode": 8, "key": "Backspace" },
+  // First row
+  "Tab": { "keyCode": 9, "key": "Tab" },
+  "KeyQ": { "keyCode": 81, "shiftKey": "Q", "key": "q" },
+  "KeyW": { "keyCode": 87, "shiftKey": "W", "key": "w" },
+  "KeyE": { "keyCode": 69, "shiftKey": "E", "key": "e" },
+  "KeyR": { "keyCode": 82, "shiftKey": "R", "key": "r" },
+  "KeyT": { "keyCode": 84, "shiftKey": "T", "key": "t" },
+  "KeyY": { "keyCode": 89, "shiftKey": "Y", "key": "y" },
+  "KeyU": { "keyCode": 85, "shiftKey": "U", "key": "u" },
+  "KeyI": { "keyCode": 73, "shiftKey": "I", "key": "i" },
+  "KeyO": { "keyCode": 79, "shiftKey": "O", "key": "o" },
+  "KeyP": { "keyCode": 80, "shiftKey": "P", "key": "p" },
+  "BracketLeft": { "keyCode": 219, "shiftKey": "{", "key": "[" },
+  "BracketRight": { "keyCode": 221, "shiftKey": "}", "key": "]" },
+  // Second row
+  "CapsLock": { "keyCode": 20, "key": "CapsLock" },
+  "KeyA": { "keyCode": 65, "shiftKey": "A", "key": "a" },
+  "KeyS": { "keyCode": 83, "shiftKey": "S", "key": "s" },
+  "KeyD": { "keyCode": 68, "shiftKey": "D", "key": "d" },
+  "KeyF": { "keyCode": 70, "shiftKey": "F", "key": "f" },
+  "KeyG": { "keyCode": 71, "shiftKey": "G", "key": "g" },
+  "KeyH": { "keyCode": 72, "shiftKey": "H", "key": "h" },
+  "KeyJ": { "keyCode": 74, "shiftKey": "J", "key": "j" },
+  "KeyK": { "keyCode": 75, "shiftKey": "K", "key": "k" },
+  "KeyL": { "keyCode": 76, "shiftKey": "L", "key": "l" },
+  "Semicolon": { "keyCode": 186, "shiftKey": ":", "key": ";" },
+  "Quote": { "keyCode": 222, "shiftKey": '"', "key": "'" },
+  "Enter": { "keyCode": 13, "key": "Enter", "text": "\r" },
+  // Third row
+  "ShiftLeft": { "keyCode": 160, "keyCodeWithoutLocation": 16, "key": "Shift", "location": 1 },
+  "KeyZ": { "keyCode": 90, "shiftKey": "Z", "key": "z" },
+  "KeyX": { "keyCode": 88, "shiftKey": "X", "key": "x" },
+  "KeyC": { "keyCode": 67, "shiftKey": "C", "key": "c" },
+  "KeyV": { "keyCode": 86, "shiftKey": "V", "key": "v" },
+  "KeyB": { "keyCode": 66, "shiftKey": "B", "key": "b" },
+  "KeyN": { "keyCode": 78, "shiftKey": "N", "key": "n" },
+  "KeyM": { "keyCode": 77, "shiftKey": "M", "key": "m" },
+  "Comma": { "keyCode": 188, "shiftKey": "<", "key": "," },
+  "Period": { "keyCode": 190, "shiftKey": ">", "key": "." },
+  "Slash": { "keyCode": 191, "shiftKey": "?", "key": "/" },
+  "ShiftRight": { "keyCode": 161, "keyCodeWithoutLocation": 16, "key": "Shift", "location": 2 },
+  // Last row
+  "ControlLeft": { "keyCode": 162, "keyCodeWithoutLocation": 17, "key": "Control", "location": 1 },
+  "MetaLeft": { "keyCode": 91, "key": "Meta", "location": 1 },
+  "AltLeft": { "keyCode": 164, "keyCodeWithoutLocation": 18, "key": "Alt", "location": 1 },
+  "Space": { "keyCode": 32, "key": " " },
+  "AltRight": { "keyCode": 165, "keyCodeWithoutLocation": 18, "key": "Alt", "location": 2 },
+  "AltGraph": { "keyCode": 225, "key": "AltGraph" },
+  "MetaRight": { "keyCode": 92, "key": "Meta", "location": 2 },
+  "ContextMenu": { "keyCode": 93, "key": "ContextMenu" },
+  "ControlRight": { "keyCode": 163, "keyCodeWithoutLocation": 17, "key": "Control", "location": 2 },
+  // Center block
+  "PrintScreen": { "keyCode": 44, "key": "PrintScreen" },
+  "ScrollLock": { "keyCode": 145, "key": "ScrollLock" },
+  "Pause": { "keyCode": 19, "key": "Pause" },
+  "PageUp": { "keyCode": 33, "key": "PageUp" },
+  "PageDown": { "keyCode": 34, "key": "PageDown" },
+  "Insert": { "keyCode": 45, "key": "Insert" },
+  "Delete": { "keyCode": 46, "key": "Delete" },
+  "Home": { "keyCode": 36, "key": "Home" },
+  "End": { "keyCode": 35, "key": "End" },
+  "ArrowLeft": { "keyCode": 37, "key": "ArrowLeft" },
+  "ArrowUp": { "keyCode": 38, "key": "ArrowUp" },
+  "ArrowRight": { "keyCode": 39, "key": "ArrowRight" },
+  "ArrowDown": { "keyCode": 40, "key": "ArrowDown" },
+  // Numpad
+  "NumLock": { "keyCode": 144, "key": "NumLock" },
+  "NumpadDivide": { "keyCode": 111, "key": "/", "location": 3 },
+  "NumpadMultiply": { "keyCode": 106, "key": "*", "location": 3 },
+  "NumpadSubtract": { "keyCode": 109, "key": "-", "location": 3 },
+  "Numpad7": { "keyCode": 36, "shiftKeyCode": 103, "key": "Home", "shiftKey": "7", "location": 3 },
+  "Numpad8": { "keyCode": 38, "shiftKeyCode": 104, "key": "ArrowUp", "shiftKey": "8", "location": 3 },
+  "Numpad9": { "keyCode": 33, "shiftKeyCode": 105, "key": "PageUp", "shiftKey": "9", "location": 3 },
+  "Numpad4": { "keyCode": 37, "shiftKeyCode": 100, "key": "ArrowLeft", "shiftKey": "4", "location": 3 },
+  "Numpad5": { "keyCode": 12, "shiftKeyCode": 101, "key": "Clear", "shiftKey": "5", "location": 3 },
+  "Numpad6": { "keyCode": 39, "shiftKeyCode": 102, "key": "ArrowRight", "shiftKey": "6", "location": 3 },
+  "NumpadAdd": { "keyCode": 107, "key": "+", "location": 3 },
+  "Numpad1": { "keyCode": 35, "shiftKeyCode": 97, "key": "End", "shiftKey": "1", "location": 3 },
+  "Numpad2": { "keyCode": 40, "shiftKeyCode": 98, "key": "ArrowDown", "shiftKey": "2", "location": 3 },
+  "Numpad3": { "keyCode": 34, "shiftKeyCode": 99, "key": "PageDown", "shiftKey": "3", "location": 3 },
+  "Numpad0": { "keyCode": 45, "shiftKeyCode": 96, "key": "Insert", "shiftKey": "0", "location": 3 },
+  "NumpadDecimal": { "keyCode": 46, "shiftKeyCode": 110, "key": "\0", "shiftKey": ".", "location": 3 },
+  "NumpadEnter": { "keyCode": 13, "key": "Enter", "text": "\r", "location": 3 }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  USKeyboardLayout,
+  keypadLocation
+});