prettier 3.6.2 → 3.7.0

package/internal/legacy-cli.mjs

@@ -11,10 +11,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -40,12 +36,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // node_modules/dashify/index.js
 var require_dashify = __commonJS({
@@ -288,7 +278,7 @@ var require_fast_json_stable_stringify = __commonJS({
       if (!opts) opts = {};
       if (typeof opts === "function") opts = { cmp: opts };
       var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false;
-      var cmp = opts.cmp && /* @__PURE__ */ function(f) {
+      var cmp = opts.cmp && /* @__PURE__ */ (function(f) {
         return function(node) {
           return function(a, b) {
             var aobj = { key: a, value: node[a] };
@@ -296,9 +286,9 @@ var require_fast_json_stable_stringify = __commonJS({
             return f(aobj, bobj);
           };
         };
-      }(opts.cmp);
+      })(opts.cmp);
       var seen = [];
-      return function stringify5(node) {
+      return (function stringify5(node) {
         if (node && node.toJSON && typeof node.toJSON === "function") {
           node = node.toJSON();
         }
@@ -331,7 +321,7 @@ var require_fast_json_stable_stringify = __commonJS({
         }
         seen.splice(seenIndex, 1);
         return "{" + out + "}";
-      }(data);
+      })(data);
     };
   }
 });
@@ -463,6 +453,11 @@ var require_vendors = __commonJS({
         constant: "CLOUDFLARE_PAGES",
         env: "CF_PAGES"
       },
+      {
+        name: "Cloudflare Workers",
+        constant: "CLOUDFLARE_WORKERS",
+        env: "WORKERS_CI"
+      },
       {
         name: "Codefresh",
         constant: "CODEFRESH",
@@ -741,23 +736,25 @@ var require_ci_info = __commonJS({
     exports.name = null;
     exports.isPR = null;
     exports.id = null;
-    vendors.forEach(function(vendor) {
-      const envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
-      const isCI2 = envs.every(function(obj) {
-        return checkEnv(obj);
+    if (env3.CI !== "false") {
+      vendors.forEach(function(vendor) {
+        const envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
+        const isCI2 = envs.every(function(obj) {
+          return checkEnv(obj);
+        });
+        exports[vendor.constant] = isCI2;
+        if (!isCI2) {
+          return;
+        }
+        exports.name = vendor.name;
+        exports.isPR = checkPR(vendor);
+        exports.id = vendor.constant;
       });
-      exports[vendor.constant] = isCI2;
-      if (!isCI2) {
-        return;
-      }
-      exports.name = vendor.name;
-      exports.isPR = checkPR(vendor);
-      exports.id = vendor.constant;
-    });
+    }
     exports.isCI = !!(env3.CI !== "false" && // Bypass all checks if CI env is explicitly set to 'false'
     (env3.BUILD_ID || // Jenkins, Cloudbees
     env3.BUILD_NUMBER || // Jenkins, TeamCity
-    env3.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari, Cloudflare Pages
+    env3.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari, Cloudflare Pages/Workers
     env3.CI_APP_ID || // Appflow
     env3.CI_BUILD_ID || // Appflow
     env3.CI_BUILD_NUMBER || // Appflow
@@ -809,17 +806,26 @@ var require_ci_info = __commonJS({
 // src/cli/index.js
 import * as prettier2 from "../index.mjs";
 
-// scripts/build/shims/at.js
-var at = (isOptionalObject, object2, index) => {
-  if (isOptionalObject && (object2 === void 0 || object2 === null)) {
+// scripts/build/shims/shared.js
+var OPTIONAL_OBJECT = 1;
+var createMethodShim = (methodName, getImplementation) => (flags, object2, ...arguments_) => {
+  if (flags | OPTIONAL_OBJECT && (object2 === void 0 || object2 === null)) {
     return;
   }
-  if (Array.isArray(object2) || typeof object2 === "string") {
-    return object2[index < 0 ? object2.length + index : index];
-  }
-  return object2.at(index);
+  const implementation = getImplementation.call(object2) ?? object2[methodName];
+  return implementation.apply(object2, arguments_);
 };
-var at_default = at;
+
+// scripts/build/shims/method-at.js
+function stringOrArrayAt(index) {
+  return this[index < 0 ? this.length + index : index];
+}
+var at = createMethodShim("at", function() {
+  if (Array.isArray(this) || typeof this === "string") {
+    return stringOrArrayAt;
+  }
+});
+var method_at_default = at;
 
 // src/cli/options/get-context-options.js
 var import_dashify = __toESM(require_dashify(), 1);
@@ -1007,7 +1013,7 @@ var {
   fastGlob,
   createTwoFilesPatch,
   picocolors,
-  leven
+  closetLevenshteinMatch
 } = sharedWithCli;
 
 // src/cli/options/get-context-options.js
@@ -1030,12 +1036,11 @@ function apiOptionToCliOption(apiOption) {
   return normalizeDetailedOption(cliOption);
 }
 function normalizeDetailedOption(option) {
-  var _a;
   return {
     category: optionCategories.CATEGORY_OTHER,
     ...option,
     name: option.cliName ?? (0, import_dashify.default)(option.name),
-    choices: (_a = option.choices) == null ? void 0 : _a.map((choice) => {
+    choices: option.choices?.map((choice) => {
       const newChoice = {
         description: "",
         deprecated: false,
@@ -1071,27 +1076,26 @@ function getContextOptionsWithoutPlugins() {
   return supportInfoToContextOptions(supportInfo);
 }
 
-// scripts/build/shims/string-replace-all.js
-var stringReplaceAll = (isOptionalObject, original, pattern, replacement) => {
-  if (isOptionalObject && (original === void 0 || original === null)) {
-    return;
-  }
-  if (original.replaceAll) {
-    return original.replaceAll(pattern, replacement);
-  }
+// scripts/build/shims/method-replace-all.js
+var stringReplaceAll = String.prototype.replaceAll ?? function(pattern, replacement) {
   if (pattern.global) {
-    return original.replace(pattern, replacement);
+    return this.replace(pattern, replacement);
   }
-  return original.split(pattern).join(replacement);
+  return this.split(pattern).join(replacement);
 };
-var string_replace_all_default = stringReplaceAll;
+var replaceAll = createMethodShim("replaceAll", function() {
+  if (typeof this === "string") {
+    return stringReplaceAll;
+  }
+});
+var method_replace_all_default = replaceAll;
 
 // node_modules/camelcase/index.js
 var UPPERCASE = /[\p{Lu}]/u;
 var LOWERCASE = /[\p{Ll}]/u;
-var LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
-var IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
+var LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/u;
 var SEPARATORS = /[_.\- ]+/;
+var IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
 var LEADING_SEPARATORS = new RegExp("^" + SEPARATORS.source);
 var SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu");
 var NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER.source, "gu");
@@ -1122,28 +1126,57 @@ var preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUp
   }
   return string;
 };
-var preserveConsecutiveUppercase = (input, toLowerCase) => {
-  LEADING_CAPITAL.lastIndex = 0;
-  return string_replace_all_default(
-    /* isOptionalObject */
-    false,
-    input,
-    LEADING_CAPITAL,
-    (match) => toLowerCase(match)
-  );
+var preserveConsecutiveUppercase = (input, toLowerCase) => input.replace(LEADING_CAPITAL, (match) => toLowerCase(match));
+var processWithCasePreservation = (input, toLowerCase, preserveConsecutiveUppercase2) => {
+  let result = "";
+  let previousWasNumber = false;
+  let previousWasUppercase = false;
+  const characters = [...input];
+  for (let index = 0; index < characters.length; index++) {
+    const character = characters[index];
+    const isUpperCase = UPPERCASE.test(character);
+    const nextCharIsUpperCase = index + 1 < characters.length && UPPERCASE.test(characters[index + 1]);
+    if (previousWasNumber && /[\p{Alpha}]/u.test(character)) {
+      result += character;
+      previousWasNumber = false;
+      previousWasUppercase = isUpperCase;
+    } else if (preserveConsecutiveUppercase2 && isUpperCase && (previousWasUppercase || nextCharIsUpperCase)) {
+      result += character;
+      previousWasUppercase = true;
+    } else if (/\d/.test(character)) {
+      result += character;
+      previousWasNumber = true;
+      previousWasUppercase = false;
+    } else if (SEPARATORS.test(character)) {
+      result += character;
+      previousWasUppercase = false;
+    } else {
+      result += toLowerCase(character);
+      previousWasNumber = false;
+      previousWasUppercase = false;
+    }
+  }
+  return result;
 };
-var postProcess = (input, toUpperCase) => {
-  SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
-  NUMBERS_AND_IDENTIFIER.lastIndex = 0;
-  return string_replace_all_default(
-    /* isOptionalObject */
-    false,
-    string_replace_all_default(
-      /* isOptionalObject */
-      false,
+var postProcess = (input, toUpperCase, {
+  capitalizeAfterNumber
+}) => {
+  const transformNumericIdentifier = capitalizeAfterNumber ? (match, identifier, offset, string) => {
+    const nextCharacter = string.charAt(offset + match.length);
+    if (SEPARATORS.test(nextCharacter)) {
+      return match;
+    }
+    return identifier ? match.slice(0, -identifier.length) + toUpperCase(identifier) : match;
+  } : (match) => match;
+  return method_replace_all_default(
+    /* OPTIONAL_OBJECT: false */
+    0,
+    method_replace_all_default(
+      /* OPTIONAL_OBJECT: false */
+      0,
       input,
       NUMBERS_AND_IDENTIFIER,
-      (match, pattern, offset) => ["_", "-"].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match)
+      transformNumericIdentifier
     ),
     SEPARATORS_AND_IDENTIFIER,
     (_2, identifier) => toUpperCase(identifier)
@@ -1156,34 +1189,44 @@ function camelCase(input, options) {
   options = {
     pascalCase: false,
     preserveConsecutiveUppercase: false,
+    capitalizeAfterNumber: true,
     ...options
   };
   if (Array.isArray(input)) {
-    input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
+    input = input.map((element) => element.trim()).filter((element) => element.length > 0).join("-");
   } else {
     input = input.trim();
   }
   if (input.length === 0) {
     return "";
   }
+  const leadingPrefix = input.match(/^[_$]*/)[0];
+  input = input.slice(leadingPrefix.length);
+  if (input.length === 0) {
+    return leadingPrefix;
+  }
   const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
   const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
   if (input.length === 1) {
     if (SEPARATORS.test(input)) {
-      return "";
+      return leadingPrefix;
     }
-    return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
+    return leadingPrefix + (options.pascalCase ? toUpperCase(input) : toLowerCase(input));
   }
   const hasUpperCase = input !== toLowerCase(input);
   if (hasUpperCase) {
     input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase);
   }
   input = input.replace(LEADING_SEPARATORS, "");
-  input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
-  if (options.pascalCase) {
-    input = toUpperCase(input.charAt(0)) + input.slice(1);
+  if (options.capitalizeAfterNumber) {
+    input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
+  } else {
+    input = processWithCasePreservation(input, toLowerCase, options.preserveConsecutiveUppercase);
+  }
+  if (options.pascalCase && input.length > 0) {
+    input = toUpperCase(input[0]) + input.slice(1);
   }
-  return postProcess(input, toUpperCase);
+  return leadingPrefix + postProcess(input, toUpperCase, options);
 }
 
 // src/cli/utils.js
@@ -1191,13 +1234,33 @@ import fs from "fs/promises";
 import path from "path";
 
 // node_modules/sdbm/index.js
-function sdbm(string) {
-  let hash2 = 0;
-  for (let i = 0; i < string.length; i++) {
-    hash2 = string.charCodeAt(i) + (hash2 << 6) + (hash2 << 16) - hash2;
+var textEncoder = new TextEncoder();
+function sdbmHash(input, options) {
+  if (typeof input === "string") {
+    if (options?.bytes) {
+      input = textEncoder.encode(input);
+    } else {
+      let hash3 = 0n;
+      for (let index = 0; index < input.length; index++) {
+        hash3 = BigInt(input.charCodeAt(index)) + (hash3 << 6n) + (hash3 << 16n) - hash3;
+      }
+      return hash3;
+    }
+  } else if (!(input instanceof Uint8Array)) {
+    throw new TypeError("Expected a string or Uint8Array");
+  }
+  let hash2 = 0n;
+  for (const byte of input) {
+    hash2 = BigInt(byte) + (hash2 << 6n) + (hash2 << 16n) - hash2;
   }
-  return hash2 >>> 0;
+  return hash2;
+}
+function sdbm(input, options) {
+  return Number(BigInt.asUintN(32, sdbmHash(input, options)));
 }
+sdbm.bigint = function(input, options) {
+  return BigInt.asUintN(64, sdbmHash(input, options));
+};
 
 // src/cli/utils.js
 import { __internal as sharedWithCli2 } from "../index.mjs";
@@ -1247,14 +1310,16 @@ function isJson(value) {
     return false;
   }
 }
-var normalizeToPosix = path.sep === "\\" ? (filepath) => string_replace_all_default(
-  /* isOptionalObject */
-  false,
+var normalizeToPosix = path.sep === "\\" ? (filepath) => method_replace_all_default(
+  /* OPTIONAL_OBJECT: false */
+  0,
   filepath,
   "\\",
   "/"
 ) : (filepath) => filepath;
-var { omit } = sharedWithCli2.utils;
+var {
+  omit
+} = sharedWithCli2.utils;
 
 // src/cli/options/create-minimist-options.js
 function createMinimistOptions(detailedOptions) {
@@ -1306,16 +1371,17 @@ var descriptor = {
   value: (value) => vnopts.apiDescriptor.value(value),
   pair: ({ key, value }) => value === false ? `--no-${key}` : value === true ? descriptor.key(key) : value === "" ? `${descriptor.key(key)} without an argument` : `${descriptor.key(key)}=${value}`
 };
-var _flags;
 var FlagSchema = class extends vnopts.ChoiceSchema {
+  #flags = [];
   constructor({ name, flags }) {
     super({ name, choices: flags });
-    __privateAdd(this, _flags, []);
-    __privateSet(this, _flags, [...flags].sort());
+    this.#flags = [...flags].sort();
   }
   preprocess(value, utils) {
-    if (typeof value === "string" && value.length > 0 && !__privateGet(this, _flags).includes(value)) {
-      const suggestion = __privateGet(this, _flags).find((flag) => leven(flag, value) < 3);
+    if (typeof value === "string" && value.length > 0 && !this.#flags.includes(value)) {
+      const suggestion = closetLevenshteinMatch(value, this.#flags, {
+        maxDistance: 3
+      });
       if (suggestion) {
         utils.logger.warn(
           [
@@ -1332,7 +1398,6 @@ var FlagSchema = class extends vnopts.ChoiceSchema {
     return "a flag";
   }
 };
-_flags = new WeakMap();
 function normalizeCliOptions(options, optionInfos, opts) {
   return normalizeOptions(options, optionInfos, {
     ...opts,
@@ -1345,7 +1410,6 @@ var normalize_cli_options_default = normalizeCliOptions;
 
 // src/cli/options/parse-cli-arguments.js
 function parseArgv(rawArguments, detailedOptions, logger, keys2) {
-  var _a;
   const minimistOptions = createMinimistOptions(detailedOptions);
   let argv2 = minimistParse(rawArguments, minimistOptions);
   if (keys2) {
@@ -1362,7 +1426,7 @@ function parseArgv(rawArguments, detailedOptions, logger, keys2) {
         return [option.forwardToApi || camelCase(key), value];
       })
     ),
-    _: (_a = normalized._) == null ? void 0 : _a.map(String),
+    _: normalized._?.map(String),
     get __raw() {
       return argv2;
     }
@@ -1379,18 +1443,23 @@ function parseArgvWithoutPlugins(rawArguments, logger, keys2) {
 }
 
 // src/cli/context.js
-var _stack;
 var Context = class {
-  constructor({ rawArguments, logger }) {
-    __privateAdd(this, _stack, []);
+  #stack = [];
+  constructor({
+    rawArguments,
+    logger
+  }) {
     this.rawArguments = rawArguments;
     this.logger = logger;
   }
   async init() {
-    const { rawArguments, logger } = this;
-    const { plugins } = parseArgvWithoutPlugins(rawArguments, logger, [
-      "plugin"
-    ]);
+    const {
+      rawArguments,
+      logger
+    } = this;
+    const {
+      plugins
+    } = parseArgvWithoutPlugins(rawArguments, logger, ["plugin"]);
     await this.pushContextPlugins(plugins);
     const argv2 = parseArgv(rawArguments, this.detailedOptions, logger);
     this.argv = argv2;
@@ -1401,21 +1470,24 @@ var Context = class {
    */
   async pushContextPlugins(plugins) {
     const options = await getContextOptions(plugins);
-    __privateGet(this, _stack).push(options);
+    this.#stack.push(options);
     Object.assign(this, options);
   }
   popContextPlugins() {
-    __privateGet(this, _stack).pop();
-    Object.assign(this, at_default(
-      /* isOptionalObject */
-      false,
-      __privateGet(this, _stack),
+    this.#stack.pop();
+    Object.assign(this, method_at_default(
+      /* OPTIONAL_OBJECT: false */
+      0,
+      this.#stack,
       -1
     ));
   }
   // eslint-disable-next-line getter-return
   get performanceTestFlag() {
-    const { debugBenchmark, debugRepeat } = this.argv;
+    const {
+      debugBenchmark,
+      debugRepeat
+    } = this.argv;
     if (debugBenchmark) {
       return {
         name: "--debug-benchmark",
@@ -1428,7 +1500,9 @@ var Context = class {
         debugRepeat
       };
     }
-    const { PRETTIER_PERF_REPEAT } = process.env;
+    const {
+      PRETTIER_PERF_REPEAT
+    } = process.env;
     if (PRETTIER_PERF_REPEAT && /^\d+$/u.test(PRETTIER_PERF_REPEAT)) {
       return {
         name: "PRETTIER_PERF_REPEAT (environment variable)",
@@ -1437,7 +1511,6 @@ var Context = class {
     }
   }
 };
-_stack = new WeakMap();
 var context_default = Context;
 
 // src/cli/file-info.js
@@ -1455,7 +1528,7 @@ async function logFileInfoOrDie(context) {
   const fileInfo = await getFileInfo(path2.resolve(file), {
     ignorePath,
     withNodeModules: withNodeModules2,
-    plugins: plugins.length > 0 ? plugins : void 0,
+    plugins,
     resolveConfig: config !== false
   });
   const result = await format((0, import_fast_json_stable_stringify.default)(fileInfo), { parser: "json" });
@@ -1518,14 +1591,13 @@ import path4 from "path";
 var alwaysIgnoredDirectories = [".git", ".sl", ".svn", ".hg", ".jj"];
 var withNodeModules = [...alwaysIgnoredDirectories, "node_modules"];
 var cwd = process.cwd();
-var _directories;
 var DirectoryIgnorer = class {
+  #directories;
+  ignorePatterns;
   constructor(shouldIgnoreNodeModules) {
-    __privateAdd(this, _directories);
-    __publicField(this, "ignorePatterns");
     const directories = shouldIgnoreNodeModules ? withNodeModules : alwaysIgnoredDirectories;
     const patterns = directories.map((directory) => `**/${directory}`);
-    __privateSet(this, _directories, new Set(directories));
+    this.#directories = new Set(directories);
     this.ignorePatterns = patterns;
   }
   /**
@@ -1534,11 +1606,10 @@ var DirectoryIgnorer = class {
   shouldIgnore(absolutePathOrPattern) {
     const directoryNames = path4.relative(cwd, absolutePathOrPattern).split(path4.sep);
     return directoryNames.some(
-      (directoryName) => __privateGet(this, _directories).has(directoryName)
+      (directoryName) => this.#directories.has(directoryName)
     );
   }
 };
-_directories = new WeakMap();
 var directoryIgnorerWithNodeModules = new DirectoryIgnorer(
   /* shouldIgnoreNodeModules */
   true
@@ -1552,12 +1623,16 @@ var directoryIgnorerWithoutNodeModules = new DirectoryIgnorer(
 async function* expandPatterns(context) {
   const seen = /* @__PURE__ */ new Set();
   let noResults = true;
-  for await (const { filePath, ignoreUnknown, error } of expandPatternsInternal(
-    context
-  )) {
+  for await (const {
+    filePath,
+    ignoreUnknown,
+    error
+  } of expandPatternsInternal(context)) {
     noResults = false;
     if (error) {
-      yield { error };
+      yield {
+        error
+      };
       continue;
     }
     const filename = path5.resolve(filePath);
@@ -1565,7 +1640,10 @@ async function* expandPatterns(context) {
       continue;
     }
     seen.add(filename);
-    yield { filename, ignoreUnknown };
+    yield {
+      filename,
+      ignoreUnknown
+    };
   }
   if (noResults && context.argv.errorOnUnmatchedPattern !== false) {
     yield {
@@ -1595,9 +1673,7 @@ async function* expandPatternsInternal(context) {
             error: `Explicitly specified pattern "${pattern}" is a symbolic link.`
           };
         } else {
-          context.logger.debug(
-            `Skipping pattern "${pattern}", as it is a symbolic link.`
-          );
+          context.logger.debug(`Skipping pattern "${pattern}", as it is a symbolic link.`);
         }
       } else if (stat.isFile()) {
         entries.push({
@@ -1625,11 +1701,18 @@ async function* expandPatternsInternal(context) {
       });
     }
   }
-  for (const { type, glob, input, ignoreUnknown } of entries) {
+  for (const {
+    type,
+    glob,
+    input,
+    ignoreUnknown
+  } of entries) {
     let result;
     try {
       result = await fastGlob(glob, globOptions);
-    } catch ({ message }) {
+    } catch ({
+      message
+    }) {
       yield {
         error: `${errorMessages.globError[type]}: "${input}".
 ${message}`
@@ -1638,10 +1721,15 @@ ${message}`
     }
     if (result.length === 0) {
       if (context.argv.errorOnUnmatchedPattern !== false) {
-        yield { error: `${errorMessages.emptyResults[type]}: "${input}".` };
+        yield {
+          error: `${errorMessages.emptyResults[type]}: "${input}".`
+        };
       }
     } else {
-      yield* sortPaths(result).map((filePath) => ({ filePath, ignoreUnknown }));
+      yield* sortPaths(result).map((filePath) => ({
+        filePath,
+        ignoreUnknown
+      }));
     }
   }
 }
@@ -1661,27 +1749,27 @@ function sortPaths(paths) {
   return paths.sort((a, b) => a.localeCompare(b));
 }
 function escapePathForGlob(path13) {
-  return string_replace_all_default(
-    /* isOptionalObject */
-    false,
-    string_replace_all_default(
-      /* isOptionalObject */
-      false,
+  return method_replace_all_default(
+    /* OPTIONAL_OBJECT: false */
+    0,
+    method_replace_all_default(
+      /* OPTIONAL_OBJECT: false */
+      0,
       fastGlob.escapePath(
-        string_replace_all_default(
-          /* isOptionalObject */
-          false,
+        method_replace_all_default(
+          /* OPTIONAL_OBJECT: false */
+          0,
           path13,
           "\\",
           "\0"
         )
         // Workaround for fast-glob#262 (part 1)
       ),
-      String.raw`\!`,
+      "\\!",
       "@(!)"
     ),
     "\0",
-    String.raw`@(\\)`
+    "@(\\\\)"
   );
 }
 var fixWindowsSlashes = normalizeToPosix;
@@ -1719,7 +1807,7 @@ function findUpSync(name, {
     const filePath = isAbsoluteName ? name : path6.join(directory, name);
     try {
       const stats = fs2.statSync(filePath, { throwIfNoEntry: false });
-      if (type === "file" && (stats == null ? void 0 : stats.isFile()) || type === "directory" && (stats == null ? void 0 : stats.isDirectory())) {
+      if (type === "file" && stats?.isFile() || type === "directory" && stats?.isDirectory()) {
         return filePath;
       }
     } catch {
@@ -1784,7 +1872,7 @@ function findCacheDirectory(options = {}) {
 
 // src/cli/find-cache-file.js
 function findDefaultCacheFile() {
-  const cacheDir = findCacheDirectory({ name: "prettier", create: true }) || os.tmpdir();
+  const cacheDir = findCacheDirectory({ name: "prettier" }) ?? os.tmpdir();
   const cacheFilePath = path9.join(cacheDir, ".prettier-cache");
   return cacheFilePath;
 }
@@ -1823,153 +1911,1392 @@ import fs6 from "fs";
 import path11 from "path";
 
 // node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
-import path10 from "path";
 import fs5 from "fs";
+import path10 from "path";
 
 // node_modules/hookified/dist/node/index.js
-var n = class {
+var Eventified = class {
   _eventListeners;
   _maxListeners;
   _logger;
-  constructor(e) {
-    this._eventListeners = /* @__PURE__ */ new Map(), this._maxListeners = 100, this._logger = e == null ? void 0 : e.logger;
+  _throwOnEmitError = false;
+  _throwOnEmptyListeners = false;
+  _errorEvent = "error";
+  constructor(options) {
+    this._eventListeners = /* @__PURE__ */ new Map();
+    this._maxListeners = 100;
+    this._logger = options?.logger;
+    if (options?.throwOnEmitError !== void 0) {
+      this._throwOnEmitError = options.throwOnEmitError;
+    }
+    if (options?.throwOnEmptyListeners !== void 0) {
+      this._throwOnEmptyListeners = options.throwOnEmptyListeners;
+    }
+  }
+  /**
+   * Gets the logger
+   * @returns {Logger}
+   */
+  get logger() {
+    return this._logger;
+  }
+  /**
+   * Sets the logger
+   * @param {Logger} logger
+   */
+  set logger(logger) {
+    this._logger = logger;
+  }
+  /**
+   * Gets whether an error should be thrown when an emit throws an error. Default is false and only emits an error event.
+   * @returns {boolean}
+   */
+  get throwOnEmitError() {
+    return this._throwOnEmitError;
+  }
+  /**
+   * Sets whether an error should be thrown when an emit throws an error. Default is false and only emits an error event.
+   * @param {boolean} value
+   */
+  set throwOnEmitError(value) {
+    this._throwOnEmitError = value;
+  }
+  /**
+   * Gets whether an error should be thrown when emitting 'error' event with no listeners. Default is false.
+   * @returns {boolean}
+   */
+  get throwOnEmptyListeners() {
+    return this._throwOnEmptyListeners;
+  }
+  /**
+   * Sets whether an error should be thrown when emitting 'error' event with no listeners. Default is false.
+   * @param {boolean} value
+   */
+  set throwOnEmptyListeners(value) {
+    this._throwOnEmptyListeners = value;
   }
-  once(e, t) {
-    let s = (...r) => {
-      this.off(e, s), t(...r);
+  /**
+   * 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_);
     };
-    return this.on(e, s), this;
+    this.on(eventName, onceListener);
+    return this;
   }
-  listenerCount(e) {
-    if (!e) return this.getAllListeners().length;
-    let t = this._eventListeners.get(e);
-    return t ? t.length : 0;
+  /**
+   * 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 === void 0) {
+      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 [...this._eventListeners.keys()];
   }
-  rawListeners(e) {
-    return e ? this._eventListeners.get(e) ?? [] : this.getAllListeners();
+  /**
+   * 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 === void 0) {
+      return this.getAllListeners();
+    }
+    return this._eventListeners.get(event) ?? [];
   }
-  prependListener(e, t) {
-    let s = this._eventListeners.get(e) ?? [];
-    return s.unshift(t), this._eventListeners.set(e, s), this;
+  /**
+   * 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;
   }
-  prependOnceListener(e, t) {
-    let s = (...r) => {
-      this.off(e, s), t(...r);
+  /**
+   * 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_);
     };
-    return this.prependListener(e, s), this;
+    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;
   }
-  addListener(e, t) {
-    return this.on(e, t), this;
+  /**
+   * 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;
+      }
+    }
+    if (event === this._errorEvent) {
+      const error = arguments_[0] instanceof Error ? arguments_[0] : new Error(`${arguments_[0]}`);
+      if (this._throwOnEmitError && !result) {
+        throw error;
+      } else {
+        if (this.listeners(this._errorEvent).length === 0 && this._throwOnEmptyListeners === true) {
+          throw error;
+        }
+      }
+    }
+    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 !== void 0) {
+      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 = [];
+    for (const listeners of this._eventListeners.values()) {
+      result = [...result, ...listeners];
+    }
+    return result;
+  }
+};
+var Hookified = class extends Eventified {
+  _hooks;
+  _throwOnHookError = false;
+  _enforceBeforeAfter = false;
+  _deprecatedHooks;
+  _allowDeprecated = true;
+  constructor(options) {
+    super({
+      logger: options?.logger,
+      throwOnEmitError: options?.throwOnEmitError,
+      throwOnEmptyListeners: options?.throwOnEmptyListeners
+    });
+    this._hooks = /* @__PURE__ */ new Map();
+    this._deprecatedHooks = options?.deprecatedHooks ? new Map(options.deprecatedHooks) : /* @__PURE__ */ new Map();
+    if (options?.throwOnHookError !== void 0) {
+      this._throwOnHookError = options.throwOnHookError;
+    } else if (options?.throwHookErrors !== void 0) {
+      this._throwOnHookError = options.throwHookErrors;
+    }
+    if (options?.enforceBeforeAfter !== void 0) {
+      this._enforceBeforeAfter = options.enforceBeforeAfter;
+    }
+    if (options?.allowDeprecated !== void 0) {
+      this._allowDeprecated = options.allowDeprecated;
+    }
+  }
+  /**
+   * 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}
+   * @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
+   */
+  get throwHookErrors() {
+    return this._throwOnHookError;
+  }
+  /**
+   * 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
+   * @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
+   */
+  set throwHookErrors(value) {
+    this._throwOnHookError = value;
+  }
+  /**
+   * 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 throwOnHookError() {
+    return this._throwOnHookError;
+  }
+  /**
+   * 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 throwOnHookError(value) {
+    this._throwOnHookError = value;
+  }
+  /**
+   * Gets whether to enforce that all hook names start with 'before' or 'after'. Default is false.
+   * @returns {boolean}
+   * @default false
+   */
+  get enforceBeforeAfter() {
+    return this._enforceBeforeAfter;
+  }
+  /**
+   * Sets whether to enforce that all hook names start with 'before' or 'after'. Default is false.
+   * @param {boolean} value
+   */
+  set enforceBeforeAfter(value) {
+    this._enforceBeforeAfter = value;
+  }
+  /**
+   * Gets the map of deprecated hook names to deprecation messages.
+   * @returns {Map<string, string>}
+   */
+  get deprecatedHooks() {
+    return this._deprecatedHooks;
+  }
+  /**
+   * Sets the map of deprecated hook names to deprecation messages.
+   * @param {Map<string, string>} value
+   */
+  set deprecatedHooks(value) {
+    this._deprecatedHooks = value;
+  }
+  /**
+   * Gets whether deprecated hooks are allowed to be registered and executed. Default is true.
+   * @returns {boolean}
+   */
+  get allowDeprecated() {
+    return this._allowDeprecated;
+  }
+  /**
+   * Sets whether deprecated hooks are allowed to be registered and executed. Default is true.
+   * @param {boolean} value
+   */
+  set allowDeprecated(value) {
+    this._allowDeprecated = value;
+  }
+  /**
+   * Validates hook event name if enforceBeforeAfter is enabled
+   * @param {string} event - The event name to validate
+   * @throws {Error} If enforceBeforeAfter is true and event doesn't start with 'before' or 'after'
+   */
+  validateHookName(event) {
+    if (this._enforceBeforeAfter) {
+      const eventValue = event.trim().toLocaleLowerCase();
+      if (!eventValue.startsWith("before") && !eventValue.startsWith("after")) {
+        throw new Error(
+          `Hook event "${event}" must start with "before" or "after" when enforceBeforeAfter is enabled`
+        );
+      }
+    }
+  }
+  /**
+   * Checks if a hook is deprecated and emits a warning if it is
+   * @param {string} event - The event name to check
+   * @returns {boolean} - Returns true if the hook should proceed, false if it should be blocked
+   */
+  checkDeprecatedHook(event) {
+    if (this._deprecatedHooks.has(event)) {
+      const message = this._deprecatedHooks.get(event);
+      const warningMessage = `Hook "${event}" is deprecated${message ? `: ${message}` : ""}`;
+      this.emit("warn", { hook: event, message: warningMessage });
+      if (this.logger?.warn) {
+        this.logger.warn(warningMessage);
+      }
+      return this._allowDeprecated;
+    }
+    return true;
   }
-  on(e, t) {
-    this._eventListeners.has(e) || this._eventListeners.set(e, []);
-    let s = this._eventListeners.get(e);
-    return s && (s.length >= this._maxListeners && console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${s.length + 1} ${e} listeners added. Use setMaxListeners() to increase limit.`), s.push(t)), this;
+  /**
+   * 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) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return;
+    }
+    const eventHandlers = this._hooks.get(event);
+    if (eventHandlers) {
+      eventHandlers.push(handler);
+    } else {
+      this._hooks.set(event, [handler]);
+    }
   }
-  removeListener(e, t) {
-    return this.off(e, t), this;
+  /**
+   * Adds a handler function for a specific event that runs before all other handlers
+   * @param {HookEntry} hookEntry
+   * @returns {void}
+   */
+  onHookEntry(hookEntry) {
+    this.onHook(hookEntry.event, hookEntry.handler);
+  }
+  /**
+   * Alias for onHook. This is provided for compatibility with other libraries that use the `addHook` method.
+   * @param {string} event
+   * @param {Hook} handler - this can be async or sync
+   * @returns {void}
+   */
+  addHook(event, handler) {
+    this.onHook(event, handler);
+  }
+  /**
+   * Adds a handler function for a specific event
+   * @param {Array<HookEntry>} hooks
+   * @returns {void}
+   */
+  onHooks(hooks) {
+    for (const hook of hooks) {
+      this.onHook(hook.event, hook.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) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return;
+    }
+    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) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return;
+    }
+    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) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return;
+    }
+    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) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return;
+    }
+    const eventHandlers = this._hooks.get(event);
+    if (eventHandlers) {
+      const index = eventHandlers.indexOf(handler);
+      if (index !== -1) {
+        eventHandlers.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * Removes all handlers for a specific event
+   * @param {Array<HookEntry>} hooks
+   * @returns {void}
+   */
+  removeHooks(hooks) {
+    for (const hook of hooks) {
+      this.removeHook(hook.event, hook.handler);
+    }
+  }
+  /**
+   * Calls all handlers for a specific event
+   * @param {string} event
+   * @param {T[]} arguments_
+   * @returns {Promise<void>}
+   */
+  async hook(event, ...arguments_) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return;
+    }
+    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.logger) {
+            this.logger.error(message);
+          }
+          if (this._throwOnHookError) {
+            throw new Error(message);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Prepends the word `before` to your hook. Example is event is `test`, the before hook is `before:test`.
+   * @param {string} event - The event name
+   * @param {T[]} arguments_ - The arguments to pass to the hook
+   */
+  async beforeHook(event, ...arguments_) {
+    await this.hook(`before:${event}`, ...arguments_);
+  }
+  /**
+   * Prepends the word `after` to your hook. Example is event is `test`, the after hook is `after:test`.
+   * @param {string} event - The event name
+   * @param {T[]} arguments_ - The arguments to pass to the hook
+   */
+  async afterHook(event, ...arguments_) {
+    await this.hook(`after:${event}`, ...arguments_);
+  }
+  /**
+   * Calls all handlers for a specific event. This is an alias for `hook` and is provided for
+   * compatibility with other libraries that use the `callHook` method.
+   * @param {string} event
+   * @param {T[]} arguments_
+   * @returns {Promise<void>}
+   */
+  async callHook(event, ...arguments_) {
+    await this.hook(event, ...arguments_);
+  }
+  /**
+   * Gets all hooks for a specific event
+   * @param {string} event
+   * @returns {Hook[]}
+   */
+  getHooks(event) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return void 0;
+    }
+    return this._hooks.get(event);
   }
-  off(e, t) {
-    let s = this._eventListeners.get(e) ?? [], r = s.indexOf(t);
-    return r !== -1 && s.splice(r, 1), s.length === 0 && this._eventListeners.delete(e), this;
+  /**
+   * Removes all hooks
+   * @returns {void}
+   */
+  clearHooks() {
+    this._hooks.clear();
+  }
+};
+
+// node_modules/hashery/dist/node/index.js
+var CRC = class {
+  get name() {
+    return "crc32";
+  }
+  toHashSync(data) {
+    let bytes;
+    if (data instanceof Uint8Array) {
+      bytes = data;
+    } else if (data instanceof ArrayBuffer) {
+      bytes = new Uint8Array(data);
+    } else if (data instanceof DataView) {
+      bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    } else {
+      const view = data;
+      bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    }
+    const CRC32_POLYNOMIAL = 3988292384;
+    let crc = 4294967295;
+    for (let i = 0; i < bytes.length; i++) {
+      crc = crc ^ bytes[i];
+      for (let j = 0; j < 8; j++) {
+        crc = crc >>> 1 ^ CRC32_POLYNOMIAL & -(crc & 1);
+      }
+    }
+    crc = (crc ^ 4294967295) >>> 0;
+    const hashHex = crc.toString(16).padStart(8, "0");
+    return hashHex;
+  }
+  async toHash(data) {
+    return this.toHashSync(data);
+  }
+};
+var WebCrypto = class {
+  _algorithm = "SHA-256";
+  constructor(options) {
+    if (options?.algorithm) {
+      this._algorithm = options?.algorithm;
+    }
+  }
+  get name() {
+    return this._algorithm;
+  }
+  async toHash(data) {
+    const hashBuffer = await crypto.subtle.digest(this._algorithm, data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    return hashHex;
+  }
+};
+var DJB2 = class {
+  /**
+   * The name identifier for this hash provider.
+   */
+  get name() {
+    return "djb2";
+  }
+  /**
+   * Computes the DJB2 hash of the provided data synchronously.
+   *
+   * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+   * @returns An 8-character lowercase hexadecimal string
+   *
+   * @example
+   * ```typescript
+   * const djb2 = new DJB2();
+   * const data = new TextEncoder().encode('hello');
+   * const hash = djb2.toHashSync(data);
+   * console.log(hash); // "7c9df5ea"
+   * ```
+   */
+  toHashSync(data) {
+    let bytes;
+    if (data instanceof Uint8Array) {
+      bytes = data;
+    } else if (data instanceof ArrayBuffer) {
+      bytes = new Uint8Array(data);
+    } else if (data instanceof DataView) {
+      bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    } else {
+      const view = data;
+      bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    }
+    let hash2 = 5381;
+    for (let i = 0; i < bytes.length; i++) {
+      hash2 = (hash2 << 5) + hash2 + bytes[i];
+      hash2 = hash2 >>> 0;
+    }
+    const hashHex = hash2.toString(16).padStart(8, "0");
+    return hashHex;
+  }
+  /**
+   * Computes the DJB2 hash of the provided data.
+   *
+   * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+   * @returns A Promise resolving to an 8-character lowercase hexadecimal string
+   *
+   * @example
+   * ```typescript
+   * const djb2 = new DJB2();
+   * const data = new TextEncoder().encode('hello');
+   * const hash = await djb2.toHash(data);
+   * console.log(hash); // "7c9df5ea"
+   * ```
+   */
+  async toHash(data) {
+    return this.toHashSync(data);
+  }
+};
+var FNV1 = class {
+  /**
+   * The name identifier for this hash provider.
+   */
+  get name() {
+    return "fnv1";
+  }
+  /**
+   * Computes the FNV-1 hash of the provided data synchronously.
+   *
+   * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+   * @returns An 8-character lowercase hexadecimal string
+   */
+  toHashSync(data) {
+    let bytes;
+    if (data instanceof Uint8Array) {
+      bytes = data;
+    } else if (data instanceof ArrayBuffer) {
+      bytes = new Uint8Array(data);
+    } else if (data instanceof DataView) {
+      bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    } else {
+      const view = data;
+      bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    }
+    const FNV_OFFSET_BASIS = 2166136261;
+    const FNV_PRIME = 16777619;
+    let hash2 = FNV_OFFSET_BASIS;
+    for (let i = 0; i < bytes.length; i++) {
+      hash2 = hash2 * FNV_PRIME;
+      hash2 = hash2 ^ bytes[i];
+      hash2 = hash2 >>> 0;
+    }
+    const hashHex = hash2.toString(16).padStart(8, "0");
+    return hashHex;
+  }
+  /**
+   * Computes the FNV-1 hash of the provided data.
+   *
+   * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+   * @returns A Promise resolving to an 8-character lowercase hexadecimal string
+   */
+  async toHash(data) {
+    return this.toHashSync(data);
+  }
+};
+var Murmer = class {
+  _seed;
+  /**
+   * Creates a new Murmer instance.
+   *
+   * @param seed - Optional seed value for the hash (default: 0)
+   */
+  constructor(seed = 0) {
+    this._seed = seed >>> 0;
+  }
+  /**
+   * The name identifier for this hash provider.
+   */
+  get name() {
+    return "murmer";
+  }
+  /**
+   * Gets the current seed value used for hashing.
+   */
+  get seed() {
+    return this._seed;
+  }
+  /**
+   * Computes the Murmer 32-bit hash of the provided data synchronously.
+   *
+   * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+   * @returns An 8-character lowercase hexadecimal string
+   *
+   * @example
+   * ```typescript
+   * const murmer = new Murmer();
+   * const data = new TextEncoder().encode('hello');
+   * const hash = murmer.toHashSync(data);
+   * console.log(hash); // "248bfa47"
+   * ```
+   */
+  toHashSync(data) {
+    let bytes;
+    if (data instanceof Uint8Array) {
+      bytes = data;
+    } else if (data instanceof ArrayBuffer) {
+      bytes = new Uint8Array(data);
+    } else if (data instanceof DataView) {
+      bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    } else {
+      const view = data;
+      bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    }
+    const c1 = 3432918353;
+    const c2 = 461845907;
+    const length = bytes.length;
+    const nblocks = Math.floor(length / 4);
+    let h1 = this._seed;
+    for (let i = 0; i < nblocks; i++) {
+      const index = i * 4;
+      let k12 = bytes[index] & 255 | (bytes[index + 1] & 255) << 8 | (bytes[index + 2] & 255) << 16 | (bytes[index + 3] & 255) << 24;
+      k12 = this._imul(k12, c1);
+      k12 = this._rotl32(k12, 15);
+      k12 = this._imul(k12, c2);
+      h1 ^= k12;
+      h1 = this._rotl32(h1, 13);
+      h1 = this._imul(h1, 5) + 3864292196;
+    }
+    const tail = nblocks * 4;
+    let k1 = 0;
+    switch (length & 3) {
+      case 3:
+        k1 ^= (bytes[tail + 2] & 255) << 16;
+      // fallthrough
+      case 2:
+        k1 ^= (bytes[tail + 1] & 255) << 8;
+      // fallthrough
+      case 1:
+        k1 ^= bytes[tail] & 255;
+        k1 = this._imul(k1, c1);
+        k1 = this._rotl32(k1, 15);
+        k1 = this._imul(k1, c2);
+        h1 ^= k1;
+    }
+    h1 ^= length;
+    h1 ^= h1 >>> 16;
+    h1 = this._imul(h1, 2246822507);
+    h1 ^= h1 >>> 13;
+    h1 = this._imul(h1, 3266489909);
+    h1 ^= h1 >>> 16;
+    h1 = h1 >>> 0;
+    const hashHex = h1.toString(16).padStart(8, "0");
+    return hashHex;
+  }
+  /**
+   * Computes the Murmer 32-bit hash of the provided data.
+   *
+   * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+   * @returns A Promise resolving to an 8-character lowercase hexadecimal string
+   *
+   * @example
+   * ```typescript
+   * const murmer = new Murmer();
+   * const data = new TextEncoder().encode('hello');
+   * const hash = await murmer.toHash(data);
+   * console.log(hash); // "248bfa47"
+   * ```
+   */
+  async toHash(data) {
+    return this.toHashSync(data);
+  }
+  /**
+   * 32-bit integer multiplication with proper overflow handling.
+   * @private
+   */
+  _imul(a, b) {
+    if (Math.imul) {
+      return Math.imul(a, b);
+    }
+    const ah = a >>> 16 & 65535;
+    const al = a & 65535;
+    const bh = b >>> 16 & 65535;
+    const bl = b & 65535;
+    return al * bl + (ah * bl + al * bh << 16 >>> 0) | 0;
+  }
+  /**
+   * Left rotate a 32-bit integer.
+   * @private
+   */
+  _rotl32(x, r) {
+    return x << r | x >>> 32 - r;
+  }
+};
+var HashProviders = class {
+  _providers = /* @__PURE__ */ new Map();
+  _getFuzzy = true;
+  /**
+   * Creates a new HashProviders instance.
+   * @param options - Optional configuration including initial providers to load
+   * @example
+   * ```ts
+   * const providers = new HashProviders({
+   *   providers: [{ name: 'custom', toHash: async (data) => '...' }]
+   * });
+   * ```
+   */
+  constructor(options) {
+    if (options?.providers) {
+      this.loadProviders(options?.providers);
+    }
+    if (options?.getFuzzy !== void 0) {
+      this._getFuzzy = Boolean(options?.getFuzzy);
+    }
+  }
+  /**
+   * Loads multiple hash providers at once.
+   * Each provider is added to the internal map using its name as the key.
+   * @param providers - Array of HashProvider objects to load
+   * @example
+   * ```ts
+   * const providers = new HashProviders();
+   * providers.loadProviders([
+   *   { name: 'md5', toHash: async (data) => '...' },
+   *   { name: 'sha1', toHash: async (data) => '...' }
+   * ]);
+   * ```
+   */
+  loadProviders(providers) {
+    for (const provider of providers) {
+      this._providers.set(provider.name, provider);
+    }
+  }
+  /**
+   * Gets the internal Map of all registered hash providers.
+   * @returns Map of provider names to HashProvider objects
+   */
+  get providers() {
+    return this._providers;
   }
-  emit(e, ...t) {
-    let s = false, r = this._eventListeners.get(e);
-    if (r && r.length > 0) for (let i of r) i(...t), s = true;
-    return s;
+  /**
+   * Sets the internal Map of hash providers, replacing all existing providers.
+   * @param providers - Map of provider names to HashProvider objects
+   */
+  set providers(providers) {
+    this._providers = providers;
   }
-  listeners(e) {
-    return this._eventListeners.get(e) ?? [];
+  /**
+   * Gets an array of all provider names.
+   * @returns Array of provider names
+   * @example
+   * ```ts
+   * const providers = new HashProviders();
+   * providers.add({ name: 'sha256', toHash: async (data) => '...' });
+   * providers.add({ name: 'md5', toHash: async (data) => '...' });
+   * console.log(providers.names); // ['sha256', 'md5']
+   * ```
+   */
+  get names() {
+    return Array.from(this._providers.keys());
   }
-  removeAllListeners(e) {
-    return e ? this._eventListeners.delete(e) : this._eventListeners.clear(), this;
+  /**
+   * Gets a hash provider by name with optional fuzzy matching.
+   *
+   * Fuzzy matching (enabled by default) attempts to find providers by:
+   * 1. Exact match (after trimming whitespace)
+   * 2. Case-insensitive match (lowercase)
+   * 3. Dash-removed match (e.g., "SHA-256" matches "sha256")
+   *
+   * @param name - The name of the provider to retrieve
+   * @param options - Optional configuration for the get operation
+   * @param options.fuzzy - Enable/disable fuzzy matching (overrides constructor setting)
+   * @returns The HashProvider if found, undefined otherwise
+   * @example
+   * ```ts
+   * const providers = new HashProviders();
+   * providers.add({ name: 'sha256', toHash: async (data) => '...' });
+   *
+   * // Exact match
+   * const provider = providers.get('sha256');
+   *
+   * // Fuzzy match (case-insensitive)
+   * const provider2 = providers.get('SHA256');
+   *
+   * // Fuzzy match (with dash)
+   * const provider3 = providers.get('SHA-256');
+   *
+   * // Disable fuzzy matching
+   * const provider4 = providers.get('SHA256', { fuzzy: false }); // returns undefined
+   * ```
+   */
+  get(name, options) {
+    const getFuzzy = options?.fuzzy ?? this._getFuzzy;
+    name = name.trim();
+    let result = this._providers.get(name);
+    if (result === void 0 && getFuzzy === true) {
+      name = name.toLowerCase();
+      result = this._providers.get(name);
+    }
+    if (result === void 0 && getFuzzy === true) {
+      name = method_replace_all_default(
+        /* OPTIONAL_OBJECT: false */
+        0,
+        name,
+        "-",
+        ""
+      );
+      result = this._providers.get(name);
+    }
+    return result;
   }
-  setMaxListeners(e) {
-    this._maxListeners = e;
-    for (let t of this._eventListeners.values()) t.length > e && t.splice(e);
+  /**
+   * Adds a single hash provider to the collection.
+   * If a provider with the same name already exists, it will be replaced.
+   * @param provider - The HashProvider object to add
+   * @example
+   * ```ts
+   * const providers = new HashProviders();
+   * providers.add({
+   *   name: 'custom-hash',
+   *   toHash: async (data) => {
+   *     // Custom hashing logic
+   *     return 'hash-result';
+   *   }
+   * });
+   * ```
+   */
+  add(provider) {
+    this._providers.set(provider.name, provider);
   }
-  getAllListeners() {
-    let e = new Array();
-    for (let t of this._eventListeners.values()) e = [...e, ...t];
-    return e;
+  /**
+   * Removes a hash provider from the collection by name.
+   * @param name - The name of the provider to remove
+   * @returns true if the provider was found and removed, false otherwise
+   * @example
+   * ```ts
+   * const providers = new HashProviders();
+   * providers.add({ name: 'custom', toHash: async (data) => '...' });
+   * const removed = providers.remove('custom'); // returns true
+   * const removed2 = providers.remove('nonexistent'); // returns false
+   * ```
+   */
+  remove(name) {
+    return this._providers.delete(name);
   }
 };
-var l = class extends n {
-  _hooks;
-  _throwHookErrors = false;
-  constructor(e) {
-    super({ logger: e == null ? void 0 : e.logger }), this._hooks = /* @__PURE__ */ new Map(), (e == null ? void 0 : e.throwHookErrors) !== void 0 && (this._throwHookErrors = e.throwHookErrors);
+var Hashery = class extends Hookified {
+  _parse = JSON.parse;
+  _stringify = JSON.stringify;
+  _providers = new HashProviders();
+  _defaultAlgorithm = "SHA-256";
+  _defaultAlgorithmSync = "djb2";
+  constructor(options) {
+    super(options);
+    if (options?.parse) {
+      this._parse = options.parse;
+    }
+    if (options?.stringify) {
+      this._stringify = options.stringify;
+    }
+    if (options?.defaultAlgorithm) {
+      this._defaultAlgorithm = options.defaultAlgorithm;
+    }
+    if (options?.defaultAlgorithmSync) {
+      this._defaultAlgorithmSync = options.defaultAlgorithmSync;
+    }
+    this.loadProviders(options?.providers, {
+      includeBase: options?.includeBase ?? true
+    });
   }
-  get hooks() {
-    return this._hooks;
+  /**
+   * Gets the parse function used to deserialize stored values.
+   * @returns The current parse function (defaults to JSON.parse)
+   */
+  get parse() {
+    return this._parse;
   }
-  get throwHookErrors() {
-    return this._throwHookErrors;
+  /**
+   * Sets the parse function used to deserialize stored values.
+   * @param value - The parse function to use for deserialization
+   */
+  set parse(value) {
+    this._parse = value;
   }
-  set throwHookErrors(e) {
-    this._throwHookErrors = e;
+  /**
+   * Gets the stringify function used to serialize values for storage.
+   * @returns The current stringify function (defaults to JSON.stringify)
+   */
+  get stringify() {
+    return this._stringify;
   }
-  get logger() {
-    return this._logger;
+  /**
+   * Sets the stringify function used to serialize values for storage.
+   * @param value - The stringify function to use for serialization
+   */
+  set stringify(value) {
+    this._stringify = value;
+  }
+  /**
+   * Gets the HashProviders instance used to manage hash providers.
+   * @returns The current HashProviders instance
+   */
+  get providers() {
+    return this._providers;
   }
-  set logger(e) {
-    this._logger = e;
+  /**
+   * Sets the HashProviders instance used to manage hash providers.
+   * @param value - The HashProviders instance to use
+   */
+  set providers(value) {
+    this._providers = value;
   }
-  onHook(e, t) {
-    let s = this._hooks.get(e);
-    s ? s.push(t) : this._hooks.set(e, [t]);
+  /**
+   * Gets the names of all registered hash algorithm providers.
+   * @returns An array of provider names (e.g., ['SHA-256', 'SHA-384', 'SHA-512'])
+   */
+  get names() {
+    return this._providers.names;
   }
-  onHooks(e) {
-    for (let t of e) this.onHook(t.event, t.handler);
+  /**
+   * Gets the default hash algorithm used when none is specified.
+   * @returns The current default algorithm (defaults to 'SHA-256')
+   */
+  get defaultAlgorithm() {
+    return this._defaultAlgorithm;
   }
-  prependHook(e, t) {
-    let s = this._hooks.get(e);
-    s ? s.unshift(t) : this._hooks.set(e, [t]);
+  /**
+   * Sets the default hash algorithm to use when none is specified.
+   * @param value - The default algorithm to use (e.g., 'SHA-256', 'SHA-512', 'djb2')
+   * @example
+   * ```ts
+   * const hashery = new Hashery();
+   * hashery.defaultAlgorithm = 'SHA-512';
+   *
+   * // Now toHash will use SHA-512 by default
+   * const hash = await hashery.toHash({ data: 'example' });
+   * ```
+   */
+  set defaultAlgorithm(value) {
+    this._defaultAlgorithm = value;
   }
-  prependOnceHook(e, t) {
-    let s = async (...r) => (this.removeHook(e, s), t(...r));
-    this.prependHook(e, s);
+  /**
+   * Gets the default synchronous hash algorithm used when none is specified.
+   * @returns The current default synchronous algorithm (defaults to 'djb2')
+   */
+  get defaultAlgorithmSync() {
+    return this._defaultAlgorithmSync;
   }
-  onceHook(e, t) {
-    let s = async (...r) => (this.removeHook(e, s), t(...r));
-    this.onHook(e, s);
+  /**
+   * Sets the default synchronous hash algorithm to use when none is specified.
+   * @param value - The default synchronous algorithm to use (e.g., 'djb2', 'fnv1', 'murmer', 'crc32')
+   * @example
+   * ```ts
+   * const hashery = new Hashery();
+   * hashery.defaultAlgorithmSync = 'fnv1';
+   *
+   * // Now synchronous operations will use fnv1 by default
+   * ```
+   */
+  set defaultAlgorithmSync(value) {
+    this._defaultAlgorithmSync = value;
   }
-  removeHook(e, t) {
-    let s = this._hooks.get(e);
-    if (s) {
-      let r = s.indexOf(t);
-      r !== -1 && s.splice(r, 1);
+  /**
+   * Generates a cryptographic hash of the provided data using the Web Crypto API.
+   * The data is first stringified using the configured stringify function, then hashed.
+   *
+   * @param data - The data to hash (will be stringified before hashing)
+   * @param options - Optional configuration object
+   * @param options.algorithm - The hash algorithm to use (defaults to 'SHA-256')
+   * @param options.maxLength - Optional maximum length for the hash output
+   * @returns A Promise that resolves to the hexadecimal string representation of the hash
+   *
+   * @example
+   * ```ts
+   * const hashery = new Hashery();
+   * const hash = await hashery.toHash({ name: 'John', age: 30 });
+   * console.log(hash); // "a1b2c3d4..."
+   *
+   * // Using a different algorithm
+   * const hash512 = await hashery.toHash({ name: 'John' }, { algorithm: 'SHA-512' });
+   * ```
+   */
+  async toHash(data, options) {
+    const context = {
+      data,
+      algorithm: options?.algorithm ?? this._defaultAlgorithm,
+      maxLength: options?.maxLength
+    };
+    await this.beforeHook("toHash", context);
+    const stringified = this._stringify(context.data);
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(stringified);
+    let provider = this._providers.get(context.algorithm);
+    if (!provider) {
+      provider = new WebCrypto({
+        algorithm: this._defaultAlgorithm
+      });
+    }
+    let hash2 = await provider.toHash(dataBuffer);
+    if (options?.maxLength && hash2.length > options?.maxLength) {
+      hash2 = hash2.substring(0, options.maxLength);
     }
+    const result = {
+      hash: hash2,
+      data: context.data,
+      algorithm: context.algorithm
+    };
+    await this.afterHook("toHash", result);
+    return result.hash;
   }
-  removeHooks(e) {
-    for (let t of e) this.removeHook(t.event, t.handler);
+  /**
+   * Generates a deterministic number within a specified range based on the hash of the provided data.
+   * This method uses the toHash function to create a consistent hash, then maps it to a number
+   * between min and max (inclusive).
+   *
+   * @param data - The data to hash (will be stringified before hashing)
+   * @param options - Configuration options (optional, defaults to min: 0, max: 100)
+   * @param options.min - The minimum value of the range (inclusive, defaults to 0)
+   * @param options.max - The maximum value of the range (inclusive, defaults to 100)
+   * @param options.algorithm - The hash algorithm to use (defaults to 'SHA-256')
+   * @param options.hashLength - Number of characters from hash to use for conversion (defaults to 16)
+   * @returns A Promise that resolves to a number between min and max (inclusive)
+   *
+   * @example
+   * ```ts
+   * const hashery = new Hashery();
+   * const num = await hashery.toNumber({ user: 'john' }); // Uses default min: 0, max: 100
+   * console.log(num); // Always returns the same number for the same input, e.g., 42
+   *
+   * // Using custom range
+   * const num2 = await hashery.toNumber({ user: 'john' }, { min: 1, max: 100 });
+   *
+   * // Using a different algorithm
+   * const num512 = await hashery.toNumber({ user: 'john' }, { min: 0, max: 255, algorithm: 'SHA-512' });
+   * ```
+   */
+  async toNumber(data, options = {}) {
+    const {
+      min = 0,
+      max = 100,
+      algorithm = this._defaultAlgorithm,
+      hashLength = 16
+    } = options;
+    if (min > max) {
+      throw new Error("min cannot be greater than max");
+    }
+    const hash2 = await this.toHash(data, {
+      algorithm,
+      maxLength: hashLength
+    });
+    const hashNumber = Number.parseInt(hash2, 16);
+    const range = max - min + 1;
+    const mapped = min + hashNumber % range;
+    return mapped;
   }
-  async hook(e, ...t) {
-    let s = this._hooks.get(e);
-    if (s) for (let r of s) try {
-      await r(...t);
-    } catch (i) {
-      let o = `${e}: ${i.message}`;
-      if (this.emit("error", new Error(o)), this._logger && this._logger.error(o), this._throwHookErrors) throw new Error(o);
+  /**
+   * Generates a hash of the provided data synchronously using a non-cryptographic hash algorithm.
+   * The data is first stringified using the configured stringify function, then hashed.
+   *
+   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmer, crc32).
+   * WebCrypto algorithms (SHA-256, SHA-384, SHA-512) are not supported and will throw an error.
+   *
+   * @param data - The data to hash (will be stringified before hashing)
+   * @param options - Optional configuration object
+   * @param options.algorithm - The hash algorithm to use (defaults to 'djb2')
+   * @param options.maxLength - Optional maximum length for the hash output
+   * @returns The hexadecimal string representation of the hash
+   *
+   * @throws {Error} If the specified algorithm does not support synchronous hashing
+   *
+   * @example
+   * ```ts
+   * const hashery = new Hashery();
+   * const hash = hashery.toHashSync({ name: 'John', age: 30 });
+   * console.log(hash); // "7c9df5ea..." (djb2 hash)
+   *
+   * // Using a different algorithm
+   * const hashFnv1 = hashery.toHashSync({ name: 'John' }, { algorithm: 'fnv1' });
+   * ```
+   */
+  toHashSync(data, options) {
+    const context = {
+      data,
+      algorithm: options?.algorithm ?? this._defaultAlgorithmSync,
+      maxLength: options?.maxLength
+    };
+    this.beforeHook("toHashSync", context);
+    const algorithm = context.algorithm;
+    const stringified = this._stringify(context.data);
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(stringified);
+    const provider = this._providers.get(algorithm);
+    if (!provider) {
+      throw new Error(`Hash provider '${algorithm}' not found`);
+    }
+    if (!provider.toHashSync) {
+      throw new Error(`Hash provider '${algorithm}' does not support synchronous hashing. Use toHash() instead or choose a different algorithm (djb2, fnv1, murmer, crc32).`);
+    }
+    let hash2 = provider.toHashSync(dataBuffer);
+    if (options?.maxLength && hash2.length > options?.maxLength) {
+      hash2 = hash2.substring(0, options.maxLength);
     }
+    const result = {
+      hash: hash2,
+      data: context.data,
+      algorithm: context.algorithm
+    };
+    this.afterHook("toHashSync", result);
+    return result.hash;
   }
-  getHooks(e) {
-    return this._hooks.get(e);
-  }
-  clearHooks() {
-    this._hooks.clear();
+  /**
+   * Generates a deterministic number within a specified range based on the hash of the provided data synchronously.
+   * This method uses the toHashSync function to create a consistent hash, then maps it to a number
+   * between min and max (inclusive).
+   *
+   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmer, crc32).
+   *
+   * @param data - The data to hash (will be stringified before hashing)
+   * @param options - Configuration options (optional, defaults to min: 0, max: 100)
+   * @param options.min - The minimum value of the range (inclusive, defaults to 0)
+   * @param options.max - The maximum value of the range (inclusive, defaults to 100)
+   * @param options.algorithm - The hash algorithm to use (defaults to 'djb2')
+   * @param options.hashLength - Number of characters from hash to use for conversion (defaults to 16)
+   * @returns A number between min and max (inclusive)
+   *
+   * @throws {Error} If the specified algorithm does not support synchronous hashing
+   * @throws {Error} If min is greater than max
+   *
+   * @example
+   * ```ts
+   * const hashery = new Hashery();
+   * const num = hashery.toNumberSync({ user: 'john' }); // Uses default min: 0, max: 100
+   * console.log(num); // Always returns the same number for the same input, e.g., 42
+   *
+   * // Using custom range
+   * const num2 = hashery.toNumberSync({ user: 'john' }, { min: 1, max: 100 });
+   *
+   * // Using a different algorithm
+   * const numFnv1 = hashery.toNumberSync({ user: 'john' }, { min: 0, max: 255, algorithm: 'fnv1' });
+   * ```
+   */
+  toNumberSync(data, options = {}) {
+    const {
+      min = 0,
+      max = 100,
+      algorithm = this._defaultAlgorithmSync,
+      hashLength = 16
+    } = options;
+    if (min > max) {
+      throw new Error("min cannot be greater than max");
+    }
+    const hash2 = this.toHashSync(data, {
+      algorithm,
+      maxLength: hashLength
+    });
+    const hashNumber = Number.parseInt(hash2, 16);
+    const range = max - min + 1;
+    const mapped = min + hashNumber % range;
+    return mapped;
+  }
+  loadProviders(providers, options = {
+    includeBase: true
+  }) {
+    if (providers) {
+      for (const provider of providers) {
+        this._providers.add(provider);
+      }
+    }
+    if (options.includeBase) {
+      this.providers.add(new WebCrypto({
+        algorithm: "SHA-256"
+      }));
+      this.providers.add(new WebCrypto({
+        algorithm: "SHA-384"
+      }));
+      this.providers.add(new WebCrypto({
+        algorithm: "SHA-512"
+      }));
+      this.providers.add(new CRC());
+      this.providers.add(new DJB2());
+      this.providers.add(new FNV1());
+      this.providers.add(new Murmer());
+    }
   }
 };
 
-// node_modules/cacheable/dist/index.js
-import * as crypto from "crypto";
-var structuredClone = globalThis.structuredClone ?? ((value) => JSON.parse(JSON.stringify(value)));
+// node_modules/@cacheable/utils/dist/index.js
 var shorthandToMilliseconds = (shorthand) => {
   let milliseconds;
   if (shorthand === void 0) {
@@ -1977,7 +3304,10 @@ var shorthandToMilliseconds = (shorthand) => {
   }
   if (typeof shorthand === "number") {
     milliseconds = shorthand;
-  } else if (typeof shorthand === "string") {
+  } else {
+    if (typeof shorthand !== "string") {
+      return void 0;
+    }
     shorthand = shorthand.trim();
     if (Number.isNaN(Number(shorthand))) {
       const match = /^([\d.]+)\s*(ms|s|m|h|hr|d)$/i.exec(shorthand);
@@ -2014,7 +3344,7 @@ var shorthandToMilliseconds = (shorthand) => {
           milliseconds = numericValue * 1e3 * 60 * 60 * 24;
           break;
         }
-        /* c8 ignore next 3 */
+        /* v8 ignore next -- @preserve */
         default: {
           milliseconds = Number(shorthand);
         }
@@ -2022,52 +3352,72 @@ var shorthandToMilliseconds = (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());
+  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 hashToNumber(object2, min = 0, max = 10, 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);
-  const hashHex = hasher.digest("hex");
-  const hashNumber = Number.parseInt(hashHex, 16);
-  const range = max - min + 1;
-  return min + hashNumber % range;
+var HashAlgorithm = /* @__PURE__ */ ((HashAlgorithm2) => {
+  HashAlgorithm2["SHA256"] = "SHA-256";
+  HashAlgorithm2["SHA384"] = "SHA-384";
+  HashAlgorithm2["SHA512"] = "SHA-512";
+  HashAlgorithm2["DJB2"] = "djb2";
+  HashAlgorithm2["FNV1"] = "fnv1";
+  HashAlgorithm2["MURMER"] = "murmer";
+  HashAlgorithm2["CRC32"] = "crc32";
+  return HashAlgorithm2;
+})(HashAlgorithm || {});
+function hashSync(object2, options = {
+  algorithm: "djb2",
+  serialize: JSON.stringify
+}) {
+  const algorithm = options?.algorithm ?? "djb2";
+  const serialize = options?.serialize ?? JSON.stringify;
+  const objectString = serialize(object2);
+  const hashery = new Hashery();
+  return hashery.toHashSync(objectString, { algorithm });
 }
-function djb2Hash(string_, min = 0, max = 10) {
-  let hash2 = 5381;
-  for (let i = 0; i < string_.length; i++) {
-    hash2 = hash2 * 33 ^ string_.charCodeAt(i);
+function hashToNumberSync(object2, options = {
+  min: 0,
+  max: 10,
+  algorithm: "djb2",
+  serialize: JSON.stringify
+}) {
+  const min = options?.min ?? 0;
+  const max = options?.max ?? 10;
+  const algorithm = options?.algorithm ?? "djb2";
+  const serialize = options?.serialize ?? JSON.stringify;
+  const hashLength = options?.hashLength ?? 16;
+  if (min >= max) {
+    throw new Error(
+      `Invalid range: min (${min}) must be less than max (${max})`
+    );
   }
-  const range = max - min + 1;
-  return min + Math.abs(hash2) % range;
+  const objectString = serialize(object2);
+  const hashery = new Hashery();
+  return hashery.toNumberSync(objectString, {
+    algorithm,
+    min,
+    max,
+    hashLength
+  });
 }
 function wrapSync(function_, options) {
-  const { ttl, keyPrefix, cache } = options;
-  return function(...arguments_) {
-    const cacheKey = createWrapKey(function_, arguments_, keyPrefix);
+  const { ttl, keyPrefix, cache, serialize } = options;
+  return (...arguments_) => {
+    let cacheKey = createWrapKey(function_, arguments_, {
+      keyPrefix,
+      serialize
+    });
+    if (options.createKey) {
+      cacheKey = options.createKey(function_, arguments_, options);
+    }
     let value = cache.get(cacheKey);
     if (value === void 0) {
       try {
@@ -2083,14 +3433,17 @@ function wrapSync(function_, options) {
     return value;
   };
 }
-function createWrapKey(function_, arguments_, keyPrefix) {
+function createWrapKey(function_, arguments_, options) {
+  const { keyPrefix, serialize } = options || {};
   if (!keyPrefix) {
-    return `${function_.name}::${hash(arguments_)}`;
+    return `${function_.name}::${hashSync(arguments_, { serialize })}`;
   }
-  return `${keyPrefix}::${function_.name}::${hash(arguments_)}`;
+  return `${keyPrefix}::${function_.name}::${hashSync(arguments_, { serialize })}`;
 }
+
+// node_modules/@cacheable/memory/dist/index.js
+var structuredClone = globalThis.structuredClone ?? ((value) => JSON.parse(JSON.stringify(value)));
 var ListNode = class {
-  // eslint-disable-next-line @typescript-eslint/parameter-properties
   value;
   prev = void 0;
   next = void 0;
@@ -2135,7 +3488,7 @@ var DoublyLinkedList = class {
       this.head.prev = node;
     }
     this.head = node;
-    this.tail || (this.tail = node);
+    this.tail ?? (this.tail = node);
   }
   // Get the oldest node (tail)
   getOldest() {
@@ -2162,12 +3515,15 @@ var DoublyLinkedList = class {
 };
 var defaultStoreHashSize = 16;
 var maximumMapSize = 16777216;
-var CacheableMemory = class extends l {
+var CacheableMemory = class extends Hookified {
   _lru = new DoublyLinkedList();
   _storeHashSize = defaultStoreHashSize;
-  _storeHashAlgorithm = "djb2Hash";
+  _storeHashAlgorithm = HashAlgorithm.DJB2;
   // Default is djb2Hash
-  _store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
+  _store = Array.from(
+    { length: this._storeHashSize },
+    () => /* @__PURE__ */ new Map()
+  );
   _ttl;
   // Turned off by default
   _useClone = true;
@@ -2184,29 +3540,37 @@ var CacheableMemory = class extends l {
    */
   constructor(options) {
     super();
-    if (options == null ? void 0 : options.ttl) {
+    if (options?.ttl) {
       this.setTtl(options.ttl);
     }
-    if ((options == null ? void 0 : options.useClone) !== void 0) {
+    if (options?.useClone !== void 0) {
       this._useClone = options.useClone;
     }
-    if ((options == null ? void 0 : options.storeHashSize) && options.storeHashSize > 0) {
+    if (options?.storeHashSize && options.storeHashSize > 0) {
       this._storeHashSize = options.storeHashSize;
     }
-    if (options == null ? void 0 : options.lruSize) {
+    if (options?.lruSize) {
       if (options.lruSize > maximumMapSize) {
-        this.emit("error", new Error(`LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`));
+        this.emit(
+          "error",
+          new Error(
+            `LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`
+          )
+        );
       } else {
         this._lruSize = options.lruSize;
       }
     }
-    if (options == null ? void 0 : options.checkInterval) {
+    if (options?.checkInterval) {
       this._checkInterval = options.checkInterval;
     }
-    if (options == null ? void 0 : options.storeHashAlgorithm) {
+    if (options?.storeHashAlgorithm) {
       this._storeHashAlgorithm = options.storeHashAlgorithm;
     }
-    this._store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
+    this._store = Array.from(
+      { length: this._storeHashSize },
+      () => /* @__PURE__ */ new Map()
+    );
     this.startIntervalCheck();
   }
   /**
@@ -2250,7 +3614,12 @@ var CacheableMemory = class extends l {
    */
   set lruSize(value) {
     if (value > maximumMapSize) {
-      this.emit("error", new Error(`LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`));
+      this.emit(
+        "error",
+        new Error(
+          `LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`
+        )
+      );
       return;
     }
     this._lruSize = value;
@@ -2301,18 +3670,21 @@ var CacheableMemory = class extends l {
       return;
     }
     this._storeHashSize = value;
-    this._store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
+    this._store = Array.from(
+      { length: this._storeHashSize },
+      () => /* @__PURE__ */ new Map()
+    );
   }
   /**
    * Gets the store hash algorithm
-   * @returns {StoreHashAlgorithm | StoreHashAlgorithmFunction} - The store hash algorithm
+   * @returns {HashAlgorithm | StoreHashAlgorithmFunction} - The store hash algorithm
    */
   get storeHashAlgorithm() {
     return this._storeHashAlgorithm;
   }
   /**
    * Sets the store hash algorithm. This will recreate the store and all data will be cleared
-   * @param {StoreHashAlgorithm | StoreHashAlgorithmFunction} value - The store hash algorithm
+   * @param {HashAlgorithm | HashAlgorithmFunction} value - The store hash algorithm
    */
   set storeHashAlgorithm(value) {
     this._storeHashAlgorithm = value;
@@ -2322,7 +3694,7 @@ var CacheableMemory = class extends l {
    * @returns {IterableIterator<string>} - The keys
    */
   get keys() {
-    const keys2 = new Array();
+    const keys2 = [];
     for (const store of this._store) {
       for (const key of store.keys()) {
         const item = store.get(key);
@@ -2340,7 +3712,7 @@ var CacheableMemory = class extends l {
    * @returns {IterableIterator<CacheableStoreItem>} - The items
    */
   get items() {
-    const items = new Array();
+    const items = [];
     for (const store of this._store) {
       for (const item of store.values()) {
         if (this.hasExpired(item)) {
@@ -2386,7 +3758,7 @@ var CacheableMemory = class extends l {
    * @returns {T[]} - The values of the keys
    */
   getMany(keys2) {
-    const result = new Array();
+    const result = [];
     for (const key of keys2) {
       result.push(this.get(key));
     }
@@ -2416,7 +3788,7 @@ var CacheableMemory = class extends l {
    * @returns {CacheableStoreItem[]} - The raw values of the keys
    */
   getManyRaw(keys2) {
-    const result = new Array();
+    const result = [];
     for (const key of keys2) {
       result.push(this.getRaw(key));
     }
@@ -2467,10 +3839,7 @@ var CacheableMemory = class extends l {
       }
     }
     const item = { key, value, expires };
-    store.set(
-      key,
-      item
-    );
+    store.set(key, item);
   }
   /**
    * Sets the values of the keys
@@ -2497,7 +3866,7 @@ var CacheableMemory = class extends l {
    * @returns {boolean[]} - If true, the key exists. If false, the key does not exist.
    */
   hasMany(keys2) {
-    const result = new Array();
+    const result = [];
     for (const key of keys2) {
       const item = this.get(key);
       result.push(Boolean(item));
@@ -2523,7 +3892,7 @@ var CacheableMemory = class extends l {
    * @returns {T[]} - The values of the keys
    */
   takeMany(keys2) {
-    const result = new Array();
+    const result = [];
     for (const key of keys2) {
       result.push(this.take(key));
     }
@@ -2553,7 +3922,10 @@ var CacheableMemory = class extends l {
    * @returns {void}
    */
   clear() {
-    this._store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
+    this._store = Array.from(
+      { length: this._storeHashSize },
+      () => /* @__PURE__ */ new Map()
+    );
     this._lru = new DoublyLinkedList();
   }
   /**
@@ -2577,19 +3949,23 @@ var CacheableMemory = class extends l {
     if (this._store.length === 1) {
       return 0;
     }
-    if (this._storeHashAlgorithm === "djb2Hash") {
-      return djb2Hash(key, 0, this._storeHashSize);
-    }
     if (typeof this._storeHashAlgorithm === "function") {
       return this._storeHashAlgorithm(key, this._storeHashSize);
     }
-    return hashToNumber(key, 0, this._storeHashSize, this._storeHashAlgorithm);
+    const storeHashSize = this._storeHashSize - 1;
+    const hash2 = hashToNumberSync(key, {
+      min: 0,
+      max: storeHashSize,
+      algorithm: this._storeHashAlgorithm
+    });
+    return hash2;
   }
   /**
    * Clone the value. This is for internal use
    * @param {any} value - The value to clone
    * @returns {any} - The cloned value
    */
+  // biome-ignore lint/suspicious/noExplicitAny: type format
   clone(value) {
     if (this.isPrimitive(value)) {
       return value;
@@ -2675,14 +4051,17 @@ var CacheableMemory = class extends l {
    * @param {Object} [options] - The options to wrap
    * @returns {Function} - The wrapped function
    */
+  // biome-ignore lint/suspicious/noExplicitAny: type format
   wrap(function_, options) {
     const wrapOptions = {
-      ttl: (options == null ? void 0 : options.ttl) ?? this._ttl,
-      keyPrefix: options == null ? void 0 : options.keyPrefix,
+      ttl: options?.ttl ?? this._ttl,
+      keyPrefix: options?.keyPrefix,
+      createKey: options?.createKey,
       cache: this
     };
     return wrapSync(function_, wrapOptions);
   }
+  // biome-ignore lint/suspicious/noExplicitAny: type format
   isPrimitive(value) {
     const result = false;
     if (value === null || value === void 0) {
@@ -2783,7 +4162,7 @@ var stringify2 = (value, replacer, space) => {
 };
 
 // node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
-var FlatCache = class extends l {
+var FlatCache = class extends Hookified {
   _cache = new CacheableMemory();
   _cacheDir = ".cache";
   _cacheId = "cache1";
@@ -2802,20 +4181,20 @@ var FlatCache = class extends l {
         checkInterval: options.expirationInterval
       });
     }
-    if (options == null ? void 0 : options.cacheDir) {
+    if (options?.cacheDir) {
       this._cacheDir = options.cacheDir;
     }
-    if (options == null ? void 0 : options.cacheId) {
+    if (options?.cacheId) {
       this._cacheId = options.cacheId;
     }
-    if (options == null ? void 0 : options.persistInterval) {
+    if (options?.persistInterval) {
       this._persistInterval = options.persistInterval;
       this.startAutoPersist();
     }
-    if (options == null ? void 0 : options.deserialize) {
+    if (options?.deserialize) {
       this._parse = options.deserialize;
     }
-    if (options == null ? void 0 : options.serialize) {
+    if (options?.serialize) {
       this._stringify = options.serialize;
     }
   }
@@ -2901,7 +4280,9 @@ var FlatCache = class extends l {
    */
   load(cacheId, cacheDir) {
     try {
-      const filePath = path10.resolve(`${cacheDir ?? this._cacheDir}/${cacheId ?? this._cacheId}`);
+      const filePath = path10.resolve(
+        `${cacheDir ?? this._cacheDir}/${cacheId ?? this._cacheId}`
+      );
       this.loadFile(filePath);
       this.emit(
         "load"
@@ -2920,12 +4301,73 @@ var FlatCache = class extends l {
     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 });
+      if (Array.isArray(items)) {
+        for (const item of items) {
+          if (item && typeof item === "object" && "key" in item) {
+            if (item.expires) {
+              this._cache.set(item.key, item.value, { expire: item.expires });
+            } else if (item.timestamp) {
+              this._cache.set(item.key, item.value, { expire: item.timestamp });
+            } else {
+              this._cache.set(item.key, item.value);
+            }
+          }
+        }
+      } else {
+        for (const key of Object.keys(items)) {
+          const item = items[key];
+          if (item && typeof item === "object" && "key" in item) {
+            this._cache.set(item.key, item.value, {
+              expire: item.expires
+            });
+          } else {
+            if (item && typeof item === "object" && item.timestamp) {
+              this._cache.set(key, item, { expire: item.timestamp });
+            } else {
+              this._cache.set(key, item);
+            }
+          }
+        }
       }
       this._changesSinceLastSave = true;
     }
   }
+  loadFileStream(pathToFile, onProgress, onEnd, onError) {
+    if (fs5.existsSync(pathToFile)) {
+      const stats = fs5.statSync(pathToFile);
+      const total = stats.size;
+      let loaded = 0;
+      let streamData = "";
+      const readStream = fs5.createReadStream(pathToFile, { encoding: "utf8" });
+      readStream.on("data", (chunk) => {
+        loaded += chunk.length;
+        streamData += chunk;
+        onProgress(loaded, total);
+      });
+      readStream.on("end", () => {
+        const items = this._parse(streamData);
+        for (const key of Object.keys(items)) {
+          this._cache.set(items[key].key, items[key].value, {
+            expire: items[key].expires
+          });
+        }
+        this._changesSinceLastSave = true;
+        onEnd();
+      });
+      readStream.on("error", (error) => {
+        this.emit("error", error);
+        if (onError) {
+          onError(error);
+        }
+      });
+    } else {
+      const error = new Error(`Cache file ${pathToFile} does not exist`);
+      this.emit("error", error);
+      if (onError) {
+        onError(error);
+      }
+    }
+  }
   /**
    * Returns the entire persisted object
    * @method all
@@ -2940,10 +4382,11 @@ var FlatCache = class extends l {
     return result;
   }
   /**
-   * Returns an array with all the items in the cache { key, value, ttl }
+   * Returns an array with all the items in the cache { key, value, expires }
    * @method items
    * @returns {Array}
    */
+  // biome-ignore lint/suspicious/noExplicitAny: cache items can store any value
   get items() {
     return [...this._cache.items];
   }
@@ -2977,6 +4420,7 @@ var FlatCache = class extends l {
    * @param key {string} the key to set
    * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
    */
+  // biome-ignore lint/suspicious/noExplicitAny: type format
   setKey(key, value, ttl) {
     this.set(key, value, ttl);
   }
@@ -2987,6 +4431,7 @@ var FlatCache = class extends l {
    * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
    * @param [ttl] {number} the time to live in milliseconds
    */
+  // biome-ignore lint/suspicious/noExplicitAny: type format
   set(key, value, ttl) {
     this._cache.set(key, value, ttl);
     this._changesSinceLastSave = true;
@@ -3010,11 +4455,11 @@ var FlatCache = class extends l {
     this.emit("delete", key);
   }
   /**
-  * (Legacy) Return the value of the provided key. This method will be deprecated in the future
-  * @method getKey<T>
-  * @param key {String} the name of the key to retrieve
-  * @returns {*} at T the value from the key
-  */
+   * (Legacy) Return the value of the provided key. This method will be deprecated in the future
+   * @method getKey<T>
+   * @param key {String} the name of the key to retrieve
+   * @returns {*} at T the value from the key
+   */
   getKey(key) {
     return this.get(key);
   }
@@ -3142,25 +4587,24 @@ function createFromFile(filePath, options) {
 }
 
 // node_modules/file-entry-cache/dist/index.js
-function createFromFile2(filePath, useCheckSum, currentWorkingDirectory) {
+function createFromFile2(filePath, options) {
   const fname = path11.basename(filePath);
   const directory = path11.dirname(filePath);
-  return create(fname, directory, useCheckSum, currentWorkingDirectory);
+  return create(fname, directory, options);
 }
-function create(cacheId, cacheDirectory, useCheckSum, currentWorkingDirectory) {
-  const options = {
-    currentWorkingDirectory,
-    useCheckSum,
+function create(cacheId, cacheDirectory, options) {
+  const opts = {
+    ...options,
     cache: {
       cacheId,
       cacheDir: cacheDirectory
     }
   };
-  const fileEntryCache = new FileEntryCache(options);
+  const fileEntryCache = new FileEntryCache(opts);
   if (cacheDirectory) {
     const cachePath = `${cacheDirectory}/${cacheId}`;
     if (fs6.existsSync(cachePath)) {
-      fileEntryCache.cache = createFromFile(cachePath, options.cache);
+      fileEntryCache.cache = createFromFile(cachePath, opts.cache);
     }
   }
   return fileEntryCache;
@@ -3172,28 +4616,40 @@ var FileEntryDefault = class {
 var FileEntryCache = class {
   _cache = new FlatCache({ useClone: false });
   _useCheckSum = false;
-  _useModifiedTime = true;
-  _currentWorkingDirectory;
   _hashAlgorithm = "md5";
+  _cwd = process.cwd();
+  _restrictAccessToCwd = false;
+  _logger;
+  _useAbsolutePathAsKey = false;
+  _useModifiedTime = true;
   /**
    * Create a new FileEntryCache instance
-   * @param options - The options for the FileEntryCache
+   * @param options - The options for the FileEntryCache (all properties are optional with defaults)
    */
   constructor(options) {
-    if (options == null ? void 0 : options.cache) {
+    if (options?.cache) {
       this._cache = new FlatCache(options.cache);
     }
-    if (options == null ? void 0 : options.useModifiedTime) {
+    if (options?.useCheckSum) {
+      this._useCheckSum = options.useCheckSum;
+    }
+    if (options?.hashAlgorithm) {
+      this._hashAlgorithm = options.hashAlgorithm;
+    }
+    if (options?.cwd) {
+      this._cwd = options.cwd;
+    }
+    if (options?.useModifiedTime !== void 0) {
       this._useModifiedTime = options.useModifiedTime;
     }
-    if (options == null ? void 0 : options.useCheckSum) {
-      this._useCheckSum = options.useCheckSum;
+    if (options?.restrictAccessToCwd !== void 0) {
+      this._restrictAccessToCwd = options.restrictAccessToCwd;
     }
-    if (options == null ? void 0 : options.currentWorkingDirectory) {
-      this._currentWorkingDirectory = options.currentWorkingDirectory;
+    if (options?.useAbsolutePathAsKey !== void 0) {
+      this._useAbsolutePathAsKey = options.useAbsolutePathAsKey;
     }
-    if (options == null ? void 0 : options.hashAlgorithm) {
-      this._hashAlgorithm = options.hashAlgorithm;
+    if (options?.logger) {
+      this._logger = options.logger;
     }
   }
   /**
@@ -3210,9 +4666,23 @@ var FileEntryCache = class {
   set cache(cache) {
     this._cache = cache;
   }
+  /**
+   * Get the logger
+   * @returns {ILogger | undefined} The logger instance
+   */
+  get logger() {
+    return this._logger;
+  }
+  /**
+   * Set the logger
+   * @param {ILogger | undefined} logger - The logger to set
+   */
+  set logger(logger) {
+    this._logger = logger;
+  }
   /**
    * Use the hash to check if the file has changed
-   * @returns {boolean} if the hash is used to check if the file has changed
+   * @returns {boolean} if the hash is used to check if the file has changed (default: false)
    */
   get useCheckSum() {
     return this._useCheckSum;
@@ -3225,46 +4695,74 @@ var FileEntryCache = class {
     this._useCheckSum = value;
   }
   /**
-   * Use the modified time to check if the file has changed
-   * @returns {boolean} if the modified time is used to check if the file has changed
+   * Get the hash algorithm
+   * @returns {string} The hash algorithm (default: 'md5')
+   */
+  get hashAlgorithm() {
+    return this._hashAlgorithm;
+  }
+  /**
+   * Set the hash algorithm
+   * @param {string} value - The value to set
+   */
+  set hashAlgorithm(value) {
+    this._hashAlgorithm = value;
+  }
+  /**
+   * Get the current working directory
+   * @returns {string} The current working directory (default: process.cwd())
+   */
+  get cwd() {
+    return this._cwd;
+  }
+  /**
+   * Set the current working directory
+   * @param {string} value - The value to set
+   */
+  set cwd(value) {
+    this._cwd = value;
+  }
+  /**
+   * Get whether to use modified time for change detection
+   * @returns {boolean} Whether modified time (mtime) is used for change detection (default: true)
    */
   get useModifiedTime() {
     return this._useModifiedTime;
   }
   /**
-   * Set the useModifiedTime value
+   * Set whether to use modified time for change detection
    * @param {boolean} value - The value to set
    */
   set useModifiedTime(value) {
     this._useModifiedTime = value;
   }
   /**
-   * Get the hash algorithm
-   * @returns {string} The hash algorithm
+   * Get whether to restrict paths to cwd boundaries
+   * @returns {boolean} Whether strict path checking is enabled (default: true)
    */
-  get hashAlgorithm() {
-    return this._hashAlgorithm;
+  get restrictAccessToCwd() {
+    return this._restrictAccessToCwd;
   }
   /**
-   * Set the hash algorithm
-   * @param {string} value - The value to set
+   * Set whether to restrict paths to cwd boundaries
+   * @param {boolean} value - The value to set
    */
-  set hashAlgorithm(value) {
-    this._hashAlgorithm = value;
+  set restrictAccessToCwd(value) {
+    this._restrictAccessToCwd = value;
   }
   /**
-   * Get the current working directory
-   * @returns {string | undefined} The current working directory
+   * Get whether to use absolute path as cache key
+   * @returns {boolean} Whether cache keys use absolute paths (default: false)
    */
-  get currentWorkingDirectory() {
-    return this._currentWorkingDirectory;
+  get useAbsolutePathAsKey() {
+    return this._useAbsolutePathAsKey;
   }
   /**
-   * Set the current working directory
-   * @param {string | undefined} value - The value to set
+   * Set whether to use absolute path as cache key
+   * @param {boolean} value - The value to set
    */
-  set currentWorkingDirectory(value) {
-    this._currentWorkingDirectory = value;
+  set useAbsolutePathAsKey(value) {
+    this._useAbsolutePathAsKey = value;
   }
   /**
    * Given a buffer, calculate md5 hash of its content.
@@ -3272,7 +4770,6 @@ var FileEntryCache = class {
    * @param  {Buffer} buffer   buffer to calculate hash on
    * @return {String}          content hash digest
    */
-  // eslint-disable-next-line @typescript-eslint/no-restricted-types
   getHash(buffer) {
     return crypto2.createHash(this._hashAlgorithm).update(buffer).digest("hex");
   }
@@ -3282,17 +4779,10 @@ var FileEntryCache = class {
    * @param {String} filePath
    * @return {String}
    */
-  createFileKey(filePath, options) {
+  createFileKey(filePath) {
     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);
-        }
-      }
+    if (this._useAbsolutePathAsKey && this.isRelativePath(filePath)) {
+      result = this.getAbsolutePathWithCwd(filePath, this._cwd);
     }
     return result;
   }
@@ -3306,17 +4796,17 @@ var FileEntryCache = class {
     return !path11.isAbsolute(filePath);
   }
   /**
-  * Delete the cache file from the disk
-  * @method deleteCacheFile
-  * @return {boolean}       true if the file was deleted, false otherwise
-  */
+   * Delete the cache file from the disk
+   * @method deleteCacheFile
+   * @return {boolean}       true if the file was deleted, false otherwise
+   */
   deleteCacheFile() {
     return this._cache.removeCacheFile();
   }
   /**
-  * Remove the cache from the file and clear the memory cache
-  * @method destroy
-  */
+   * Remove the cache from the file and clear the memory cache
+   * @method destroy
+   */
   destroy() {
     this._cache.destroy();
   }
@@ -3325,12 +4815,8 @@ var FileEntryCache = class {
    * @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 });
+  removeEntry(filePath) {
+    const key = this.createFileKey(filePath);
     this._cache.removeKey(key);
   }
   /**
@@ -3368,34 +4854,54 @@ var FileEntryCache = class {
    * @param options - The options for getting the file descriptor
    * @returns The file descriptor
    */
-  // eslint-disable-next-line complexity
   getFileDescriptor(filePath, options) {
-    var _a, _b, _c;
+    this._logger?.debug({ filePath, options }, "Getting file descriptor");
     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;
-    const useModifiedTimeValue = (options == null ? void 0 : options.useModifiedTime) ?? this._useModifiedTime;
+    this._logger?.trace({ key: result.key }, "Created file key");
+    const metaCache = this._cache.getKey(result.key);
+    if (metaCache) {
+      this._logger?.trace({ metaCache }, "Found cached meta");
+    } else {
+      this._logger?.trace("No cached meta found");
+    }
+    result.meta = metaCache ? { ...metaCache } : {};
+    const absolutePath = this.getAbsolutePath(filePath);
+    this._logger?.trace({ absolutePath }, "Resolved absolute path");
+    const useCheckSumValue = options?.useCheckSum ?? this._useCheckSum;
+    this._logger?.debug(
+      { useCheckSum: useCheckSumValue },
+      "Using checksum setting"
+    );
+    const useModifiedTimeValue = options?.useModifiedTime ?? this.useModifiedTime;
+    this._logger?.debug(
+      { useModifiedTime: useModifiedTimeValue },
+      "Using modified time (mtime) setting"
+    );
     try {
-      fstat = fs6.statSync(filePath);
-      result.meta = {
-        size: fstat.size
-      };
+      fstat = fs6.statSync(absolutePath);
+      result.meta.size = fstat.size;
       result.meta.mtime = fstat.mtime.getTime();
+      this._logger?.trace(
+        { size: result.meta.size, mtime: result.meta.mtime },
+        "Read file stats"
+      );
       if (useCheckSumValue) {
-        const buffer = fs6.readFileSync(filePath);
+        const buffer = fs6.readFileSync(absolutePath);
         result.meta.hash = this.getHash(buffer);
+        this._logger?.trace({ hash: result.meta.hash }, "Calculated file hash");
       }
     } catch (error) {
+      this._logger?.error({ filePath, error }, "Error reading file");
       this.removeEntry(filePath);
       let notFound = false;
       if (error.message.includes("ENOENT")) {
         notFound = true;
+        this._logger?.debug({ filePath }, "File not found");
       }
       return {
         key: result.key,
@@ -3404,25 +4910,39 @@ var FileEntryCache = class {
         meta: {}
       };
     }
-    const metaCache = this._cache.getKey(result.key);
     if (!metaCache) {
       result.changed = true;
       this._cache.setKey(result.key, result.meta);
+      this._logger?.debug({ filePath }, "File not in cache, marked as changed");
       return result;
     }
-    if (result.meta.data === void 0) {
-      result.meta.data = metaCache.data;
-    }
-    if (useModifiedTimeValue && (metaCache == null ? void 0 : metaCache.mtime) !== ((_a = result.meta) == null ? void 0 : _a.mtime)) {
+    if (useModifiedTimeValue && metaCache?.mtime !== result.meta?.mtime) {
       result.changed = true;
+      this._logger?.debug(
+        { filePath, oldMtime: metaCache.mtime, newMtime: result.meta.mtime },
+        "File changed: mtime differs"
+      );
     }
-    if ((metaCache == null ? void 0 : metaCache.size) !== ((_b = result.meta) == null ? void 0 : _b.size)) {
+    if (metaCache?.size !== result.meta?.size) {
       result.changed = true;
+      this._logger?.debug(
+        { filePath, oldSize: metaCache.size, newSize: result.meta.size },
+        "File changed: size differs"
+      );
     }
-    if (useCheckSumValue && (metaCache == null ? void 0 : metaCache.hash) !== ((_c = result.meta) == null ? void 0 : _c.hash)) {
+    if (useCheckSumValue && metaCache?.hash !== result.meta?.hash) {
       result.changed = true;
+      this._logger?.debug(
+        { filePath, oldHash: metaCache.hash, newHash: result.meta.hash },
+        "File changed: hash differs"
+      );
     }
     this._cache.setKey(result.key, result.meta);
+    if (result.changed) {
+      this._logger?.info({ filePath }, "File has changed");
+    } else {
+      this._logger?.debug({ filePath }, "File unchanged");
+    }
     return result;
   }
   /**
@@ -3432,7 +4952,7 @@ var FileEntryCache = class {
    * @returns The file descriptors
    */
   normalizeEntries(files) {
-    const result = new Array();
+    const result = [];
     if (files) {
       for (const file of files) {
         const fileDescriptor = this.getFileDescriptor(file);
@@ -3480,7 +5000,7 @@ var FileEntryCache = class {
    * @returns {string[]} The updated files
    */
   getUpdatedFiles(files) {
-    const result = new Array();
+    const result = [];
     const fileDescriptors = this.normalizeEntries(files);
     for (const fileDescriptor of fileDescriptors) {
       if (fileDescriptor.changed) {
@@ -3490,17 +5010,16 @@ var FileEntryCache = class {
     return result;
   }
   /**
-   * Get the not found files
+   * Get the file descriptors by path prefix
    * @method getFileDescriptorsByPath
-   * @param filePath - the files that you want to get from a path
-   * @returns {FileDescriptor[]} The not found files
+   * @param filePath - the path prefix to match
+   * @returns {FileDescriptor[]} The file descriptors
    */
   getFileDescriptorsByPath(filePath) {
-    const result = new Array();
+    const result = [];
     const keys2 = this._cache.keys();
     for (const key of keys2) {
-      const absolutePath = this.getAbsolutePath(filePath);
-      if (absolutePath.startsWith(filePath)) {
+      if (key.startsWith(filePath)) {
         const fileDescriptor = this.getFileDescriptor(key);
         result.push(fileDescriptor);
       }
@@ -3509,25 +5028,64 @@ var FileEntryCache = class {
   }
   /**
    * Get the Absolute Path. If it is already absolute it will return the path as is.
+   * When restrictAccessToCwd is enabled, ensures the resolved path stays within cwd boundaries.
    * @method getAbsolutePath
    * @param filePath - The file path to get the absolute path for
-   * @param options - The options for getting the absolute path. The current working directory is used if not provided.
    * @returns {string}
+   * @throws {Error} When restrictAccessToCwd is true and path would resolve outside cwd
+   */
+  getAbsolutePath(filePath) {
+    if (this.isRelativePath(filePath)) {
+      const sanitizedPath = filePath.replace(/\0/g, "");
+      const resolved = path11.resolve(this._cwd, sanitizedPath);
+      if (this._restrictAccessToCwd) {
+        const normalizedResolved = path11.normalize(resolved);
+        const normalizedCwd = path11.normalize(this._cwd);
+        const isWithinCwd = normalizedResolved === normalizedCwd || normalizedResolved.startsWith(normalizedCwd + path11.sep);
+        if (!isWithinCwd) {
+          throw new Error(
+            `Path traversal attempt blocked: "${filePath}" resolves outside of working directory "${this._cwd}"`
+          );
+        }
+      }
+      return resolved;
+    }
+    return filePath;
+  }
+  /**
+   * Get the Absolute Path with a custom working directory. If it is already absolute it will return the path as is.
+   * When restrictAccessToCwd is enabled, ensures the resolved path stays within the provided cwd boundaries.
+   * @method getAbsolutePathWithCwd
+   * @param filePath - The file path to get the absolute path for
+   * @param cwd - The custom working directory to resolve relative paths from
+   * @returns {string}
+   * @throws {Error} When restrictAccessToCwd is true and path would resolve outside the provided cwd
    */
-  getAbsolutePath(filePath, options) {
+  getAbsolutePathWithCwd(filePath, cwd3) {
     if (this.isRelativePath(filePath)) {
-      const currentWorkingDirectory = (options == null ? void 0 : options.currentWorkingDirectory) ?? this._currentWorkingDirectory ?? process.cwd();
-      filePath = path11.resolve(currentWorkingDirectory, filePath);
+      const sanitizedPath = filePath.replace(/\0/g, "");
+      const resolved = path11.resolve(cwd3, sanitizedPath);
+      if (this._restrictAccessToCwd) {
+        const normalizedResolved = path11.normalize(resolved);
+        const normalizedCwd = path11.normalize(cwd3);
+        const isWithinCwd = normalizedResolved === normalizedCwd || normalizedResolved.startsWith(normalizedCwd + path11.sep);
+        if (!isWithinCwd) {
+          throw new Error(
+            `Path traversal attempt blocked: "${filePath}" resolves outside of working directory "${cwd3}"`
+          );
+        }
+      }
+      return resolved;
     }
     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
+   * Rename cache keys that start with a given path prefix.
+   * @method renameCacheKeys
+   * @param oldPath - The old path prefix to rename
+   * @param newPath - The new path prefix to rename to
    */
-  renameAbsolutePathKeys(oldPath, newPath) {
+  renameCacheKeys(oldPath, newPath) {
     const keys2 = this._cache.keys();
     for (const key of keys2) {
       if (key.startsWith(oldPath)) {
@@ -3557,46 +5115,46 @@ function getHashOfOptions(options) {
 function getMetadataFromFileDescriptor(fileDescriptor) {
   return fileDescriptor.meta;
 }
-var _useChecksum, _fileEntryCache, _FormatResultsCache_instances, getFileDescriptor_fn;
 var FormatResultsCache = class {
+  #fileEntryCache;
   /**
    * @param {string} cacheFileLocation The path of cache file location. (default: `node_modules/.cache/prettier/.prettier-cache`)
    * @param {string} cacheStrategy
    */
   constructor(cacheFileLocation, cacheStrategy) {
-    __privateAdd(this, _FormatResultsCache_instances);
-    __privateAdd(this, _useChecksum);
-    __privateAdd(this, _fileEntryCache);
     const useChecksum = cacheStrategy === "content";
+    const fileEntryCacheOptions = {
+      useChecksum,
+      useModifiedTime: !useChecksum,
+      restrictAccessToCwd: false
+    };
     try {
-      __privateSet(this, _fileEntryCache, FileEntryDefault.createFromFile(
+      this.#fileEntryCache = FileEntryDefault.createFromFile(
         /* filePath */
         cacheFileLocation,
-        useChecksum
-      ));
+        fileEntryCacheOptions
+      );
     } catch {
       if (fs7.existsSync(cacheFileLocation)) {
         fs7.unlinkSync(cacheFileLocation);
-        __privateSet(this, _fileEntryCache, FileEntryDefault.createFromFile(
+        this.#fileEntryCache = FileEntryDefault.createFromFile(
           /* filePath */
           cacheFileLocation,
-          useChecksum
-        ));
+          fileEntryCacheOptions
+        );
       }
     }
-    __privateSet(this, _useChecksum, useChecksum);
   }
   /**
    * @param {string} filePath
    * @param {any} options
    */
   existsAvailableFormatResultsCache(filePath, options) {
-    var _a;
-    const fileDescriptor = __privateMethod(this, _FormatResultsCache_instances, getFileDescriptor_fn).call(this, filePath);
+    const fileDescriptor = this.#getFileDescriptor(filePath);
     if (fileDescriptor.notFound || fileDescriptor.changed) {
       return false;
     }
-    const hashOfOptions = (_a = getMetadataFromFileDescriptor(fileDescriptor).data) == null ? void 0 : _a.hashOfOptions;
+    const hashOfOptions = getMetadataFromFileDescriptor(fileDescriptor).data?.hashOfOptions;
     return hashOfOptions && hashOfOptions === getHashOfOptions(options);
   }
   /**
@@ -3604,7 +5162,7 @@ var FormatResultsCache = class {
    * @param {any} options
    */
   setFormatResultsCache(filePath, options) {
-    const fileDescriptor = __privateMethod(this, _FormatResultsCache_instances, getFileDescriptor_fn).call(this, filePath);
+    const fileDescriptor = this.#getFileDescriptor(filePath);
     if (!fileDescriptor.notFound) {
       const meta = getMetadataFromFileDescriptor(fileDescriptor);
       meta.data = { ...meta.data, hashOfOptions: getHashOfOptions(options) };
@@ -3614,19 +5172,14 @@ var FormatResultsCache = class {
    * @param {string} filePath
    */
   removeFormatResultsCache(filePath) {
-    __privateGet(this, _fileEntryCache).removeEntry(filePath);
+    this.#fileEntryCache.removeEntry(filePath);
   }
   reconcile() {
-    __privateGet(this, _fileEntryCache).reconcile();
+    this.#fileEntryCache.reconcile();
+  }
+  #getFileDescriptor(filePath) {
+    return this.#fileEntryCache.getFileDescriptor(filePath);
   }
-};
-_useChecksum = new WeakMap();
-_fileEntryCache = new WeakMap();
-_FormatResultsCache_instances = new WeakSet();
-getFileDescriptor_fn = function(filePath) {
-  return __privateGet(this, _fileEntryCache).getFileDescriptor(filePath, {
-    useModifiedTime: !__privateGet(this, _useChecksum)
-  });
 };
 var format_results_cache_default = FormatResultsCache;
 
@@ -3642,10 +5195,9 @@ import readline from "readline";
 // node_modules/ansi-regex/index.js
 function ansiRegex({ onlyFirst = false } = {}) {
   const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
-  const pattern = [
-    `[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?${ST})`,
-    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
-  ].join("|");
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
   return new RegExp(pattern, onlyFirst ? void 0 : "g");
 }
 
@@ -3837,23 +5389,23 @@ function wcwidth(ucs, opts) {
 }
 function wcswidth(str, opts) {
   let h;
-  let l2;
+  let l;
   let s = 0;
-  let n2;
+  let n;
   if (typeof str !== "string") return wcwidth(str, opts);
   for (let i = 0; i < str.length; i++) {
     h = str.charCodeAt(i);
     if (h >= 55296 && h <= 56319) {
-      l2 = str.charCodeAt(++i);
-      if (l2 >= 56320 && l2 <= 57343) {
-        h = (h - 55296) * 1024 + (l2 - 56320) + 65536;
+      l = str.charCodeAt(++i);
+      if (l >= 56320 && l <= 57343) {
+        h = (h - 55296) * 1024 + (l - 56320) + 65536;
       } else {
         i--;
       }
     }
-    n2 = wcwidth(h, opts);
-    if (n2 < 0) return -1;
-    s += n2;
+    n = wcwidth(h, opts);
+    if (n < 0) return -1;
+    s += n;
   }
   return s;
 }
@@ -3982,7 +5534,7 @@ function applyConfigPrecedence(context, options) {
 }
 async function getOptionsForFile(context, filepath) {
   const options = await getOptionsOrDie(context, filepath);
-  const hasPlugins = options == null ? void 0 : options.plugins;
+  const hasPlugins = options?.plugins;
   if (hasPlugins) {
     await context.pushContextPlugins(options.plugins);
   }
@@ -4016,7 +5568,7 @@ function handleError(context, filename, error, printedFilename, ignoreUnknown) {
   ignoreUnknown || (ignoreUnknown = context.argv.ignoreUnknown);
   const errorIsUndefinedParseError = error instanceof errors.UndefinedParserError;
   if (errorIsUndefinedParseError && ignoreUnknown) {
-    printedFilename == null ? void 0 : printedFilename.clear();
+    printedFilename?.clear();
     return true;
   }
   if (printedFilename) {
@@ -4027,8 +5579,8 @@ function handleError(context, filename, error, printedFilename, ignoreUnknown) {
     process.exitCode = 2;
     return;
   }
-  const isParseError = Boolean(error == null ? void 0 : error.loc);
-  const isValidationError = /^Invalid \S+ value\./u.test(error == null ? void 0 : error.message);
+  const isParseError = Boolean(error?.loc);
+  const isValidationError = /^Invalid \S+ value\./u.test(error?.message);
   if (isParseError) {
     context.logger.error(`${filename}: ${String(error)}`);
   } else if (isValidationError || error instanceof errors.ConfigError) {
@@ -4110,7 +5662,7 @@ async function format3(context, input, opt) {
     return { formatted: pp, filepath: opt.filepath || "(stdin)\n" };
   }
   const { performanceTestFlag } = context;
-  if (performanceTestFlag == null ? void 0 : performanceTestFlag.debugBenchmark) {
+  if (performanceTestFlag?.debugBenchmark) {
     let Bench;
     try {
       ({ Bench } = await import("tinybench"));
@@ -4130,7 +5682,7 @@ async function format3(context, input, opt) {
     context.logger.debug(
       "'--debug-benchmark' measurements for formatWithCursor: " + JSON.stringify(result, void 0, 2)
     );
-  } else if (performanceTestFlag == null ? void 0 : performanceTestFlag.debugRepeat) {
+  } else if (performanceTestFlag?.debugRepeat) {
     const repeat = performanceTestFlag.debugRepeat;
     context.logger.debug(
       `'${performanceTestFlag.name}' found, running formatWithCursor ${repeat} times.`
@@ -4261,12 +5813,12 @@ ${error2.message}`
       continue;
     }
     if (isFileIgnored) {
-      printedFilename == null ? void 0 : printedFilename.clear();
+      printedFilename?.clear();
       writeOutput(context, { formatted: input }, options);
       continue;
     }
     const start = mockable_default.getTimestamp();
-    const isCacheExists = formatResultsCache == null ? void 0 : formatResultsCache.existsAvailableFormatResultsCache(
+    const isCacheExists = formatResultsCache?.existsAvailableFormatResultsCache(
       filename,
       options
     );
@@ -4294,7 +5846,7 @@ ${error2.message}`
     }
     const isDifferent = output !== input;
     let shouldSetCache = !isDifferent;
-    printedFilename == null ? void 0 : printedFilename.clear();
+    printedFilename?.clear();
     if (performanceTestFlag) {
       context.logger.log(
         `'${performanceTestFlag.name}' option found, skipped print code or write files.`
@@ -4335,9 +5887,9 @@ ${error2.message}`
       writeOutput(context, result, options);
     }
     if (shouldSetCache) {
-      formatResultsCache == null ? void 0 : formatResultsCache.setFormatResultsCache(filename, options);
+      formatResultsCache?.setFormatResultsCache(filename, options);
     } else {
-      formatResultsCache == null ? void 0 : formatResultsCache.removeFormatResultsCache(filename);
+      formatResultsCache?.removeFormatResultsCache(filename);
     }
     if (isDifferent) {
       if (context.argv.check) {
@@ -4348,7 +5900,7 @@ ${error2.message}`
       numberOfUnformattedFilesFound += 1;
     }
   }
-  formatResultsCache == null ? void 0 : formatResultsCache.reconcile();
+  formatResultsCache?.reconcile();
   if (context.argv.check) {
     if (numberOfFilesWithError > 0) {
       const files = numberOfFilesWithError === 1 ? "the above file" : `${numberOfFilesWithError} files`;
@@ -4370,11 +5922,16 @@ ${error2.message}`
 }
 
 // src/cli/logger.js
-var { argv, env: env2 } = process;
+var {
+  argv,
+  env: env2
+} = process;
 var isStderrColorSupported = !(Boolean(env2.NO_COLOR) || argv.includes("--no-color")) && (Boolean(env2.FORCE_COLOR) || argv.includes("--color") || process.platform === "win32" || process.stderr.isTTY && env2.TERM !== "dumb" || Boolean(env2.CI));
 var picocolorsStderr = picocolors.createColors(isStderrColorSupported);
-var emptyLogResult = { clear() {
-} };
+var emptyLogResult = {
+  clear() {
+  }
+};
 function createLogger(logLevel = "log") {
   return {
     logLevel,
@@ -4396,9 +5953,9 @@ function createLogger(logLevel = "log") {
         clearable: false,
         ...options
       };
-      message = string_replace_all_default(
-        /* isOptionalObject */
-        false,
+      message = method_replace_all_default(
+        /* OPTIONAL_OBJECT: false */
+        0,
         message,
         /^/gmu,
         prefix
@@ -4469,9 +6026,9 @@ var OPTION_USAGE_THRESHOLD = 25;
 var CHOICE_USAGE_MARGIN = 3;
 var CHOICE_USAGE_INDENTATION = 2;
 function indent(str, spaces) {
-  return string_replace_all_default(
-    /* isOptionalObject */
-    false,
+  return method_replace_all_default(
+    /* OPTIONAL_OBJECT: false */
+    0,
     str,
     /^/gmu,
     " ".repeat(spaces)
@@ -4481,17 +6038,14 @@ function createDefaultValueDisplay(value) {
   return Array.isArray(value) ? `[${value.map(createDefaultValueDisplay).join(", ")}]` : value;
 }
 function getOptionDefaultValue(context, optionName) {
-  var _a;
-  const option = context.detailedOptions.find(
-    ({ name }) => name === optionName
-  );
-  if ((option == null ? void 0 : option.default) !== void 0) {
+  const option = context.detailedOptions.find(({
+    name
+  }) => name === optionName);
+  if (option?.default !== void 0) {
     return option.default;
   }
   const optionCamelName = camelCase(optionName);
-  return formatOptionsHiddenDefaults[optionCamelName] ?? ((_a = context.supportOptions.find(
-    (option2) => !option2.deprecated && option2.name === optionCamelName
-  )) == null ? void 0 : _a.default);
+  return formatOptionsHiddenDefaults[optionCamelName] ?? context.supportOptions.find((option2) => !option2.deprecated && option2.name === optionCamelName)?.default;
 }
 function createOptionUsageHeader(option) {
   const name = `--${option.name}`;
@@ -4502,9 +6056,9 @@ function createOptionUsageHeader(option) {
 function createOptionUsageRow(header, content, threshold) {
   const separator = header.length >= threshold ? `
 ${" ".repeat(threshold)}` : " ".repeat(threshold - header.length);
-  const description = string_replace_all_default(
-    /* isOptionalObject */
-    false,
+  const description = method_replace_all_default(
+    /* OPTIONAL_OBJECT: false */
+    0,
     content,
     "\n",
     `
@@ -4525,39 +6079,25 @@ function createOptionUsageType(option) {
 function createChoiceUsages(choices, margin, indentation) {
   const activeChoices = choices.filter((choice) => !choice.deprecated);
   const threshold = Math.max(0, ...activeChoices.map((choice) => choice.value.length)) + margin;
-  return activeChoices.map(
-    (choice) => indent(
-      createOptionUsageRow(choice.value, choice.description, threshold),
-      indentation
-    )
-  );
+  return activeChoices.map((choice) => indent(createOptionUsageRow(choice.value, choice.description, threshold), indentation));
 }
 function createOptionUsage(context, option, threshold) {
   const header = createOptionUsageHeader(option);
   const optionDefaultValue = getOptionDefaultValue(context, option.name);
-  return createOptionUsageRow(
-    header,
-    `${option.description}${optionDefaultValue === void 0 ? "" : `
-Defaults to ${createDefaultValueDisplay(optionDefaultValue)}.`}`,
-    threshold
-  );
+  return createOptionUsageRow(header, `${option.description}${optionDefaultValue === void 0 ? "" : `
+Defaults to ${createDefaultValueDisplay(optionDefaultValue)}.`}`, threshold);
 }
 function getOptionsWithOpposites(options) {
-  const optionsWithOpposites = options.map((option) => [
-    option.description ? option : null,
-    option.oppositeDescription ? {
-      ...option,
-      name: `no-${option.name}`,
-      type: "boolean",
-      description: option.oppositeDescription
-    } : null
-  ]);
+  const optionsWithOpposites = options.map((option) => [option.description ? option : null, option.oppositeDescription ? {
+    ...option,
+    name: `no-${option.name}`,
+    type: "boolean",
+    description: option.oppositeDescription
+  } : null]);
   return optionsWithOpposites.flat().filter(Boolean);
 }
 function createUsage(context) {
-  const sortedOptions = context.detailedOptions.sort(
-    (optionA, optionB) => optionA.name.localeCompare(optionB.name)
-  );
+  const sortedOptions = context.detailedOptions.sort((optionA, optionB) => optionA.name.localeCompare(optionB.name));
   const options = getOptionsWithOpposites(sortedOptions).filter(
     // remove unnecessary option (e.g. `semi`, `color`, etc.), which is only used for --help <flag>
     (option) => !(option.type === "boolean" && option.oppositeDescription && !option.name.startsWith("no-"))
@@ -4565,18 +6105,10 @@ function createUsage(context) {
   const groupedOptions = groupBy(options, (option) => option.category);
   const firstCategories = categoryOrder.slice(0, -1);
   const lastCategories = categoryOrder.slice(-1);
-  const restCategories = Object.keys(groupedOptions).filter(
-    (category) => !categoryOrder.includes(category)
-  );
-  const allCategories = [
-    ...firstCategories,
-    ...restCategories,
-    ...lastCategories
-  ];
+  const restCategories = Object.keys(groupedOptions).filter((category) => !categoryOrder.includes(category));
+  const allCategories = [...firstCategories, ...restCategories, ...lastCategories];
   const optionsUsage = allCategories.map((category) => {
-    const categoryOptions = groupedOptions[category].map(
-      (option) => createOptionUsage(context, option, OPTION_USAGE_THRESHOLD)
-    ).join("\n");
+    const categoryOptions = groupedOptions[category].map((option) => createOptionUsage(context, option, OPTION_USAGE_THRESHOLD)).join("\n");
     return `${category} options:
 
 ${indent(categoryOptions, 2)}`;
@@ -4587,19 +6119,13 @@ function createPluginDefaults(pluginDefaults) {
   if (!pluginDefaults || Object.keys(pluginDefaults).length === 0) {
     return "";
   }
-  const defaults = Object.entries(pluginDefaults).sort(
-    ([pluginNameA], [pluginNameB]) => pluginNameA.localeCompare(pluginNameB)
-  ).map(
-    ([plugin, value]) => `* ${plugin}: ${createDefaultValueDisplay(value)}`
-  ).join("\n");
+  const defaults = Object.entries(pluginDefaults).sort(([pluginNameA], [pluginNameB]) => pluginNameA.localeCompare(pluginNameB)).map(([plugin, value]) => `* ${plugin}: ${createDefaultValueDisplay(value)}`).join("\n");
   return `
 Plugin defaults:
 ${defaults}`;
 }
 function createDetailedUsage(context, flag) {
-  const option = getOptionsWithOpposites(context.detailedOptions).find(
-    (option2) => option2.name === flag || option2.alias === flag
-  );
+  const option = getOptionsWithOpposites(context.detailedOptions).find((option2) => option2.name === flag || option2.alias === flag);
   const header = createOptionUsageHeader(option);
   const description = `
 
@@ -4608,11 +6134,7 @@ ${indent(option.description, 2)}`;
 
 Valid options:
 
-${createChoiceUsages(
-    option.choices,
-    CHOICE_USAGE_MARGIN,
-    CHOICE_USAGE_INDENTATION
-  ).join("\n")}`;
+${createChoiceUsages(option.choices, CHOICE_USAGE_MARGIN, CHOICE_USAGE_INDENTATION).join("\n")}`;
   const optionDefaultValue = getOptionDefaultValue(context, option.name);
   const defaults = optionDefaultValue !== void 0 ? `