prettier 3.8.4 → 3.9.0

package/internal/legacy-cli.mjs

@@ -18,7 +18,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -368,6 +372,11 @@ var require_vendors = __commonJS({
         env: "AGOLA_GIT_REF",
         pr: "AGOLA_PULL_REQUEST_ID"
       },
+      {
+        name: "Alpic",
+        constant: "ALPIC",
+        env: "ALPIC_HOST"
+      },
       {
         name: "Appcircle",
         constant: "APPCIRCLE",
@@ -820,7 +829,7 @@ var createMethodShim = (methodName, getImplementation) => (flags, object2, ...ar
 function stringOrArrayAt(index) {
   return this[index < 0 ? this.length + index : index];
 }
-var at = createMethodShim("at", function() {
+var at = /* @__PURE__ */ createMethodShim("at", function() {
   if (Array.isArray(this) || typeof this === "string") {
     return stringOrArrayAt;
   }
@@ -1083,7 +1092,7 @@ var stringReplaceAll = String.prototype.replaceAll ?? function(pattern, replacem
   }
   return this.split(pattern).join(replacement);
 };
-var replaceAll = createMethodShim("replaceAll", function() {
+var replaceAll = /* @__PURE__ */ createMethodShim("replaceAll", function() {
   if (typeof this === "string") {
     return stringReplaceAll;
   }
@@ -1233,34 +1242,97 @@ function camelCase(input, options) {
 import fs from "fs/promises";
 import path from "path";
 
-// node_modules/sdbm/index.js
-var textEncoder = new TextEncoder();
-function sdbmHash(input, options) {
-  if (typeof input === "string") {
-    if (options?.bytes) {
-      input = textEncoder.encode(input);
-    } else {
-      let hash3 = 0n;
-      for (let index = 0; index < input.length; index++) {
-        hash3 = BigInt(input.charCodeAt(index)) + (hash3 << 6n) + (hash3 << 16n) - hash3;
-      }
-      return hash3;
+// node_modules/imurmurhash-esm/index.js
+var cache;
+function MurmurHash3(key, seed) {
+  var m = this;
+  if (!(this instanceof MurmurHash3)) {
+    if (!cache) {
+      cache ?? (cache = new MurmurHash3());
     }
-  } else if (!(input instanceof Uint8Array)) {
-    throw new TypeError("Expected a string or Uint8Array");
+    m = cache;
   }
-  let hash2 = 0n;
-  for (const byte of input) {
-    hash2 = BigInt(byte) + (hash2 << 6n) + (hash2 << 16n) - hash2;
+  m.reset(seed);
+  if (typeof key === "string" && key.length > 0) {
+    m.hash(key);
+  }
+  if (m !== this) {
+    return m;
   }
-  return hash2;
-}
-function sdbm(input, options) {
-  return Number(BigInt.asUintN(32, sdbmHash(input, options)));
 }
-sdbm.bigint = function(input, options) {
-  return BigInt.asUintN(64, sdbmHash(input, options));
+MurmurHash3.prototype.hash = function(key) {
+  var h1, k1, i, top, len;
+  len = key.length;
+  this.len += len;
+  k1 = this.k1;
+  i = 0;
+  switch (this.rem) {
+    case 0:
+      k1 ^= len > i ? key.charCodeAt(i++) & 65535 : 0;
+    case 1:
+      k1 ^= len > i ? (key.charCodeAt(i++) & 65535) << 8 : 0;
+    case 2:
+      k1 ^= len > i ? (key.charCodeAt(i++) & 65535) << 16 : 0;
+    case 3:
+      k1 ^= len > i ? (key.charCodeAt(i) & 255) << 24 : 0;
+      k1 ^= len > i ? (key.charCodeAt(i++) & 65280) >> 8 : 0;
+  }
+  this.rem = len + this.rem & 3;
+  len -= this.rem;
+  if (len > 0) {
+    h1 = this.h1;
+    while (1) {
+      k1 = k1 * 11601 + (k1 & 65535) * 3432906752 & 4294967295;
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = k1 * 13715 + (k1 & 65535) * 461832192 & 4294967295;
+      h1 ^= k1;
+      h1 = h1 << 13 | h1 >>> 19;
+      h1 = h1 * 5 + 3864292196 & 4294967295;
+      if (i >= len) {
+        break;
+      }
+      k1 = key.charCodeAt(i++) & 65535 ^ (key.charCodeAt(i++) & 65535) << 8 ^ (key.charCodeAt(i++) & 65535) << 16;
+      top = key.charCodeAt(i++);
+      k1 ^= (top & 255) << 24 ^ (top & 65280) >> 8;
+    }
+    k1 = 0;
+    switch (this.rem) {
+      case 3:
+        k1 ^= (key.charCodeAt(i + 2) & 65535) << 16;
+      case 2:
+        k1 ^= (key.charCodeAt(i + 1) & 65535) << 8;
+      case 1:
+        k1 ^= key.charCodeAt(i) & 65535;
+    }
+    this.h1 = h1;
+  }
+  this.k1 = k1;
+  return this;
+};
+MurmurHash3.prototype.result = function() {
+  var k1, h1;
+  k1 = this.k1;
+  h1 = this.h1;
+  if (k1 > 0) {
+    k1 = k1 * 11601 + (k1 & 65535) * 3432906752 & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = k1 * 13715 + (k1 & 65535) * 461832192 & 4294967295;
+    h1 ^= k1;
+  }
+  h1 ^= this.len;
+  h1 ^= h1 >>> 16;
+  h1 = h1 * 51819 + (h1 & 65535) * 2246770688 & 4294967295;
+  h1 ^= h1 >>> 13;
+  h1 = h1 * 44597 + (h1 & 65535) * 3266445312 & 4294967295;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+};
+MurmurHash3.prototype.reset = function(seed) {
+  this.h1 = typeof seed === "number" ? seed : 0;
+  this.rem = this.k1 = this.len = 0;
+  return this;
 };
+var imurmurhash_esm_default = MurmurHash3;
 
 // src/cli/utilities.js
 import { __internal as sharedWithCli2 } from "../index.mjs";
@@ -1281,8 +1353,8 @@ function pick(object2, keys2) {
   const entries = keys2.map((key) => [key, object2[key]]);
   return Object.fromEntries(entries);
 }
-function createHash(source) {
-  return String(sdbm(source));
+function createHash(string) {
+  return imurmurhash_esm_default(string).result().toString(36);
 }
 async function statSafe(filePath) {
   try {
@@ -1318,13 +1390,14 @@ var normalizeToPosix = path.sep === "\\" ? (filepath) => method_replace_all_defa
   "/"
 ) : (filepath) => filepath;
 var {
-  omit
+  omit,
+  getOrInsertComputed
 } = sharedWithCli2.utilities;
 
 // src/cli/options/create-minimist-options.js
 function createMinimistOptions(detailedOptions) {
   const booleanNames = [];
-  const stringNames = [];
+  const stringNames = ["_"];
   const defaultValues = {};
   for (const option of detailedOptions) {
     const { name, alias, type } = option;
@@ -1426,7 +1499,7 @@ function parseArgv(rawArguments, detailedOptions, logger, keys2) {
         return [option.forwardToApi || camelCase(key), value];
       })
     ),
-    _: normalized._?.map(String),
+    _: normalized._,
     get __raw() {
       return argv2;
     }
@@ -1503,7 +1576,7 @@ var Context = class {
     const {
       PRETTIER_PERF_REPEAT
     } = process.env;
-    if (PRETTIER_PERF_REPEAT && /^\d+$/u.test(PRETTIER_PERF_REPEAT)) {
+    if (PRETTIER_PERF_REPEAT && /^\d+$/.test(PRETTIER_PERF_REPEAT)) {
       return {
         name: "PRETTIER_PERF_REPEAT (environment variable)",
         debugRepeat: Number(PRETTIER_PERF_REPEAT)
@@ -1765,11 +1838,11 @@ function escapePathForGlob(path13) {
         )
         // Workaround for fast-glob#262 (part 1)
       ),
-      "\\!",
-      "@(!)"
+      "\0",
+      "@(\\\\)"
     ),
-    "\0",
-    "@(\\\\)"
+    '"',
+    '@(\\")'
   );
 }
 var fixWindowsSlashes = normalizeToPosix;
@@ -2135,6 +2208,7 @@ var Eventified = class {
         }
       }
     }
+    this.sendLog(event, arguments_);
     return result;
   }
   /**
@@ -2182,6 +2256,54 @@ var Eventified = class {
     }
     return result;
   }
+  /**
+   * Sends a log message using the configured logger based on the event name
+   * @param {string | symbol} eventName - The event name that determines the log level
+   * @param {unknown} data - The data to log
+   */
+  sendLog(eventName, data) {
+    if (!this._logger) {
+      return;
+    }
+    let message;
+    if (typeof data === "string") {
+      message = data;
+    } else if (Array.isArray(data) && data.length > 0 && data[0] instanceof Error) {
+      message = data[0].message;
+    } else if (data instanceof Error) {
+      message = data.message;
+    } else if (Array.isArray(data) && data.length > 0 && typeof data[0]?.message === "string") {
+      message = data[0].message;
+    } else {
+      message = JSON.stringify(data);
+    }
+    switch (eventName) {
+      case "error": {
+        this._logger.error?.(message, { event: eventName, data });
+        break;
+      }
+      case "warn": {
+        this._logger.warn?.(message, { event: eventName, data });
+        break;
+      }
+      case "trace": {
+        this._logger.trace?.(message, { event: eventName, data });
+        break;
+      }
+      case "debug": {
+        this._logger.debug?.(message, { event: eventName, data });
+        break;
+      }
+      case "fatal": {
+        this._logger.fatal?.(message, { event: eventName, data });
+        break;
+      }
+      default: {
+        this._logger.info?.(message, { event: eventName, data });
+        break;
+      }
+    }
+  }
 };
 var Hookified = class extends Eventified {
   _hooks;
@@ -2314,9 +2436,6 @@ var Hookified = class extends Eventified {
       const message = this._deprecatedHooks.get(event);
       const warningMessage = `Hook "${event}" is deprecated${message ? `: ${message}` : ""}`;
       this.emit("warn", { hook: event, message: warningMessage });
-      if (this.logger?.warn) {
-        this.logger.warn(warningMessage);
-      }
       return this._allowDeprecated;
     }
     return true;
@@ -2328,24 +2447,24 @@ var Hookified = class extends Eventified {
    * @returns {void}
    */
   onHook(event, handler) {
-    this.validateHookName(event);
-    if (!this.checkDeprecatedHook(event)) {
-      return;
-    }
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      eventHandlers.push(handler);
-    } else {
-      this._hooks.set(event, [handler]);
-    }
+    this.onHookEntry({ event, handler });
   }
   /**
-   * Adds a handler function for a specific event that runs before all other handlers
+   * Adds a handler function for a specific event
    * @param {HookEntry} hookEntry
    * @returns {void}
    */
   onHookEntry(hookEntry) {
-    this.onHook(hookEntry.event, hookEntry.handler);
+    this.validateHookName(hookEntry.event);
+    if (!this.checkDeprecatedHook(hookEntry.event)) {
+      return;
+    }
+    const eventHandlers = this._hooks.get(hookEntry.event);
+    if (eventHandlers) {
+      eventHandlers.push(hookEntry.handler);
+    } else {
+      this._hooks.set(hookEntry.event, [hookEntry.handler]);
+    }
   }
   /**
    * Alias for onHook. This is provided for compatibility with other libraries that use the `addHook` method.
@@ -2354,7 +2473,7 @@ var Hookified = class extends Eventified {
    * @returns {void}
    */
   addHook(event, handler) {
-    this.onHook(event, handler);
+    this.onHookEntry({ event, handler });
   }
   /**
    * Adds a handler function for a specific event
@@ -2464,9 +2583,39 @@ var Hookified = class extends Eventified {
         } catch (error) {
           const message = `${event}: ${error.message}`;
           this.emit("error", new Error(message));
-          if (this.logger) {
-            this.logger.error(message);
+          if (this._throwOnHookError) {
+            throw new Error(message);
           }
+        }
+      }
+    }
+  }
+  /**
+   * Calls all synchronous handlers for a specific event.
+   * Async handlers (declared with `async` keyword) are silently skipped.
+   *
+   * Note: The `hook` method is preferred as it executes both sync and async functions.
+   * Use `hookSync` only when you specifically need synchronous execution.
+   * @param {string} event
+   * @param {T[]} arguments_
+   * @returns {void}
+   */
+  hookSync(event, ...arguments_) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return;
+    }
+    const eventHandlers = this._hooks.get(event);
+    if (eventHandlers) {
+      for (const handler of eventHandlers) {
+        if (handler.constructor.name === "AsyncFunction") {
+          continue;
+        }
+        try {
+          handler(...arguments_);
+        } catch (error) {
+          const message = `${event}: ${error.message}`;
+          this.emit("error", new Error(message));
           if (this._throwOnHookError) {
             throw new Error(message);
           }
@@ -2522,6 +2671,103 @@ var Hookified = class extends Eventified {
 };
 
 // node_modules/hashery/dist/node/index.js
+var Cache = class {
+  _enabled = true;
+  _maxSize = 4e3;
+  _store = /* @__PURE__ */ new Map();
+  _keys = [];
+  constructor(options) {
+    if (options?.enabled !== void 0) {
+      this._enabled = options.enabled;
+    }
+    if (options?.maxSize !== void 0) {
+      this._maxSize = options.maxSize;
+    }
+  }
+  /**
+   * Gets whether the cache is enabled.
+   */
+  get enabled() {
+    return this._enabled;
+  }
+  /**
+   * Sets whether the cache is enabled.
+   */
+  set enabled(value) {
+    this._enabled = value;
+  }
+  /**
+   * Gets the maximum number of items the cache can hold.
+   */
+  get maxSize() {
+    return this._maxSize;
+  }
+  /**
+   * Sets the maximum number of items the cache can hold.
+   */
+  set maxSize(value) {
+    this._maxSize = value;
+  }
+  /**
+   * Gets the underlying Map store.
+   */
+  get store() {
+    return this._store;
+  }
+  /**
+   * Gets the current number of items in the cache.
+   */
+  get size() {
+    return this._store.size;
+  }
+  /**
+   * Gets a value from the cache.
+   * @param key - The cache key
+   * @returns The cached value, or undefined if not found
+   */
+  get(key) {
+    return this._store.get(key);
+  }
+  /**
+   * Sets a value in the cache with FIFO eviction.
+   * If the cache is disabled, this method does nothing.
+   * If the cache is at capacity, the oldest entry is removed before adding the new one.
+   * @param key - The cache key
+   * @param value - The value to cache
+   */
+  set(key, value) {
+    if (!this._enabled) {
+      return;
+    }
+    if (this._store.has(key)) {
+      this._store.set(key, value);
+      return;
+    }
+    if (this._store.size >= this._maxSize) {
+      const oldestKey = this._keys.shift();
+      if (oldestKey) {
+        this._store.delete(oldestKey);
+      }
+    }
+    this._keys.push(key);
+    this._store.set(key, value);
+  }
+  /**
+   * Checks if a key exists in the cache.
+   * @param key - The cache key
+   * @returns True if the key exists, false otherwise
+   */
+  has(key) {
+    return this._store.has(key);
+  }
+  /**
+   * Clears all entries from the cache.
+   */
+  clear() {
+    this._store.clear();
+    this._keys = [];
+  }
+};
 var CRC = class {
   get name() {
     return "crc32";
@@ -2676,10 +2922,10 @@ var FNV1 = class {
     return this.toHashSync(data);
   }
 };
-var Murmer = class {
+var Murmur = class {
   _seed;
   /**
-   * Creates a new Murmer instance.
+   * Creates a new Murmur instance.
    *
    * @param seed - Optional seed value for the hash (default: 0)
    */
@@ -2690,7 +2936,7 @@ var Murmer = class {
    * The name identifier for this hash provider.
    */
   get name() {
-    return "murmer";
+    return "murmur";
   }
   /**
    * Gets the current seed value used for hashing.
@@ -2699,16 +2945,16 @@ var Murmer = class {
     return this._seed;
   }
   /**
-   * Computes the Murmer 32-bit hash of the provided data synchronously.
+   * Computes the Murmur 32-bit hash of the provided data synchronously.
    *
    * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
    * @returns An 8-character lowercase hexadecimal string
    *
    * @example
    * ```typescript
-   * const murmer = new Murmer();
+   * const murmur = new Murmur();
    * const data = new TextEncoder().encode('hello');
-   * const hash = murmer.toHashSync(data);
+   * const hash = murmur.toHashSync(data);
    * console.log(hash); // "248bfa47"
    * ```
    */
@@ -2766,16 +3012,16 @@ var Murmer = class {
     return hashHex;
   }
   /**
-   * Computes the Murmer 32-bit hash of the provided data.
+   * Computes the Murmur 32-bit hash of the provided data.
    *
    * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
    * @returns A Promise resolving to an 8-character lowercase hexadecimal string
    *
    * @example
    * ```typescript
-   * const murmer = new Murmer();
+   * const murmur = new Murmur();
    * const data = new TextEncoder().encode('hello');
-   * const hash = await murmer.toHash(data);
+   * const hash = await murmur.toHash(data);
    * console.log(hash); // "248bfa47"
    * ```
    */
@@ -2962,6 +3208,7 @@ var Hashery = class extends Hookified {
   _providers = new HashProviders();
   _defaultAlgorithm = "SHA-256";
   _defaultAlgorithmSync = "djb2";
+  _cache;
   constructor(options) {
     super(options);
     if (options?.parse) {
@@ -2976,6 +3223,7 @@ var Hashery = class extends Hookified {
     if (options?.defaultAlgorithmSync) {
       this._defaultAlgorithmSync = options.defaultAlgorithmSync;
     }
+    this._cache = new Cache(options?.cache);
     this.loadProviders(options?.providers, {
       includeBase: options?.includeBase ?? true
     });
@@ -3060,7 +3308,7 @@ var Hashery = class extends Hookified {
   }
   /**
    * Sets the default synchronous hash algorithm to use when none is specified.
-   * @param value - The default synchronous algorithm to use (e.g., 'djb2', 'fnv1', 'murmer', 'crc32')
+   * @param value - The default synchronous algorithm to use (e.g., 'djb2', 'fnv1', 'murmur', 'crc32')
    * @example
    * ```ts
    * const hashery = new Hashery();
@@ -3072,10 +3320,32 @@ var Hashery = class extends Hookified {
   set defaultAlgorithmSync(value) {
     this._defaultAlgorithmSync = value;
   }
+  /**
+   * Gets the cache instance used to store computed hash values.
+   * @returns The Cache instance
+   * @example
+   * ```ts
+   * const hashery = new Hashery({ cache: { enabled: true } });
+   *
+   * // Access the cache
+   * hashery.cache.enabled; // true
+   * hashery.cache.size; // number of cached items
+   * hashery.cache.clear(); // clear all cached items
+   * ```
+   */
+  get cache() {
+    return this._cache;
+  }
   /**
    * Generates a cryptographic hash of the provided data using the Web Crypto API.
    * The data is first stringified using the configured stringify function, then hashed.
    *
+   * If an invalid algorithm is provided, a 'warn' event is emitted and the method falls back
+   * to the default algorithm. You can listen to these warnings:
+   * ```ts
+   * hashery.on('warn', (message) => console.log(message));
+   * ```
+   *
    * @param data - The data to hash (will be stringified before hashing)
    * @param options - Optional configuration object
    * @param options.algorithm - The hash algorithm to use (defaults to 'SHA-256')
@@ -3100,15 +3370,36 @@ var Hashery = class extends Hookified {
     };
     await this.beforeHook("toHash", context);
     const stringified = this._stringify(context.data);
+    const cacheKey = `${context.algorithm}:${stringified}`;
+    if (this._cache.enabled) {
+      const cached = this._cache.get(cacheKey);
+      if (cached !== void 0) {
+        let cachedHash = cached;
+        if (options?.maxLength && cachedHash.length > options.maxLength) {
+          cachedHash = cachedHash.substring(0, options.maxLength);
+        }
+        const result2 = {
+          hash: cachedHash,
+          data: context.data,
+          algorithm: context.algorithm
+        };
+        await this.afterHook("toHash", result2);
+        return result2.hash;
+      }
+    }
     const encoder = new TextEncoder();
     const dataBuffer = encoder.encode(stringified);
     let provider = this._providers.get(context.algorithm);
     if (!provider) {
+      this.emit("warn", `Invalid algorithm '${context.algorithm}' not found. Falling back to default algorithm '${this._defaultAlgorithm}'.`);
       provider = new WebCrypto({
         algorithm: this._defaultAlgorithm
       });
     }
     let hash2 = await provider.toHash(dataBuffer);
+    if (this._cache.enabled) {
+      this._cache.set(cacheKey, hash2);
+    }
     if (options?.maxLength && hash2.length > options?.maxLength) {
       hash2 = hash2.substring(0, options.maxLength);
     }
@@ -3169,9 +3460,15 @@ var Hashery = class extends Hookified {
    * Generates a hash of the provided data synchronously using a non-cryptographic hash algorithm.
    * The data is first stringified using the configured stringify function, then hashed.
    *
-   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmer, crc32).
+   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmur, crc32).
    * WebCrypto algorithms (SHA-256, SHA-384, SHA-512) are not supported and will throw an error.
    *
+   * If an invalid algorithm is provided, a 'warn' event is emitted and the method falls back
+   * to the default synchronous algorithm. You can listen to these warnings:
+   * ```ts
+   * hashery.on('warn', (message) => console.log(message));
+   * ```
+   *
    * @param data - The data to hash (will be stringified before hashing)
    * @param options - Optional configuration object
    * @param options.algorithm - The hash algorithm to use (defaults to 'djb2')
@@ -3179,6 +3476,7 @@ var Hashery = class extends Hookified {
    * @returns The hexadecimal string representation of the hash
    *
    * @throws {Error} If the specified algorithm does not support synchronous hashing
+   * @throws {Error} If the default algorithm is not found
    *
    * @example
    * ```ts
@@ -3196,19 +3494,43 @@ var Hashery = class extends Hookified {
       algorithm: options?.algorithm ?? this._defaultAlgorithmSync,
       maxLength: options?.maxLength
     };
-    this.beforeHook("toHashSync", context);
+    this.hookSync("before:toHashSync", context);
     const algorithm = context.algorithm;
     const stringified = this._stringify(context.data);
+    const cacheKey = `${algorithm}:${stringified}`;
+    if (this._cache.enabled) {
+      const cached = this._cache.get(cacheKey);
+      if (cached !== void 0) {
+        let cachedHash = cached;
+        if (options?.maxLength && cachedHash.length > options.maxLength) {
+          cachedHash = cachedHash.substring(0, options.maxLength);
+        }
+        const result2 = {
+          hash: cachedHash,
+          data: context.data,
+          algorithm
+        };
+        this.hookSync("after:toHashSync", result2);
+        return result2.hash;
+      }
+    }
     const encoder = new TextEncoder();
     const dataBuffer = encoder.encode(stringified);
-    const provider = this._providers.get(algorithm);
+    let provider = this._providers.get(algorithm);
     if (!provider) {
-      throw new Error(`Hash provider '${algorithm}' not found`);
+      this.emit("warn", `Invalid algorithm '${algorithm}' not found. Falling back to default algorithm '${this._defaultAlgorithmSync}'.`);
+      provider = this._providers.get(this._defaultAlgorithmSync);
+      if (!provider) {
+        throw new Error(`Hash provider '${this._defaultAlgorithmSync}' (default) not found`);
+      }
     }
     if (!provider.toHashSync) {
-      throw new Error(`Hash provider '${algorithm}' does not support synchronous hashing. Use toHash() instead or choose a different algorithm (djb2, fnv1, murmer, crc32).`);
+      throw new Error(`Hash provider '${algorithm}' does not support synchronous hashing. Use toHash() instead or choose a different algorithm (djb2, fnv1, murmur, crc32).`);
     }
     let hash2 = provider.toHashSync(dataBuffer);
+    if (this._cache.enabled) {
+      this._cache.set(cacheKey, hash2);
+    }
     if (options?.maxLength && hash2.length > options?.maxLength) {
       hash2 = hash2.substring(0, options.maxLength);
     }
@@ -3217,7 +3539,7 @@ var Hashery = class extends Hookified {
       data: context.data,
       algorithm: context.algorithm
     };
-    this.afterHook("toHashSync", result);
+    this.hookSync("after:toHashSync", result);
     return result.hash;
   }
   /**
@@ -3225,7 +3547,7 @@ var Hashery = class extends Hookified {
    * This method uses the toHashSync function to create a consistent hash, then maps it to a number
    * between min and max (inclusive).
    *
-   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmer, crc32).
+   * Note: This method only works with synchronous hash providers (djb2, fnv1, murmur, crc32).
    *
    * @param data - The data to hash (will be stringified before hashing)
    * @param options - Configuration options (optional, defaults to min: 0, max: 100)
@@ -3291,7 +3613,7 @@ var Hashery = class extends Hookified {
       this.providers.add(new CRC());
       this.providers.add(new DJB2());
       this.providers.add(new FNV1());
-      this.providers.add(new Murmer());
+      this.providers.add(new Murmur());
     }
   }
 };
@@ -3409,7 +3731,7 @@ function hashToNumberSync(object2, options = {
   });
 }
 function wrapSync(function_, options) {
-  const { ttl, keyPrefix, cache, serialize } = options;
+  const { ttl, keyPrefix, cache: cache2, serialize } = options;
   return (...arguments_) => {
     let cacheKey = createWrapKey(function_, arguments_, {
       keyPrefix,
@@ -3418,15 +3740,15 @@ function wrapSync(function_, options) {
     if (options.createKey) {
       cacheKey = options.createKey(function_, arguments_, options);
     }
-    let value = cache.get(cacheKey);
+    let value = cache2.get(cacheKey);
     if (value === void 0) {
       try {
         value = function_(...arguments_);
-        cache.set(cacheKey, value, ttl);
+        cache2.set(cacheKey, value, ttl);
       } catch (error) {
-        cache.emit("error", error);
+        cache2.emit("error", error);
         if (options.cacheErrors) {
-          cache.set(cacheKey, error, ttl);
+          cache2.set(cacheKey, error, ttl);
         }
       }
     }
@@ -3509,6 +3831,31 @@ var DoublyLinkedList = class {
     this.nodesMap.delete(oldValue);
     return oldValue;
   }
+  // Remove a specific node by value
+  remove(value) {
+    const node = this.nodesMap.get(value);
+    if (!node) {
+      return false;
+    }
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+      if (this.head) {
+        this.head.prev = void 0;
+      }
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+      if (this.tail) {
+        this.tail.next = void 0;
+      }
+    }
+    this.nodesMap.delete(value);
+    return true;
+  }
   get size() {
     return this.nodesMap.size;
   }
@@ -3700,6 +4047,7 @@ var CacheableMemory = class extends Hookified {
         const item = store.get(key);
         if (item && this.hasExpired(item)) {
           store.delete(key);
+          this.lruRemove(key);
           continue;
         }
         keys2.push(key);
@@ -3717,6 +4065,7 @@ var CacheableMemory = class extends Hookified {
       for (const item of store.values()) {
         if (this.hasExpired(item)) {
           store.delete(item.key);
+          this.lruRemove(item.key);
           continue;
         }
         items.push(item);
@@ -3744,6 +4093,7 @@ var CacheableMemory = class extends Hookified {
     }
     if (item.expires && Date.now() > item.expires) {
       store.delete(key);
+      this.lruRemove(key);
       return void 0;
     }
     this.lruMoveToFront(key);
@@ -3777,6 +4127,7 @@ var CacheableMemory = class extends Hookified {
     }
     if (item.expires && item.expires && Date.now() > item.expires) {
       store.delete(key);
+      this.lruRemove(key);
       return void 0;
     }
     this.lruMoveToFront(key);
@@ -3906,6 +4257,7 @@ var CacheableMemory = class extends Hookified {
   delete(key) {
     const store = this.getStore(key);
     store.delete(key);
+    this.lruRemove(key);
   }
   /**
    * Delete the keys
@@ -3994,6 +4346,17 @@ var CacheableMemory = class extends Hookified {
     }
     this._lru.moveToFront(key);
   }
+  /**
+   * Remove a key from the LRU cache. This is for internal use
+   * @param {string} key - The key to remove
+   * @returns {void}
+   */
+  lruRemove(key) {
+    if (this._lruSize === 0) {
+      return;
+    }
+    this._lru.remove(key);
+  }
   /**
    * Resize the LRU cache. This is for internal use.
    * @returns {void}
@@ -4016,6 +4379,7 @@ var CacheableMemory = class extends Hookified {
       for (const item of store.values()) {
         if (item.expires && Date.now() > item.expires) {
           store.delete(item.key);
+          this.lruRemove(item.key);
         }
       }
     }
@@ -4099,26 +4463,21 @@ var object = "object";
 var noop = (_2, value) => value;
 var primitives = (value) => value instanceof Primitive ? Primitive(value) : value;
 var Primitives = (_2, value) => typeof value === primitive ? new Primitive(value) : value;
-var revive = (input, parsed, output, $) => {
-  const lazy = [];
+var resolver = (input, lazy, parsed, $) => (output) => {
   for (let ke = keys(output), { length } = ke, y = 0; y < length; y++) {
     const k = ke[y];
     const value = output[k];
     if (value instanceof Primitive) {
-      const tmp = input[value];
+      const tmp = input[+value];
       if (typeof tmp === object && !parsed.has(tmp)) {
         parsed.add(tmp);
         output[k] = ignore;
-        lazy.push({ k, a: [input, parsed, tmp, $] });
+        lazy.push({ o: output, k, r: tmp });
       } else
         output[k] = $.call(output, k, tmp);
     } else if (output[k] !== ignore)
       output[k] = $.call(output, k, value);
   }
-  for (let { length } = lazy, i = 0; i < length; i++) {
-    const { k, a } = lazy[i];
-    output[k] = $.call(output, k, revive.apply(null, a));
-  }
   return output;
 };
 var set = (known, input, value) => {
@@ -4128,10 +4487,19 @@ var set = (known, input, value) => {
 };
 var parse = (text, reviver) => {
   const input = $parse(text, Primitives).map(primitives);
-  const value = input[0];
   const $ = reviver || noop;
-  const tmp = typeof value === object && value ? revive(input, /* @__PURE__ */ new Set(), value, $) : value;
-  return $.call({ "": tmp }, "", tmp);
+  let value = input[0];
+  if (typeof value === object && value) {
+    const lazy = [];
+    const revive = resolver(input, lazy, /* @__PURE__ */ new Set(), $);
+    value = revive(value);
+    let i = 0;
+    while (i < lazy.length) {
+      const { o, k, r } = lazy[i++];
+      o[k] = $.call(o, k, revive(r));
+    }
+  }
+  return $.call({ "": value }, "", value);
 };
 var stringify2 = (value, replacer, space) => {
   const $ = replacer && typeof replacer === object ? (k, v) => k === "" || -1 < replacer.indexOf(k) ? v : void 0 : replacer || noop;
@@ -4581,9 +4949,9 @@ var FlatCache = class extends Hookified {
   }
 };
 function createFromFile(filePath, options) {
-  const cache = new FlatCache(options);
-  cache.loadFile(filePath);
-  return cache;
+  const cache2 = new FlatCache(options);
+  cache2.loadFile(filePath);
+  return cache2;
 }
 
 // node_modules/file-entry-cache/dist/index.js
@@ -4663,8 +5031,8 @@ var FileEntryCache = class {
    * Set the cache
    * @param {FlatCache} cache - The cache to set
    */
-  set cache(cache) {
-    this._cache = cache;
+  set cache(cache2) {
+    this._cache = cache2;
   }
   /**
    * Get the logger
@@ -5103,14 +5471,11 @@ import { version as prettierVersion } from "../index.mjs";
 var optionsHashCache = /* @__PURE__ */ new WeakMap();
 var nodeVersion = process.version;
 function getHashOfOptions(options) {
-  if (optionsHashCache.has(options)) {
-    return optionsHashCache.get(options);
-  }
-  const hash2 = createHash(
-    `${prettierVersion}_${nodeVersion}_${(0, import_fast_json_stable_stringify2.default)(options)}`
+  return getOrInsertComputed(
+    optionsHashCache,
+    options,
+    (options2) => createHash(`${prettierVersion}_${nodeVersion}_${(0, import_fast_json_stable_stringify2.default)(options2)}`)
   );
-  optionsHashCache.set(options, hash2);
-  return hash2;
 }
 function getMetadataFromFileDescriptor(fileDescriptor) {
   return fileDescriptor.meta;
@@ -5122,10 +5487,10 @@ var FormatResultsCache = class {
    * @param {string} cacheStrategy
    */
   constructor(cacheFileLocation, cacheStrategy) {
-    const useChecksum = cacheStrategy === "content";
+    const useCheckSum = cacheStrategy === "content";
     const fileEntryCacheOptions = {
-      useChecksum,
-      useModifiedTime: !useChecksum,
+      useCheckSum,
+      useModifiedTime: !useCheckSum,
       restrictAccessToCwd: false
     };
     try {
@@ -5207,6 +5572,9 @@ function stripAnsi(string) {
   if (typeof string !== "string") {
     throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
   }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
   return string.replace(regex, "");
 }
 
@@ -5580,7 +5948,7 @@ function handleError(context, filename, error, printedFilename, ignoreUnknown) {
     return;
   }
   const isParseError = Boolean(error?.loc);
-  const isValidationError = /^Invalid \S+ value\./u.test(error?.message);
+  const isValidationError = /^Invalid \S+ value\./.test(error?.message);
   if (isParseError) {
     context.logger.error(`${filename}: ${String(error)}`);
   } else if (isValidationError || error instanceof errors.ConfigError) {
@@ -5643,21 +6011,20 @@ async function format3(context, input, opt) {
       throw new DebugError(
         "prettier(input) !== prettier(prettier(input))\n" + diff(pp, pppp)
       );
-    } else {
-      const stringify5 = (obj) => JSON.stringify(obj, null, 2);
-      const ast = stringify5(
-        (await prettier.__debug.parse(input, opt, { massage: true })).ast
-      );
-      const past = stringify5(
-        (await prettier.__debug.parse(pp, opt, { massage: true })).ast
+    }
+    const stringify5 = (obj) => JSON.stringify(obj, null, 2);
+    const ast = stringify5(
+      (await prettier.__debug.parse(input, opt, { massage: true })).ast
+    );
+    const past = stringify5(
+      (await prettier.__debug.parse(pp, opt, { massage: true })).ast
+    );
+    if (ast !== past) {
+      const MAX_AST_SIZE = 2097152;
+      const astDiff = ast.length > MAX_AST_SIZE || past.length > MAX_AST_SIZE ? "AST diff too large to render" : diff(ast, past);
+      throw new DebugError(
+        "ast(input) !== ast(prettier(input))\n" + astDiff + "\n" + diff(input, pp)
       );
-      if (ast !== past) {
-        const MAX_AST_SIZE = 2097152;
-        const astDiff = ast.length > MAX_AST_SIZE || past.length > MAX_AST_SIZE ? "AST diff too large to render" : diff(ast, past);
-        throw new DebugError(
-          "ast(input) !== ast(prettier(input))\n" + astDiff + "\n" + diff(input, pp)
-        );
-      }
     }
     return { formatted: pp, filepath: opt.filepath || "(stdin)\n" };
   }
@@ -5786,6 +6153,7 @@ async function formatFiles(context) {
     }
     const isFileIgnored = isIgnored(filename);
     if (isFileIgnored && (context.argv.debugCheck || context.argv.write || context.argv.check || context.argv.listDifferent)) {
+      formatResultsCache?.removeFormatResultsCache(filename);
       continue;
     }
     const options = {
@@ -5957,7 +6325,7 @@ function createLogger(logLevel = "log") {
         /* OPTIONAL_OBJECT: false */
         0,
         message,
-        /^/gmu,
+        /^/gm,
         prefix
       ) + (options.newline ? "\n" : "");
       stream.write(message);
@@ -6030,7 +6398,7 @@ function indent(str, spaces) {
     /* OPTIONAL_OBJECT: false */
     0,
     str,
-    /^/gmu,
+    /^/gm,
     " ".repeat(spaces)
   );
 }