patchright-core 1.57.0 → 1.59.0

package/lib/tools/utils/mcp/server.js

@@ -0,0 +1,230 @@
+"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 server_exports = {};
+__export(server_exports, {
+  allRootPaths: () => allRootPaths,
+  connect: () => connect,
+  createServer: () => createServer,
+  firstRootPath: () => firstRootPath,
+  start: () => start
+});
+module.exports = __toCommonJS(server_exports);
+var import_url = require("url");
+var import_utilsBundle = require("../../../utilsBundle");
+var mcpBundle = __toESM(require("../../../mcpBundle"));
+var import_http = require("./http");
+var import_tool = require("./tool");
+const serverDebug = (0, import_utilsBundle.debug)("pw:mcp:server");
+const serverDebugResponse = (0, import_utilsBundle.debug)("pw:mcp:server:response");
+class BackendManager {
+  constructor() {
+    this._backends = /* @__PURE__ */ new Map();
+  }
+  async createBackend(factory, clientInfo) {
+    const backend = await factory.create(clientInfo);
+    await backend.initialize?.(clientInfo);
+    this._backends.set(backend, factory);
+    return backend;
+  }
+  async disposeBackend(backend) {
+    const factory = this._backends.get(backend);
+    if (!factory)
+      return;
+    await backend.dispose?.();
+    await factory.disposed(backend).catch(serverDebug);
+    this._backends.delete(backend);
+  }
+}
+const backendManager = new BackendManager();
+async function connect(factory, transport, runHeartbeat) {
+  const server = createServer(factory.name, factory.version, factory, runHeartbeat);
+  await server.connect(transport);
+}
+function createServer(name, version, factory, runHeartbeat) {
+  const server = new mcpBundle.Server({ name, version }, {
+    capabilities: {
+      tools: {}
+    }
+  });
+  server.setRequestHandler(mcpBundle.ListToolsRequestSchema, async () => {
+    serverDebug("listTools");
+    return { tools: factory.toolSchemas.map((s) => (0, import_tool.toMcpTool)(s)) };
+  });
+  let backendPromise;
+  const onClose = () => backendPromise?.then((b) => backendManager.disposeBackend(b)).catch(serverDebug);
+  addServerListener(server, "close", onClose);
+  server.setRequestHandler(mcpBundle.CallToolRequestSchema, async (request, extra) => {
+    serverDebug("callTool", request);
+    const progressToken = request.params._meta?.progressToken;
+    let progressCounter = 0;
+    const progress = progressToken ? (params) => {
+      extra.sendNotification({
+        method: "notifications/progress",
+        params: {
+          progressToken,
+          progress: params.progress ?? ++progressCounter,
+          total: params.total,
+          message: params.message
+        }
+      }).catch((e) => serverDebug("notification", e));
+    } : () => {
+    };
+    try {
+      if (!backendPromise) {
+        backendPromise = initializeServer(server, factory, runHeartbeat).catch((e) => {
+          backendPromise = void 0;
+          throw e;
+        });
+      }
+      const backend = await backendPromise;
+      const toolResult = await backend.callTool(request.params.name, request.params.arguments || {}, progress);
+      if (toolResult.isClose) {
+        await backendManager.disposeBackend(backend).catch(serverDebug);
+        backendPromise = void 0;
+        delete toolResult.isClose;
+      }
+      const mergedResult = mergeTextParts(toolResult);
+      serverDebugResponse("callResult", mergedResult);
+      return mergedResult;
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: "### Error\n" + String(error) }],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+const initializeServer = async (server, factory, runHeartbeat) => {
+  const capabilities = server.getClientCapabilities();
+  let clientRoots = [];
+  if (capabilities?.roots) {
+    const { roots } = await server.listRoots().catch((e) => {
+      serverDebug(e);
+      return { roots: [] };
+    });
+    clientRoots = roots;
+  }
+  const clientInfo = {
+    cwd: firstRootPath(clientRoots)
+  };
+  const backend = await backendManager.createBackend(factory, clientInfo);
+  if (runHeartbeat)
+    startHeartbeat(server);
+  return backend;
+};
+const startHeartbeat = (server) => {
+  const beat = () => {
+    Promise.race([
+      server.ping(),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("ping timeout")), 5e3))
+    ]).then(() => {
+      setTimeout(beat, 3e3);
+    }).catch(() => {
+      void server.close();
+    });
+  };
+  beat();
+};
+function addServerListener(server, event, listener) {
+  const oldListener = server[`on${event}`];
+  server[`on${event}`] = () => {
+    oldListener?.();
+    listener();
+  };
+}
+async function start(serverBackendFactory, options = {}) {
+  if (options.port === void 0) {
+    await connect(serverBackendFactory, new mcpBundle.StdioServerTransport(), false);
+    return;
+  }
+  const url = await (0, import_http.startMcpHttpServer)(options, serverBackendFactory, options.allowedHosts);
+  const mcpConfig = { mcpServers: {} };
+  mcpConfig.mcpServers[serverBackendFactory.nameInConfig] = {
+    url: `${url}/mcp`
+  };
+  const message = [
+    `Listening on ${url}`,
+    "Put this in your client config:",
+    JSON.stringify(mcpConfig, void 0, 2),
+    "For legacy SSE transport support, you can use the /sse endpoint instead."
+  ].join("\n");
+  console.error(message);
+}
+function firstRootPath(roots) {
+  return allRootPaths(roots)[0];
+}
+function allRootPaths(roots) {
+  const paths = [];
+  for (const root of roots) {
+    const url = new URL(root.uri);
+    let rootPath;
+    try {
+      rootPath = (0, import_url.fileURLToPath)(url);
+    } catch (e) {
+      if (e.code === "ERR_INVALID_FILE_URL_PATH" && process.platform === "win32")
+        rootPath = decodeURIComponent(url.pathname);
+    }
+    if (!rootPath)
+      continue;
+    paths.push(rootPath);
+  }
+  if (paths.length === 0)
+    paths.push(process.cwd());
+  return paths;
+}
+function mergeTextParts(result) {
+  const content = [];
+  const testParts = [];
+  for (const part of result.content) {
+    if (part.type === "text") {
+      testParts.push(part.text);
+      continue;
+    }
+    if (testParts.length > 0) {
+      content.push({ type: "text", text: testParts.join("\n") });
+      testParts.length = 0;
+    }
+    content.push(part);
+  }
+  if (testParts.length > 0)
+    content.push({ type: "text", text: testParts.join("\n") });
+  return {
+    ...result,
+    content
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allRootPaths,
+  connect,
+  createServer,
+  firstRootPath,
+  start
+});

