prettier 3.8.5 → 3.9.1

package/internal/legacy-cli.mjs

@@ -18,7 +18,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -368,6 +372,11 @@ var require_vendors = __commonJS({
         env: "AGOLA_GIT_REF",
         pr: "AGOLA_PULL_REQUEST_ID"
       },
+      {
+        name: "Alpic",
+        constant: "ALPIC",
+        env: "ALPIC_HOST"
+      },
       {
         name: "Appcircle",
         constant: "APPCIRCLE",
@@ -820,7 +829,7 @@ var createMethodShim = (methodName, getImplementation) => (flags, object2, ...ar
 function stringOrArrayAt(index) {
   return this[index < 0 ? this.length + index : index];
 }
-var at = createMethodShim("at", function() {
+var at = /* @__PURE__ */ createMethodShim("at", function() {
   if (Array.isArray(this) || typeof this === "string") {
     return stringOrArrayAt;
   }
@@ -1083,7 +1092,7 @@ var stringReplaceAll = String.prototype.replaceAll ?? function(pattern, replacem
   }
   return this.split(pattern).join(replacement);
 };
-var replaceAll = createMethodShim("replaceAll", function() {
+var replaceAll = /* @__PURE__ */ createMethodShim("replaceAll", function() {
   if (typeof this === "string") {
     return stringReplaceAll;
   }
@@ -1233,34 +1242,97 @@ function camelCase(input, options) {
 import fs from "fs/promises";
 import path from "path";
 
-// node_modules/sdbm/index.js
-var textEncoder = new TextEncoder();
-function sdbmHash(input, options) {
-  if (typeof input === "string") {
-    if (options?.bytes) {
-      input = textEncoder.encode(input);
-    } else {
-      let hash3 = 0n;
-      for (let index = 0; index < input.length; index++) {
-        hash3 = BigInt(input.charCodeAt(index)) + (hash3 << 6n) + (hash3 << 16n) - hash3;
-      }
-      return hash3;
+// node_modules/imurmurhash-esm/index.js
+var cache;
+function MurmurHash3(key, seed) {
+  var m = this;
+  if (!(this instanceof MurmurHash3)) {
+    if (!cache) {
+      cache ?? (cache = new MurmurHash3());
     }
-  } else if (!(input instanceof Uint8Array)) {
-    throw new TypeError("Expected a string or Uint8Array");
+    m = cache;
   }
-  let hash2 = 0n;
-  for (const byte of input) {
-    hash2 = BigInt(byte) + (hash2 << 6n) + (hash2 << 16n) - hash2;
+  m.reset(seed);
+  if (typeof key === "string" && key.length > 0) {
+    m.hash(key);
+  }
+  if (m !== this) {
+    return m;
   }
-  return hash2;
-}
-function sdbm(input, options) {
-  return Number(BigInt.asUintN(32, sdbmHash(input, options)));
 }
-sdbm.bigint = function(input, options) {
-  return BigInt.asUintN(64, sdbmHash(input, options));
+MurmurHash3.prototype.hash = function(key) {
+  var h1, k1, i, top, len;
+  len = key.length;
+  this.len += len;
+  k1 = this.k1;
+  i = 0;
+  switch (this.rem) {
+    case 0:
+      k1 ^= len > i ? key.charCodeAt(i++) & 65535 : 0;
+    case 1:
+      k1 ^= len > i ? (key.charCodeAt(i++) & 65535) << 8 : 0;
+    case 2:
+      k1 ^= len > i ? (key.charCodeAt(i++) & 65535) << 16 : 0;
+    case 3:
+      k1 ^= len > i ? (key.charCodeAt(i) & 255) << 24 : 0;
+      k1 ^= len > i ? (key.charCodeAt(i++) & 65280) >> 8 : 0;
+  }
+  this.rem = len + this.rem & 3;
+  len -= this.rem;
+  if (len > 0) {
+    h1 = this.h1;
+    while (1) {
+      k1 = k1 * 11601 + (k1 & 65535) * 3432906752 & 4294967295;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = k1 * 13715 + (k1 & 65535) * 461832192 & 4294967295;
+      h1 ^= k1;
+      h1 = h1 << 13 | h1 >>> 19;
+      h1 = h1 * 5 + 3864292196 & 4294967295;
+      if (i >= len) {
+        break;
+      }
+      k1 = key.charCodeAt(i++) & 65535 ^ (key.charCodeAt(i++) & 65535) << 8 ^ (key.charCodeAt(i++) & 65535) << 16;
+      top = key.charCodeAt(i++);
+      k1 ^= (top & 255) << 24 ^ (top & 65280) >> 8;
+    }
+    k1 = 0;
+    switch (this.rem) {
+      case 3:
+        k1 ^= (key.charCodeAt(i + 2) & 65535) << 16;
+      case 2:
+        k1 ^= (key.charCodeAt(i + 1) & 65535) << 8;
+      case 1:
+        k1 ^= key.charCodeAt(i) & 65535;
+    }
+    this.h1 = h1;
+  }
+  this.k1 = k1;
+  return this;
 };
+MurmurHash3.prototype.result = function() {
+  var k1, h1;
+  k1 = this.k1;
+  h1 = this.h1;
+  if (k1 > 0) {
+    k1 = k1 * 11601 + (k1 & 65535) * 3432906752 & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = k1 * 13715 + (k1 & 65535) * 461832192 & 4294967295;
+    h1 ^= k1;
+  }
+  h1 ^= this.len;
+  h1 ^= h1 >>> 16;
+  h1 = h1 * 51819 + (h1 & 65535) * 2246770688 & 4294967295;
+  h1 ^= h1 >>> 13;
+  h1 = h1 * 44597 + (h1 & 65535) * 3266445312 & 4294967295;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+};
+MurmurHash3.prototype.reset = function(seed) {
+  this.h1 = typeof seed === "number" ? seed : 0;
+  this.rem = this.k1 = this.len = 0;
+  return this;
+};
+var imurmurhash_esm_default = MurmurHash3;
 
 // src/cli/utilities.js
 import { __internal as sharedWithCli2 } from "../index.mjs";
@@ -1281,8 +1353,8 @@ function pick(object2, keys2) {
   const entries = keys2.map((key) => [key, object2[key]]);
   return Object.fromEntries(entries);
 }
-function createHash(source) {
-  return String(sdbm(source));
+function createHash(string) {
+  return imurmurhash_esm_default(string).result().toString(36);
 }
 async function statSafe(filePath) {
   try {
@@ -1318,13 +1390,14 @@ var normalizeToPosix = path.sep === "\\" ? (filepath) => method_replace_all_defa
   "/"
 ) : (filepath) => filepath;
 var {
-  omit
+  omit,
+  getOrInsertComputed
 } = sharedWithCli2.utilities;
 
 // src/cli/options/create-minimist-options.js
 function createMinimistOptions(detailedOptions) {
   const booleanNames = [];
-  const stringNames = [];
+  const stringNames = ["_"];
   const defaultValues = {};
   for (const option of detailedOptions) {
     const { name, alias, type } = option;
@@ -1426,7 +1499,7 @@ function parseArgv(rawArguments, detailedOptions, logger, keys2) {
         return [option.forwardToApi || camelCase(key), value];
       })
     ),
-    _: normalized._?.map(String),
+    _: normalized._,
     get __raw() {
       return argv2;
     }
@@ -1503,7 +1576,7 @@ var Context = class {
     const {
       PRETTIER_PERF_REPEAT
     } = process.env;
-    if (PRETTIER_PERF_REPEAT && /^\d+$/u.test(PRETTIER_PERF_REPEAT)) {
+    if (PRETTIER_PERF_REPEAT && /^\d+$/.test(PRETTIER_PERF_REPEAT)) {
       return {
         name: "PRETTIER_PERF_REPEAT (environment variable)",
         debugRepeat: Number(PRETTIER_PERF_REPEAT)
@@ -1765,11 +1838,11 @@ function escapePathForGlob(path13) {
         )
         // Workaround for fast-glob#262 (part 1)
       ),
-      "\\!",
-      "@(!)"
+      "\0",
+      "@(\\\\)"
     ),
-    "\0",
-    "@(\\\\)"
+    '"',
+    '@(\\")'
   );
 }
 var fixWindowsSlashes = normalizeToPosix;
@@ -1905,12 +1978,12 @@ var find_cache_file_default = findCacheFile;
 var import_fast_json_stable_stringify2 = __toESM(require_fast_json_stable_stringify(), 1);
 import fs7 from "fs";
 
-// node_modules/file-entry-cache/dist/index.js
+// node_modules/file-entry-cache/dist/index.mjs
 import crypto2 from "crypto";
 import fs6 from "fs";
 import path11 from "path";
 
-// node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
+// node_modules/file-entry-cache/node_modules/flat-cache/dist/index.mjs
 import fs5 from "fs";
 import path10 from "path";
 
@@ -2135,6 +2208,7 @@ var Eventified = class {
         }
       }
     }
+    this.sendLog(event, arguments_);
     return result;
   }
   /**
@@ -2182,6 +2256,54 @@ var Eventified = class {
     }
     return result;
   }
+  /**
+   * Sends a log message using the configured logger based on the event name
+   * @param {string | symbol} eventName - The event name that determines the log level
+   * @param {unknown} data - The data to log
+   */
+  sendLog(eventName, data) {
+    if (!this._logger) {
+      return;
+    }
+    let message;
+    if (typeof data === "string") {
+      message = data;
+    } else if (Array.isArray(data) && data.length > 0 && data[0] instanceof Error) {
+      message = data[0].message;
+    } else if (data instanceof Error) {
+      message = data.message;
+    } else if (Array.isArray(data) && data.length > 0 && typeof data[0]?.message === "string") {
+      message = data[0].message;
+    } else {
+      message = JSON.stringify(data);
+    }
+    switch (eventName) {
+      case "error": {
+        this._logger.error?.(message, { event: eventName, data });
+        break;
+      }
+      case "warn": {
+        this._logger.warn?.(message, { event: eventName, data });
+        break;
+      }
+      case "trace": {
+        this._logger.trace?.(message, { event: eventName, data });
+        break;
+      }
+      case "debug": {
+        this._logger.debug?.(message, { event: eventName, data });
+        break;
+      }
+      case "fatal": {
+        this._logger.fatal?.(message, { event: eventName, data });
+        break;
+      }
+      default: {
+        this._logger.info?.(message, { event: eventName, data });
+        break;
+      }
+    }
+  }
 };
 var Hookified = class extends Eventified {
   _hooks;
@@ -2314,9 +2436,6 @@ var Hookified = class extends Eventified {
       const message = this._deprecatedHooks.get(event);
       const warningMessage = `Hook "${event}" is deprecated${message ? `: ${message}` : ""}`;
       this.emit("warn", { hook: event, message: warningMessage });
-      if (this.logger?.warn) {
-        this.logger.warn(warningMessage);
-      }
       return this._allowDeprecated;
     }
     return true;
@@ -2328,24 +2447,24 @@ var Hookified = class extends Eventified {
    * @returns {void}
    */
   onHook(event, handler) {
-    this.validateHookName(event);
-    if (!this.checkDeprecatedHook(event)) {
-      return;
-    }
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      eventHandlers.push(handler);
-    } else {
-      this._hooks.set(event, [handler]);
-    }
+    this.onHookEntry({ event, handler });
   }
   /**
-   * Adds a handler function for a specific event that runs before all other handlers
+   * Adds a handler function for a specific event
    * @param {HookEntry} hookEntry
    * @returns {void}
    */
   onHookEntry(hookEntry) {
-    this.onHook(hookEntry.event, hookEntry.handler);
+    this.validateHookName(hookEntry.event);
+    if (!this.checkDeprecatedHook(hookEntry.event)) {
+      return;
+    }
+    const eventHandlers = this._hooks.get(hookEntry.event);
+    if (eventHandlers) {
+      eventHandlers.push(hookEntry.handler);
+    } else {
+      this._hooks.set(hookEntry.event, [hookEntry.handler]);
+    }
   }
   /**
    * Alias for onHook. This is provided for compatibility with other libraries that use the `addHook` method.
@@ -2354,7 +2473,7 @@ var Hookified = class extends Eventified {
    * @returns {void}
    */
   addHook(event, handler) {
-    this.onHook(event, handler);
+    this.onHookEntry({ event, handler });
   }
   /**
    * Adds a handler function for a specific event
@@ -2464,9 +2583,39 @@ var Hookified = class extends Eventified {
         } catch (error) {
           const message = `${event}: ${error.message}`;
           this.emit("error", new Error(message));
-          if (this.logger) {
-            this.logger.error(message);
+          if (this._throwOnHookError) {
+            throw new Error(message);
           }
+        }
+      }
+    }
+  }
+  /**
+   * Calls all synchronous handlers for a specific event.
+   * Async handlers (declared with `async` keyword) are silently skipped.
+   *
+   * Note: The `hook` method is preferred as it executes both sync and async functions.
+   * Use `hookSync` only when you specifically need synchronous execution.
+   * @param {string} event
+   * @param {T[]} arguments_
+   * @returns {void}
+   */
+  hookSync(event, ...arguments_) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return;
+    }
+    const eventHandlers = this._hooks.get(event);
+    if (eventHandlers) {
+      for (const handler of eventHandlers) {
+        if (handler.constructor.name === "AsyncFunction") {
+          continue;
+        }
+        try {
+          handler(...arguments_);
+        } catch (error) {
+          const message = `${event}: ${error.message}`;
+          this.emit("error", new Error(message));
           if (this._throwOnHookError) {
             throw new Error(message);
           }
@@ -2522,6 +2671,103 @@ var Hookified = class extends Eventified {
 };
 
 // node_modules/hashery/dist/node/index.js
+var Cache = class {
+  _enabled = true;
+  _maxSize = 4e3;
+  _store = /* @__PURE__ */ new Map();
+  _keys = [];
+  constructor(options) {
+    if (options?.enabled !== void 0) {
+      this._enabled = options.enabled;
+    }
+    if (options?.maxSize !== void 0) {
+      this._maxSize = options.maxSize;
+    }
+  }
+  /**
+   * Gets whether the cache is enabled.
+   */
+  get enabled() {
+    return this._enabled;
+  }
+  /**
+   * Sets whether the cache is enabled.
+   */
+  set enabled(value) {
+    this._enabled = value;
+  }
+  /**
+   * Gets the maximum number of items the cache can hold.
+   */
+  get maxSize() {
+    return this._maxSize;
+  }
+  /**
+   * Sets the maximum number of items the cache can hold.
+   */
+  set maxSize(value) {
+    this._maxSize = value;
+  }
+  /**
+   * Gets the underlying Map store.
+   */
+  get store() {
+    return this._store;
+  }
+  /**
+   * Gets the current number of items in the cache.
+   */
+  get size() {
+    return this._store.size;
+  }
+  /**
+   * Gets a value from the cache.
+   * @param key - The cache key
+   * @returns The cached value, or undefined if not found
+   */
+  get(key) {
+    return this._store.get(key);
+  }
+  /**
+   * Sets a value in the cache with FIFO eviction.
+   * If the cache is disabled, this method does nothing.
+   * If the cache is at capacity, the oldest entry is removed before adding the new one.
+   * @param key - The cache key
+   * @param value - The value to cache
+   */
+  set(key, value) {
+    if (!this._enabled) {
+      return;
+    }
+    if (this._store.has(key)) {
+      this._store.set(key, value);
+      return;
+    }
+    if (this._store.size >= this._maxSize) {
+      const oldestKey = this._keys.shift();
+      if (oldestKey) {
+        this._store.delete(oldestKey);
+      }
+    }
+    this._keys.push(key);
+    this._store.set(key, value);
+  }
+  /**
+   * Checks if a key exists in the cache.
+   * @param key - The cache key
+   * @returns True if the key exists, false otherwise
+   */
+  has(key) {
+    return this._store.has(key);
+  }
+  /**
+   * Clears all entries from the cache.
+   */
+  clear() {
+    this._store.clear();
+    this._keys = [];
+  }
+};
 var CRC = class {
   get name() {
     return "crc32";
@@ -2676,10 +2922,10 @@ var FNV1 = class {
     return this.toHashSync(data);
   }
 };
-var Murmer = class {
+var Murmur = class {
   _seed;
   /**
-   * Creates a new Murmer instance.
+   * Creates a new Murmur instance.
    *
    * @param seed - Optional seed value for the hash (default: 0)
    */
@@ -2690,7 +2936,7 @@ var Murmer = class {
    * The name identifier for this hash provider.
    */
   get name() {
-    return "murmer";
+    return "murmur";
   }
   /**
    * Gets the current seed value used for hashing.
@@ -2699,16 +2945,16 @@ var Murmer = class {
     return this._seed;
   }
   /**
-   * Computes the Murmer 32-bit hash of the provided data synchronously.
+   * Computes the Murmur 32-bit hash of the provided data synchronously.
    *
    * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
    * @returns An 8-character lowercase hexadecimal string
    *
    * @example
    * ```typescript
-   * const murmer = new Murmer();
+   * const murmur = new Murmur();
    * const data = new TextEncoder().encode('hello');
-   * const hash = murmer.toHashSync(data);
+   * const hash = murmur.toHashSync(data);
    * console.log(hash); // "248bfa47"
    * ```
    */
@@ -2766,16 +3012,16 @@ var Murmer = class {
     return hashHex;
   }
   /**
-   * Computes the Murmer 32-bit hash of the provided data.
+   * Computes the Murmur 32-bit hash of the provided data.
    *
    * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
    * @returns A Promise resolving to an 8-character lowercase hexadecimal string
    *
    * @example
    * ```typescript
-   * const murmer = new Murmer();
+   * const murmur = new Murmur();
    * const data = new TextEncoder().encode('hello');
-   * const hash = await murmer.toHash(data);
+   * const hash = await murmur.toHash(data);
    * console.log(hash); // "248bfa47"
    * ```
    */
@@ -2962,6 +3208,7 @@ var Hashery = class extends Hookified {
   _providers = new HashProviders();
   _defaultAlgorithm = "SHA-256";
   _defaultAlgorithmSync = "djb2";
+  _cache;
   constructor(options) {
     super(options);
     if (options?.parse) {
@@ -2976,6 +3223,7 @@ var Hashery = class extends Hookified {
     if (options?.defaultAlgorithmSync) {
       this._defaultAlgorithmSync = options.defaultAlgorithmSync;
     }
+    this._cache = new Cache(options?.cache);
     this.loadProviders(options?.providers, {
       includeBase: options?.includeBase ?? true
     });
@@ -3060,7 +3308,7 @@ var Hashery = class extends Hookified {
   }
   /**
    * Sets the default synchronous hash algorithm to use when none is specified.
-   * @param value - The default synchronous algorithm to use (e.g., 'djb2', 'fnv1', 'murmer', 'crc32')
+   * @param value - The default synchronous algorithm to use (e.g., 'djb2', 'fnv1', 'murmur', 'crc32')
    * @example
    * ```ts
    * const hashery = new Hashery();
@@ -3072,10 +3320,32 @@ var Hashery = class extends Hookified {
   set defaultAlgorithmSync(value) {
     this._defaultAlgorithmSync = value;
   }
+  /**
+   * Gets the cache instance used to store computed hash values.
+   * @returns The Cache instance
+   * @example
+   * ```ts
+   * const hashery = new Hashery({ cache: { enabled: true } });
+   *
+   * // Access the cache
+   * hashery.cache.enabled; // true
+   * hashery.cache.size; // number of cached items
+   * hashery.cache.clear(); // clear all cached items
+   * ```
+   */
+  get cache() {
+    return this._cache;
+  }
   /**
    * Generates a cryptographic hash of the provided data using the Web Crypto API.
    * The data is first stringified using the configured stringify function, then hashed.
    *
+   * If an invalid algorithm is provided, a 'warn' event is emitted and the method falls back
+   * to the default algorithm. You can listen to these warnings:
+   * ```ts
+   * hashery.on('warn', (message) => console.log(message));
+   * ```
+   *
    * @param data - The data to hash (will be stringified before hashing)
    * @param options - Optional configuration object
    * @param options.algorithm - The hash algorithm to use (defaults to 'SHA-256')
@@ -3100,15 +3370,36 @@ var Hashery = class extends Hookified {
     };
     await this.beforeHook("toHash", context);
     const stringified = this._stringify(context.data);
+    const cacheKey = `${context.algorithm}:${stringified}`;
+    if (this._cache.enabled) {
+      const cached = this._cache.get(cacheKey);
+      if (cached !== void 0) {
+        let cachedHash = cached;
+        if (options?.maxLength && cachedHash.length > options.maxLength) {
+          cachedHash = cachedHash.substring(0, options.maxLength);
+        }
+        const result2 = {
+          hash: cachedHash,
+          data: context.data,
+          algorithm: context.algorithm
+        };
+        await this.afterHook("toHash", result2);
+        return result2.hash;
+      }
+    }
     const encoder = new TextEncoder();
     const dataBuffer = encoder.encode(stringified);
     let provider = this._providers.get(context.algorithm);
     if (!provider) {
+      this.emit("warn", `Invalid algorithm '${context.algorithm}' not found. Falling back to default algorithm '${this._defaultAlgorithm}'.`);
       provider = new WebCrypto({
         algorithm: this._defaultAlgorithm
       });
     }
     let hash2 = await provider.toHash(dataBuffer);
+    if (this._cache.enabled) {
+      this._cache.set(cacheKey, hash2);
+    }
     if (options?.maxLength && hash2.length > options?.maxLength) {
       hash2 = hash2.substring(0, options.maxLength);
     }
@@ -3169,9 +3460,15 @@ var Hashery = class extends Hookified {
    * Generates a hash of the provided data synchronously using a non-cryptographic hash algorithm.
    * The data is first stringified using the configured stringify function, then hashed.
    *
-   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmer, crc32).
+   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmur, crc32).
    * WebCrypto algorithms (SHA-256, SHA-384, SHA-512) are not supported and will throw an error.
    *
+   * If an invalid algorithm is provided, a 'warn' event is emitted and the method falls back
+   * to the default synchronous algorithm. You can listen to these warnings:
+   * ```ts
+   * hashery.on('warn', (message) => console.log(message));
+   * ```
+   *
    * @param data - The data to hash (will be stringified before hashing)
    * @param options - Optional configuration object
    * @param options.algorithm - The hash algorithm to use (defaults to 'djb2')
@@ -3179,6 +3476,7 @@ var Hashery = class extends Hookified {
    * @returns The hexadecimal string representation of the hash
    *
    * @throws {Error} If the specified algorithm does not support synchronous hashing
+   * @throws {Error} If the default algorithm is not found
    *
    * @example
    * ```ts
@@ -3196,19 +3494,43 @@ var Hashery = class extends Hookified {
       algorithm: options?.algorithm ?? this._defaultAlgorithmSync,
       maxLength: options?.maxLength
     };
-    this.beforeHook("toHashSync", context);
+    this.hookSync("before:toHashSync", context);
     const algorithm = context.algorithm;
     const stringified = this._stringify(context.data);
+    const cacheKey = `${algorithm}:${stringified}`;
+    if (this._cache.enabled) {
+      const cached = this._cache.get(cacheKey);
+      if (cached !== void 0) {
+        let cachedHash = cached;
+        if (options?.maxLength && cachedHash.length > options.maxLength) {
+          cachedHash = cachedHash.substring(0, options.maxLength);
+        }
+        const result2 = {
+          hash: cachedHash,
+          data: context.data,
+          algorithm
+        };
+        this.hookSync("after:toHashSync", result2);
+        return result2.hash;
+      }
+    }
     const encoder = new TextEncoder();
     const dataBuffer = encoder.encode(stringified);
-    const provider = this._providers.get(algorithm);
+    let provider = this._providers.get(algorithm);
     if (!provider) {
-      throw new Error(`Hash provider '${algorithm}' not found`);
+      this.emit("warn", `Invalid algorithm '${algorithm}' not found. Falling back to default algorithm '${this._defaultAlgorithmSync}'.`);
+      provider = this._providers.get(this._defaultAlgorithmSync);
+      if (!provider) {
+        throw new Error(`Hash provider '${this._defaultAlgorithmSync}' (default) not found`);
+      }
     }
     if (!provider.toHashSync) {
-      throw new Error(`Hash provider '${algorithm}' does not support synchronous hashing. Use toHash() instead or choose a different algorithm (djb2, fnv1, murmer, crc32).`);
+      throw new Error(`Hash provider '${algorithm}' does not support synchronous hashing. Use toHash() instead or choose a different algorithm (djb2, fnv1, murmur, crc32).`);
     }
     let hash2 = provider.toHashSync(dataBuffer);
+    if (this._cache.enabled) {
+      this._cache.set(cacheKey, hash2);
+    }
     if (options?.maxLength && hash2.length > options?.maxLength) {
       hash2 = hash2.substring(0, options.maxLength);
     }
@@ -3217,7 +3539,7 @@ var Hashery = class extends Hookified {
       data: context.data,
       algorithm: context.algorithm
     };
-    this.afterHook("toHashSync", result);
+    this.hookSync("after:toHashSync", result);
     return result.hash;
   }
   /**
@@ -3225,7 +3547,7 @@ var Hashery = class extends Hookified {
    * This method uses the toHashSync function to create a consistent hash, then maps it to a number
    * between min and max (inclusive).
    *
-   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmer, crc32).
+   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmur, crc32).
    *
    * @param data - The data to hash (will be stringified before hashing)
    * @param options - Configuration options (optional, defaults to min: 0, max: 100)
@@ -3291,79 +3613,58 @@ var Hashery = class extends Hookified {
       this.providers.add(new CRC());
       this.providers.add(new DJB2());
       this.providers.add(new FNV1());
-      this.providers.add(new Murmer());
+      this.providers.add(new Murmur());
     }
   }
 };
 
-// node_modules/@cacheable/utils/dist/index.js
+// node_modules/@cacheable/utils/dist/index.mjs
 var shorthandToMilliseconds = (shorthand) => {
   let milliseconds;
-  if (shorthand === void 0) {
-    return void 0;
-  }
-  if (typeof shorthand === "number") {
-    milliseconds = shorthand;
-  } else {
-    if (typeof shorthand !== "string") {
-      return void 0;
-    }
+  if (shorthand === void 0) return;
+  if (typeof shorthand === "number") milliseconds = shorthand;
+  else {
+    if (typeof shorthand !== "string") return;
     shorthand = shorthand.trim();
     if (Number.isNaN(Number(shorthand))) {
       const match = /^([\d.]+)\s*(ms|s|m|h|hr|d)$/i.exec(shorthand);
-      if (!match) {
-        throw new Error(
-          `Unsupported time format: "${shorthand}". Use 'ms', 's', 'm', 'h', 'hr', or 'd'.`
-        );
-      }
+      if (!match) throw new Error(`Unsupported time format: "${shorthand}". Use 'ms', 's', 'm', 'h', 'hr', or 'd'.`);
       const [, value, unit] = match;
       const numericValue = Number.parseFloat(value);
-      const unitLower = unit.toLowerCase();
-      switch (unitLower) {
-        case "ms": {
+      switch (unit.toLowerCase()) {
+        case "ms":
           milliseconds = numericValue;
           break;
-        }
-        case "s": {
+        case "s":
           milliseconds = numericValue * 1e3;
           break;
-        }
-        case "m": {
+        case "m":
           milliseconds = numericValue * 1e3 * 60;
           break;
-        }
-        case "h": {
+        case "h":
           milliseconds = numericValue * 1e3 * 60 * 60;
           break;
-        }
-        case "hr": {
+        case "hr":
           milliseconds = numericValue * 1e3 * 60 * 60;
           break;
-        }
-        case "d": {
+        case "d":
           milliseconds = numericValue * 1e3 * 60 * 60 * 24;
           break;
-        }
         /* v8 ignore next -- @preserve */
-        default: {
+        default:
           milliseconds = Number(shorthand);
-        }
       }
-    } else {
-      milliseconds = Number(shorthand);
-    }
+    } else milliseconds = Number(shorthand);
   }
   return milliseconds;
 };
 var shorthandToTime = (shorthand, fromDate) => {
   fromDate ?? (fromDate = /* @__PURE__ */ new Date());
   const milliseconds = shorthandToMilliseconds(shorthand);
-  if (milliseconds === void 0) {
-    return fromDate.getTime();
-  }
+  if (milliseconds === void 0) return fromDate.getTime();
   return fromDate.getTime() + milliseconds;
 };
-var HashAlgorithm = /* @__PURE__ */ ((HashAlgorithm2) => {
+var HashAlgorithm = /* @__PURE__ */ (function(HashAlgorithm2) {
   HashAlgorithm2["SHA256"] = "SHA-256";
   HashAlgorithm2["SHA384"] = "SHA-384";
   HashAlgorithm2["SHA512"] = "SHA-512";
@@ -3372,16 +3673,14 @@ var HashAlgorithm = /* @__PURE__ */ ((HashAlgorithm2) => {
   HashAlgorithm2["MURMER"] = "murmer";
   HashAlgorithm2["CRC32"] = "crc32";
   return HashAlgorithm2;
-})(HashAlgorithm || {});
+})({});
 function hashSync(object2, options = {
   algorithm: "djb2",
   serialize: JSON.stringify
 }) {
   const algorithm = options?.algorithm ?? "djb2";
-  const serialize = options?.serialize ?? JSON.stringify;
-  const objectString = serialize(object2);
-  const hashery = new Hashery();
-  return hashery.toHashSync(objectString, { algorithm });
+  const objectString = (options?.serialize ?? JSON.stringify)(object2);
+  return new Hashery().toHashSync(objectString, { algorithm });
 }
 function hashToNumberSync(object2, options = {
   min: 0,
@@ -3394,14 +3693,9 @@ function hashToNumberSync(object2, options = {
   const algorithm = options?.algorithm ?? "djb2";
   const serialize = options?.serialize ?? JSON.stringify;
   const hashLength = options?.hashLength ?? 16;
-  if (min >= max) {
-    throw new Error(
-      `Invalid range: min (${min}) must be less than max (${max})`
-    );
-  }
+  if (min >= max) throw new Error(`Invalid range: min (${min}) must be less than max (${max})`);
   const objectString = serialize(object2);
-  const hashery = new Hashery();
-  return hashery.toNumberSync(objectString, {
+  return new Hashery().toNumberSync(objectString, {
     algorithm,
     min,
     max,
@@ -3409,217 +3703,733 @@ function hashToNumberSync(object2, options = {
   });
 }
 function wrapSync(function_, options) {
-  const { ttl, keyPrefix, cache, serialize } = options;
+  const { ttl, keyPrefix, cache: cache2, serialize } = options;
   return (...arguments_) => {
     let cacheKey = createWrapKey(function_, arguments_, {
       keyPrefix,
       serialize
     });
-    if (options.createKey) {
-      cacheKey = options.createKey(function_, arguments_, options);
-    }
-    let value = cache.get(cacheKey);
-    if (value === void 0) {
-      try {
-        value = function_(...arguments_);
-        cache.set(cacheKey, value, ttl);
-      } catch (error) {
-        cache.emit("error", error);
-        if (options.cacheErrors) {
-          cache.set(cacheKey, error, ttl);
-        }
-      }
+    if (options.createKey) cacheKey = options.createKey(function_, arguments_, options);
+    let value = cache2.get(cacheKey);
+    if (value === void 0) try {
+      value = function_(...arguments_);
+      cache2.set(cacheKey, value, ttl);
+    } catch (error) {
+      cache2.emit("error", error);
+      if (options.cacheErrors) cache2.set(cacheKey, error, ttl);
     }
     return value;
   };
 }
+function getOrSetSync(key, function_, options) {
+  const keyString = typeof key === "function" ? key(options) : key;
+  let value;
+  try {
+    value = options.cache.get(keyString);
+  } catch (error) {
+    options.cache.emit("error", error);
+    if (options.throwErrors === true || options.throwErrors === "store") throw error;
+  }
+  if (value === void 0) try {
+    try {
+      value = function_();
+    } catch (error) {
+      throw new ErrorEnvelope(error, "function");
+    }
+    try {
+      options.cache.set(keyString, value, options.ttl);
+    } catch (error) {
+      throw new ErrorEnvelope(error, "store");
+    }
+  } catch (caught) {
+    const errorType = caught instanceof ErrorEnvelope ? caught.context : void 0;
+    const error = caught instanceof ErrorEnvelope ? caught.error : caught;
+    options.cache.emit("error", error);
+    if (options.cacheErrors && errorType === "function") try {
+      options.cache.set(keyString, error, options.ttl);
+    } catch (storeError) {
+      options.cache.emit("error", storeError);
+    }
+    if (options.throwErrors === true || options.throwErrors === errorType) throw error;
+  }
+  return value;
+}
 function createWrapKey(function_, arguments_, options) {
   const { keyPrefix, serialize } = options || {};
-  if (!keyPrefix) {
-    return `${function_.name}::${hashSync(arguments_, { serialize })}`;
-  }
+  if (!keyPrefix) return `${function_.name}::${hashSync(arguments_, { serialize })}`;
   return `${keyPrefix}::${function_.name}::${hashSync(arguments_, { serialize })}`;
 }
-
-// node_modules/@cacheable/memory/dist/index.js
-var structuredClone = globalThis.structuredClone ?? ((value) => JSON.parse(JSON.stringify(value)));
-var ListNode = class {
-  value;
-  prev = void 0;
-  next = void 0;
-  constructor(value) {
-    this.value = value;
+var ErrorEnvelope = class {
+  error;
+  context;
+  constructor(error, context) {
+    this.error = error;
+    this.context = context;
   }
 };
-var DoublyLinkedList = class {
-  head = void 0;
-  tail = void 0;
-  nodesMap = /* @__PURE__ */ new Map();
-  // Add a new node to the front (most recently used)
-  addToFront(value) {
-    const newNode = new ListNode(value);
-    if (this.head) {
-      newNode.next = this.head;
-      this.head.prev = newNode;
-      this.head = newNode;
-    } else {
-      this.head = this.tail = newNode;
-    }
-    this.nodesMap.set(value, newNode);
+var Stats = class {
+  _counters = {
+    hits: 0,
+    misses: 0,
+    gets: 0,
+    sets: 0,
+    deletes: 0,
+    clears: 0,
+    count: 0
+  };
+  _vsize = 0;
+  _ksize = 0;
+  _enabled = false;
+  _lastUpdated;
+  _lastReset;
+  _subscriptions = [];
+  /** Backing store for the public {@link trackedKeys} read-only view. */
+  _trackedKeys = /* @__PURE__ */ new Map();
+  _trackKeys = false;
+  _maxTrackedKeys;
+  constructor(options) {
+    if (options?.enabled) this._enabled = options.enabled;
+    if (options?.trackKeys) this._trackKeys = options.trackKeys;
+    if (options?.maxTrackedKeys !== void 0) this._maxTrackedKeys = options.maxTrackedKeys;
+    if (options?.emitter && options?.eventMap) this.subscribe(options.emitter, options.eventMap);
   }
-  // Move an existing node to the front (most recently used)
-  moveToFront(value) {
-    const node = this.nodesMap.get(value);
-    if (!node || this.head === node) {
-      return;
-    }
-    if (node.prev) {
-      node.prev.next = node.next;
-    }
-    if (node.next) {
-      node.next.prev = node.prev;
-    }
-    if (node === this.tail) {
-      this.tail = node.prev;
-    }
-    node.prev = void 0;
-    node.next = this.head;
-    if (this.head) {
-      this.head.prev = node;
-    }
-    this.head = node;
-    this.tail ?? (this.tail = node);
+  /**
+  * @returns {boolean} - Whether the stats are enabled
+  */
+  get enabled() {
+    return this._enabled;
   }
-  // Get the oldest node (tail)
-  getOldest() {
-    return this.tail ? this.tail.value : void 0;
+  /**
+  * @param {boolean} enabled - Whether to enable the stats
+  */
+  set enabled(enabled) {
+    this._enabled = enabled;
   }
-  // Remove the oldest node (tail)
-  removeOldest() {
-    if (!this.tail) {
-      return void 0;
-    }
-    const oldValue = this.tail.value;
-    if (this.tail.prev) {
-      this.tail = this.tail.prev;
-      this.tail.next = void 0;
-    } else {
-      this.head = this.tail = void 0;
-    }
-    this.nodesMap.delete(oldValue);
-    return oldValue;
+  /**
+  * @returns {boolean} - Whether per-key statistics are tracked
+  */
+  get trackKeys() {
+    return this._trackKeys;
   }
-  get size() {
-    return this.nodesMap.size;
+  /**
+  * @param {boolean} trackKeys - Whether to track per-key statistics
+  */
+  set trackKeys(trackKeys) {
+    this._trackKeys = trackKeys;
   }
-};
-var defaultStoreHashSize = 16;
-var maximumMapSize = 16777216;
-var CacheableMemory = class extends Hookified {
-  _lru = new DoublyLinkedList();
-  _storeHashSize = defaultStoreHashSize;
-  _storeHashAlgorithm = HashAlgorithm.DJB2;
-  // Default is djb2Hash
-  _store = Array.from(
-    { length: this._storeHashSize },
-    () => /* @__PURE__ */ new Map()
-  );
-  _ttl;
-  // Turned off by default
-  _useClone = true;
-  // Turned on by default
-  _lruSize = 0;
-  // Turned off by default
-  _checkInterval = 0;
-  // Turned off by default
-  _interval = 0;
-  // Turned off by default
   /**
-   * @constructor
-   * @param {CacheableMemoryOptions} [options] - The options for the CacheableMemory
-   */
-  constructor(options) {
-    super();
-    if (options?.ttl) {
-      this.setTtl(options.ttl);
-    }
-    if (options?.useClone !== void 0) {
-      this._useClone = options.useClone;
-    }
-    if (options?.storeHashSize && options.storeHashSize > 0) {
-      this._storeHashSize = options.storeHashSize;
-    }
-    if (options?.lruSize) {
-      if (options.lruSize > maximumMapSize) {
-        this.emit(
-          "error",
-          new Error(
-            `LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`
-          )
-        );
-      } else {
-        this._lruSize = options.lruSize;
+  * @returns {number | undefined} - The cap on unique keys tracked, or
+  * `undefined` when unbounded
+  */
+  get maxTrackedKeys() {
+    return this._maxTrackedKeys;
+  }
+  /**
+  * @param {number | undefined} maxTrackedKeys - The cap on unique keys
+  * tracked. Set `undefined` for unbounded.
+  */
+  set maxTrackedKeys(maxTrackedKeys) {
+    this._maxTrackedKeys = maxTrackedKeys;
+  }
+  /**
+  * Per-key statistics, keyed by cache key, holding each key's raw
+  * `hits`/`misses`/`gets`/`sets`/`deletes` counters. Populated by
+  * {@link recordKey} when {@link trackKeys} is enabled; read `trackedKeys.size`
+  * for the number of unique keys currently tracked. The returned map is a
+  * read-only view — mutate per-key stats via {@link recordKey} /
+  * {@link clearKeys} / {@link reset}.
+  * @returns {ReadonlyMap<string, Readonly<KeyCounters>>}
+  * @readonly
+  */
+  get trackedKeys() {
+    return this._trackedKeys;
+  }
+  /**
+  * @returns {number} - The number of hits
+  * @readonly
+  */
+  get hits() {
+    return this._counters.hits;
+  }
+  /**
+  * @returns {number} - The number of misses
+  * @readonly
+  */
+  get misses() {
+    return this._counters.misses;
+  }
+  /**
+  * @returns {number} - The number of gets
+  * @readonly
+  */
+  get gets() {
+    return this._counters.gets;
+  }
+  /**
+  * @returns {number} - The number of sets
+  * @readonly
+  */
+  get sets() {
+    return this._counters.sets;
+  }
+  /**
+  * @returns {number} - The number of deletes
+  * @readonly
+  */
+  get deletes() {
+    return this._counters.deletes;
+  }
+  /**
+  * @returns {number} - The number of clears
+  * @readonly
+  */
+  get clears() {
+    return this._counters.clears;
+  }
+  /**
+  * @returns {number} - The vsize (value size) of the cache instance
+  * @readonly
+  */
+  get vsize() {
+    return this._vsize;
+  }
+  /**
+  * @returns {number} - The ksize (key size) of the cache instance
+  * @readonly
+  */
+  get ksize() {
+    return this._ksize;
+  }
+  /**
+  * @returns {number} - The count of the cache instance
+  * @readonly
+  */
+  get count() {
+    return this._counters.count;
+  }
+  /**
+  * The ratio of hits to total lookups (hits + misses). Returns `0` when there
+  * have been no lookups.
+  * @returns {number} - A value between 0 and 1
+  * @readonly
+  */
+  get hitRate() {
+    const total = this._counters.hits + this._counters.misses;
+    return total === 0 ? 0 : this._counters.hits / total;
+  }
+  /**
+  * The ratio of misses to total lookups (hits + misses). Returns `0` when
+  * there have been no lookups.
+  * @returns {number} - A value between 0 and 1
+  * @readonly
+  */
+  get missRate() {
+    const total = this._counters.hits + this._counters.misses;
+    return total === 0 ? 0 : this._counters.misses / total;
+  }
+  /**
+  * The timestamp (ms since epoch) of the last mutation while enabled, or
+  * `undefined` if there have been none since the last reset.
+  * @returns {number | undefined}
+  * @readonly
+  */
+  get lastUpdated() {
+    return this._lastUpdated;
+  }
+  /**
+  * The timestamp (ms since epoch) of the last {@link reset}/{@link clear}, or
+  * `undefined` if it has never been reset.
+  * @returns {number | undefined}
+  * @readonly
+  */
+  get lastReset() {
+    return this._lastReset;
+  }
+  /**
+  * Increment a counter field by `amount` (default `1`). No-op when disabled.
+  * @param {StatField} field - The counter to increment
+  * @param {number} amount - The amount to add (default 1)
+  */
+  increment(field, amount = 1) {
+    if (!this._enabled) return;
+    this._counters[field] += amount;
+    this.touch();
+  }
+  /**
+  * Decrement a counter field by `amount` (default `1`). No-op when disabled.
+  * @param {StatField} field - The counter to decrement
+  * @param {number} amount - The amount to subtract (default 1)
+  */
+  decrement(field, amount = 1) {
+    if (!this._enabled) return;
+    this._counters[field] -= amount;
+    this.touch();
+  }
+  incrementHits(amount = 1) {
+    this.increment("hits", amount);
+  }
+  incrementMisses(amount = 1) {
+    this.increment("misses", amount);
+  }
+  incrementGets(amount = 1) {
+    this.increment("gets", amount);
+  }
+  incrementSets(amount = 1) {
+    this.increment("sets", amount);
+  }
+  incrementDeletes(amount = 1) {
+    this.increment("deletes", amount);
+  }
+  incrementClears(amount = 1) {
+    this.increment("clears", amount);
+  }
+  incrementVSize(value) {
+    if (!this._enabled) return;
+    this._vsize += this.roughSizeOfObject(value);
+    this.touch();
+  }
+  decreaseVSize(value) {
+    if (!this._enabled) return;
+    this._vsize = Math.max(0, this._vsize - this.roughSizeOfObject(value));
+    this.touch();
+  }
+  incrementKSize(key) {
+    if (!this._enabled) return;
+    this._ksize += this.roughSizeOfString(key);
+    this.touch();
+  }
+  decreaseKSize(key) {
+    if (!this._enabled) return;
+    this._ksize = Math.max(0, this._ksize - this.roughSizeOfString(key));
+    this.touch();
+  }
+  incrementCount(amount = 1) {
+    this.increment("count", amount);
+  }
+  decreaseCount(amount = 1) {
+    if (!this._enabled) return;
+    this._counters.count = Math.max(0, this._counters.count - amount);
+    this.touch();
+  }
+  setCount(count) {
+    if (!this._enabled) return;
+    this._counters.count = count;
+    this.touch();
+  }
+  roughSizeOfString(value) {
+    return value.length * 2;
+  }
+  roughSizeOfObject(object2) {
+    const objectList = [];
+    const stack = [object2];
+    let bytes = 0;
+    while (stack.length > 0) {
+      const value = stack.pop();
+      if (typeof value === "boolean") bytes += 4;
+      else if (typeof value === "string") bytes += value.length * 2;
+      else if (typeof value === "number") bytes += 8;
+      else {
+        if (value === null || value === void 0) {
+          bytes += 4;
+          continue;
+        }
+        if (objectList.includes(value)) continue;
+        objectList.push(value);
+        for (const key in value) {
+          bytes += key.length * 2;
+          stack.push(value[key]);
+        }
       }
     }
-    if (options?.checkInterval) {
-      this._checkInterval = options.checkInterval;
+    return bytes;
+  }
+  /**
+  * Enable stat tracking. Equivalent to setting {@link enabled} to `true`.
+  */
+  enable() {
+    this._enabled = true;
+  }
+  /**
+  * Disable stat tracking. Equivalent to setting {@link enabled} to `false`.
+  */
+  disable() {
+    this._enabled = false;
+  }
+  /**
+  * Reset all counters to zero and record the reset timestamp. Alias of
+  * {@link reset}.
+  */
+  clear() {
+    this.reset();
+  }
+  reset() {
+    this._counters = {
+      hits: 0,
+      misses: 0,
+      gets: 0,
+      sets: 0,
+      deletes: 0,
+      clears: 0,
+      count: 0
+    };
+    this._vsize = 0;
+    this._ksize = 0;
+    this._trackedKeys.clear();
+    this._lastReset = Date.now();
+    this._lastUpdated = void 0;
+  }
+  resetStoreValues() {
+    this._vsize = 0;
+    this._ksize = 0;
+    this._counters.count = 0;
+  }
+  /**
+  * @returns {StatsSnapshot} - A plain-object snapshot of the current stats,
+  * including computed `hitRate`/`missRate` and timestamps.
+  */
+  toJSON() {
+    return {
+      enabled: this._enabled,
+      hits: this._counters.hits,
+      misses: this._counters.misses,
+      gets: this._counters.gets,
+      sets: this._counters.sets,
+      deletes: this._counters.deletes,
+      clears: this._counters.clears,
+      vsize: this._vsize,
+      ksize: this._ksize,
+      count: this._counters.count,
+      hitRate: this.hitRate,
+      missRate: this.missRate,
+      trackedKeys: this._trackedKeys.size,
+      lastUpdated: this._lastUpdated,
+      lastReset: this._lastReset
+    };
+  }
+  /**
+  * @returns {StatsSnapshot} - A plain-object snapshot of the current stats.
+  * Alias of {@link toJSON}.
+  */
+  snapshot() {
+    return this.toJSON();
+  }
+  /**
+  * Record an operation against a specific key for per-key statistics. No-op
+  * unless both {@link enabled} and {@link trackKeys} are `true`.
+  * @param {string} key - The cache key the operation touched
+  * @param {KeyStatField} field - The per-key counter to increment
+  * @param {number} amount - The amount to add (default 1)
+  */
+  recordKey(key, field, amount = 1) {
+    if (!this._enabled || !this._trackKeys) return;
+    let counters = this._trackedKeys.get(key);
+    if (!counters) {
+      counters = {
+        hits: 0,
+        misses: 0,
+        gets: 0,
+        sets: 0,
+        deletes: 0
+      };
+      this._trackedKeys.set(key, counters);
+      this.pruneTrackedKeys(key);
+    }
+    counters[field] += amount;
+    this.touch();
+  }
+  /**
+  * The most-used keys, sorted descending. Sorts by total recorded operations,
+  * or by a single field when `field` is provided. Ties order by key.
+  * @param {number} limit - Maximum entries to return (default 100)
+  * @param {KeyStatField} [field] - Optionally rank by one counter (e.g. "hits")
+  * @returns {StatsKeyEntry[]}
+  */
+  mostUsedKeys(limit = 100, field) {
+    return this.sortedKeyEntries(field, "desc").slice(0, limit);
+  }
+  /**
+  * The least-used keys, sorted ascending. Sorts by total recorded operations,
+  * or by a single field when `field` is provided. Ties order by key. Note:
+  * only keys that have been recorded at least once can be ranked, and when
+  * {@link maxTrackedKeys} pruning has occurred the true least-used keys may
+  * have been evicted.
+  * @param {number} limit - Maximum entries to return (default 100)
+  * @param {KeyStatField} [field] - Optionally rank by one counter (e.g. "gets")
+  * @returns {StatsKeyEntry[]}
+  */
+  leastUsedKeys(limit = 100, field) {
+    return this.sortedKeyEntries(field, "asc").slice(0, limit);
+  }
+  /**
+  * @param {string} key - The key to look up
+  * @returns {StatsKeyEntry | undefined} - The per-key statistics, or
+  * `undefined` if the key has not been recorded
+  */
+  keyStats(key) {
+    const counters = this._trackedKeys.get(key);
+    return counters ? this.toKeyEntry(key, counters) : void 0;
+  }
+  /**
+  * Clear all per-key statistics without touching the aggregate counters.
+  */
+  clearKeys() {
+    this._trackedKeys.clear();
+  }
+  totalOf(counters) {
+    return counters.hits + counters.misses + counters.gets + counters.sets + counters.deletes;
+  }
+  toKeyEntry(key, counters) {
+    const lookups = counters.hits + counters.misses;
+    return {
+      key,
+      count: this.totalOf(counters),
+      hits: counters.hits,
+      misses: counters.misses,
+      gets: counters.gets,
+      sets: counters.sets,
+      deletes: counters.deletes,
+      hitRate: lookups === 0 ? 0 : counters.hits / lookups
+    };
+  }
+  sortedKeyEntries(field, direction) {
+    const entries = [];
+    for (const [key, counters] of this._trackedKeys) entries.push(this.toKeyEntry(key, counters));
+    const sign = direction === "asc" ? 1 : -1;
+    entries.sort((a, b) => {
+      const valueA = field ? a[field] : a.count;
+      const valueB = field ? b[field] : b.count;
+      if (valueA !== valueB) return (valueA - valueB) * sign;
+      return a.key < b.key ? -1 : 1;
+    });
+    return entries;
+  }
+  /**
+  * When over {@link maxTrackedKeys}, prune the lowest-count keys down to 90%
+  * of the cap (batched so the sort cost amortizes across inserts). The key
+  * that was just recorded is never pruned.
+  */
+  pruneTrackedKeys(protectedKey) {
+    if (this._maxTrackedKeys === void 0 || this._trackedKeys.size <= this._maxTrackedKeys) return;
+    const target = Math.max(1, Math.floor(this._maxTrackedKeys * 0.9));
+    const sorted = [...this._trackedKeys.entries()].sort((a, b) => this.totalOf(a[1]) - this.totalOf(b[1]));
+    for (const [key] of sorted) {
+      if (this._trackedKeys.size <= target) break;
+      if (key === protectedKey) continue;
+      this._trackedKeys.delete(key);
+    }
+  }
+  /**
+  * Subscribe to an emitter so that matching events automatically update the
+  * stats. Counting is gated by {@link enabled}, so you may subscribe first and
+  * toggle enablement later. Call {@link unsubscribe} to detach.
+  * @param {StatsEmitter} emitter - The emitter to listen on
+  * @param {StatsEventMap} eventMap - The event-to-stat mapping (e.g.
+  * {@link nodeCacheStatsEventMap} or a custom map)
+  */
+  subscribe(emitter, eventMap) {
+    for (const [event, action] of Object.entries(eventMap)) {
+      const listener = (...args) => {
+        this.applyEvent(action, args);
+      };
+      emitter.on(event, listener);
+      this._subscriptions.push({
+        emitter,
+        event,
+        listener
+      });
     }
-    if (options?.storeHashAlgorithm) {
-      this._storeHashAlgorithm = options.storeHashAlgorithm;
+  }
+  /**
+  * Detach listeners previously attached via {@link subscribe}. When `emitter`
+  * is provided, only that emitter's listeners are removed; otherwise all are.
+  * @param {StatsEmitter} [emitter] - The emitter to detach from
+  */
+  unsubscribe(emitter) {
+    const remaining = [];
+    for (const sub of this._subscriptions) {
+      if (emitter && sub.emitter !== emitter) {
+        remaining.push(sub);
+        continue;
+      }
+      (sub.emitter.off ?? sub.emitter.removeListener)?.call(sub.emitter, sub.event, sub.listener);
     }
-    this._store = Array.from(
-      { length: this._storeHashSize },
-      () => /* @__PURE__ */ new Map()
-    );
+    this._subscriptions = remaining;
+  }
+  applyEvent(action, args) {
+    if (!this._enabled) return;
+    if (typeof action === "function") {
+      action(this, ...args);
+      return;
+    }
+    if (Array.isArray(action)) {
+      for (const field of action) this.increment(field);
+      return;
+    }
+    this.increment(action);
+  }
+  touch() {
+    this._lastUpdated = Date.now();
+  }
+};
+
+// node_modules/@cacheable/memory/dist/index.mjs
+var structuredClone = globalThis.structuredClone ?? ((value) => JSON.parse(JSON.stringify(value)));
+var ListNode = class {
+  value;
+  prev = void 0;
+  next = void 0;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var DoublyLinkedList = class {
+  head = void 0;
+  tail = void 0;
+  nodesMap = /* @__PURE__ */ new Map();
+  addToFront(value) {
+    const newNode = new ListNode(value);
+    if (this.head) {
+      newNode.next = this.head;
+      this.head.prev = newNode;
+      this.head = newNode;
+    } else this.head = this.tail = newNode;
+    this.nodesMap.set(value, newNode);
+  }
+  moveToFront(value) {
+    const node = this.nodesMap.get(value);
+    if (!node || this.head === node) return;
+    if (node.prev) node.prev.next = node.next;
+    if (node.next) node.next.prev = node.prev;
+    if (node === this.tail) this.tail = node.prev;
+    node.prev = void 0;
+    node.next = this.head;
+    if (this.head) this.head.prev = node;
+    this.head = node;
+    this.tail ?? (this.tail = node);
+  }
+  getOldest() {
+    return this.tail ? this.tail.value : void 0;
+  }
+  removeOldest() {
+    if (!this.tail) return;
+    const oldValue = this.tail.value;
+    if (this.tail.prev) {
+      this.tail = this.tail.prev;
+      this.tail.next = void 0;
+    } else
+      this.head = this.tail = void 0;
+    this.nodesMap.delete(oldValue);
+    return oldValue;
+  }
+  remove(value) {
+    const node = this.nodesMap.get(value);
+    if (!node) return false;
+    if (node.prev) node.prev.next = node.next;
+    else {
+      this.head = node.next;
+      if (this.head) this.head.prev = void 0;
+    }
+    if (node.next) node.next.prev = node.prev;
+    else {
+      this.tail = node.prev;
+      if (this.tail) this.tail.next = void 0;
+    }
+    this.nodesMap.delete(value);
+    return true;
+  }
+  get size() {
+    return this.nodesMap.size;
+  }
+};
+var maximumMapSize = 16777216;
+var CacheableMemory = class extends Hookified {
+  _lru = new DoublyLinkedList();
+  _storeHashSize = 16;
+  _storeHashAlgorithm = HashAlgorithm.DJB2;
+  _store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
+  _ttl;
+  _maxTtl;
+  _useClone = true;
+  _lruSize = 0;
+  _checkInterval = 0;
+  _interval = 0;
+  _stats = new Stats({ enabled: false });
+  /**
+  * @constructor
+  * @param {CacheableMemoryOptions} [options] - The options for the CacheableMemory
+  */
+  constructor(options) {
+    super();
+    if (options?.ttl) this.setTtl(options.ttl);
+    if (options?.maxTtl !== void 0) this.setMaxTtl(options.maxTtl);
+    if (options?.useClone !== void 0) this._useClone = options.useClone;
+    if (options?.stats) this._stats.enabled = options.stats;
+    if (options?.storeHashSize && options.storeHashSize > 0) this._storeHashSize = options.storeHashSize;
+    if (options?.lruSize) if (options.lruSize > 16777216) this.emit("error", /* @__PURE__ */ new Error(`LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`));
+    else this._lruSize = options.lruSize;
+    if (options?.checkInterval) this._checkInterval = options.checkInterval;
+    if (options?.storeHashAlgorithm) this._storeHashAlgorithm = options.storeHashAlgorithm;
+    this._store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
     this.startIntervalCheck();
   }
   /**
-   * Gets the time-to-live
-   * @returns {number|string|undefined} - The time-to-live in miliseconds or a human-readable format. If undefined, it will not have a time-to-live.
-   */
+  * Gets the time-to-live
+  * @returns {number|string|undefined} - The time-to-live in miliseconds or a human-readable format. If undefined, it will not have a time-to-live.
+  */
   get ttl() {
     return this._ttl;
   }
   /**
-   * Sets the time-to-live
-   * @param {number|string|undefined} value - The time-to-live in miliseconds or a human-readable format (example '1s' = 1 second, '1h' = 1 hour). If undefined, it will not have a time-to-live.
-   */
+  * Sets the time-to-live
+  * @param {number|string|undefined} value - The time-to-live in miliseconds or a human-readable format (example '1s' = 1 second, '1h' = 1 hour). If undefined, it will not have a time-to-live.
+  */
   set ttl(value) {
     this.setTtl(value);
   }
   /**
-   * Gets whether to use clone
-   * @returns {boolean} - If true, it will clone the value before returning it. If false, it will return the value directly. Default is true.
-   */
+  * Gets the maximum time-to-live. When set, any TTL that exceeds this value is capped to maxTtl.
+  * Entries with no TTL will also be capped to maxTtl. Default is `undefined` (no maximum).
+  * @returns {number|string|undefined} - The maximum TTL in milliseconds, human-readable format, or undefined.
+  */
+  get maxTtl() {
+    return this._maxTtl;
+  }
+  /**
+  * Sets the maximum time-to-live. When set, any TTL that exceeds this value is capped to maxTtl.
+  * Entries with no TTL will also be capped to maxTtl.
+  * @param {number|string|undefined} value - The maximum TTL in milliseconds or human-readable format (e.g. '1s', '1h'). If undefined, no maximum is enforced.
+  */
+  set maxTtl(value) {
+    this.setMaxTtl(value);
+  }
+  /**
+  * Gets whether to use clone
+  * @returns {boolean} - If true, it will clone the value before returning it. If false, it will return the value directly. Default is true.
+  */
   get useClone() {
     return this._useClone;
   }
   /**
-   * Sets whether to use clone
-   * @param {boolean} value - If true, it will clone the value before returning it. If false, it will return the value directly. Default is true.
-   */
+  * Sets whether to use clone
+  * @param {boolean} value - If true, it will clone the value before returning it. If false, it will return the value directly. Default is true.
+  */
   set useClone(value) {
     this._useClone = value;
   }
   /**
-   * Gets the size of the LRU cache
-   * @returns {number} - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0. If you are using LRU then the limit is based on Map() size 17mm.
-   */
+  * Gets the size of the LRU cache
+  * @returns {number} - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0. If you are using LRU then the limit is based on Map() size 17mm.
+  */
   get lruSize() {
     return this._lruSize;
   }
   /**
-   * Sets the size of the LRU cache
-   * @param {number} value - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0. If you are using LRU then the limit is based on Map() size 17mm.
-   */
+  * Sets the size of the LRU cache
+  * @param {number} value - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0. If you are using LRU then the limit is based on Map() size 17mm.
+  */
   set lruSize(value) {
-    if (value > maximumMapSize) {
-      this.emit(
-        "error",
-        new Error(
-          `LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`
-        )
-      );
+    if (value > 16777216) {
+      this.emit("error", /* @__PURE__ */ new Error(`LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`));
       return;
     }
     this._lruSize = value;
@@ -3630,241 +4440,284 @@ var CacheableMemory = class extends Hookified {
     this.lruResize();
   }
   /**
-   * Gets the check interval
-   * @returns {number} - The interval to check for expired items. If set to 0, it will not check for expired items. Default is 0.
-   */
+  * Gets the check interval
+  * @returns {number} - The interval to check for expired items. If set to 0, it will not check for expired items. Default is 0.
+  */
   get checkInterval() {
     return this._checkInterval;
   }
   /**
-   * Sets the check interval
-   * @param {number} value - The interval to check for expired items. If set to 0, it will not check for expired items. Default is 0.
-   */
+  * Sets the check interval
+  * @param {number} value - The interval to check for expired items. If set to 0, it will not check for expired items. Default is 0.
+  */
   set checkInterval(value) {
     this._checkInterval = value;
   }
   /**
-   * Gets the size of the cache
-   * @returns {number} - The size of the cache
-   */
+  * Gets the size of the cache
+  * @returns {number} - The size of the cache
+  */
   get size() {
     let size = 0;
-    for (const store of this._store) {
-      size += store.size;
-    }
+    for (const store of this._store) size += store.size;
     return size;
   }
   /**
-   * Gets the number of hash stores
-   * @returns {number} - The number of hash stores
-   */
+  * Gets the statistics of the cache. Statistics track aggregate counters such as `hits`, `misses`,
+  * `gets`, `sets`, `deletes`, `clears`, `count`, `ksize`, and `vsize`. They are disabled by default;
+  * enable them via the `stats` option or by setting `cache.stats.enabled = true`.
+  * @returns {Stats} - The statistics for this CacheableMemory instance
+  */
+  get stats() {
+    return this._stats;
+  }
+  /**
+  * Gets the number of hash stores
+  * @returns {number} - The number of hash stores
+  */
   get storeHashSize() {
     return this._storeHashSize;
   }
   /**
-   * Sets the number of hash stores. This will recreate the store and all data will be cleared
-   * @param {number} value - The number of hash stores
-   */
+  * Sets the number of hash stores. This will recreate the store and all data will be cleared
+  * @param {number} value - The number of hash stores
+  */
   set storeHashSize(value) {
-    if (value === this._storeHashSize) {
-      return;
-    }
+    if (value === this._storeHashSize) return;
     this._storeHashSize = value;
-    this._store = Array.from(
-      { length: this._storeHashSize },
-      () => /* @__PURE__ */ new Map()
-    );
+    this._store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
+    if (this._stats.enabled) this._stats.resetStoreValues();
   }
   /**
-   * Gets the store hash algorithm
-   * @returns {HashAlgorithm | StoreHashAlgorithmFunction} - The store hash algorithm
-   */
+  * Gets the store hash algorithm
+  * @returns {HashAlgorithm | StoreHashAlgorithmFunction} - The store hash algorithm
+  */
   get storeHashAlgorithm() {
     return this._storeHashAlgorithm;
   }
   /**
-   * Sets the store hash algorithm. This will recreate the store and all data will be cleared
-   * @param {HashAlgorithm | HashAlgorithmFunction} value - The store hash algorithm
-   */
+  * Sets the store hash algorithm. This will recreate the store and all data will be cleared
+  * @param {HashAlgorithm | HashAlgorithmFunction} value - The store hash algorithm
+  */
   set storeHashAlgorithm(value) {
     this._storeHashAlgorithm = value;
   }
   /**
-   * Gets the keys
-   * @returns {IterableIterator<string>} - The keys
-   */
+  * Gets the keys
+  * @returns {IterableIterator<string>} - The keys
+  */
   get keys() {
     const keys2 = [];
-    for (const store of this._store) {
-      for (const key of store.keys()) {
-        const item = store.get(key);
-        if (item && this.hasExpired(item)) {
-          store.delete(key);
-          continue;
-        }
-        keys2.push(key);
+    for (const store of this._store) for (const key of store.keys()) {
+      const item = store.get(key);
+      if (item && this.hasExpired(item)) {
+        this.recordExpiration(item);
+        store.delete(key);
+        this.lruRemove(key);
+        continue;
       }
+      keys2.push(key);
     }
     return keys2.values();
   }
   /**
-   * Gets the items
-   * @returns {IterableIterator<CacheableStoreItem>} - The items
-   */
+  * Gets the items
+  * @returns {IterableIterator<CacheableStoreItem>} - The items
+  */
   get items() {
     const items = [];
-    for (const store of this._store) {
-      for (const item of store.values()) {
-        if (this.hasExpired(item)) {
-          store.delete(item.key);
-          continue;
-        }
-        items.push(item);
+    for (const store of this._store) for (const item of store.values()) {
+      if (this.hasExpired(item)) {
+        this.recordExpiration(item);
+        store.delete(item.key);
+        this.lruRemove(item.key);
+        continue;
       }
+      items.push(item);
     }
     return items.values();
   }
   /**
-   * Gets the store
-   * @returns {Array<Map<string, CacheableStoreItem>>} - The store
-   */
+  * Gets the store
+  * @returns {Array<Map<string, CacheableStoreItem>>} - The store
+  */
   get store() {
     return this._store;
   }
   /**
-   * Gets the value of the key
-   * @param {string} key - The key to get the value
-   * @returns {T | undefined} - The value of the key
-   */
+  * Gets the value of the key
+  * @param {string} key - The key to get the value
+  * @returns {T | undefined} - The value of the key
+  */
   get(key) {
+    this.hookSync("BEFORE_GET", key);
     const store = this.getStore(key);
     const item = store.get(key);
     if (!item) {
-      return void 0;
+      this.recordRead(false);
+      this.hookSync("AFTER_GET", {
+        key,
+        result: void 0
+      });
+      return;
     }
     if (item.expires && Date.now() > item.expires) {
+      this.recordExpiration(item);
       store.delete(key);
-      return void 0;
+      this.lruRemove(key);
+      this.recordRead(false);
+      this.hookSync("AFTER_GET", {
+        key,
+        result: void 0
+      });
+      return;
     }
     this.lruMoveToFront(key);
-    if (!this._useClone) {
-      return item.value;
-    }
-    return this.clone(item.value);
+    let result;
+    if (!this._useClone) result = item.value;
+    else result = this.clone(item.value);
+    this.recordRead(true);
+    this.hookSync("AFTER_GET", {
+      key,
+      result
+    });
+    return result;
   }
   /**
-   * Gets the values of the keys
-   * @param {string[]} keys - The keys to get the values
-   * @returns {T[]} - The values of the keys
-   */
+  * Gets the values of the keys
+  * @param {string[]} keys - The keys to get the values
+  * @returns {T[]} - The values of the keys
+  */
   getMany(keys2) {
+    this.hookSync("BEFORE_GET_MANY", keys2);
     const result = [];
-    for (const key of keys2) {
-      result.push(this.get(key));
-    }
+    for (const key of keys2) result.push(this.get(key));
+    this.hookSync("AFTER_GET_MANY", {
+      keys: keys2,
+      result
+    });
     return result;
   }
   /**
-   * Gets the raw value of the key
-   * @param {string} key - The key to get the value
-   * @returns {CacheableStoreItem | undefined} - The raw value of the key
-   */
+  * Gets the raw value of the key
+  * @param {string} key - The key to get the value
+  * @returns {CacheableStoreItem | undefined} - The raw value of the key
+  */
   getRaw(key) {
     const store = this.getStore(key);
     const item = store.get(key);
     if (!item) {
-      return void 0;
+      this.recordRead(false);
+      return;
     }
-    if (item.expires && item.expires && Date.now() > item.expires) {
+    if (item.expires && Date.now() > item.expires) {
+      this.recordExpiration(item);
       store.delete(key);
-      return void 0;
+      this.lruRemove(key);
+      this.recordRead(false);
+      return;
     }
     this.lruMoveToFront(key);
+    this.recordRead(true);
     return item;
   }
   /**
-   * Gets the raw values of the keys
-   * @param {string[]} keys - The keys to get the values
-   * @returns {CacheableStoreItem[]} - The raw values of the keys
-   */
+  * Gets the raw values of the keys
+  * @param {string[]} keys - The keys to get the values
+  * @returns {CacheableStoreItem[]} - The raw values of the keys
+  */
   getManyRaw(keys2) {
     const result = [];
-    for (const key of keys2) {
-      result.push(this.getRaw(key));
-    }
+    for (const key of keys2) result.push(this.getRaw(key));
     return result;
   }
   /**
-   * Sets the value of the key
-   * @param {string} key - The key to set the value
-   * @param {any} value - The value to set
-   * @param {number|string|SetOptions} [ttl] - Time to Live - If you set a number it is miliseconds, if you set a string it is a human-readable.
-   * If you want to set expire directly you can do that by setting the expire property in the SetOptions.
-   * If you set undefined, it will use the default time-to-live. If both are undefined then it will not have a time-to-live.
-   * @returns {void}
-   */
+  * Sets the value of the key
+  * @param {string} key - The key to set the value
+  * @param {any} value - The value to set
+  * @param {number|string|SetOptions} [ttl] - Time to Live - If you set a number it is miliseconds, if you set a string it is a human-readable.
+  * If you want to set expire directly you can do that by setting the expire property in the SetOptions.
+  * If you set undefined, it will use the default time-to-live. If both are undefined then it will not have a time-to-live.
+  * @returns {void}
+  */
   set(key, value, ttl) {
-    const store = this.getStore(key);
+    const hookItem = {
+      key,
+      value,
+      ttl
+    };
+    this.hookSync("BEFORE_SET", hookItem);
+    const store = this.getStore(hookItem.key);
     let expires;
-    if (ttl !== void 0 || this._ttl !== void 0) {
-      if (typeof ttl === "object") {
-        if (ttl.expire) {
-          expires = typeof ttl.expire === "number" ? ttl.expire : ttl.expire.getTime();
-        }
-        if (ttl.ttl) {
-          const finalTtl = shorthandToTime(ttl.ttl);
-          if (finalTtl !== void 0) {
-            expires = finalTtl;
-          }
-        }
-      } else {
-        const finalTtl = shorthandToTime(ttl ?? this._ttl);
-        if (finalTtl !== void 0) {
-          expires = finalTtl;
+    const effectiveTtl = hookItem.ttl;
+    if (effectiveTtl !== void 0 || this._ttl !== void 0) if (typeof effectiveTtl === "object") {
+      if (effectiveTtl.expire) expires = typeof effectiveTtl.expire === "number" ? effectiveTtl.expire : effectiveTtl.expire.getTime();
+      if (effectiveTtl.ttl) {
+        const finalTtl = shorthandToTime(effectiveTtl.ttl);
+        if (finalTtl !== void 0) expires = finalTtl;
+      }
+    } else {
+      const finalTtl = shorthandToTime(effectiveTtl ?? this._ttl);
+      if (finalTtl !== void 0) expires = finalTtl;
+    }
+    if (this._maxTtl !== void 0) {
+      const maxExpires = shorthandToTime(this._maxTtl);
+      if (expires === void 0) expires = maxExpires;
+      else if (expires > maxExpires) expires = maxExpires;
+    }
+    if (this._lruSize > 0) if (store.has(hookItem.key)) this.lruMoveToFront(hookItem.key);
+    else {
+      this.lruAddToFront(hookItem.key);
+      if (this._lru.size > this._lruSize) {
+        const oldestKey = this._lru.getOldest();
+        if (oldestKey) {
+          this._lru.removeOldest();
+          this.delete(oldestKey);
         }
       }
     }
-    if (this._lruSize > 0) {
-      if (store.has(key)) {
-        this.lruMoveToFront(key);
-      } else {
-        this.lruAddToFront(key);
-        if (this._lru.size > this._lruSize) {
-          const oldestKey = this._lru.getOldest();
-          if (oldestKey) {
-            this._lru.removeOldest();
-            this.delete(oldestKey);
-          }
-        }
+    if (this._stats.enabled) {
+      const existing = store.get(hookItem.key);
+      if (existing) this._stats.decreaseVSize(existing.value);
+      else {
+        this._stats.incrementKSize(hookItem.key);
+        this._stats.incrementCount();
       }
+      this._stats.incrementVSize(hookItem.value);
+      this._stats.incrementSets();
     }
-    const item = { key, value, expires };
-    store.set(key, item);
+    const item = {
+      key: hookItem.key,
+      value: hookItem.value,
+      expires
+    };
+    store.set(hookItem.key, item);
+    this.hookSync("AFTER_SET", hookItem);
   }
   /**
-   * Sets the values of the keys
-   * @param {CacheableItem[]} items - The items to set
-   * @returns {void}
-   */
+  * Sets the values of the keys
+  * @param {CacheableItem[]} items - The items to set
+  * @returns {void}
+  */
   setMany(items) {
-    for (const item of items) {
-      this.set(item.key, item.value, item.ttl);
-    }
+    this.hookSync("BEFORE_SET_MANY", items);
+    for (const item of items) this.set(item.key, item.value, item.ttl);
+    this.hookSync("AFTER_SET_MANY", items);
   }
   /**
-   * Checks if the key exists
-   * @param {string} key - The key to check
-   * @returns {boolean} - If true, the key exists. If false, the key does not exist.
-   */
+  * Checks if the key exists
+  * @param {string} key - The key to check
+  * @returns {boolean} - If true, the key exists. If false, the key does not exist.
+  */
   has(key) {
     const item = this.get(key);
     return Boolean(item);
   }
   /**
-   * @function hasMany
-   * @param {string[]} keys - The keys to check
-   * @returns {boolean[]} - If true, the key exists. If false, the key does not exist.
-   */
+  * @function hasMany
+  * @param {string[]} keys - The keys to check
+  * @returns {boolean[]} - If true, the key exists. If false, the key does not exist.
+  */
   hasMany(keys2) {
     const result = [];
     for (const key of keys2) {
@@ -3874,65 +4727,76 @@ var CacheableMemory = class extends Hookified {
     return result;
   }
   /**
-   * Take will get the key and delete the entry from cache
-   * @param {string} key - The key to take
-   * @returns {T | undefined} - The value of the key
-   */
+  * Take will get the key and delete the entry from cache
+  * @param {string} key - The key to take
+  * @returns {T | undefined} - The value of the key
+  */
   take(key) {
     const item = this.get(key);
-    if (!item) {
-      return void 0;
-    }
+    if (!item) return;
     this.delete(key);
     return item;
   }
   /**
-   * TakeMany will get the keys and delete the entries from cache
-   * @param {string[]} keys - The keys to take
-   * @returns {T[]} - The values of the keys
-   */
+  * TakeMany will get the keys and delete the entries from cache
+  * @param {string[]} keys - The keys to take
+  * @returns {T[]} - The values of the keys
+  */
   takeMany(keys2) {
     const result = [];
-    for (const key of keys2) {
-      result.push(this.take(key));
-    }
+    for (const key of keys2) result.push(this.take(key));
     return result;
   }
   /**
-   * Delete the key
-   * @param {string} key - The key to delete
-   * @returns {void}
-   */
+  * Delete the key
+  * @param {string} key - The key to delete
+  * @returns {void}
+  */
   delete(key) {
+    this.hookSync("BEFORE_DELETE", key);
     const store = this.getStore(key);
+    if (this._stats.enabled) {
+      const item = store.get(key);
+      if (item) {
+        this._stats.decreaseKSize(key);
+        this._stats.decreaseVSize(item.value);
+        this._stats.decreaseCount();
+        this._stats.incrementDeletes();
+      }
+    }
     store.delete(key);
+    this.lruRemove(key);
+    this.hookSync("AFTER_DELETE", key);
   }
   /**
-   * Delete the keys
-   * @param {string[]} keys - The keys to delete
-   * @returns {void}
-   */
+  * Delete the keys
+  * @param {string[]} keys - The keys to delete
+  * @returns {void}
+  */
   deleteMany(keys2) {
-    for (const key of keys2) {
-      this.delete(key);
-    }
+    this.hookSync("BEFORE_DELETE_MANY", keys2);
+    for (const key of keys2) this.delete(key);
+    this.hookSync("AFTER_DELETE_MANY", keys2);
   }
   /**
-   * Clear the cache
-   * @returns {void}
-   */
+  * Clear the cache
+  * @returns {void}
+  */
   clear() {
-    this._store = Array.from(
-      { length: this._storeHashSize },
-      () => /* @__PURE__ */ new Map()
-    );
+    this.hookSync("BEFORE_CLEAR");
+    this._store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
     this._lru = new DoublyLinkedList();
+    if (this._stats.enabled) {
+      this._stats.resetStoreValues();
+      this._stats.incrementClears();
+    }
+    this.hookSync("AFTER_CLEAR");
   }
   /**
-   * Get the store based on the key (internal use)
-   * @param {string} key - The key to get the store
-   * @returns {CacheableHashStore} - The store
-   */
+  * Get the store based on the key (internal use)
+  * @param {string} key - The key to get the store
+  * @returns {CacheableHashStore} - The store
+  */
   getStore(key) {
     var _a;
     const hash2 = this.getKeyStoreHash(key);
@@ -3940,64 +4804,60 @@ var CacheableMemory = class extends Hookified {
     return this._store[hash2];
   }
   /**
-   * Hash the key for which store to go to (internal use)
-   * @param {string} key - The key to hash
-   * Available algorithms are: SHA256, SHA1, MD5, and djb2Hash.
-   * @returns {number} - The hashed key as a number
-   */
+  * Hash the key for which store to go to (internal use)
+  * @param {string} key - The key to hash
+  * Available algorithms are: SHA256, SHA1, MD5, and djb2Hash.
+  * @returns {number} - The hashed key as a number
+  */
   getKeyStoreHash(key) {
-    if (this._store.length === 1) {
-      return 0;
-    }
-    if (typeof this._storeHashAlgorithm === "function") {
-      return this._storeHashAlgorithm(key, this._storeHashSize);
-    }
-    const storeHashSize = this._storeHashSize - 1;
-    const hash2 = hashToNumberSync(key, {
+    if (this._store.length === 1) return 0;
+    if (typeof this._storeHashAlgorithm === "function") return this._storeHashAlgorithm(key, this._storeHashSize);
+    return hashToNumberSync(key, {
       min: 0,
-      max: storeHashSize,
+      max: this._storeHashSize - 1,
       algorithm: this._storeHashAlgorithm
     });
-    return hash2;
   }
   /**
-   * Clone the value. This is for internal use
-   * @param {any} value - The value to clone
-   * @returns {any} - The cloned value
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: type format
+  * Clone the value. This is for internal use
+  * @param {any} value - The value to clone
+  * @returns {any} - The cloned value
+  */
   clone(value) {
-    if (this.isPrimitive(value)) {
-      return value;
-    }
+    if (this.isPrimitive(value)) return value;
     return structuredClone(value);
   }
   /**
-   * Add to the front of the LRU cache. This is for internal use
-   * @param {string} key - The key to add to the front
-   * @returns {void}
-   */
+  * Add to the front of the LRU cache. This is for internal use
+  * @param {string} key - The key to add to the front
+  * @returns {void}
+  */
   lruAddToFront(key) {
-    if (this._lruSize === 0) {
-      return;
-    }
+    if (this._lruSize === 0) return;
     this._lru.addToFront(key);
   }
   /**
-   * Move to the front of the LRU cache. This is for internal use
-   * @param {string} key - The key to move to the front
-   * @returns {void}
-   */
+  * Move to the front of the LRU cache. This is for internal use
+  * @param {string} key - The key to move to the front
+  * @returns {void}
+  */
   lruMoveToFront(key) {
-    if (this._lruSize === 0) {
-      return;
-    }
+    if (this._lruSize === 0) return;
     this._lru.moveToFront(key);
   }
   /**
-   * Resize the LRU cache. This is for internal use.
-   * @returns {void}
-   */
+  * Remove a key from the LRU cache. This is for internal use
+  * @param {string} key - The key to remove
+  * @returns {void}
+  */
+  lruRemove(key) {
+    if (this._lruSize === 0) return;
+    this._lru.remove(key);
+  }
+  /**
+  * Resize the LRU cache. This is for internal use.
+  * @returns {void}
+  */
   lruResize() {
     while (this._lru.size > this._lruSize) {
       const oldestKey = this._lru.getOldest();
@@ -4008,83 +4868,116 @@ var CacheableMemory = class extends Hookified {
     }
   }
   /**
-   * Check for expiration. This is for internal use
-   * @returns {void}
-   */
+  * Check for expiration. This is for internal use
+  * @returns {void}
+  */
   checkExpiration() {
-    for (const store of this._store) {
-      for (const item of store.values()) {
-        if (item.expires && Date.now() > item.expires) {
-          store.delete(item.key);
-        }
-      }
+    for (const store of this._store) for (const item of store.values()) if (item.expires && Date.now() > item.expires) {
+      this.recordExpiration(item);
+      store.delete(item.key);
+      this.lruRemove(item.key);
     }
   }
   /**
-   * Start the interval check. This is for internal use
-   * @returns {void}
-   */
+  * Start the interval check. This is for internal use
+  * @returns {void}
+  */
   startIntervalCheck() {
     if (this._checkInterval > 0) {
-      if (this._interval) {
+      if (this._interval)
         clearInterval(this._interval);
-      }
       this._interval = setInterval(() => {
         this.checkExpiration();
       }, this._checkInterval).unref();
     }
   }
   /**
-   * Stop the interval check. This is for internal use
-   * @returns {void}
-   */
+  * Stop the interval check. This is for internal use
+  * @returns {void}
+  */
   stopIntervalCheck() {
-    if (this._interval) {
-      clearInterval(this._interval);
-    }
+    if (this._interval) clearInterval(this._interval);
     this._interval = 0;
     this._checkInterval = 0;
   }
   /**
-   * Wrap the function for caching
-   * @param {Function} function_ - The function to wrap
-   * @param {Object} [options] - The options to wrap
-   * @returns {Function} - The wrapped function
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: type format
+  * Wrap the function for caching
+  * @param {Function} function_ - The function to wrap
+  * @param {Object} [options] - The options to wrap
+  * @returns {Function} - The wrapped function
+  */
   wrap(function_, options) {
-    const wrapOptions = {
+    return wrapSync(function_, {
       ttl: options?.ttl ?? this._ttl,
       keyPrefix: options?.keyPrefix,
       createKey: options?.createKey,
       cache: this
-    };
-    return wrapSync(function_, wrapOptions);
+    });
+  }
+  /**
+  * Gets the value of the key, or computes and stores it on a cache miss. This is the synchronous
+  * cache-aside helper: if the key is present its value is returned, otherwise `function_` is
+  * invoked, its result is stored, and that result is returned.
+  *
+  * The value is stored using `options.ttl`, falling back to the instance default `ttl`. Because
+  * the cache is synchronous there is no request coalescing — concurrent callers cannot stampede
+  * the setter the way they can with an async cache.
+  * @param {GetOrSetSyncKey} key - The key to get or set. Can also be a function that returns the key.
+  * @param {() => T} function_ - The function that computes the value on a cache miss.
+  * @param {GetOrSetFunctionOptions} [options] - Options such as `ttl`, `cacheErrors`, and `throwErrors`.
+  * @returns {T | undefined} - The cached or freshly computed value
+  */
+  getOrSet(key, function_, options) {
+    return getOrSetSync(key, function_, {
+      cache: this,
+      ttl: options?.ttl ?? this._ttl,
+      cacheErrors: options?.cacheErrors,
+      throwErrors: options?.throwErrors
+    });
+  }
+  /**
+  * Records a single read against the statistics counters. Each read increments `gets` and either
+  * `hits` or `misses`. No-op when statistics are disabled. This is for internal use.
+  * @param {boolean} hit - Whether the read found a (non-expired) value
+  * @returns {void}
+  */
+  recordRead(hit) {
+    if (!this._stats.enabled) return;
+    if (hit) this._stats.incrementHits();
+    else this._stats.incrementMisses();
+    this._stats.incrementGets();
+  }
+  /**
+  * Decrements the size statistics (`count`, `ksize`, and `vsize`) for an entry that is being removed
+  * because it expired. Expirations are not counted as `deletes` since they are not user-initiated.
+  * No-op when statistics are disabled. This is for internal use.
+  * @param {CacheableStoreItem} item - The expired item being removed from the store
+  * @returns {void}
+  */
+  recordExpiration(item) {
+    if (!this._stats.enabled) return;
+    this._stats.decreaseKSize(item.key);
+    this._stats.decreaseVSize(item.value);
+    this._stats.decreaseCount();
   }
-  // biome-ignore lint/suspicious/noExplicitAny: type format
   isPrimitive(value) {
     const result = false;
-    if (value === null || value === void 0) {
-      return true;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      return true;
-    }
+    if (value === null || value === void 0) return true;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return true;
     return result;
   }
   setTtl(ttl) {
-    if (typeof ttl === "string" || ttl === void 0) {
-      this._ttl = ttl;
-    } else if (ttl > 0) {
-      this._ttl = ttl;
-    } else {
-      this._ttl = void 0;
-    }
+    if (typeof ttl === "string" || ttl === void 0) this._ttl = ttl;
+    else if (ttl > 0) this._ttl = ttl;
+    else this._ttl = void 0;
+  }
+  setMaxTtl(maxTtl) {
+    if (typeof maxTtl === "string" || maxTtl === void 0) this._maxTtl = maxTtl;
+    else if (maxTtl > 0) this._maxTtl = maxTtl;
+    else this._maxTtl = void 0;
   }
   hasExpired(item) {
-    if (item.expires && Date.now() > item.expires) {
-      return true;
-    }
+    if (item.expires && Date.now() > item.expires) return true;
     return false;
   }
 };
@@ -4099,26 +4992,21 @@ var object = "object";
 var noop = (_2, value) => value;
 var primitives = (value) => value instanceof Primitive ? Primitive(value) : value;
 var Primitives = (_2, value) => typeof value === primitive ? new Primitive(value) : value;
-var revive = (input, parsed, output, $) => {
-  const lazy = [];
+var resolver = (input, lazy, parsed, $) => (output) => {
   for (let ke = keys(output), { length } = ke, y = 0; y < length; y++) {
     const k = ke[y];
     const value = output[k];
     if (value instanceof Primitive) {
-      const tmp = input[value];
+      const tmp = input[+value];
       if (typeof tmp === object && !parsed.has(tmp)) {
         parsed.add(tmp);
         output[k] = ignore;
-        lazy.push({ k, a: [input, parsed, tmp, $] });
+        lazy.push({ o: output, k, r: tmp });
       } else
         output[k] = $.call(output, k, tmp);
     } else if (output[k] !== ignore)
       output[k] = $.call(output, k, value);
   }
-  for (let { length } = lazy, i = 0; i < length; i++) {
-    const { k, a } = lazy[i];
-    output[k] = $.call(output, k, revive.apply(null, a));
-  }
   return output;
 };
 var set = (known, input, value) => {
@@ -4128,10 +5016,19 @@ var set = (known, input, value) => {
 };
 var parse = (text, reviver) => {
   const input = $parse(text, Primitives).map(primitives);
-  const value = input[0];
   const $ = reviver || noop;
-  const tmp = typeof value === object && value ? revive(input, /* @__PURE__ */ new Set(), value, $) : value;
-  return $.call({ "": tmp }, "", tmp);
+  let value = input[0];
+  if (typeof value === object && value) {
+    const lazy = [];
+    const revive = resolver(input, lazy, /* @__PURE__ */ new Set(), $);
+    value = revive(value);
+    let i = 0;
+    while (i < lazy.length) {
+      const { o, k, r } = lazy[i++];
+      o[k] = $.call(o, k, revive(r));
+    }
+  }
+  return $.call({ "": value }, "", value);
 };
 var stringify2 = (value, replacer, space) => {
   const $ = replacer && typeof replacer === object ? (k, v) => k === "" || -1 < replacer.indexOf(k) ? v : void 0 : replacer || noop;
@@ -4161,7 +5058,7 @@ var stringify2 = (value, replacer, space) => {
   }
 };
 
-// node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
+// node_modules/file-entry-cache/node_modules/flat-cache/dist/index.mjs
 var FlatCache = class extends Hookified {
   _cache = new CacheableMemory();
   _cacheDir = ".cache";
@@ -4173,169 +5070,137 @@ var FlatCache = class extends Hookified {
   _stringify = stringify2;
   constructor(options) {
     super();
-    if (options) {
-      this._cache = new CacheableMemory({
-        ttl: options.ttl,
-        useClone: options.useClone,
-        lruSize: options.lruSize,
-        checkInterval: options.expirationInterval
-      });
-    }
-    if (options?.cacheDir) {
-      this._cacheDir = options.cacheDir;
-    }
-    if (options?.cacheId) {
-      this._cacheId = options.cacheId;
-    }
+    if (options) this._cache = new CacheableMemory({
+      ttl: options.ttl,
+      useClone: options.useClone,
+      lruSize: options.lruSize,
+      checkInterval: options.expirationInterval
+    });
+    if (options?.cacheDir) this._cacheDir = options.cacheDir;
+    if (options?.cacheId) this._cacheId = options.cacheId;
     if (options?.persistInterval) {
       this._persistInterval = options.persistInterval;
       this.startAutoPersist();
     }
-    if (options?.deserialize) {
-      this._parse = options.deserialize;
-    }
-    if (options?.serialize) {
-      this._stringify = options.serialize;
-    }
+    if (options?.deserialize) this._parse = options.deserialize;
+    if (options?.serialize) this._stringify = options.serialize;
   }
   /**
-   * The cache object
-   * @property cache
-   * @type {CacheableMemory}
-   */
+  * The cache object
+  * @property cache
+  * @type {CacheableMemory}
+  */
   get cache() {
     return this._cache;
   }
   /**
-   * The cache directory
-   * @property cacheDir
-   * @type {String}
-   * @default '.cache'
-   */
+  * The cache directory
+  * @property cacheDir
+  * @type {String}
+  * @default '.cache'
+  */
   get cacheDir() {
     return this._cacheDir;
   }
   /**
-   * Set the cache directory
-   * @property cacheDir
-   * @type {String}
-   * @default '.cache'
-   */
+  * Set the cache directory
+  * @property cacheDir
+  * @type {String}
+  * @default '.cache'
+  */
   set cacheDir(value) {
     this._cacheDir = value;
   }
   /**
-   * The cache id
-   * @property cacheId
-   * @type {String}
-   * @default 'cache1'
-   */
+  * The cache id
+  * @property cacheId
+  * @type {String}
+  * @default 'cache1'
+  */
   get cacheId() {
     return this._cacheId;
   }
   /**
-   * Set the cache id
-   * @property cacheId
-   * @type {String}
-   * @default 'cache1'
-   */
+  * Set the cache id
+  * @property cacheId
+  * @type {String}
+  * @default 'cache1'
+  */
   set cacheId(value) {
     this._cacheId = value;
   }
   /**
-   * The flag to indicate if there are changes since the last save
-   * @property changesSinceLastSave
-   * @type {Boolean}
-   * @default false
-   */
+  * The flag to indicate if there are changes since the last save
+  * @property changesSinceLastSave
+  * @type {Boolean}
+  * @default false
+  */
   get changesSinceLastSave() {
     return this._changesSinceLastSave;
   }
   /**
-   * The interval to persist the cache to disk. 0 means no timed persistence
-   * @property persistInterval
-   * @type {Number}
-   * @default 0
-   */
+  * The interval to persist the cache to disk. 0 means no timed persistence
+  * @property persistInterval
+  * @type {Number}
+  * @default 0
+  */
   get persistInterval() {
     return this._persistInterval;
   }
   /**
-   * Set the interval to persist the cache to disk. 0 means no timed persistence
-   * @property persistInterval
-   * @type {Number}
-   * @default 0
-   */
+  * Set the interval to persist the cache to disk. 0 means no timed persistence
+  * @property persistInterval
+  * @type {Number}
+  * @default 0
+  */
   set persistInterval(value) {
     this._persistInterval = value;
   }
   /**
-   * Load a cache identified by the given Id. If the element does not exists, then initialize an empty
-   * cache storage. If specified `cacheDir` will be used as the directory to persist the data to. If omitted
-   * then the cache module directory `.cacheDir` will be used instead
-   *
-   * @method load
-   * @param cacheId {String} the id of the cache, would also be used as the name of the file cache
-   * @param cacheDir {String} directory for the cache entry
-   */
+  * Load a cache identified by the given Id. If the element does not exists, then initialize an empty
+  * cache storage. If specified `cacheDir` will be used as the directory to persist the data to. If omitted
+  * then the cache module directory `.cacheDir` will be used instead
+  *
+  * @method load
+  * @param cacheId {String} the id of the cache, would also be used as the name of the file cache
+  * @param cacheDir {String} directory for the cache entry
+  */
   load(cacheId, cacheDir) {
     try {
-      const filePath = path10.resolve(
-        `${cacheDir ?? this._cacheDir}/${cacheId ?? this._cacheId}`
-      );
+      const filePath = path10.resolve(`${cacheDir ?? this._cacheDir}/${cacheId ?? this._cacheId}`);
       this.loadFile(filePath);
-      this.emit(
-        "load"
-        /* LOAD */
-      );
+      this.emit("load");
     } catch (error) {
       this.emit("error", error);
     }
   }
   /**
-   * Load the cache from the provided file
-   * @method loadFile
-   * @param  {String} pathToFile the path to the file containing the info for the cache
-   */
+  * Load the cache from the provided file
+  * @method loadFile
+  * @param  {String} pathToFile the path to the file containing the info for the cache
+  */
   loadFile(pathToFile) {
     if (fs5.existsSync(pathToFile)) {
       const data = fs5.readFileSync(pathToFile, "utf8");
       const items = this._parse(data);
       if (Array.isArray(items)) {
-        for (const item of items) {
-          if (item && typeof item === "object" && "key" in item) {
-            if (item.expires) {
-              this._cache.set(item.key, item.value, { expire: item.expires });
-            } else if (item.timestamp) {
-              this._cache.set(item.key, item.value, { expire: item.timestamp });
-            } else {
-              this._cache.set(item.key, item.value);
-            }
-          }
-        }
-      } else {
-        for (const key of Object.keys(items)) {
-          const item = items[key];
-          if (item && typeof item === "object" && "key" in item) {
-            this._cache.set(item.key, item.value, {
-              expire: item.expires
-            });
-          } else {
-            if (item && typeof item === "object" && item.timestamp) {
-              this._cache.set(key, item, { expire: item.timestamp });
-            } else {
-              this._cache.set(key, item);
-            }
-          }
-        }
+        for (const item of items) if (item && typeof item === "object" && "key" in item) if (item.expires) this._cache.set(item.key, item.value, { expire: item.expires });
+        else if (item.timestamp)
+          this._cache.set(item.key, item.value, { expire: item.timestamp });
+        else this._cache.set(item.key, item.value);
+      } else for (const key of Object.keys(items)) {
+        const item = items[key];
+        if (item && typeof item === "object" && "key" in item) this._cache.set(item.key, item.value, { expire: item.expires });
+        else if (item && typeof item === "object" && item.timestamp)
+          this._cache.set(key, item, { expire: item.timestamp });
+        else this._cache.set(key, item);
       }
       this._changesSinceLastSave = true;
     }
   }
   loadFileStream(pathToFile, onProgress, onEnd, onError) {
     if (fs5.existsSync(pathToFile)) {
-      const stats = fs5.statSync(pathToFile);
-      const total = stats.size;
+      const total = fs5.statSync(pathToFile).size;
       let loaded = 0;
       let streamData = "";
       const readStream = fs5.createReadStream(pathToFile, { encoding: "utf8" });
@@ -4346,179 +5211,158 @@ var FlatCache = class extends Hookified {
       });
       readStream.on("end", () => {
         const items = this._parse(streamData);
-        for (const key of Object.keys(items)) {
-          this._cache.set(items[key].key, items[key].value, {
-            expire: items[key].expires
-          });
-        }
+        for (const key of Object.keys(items)) this._cache.set(items[key].key, items[key].value, { expire: items[key].expires });
         this._changesSinceLastSave = true;
         onEnd();
       });
       readStream.on("error", (error) => {
         this.emit("error", error);
-        if (onError) {
-          onError(error);
-        }
+        if (onError) onError(error);
       });
     } else {
-      const error = new Error(`Cache file ${pathToFile} does not exist`);
+      const error = /* @__PURE__ */ new Error(`Cache file ${pathToFile} does not exist`);
       this.emit("error", error);
-      if (onError) {
-        onError(error);
-      }
+      if (onError) onError(error);
     }
   }
   /**
-   * Returns the entire persisted object
-   * @method all
-   * @returns {*}
-   */
+  * Returns the entire persisted object
+  * @method all
+  * @returns {*}
+  */
   all() {
     const result = {};
     const items = [...this._cache.items];
-    for (const item of items) {
-      result[item.key] = item.value;
-    }
+    for (const item of items) result[item.key] = item.value;
     return result;
   }
   /**
-   * Returns an array with all the items in the cache { key, value, expires }
-   * @method items
-   * @returns {Array}
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: cache items can store any value
+  * Returns an array with all the items in the cache { key, value, expires }
+  * @method items
+  * @returns {Array}
+  */
   get items() {
     return [...this._cache.items];
   }
   /**
-   * Returns the path to the file where the cache is persisted
-   * @method cacheFilePath
-   * @returns {String}
-   */
+  * Returns the path to the file where the cache is persisted
+  * @method cacheFilePath
+  * @returns {String}
+  */
   get cacheFilePath() {
     return path10.resolve(`${this._cacheDir}/${this._cacheId}`);
   }
   /**
-   * Returns the path to the cache directory
-   * @method cacheDirPath
-   * @returns {String}
-   */
+  * Returns the path to the cache directory
+  * @method cacheDirPath
+  * @returns {String}
+  */
   get cacheDirPath() {
     return path10.resolve(this._cacheDir);
   }
   /**
-   * Returns an array with all the keys in the cache
-   * @method keys
-   * @returns {Array}
-   */
+  * Returns an array with all the keys in the cache
+  * @method keys
+  * @returns {Array}
+  */
   keys() {
     return [...this._cache.keys];
   }
   /**
-   * (Legacy) set key method. This method will be deprecated in the future
-   * @method setKey
-   * @param key {string} the key to set
-   * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: type format
+  * (Legacy) set key method. This method will be deprecated in the future
+  * @method setKey
+  * @param key {string} the key to set
+  * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
+  */
   setKey(key, value, ttl) {
     this.set(key, value, ttl);
   }
   /**
-   * Sets a key to a given value
-   * @method set
-   * @param key {string} the key to set
-   * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
-   * @param [ttl] {number} the time to live in milliseconds
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: type format
+  * Sets a key to a given value
+  * @method set
+  * @param key {string} the key to set
+  * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
+  * @param [ttl] {number} the time to live in milliseconds
+  */
   set(key, value, ttl) {
     this._cache.set(key, value, ttl);
     this._changesSinceLastSave = true;
   }
   /**
-   * (Legacy) Remove a given key from the cache. This method will be deprecated in the future
-   * @method removeKey
-   * @param key {String} the key to remove from the object
-   */
+  * (Legacy) Remove a given key from the cache. This method will be deprecated in the future
+  * @method removeKey
+  * @param key {String} the key to remove from the object
+  */
   removeKey(key) {
     this.delete(key);
   }
   /**
-   * Remove a given key from the cache
-   * @method delete
-   * @param key {String} the key to remove from the object
-   */
+  * Remove a given key from the cache
+  * @method delete
+  * @param key {String} the key to remove from the object
+  */
   delete(key) {
     this._cache.delete(key);
     this._changesSinceLastSave = true;
     this.emit("delete", key);
   }
   /**
-   * (Legacy) Return the value of the provided key. This method will be deprecated in the future
-   * @method getKey<T>
-   * @param key {String} the name of the key to retrieve
-   * @returns {*} at T the value from the key
-   */
+  * (Legacy) Return the value of the provided key. This method will be deprecated in the future
+  * @method getKey<T>
+  * @param key {String} the name of the key to retrieve
+  * @returns {*} at T the value from the key
+  */
   getKey(key) {
     return this.get(key);
   }
   /**
-   * Return the value of the provided key
-   * @method get<T>
-   * @param key {String} the name of the key to retrieve
-   * @returns {*} at T the value from the key
-   */
+  * Return the value of the provided key
+  * @method get<T>
+  * @param key {String} the name of the key to retrieve
+  * @returns {*} at T the value from the key
+  */
   get(key) {
     return this._cache.get(key);
   }
   /**
-   * Clear the cache and save the state to disk
-   * @method clear
-   */
+  * Clear the cache and save the state to disk
+  * @method clear
+  */
   clear() {
     try {
       this._cache.clear();
       this._changesSinceLastSave = true;
       this.save();
-      this.emit(
-        "clear"
-        /* CLEAR */
-      );
+      this.emit("clear");
     } catch (error) {
       this.emit("error", error);
     }
   }
   /**
-   * Save the state of the cache identified by the docId to disk
-   * as a JSON structure
-   * @method save
-   */
+  * Save the state of the cache identified by the docId to disk
+  * as a JSON structure
+  * @method save
+  */
   save(force = false) {
     try {
       if (this._changesSinceLastSave || force) {
         const filePath = this.cacheFilePath;
         const items = [...this._cache.items];
         const data = this._stringify(items);
-        if (!fs5.existsSync(this._cacheDir)) {
-          fs5.mkdirSync(this._cacheDir, { recursive: true });
-        }
+        if (!fs5.existsSync(this._cacheDir)) fs5.mkdirSync(this._cacheDir, { recursive: true });
         fs5.writeFileSync(filePath, data);
         this._changesSinceLastSave = false;
-        this.emit(
-          "save"
-          /* SAVE */
-        );
+        this.emit("save");
       }
     } catch (error) {
       this.emit("error", error);
     }
   }
   /**
-   * Remove the file where the cache is persisted
-   * @method removeCacheFile
-   * @return {Boolean} true or false if the file was successfully deleted
-   */
+  * Remove the file where the cache is persisted
+  * @method removeCacheFile
+  * @return {Boolean} true or false if the file was successfully deleted
+  */
   removeCacheFile() {
     try {
       if (fs5.existsSync(this.cacheFilePath)) {
@@ -4531,33 +5375,33 @@ var FlatCache = class extends Hookified {
     return false;
   }
   /**
-   * Destroy the cache. This will remove the directory, file, and memory cache
-   * @method destroy
-   * @param [includeCacheDir=false] {Boolean} if true, the cache directory will be removed
-   * @return {undefined}
-   */
+  * Destroy the cache. This will remove the directory, file, and memory cache
+  * @method destroy
+  * @param [includeCacheDir=false] {Boolean} if true, the cache directory will be removed
+  * @return {undefined}
+  */
   destroy(includeCacheDirectory = false) {
     try {
       this._cache.clear();
       this.stopAutoPersist();
-      if (includeCacheDirectory) {
-        fs5.rmSync(this.cacheDirPath, { recursive: true, force: true });
-      } else {
-        fs5.rmSync(this.cacheFilePath, { recursive: true, force: true });
-      }
+      if (includeCacheDirectory) fs5.rmSync(this.cacheDirPath, {
+        recursive: true,
+        force: true
+      });
+      else fs5.rmSync(this.cacheFilePath, {
+        recursive: true,
+        force: true
+      });
       this._changesSinceLastSave = false;
-      this.emit(
-        "destroy"
-        /* DESTROY */
-      );
+      this.emit("destroy");
     } catch (error) {
       this.emit("error", error);
     }
   }
   /**
-   * Start the auto persist interval
-   * @method startAutoPersist
-   */
+  * Start the auto persist interval
+  * @method startAutoPersist
+  */
   startAutoPersist() {
     if (this._persistInterval > 0) {
       if (this._persistTimer) {
@@ -4570,9 +5414,9 @@ var FlatCache = class extends Hookified {
     }
   }
   /**
-   * Stop the auto persist interval
-   * @method stopAutoPersist
-   */
+  * Stop the auto persist interval
+  * @method stopAutoPersist
+  */
   stopAutoPersist() {
     if (this._persistTimer) {
       clearInterval(this._persistTimer);
@@ -4581,16 +5425,14 @@ var FlatCache = class extends Hookified {
   }
 };
 function createFromFile(filePath, options) {
-  const cache = new FlatCache(options);
-  cache.loadFile(filePath);
-  return cache;
+  const cache2 = new FlatCache(options);
+  cache2.loadFile(filePath);
+  return cache2;
 }
 
-// node_modules/file-entry-cache/dist/index.js
+// node_modules/file-entry-cache/dist/index.mjs
 function createFromFile2(filePath, options) {
-  const fname = path11.basename(filePath);
-  const directory = path11.dirname(filePath);
-  return create(fname, directory, options);
+  return create(path11.basename(filePath), path11.dirname(filePath), options);
 }
 function create(cacheId, cacheDirectory, options) {
   const opts = {
@@ -4603,8 +5445,11 @@ function create(cacheId, cacheDirectory, options) {
   const fileEntryCache = new FileEntryCache(opts);
   if (cacheDirectory) {
     const cachePath = `${cacheDirectory}/${cacheId}`;
-    if (fs6.existsSync(cachePath)) {
+    if (fs6.existsSync(cachePath)) try {
       fileEntryCache.cache = createFromFile(cachePath, opts.cache);
+    } catch (error) {
+      if (error instanceof SyntaxError || error instanceof TypeError) fileEntryCache.cache = new FlatCache(opts.cache);
+      else throw error;
     }
   }
   return fileEntryCache;
@@ -4623,239 +5468,249 @@ var FileEntryCache = class {
   _useAbsolutePathAsKey = false;
   _useModifiedTime = true;
   /**
-   * Create a new FileEntryCache instance
-   * @param options - The options for the FileEntryCache (all properties are optional with defaults)
-   */
+  * Snapshot of the persisted meta for each key as of the last load/reconcile.
+  * Change detection compares against this baseline (not the working cache) so
+  * that repeated `getFileDescriptor()` calls keep reporting a file as changed
+  * until the cache is reconciled. The set of keys also tracks which files were
+  * visited during the current session so that `reconcile()` only updates those.
+  */
+  _originalMeta = /* @__PURE__ */ new Map();
+  /**
+  * Create a new FileEntryCache instance
+  * @param options - The options for the FileEntryCache (all properties are optional with defaults)
+  */
   constructor(options) {
-    if (options?.cache) {
-      this._cache = new FlatCache(options.cache);
-    }
-    if (options?.useCheckSum) {
-      this._useCheckSum = options.useCheckSum;
-    }
-    if (options?.hashAlgorithm) {
-      this._hashAlgorithm = options.hashAlgorithm;
-    }
-    if (options?.cwd) {
-      this._cwd = options.cwd;
-    }
-    if (options?.useModifiedTime !== void 0) {
-      this._useModifiedTime = options.useModifiedTime;
-    }
-    if (options?.restrictAccessToCwd !== void 0) {
-      this._restrictAccessToCwd = options.restrictAccessToCwd;
-    }
-    if (options?.useAbsolutePathAsKey !== void 0) {
-      this._useAbsolutePathAsKey = options.useAbsolutePathAsKey;
-    }
-    if (options?.logger) {
-      this._logger = options.logger;
-    }
-  }
-  /**
-   * Get the cache
-   * @returns {FlatCache} The cache
-   */
+    if (options?.cache) this._cache = new FlatCache(options.cache);
+    if (options?.useCheckSum) this._useCheckSum = options.useCheckSum;
+    if (options?.hashAlgorithm) this._hashAlgorithm = options.hashAlgorithm;
+    if (options?.cwd) this._cwd = options.cwd;
+    if (options?.useModifiedTime !== void 0) this._useModifiedTime = options.useModifiedTime;
+    if (options?.restrictAccessToCwd !== void 0) this._restrictAccessToCwd = options.restrictAccessToCwd;
+    if (options?.useAbsolutePathAsKey !== void 0) this._useAbsolutePathAsKey = options.useAbsolutePathAsKey;
+    if (options?.logger) this._logger = options.logger;
+  }
+  /**
+  * Get the cache
+  * @returns {FlatCache} The cache
+  */
   get cache() {
     return this._cache;
   }
   /**
-   * Set the cache
-   * @param {FlatCache} cache - The cache to set
-   */
-  set cache(cache) {
-    this._cache = cache;
+  * Set the cache
+  * @param {FlatCache} cache - The cache to set
+  */
+  set cache(cache2) {
+    this._cache = cache2;
+    this._originalMeta = /* @__PURE__ */ new Map();
   }
   /**
-   * Get the logger
-   * @returns {ILogger | undefined} The logger instance
-   */
+  * Get the logger
+  * @returns {ILogger | undefined} The logger instance
+  */
   get logger() {
     return this._logger;
   }
   /**
-   * Set the logger
-   * @param {ILogger | undefined} logger - The logger to set
-   */
+  * Set the logger
+  * @param {ILogger | undefined} logger - The logger to set
+  */
   set logger(logger) {
     this._logger = logger;
   }
   /**
-   * Use the hash to check if the file has changed
-   * @returns {boolean} if the hash is used to check if the file has changed (default: false)
-   */
+  * Use the hash to check if the file has changed
+  * @returns {boolean} if the hash is used to check if the file has changed (default: false)
+  */
   get useCheckSum() {
     return this._useCheckSum;
   }
   /**
-   * Set the useCheckSum value
-   * @param {boolean} value - The value to set
-   */
+  * Set the useCheckSum value
+  * @param {boolean} value - The value to set
+  */
   set useCheckSum(value) {
     this._useCheckSum = value;
   }
   /**
-   * Get the hash algorithm
-   * @returns {string} The hash algorithm (default: 'md5')
-   */
+  * Get the hash algorithm
+  * @returns {string} The hash algorithm (default: 'md5')
+  */
   get hashAlgorithm() {
     return this._hashAlgorithm;
   }
   /**
-   * Set the hash algorithm
-   * @param {string} value - The value to set
-   */
+  * Set the hash algorithm
+  * @param {string} value - The value to set
+  */
   set hashAlgorithm(value) {
     this._hashAlgorithm = value;
   }
   /**
-   * Get the current working directory
-   * @returns {string} The current working directory (default: process.cwd())
-   */
+  * Get the current working directory
+  * @returns {string} The current working directory (default: process.cwd())
+  */
   get cwd() {
     return this._cwd;
   }
   /**
-   * Set the current working directory
-   * @param {string} value - The value to set
-   */
+  * Set the current working directory
+  *
+  * Note: when relative paths are used as cache keys (the default), `cwd` must
+  * stay stable across a `getFileDescriptor()` / `reconcile()` cycle. Relative
+  * keys are resolved against the *current* `cwd` each time, so changing it
+  * mid-run can cause `reconcile()` to resolve a key to a different (missing)
+  * path and drop the entry. Use absolute keys (`useAbsolutePathAsKey: true`)
+  * if `cwd` must change during a run.
+  * @param {string} value - The value to set
+  */
   set cwd(value) {
     this._cwd = value;
   }
   /**
-   * Get whether to use modified time for change detection
-   * @returns {boolean} Whether modified time (mtime) is used for change detection (default: true)
-   */
+  * Get whether to use modified time for change detection
+  * @returns {boolean} Whether modified time (mtime) is used for change detection (default: true)
+  */
   get useModifiedTime() {
     return this._useModifiedTime;
   }
   /**
-   * Set whether to use modified time for change detection
-   * @param {boolean} value - The value to set
-   */
+  * Set whether to use modified time for change detection
+  * @param {boolean} value - The value to set
+  */
   set useModifiedTime(value) {
     this._useModifiedTime = value;
   }
   /**
-   * Get whether to restrict paths to cwd boundaries
-   * @returns {boolean} Whether strict path checking is enabled (default: true)
-   */
+  * Get whether to restrict paths to cwd boundaries
+  * @returns {boolean} Whether strict path checking is enabled (default: true)
+  */
   get restrictAccessToCwd() {
     return this._restrictAccessToCwd;
   }
   /**
-   * Set whether to restrict paths to cwd boundaries
-   * @param {boolean} value - The value to set
-   */
+  * Set whether to restrict paths to cwd boundaries
+  * @param {boolean} value - The value to set
+  */
   set restrictAccessToCwd(value) {
     this._restrictAccessToCwd = value;
   }
   /**
-   * Get whether to use absolute path as cache key
-   * @returns {boolean} Whether cache keys use absolute paths (default: false)
-   */
+  * Get whether to use absolute path as cache key
+  * @returns {boolean} Whether cache keys use absolute paths (default: false)
+  */
   get useAbsolutePathAsKey() {
     return this._useAbsolutePathAsKey;
   }
   /**
-   * Set whether to use absolute path as cache key
-   * @param {boolean} value - The value to set
-   */
+  * Set whether to use absolute path as cache key
+  * @param {boolean} value - The value to set
+  */
   set useAbsolutePathAsKey(value) {
     this._useAbsolutePathAsKey = value;
   }
   /**
-   * Given a buffer, calculate md5 hash of its content.
-   * @method getHash
-   * @param  {Buffer} buffer   buffer to calculate hash on
-   * @return {String}          content hash digest
-   */
+  * Given a buffer, calculate md5 hash of its content.
+  * @method getHash
+  * @param  {Buffer} buffer   buffer to calculate hash on
+  * @return {String}          content hash digest
+  */
   getHash(buffer) {
     return crypto2.createHash(this._hashAlgorithm).update(buffer).digest("hex");
   }
   /**
-   * Create the key for the file path used for caching.
-   * @method createFileKey
-   * @param {String} filePath
-   * @return {String}
-   */
+  * Create the key for the file path used for caching.
+  * @method createFileKey
+  * @param {String} filePath
+  * @return {String}
+  */
   createFileKey(filePath) {
     let result = filePath;
-    if (this._useAbsolutePathAsKey && this.isRelativePath(filePath)) {
-      result = this.getAbsolutePathWithCwd(filePath, this._cwd);
-    }
+    if (this._useAbsolutePathAsKey && this.isRelativePath(filePath)) result = this.getAbsolutePathWithCwd(filePath, this._cwd);
     return result;
   }
   /**
-   * Check if the file path is a relative path
-   * @method isRelativePath
-   * @param filePath - The file path to check
-   * @returns {boolean} if the file path is a relative path, false otherwise
-   */
+  * Check if the file path is a relative path
+  * @method isRelativePath
+  * @param filePath - The file path to check
+  * @returns {boolean} if the file path is a relative path, false otherwise
+  */
   isRelativePath(filePath) {
     return !path11.isAbsolute(filePath);
   }
   /**
-   * Delete the cache file from the disk
-   * @method deleteCacheFile
-   * @return {boolean}       true if the file was deleted, false otherwise
-   */
+  * Delete the cache file from the disk
+  * @method deleteCacheFile
+  * @return {boolean}       true if the file was deleted, false otherwise
+  */
   deleteCacheFile() {
     return this._cache.removeCacheFile();
   }
   /**
-   * Remove the cache from the file and clear the memory cache
-   * @method destroy
-   */
+  * Remove the cache from the file and clear the memory cache
+  * @method destroy
+  */
   destroy() {
     this._cache.destroy();
+    this._originalMeta = /* @__PURE__ */ new Map();
   }
   /**
-   * Remove and Entry From the Cache
-   * @method removeEntry
-   * @param filePath - The file path to remove from the cache
-   */
+  * Remove and Entry From the Cache
+  * @method removeEntry
+  * @param filePath - The file path to remove from the cache
+  */
   removeEntry(filePath) {
     const key = this.createFileKey(filePath);
     this._cache.removeKey(key);
+    this._originalMeta.delete(key);
   }
   /**
-   * Reconcile the cache
-   * @method reconcile
-   */
+  * Reconcile the cache
+  * @method reconcile
+  */
   reconcile() {
-    const { items } = this._cache;
-    for (const item of items) {
-      const fileDescriptor = this.getFileDescriptor(item.key);
-      if (fileDescriptor.notFound) {
-        this._cache.removeKey(item.key);
-      }
+    for (const key of [...this._cache.keys()]) try {
+      fs6.statSync(this.getAbsolutePath(key));
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        this._cache.removeKey(key);
+        this._originalMeta.delete(key);
+      } else this._logger?.error({
+        key,
+        error
+      }, "reconcile: unable to stat file; keeping cached entry");
+    }
+    for (const key of [...this._originalMeta.keys()]) {
+      const meta = this._cache.getKey(key);
+      if (meta) this._originalMeta.set(key, { ...meta });
+      else this._originalMeta.delete(key);
     }
     this._cache.save();
   }
   /**
-   * Check if the file has changed
-   * @method hasFileChanged
-   * @param filePath - The file path to check
-   * @returns {boolean} if the file has changed, false otherwise
-   */
+  * Check if the file has changed
+  * @method hasFileChanged
+  * @param filePath - The file path to check
+  * @returns {boolean} if the file has changed, false otherwise
+  */
   hasFileChanged(filePath) {
     let result = false;
     const fileDescriptor = this.getFileDescriptor(filePath);
-    if ((!fileDescriptor.err || !fileDescriptor.notFound) && fileDescriptor.changed) {
-      result = true;
-    }
+    if ((!fileDescriptor.err || !fileDescriptor.notFound) && fileDescriptor.changed) result = true;
     return result;
   }
   /**
-   * Get the file descriptor for the file path
-   * @method getFileDescriptor
-   * @param filePath - The file path to get the file descriptor for
-   * @param options - The options for getting the file descriptor
-   * @returns The file descriptor
-   */
+  * Get the file descriptor for the file path
+  * @method getFileDescriptor
+  * @param filePath - The file path to get the file descriptor for
+  * @param options - The options for getting the file descriptor
+  * @returns The file descriptor
+  */
   getFileDescriptor(filePath, options) {
-    this._logger?.debug({ filePath, options }, "Getting file descriptor");
+    this._logger?.debug({
+      filePath,
+      options
+    }, "Getting file descriptor");
     let fstat;
     const result = {
       key: this.createFileKey(filePath),
@@ -4864,39 +5719,33 @@ var FileEntryCache = class {
     };
     this._logger?.trace({ key: result.key }, "Created file key");
     const metaCache = this._cache.getKey(result.key);
-    if (metaCache) {
-      this._logger?.trace({ metaCache }, "Found cached meta");
-    } else {
-      this._logger?.trace("No cached meta found");
-    }
+    if (metaCache) this._logger?.trace({ metaCache }, "Found cached meta");
+    else this._logger?.trace("No cached meta found");
     result.meta = metaCache ? { ...metaCache } : {};
     const absolutePath = this.getAbsolutePath(filePath);
     this._logger?.trace({ absolutePath }, "Resolved absolute path");
     const useCheckSumValue = options?.useCheckSum ?? this._useCheckSum;
-    this._logger?.debug(
-      { useCheckSum: useCheckSumValue },
-      "Using checksum setting"
-    );
+    this._logger?.debug({ useCheckSum: useCheckSumValue }, "Using checksum setting");
     const useModifiedTimeValue = options?.useModifiedTime ?? this.useModifiedTime;
-    this._logger?.debug(
-      { useModifiedTime: useModifiedTimeValue },
-      "Using modified time (mtime) setting"
-    );
+    this._logger?.debug({ useModifiedTime: useModifiedTimeValue }, "Using modified time (mtime) setting");
     try {
       fstat = fs6.statSync(absolutePath);
       result.meta.size = fstat.size;
       result.meta.mtime = fstat.mtime.getTime();
-      this._logger?.trace(
-        { size: result.meta.size, mtime: result.meta.mtime },
-        "Read file stats"
-      );
+      this._logger?.trace({
+        size: result.meta.size,
+        mtime: result.meta.mtime
+      }, "Read file stats");
       if (useCheckSumValue) {
         const buffer = fs6.readFileSync(absolutePath);
         result.meta.hash = this.getHash(buffer);
         this._logger?.trace({ hash: result.meta.hash }, "Calculated file hash");
       }
     } catch (error) {
-      this._logger?.error({ filePath, error }, "Error reading file");
+      this._logger?.error({
+        filePath,
+        error
+      }, "Error reading file");
       this.removeEntry(filePath);
       let notFound = false;
       if (error.message.includes("ENOENT")) {
@@ -4910,47 +5759,49 @@ var FileEntryCache = class {
         meta: {}
       };
     }
-    if (!metaCache) {
+    if (!this._originalMeta.has(result.key)) this._originalMeta.set(result.key, metaCache ? { ...metaCache } : void 0);
+    const baseline = this._originalMeta.get(result.key);
+    if (baseline === void 0) {
       result.changed = true;
       this._cache.setKey(result.key, result.meta);
       this._logger?.debug({ filePath }, "File not in cache, marked as changed");
       return result;
     }
-    if (useModifiedTimeValue && metaCache?.mtime !== result.meta?.mtime) {
+    if (useModifiedTimeValue && baseline.mtime !== result.meta?.mtime) {
       result.changed = true;
-      this._logger?.debug(
-        { filePath, oldMtime: metaCache.mtime, newMtime: result.meta.mtime },
-        "File changed: mtime differs"
-      );
+      this._logger?.debug({
+        filePath,
+        oldMtime: baseline.mtime,
+        newMtime: result.meta.mtime
+      }, "File changed: mtime differs");
     }
-    if (metaCache?.size !== result.meta?.size) {
+    if (baseline.size !== result.meta?.size) {
       result.changed = true;
-      this._logger?.debug(
-        { filePath, oldSize: metaCache.size, newSize: result.meta.size },
-        "File changed: size differs"
-      );
+      this._logger?.debug({
+        filePath,
+        oldSize: baseline.size,
+        newSize: result.meta.size
+      }, "File changed: size differs");
     }
-    if (useCheckSumValue && metaCache?.hash !== result.meta?.hash) {
+    if (useCheckSumValue && baseline.hash !== result.meta?.hash) {
       result.changed = true;
-      this._logger?.debug(
-        { filePath, oldHash: metaCache.hash, newHash: result.meta.hash },
-        "File changed: hash differs"
-      );
+      this._logger?.debug({
+        filePath,
+        oldHash: baseline.hash,
+        newHash: result.meta.hash
+      }, "File changed: hash differs");
     }
     this._cache.setKey(result.key, result.meta);
-    if (result.changed) {
-      this._logger?.info({ filePath }, "File has changed");
-    } else {
-      this._logger?.debug({ filePath }, "File unchanged");
-    }
+    if (result.changed) this._logger?.info({ filePath }, "File has changed");
+    else this._logger?.debug({ filePath }, "File unchanged");
     return result;
   }
   /**
-   * Get the file descriptors for the files
-   * @method normalizeEntries
-   * @param files?: string[] - The files to get the file descriptors for
-   * @returns The file descriptors
-   */
+  * Get the file descriptors for the files
+  * @method normalizeEntries
+  * @param files?: string[] - The files to get the file descriptors for
+  * @returns The file descriptors
+  */
   normalizeEntries(files) {
     const result = [];
     if (files) {
@@ -4963,18 +5814,16 @@ var FileEntryCache = class {
     const keys2 = this.cache.keys();
     for (const key of keys2) {
       const fileDescriptor = this.getFileDescriptor(key);
-      if (!fileDescriptor.notFound && !fileDescriptor.err) {
-        result.push(fileDescriptor);
-      }
+      if (!fileDescriptor.notFound && !fileDescriptor.err) result.push(fileDescriptor);
     }
     return result;
   }
   /**
-   * Analyze the files
-   * @method analyzeFiles
-   * @param files - The files to analyze
-   * @returns {AnalyzedFiles} The analysis of the files
-   */
+  * Analyze the files
+  * @method analyzeFiles
+  * @param files - The files to analyze
+  * @returns {AnalyzedFiles} The analysis of the files
+  */
   analyzeFiles(files) {
     const result = {
       changedFiles: [],
@@ -4982,58 +5831,47 @@ var FileEntryCache = class {
       notChangedFiles: []
     };
     const fileDescriptors = this.normalizeEntries(files);
-    for (const fileDescriptor of fileDescriptors) {
-      if (fileDescriptor.notFound) {
-        result.notFoundFiles.push(fileDescriptor.key);
-      } else if (fileDescriptor.changed) {
-        result.changedFiles.push(fileDescriptor.key);
-      } else {
-        result.notChangedFiles.push(fileDescriptor.key);
-      }
-    }
+    for (const fileDescriptor of fileDescriptors) if (fileDescriptor.notFound) result.notFoundFiles.push(fileDescriptor.key);
+    else if (fileDescriptor.changed) result.changedFiles.push(fileDescriptor.key);
+    else result.notChangedFiles.push(fileDescriptor.key);
     return result;
   }
   /**
-   * Get the updated files
-   * @method getUpdatedFiles
-   * @param files - The files to get the updated files for
-   * @returns {string[]} The updated files
-   */
+  * Get the updated files
+  * @method getUpdatedFiles
+  * @param files - The files to get the updated files for
+  * @returns {string[]} The updated files
+  */
   getUpdatedFiles(files) {
     const result = [];
     const fileDescriptors = this.normalizeEntries(files);
-    for (const fileDescriptor of fileDescriptors) {
-      if (fileDescriptor.changed) {
-        result.push(fileDescriptor.key);
-      }
-    }
+    for (const fileDescriptor of fileDescriptors) if (fileDescriptor.changed) result.push(fileDescriptor.key);
     return result;
   }
   /**
-   * Get the file descriptors by path prefix
-   * @method getFileDescriptorsByPath
-   * @param filePath - the path prefix to match
-   * @returns {FileDescriptor[]} The file descriptors
-   */
+  * Get the file descriptors by path prefix
+  * @method getFileDescriptorsByPath
+  * @param filePath - the path prefix to match
+  * @returns {FileDescriptor[]} The file descriptors
+  */
   getFileDescriptorsByPath(filePath) {
     const result = [];
     const keys2 = this._cache.keys();
-    for (const key of keys2) {
+    for (const key of keys2)
       if (key.startsWith(filePath)) {
         const fileDescriptor = this.getFileDescriptor(key);
         result.push(fileDescriptor);
       }
-    }
     return result;
   }
   /**
-   * Get the Absolute Path. If it is already absolute it will return the path as is.
-   * When restrictAccessToCwd is enabled, ensures the resolved path stays within cwd boundaries.
-   * @method getAbsolutePath
-   * @param filePath - The file path to get the absolute path for
-   * @returns {string}
-   * @throws {Error} When restrictAccessToCwd is true and path would resolve outside cwd
-   */
+  * Get the Absolute Path. If it is already absolute it will return the path as is.
+  * When restrictAccessToCwd is enabled, ensures the resolved path stays within cwd boundaries.
+  * @method getAbsolutePath
+  * @param filePath - The file path to get the absolute path for
+  * @returns {string}
+  * @throws {Error} When restrictAccessToCwd is true and path would resolve outside cwd
+  */
   getAbsolutePath(filePath) {
     if (this.isRelativePath(filePath)) {
       const sanitizedPath = filePath.replace(/\0/g, "");
@@ -5041,26 +5879,21 @@ var FileEntryCache = class {
       if (this._restrictAccessToCwd) {
         const normalizedResolved = path11.normalize(resolved);
         const normalizedCwd = path11.normalize(this._cwd);
-        const isWithinCwd = normalizedResolved === normalizedCwd || normalizedResolved.startsWith(normalizedCwd + path11.sep);
-        if (!isWithinCwd) {
-          throw new Error(
-            `Path traversal attempt blocked: "${filePath}" resolves outside of working directory "${this._cwd}"`
-          );
-        }
+        if (!(normalizedResolved === normalizedCwd || normalizedResolved.startsWith(normalizedCwd + path11.sep))) throw new Error(`Path traversal attempt blocked: "${filePath}" resolves outside of working directory "${this._cwd}"`);
       }
       return resolved;
     }
     return filePath;
   }
   /**
-   * Get the Absolute Path with a custom working directory. If it is already absolute it will return the path as is.
-   * When restrictAccessToCwd is enabled, ensures the resolved path stays within the provided cwd boundaries.
-   * @method getAbsolutePathWithCwd
-   * @param filePath - The file path to get the absolute path for
-   * @param cwd - The custom working directory to resolve relative paths from
-   * @returns {string}
-   * @throws {Error} When restrictAccessToCwd is true and path would resolve outside the provided cwd
-   */
+  * Get the Absolute Path with a custom working directory. If it is already absolute it will return the path as is.
+  * When restrictAccessToCwd is enabled, ensures the resolved path stays within the provided cwd boundaries.
+  * @method getAbsolutePathWithCwd
+  * @param filePath - The file path to get the absolute path for
+  * @param cwd - The custom working directory to resolve relative paths from
+  * @returns {string}
+  * @throws {Error} When restrictAccessToCwd is true and path would resolve outside the provided cwd
+  */
   getAbsolutePathWithCwd(filePath, cwd3) {
     if (this.isRelativePath(filePath)) {
       const sanitizedPath = filePath.replace(/\0/g, "");
@@ -5068,33 +5901,31 @@ var FileEntryCache = class {
       if (this._restrictAccessToCwd) {
         const normalizedResolved = path11.normalize(resolved);
         const normalizedCwd = path11.normalize(cwd3);
-        const isWithinCwd = normalizedResolved === normalizedCwd || normalizedResolved.startsWith(normalizedCwd + path11.sep);
-        if (!isWithinCwd) {
-          throw new Error(
-            `Path traversal attempt blocked: "${filePath}" resolves outside of working directory "${cwd3}"`
-          );
-        }
+        if (!(normalizedResolved === normalizedCwd || normalizedResolved.startsWith(normalizedCwd + path11.sep))) throw new Error(`Path traversal attempt blocked: "${filePath}" resolves outside of working directory "${cwd3}"`);
       }
       return resolved;
     }
     return filePath;
   }
   /**
-   * Rename cache keys that start with a given path prefix.
-   * @method renameCacheKeys
-   * @param oldPath - The old path prefix to rename
-   * @param newPath - The new path prefix to rename to
-   */
+  * Rename cache keys that start with a given path prefix.
+  * @method renameCacheKeys
+  * @param oldPath - The old path prefix to rename
+  * @param newPath - The new path prefix to rename to
+  */
   renameCacheKeys(oldPath, newPath) {
     const keys2 = this._cache.keys();
-    for (const key of keys2) {
+    for (const key of keys2)
       if (key.startsWith(oldPath)) {
         const newKey = key.replace(oldPath, newPath);
         const meta = this._cache.getKey(key);
         this._cache.removeKey(key);
         this._cache.setKey(newKey, meta);
+        if (this._originalMeta.has(key)) {
+          this._originalMeta.set(newKey, this._originalMeta.get(key));
+          this._originalMeta.delete(key);
+        }
       }
-    }
   }
 };
 
@@ -5103,14 +5934,11 @@ import { version as prettierVersion } from "../index.mjs";
 var optionsHashCache = /* @__PURE__ */ new WeakMap();
 var nodeVersion = process.version;
 function getHashOfOptions(options) {
-  if (optionsHashCache.has(options)) {
-    return optionsHashCache.get(options);
-  }
-  const hash2 = createHash(
-    `${prettierVersion}_${nodeVersion}_${(0, import_fast_json_stable_stringify2.default)(options)}`
+  return getOrInsertComputed(
+    optionsHashCache,
+    options,
+    (options2) => createHash(`${prettierVersion}_${nodeVersion}_${(0, import_fast_json_stable_stringify2.default)(options2)}`)
   );
-  optionsHashCache.set(options, hash2);
-  return hash2;
 }
 function getMetadataFromFileDescriptor(fileDescriptor) {
   return fileDescriptor.meta;
@@ -5122,10 +5950,10 @@ var FormatResultsCache = class {
    * @param {string} cacheStrategy
    */
   constructor(cacheFileLocation, cacheStrategy) {
-    const useChecksum = cacheStrategy === "content";
+    const useCheckSum = cacheStrategy === "content";
     const fileEntryCacheOptions = {
-      useChecksum,
-      useModifiedTime: !useChecksum,
+      useCheckSum,
+      useModifiedTime: !useCheckSum,
       restrictAccessToCwd: false
     };
     try {
@@ -5207,6 +6035,9 @@ function stripAnsi(string) {
   if (typeof string !== "string") {
     throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
   }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
   return string.replace(regex, "");
 }
 
@@ -5580,7 +6411,7 @@ function handleError(context, filename, error, printedFilename, ignoreUnknown) {
     return;
   }
   const isParseError = Boolean(error?.loc);
-  const isValidationError = /^Invalid \S+ value\./u.test(error?.message);
+  const isValidationError = /^Invalid \S+ value\./.test(error?.message);
   if (isParseError) {
     context.logger.error(`${filename}: ${String(error)}`);
   } else if (isValidationError || error instanceof errors.ConfigError) {
@@ -5643,21 +6474,20 @@ async function format3(context, input, opt) {
       throw new DebugError(
         "prettier(input) !== prettier(prettier(input))\n" + diff(pp, pppp)
       );
-    } else {
-      const stringify5 = (obj) => JSON.stringify(obj, null, 2);
-      const ast = stringify5(
-        (await prettier.__debug.parse(input, opt, { massage: true })).ast
-      );
-      const past = stringify5(
-        (await prettier.__debug.parse(pp, opt, { massage: true })).ast
+    }
+    const stringify5 = (obj) => JSON.stringify(obj, null, 2);
+    const ast = stringify5(
+      (await prettier.__debug.parse(input, opt, { massage: true })).ast
+    );
+    const past = stringify5(
+      (await prettier.__debug.parse(pp, opt, { massage: true })).ast
+    );
+    if (ast !== past) {
+      const MAX_AST_SIZE = 2097152;
+      const astDiff = ast.length > MAX_AST_SIZE || past.length > MAX_AST_SIZE ? "AST diff too large to render" : diff(ast, past);
+      throw new DebugError(
+        "ast(input) !== ast(prettier(input))\n" + astDiff + "\n" + diff(input, pp)
       );
-      if (ast !== past) {
-        const MAX_AST_SIZE = 2097152;
-        const astDiff = ast.length > MAX_AST_SIZE || past.length > MAX_AST_SIZE ? "AST diff too large to render" : diff(ast, past);
-        throw new DebugError(
-          "ast(input) !== ast(prettier(input))\n" + astDiff + "\n" + diff(input, pp)
-        );
-      }
     }
     return { formatted: pp, filepath: opt.filepath || "(stdin)\n" };
   }
@@ -5957,7 +6787,7 @@ function createLogger(logLevel = "log") {
         /* OPTIONAL_OBJECT: false */
         0,
         message,
-        /^/gmu,
+        /^/gm,
         prefix
       ) + (options.newline ? "\n" : "");
       stream.write(message);
@@ -6030,7 +6860,7 @@ function indent(str, spaces) {
     /* OPTIONAL_OBJECT: false */
     0,
     str,
-    /^/gmu,
+    /^/gm,
     " ".repeat(spaces)
   );
 }