prettier 3.4.2 → 3.5.0

package/internal/cli.mjs

@@ -59,12 +59,12 @@ var require_dashify = __commonJS({
 var require_minimist = __commonJS({
   "node_modules/minimist/index.js"(exports, module) {
     "use strict";
-    function hasKey(obj, keys) {
+    function hasKey(obj, keys2) {
       var o = obj;
-      keys.slice(0, -1).forEach(function(key2) {
+      keys2.slice(0, -1).forEach(function(key2) {
         o = o[key2] || {};
       });
-      var key = keys[keys.length - 1];
+      var key = keys2[keys2.length - 1];
       return key in o;
     }
     function isNumber(x) {
@@ -125,10 +125,10 @@ var require_minimist = __commonJS({
       function argDefined(key2, arg2) {
         return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
       }
-      function setKey(obj, keys, value2) {
+      function setKey(obj, keys2, value2) {
         var o = obj;
-        for (var i2 = 0; i2 < keys.length - 1; i2++) {
-          var key2 = keys[i2];
+        for (var i2 = 0; i2 < keys2.length - 1; i2++) {
+          var key2 = keys2[i2];
           if (isConstructorOrProto(o, key2)) {
             return;
           }
@@ -143,7 +143,7 @@ var require_minimist = __commonJS({
           }
           o = o[key2];
         }
-        var lastKey = keys[keys.length - 1];
+        var lastKey = keys2[keys2.length - 1];
         if (isConstructorOrProto(o, lastKey)) {
           return;
         }
@@ -295,7 +295,7 @@ var require_fast_json_stable_stringify = __commonJS({
         };
       }(opts.cmp);
       var seen = [];
-      return function stringify4(node) {
+      return function stringify5(node) {
         if (node && node.toJSON && typeof node.toJSON === "function") {
           node = node.toJSON();
         }
@@ -307,7 +307,7 @@ var require_fast_json_stable_stringify = __commonJS({
           out = "[";
           for (i = 0; i < node.length; i++) {
             if (i) out += ",";
-            out += stringify4(node[i]) || "null";
+            out += stringify5(node[i]) || "null";
           }
           return out + "]";
         }
@@ -317,11 +317,11 @@ var require_fast_json_stable_stringify = __commonJS({
           throw new TypeError("Converting circular structure to JSON");
         }
         var seenIndex = seen.push(node) - 1;
-        var keys = Object.keys(node).sort(cmp && cmp(node));
+        var keys2 = Object.keys(node).sort(cmp && cmp(node));
         out = "";
-        for (i = 0; i < keys.length; i++) {
-          var key = keys[i];
-          var value = stringify4(node[key]);
+        for (i = 0; i < keys2.length; i++) {
+          var key = keys2[i];
+          var value = stringify5(node[key]);
           if (!value) continue;
           if (out) out += ",";
           out += JSON.stringify(key) + ":" + value;
@@ -339,8 +339,8 @@ var require_common_path_prefix = __commonJS({
     "use strict";
     var { sep: DEFAULT_SEPARATOR } = __require("path");
     var determineSeparator = (paths) => {
-      for (const path10 of paths) {
-        const match = /(\/|\\)/.exec(path10);
+      for (const path12 of paths) {
+        const match = /(\/|\\)/.exec(path12);
         if (match !== null) return match[0];
       }
       return DEFAULT_SEPARATOR;
@@ -350,8 +350,8 @@ var require_common_path_prefix = __commonJS({
       if (first === "" || remaining.length === 0) return "";
       const parts = first.split(sep);
       let endOfPrefix = parts.length;
-      for (const path10 of remaining) {
-        const compare = path10.split(sep);
+      for (const path12 of remaining) {
+        const compare = path12.split(sep);
         for (let i = 0; i < endOfPrefix; i++) {
           if (compare[i] !== parts[i]) {
             endOfPrefix = i;
@@ -365,873 +365,18 @@ var require_common_path_prefix = __commonJS({
   }
 });
 
-// node_modules/json-buffer/index.js
-var require_json_buffer = __commonJS({
-  "node_modules/json-buffer/index.js"(exports) {
-    exports.stringify = function stringify4(o) {
-      if ("undefined" == typeof o) return o;
-      if (o && Buffer.isBuffer(o))
-        return JSON.stringify(":base64:" + o.toString("base64"));
-      if (o && o.toJSON)
-        o = o.toJSON();
-      if (o && "object" === typeof o) {
-        var s = "";
-        var array2 = Array.isArray(o);
-        s = array2 ? "[" : "{";
-        var first = true;
-        for (var k in o) {
-          var ignore = "function" == typeof o[k] || !array2 && "undefined" === typeof o[k];
-          if (Object.hasOwnProperty.call(o, k) && !ignore) {
-            if (!first)
-              s += ",";
-            first = false;
-            if (array2) {
-              if (o[k] == void 0)
-                s += "null";
-              else
-                s += stringify4(o[k]);
-            } else if (o[k] !== void 0) {
-              s += stringify4(k) + ":" + stringify4(o[k]);
-            }
-          }
-        }
-        s += array2 ? "]" : "}";
-        return s;
-      } else if ("string" === typeof o) {
-        return JSON.stringify(/^:/.test(o) ? ":" + o : o);
-      } else if ("undefined" === typeof o) {
-        return "null";
-      } else
-        return JSON.stringify(o);
-    };
-    exports.parse = function(s) {
-      return JSON.parse(s, function(key, value) {
-        if ("string" === typeof value) {
-          if (/^:base64:/.test(value))
-            return Buffer.from(value.substring(8), "base64");
-          else
-            return /^:/.test(value) ? value.substring(1) : value;
-        }
-        return value;
-      });
-    };
-  }
-});
-
-// node_modules/keyv/src/index.js
-var require_src = __commonJS({
-  "node_modules/keyv/src/index.js"(exports, module) {
-    "use strict";
-    var EventEmitter = __require("events");
-    var JSONB = require_json_buffer();
-    var loadStore = (options) => {
-      const adapters = {
-        redis: "@keyv/redis",
-        rediss: "@keyv/redis",
-        mongodb: "@keyv/mongo",
-        mongo: "@keyv/mongo",
-        sqlite: "@keyv/sqlite",
-        postgresql: "@keyv/postgres",
-        postgres: "@keyv/postgres",
-        mysql: "@keyv/mysql",
-        etcd: "@keyv/etcd",
-        offline: "@keyv/offline",
-        tiered: "@keyv/tiered"
-      };
-      if (options.adapter || options.uri) {
-        const adapter = options.adapter || /^[^:+]*/.exec(options.uri)[0];
-        return new (__require(adapters[adapter]))(options);
-      }
-      return /* @__PURE__ */ new Map();
-    };
-    var iterableAdapters = [
-      "sqlite",
-      "postgres",
-      "mysql",
-      "mongo",
-      "redis",
-      "tiered"
-    ];
-    var Keyv = class extends EventEmitter {
-      constructor(uri, { emitErrors = true, ...options } = {}) {
-        super();
-        this.opts = {
-          namespace: "keyv",
-          serialize: JSONB.stringify,
-          deserialize: JSONB.parse,
-          ...typeof uri === "string" ? { uri } : uri,
-          ...options
-        };
-        if (!this.opts.store) {
-          const adapterOptions = { ...this.opts };
-          this.opts.store = loadStore(adapterOptions);
-        }
-        if (this.opts.compression) {
-          const compression = this.opts.compression;
-          this.opts.serialize = compression.serialize.bind(compression);
-          this.opts.deserialize = compression.deserialize.bind(compression);
-        }
-        if (typeof this.opts.store.on === "function" && emitErrors) {
-          this.opts.store.on("error", (error) => this.emit("error", error));
-        }
-        this.opts.store.namespace = this.opts.namespace;
-        const generateIterator = (iterator) => async function* () {
-          for await (const [key, raw] of typeof iterator === "function" ? iterator(this.opts.store.namespace) : iterator) {
-            const data = await this.opts.deserialize(raw);
-            if (this.opts.store.namespace && !key.includes(this.opts.store.namespace)) {
-              continue;
-            }
-            if (typeof data.expires === "number" && Date.now() > data.expires) {
-              this.delete(key);
-              continue;
-            }
-            yield [this._getKeyUnprefix(key), data.value];
-          }
-        };
-        if (typeof this.opts.store[Symbol.iterator] === "function" && this.opts.store instanceof Map) {
-          this.iterator = generateIterator(this.opts.store);
-        } else if (typeof this.opts.store.iterator === "function" && this.opts.store.opts && this._checkIterableAdaptar()) {
-          this.iterator = generateIterator(this.opts.store.iterator.bind(this.opts.store));
-        }
-      }
-      _checkIterableAdaptar() {
-        return iterableAdapters.includes(this.opts.store.opts.dialect) || iterableAdapters.findIndex((element) => this.opts.store.opts.url.includes(element)) >= 0;
-      }
-      _getKeyPrefix(key) {
-        return `${this.opts.namespace}:${key}`;
-      }
-      _getKeyPrefixArray(keys) {
-        return keys.map((key) => `${this.opts.namespace}:${key}`);
-      }
-      _getKeyUnprefix(key) {
-        return key.split(":").splice(1).join(":");
-      }
-      get(key, options) {
-        const { store } = this.opts;
-        const isArray = Array.isArray(key);
-        const keyPrefixed = isArray ? this._getKeyPrefixArray(key) : this._getKeyPrefix(key);
-        if (isArray && store.getMany === void 0) {
-          const promises = [];
-          for (const key2 of keyPrefixed) {
-            promises.push(
-              Promise.resolve().then(() => store.get(key2)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => {
-                if (data === void 0 || data === null) {
-                  return void 0;
-                }
-                if (typeof data.expires === "number" && Date.now() > data.expires) {
-                  return this.delete(key2).then(() => void 0);
-                }
-                return options && options.raw ? data : data.value;
-              })
-            );
-          }
-          return Promise.allSettled(promises).then((values) => {
-            const data = [];
-            for (const value of values) {
-              data.push(value.value);
-            }
-            return data;
-          });
-        }
-        return Promise.resolve().then(() => isArray ? store.getMany(keyPrefixed) : store.get(keyPrefixed)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => {
-          if (data === void 0 || data === null) {
-            return void 0;
-          }
-          if (isArray) {
-            return data.map((row, index) => {
-              if (typeof row === "string") {
-                row = this.opts.deserialize(row);
-              }
-              if (row === void 0 || row === null) {
-                return void 0;
-              }
-              if (typeof row.expires === "number" && Date.now() > row.expires) {
-                this.delete(key[index]).then(() => void 0);
-                return void 0;
-              }
-              return options && options.raw ? row : row.value;
-            });
-          }
-          if (typeof data.expires === "number" && Date.now() > data.expires) {
-            return this.delete(key).then(() => void 0);
-          }
-          return options && options.raw ? data : data.value;
-        });
-      }
-      set(key, value, ttl) {
-        const keyPrefixed = this._getKeyPrefix(key);
-        if (typeof ttl === "undefined") {
-          ttl = this.opts.ttl;
-        }
-        if (ttl === 0) {
-          ttl = void 0;
-        }
-        const { store } = this.opts;
-        return Promise.resolve().then(() => {
-          const expires = typeof ttl === "number" ? Date.now() + ttl : null;
-          if (typeof value === "symbol") {
-            this.emit("error", "symbol cannot be serialized");
-          }
-          value = { value, expires };
-          return this.opts.serialize(value);
-        }).then((value2) => store.set(keyPrefixed, value2, ttl)).then(() => true);
-      }
-      delete(key) {
-        const { store } = this.opts;
-        if (Array.isArray(key)) {
-          const keyPrefixed2 = this._getKeyPrefixArray(key);
-          if (store.deleteMany === void 0) {
-            const promises = [];
-            for (const key2 of keyPrefixed2) {
-              promises.push(store.delete(key2));
-            }
-            return Promise.allSettled(promises).then((values) => values.every((x) => x.value === true));
-          }
-          return Promise.resolve().then(() => store.deleteMany(keyPrefixed2));
-        }
-        const keyPrefixed = this._getKeyPrefix(key);
-        return Promise.resolve().then(() => store.delete(keyPrefixed));
-      }
-      clear() {
-        const { store } = this.opts;
-        return Promise.resolve().then(() => store.clear());
-      }
-      has(key) {
-        const keyPrefixed = this._getKeyPrefix(key);
-        const { store } = this.opts;
-        return Promise.resolve().then(async () => {
-          if (typeof store.has === "function") {
-            return store.has(keyPrefixed);
-          }
-          const value = await store.get(keyPrefixed);
-          return value !== void 0;
-        });
-      }
-      disconnect() {
-        const { store } = this.opts;
-        if (typeof store.disconnect === "function") {
-          return store.disconnect();
-        }
-      }
-    };
-    module.exports = Keyv;
-  }
-});
-
-// node_modules/flatted/cjs/index.js
-var require_cjs = __commonJS({
-  "node_modules/flatted/cjs/index.js"(exports) {
-    "use strict";
-    var { parse: $parse, stringify: $stringify } = JSON;
-    var { keys } = Object;
-    var Primitive = String;
-    var primitive = "string";
-    var ignore = {};
-    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 = [];
-      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];
-          if (typeof tmp === object && !parsed.has(tmp)) {
-            parsed.add(tmp);
-            output[k] = ignore;
-            lazy.push({ k, a: [input, parsed, 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) => {
-      const index = Primitive(input.push(value) - 1);
-      known.set(value, index);
-      return index;
-    };
-    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);
-    };
-    exports.parse = parse;
-    var stringify4 = (value, replacer, space) => {
-      const $ = replacer && typeof replacer === object ? (k, v) => k === "" || -1 < replacer.indexOf(k) ? v : void 0 : replacer || noop;
-      const known = /* @__PURE__ */ new Map();
-      const input = [];
-      const output = [];
-      let i = +set(known, input, $.call({ "": value }, "", value));
-      let firstRun = !i;
-      while (i < input.length) {
-        firstRun = true;
-        output[i] = $stringify(input[i++], replace, space);
-      }
-      return "[" + output.join(",") + "]";
-      function replace(key, value2) {
-        if (firstRun) {
-          firstRun = !firstRun;
-          return value2;
-        }
-        const after = $.call(this, key, value2);
-        switch (typeof after) {
-          case object:
-            if (after === null) return after;
-          case primitive:
-            return known.get(after) || set(known, input, after);
-        }
-        return after;
-      }
-    };
-    exports.stringify = stringify4;
-    var toJSON = (value) => $parse(stringify4(value));
-    exports.toJSON = toJSON;
-    var fromJSON = (value) => parse($stringify(value));
-    exports.fromJSON = fromJSON;
-  }
-});
-
-// node_modules/flat-cache/src/utils.js
-var require_utils = __commonJS({
-  "node_modules/flat-cache/src/utils.js"(exports, module) {
-    var fs6 = __require("fs");
-    var path10 = __require("path");
-    var flatted = require_cjs();
-    function tryParse(filePath, defaultValue) {
-      let result;
-      try {
-        result = readJSON(filePath);
-      } catch {
-        result = defaultValue;
-      }
-      return result;
-    }
-    function readJSON(filePath) {
-      return flatted.parse(
-        fs6.readFileSync(filePath, {
-          encoding: "utf8"
-        })
-      );
-    }
-    function writeJSON(filePath, data) {
-      fs6.mkdirSync(path10.dirname(filePath), {
-        recursive: true
-      });
-      fs6.writeFileSync(filePath, flatted.stringify(data));
-    }
-    module.exports = { tryParse, readJSON, writeJSON };
-  }
-});
-
-// node_modules/flat-cache/src/del.js
-var require_del = __commonJS({
-  "node_modules/flat-cache/src/del.js"(exports, module) {
-    var fs6 = __require("fs");
-    var path10 = __require("path");
-    function del(targetPath) {
-      if (!fs6.existsSync(targetPath)) {
-        return false;
-      }
-      try {
-        if (fs6.statSync(targetPath).isDirectory()) {
-          for (const file of fs6.readdirSync(targetPath)) {
-            const currentPath = path10.join(targetPath, file);
-            if (fs6.statSync(currentPath).isFile()) {
-              fs6.unlinkSync(currentPath);
-            }
-          }
-          fs6.rmdirSync(targetPath);
-        } else {
-          fs6.unlinkSync(targetPath);
-        }
-        return true;
-      } catch (error) {
-        console.error(`Error while deleting ${targetPath}: ${error.message}`);
-      }
-    }
-    module.exports = { del };
-  }
-});
-
-// node_modules/flat-cache/src/cache.js
-var require_cache = __commonJS({
-  "node_modules/flat-cache/src/cache.js"(exports, module) {
-    var path10 = __require("path");
-    var fs6 = __require("fs");
-    var Keyv = require_src();
-    var { writeJSON, tryParse } = require_utils();
-    var { del } = require_del();
-    var cache = {
-      /**
-        * 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 `./cache` will be used instead
-        *
-        * @method load
-        * @param docId {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(documentId, cacheDir) {
-        const me = this;
-        me.keyv = new Keyv();
-        me.__visited = {};
-        me.__persisted = {};
-        me._pathToFile = cacheDir ? path10.resolve(cacheDir, documentId) : path10.resolve(__dirname, "../.cache/", documentId);
-        if (fs6.existsSync(me._pathToFile)) {
-          me._persisted = tryParse(me._pathToFile, {});
-        }
-      },
-      get _persisted() {
-        return this.__persisted;
-      },
-      set _persisted(value) {
-        this.__persisted = value;
-      },
-      get _visited() {
-        return this.__visited;
-      },
-      set _visited(value) {
-        this.__visited = value;
-      },
-      /**
-        * 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) {
-        const me = this;
-        const dir = path10.dirname(pathToFile);
-        const fName = path10.basename(pathToFile);
-        me.load(fName, dir);
-      },
-      /**
-        * Returns the entire persisted object
-        * @method all
-        * @returns {*}
-        */
-      all() {
-        return this._persisted;
-      },
-      keys() {
-        return Object.keys(this._persisted);
-      },
-      /**
-        * Sets a key to a given value
-        * @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) {
-        this._visited[key] = true;
-        this._persisted[key] = value;
-      },
-      /**
-        * Remove a given key from the cache
-        * @method removeKey
-        * @param key {String} the key to remove from the object
-        */
-      removeKey(key) {
-        delete this._visited[key];
-        delete this._persisted[key];
-      },
-      /**
-        * Return the value of the provided key
-        * @method getKey
-        * @param key {String} the name of the key to retrieve
-        * @returns {*} the value from the key
-        */
-      getKey(key) {
-        this._visited[key] = true;
-        return this._persisted[key];
-      },
-      /**
-        * Remove keys that were not accessed/set since the
-        * last time the `prune` method was called.
-        * @method _prune
-        * @private
-        */
-      _prune() {
-        const me = this;
-        const object = {};
-        const keys = Object.keys(me._visited);
-        if (keys.length === 0) {
-          return;
-        }
-        for (const key of keys) {
-          object[key] = me._persisted[key];
-        }
-        me._visited = {};
-        me._persisted = object;
-      },
-      /**
-        * Save the state of the cache identified by the docId to disk
-        * as a JSON structure
-        * @param [noPrune=false] {Boolean} whether to remove from cache the non visited files
-        * @method save
-        */
-      save(noPrune) {
-        const me = this;
-        !noPrune && me._prune();
-        writeJSON(me._pathToFile, me._persisted);
-      },
-      /**
-        * Remove the file where the cache is persisted
-        * @method removeCacheFile
-        * @return {Boolean} true or false if the file was successfully deleted
-        */
-      removeCacheFile() {
-        return del(this._pathToFile);
-      },
-      /**
-        * Destroy the file cache and cache content.
-        * @method destroy
-        */
-      destroy() {
-        const me = this;
-        me._visited = {};
-        me._persisted = {};
-        me.removeCacheFile();
-      }
-    };
-    module.exports = {
-      /**
-        * Alias for create. Should be considered depreacted. Will be removed in next releases
-        *
-        * @method load
-        * @param docId {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
-        * @returns {cache} cache instance
-        */
-      load(documentId, cacheDir) {
-        return this.create(documentId, cacheDir);
-      },
-      /**
-        * Load a cache identified by the given Id. If the element does not exists, then initialize an empty
-        * cache storage.
-        *
-        * @method create
-        * @param docId {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
-        * @returns {cache} cache instance
-        */
-      create(documentId, cacheDir) {
-        const object = Object.create(cache);
-        object.load(documentId, cacheDir);
-        return object;
-      },
-      createFromFile(filePath) {
-        const object = Object.create(cache);
-        object.loadFile(filePath);
-        return object;
-      },
-      /**
-        * Clear the cache identified by the given id. Caches stored in a different cache directory can be deleted directly
-        *
-        * @method clearCache
-        * @param docId {String} the id of the cache, would also be used as the name of the file cache
-        * @param cacheDir {String} the directory where the cache file was written
-        * @returns {Boolean} true if the cache folder was deleted. False otherwise
-        */
-      clearCacheById(documentId, cacheDir) {
-        const filePath = cacheDir ? path10.resolve(cacheDir, documentId) : path10.resolve(__dirname, "../.cache/", documentId);
-        return del(filePath);
-      },
-      /**
-        * Remove all cache stored in the cache directory
-        * @method clearAll
-        * @returns {Boolean} true if the cache folder was deleted. False otherwise
-        */
-      clearAll(cacheDir) {
-        const filePath = cacheDir ? path10.resolve(cacheDir) : path10.resolve(__dirname, "../.cache/");
-        return del(filePath);
-      }
-    };
-  }
-});
-
-// node_modules/file-entry-cache/cache.js
-var require_cache2 = __commonJS({
-  "node_modules/file-entry-cache/cache.js"(exports, module) {
-    var path10 = __require("path");
-    var crypto = __require("crypto");
-    module.exports = {
-      createFromFile(filePath, useChecksum, currentWorkingDir) {
-        const fname = path10.basename(filePath);
-        const dir = path10.dirname(filePath);
-        return this.create(fname, dir, useChecksum, currentWorkingDir);
-      },
-      create(cacheId, _path, useChecksum, currentWorkingDir) {
-        const fs6 = __require("fs");
-        const flatCache = require_cache();
-        const cache = flatCache.load(cacheId, _path);
-        let normalizedEntries = {};
-        const removeNotFoundFiles = function removeNotFoundFiles2() {
-          const cachedEntries = cache.keys();
-          for (const fPath of cachedEntries) {
-            try {
-              let filePath = fPath;
-              if (currentWorkingDir) {
-                filePath = path10.join(currentWorkingDir, fPath);
-              }
-              fs6.statSync(filePath);
-            } catch (error) {
-              if (error.code === "ENOENT") {
-                cache.removeKey(fPath);
-              }
-            }
-          }
-        };
-        removeNotFoundFiles();
-        return {
-          /**
-              * The flat cache storage used to persist the metadata of the `files
-              * @type {Object}
-              */
-          cache,
-          /**
-              * To enable relative paths as the key with current working directory
-              * @type {string}
-              */
-          currentWorkingDir: currentWorkingDir ?? void 0,
-          /**
-              * 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 crypto.createHash("md5").update(buffer).digest("hex");
-          },
-          /**
-              * Return whether or not a file has changed since last time reconcile was called.
-              * @method hasFileChanged
-              * @param  {String}  file  the filepath to check
-              * @return {Boolean}       wheter or not the file has changed
-              */
-          hasFileChanged(file) {
-            return this.getFileDescriptor(file).changed;
-          },
-          /**
-              * Given an array of file paths it return and object with three arrays:
-              *  - changedFiles: Files that changed since previous run
-              *  - notChangedFiles: Files that haven't change
-              *  - notFoundFiles: Files that were not found, probably deleted
-              *
-              * @param  {Array} files the files to analyze and compare to the previous seen files
-              * @return {[type]}       [description]
-              */
-          analyzeFiles(files) {
-            const me = this;
-            files || (files = []);
-            const res = {
-              changedFiles: [],
-              notFoundFiles: [],
-              notChangedFiles: []
-            };
-            for (const entry of me.normalizeEntries(files)) {
-              if (entry.changed) {
-                res.changedFiles.push(entry.key);
-                continue;
-              }
-              if (entry.notFound) {
-                res.notFoundFiles.push(entry.key);
-                continue;
-              }
-              res.notChangedFiles.push(entry.key);
-            }
-            return res;
-          },
-          getFileDescriptor(file) {
-            let fstat;
-            try {
-              fstat = fs6.statSync(file);
-            } catch (error) {
-              this.removeEntry(file);
-              return { key: file, notFound: true, err: error };
-            }
-            if (useChecksum) {
-              return this._getFileDescriptorUsingChecksum(file);
-            }
-            return this._getFileDescriptorUsingMtimeAndSize(file, fstat);
-          },
-          _getFileKey(file) {
-            if (this.currentWorkingDir) {
-              return file.split(this.currentWorkingDir).pop();
-            }
-            return file;
-          },
-          _getFileDescriptorUsingMtimeAndSize(file, fstat) {
-            let meta = cache.getKey(this._getFileKey(file));
-            const cacheExists = Boolean(meta);
-            const cSize = fstat.size;
-            const cTime = fstat.mtime.getTime();
-            let isDifferentDate;
-            let isDifferentSize;
-            if (meta) {
-              isDifferentDate = cTime !== meta.mtime;
-              isDifferentSize = cSize !== meta.size;
-            } else {
-              meta = { size: cSize, mtime: cTime };
-            }
-            const nEntry = normalizedEntries[this._getFileKey(file)] = {
-              key: this._getFileKey(file),
-              changed: !cacheExists || isDifferentDate || isDifferentSize,
-              meta
-            };
-            return nEntry;
-          },
-          _getFileDescriptorUsingChecksum(file) {
-            let meta = cache.getKey(this._getFileKey(file));
-            const cacheExists = Boolean(meta);
-            let contentBuffer;
-            try {
-              contentBuffer = fs6.readFileSync(file);
-            } catch {
-              contentBuffer = "";
-            }
-            let isDifferent = true;
-            const hash = this.getHash(contentBuffer);
-            if (meta) {
-              isDifferent = hash !== meta.hash;
-            } else {
-              meta = { hash };
-            }
-            const nEntry = normalizedEntries[this._getFileKey(file)] = {
-              key: this._getFileKey(file),
-              changed: !cacheExists || isDifferent,
-              meta
-            };
-            return nEntry;
-          },
-          /**
-              * Return the list o the files that changed compared
-              * against the ones stored in the cache
-              *
-              * @method getUpdated
-              * @param files {Array} the array of files to compare against the ones in the cache
-              * @returns {Array}
-              */
-          getUpdatedFiles(files) {
-            const me = this;
-            files || (files = []);
-            return me.normalizeEntries(files).filter((entry) => entry.changed).map((entry) => entry.key);
-          },
-          /**
-              * Return the list of files
-              * @method normalizeEntries
-              * @param files
-              * @returns {*}
-              */
-          normalizeEntries(files) {
-            files || (files = []);
-            const me = this;
-            const nEntries = files.map((file) => me.getFileDescriptor(file));
-            return nEntries;
-          },
-          /**
-              * Remove an entry from the file-entry-cache. Useful to force the file to still be considered
-              * modified the next time the process is run
-              *
-              * @method removeEntry
-              * @param entryName
-              */
-          removeEntry(entryName) {
-            delete normalizedEntries[this._getFileKey(entryName)];
-            cache.removeKey(this._getFileKey(entryName));
-          },
-          /**
-              * Delete the cache file from the disk
-              * @method deleteCacheFile
-              */
-          deleteCacheFile() {
-            cache.removeCacheFile();
-          },
-          /**
-              * Remove the cache from the file and clear the memory cache
-              */
-          destroy() {
-            normalizedEntries = {};
-            cache.destroy();
-          },
-          _getMetaForFileUsingCheckSum(cacheEntry) {
-            let filePath = cacheEntry.key;
-            if (this.currentWorkingDir) {
-              filePath = path10.join(this.currentWorkingDir, filePath);
-            }
-            const contentBuffer = fs6.readFileSync(filePath);
-            const hash = this.getHash(contentBuffer);
-            const meta = Object.assign(cacheEntry.meta, { hash });
-            delete meta.size;
-            delete meta.mtime;
-            return meta;
-          },
-          _getMetaForFileUsingMtimeAndSize(cacheEntry) {
-            let filePath = cacheEntry.key;
-            if (currentWorkingDir) {
-              filePath = path10.join(currentWorkingDir, filePath);
-            }
-            const stat = fs6.statSync(filePath);
-            const meta = Object.assign(cacheEntry.meta, {
-              size: stat.size,
-              mtime: stat.mtime.getTime()
-            });
-            delete meta.hash;
-            return meta;
-          },
-          /**
-              * Sync the files and persist them to the cache
-              * @method reconcile
-              */
-          reconcile(noPrune) {
-            removeNotFoundFiles();
-            noPrune = noPrune === void 0 ? true : noPrune;
-            const entries = normalizedEntries;
-            const keys = Object.keys(entries);
-            if (keys.length === 0) {
-              return;
-            }
-            const me = this;
-            for (const entryName of keys) {
-              const cacheEntry = entries[entryName];
-              try {
-                const meta = useChecksum ? me._getMetaForFileUsingCheckSum(cacheEntry) : me._getMetaForFileUsingMtimeAndSize(cacheEntry);
-                cache.setKey(this._getFileKey(entryName), meta);
-              } catch (error) {
-                if (error.code !== "ENOENT") {
-                  throw error;
-                }
-              }
-            }
-            cache.save(noPrune);
-          }
-        };
-      }
-    };
-  }
-});
-
 // src/cli/index.js
 import * as prettier2 from "../index.mjs";
 
 // scripts/build/shims/at.js
-var at = (isOptionalObject, object, index) => {
-  if (isOptionalObject && (object === void 0 || object === null)) {
+var at = (isOptionalObject, object2, index) => {
+  if (isOptionalObject && (object2 === void 0 || object2 === null)) {
     return;
   }
-  if (Array.isArray(object) || typeof object === "string") {
-    return object[index < 0 ? object.length + index : index];
+  if (Array.isArray(object2) || typeof object2 === "string") {
+    return object2[index < 0 ? object2.length + index : index];
   }
-  return object.at(index);
+  return object2.at(index);
 };
 var at_default = at;
 
@@ -1605,11 +750,11 @@ import path from "path";
 
 // node_modules/sdbm/index.js
 function sdbm(string) {
-  let hash = 0;
+  let hash2 = 0;
   for (let i = 0; i < string.length; i++) {
-    hash = string.charCodeAt(i) + (hash << 6) + (hash << 16) - hash;
+    hash2 = string.charCodeAt(i) + (hash2 << 6) + (hash2 << 16) - hash2;
   }
-  return hash >>> 0;
+  return hash2 >>> 0;
 }
 
 // src/cli/utils.js
@@ -1627,8 +772,8 @@ function groupBy(array2, iteratee) {
   }
   return result;
 }
-function pick(object, keys) {
-  const entries = keys.map((key) => [key, object[key]]);
+function pick(object2, keys2) {
+  const entries = keys2.map((key) => [key, object2[key]]);
   return Object.fromEntries(entries);
 }
 function createHash(source) {
@@ -1973,10 +1118,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 1;
   }
   if ("CI" in env) {
-    if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
       return 3;
     }
-    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
       return 1;
     }
     return min;
@@ -2067,12 +1212,12 @@ var levelMapping = [
   "ansi16m"
 ];
 var styles2 = /* @__PURE__ */ Object.create(null);
-var applyOptions = (object, options = {}) => {
+var applyOptions = (object2, options = {}) => {
   if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
     throw new Error("The `level` option should be an integer from 0 to 3");
   }
   const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === void 0 ? colorLevel : options.level;
+  object2.level = options.level === void 0 ? colorLevel : options.level;
 };
 var chalkFactory = (options) => {
   const chalk2 = (...strings) => strings.join(" ");
@@ -2296,15 +1441,15 @@ function normalizeCliOptions(options, optionInfos, opts) {
 var normalize_cli_options_default = normalizeCliOptions;
 
 // src/cli/options/parse-cli-arguments.js
-function parseArgv(rawArguments, detailedOptions, logger, keys) {
+function parseArgv(rawArguments, detailedOptions, logger, keys2) {
   var _a;
   const minimistOptions = createMinimistOptions(detailedOptions);
   let argv = minimistParse(rawArguments, minimistOptions);
-  if (keys) {
+  if (keys2) {
     detailedOptions = detailedOptions.filter(
-      (option) => keys.includes(option.name)
+      (option) => keys2.includes(option.name)
     );
-    argv = pick(argv, keys);
+    argv = pick(argv, keys2);
   }
   const normalized = normalize_cli_options_default(argv, detailedOptions, { logger });
   return {
@@ -2321,12 +1466,12 @@ function parseArgv(rawArguments, detailedOptions, logger, keys) {
   };
 }
 var { detailedOptions: detailedOptionsWithoutPlugins } = getContextOptionsWithoutPlugins();
-function parseArgvWithoutPlugins(rawArguments, logger, keys) {
+function parseArgvWithoutPlugins(rawArguments, logger, keys2) {
   return parseArgv(
     rawArguments,
     detailedOptionsWithoutPlugins,
     logger,
-    typeof keys === "string" ? [keys] : keys
+    typeof keys2 === "string" ? [keys2] : keys2
   );
 }
 
@@ -2428,8 +1573,8 @@ async function logResolvedConfigPathOrDie(context) {
 var find_config_path_default = logResolvedConfigPathOrDie;
 
 // src/cli/format.js
-import fs5 from "fs/promises";
-import path9 from "path";
+import fs7 from "fs/promises";
+import path11 from "path";
 import * as prettier from "../index.mjs";
 
 // src/cli/expand-patterns.js
@@ -2551,7 +1696,7 @@ function containsIgnoredPathSegment(absolutePath, cwd2, ignoredDirectories) {
 function sortPaths(paths) {
   return paths.sort((a, b) => a.localeCompare(b));
 }
-function escapePathForGlob(path10) {
+function escapePathForGlob(path12) {
   return string_replace_all_default(
     /* isOptionalObject */
     false,
@@ -2562,7 +1707,7 @@ function escapePathForGlob(path10) {
         string_replace_all_default(
           /* isOptionalObject */
           false,
-          path10,
+          path12,
           "\\",
           "\0"
         )
@@ -2684,9 +1829,9 @@ function packageDirectorySync({ cwd: cwd2 } = {}) {
 
 // node_modules/find-cache-dir/index.js
 var { env: env2, cwd } = process4;
-var isWritable = (path10) => {
+var isWritable = (path12) => {
   try {
-    fs3.accessSync(path10, fs3.constants.W_OK);
+    fs3.accessSync(path12, fs3.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -2760,7 +1905,1831 @@ var find_cache_file_default = findCacheFile;
 
 // src/cli/format-results-cache.js
 var import_fast_json_stable_stringify2 = __toESM(require_fast_json_stable_stringify(), 1);
-var import_file_entry_cache = __toESM(require_cache2(), 1);
+
+// node_modules/file-entry-cache/dist/index.js
+import crypto2 from "crypto";
+import fs6 from "fs";
+import path10 from "path";
+
+// node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
+import path9 from "path";
+import fs5 from "fs";
+
+// node_modules/hookified/dist/node/index.js
+var Eventified = class {
+  _eventListeners;
+  _maxListeners;
+  constructor() {
+    this._eventListeners = /* @__PURE__ */ new Map();
+    this._maxListeners = 100;
+  }
+  /**
+   * Adds a handler function for a specific event that will run only once
+   * @param {string | symbol} eventName
+   * @param {EventListener} listener
+   * @returns {IEventEmitter} returns the instance of the class for chaining
+   */
+  once(eventName, listener) {
+    const onceListener = (...arguments_) => {
+      this.off(eventName, onceListener);
+      listener(...arguments_);
+    };
+    this.on(eventName, onceListener);
+    return this;
+  }
+  /**
+   * Gets the number of listeners for a specific event. If no event is provided, it returns the total number of listeners
+   * @param {string} eventName The event name. Not required
+   * @returns {number} The number of listeners
+   */
+  listenerCount(eventName) {
+    if (!eventName) {
+      return this.getAllListeners().length;
+    }
+    const listeners = this._eventListeners.get(eventName);
+    return listeners ? listeners.length : 0;
+  }
+  /**
+   * Gets an array of event names
+   * @returns {Array<string | symbol>} An array of event names
+   */
+  eventNames() {
+    return Array.from(this._eventListeners.keys());
+  }
+  /**
+   * Gets an array of listeners for a specific event. If no event is provided, it returns all listeners
+   * @param {string} [event] (Optional) The event name
+   * @returns {EventListener[]} An array of listeners
+   */
+  rawListeners(event) {
+    if (!event) {
+      return this.getAllListeners();
+    }
+    return this._eventListeners.get(event) ?? [];
+  }
+  /**
+   * Prepends a listener to the beginning of the listeners array for the specified event
+   * @param {string | symbol} eventName
+   * @param {EventListener} listener
+   * @returns {IEventEmitter} returns the instance of the class for chaining
+   */
+  prependListener(eventName, listener) {
+    const listeners = this._eventListeners.get(eventName) ?? [];
+    listeners.unshift(listener);
+    this._eventListeners.set(eventName, listeners);
+    return this;
+  }
+  /**
+   * Prepends a one-time listener to the beginning of the listeners array for the specified event
+   * @param {string | symbol} eventName
+   * @param {EventListener} listener
+   * @returns {IEventEmitter} returns the instance of the class for chaining
+   */
+  prependOnceListener(eventName, listener) {
+    const onceListener = (...arguments_) => {
+      this.off(eventName, onceListener);
+      listener(...arguments_);
+    };
+    this.prependListener(eventName, onceListener);
+    return this;
+  }
+  /**
+   * Gets the maximum number of listeners that can be added for a single event
+   * @returns {number} The maximum number of listeners
+   */
+  maxListeners() {
+    return this._maxListeners;
+  }
+  /**
+   * Adds a listener for a specific event. It is an alias for the on() method
+   * @param {string | symbol} event
+   * @param {EventListener} listener
+   * @returns {IEventEmitter} returns the instance of the class for chaining
+   */
+  addListener(event, listener) {
+    this.on(event, listener);
+    return this;
+  }
+  /**
+   * Adds a listener for a specific event
+   * @param {string | symbol} event
+   * @param {EventListener} listener
+   * @returns {IEventEmitter} returns the instance of the class for chaining
+   */
+  on(event, listener) {
+    if (!this._eventListeners.has(event)) {
+      this._eventListeners.set(event, []);
+    }
+    const listeners = this._eventListeners.get(event);
+    if (listeners) {
+      if (listeners.length >= this._maxListeners) {
+        console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${listeners.length + 1} ${event} listeners added. Use setMaxListeners() to increase limit.`);
+      }
+      listeners.push(listener);
+    }
+    return this;
+  }
+  /**
+   * Removes a listener for a specific event. It is an alias for the off() method
+   * @param {string | symbol} event
+   * @param {EventListener} listener
+   * @returns {IEventEmitter} returns the instance of the class for chaining
+   */
+  removeListener(event, listener) {
+    this.off(event, listener);
+    return this;
+  }
+  /**
+   * Removes a listener for a specific event
+   * @param {string | symbol} event
+   * @param {EventListener} listener
+   * @returns {IEventEmitter} returns the instance of the class for chaining
+   */
+  off(event, listener) {
+    const listeners = this._eventListeners.get(event) ?? [];
+    const index = listeners.indexOf(listener);
+    if (index !== -1) {
+      listeners.splice(index, 1);
+    }
+    if (listeners.length === 0) {
+      this._eventListeners.delete(event);
+    }
+    return this;
+  }
+  /**
+   * Calls all listeners for a specific event
+   * @param {string | symbol} event
+   * @param arguments_ The arguments to pass to the listeners
+   * @returns {boolean} Returns true if the event had listeners, false otherwise
+   */
+  emit(event, ...arguments_) {
+    let result = false;
+    const listeners = this._eventListeners.get(event);
+    if (listeners && listeners.length > 0) {
+      for (const listener of listeners) {
+        listener(...arguments_);
+        result = true;
+      }
+    }
+    return result;
+  }
+  /**
+   * Gets all listeners for a specific event. If no event is provided, it returns all listeners
+   * @param {string} [event] (Optional) The event name
+   * @returns {EventListener[]} An array of listeners
+   */
+  listeners(event) {
+    return this._eventListeners.get(event) ?? [];
+  }
+  /**
+   * Removes all listeners for a specific event. If no event is provided, it removes all listeners
+   * @param {string} [event] (Optional) The event name
+   * @returns {IEventEmitter} returns the instance of the class for chaining
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this._eventListeners.delete(event);
+    } else {
+      this._eventListeners.clear();
+    }
+    return this;
+  }
+  /**
+   * Sets the maximum number of listeners that can be added for a single event
+   * @param {number} n The maximum number of listeners
+   * @returns {void}
+   */
+  setMaxListeners(n) {
+    this._maxListeners = n;
+    for (const listeners of this._eventListeners.values()) {
+      if (listeners.length > n) {
+        listeners.splice(n);
+      }
+    }
+  }
+  /**
+   * Gets all listeners
+   * @returns {EventListener[]} An array of listeners
+   */
+  getAllListeners() {
+    let result = new Array();
+    for (const listeners of this._eventListeners.values()) {
+      result = result.concat(listeners);
+    }
+    return result;
+  }
+};
+var Hookified = class extends Eventified {
+  _hooks;
+  _throwHookErrors = false;
+  constructor(options) {
+    super();
+    this._hooks = /* @__PURE__ */ new Map();
+    if ((options == null ? void 0 : options.throwHookErrors) !== void 0) {
+      this._throwHookErrors = options.throwHookErrors;
+    }
+  }
+  /**
+   * Gets all hooks
+   * @returns {Map<string, Hook[]>}
+   */
+  get hooks() {
+    return this._hooks;
+  }
+  /**
+   * Gets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+   * @returns {boolean}
+   */
+  get throwHookErrors() {
+    return this._throwHookErrors;
+  }
+  /**
+   * Sets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+   * @param {boolean} value
+   */
+  set throwHookErrors(value) {
+    this._throwHookErrors = value;
+  }
+  /**
+   * Adds a handler function for a specific event
+   * @param {string} event
+   * @param {Hook} handler - this can be async or sync
+   * @returns {void}
+   */
+  onHook(event, handler) {
+    const eventHandlers = this._hooks.get(event);
+    if (eventHandlers) {
+      eventHandlers.push(handler);
+    } else {
+      this._hooks.set(event, [handler]);
+    }
+  }
+  /**
+   * Adds a handler function for a specific event that runs before all other handlers
+   * @param {string} event
+   * @param {Hook} handler - this can be async or sync
+   * @returns {void}
+   */
+  prependHook(event, handler) {
+    const eventHandlers = this._hooks.get(event);
+    if (eventHandlers) {
+      eventHandlers.unshift(handler);
+    } else {
+      this._hooks.set(event, [handler]);
+    }
+  }
+  /**
+   * Adds a handler that only executes once for a specific event before all other handlers
+   * @param event
+   * @param handler
+   */
+  prependOnceHook(event, handler) {
+    const hook = async (...arguments_) => {
+      this.removeHook(event, hook);
+      return handler(...arguments_);
+    };
+    this.prependHook(event, hook);
+  }
+  /**
+   * Adds a handler that only executes once for a specific event
+   * @param event
+   * @param handler
+   */
+  onceHook(event, handler) {
+    const hook = async (...arguments_) => {
+      this.removeHook(event, hook);
+      return handler(...arguments_);
+    };
+    this.onHook(event, hook);
+  }
+  /**
+   * Removes a handler function for a specific event
+   * @param {string} event
+   * @param {Hook} handler
+   * @returns {void}
+   */
+  removeHook(event, handler) {
+    const eventHandlers = this._hooks.get(event);
+    if (eventHandlers) {
+      const index = eventHandlers.indexOf(handler);
+      if (index !== -1) {
+        eventHandlers.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * Calls all handlers for a specific event
+   * @param {string} event
+   * @param {T[]} arguments_
+   * @returns {Promise<void>}
+   */
+  async hook(event, ...arguments_) {
+    const eventHandlers = this._hooks.get(event);
+    if (eventHandlers) {
+      for (const handler of eventHandlers) {
+        try {
+          await handler(...arguments_);
+        } catch (error) {
+          const message = `${event}: ${error.message}`;
+          this.emit("error", new Error(message));
+          if (this._throwHookErrors) {
+            throw new Error(message);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Gets all hooks for a specific event
+   * @param {string} event
+   * @returns {Hook[]}
+   */
+  getHooks(event) {
+    return this._hooks.get(event);
+  }
+  /**
+   * Removes all hooks
+   * @returns {void}
+   */
+  clearHooks() {
+    this._hooks.clear();
+  }
+};
+
+// node_modules/cacheable/dist/index.js
+import * as crypto from "crypto";
+var structuredClone = globalThis.structuredClone ?? ((value) => JSON.parse(JSON.stringify(value)));
+var shorthandToMilliseconds = (shorthand) => {
+  let milliseconds;
+  if (shorthand === void 0) {
+    return void 0;
+  }
+  if (typeof shorthand === "number") {
+    milliseconds = shorthand;
+  } else if (typeof shorthand === "string") {
+    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'.`
+        );
+      }
+      const [, value, unit] = match;
+      const numericValue = Number.parseFloat(value);
+      const unitLower = unit.toLowerCase();
+      switch (unitLower) {
+        case "ms": {
+          milliseconds = numericValue;
+          break;
+        }
+        case "s": {
+          milliseconds = numericValue * 1e3;
+          break;
+        }
+        case "m": {
+          milliseconds = numericValue * 1e3 * 60;
+          break;
+        }
+        case "h": {
+          milliseconds = numericValue * 1e3 * 60 * 60;
+          break;
+        }
+        case "hr": {
+          milliseconds = numericValue * 1e3 * 60 * 60;
+          break;
+        }
+        case "d": {
+          milliseconds = numericValue * 1e3 * 60 * 60 * 24;
+          break;
+        }
+        /* c8 ignore next 3 */
+        default: {
+          milliseconds = Number(shorthand);
+        }
+      }
+    } else {
+      milliseconds = Number(shorthand);
+    }
+  } else {
+    throw new TypeError("Time must be a string or a number.");
+  }
+  return milliseconds;
+};
+var shorthandToTime = (shorthand, fromDate) => {
+  fromDate || (fromDate = /* @__PURE__ */ new Date());
+  const milliseconds = shorthandToMilliseconds(shorthand);
+  if (milliseconds === void 0) {
+    return fromDate.getTime();
+  }
+  return fromDate.getTime() + milliseconds;
+};
+function hash(object2, algorithm = "sha256") {
+  const objectString = JSON.stringify(object2);
+  if (!crypto.getHashes().includes(algorithm)) {
+    throw new Error(`Unsupported hash algorithm: '${algorithm}'`);
+  }
+  const hasher = crypto.createHash(algorithm);
+  hasher.update(objectString);
+  return hasher.digest("hex");
+}
+function wrapSync(function_, options) {
+  const { ttl, keyPrefix, cache } = options;
+  return function(...arguments_) {
+    const cacheKey = createWrapKey(function_, arguments_, keyPrefix);
+    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);
+        }
+      }
+    }
+    return value;
+  };
+}
+function createWrapKey(function_, arguments_, keyPrefix) {
+  if (!keyPrefix) {
+    return `${function_.name}::${hash(arguments_)}`;
+  }
+  return `${keyPrefix}::${function_.name}::${hash(arguments_)}`;
+}
+var ListNode = class {
+  // eslint-disable-next-line @typescript-eslint/parameter-properties
+  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();
+  // 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);
+  }
+  // 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);
+  }
+  // Get the oldest node (tail)
+  getOldest() {
+    return this.tail ? this.tail.value : void 0;
+  }
+  // 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;
+  }
+  get size() {
+    return this.nodesMap.size;
+  }
+};
+var CacheableMemory = class extends Hookified {
+  _lru = new DoublyLinkedList();
+  _hashCache = /* @__PURE__ */ new Map();
+  _hash0 = /* @__PURE__ */ new Map();
+  _hash1 = /* @__PURE__ */ new Map();
+  _hash2 = /* @__PURE__ */ new Map();
+  _hash3 = /* @__PURE__ */ new Map();
+  _hash4 = /* @__PURE__ */ new Map();
+  _hash5 = /* @__PURE__ */ new Map();
+  _hash6 = /* @__PURE__ */ new Map();
+  _hash7 = /* @__PURE__ */ new Map();
+  _hash8 = /* @__PURE__ */ new Map();
+  _hash9 = /* @__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 == null ? void 0 : options.ttl) {
+      this.setTtl(options.ttl);
+    }
+    if ((options == null ? void 0 : options.useClone) !== void 0) {
+      this._useClone = options.useClone;
+    }
+    if (options == null ? void 0 : options.lruSize) {
+      this._lruSize = options.lruSize;
+    }
+    if (options == null ? void 0 : options.checkInterval) {
+      this._checkInterval = options.checkInterval;
+    }
+    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.
+   */
+  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.
+   */
+  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.
+   */
+  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.
+   */
+  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.
+   */
+  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.
+   */
+  set lruSize(value) {
+    this._lruSize = value;
+    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.
+   */
+  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.
+   */
+  set checkInterval(value) {
+    this._checkInterval = value;
+  }
+  /**
+   * Gets the size of the cache
+   * @returns {number} - The size of the cache
+   */
+  get size() {
+    return this._hash0.size + this._hash1.size + this._hash2.size + this._hash3.size + this._hash4.size + this._hash5.size + this._hash6.size + this._hash7.size + this._hash8.size + this._hash9.size;
+  }
+  /**
+   * Gets the keys
+   * @returns {IterableIterator<string>} - The keys
+   */
+  get keys() {
+    return this.concatStores().keys();
+  }
+  /**
+   * Gets the items
+   * @returns {IterableIterator<CacheableStoreItem>} - The items
+   */
+  get items() {
+    return this.concatStores().values();
+  }
+  /**
+   * 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) {
+    const store = this.getStore(key);
+    const item = store.get(key);
+    if (!item) {
+      return void 0;
+    }
+    if (item.expires && item.expires && Date.now() > item.expires) {
+      store.delete(key);
+      return void 0;
+    }
+    this.lruMoveToFront(key);
+    if (!this._useClone) {
+      return item.value;
+    }
+    return this.clone(item.value);
+  }
+  /**
+   * Gets the values of the keys
+   * @param {string[]} keys - The keys to get the values
+   * @returns {T[]} - The values of the keys
+   */
+  getMany(keys2) {
+    const result = new Array();
+    for (const key of keys2) {
+      result.push(this.get(key));
+    }
+    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
+   */
+  getRaw(key) {
+    const store = this.getStore(key);
+    const item = store.get(key);
+    if (!item) {
+      return void 0;
+    }
+    if (item.expires && item.expires && Date.now() > item.expires) {
+      store.delete(key);
+      return void 0;
+    }
+    this.lruMoveToFront(key);
+    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
+   */
+  getManyRaw(keys2) {
+    const result = new Array();
+    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}
+   */
+  set(key, value, ttl) {
+    const store = this.getStore(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;
+        }
+      }
+    }
+    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);
+          }
+        }
+      }
+    }
+    const item = { key, value, expires };
+    store.set(
+      key,
+      item
+    );
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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.
+   */
+  hasMany(keys2) {
+    const result = new Array();
+    for (const key of keys2) {
+      const item = this.get(key);
+      result.push(Boolean(item));
+    }
+    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(key) {
+    const item = this.get(key);
+    if (!item) {
+      return void 0;
+    }
+    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(keys2) {
+    const result = new Array();
+    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(key) {
+    const store = this.getStore(key);
+    store.delete(key);
+  }
+  /**
+   * Delete the keys
+   * @param {string[]} keys - The keys to delete
+   * @returns {void}
+   */
+  deleteMany(keys2) {
+    for (const key of keys2) {
+      this.delete(key);
+    }
+  }
+  /**
+   * Clear the cache
+   * @returns {void}
+   */
+  clear() {
+    this._hash0.clear();
+    this._hash1.clear();
+    this._hash2.clear();
+    this._hash3.clear();
+    this._hash4.clear();
+    this._hash5.clear();
+    this._hash6.clear();
+    this._hash7.clear();
+    this._hash8.clear();
+    this._hash9.clear();
+    this._hashCache.clear();
+    this._lru = new DoublyLinkedList();
+  }
+  /**
+   * Get the store based on the key (internal use)
+   * @param {string} key - The key to get the store
+   * @returns {CacheableHashStore} - The store
+   */
+  getStore(key) {
+    const hash2 = this.hashKey(key);
+    return this.getStoreFromHash(hash2);
+  }
+  /**
+   * Get the store based on the hash (internal use)
+   * @param {number} hash
+   * @returns {Map<string, CacheableStoreItem>}
+   */
+  getStoreFromHash(hash2) {
+    switch (hash2) {
+      case 1: {
+        return this._hash1;
+      }
+      case 2: {
+        return this._hash2;
+      }
+      case 3: {
+        return this._hash3;
+      }
+      case 4: {
+        return this._hash4;
+      }
+      case 5: {
+        return this._hash5;
+      }
+      case 6: {
+        return this._hash6;
+      }
+      case 7: {
+        return this._hash7;
+      }
+      case 8: {
+        return this._hash8;
+      }
+      case 9: {
+        return this._hash9;
+      }
+      default: {
+        return this._hash0;
+      }
+    }
+  }
+  /**
+   * Hash the key (internal use)
+   * @param key
+   * @returns {number} from 0 to 9
+   */
+  hashKey(key) {
+    const cacheHashNumber = this._hashCache.get(key);
+    if (cacheHashNumber) {
+      return cacheHashNumber;
+    }
+    let hash2 = 0;
+    const primeMultiplier = 31;
+    for (let i = 0; i < key.length; i++) {
+      hash2 = hash2 * primeMultiplier + key.charCodeAt(i);
+    }
+    const result = Math.abs(hash2) % 10;
+    this._hashCache.set(key, result);
+    return result;
+  }
+  /**
+   * 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;
+    }
+    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}
+   */
+  lruAddToFront(key) {
+    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}
+   */
+  lruMoveToFront(key) {
+    if (this._lruSize === 0) {
+      return;
+    }
+    this._lru.moveToFront(key);
+  }
+  /**
+   * Resize the LRU cache. This is for internal use
+   * @returns {void}
+   */
+  lruResize() {
+    if (this._lruSize === 0) {
+      return;
+    }
+    while (this._lru.size > this._lruSize) {
+      const oldestKey = this._lru.getOldest();
+      if (oldestKey) {
+        this._lru.removeOldest();
+        this.delete(oldestKey);
+      }
+    }
+  }
+  /**
+   * Check for expiration. This is for internal use
+   * @returns {void}
+   */
+  checkExpiration() {
+    const stores = this.concatStores();
+    for (const item of stores.values()) {
+      if (item.expires && Date.now() > item.expires) {
+        this.delete(item.key);
+      }
+    }
+  }
+  /**
+   * Start the interval check. This is for internal use
+   * @returns {void}
+   */
+  startIntervalCheck() {
+    if (this._checkInterval > 0) {
+      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}
+   */
+  stopIntervalCheck() {
+    if (this._interval) {
+      clearInterval(this._interval);
+    }
+    this._interval = 0;
+    this._checkInterval = 0;
+  }
+  /**
+   * Hash the object. This is for internal use
+   * @param {any} object - The object to hash
+   * @param {string} [algorithm='sha256'] - The algorithm to hash
+   * @returns {string} - The hashed string
+   */
+  hash(object2, algorithm = "sha256") {
+    return hash(object2, algorithm);
+  }
+  /**
+   * 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 = {
+      ttl: (options == null ? void 0 : options.ttl) ?? this._ttl,
+      keyPrefix: options == null ? void 0 : options.keyPrefix,
+      cache: this
+    };
+    return wrapSync(function_, wrapOptions);
+  }
+  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;
+    }
+    return result;
+  }
+  concatStores() {
+    return new Map([...this._hash0, ...this._hash1, ...this._hash2, ...this._hash3, ...this._hash4, ...this._hash5, ...this._hash6, ...this._hash7, ...this._hash8, ...this._hash9]);
+  }
+  setTtl(ttl) {
+    if (typeof ttl === "string" || ttl === void 0) {
+      this._ttl = ttl;
+    } else if (ttl > 0) {
+      this._ttl = ttl;
+    } else {
+      this._ttl = void 0;
+    }
+  }
+};
+
+// node_modules/flatted/esm/index.js
+var { parse: $parse, stringify: $stringify } = JSON;
+var { keys } = Object;
+var Primitive = String;
+var primitive = "string";
+var ignore = {};
+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 = [];
+  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];
+      if (typeof tmp === object && !parsed.has(tmp)) {
+        parsed.add(tmp);
+        output[k] = ignore;
+        lazy.push({ k, a: [input, parsed, 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) => {
+  const index = Primitive(input.push(value) - 1);
+  known.set(value, index);
+  return index;
+};
+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);
+};
+var stringify2 = (value, replacer, space) => {
+  const $ = replacer && typeof replacer === object ? (k, v) => k === "" || -1 < replacer.indexOf(k) ? v : void 0 : replacer || noop;
+  const known = /* @__PURE__ */ new Map();
+  const input = [];
+  const output = [];
+  let i = +set(known, input, $.call({ "": value }, "", value));
+  let firstRun = !i;
+  while (i < input.length) {
+    firstRun = true;
+    output[i] = $stringify(input[i++], replace, space);
+  }
+  return "[" + output.join(",") + "]";
+  function replace(key, value2) {
+    if (firstRun) {
+      firstRun = !firstRun;
+      return value2;
+    }
+    const after = $.call(this, key, value2);
+    switch (typeof after) {
+      case object:
+        if (after === null) return after;
+      case primitive:
+        return known.get(after) || set(known, input, after);
+    }
+    return after;
+  }
+};
+
+// node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
+var FlatCache = class extends Hookified {
+  _cache = new CacheableMemory();
+  _cacheDir = ".cache";
+  _cacheId = "cache1";
+  _persistInterval = 0;
+  _persistTimer;
+  _changesSinceLastSave = false;
+  _parse = parse;
+  _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 == null ? void 0 : options.cacheDir) {
+      this._cacheDir = options.cacheDir;
+    }
+    if (options == null ? void 0 : options.cacheId) {
+      this._cacheId = options.cacheId;
+    }
+    if (options == null ? void 0 : options.persistInterval) {
+      this._persistInterval = options.persistInterval;
+      this.startAutoPersist();
+    }
+    if (options == null ? void 0 : options.deserialize) {
+      this._parse = options.deserialize;
+    }
+    if (options == null ? void 0 : options.serialize) {
+      this._stringify = options.serialize;
+    }
+  }
+  /**
+   * The cache object
+   * @property cache
+   * @type {CacheableMemory}
+   */
+  get cache() {
+    return this._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 cacheDir(value) {
+    this._cacheDir = value;
+  }
+  /**
+   * 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 cacheId(value) {
+    this._cacheId = value;
+  }
+  /**
+   * 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
+   */
+  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 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
+   */
+  // eslint-disable-next-line unicorn/prevent-abbreviations
+  load(cacheId, cacheDir) {
+    try {
+      const filePath = path9.resolve(`${cacheDir ?? this._cacheDir}/${cacheId ?? this._cacheId}`);
+      this.loadFile(filePath);
+      this.emit(
+        "load"
+        /* 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
+   */
+  loadFile(pathToFile) {
+    if (fs5.existsSync(pathToFile)) {
+      const data = fs5.readFileSync(pathToFile, "utf8");
+      const items = this._parse(data);
+      for (const key of Object.keys(items)) {
+        this._cache.set(items[key].key, items[key].value, { expire: items[key].expires });
+      }
+      this._changesSinceLastSave = true;
+    }
+  }
+  /**
+   * Returns the entire persisted object
+   * @method all
+   * @returns {*}
+   */
+  all() {
+    const result = {};
+    const items = Array.from(this._cache.items);
+    for (const item of items) {
+      result[item.key] = item.value;
+    }
+    return result;
+  }
+  /**
+   * Returns an array with all the items in the cache { key, value, ttl }
+   * @method items
+   * @returns {Array}
+   */
+  get items() {
+    return Array.from(this._cache.items);
+  }
+  /**
+   * Returns the path to the file where the cache is persisted
+   * @method cacheFilePath
+   * @returns {String}
+   */
+  get cacheFilePath() {
+    return path9.resolve(`${this._cacheDir}/${this._cacheId}`);
+  }
+  /**
+   * Returns the path to the cache directory
+   * @method cacheDirPath
+   * @returns {String}
+   */
+  get cacheDirPath() {
+    return path9.resolve(this._cacheDir);
+  }
+  /**
+   * Returns an array with all the keys in the cache
+   * @method keys
+   * @returns {Array}
+   */
+  keys() {
+    return Array.from(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
+   */
+  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
+   */
+  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
+   */
+  removeKey(key) {
+    this.delete(key);
+  }
+  /**
+   * 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
+  */
+  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
+   */
+  get(key) {
+    return this._cache.get(key);
+  }
+  /**
+   * 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 */
+      );
+    } 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(force = false) {
+    try {
+      if (this._changesSinceLastSave || force) {
+        const filePath = this.cacheFilePath;
+        const items = Array.from(this._cache.items);
+        const data = this._stringify(items);
+        if (!fs5.existsSync(this._cacheDir)) {
+          fs5.mkdirSync(this._cacheDir, { recursive: true });
+        }
+        fs5.writeFileSync(filePath, data);
+        this._changesSinceLastSave = false;
+        this.emit(
+          "save"
+          /* 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
+   */
+  removeCacheFile() {
+    try {
+      if (fs5.existsSync(this.cacheFilePath)) {
+        fs5.rmSync(this.cacheFilePath);
+        return true;
+      }
+    } catch (error) {
+      this.emit("error", error);
+    }
+    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(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 });
+      }
+      this._changesSinceLastSave = false;
+      this.emit(
+        "destroy"
+        /* DESTROY */
+      );
+    } catch (error) {
+      this.emit("error", error);
+    }
+  }
+  /**
+   * Start the auto persist interval
+   * @method startAutoPersist
+   */
+  startAutoPersist() {
+    if (this._persistInterval > 0) {
+      if (this._persistTimer) {
+        clearInterval(this._persistTimer);
+        this._persistTimer = void 0;
+      }
+      this._persistTimer = setInterval(() => {
+        this.save();
+      }, this._persistInterval);
+    }
+  }
+  /**
+   * Stop the auto persist interval
+   * @method stopAutoPersist
+   */
+  stopAutoPersist() {
+    if (this._persistTimer) {
+      clearInterval(this._persistTimer);
+      this._persistTimer = void 0;
+    }
+  }
+};
+function createFromFile(filePath, options) {
+  const cache = new FlatCache(options);
+  cache.loadFile(filePath);
+  return cache;
+}
+
+// node_modules/file-entry-cache/dist/index.js
+function createFromFile2(filePath, useCheckSum, currentWorkingDirectory) {
+  const fname = path10.basename(filePath);
+  const directory = path10.dirname(filePath);
+  return create(fname, directory, useCheckSum, currentWorkingDirectory);
+}
+function create(cacheId, cacheDirectory, useCheckSum, currentWorkingDirectory) {
+  const options = {
+    currentWorkingDirectory,
+    useCheckSum,
+    cache: {
+      cacheId,
+      cacheDir: cacheDirectory
+    }
+  };
+  const fileEntryCache = new FileEntryCache(options);
+  if (cacheDirectory) {
+    const cachePath = `${cacheDirectory}/${cacheId}`;
+    if (fs6.existsSync(cachePath)) {
+      fileEntryCache.cache = createFromFile(cachePath, options.cache);
+    }
+  }
+  return fileEntryCache;
+}
+var FileEntryDefault = class {
+  static create = create;
+  static createFromFile = createFromFile2;
+};
+var FileEntryCache = class {
+  _cache = new FlatCache({ useClone: false });
+  _useCheckSum = false;
+  _currentWorkingDirectory;
+  _hashAlgorithm = "md5";
+  constructor(options) {
+    if (options == null ? void 0 : options.cache) {
+      this._cache = new FlatCache(options.cache);
+    }
+    if (options == null ? void 0 : options.useCheckSum) {
+      this._useCheckSum = options.useCheckSum;
+    }
+    if (options == null ? void 0 : options.currentWorkingDirectory) {
+      this._currentWorkingDirectory = options.currentWorkingDirectory;
+    }
+    if (options == null ? void 0 : options.hashAlgorithm) {
+      this._hashAlgorithm = options.hashAlgorithm;
+    }
+  }
+  get cache() {
+    return this._cache;
+  }
+  set cache(cache) {
+    this._cache = cache;
+  }
+  get useCheckSum() {
+    return this._useCheckSum;
+  }
+  set useCheckSum(value) {
+    this._useCheckSum = value;
+  }
+  get hashAlgorithm() {
+    return this._hashAlgorithm;
+  }
+  set hashAlgorithm(value) {
+    this._hashAlgorithm = value;
+  }
+  get currentWorkingDirectory() {
+    return this._currentWorkingDirectory;
+  }
+  set currentWorkingDirectory(value) {
+    this._currentWorkingDirectory = 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
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  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}
+   */
+  createFileKey(filePath, options) {
+    let result = filePath;
+    const currentWorkingDirectory = (options == null ? void 0 : options.currentWorkingDirectory) ?? this._currentWorkingDirectory;
+    if (currentWorkingDirectory && filePath.startsWith(currentWorkingDirectory)) {
+      const splitPath = filePath.split(currentWorkingDirectory).pop();
+      if (splitPath) {
+        result = splitPath;
+        if (result.startsWith("/")) {
+          result = result.slice(1);
+        }
+      }
+    }
+    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
+   */
+  isRelativePath(filePath) {
+    return !path10.isAbsolute(filePath);
+  }
+  /**
+  * 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
+  */
+  destroy() {
+    this._cache.destroy();
+  }
+  /**
+   * Remove and Entry From the Cache
+   * @method removeEntry
+   * @param filePath - The file path to remove from the cache
+   */
+  removeEntry(filePath, options) {
+    if (this.isRelativePath(filePath)) {
+      filePath = this.getAbsolutePath(filePath, { currentWorkingDirectory: options == null ? void 0 : options.currentWorkingDirectory });
+      this._cache.removeKey(this.createFileKey(filePath));
+    }
+    const key = this.createFileKey(filePath, { currentWorkingDirectory: options == null ? void 0 : options.currentWorkingDirectory });
+    this._cache.removeKey(key);
+  }
+  /**
+   * Reconcile the cache
+   * @method reconcile
+   */
+  reconcile() {
+    const items = this._cache.items;
+    for (const item of items) {
+      const fileDescriptor = this.getFileDescriptor(item.key);
+      if (fileDescriptor.notFound) {
+        this._cache.removeKey(item.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
+   */
+  hasFileChanged(filePath) {
+    let result = false;
+    const fileDescriptor = this.getFileDescriptor(filePath);
+    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
+   */
+  getFileDescriptor(filePath, options) {
+    var _a, _b, _c;
+    let fstat;
+    const result = {
+      key: this.createFileKey(filePath),
+      changed: false,
+      meta: {}
+    };
+    result.meta = this._cache.getKey(result.key) ?? {};
+    filePath = this.getAbsolutePath(filePath, { currentWorkingDirectory: options == null ? void 0 : options.currentWorkingDirectory });
+    const useCheckSumValue = (options == null ? void 0 : options.useCheckSum) ?? this._useCheckSum;
+    try {
+      fstat = fs6.statSync(filePath);
+      result.meta = {
+        size: fstat.size
+      };
+      result.meta.mtime = fstat.mtime.getTime();
+      if (useCheckSumValue) {
+        const buffer = fs6.readFileSync(filePath);
+        result.meta.hash = this.getHash(buffer);
+      }
+    } catch (error) {
+      this.removeEntry(filePath);
+      let notFound = false;
+      if (error.message.includes("ENOENT")) {
+        notFound = true;
+      }
+      return {
+        key: result.key,
+        err: error,
+        notFound,
+        meta: {}
+      };
+    }
+    const metaCache = this._cache.getKey(result.key);
+    if (!metaCache) {
+      result.changed = true;
+      this._cache.setKey(result.key, result.meta);
+      return result;
+    }
+    if (result.meta.data === void 0) {
+      result.meta.data = metaCache.data;
+    }
+    if ((metaCache == null ? void 0 : metaCache.mtime) !== ((_a = result.meta) == null ? void 0 : _a.mtime) || (metaCache == null ? void 0 : metaCache.size) !== ((_b = result.meta) == null ? void 0 : _b.size)) {
+      result.changed = true;
+    }
+    if (useCheckSumValue && (metaCache == null ? void 0 : metaCache.hash) !== ((_c = result.meta) == null ? void 0 : _c.hash)) {
+      result.changed = true;
+    }
+    this._cache.setKey(result.key, result.meta);
+    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
+   */
+  normalizeEntries(files) {
+    const result = new Array();
+    if (files) {
+      for (const file of files) {
+        const fileDescriptor = this.getFileDescriptor(file);
+        result.push(fileDescriptor);
+      }
+      return result;
+    }
+    const keys2 = this.cache.keys();
+    for (const key of keys2) {
+      const fileDescriptor = this.getFileDescriptor(key);
+      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
+   */
+  analyzeFiles(files) {
+    const result = {
+      changedFiles: [],
+      notFoundFiles: [],
+      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);
+      }
+    }
+    return result;
+  }
+  /**
+   * 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 = new Array();
+    const fileDescriptors = this.normalizeEntries(files);
+    for (const fileDescriptor of fileDescriptors) {
+      if (fileDescriptor.changed) {
+        result.push(fileDescriptor.key);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get the not found files
+   * @method getFileDescriptorsByPath
+   * @param filePath - the files that you want to get from a path
+   * @returns {FileDescriptor[]} The not found files
+   */
+  getFileDescriptorsByPath(filePath) {
+    const result = new Array();
+    const keys2 = this._cache.keys();
+    for (const key of keys2) {
+      const absolutePath = this.getAbsolutePath(filePath);
+      if (absolutePath.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.
+   * @method getAbsolutePath
+   * @param filePath - The file path to get the absolute path for
+   * @param options - The options for getting the absolute path. The current working directory is used if not provided.
+   * @returns {string}
+   */
+  getAbsolutePath(filePath, options) {
+    if (this.isRelativePath(filePath)) {
+      const currentWorkingDirectory = (options == null ? void 0 : options.currentWorkingDirectory) ?? this._currentWorkingDirectory ?? process.cwd();
+      filePath = path10.resolve(currentWorkingDirectory, filePath);
+    }
+    return filePath;
+  }
+  /**
+   * Rename the absolute path keys. This is used when a directory is changed or renamed.
+   * @method renameAbsolutePathKeys
+   * @param oldPath - The old path to rename
+   * @param newPath - The new path to rename to
+   */
+  renameAbsolutePathKeys(oldPath, newPath) {
+    const keys2 = this._cache.keys();
+    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);
+      }
+    }
+  }
+};
+
+// src/cli/format-results-cache.js
 import { version as prettierVersion } from "../index.mjs";
 var optionsHashCache = /* @__PURE__ */ new WeakMap();
 var nodeVersion = process.version;
@@ -2768,11 +3737,11 @@ function getHashOfOptions(options) {
   if (optionsHashCache.has(options)) {
     return optionsHashCache.get(options);
   }
-  const hash = createHash(
+  const hash2 = createHash(
     `${prettierVersion}_${nodeVersion}_${(0, import_fast_json_stable_stringify2.default)(options)}`
   );
-  optionsHashCache.set(options, hash);
-  return hash;
+  optionsHashCache.set(options, hash2);
+  return hash2;
 }
 function getMetadataFromFileDescriptor(fileDescriptor) {
   return fileDescriptor.meta;
@@ -2786,11 +3755,9 @@ var FormatResultsCache = class {
   constructor(cacheFileLocation, cacheStrategy) {
     __privateAdd(this, _fileEntryCache);
     const useChecksum = cacheStrategy === "content";
-    __privateSet(this, _fileEntryCache, import_file_entry_cache.default.create(
-      /* cacheId */
+    __privateSet(this, _fileEntryCache, FileEntryDefault.createFromFile(
+      /* filePath */
       cacheFileLocation,
-      /* directory */
-      void 0,
       useChecksum
     ));
   }
@@ -2799,14 +3766,13 @@ var FormatResultsCache = class {
    * @param {any} options
    */
   existsAvailableFormatResultsCache(filePath, options) {
+    var _a;
     const fileDescriptor = __privateGet(this, _fileEntryCache).getFileDescriptor(filePath);
-    if (fileDescriptor.notFound) {
+    if (fileDescriptor.notFound || fileDescriptor.changed) {
       return false;
     }
-    const hashOfOptions = getHashOfOptions(options);
-    const meta = getMetadataFromFileDescriptor(fileDescriptor);
-    const changed = fileDescriptor.changed || meta.hashOfOptions !== hashOfOptions;
-    return !changed;
+    const hashOfOptions = (_a = getMetadataFromFileDescriptor(fileDescriptor).data) == null ? void 0 : _a.hashOfOptions;
+    return hashOfOptions && hashOfOptions === getHashOfOptions(options);
   }
   /**
    * @param {string} filePath
@@ -2814,9 +3780,9 @@ var FormatResultsCache = class {
    */
   setFormatResultsCache(filePath, options) {
     const fileDescriptor = __privateGet(this, _fileEntryCache).getFileDescriptor(filePath);
-    const meta = getMetadataFromFileDescriptor(fileDescriptor);
-    if (fileDescriptor && !fileDescriptor.notFound) {
-      meta.hashOfOptions = getHashOfOptions(options);
+    if (!fileDescriptor.notFound) {
+      const meta = getMetadataFromFileDescriptor(fileDescriptor);
+      meta.data = { ...meta.data, hashOfOptions: getHashOfOptions(options) };
     }
   }
   /**
@@ -2845,9 +3811,9 @@ function getOptions(argv, detailedOptions) {
     detailedOptions.filter(({ forwardToApi }) => forwardToApi).map(({ forwardToApi, name }) => [forwardToApi, argv[name]])
   );
 }
-function cliifyOptions(object, apiDetailedOptionMap) {
+function cliifyOptions(object2, apiDetailedOptionMap) {
   return Object.fromEntries(
-    Object.entries(object || {}).map(([key, value]) => {
+    Object.entries(object2 || {}).map(([key, value]) => {
       const apiOption = apiDetailedOptionMap[key];
       const cliKey = apiOption ? apiOption.name : key;
       return [(0, import_dashify2.default)(cliKey), value];
@@ -3037,11 +4003,11 @@ async function format3(context, input, opt) {
         "prettier(input) !== prettier(prettier(input))\n" + diff(pp, pppp)
       );
     } else {
-      const stringify4 = (obj) => JSON.stringify(obj, null, 2);
-      const ast = stringify4(
+      const stringify5 = (obj) => JSON.stringify(obj, null, 2);
+      const ast = stringify5(
         (await prettier.__debug.parse(input, opt, { massage: true })).ast
       );
-      const past = stringify4(
+      const past = stringify5(
         (await prettier.__debug.parse(pp, opt, { massage: true })).ast
       );
       if (ast !== past) {
@@ -3141,7 +4107,7 @@ async function formatStdin(context) {
     }
     const options = await get_options_for_file_default(
       context,
-      filepath ? path9.resolve(filepath) : void 0
+      filepath ? path11.resolve(filepath) : void 0
     );
     if (await listDifferent(context, input, options, "(stdin)")) {
       return;
@@ -3177,7 +4143,7 @@ async function formatFiles(context) {
   } else if (!context.argv.cacheLocation) {
     const stat = await statSafe(cacheFilePath);
     if (stat) {
-      await fs5.unlink(cacheFilePath);
+      await fs7.unlink(cacheFilePath);
     }
   }
   for await (const { error, filename, ignoreUnknown } of expandPatterns(
@@ -3196,7 +4162,7 @@ async function formatFiles(context) {
       ...await get_options_for_file_default(context, filename),
       filepath: filename
     };
-    const fileNameToDisplay = normalizeToPosix(path9.relative(cwd2, filename));
+    const fileNameToDisplay = normalizeToPosix(path11.relative(cwd2, filename));
     let printedFilename;
     if (isTTY()) {
       printedFilename = context.logger.log(fileNameToDisplay, {
@@ -3206,7 +4172,7 @@ async function formatFiles(context) {
     }
     let input;
     try {
-      input = await fs5.readFile(filename, "utf8");
+      input = await fs7.readFile(filename, "utf8");
     } catch (error2) {
       context.logger.log("");
       context.logger.error(