package/lib/tools/utils/mcp/tool.js

@@ -0,0 +1,47 @@
+"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 tool_exports = {};
+__export(tool_exports, {
+  defineToolSchema: () => defineToolSchema,
+  toMcpTool: () => toMcpTool
+});
+module.exports = __toCommonJS(tool_exports);
+var import_zodBundle = require("../../../zodBundle");
+function toMcpTool(tool) {
+  const readOnly = tool.type === "readOnly" || tool.type === "assertion";
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: import_zodBundle.z.toJSONSchema(tool.inputSchema),
+    annotations: {
+      title: tool.title,
+      readOnlyHint: readOnly,
+      destructiveHint: !readOnly,
+      openWorldHint: true
+    }
+  };
+}
+function defineToolSchema(tool) {
+  return tool;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineToolSchema,
+  toMcpTool
+});

package/lib/tools/utils/socketConnection.js

@@ -0,0 +1,108 @@
+"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 socketConnection_exports = {};
+__export(socketConnection_exports, {
+  SocketConnection: () => SocketConnection,
+  compareSemver: () => compareSemver
+});
+module.exports = __toCommonJS(socketConnection_exports);
+class SocketConnection {
+  constructor(socket) {
+    this._pendingBuffers = [];
+    this._socket = socket;
+    socket.on("data", (buffer) => this._onData(buffer));
+    socket.on("close", () => {
+      this.onclose?.();
+    });
+    socket.on("error", (e) => console.error(`error: ${e.message}`));
+  }
+  async send(message) {
+    await new Promise((resolve, reject) => {
+      this._socket.write(`${JSON.stringify(message)}
+`, (error) => {
+        if (error)
+          reject(error);
+        else
+          resolve(void 0);
+      });
+    });
+  }
+  close() {
+    this._socket.destroy();
+  }
+  _onData(buffer) {
+    let end = buffer.indexOf("\n");
+    if (end === -1) {
+      this._pendingBuffers.push(buffer);
+      return;
+    }
+    this._pendingBuffers.push(buffer.slice(0, end));
+    const message = Buffer.concat(this._pendingBuffers).toString();
+    this._dispatchMessage(message);
+    let start = end + 1;
+    end = buffer.indexOf("\n", start);
+    while (end !== -1) {
+      const message2 = buffer.toString(void 0, start, end);
+      this._dispatchMessage(message2);
+      start = end + 1;
+      end = buffer.indexOf("\n", start);
+    }
+    this._pendingBuffers = [buffer.slice(start)];
+  }
+  _dispatchMessage(message) {
+    try {
+      this.onmessage?.(JSON.parse(message));
+    } catch (e) {
+      console.error("failed to dispatch message", e);
+    }
+  }
+}
+function compareSemver(a, b) {
+  const aBase = a.replace(/-.*$/, "");
+  const bBase = b.replace(/-.*$/, "");
+  const aParts = aBase.split(".").map(Number);
+  const bParts = bBase.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (aParts[i] > bParts[i])
+      return 1;
+    if (aParts[i] < bParts[i])
+      return -1;
+  }
+  const aTimestamp = parseSuffixTimestamp(a);
+  const bTimestamp = parseSuffixTimestamp(b);
+  if (aTimestamp > bTimestamp)
+    return 1;
+  if (aTimestamp < bTimestamp)
+    return -1;
+  return 0;
+}
+function parseSuffixTimestamp(version) {
+  const match = version.match(/^\d+\.\d+\.\d+-(?:alpha|beta)-(.+)$/);
+  if (!match)
+    return Infinity;
+  const suffix = match[1];
+  if (/^\d{4}-\d{2}-\d{2}$/.test(suffix))
+    return new Date(suffix).getTime();
+  return Number(suffix);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SocketConnection,
+  compareSemver
+});

package/lib/utils/isomorphic/ariaSnapshot.js

@@ -20,12 +20,26 @@ var ariaSnapshot_exports = {};
 __export(ariaSnapshot_exports, {
   KeyParser: () => KeyParser,
   ParserError: () => ParserError,
-  ariaPropsEqual: () => ariaPropsEqual,
+  ariaNodesEqual: () => ariaNodesEqual,
+  findNewNode: () => findNewNode,
+  hasPointerCursor: () => hasPointerCursor,
   parseAriaSnapshot: () => parseAriaSnapshot,
   parseAriaSnapshotUnsafe: () => parseAriaSnapshotUnsafe,
   textValue: () => textValue
 });
 module.exports = __toCommonJS(ariaSnapshot_exports);
+function ariaNodesEqual(a, b) {
+  if (a.role !== b.role || a.name !== b.name)
+    return false;
+  if (!ariaPropsEqual(a, b) || hasPointerCursor(a) !== hasPointerCursor(b))
+    return false;
+  const aKeys = Object.keys(a.props);
+  const bKeys = Object.keys(b.props);
+  return aKeys.length === bKeys.length && aKeys.every((k) => a.props[k] === b.props[k]);
+}
+function hasPointerCursor(ariaNode) {
+  return ariaNode.box.cursor === "pointer";
+}
 function ariaPropsEqual(a, b) {
   return a.active === b.active && a.checked === b.checked && a.disabled === b.disabled && a.expanded === b.expanded && a.selected === b.selected && a.level === b.level && a.pressed === b.pressed;
 }
@@ -386,11 +400,55 @@ class ParserError extends Error {
     this.pos = pos;
   }
 }
+function findNewNode(from, to) {
+  function fillMap(root, map, position) {
+    let size = 1;
+    let childPosition = position + size;
+    for (const child of root.children || []) {
+      if (typeof child === "string") {
+        size++;
+        childPosition++;
+      } else {
+        size += fillMap(child, map, childPosition);
+        childPosition += size;
+      }
+    }
+    if (!["none", "presentation", "fragment", "iframe", "generic"].includes(root.role) && root.name) {
+      let byRole = map.get(root.role);
+      if (!byRole) {
+        byRole = /* @__PURE__ */ new Map();
+        map.set(root.role, byRole);
+      }
+      const existing = byRole.get(root.name);
+      const sizeAndPosition = size * 100 - position;
+      if (!existing || existing.sizeAndPosition < sizeAndPosition)
+        byRole.set(root.name, { node: root, sizeAndPosition });
+    }
+    return size;
+  }
+  const fromMap = /* @__PURE__ */ new Map();
+  if (from)
+    fillMap(from, fromMap, 0);
+  const toMap = /* @__PURE__ */ new Map();
+  fillMap(to, toMap, 0);
+  const result = [];
+  for (const [role, byRole] of toMap) {
+    for (const [name, byName] of byRole) {
+      const inFrom = fromMap.get(role)?.get(name);
+      if (!inFrom)
+        result.push(byName);
+    }
+  }
+  result.sort((a, b) => b.sizeAndPosition - a.sizeAndPosition);
+  return result[0]?.node;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KeyParser,
   ParserError,
-  ariaPropsEqual,
+  ariaNodesEqual,
+  findNewNode,
+  hasPointerCursor,
   parseAriaSnapshot,
   parseAriaSnapshotUnsafe,
   textValue

package/lib/utils/isomorphic/formatUtils.js

@@ -0,0 +1,64 @@
+"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 formatUtils_exports = {};
+__export(formatUtils_exports, {
+  bytesToString: () => bytesToString,
+  msToString: () => msToString
+});
+module.exports = __toCommonJS(formatUtils_exports);
+function msToString(ms) {
+  if (ms < 0 || !isFinite(ms))
+    return "-";
+  if (ms === 0)
+    return "0ms";
+  if (ms < 1e3)
+    return ms.toFixed(0) + "ms";
+  const seconds = ms / 1e3;
+  if (seconds < 60)
+    return seconds.toFixed(1) + "s";
+  const minutes = seconds / 60;
+  if (minutes < 60)
+    return minutes.toFixed(1) + "m";
+  const hours = minutes / 60;
+  if (hours < 24)
+    return hours.toFixed(1) + "h";
+  const days = hours / 24;
+  return days.toFixed(1) + "d";
+}
+function bytesToString(bytes) {
+  if (bytes < 0 || !isFinite(bytes))
+    return "-";
+  if (bytes === 0)
+    return "0";
+  if (bytes < 1e3)
+    return bytes.toFixed(0);
+  const kb = bytes / 1024;
+  if (kb < 1e3)
+    return kb.toFixed(1) + "K";
+  const mb = kb / 1024;
+  if (mb < 1e3)
+    return mb.toFixed(1) + "M";
+  const gb = mb / 1024;
+  return gb.toFixed(1) + "G";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bytesToString,
+  msToString
+});

package/lib/utils/isomorphic/jsonSchema.js

@@ -0,0 +1,89 @@
+"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 jsonSchema_exports = {};
+__export(jsonSchema_exports, {
+  validate: () => validate
+});
+module.exports = __toCommonJS(jsonSchema_exports);
+const regexCache = /* @__PURE__ */ new Map();
+function validate(value, schema, path) {
+  const errors = [];
+  if (schema.oneOf) {
+    let bestErrors;
+    for (const variant of schema.oneOf) {
+      const variantErrors = validate(value, variant, path);
+      if (variantErrors.length === 0)
+        return [];
+      if (!bestErrors || variantErrors.length < bestErrors.length)
+        bestErrors = variantErrors;
+    }
+    if (bestErrors.length === 1 && bestErrors[0].startsWith(`${path}: expected `))
+      return [`${path}: does not match any of the expected types`];
+    return bestErrors;
+  }
+  if (schema.type === "string") {
+    if (typeof value !== "string") {
+      errors.push(`${path}: expected string, got ${typeof value}`);
+      return errors;
+    }
+    if (schema.pattern && !cachedRegex(schema.pattern).test(value))
+      errors.push(schema.patternError || `${path}: must match pattern "${schema.pattern}"`);
+    return errors;
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(value)) {
+      errors.push(`${path}: expected array, got ${typeof value}`);
+      return errors;
+    }
+    if (schema.items) {
+      for (let i = 0; i < value.length; i++)
+        errors.push(...validate(value[i], schema.items, `${path}[${i}]`));
+    }
+    return errors;
+  }
+  if (schema.type === "object") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      errors.push(`${path}: expected object, got ${Array.isArray(value) ? "array" : typeof value}`);
+      return errors;
+    }
+    const obj = value;
+    for (const key of schema.required || []) {
+      if (obj[key] === void 0)
+        errors.push(`${path}.${key}: required`);
+    }
+    for (const [key, propSchema] of Object.entries(schema.properties || {})) {
+      if (obj[key] !== void 0)
+        errors.push(...validate(obj[key], propSchema, `${path}.${key}`));
+    }
+    return errors;
+  }
+  return errors;
+}
+function cachedRegex(pattern) {
+  let regex = regexCache.get(pattern);
+  if (!regex) {
+    regex = new RegExp(pattern);
+    regexCache.set(pattern, regex);
+  }
+  return regex;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validate
+});

package/lib/utils/isomorphic/lruCache.js

@@ -0,0 +1,51 @@
+"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 lruCache_exports = {};
+__export(lruCache_exports, {
+  LRUCache: () => LRUCache
+});
+module.exports = __toCommonJS(lruCache_exports);
+class LRUCache {
+  constructor(maxSize) {
+    this._maxSize = maxSize;
+    this._map = /* @__PURE__ */ new Map();
+    this._size = 0;
+  }
+  getOrCompute(key, compute) {
+    if (this._map.has(key)) {
+      const result2 = this._map.get(key);
+      this._map.delete(key);
+      this._map.set(key, result2);
+      return result2.value;
+    }
+    const result = compute();
+    while (this._map.size && this._size + result.size > this._maxSize) {
+      const [firstKey, firstValue] = this._map.entries().next().value;
+      this._size -= firstValue.size;
+      this._map.delete(firstKey);
+    }
+    this._map.set(key, result);
+    this._size += result.size;
+    return result.value;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LRUCache
+});