prettier 3.6.1 → 3.7.0

package/internal/experimental-cli-worker.mjs

@@ -6,19 +6,27 @@ const __filename = __prettierFileUrlToPath(import.meta.url);
 const __dirname = __prettierDirname(__filename);
 
 // node_modules/atomically/dist/index.js
+import { once } from "events";
+import { createWriteStream } from "fs";
 import path2 from "path";
+import { Readable } from "stream";
 
 // node_modules/stubborn-fs/dist/index.js
 import fs from "fs";
 import { promisify } from "util";
 
-// node_modules/stubborn-fs/dist/attemptify.js
-var attemptifyAsync = (fn, onError) => {
+// node_modules/stubborn-utils/dist/attemptify_async.js
+var attemptifyAsync = (fn, options) => {
+  const { onError } = options;
   return function attemptified(...args) {
     return fn.apply(void 0, args).catch(onError);
   };
 };
-var attemptifySync = (fn, onError) => {
+var attemptify_async_default = attemptifyAsync;
+
+// node_modules/stubborn-utils/dist/attemptify_sync.js
+var attemptifySync = (fn, options) => {
+  const { onError } = options;
   return function attemptified(...args) {
     try {
       return fn.apply(void 0, args);
@@ -27,12 +35,62 @@ var attemptifySync = (fn, onError) => {
     }
   };
 };
+var attemptify_sync_default = attemptifySync;
+
+// node_modules/stubborn-utils/dist/constants.js
+var RETRY_INTERVAL = 250;
+
+// node_modules/stubborn-utils/dist/retryify_async.js
+var retryifyAsync = (fn, options) => {
+  const { isRetriable } = options;
+  return function retryified(options2) {
+    const { timeout } = options2;
+    const interval = options2.interval ?? RETRY_INTERVAL;
+    const timestamp = Date.now() + timeout;
+    return function attempt3(...args) {
+      return fn.apply(void 0, args).catch((error) => {
+        if (!isRetriable(error))
+          throw error;
+        if (Date.now() >= timestamp)
+          throw error;
+        const delay = Math.round(interval * Math.random());
+        if (delay > 0) {
+          const delayPromise = new Promise((resolve3) => setTimeout(resolve3, delay));
+          return delayPromise.then(() => attempt3.apply(void 0, args));
+        } else {
+          return attempt3.apply(void 0, args);
+        }
+      });
+    };
+  };
+};
+var retryify_async_default = retryifyAsync;
+
+// node_modules/stubborn-utils/dist/retryify_sync.js
+var retryifySync = (fn, options) => {
+  const { isRetriable } = options;
+  return function retryified(options2) {
+    const { timeout } = options2;
+    const timestamp = Date.now() + timeout;
+    return function attempt3(...args) {
+      while (true) {
+        try {
+          return fn.apply(void 0, args);
+        } catch (error) {
+          if (!isRetriable(error))
+            throw error;
+          if (Date.now() >= timestamp)
+            throw error;
+          continue;
+        }
+      }
+    };
+  };
+};
+var retryify_sync_default = retryifySync;
 
 // node_modules/stubborn-fs/dist/constants.js
 import process from "process";
-var IS_USER_ROOT = process.getuid ? !process.getuid() : false;
-var LIMIT_FILES_DESCRIPTORS = 1e4;
-var NOOP = () => void 0;
 
 // node_modules/stubborn-fs/dist/handlers.js
 var Handlers = {
@@ -68,158 +126,74 @@ var Handlers = {
 };
 var handlers_default = Handlers;
 
-// node_modules/stubborn-fs/dist/retryify_queue.js
-var RetryfyQueue = class {
-  constructor() {
-    this.interval = 25;
-    this.intervalId = void 0;
-    this.limit = LIMIT_FILES_DESCRIPTORS;
-    this.queueActive = /* @__PURE__ */ new Set();
-    this.queueWaiting = /* @__PURE__ */ new Set();
-    this.init = () => {
-      if (this.intervalId)
-        return;
-      this.intervalId = setInterval(this.tick, this.interval);
-    };
-    this.reset = () => {
-      if (!this.intervalId)
-        return;
-      clearInterval(this.intervalId);
-      delete this.intervalId;
-    };
-    this.add = (fn) => {
-      this.queueWaiting.add(fn);
-      if (this.queueActive.size < this.limit / 2) {
-        this.tick();
-      } else {
-        this.init();
-      }
-    };
-    this.remove = (fn) => {
-      this.queueWaiting.delete(fn);
-      this.queueActive.delete(fn);
-    };
-    this.schedule = () => {
-      return new Promise((resolve3) => {
-        const cleanup = () => this.remove(resolver);
-        const resolver = () => resolve3(cleanup);
-        this.add(resolver);
-      });
-    };
-    this.tick = () => {
-      if (this.queueActive.size >= this.limit)
-        return;
-      if (!this.queueWaiting.size)
-        return this.reset();
-      for (const fn of this.queueWaiting) {
-        if (this.queueActive.size >= this.limit)
-          break;
-        this.queueWaiting.delete(fn);
-        this.queueActive.add(fn);
-        fn();
-      }
-    };
-  }
+// node_modules/stubborn-fs/dist/constants.js
+var ATTEMPTIFY_CHANGE_ERROR_OPTIONS = {
+  onError: handlers_default.onChangeError
 };
-var retryify_queue_default = new RetryfyQueue();
-
-// node_modules/stubborn-fs/dist/retryify.js
-var retryifyAsync = (fn, isRetriableError) => {
-  return function retrified(timestamp) {
-    return function attempt3(...args) {
-      return retryify_queue_default.schedule().then((cleanup) => {
-        const onResolve = (result) => {
-          cleanup();
-          return result;
-        };
-        const onReject = (error) => {
-          cleanup();
-          if (Date.now() >= timestamp)
-            throw error;
-          if (isRetriableError(error)) {
-            const delay = Math.round(100 * Math.random());
-            const delayPromise = new Promise((resolve3) => setTimeout(resolve3, delay));
-            return delayPromise.then(() => attempt3.apply(void 0, args));
-          }
-          throw error;
-        };
-        return fn.apply(void 0, args).then(onResolve, onReject);
-      });
-    };
-  };
+var ATTEMPTIFY_NOOP_OPTIONS = {
+  onError: () => void 0
 };
-var retryifySync = (fn, isRetriableError) => {
-  return function retrified(timestamp) {
-    return function attempt3(...args) {
-      try {
-        return fn.apply(void 0, args);
-      } catch (error) {
-        if (Date.now() > timestamp)
-          throw error;
-        if (isRetriableError(error))
-          return attempt3.apply(void 0, args);
-        throw error;
-      }
-    };
-  };
+var IS_USER_ROOT = process.getuid ? !process.getuid() : false;
+var RETRYIFY_OPTIONS = {
+  isRetriable: handlers_default.isRetriableError
 };
 
 // node_modules/stubborn-fs/dist/index.js
 var FS = {
   attempt: {
     /* ASYNC */
-    chmod: attemptifyAsync(promisify(fs.chmod), handlers_default.onChangeError),
-    chown: attemptifyAsync(promisify(fs.chown), handlers_default.onChangeError),
-    close: attemptifyAsync(promisify(fs.close), NOOP),
-    fsync: attemptifyAsync(promisify(fs.fsync), NOOP),
-    mkdir: attemptifyAsync(promisify(fs.mkdir), NOOP),
-    realpath: attemptifyAsync(promisify(fs.realpath), NOOP),
-    stat: attemptifyAsync(promisify(fs.stat), NOOP),
-    unlink: attemptifyAsync(promisify(fs.unlink), NOOP),
+    chmod: attemptify_async_default(promisify(fs.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chown: attemptify_async_default(promisify(fs.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    close: attemptify_async_default(promisify(fs.close), ATTEMPTIFY_NOOP_OPTIONS),
+    fsync: attemptify_async_default(promisify(fs.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+    mkdir: attemptify_async_default(promisify(fs.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+    realpath: attemptify_async_default(promisify(fs.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+    stat: attemptify_async_default(promisify(fs.stat), ATTEMPTIFY_NOOP_OPTIONS),
+    unlink: attemptify_async_default(promisify(fs.unlink), ATTEMPTIFY_NOOP_OPTIONS),
     /* SYNC */
-    chmodSync: attemptifySync(fs.chmodSync, handlers_default.onChangeError),
-    chownSync: attemptifySync(fs.chownSync, handlers_default.onChangeError),
-    closeSync: attemptifySync(fs.closeSync, NOOP),
-    existsSync: attemptifySync(fs.existsSync, NOOP),
-    fsyncSync: attemptifySync(fs.fsync, NOOP),
-    mkdirSync: attemptifySync(fs.mkdirSync, NOOP),
-    realpathSync: attemptifySync(fs.realpathSync, NOOP),
-    statSync: attemptifySync(fs.statSync, NOOP),
-    unlinkSync: attemptifySync(fs.unlinkSync, NOOP)
+    chmodSync: attemptify_sync_default(fs.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chownSync: attemptify_sync_default(fs.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    closeSync: attemptify_sync_default(fs.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+    existsSync: attemptify_sync_default(fs.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+    fsyncSync: attemptify_sync_default(fs.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+    mkdirSync: attemptify_sync_default(fs.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+    realpathSync: attemptify_sync_default(fs.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+    statSync: attemptify_sync_default(fs.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+    unlinkSync: attemptify_sync_default(fs.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
   },
   retry: {
     /* ASYNC */
-    close: retryifyAsync(promisify(fs.close), handlers_default.isRetriableError),
-    fsync: retryifyAsync(promisify(fs.fsync), handlers_default.isRetriableError),
-    open: retryifyAsync(promisify(fs.open), handlers_default.isRetriableError),
-    readFile: retryifyAsync(promisify(fs.readFile), handlers_default.isRetriableError),
-    rename: retryifyAsync(promisify(fs.rename), handlers_default.isRetriableError),
-    stat: retryifyAsync(promisify(fs.stat), handlers_default.isRetriableError),
-    write: retryifyAsync(promisify(fs.write), handlers_default.isRetriableError),
-    writeFile: retryifyAsync(promisify(fs.writeFile), handlers_default.isRetriableError),
+    close: retryify_async_default(promisify(fs.close), RETRYIFY_OPTIONS),
+    fsync: retryify_async_default(promisify(fs.fsync), RETRYIFY_OPTIONS),
+    open: retryify_async_default(promisify(fs.open), RETRYIFY_OPTIONS),
+    readFile: retryify_async_default(promisify(fs.readFile), RETRYIFY_OPTIONS),
+    rename: retryify_async_default(promisify(fs.rename), RETRYIFY_OPTIONS),
+    stat: retryify_async_default(promisify(fs.stat), RETRYIFY_OPTIONS),
+    write: retryify_async_default(promisify(fs.write), RETRYIFY_OPTIONS),
+    writeFile: retryify_async_default(promisify(fs.writeFile), RETRYIFY_OPTIONS),
     /* SYNC */
-    closeSync: retryifySync(fs.closeSync, handlers_default.isRetriableError),
-    fsyncSync: retryifySync(fs.fsyncSync, handlers_default.isRetriableError),
-    openSync: retryifySync(fs.openSync, handlers_default.isRetriableError),
-    readFileSync: retryifySync(fs.readFileSync, handlers_default.isRetriableError),
-    renameSync: retryifySync(fs.renameSync, handlers_default.isRetriableError),
-    statSync: retryifySync(fs.statSync, handlers_default.isRetriableError),
-    writeSync: retryifySync(fs.writeSync, handlers_default.isRetriableError),
-    writeFileSync: retryifySync(fs.writeFileSync, handlers_default.isRetriableError)
+    closeSync: retryify_sync_default(fs.closeSync, RETRYIFY_OPTIONS),
+    fsyncSync: retryify_sync_default(fs.fsyncSync, RETRYIFY_OPTIONS),
+    openSync: retryify_sync_default(fs.openSync, RETRYIFY_OPTIONS),
+    readFileSync: retryify_sync_default(fs.readFileSync, RETRYIFY_OPTIONS),
+    renameSync: retryify_sync_default(fs.renameSync, RETRYIFY_OPTIONS),
+    statSync: retryify_sync_default(fs.statSync, RETRYIFY_OPTIONS),
+    writeSync: retryify_sync_default(fs.writeSync, RETRYIFY_OPTIONS),
+    writeFileSync: retryify_sync_default(fs.writeFileSync, RETRYIFY_OPTIONS)
   }
 };
 var dist_default = FS;
 
 // node_modules/atomically/dist/constants.js
-import os from "os";
 import process2 from "process";
 var DEFAULT_ENCODING = "utf8";
 var DEFAULT_FILE_MODE = 438;
 var DEFAULT_FOLDER_MODE = 511;
 var DEFAULT_READ_OPTIONS = {};
 var DEFAULT_WRITE_OPTIONS = {};
-var DEFAULT_USER_UID = os.userInfo().uid;
-var DEFAULT_USER_GID = os.userInfo().gid;
+var DEFAULT_USER_UID = process2.geteuid ? process2.geteuid() : -1;
+var DEFAULT_USER_GID = process2.getegid ? process2.getegid() : -1;
+var DEFAULT_INTERVAL_ASYNC = 200;
 var DEFAULT_TIMEOUT_ASYNC = 7500;
 var IS_POSIX = !!process2.getuid;
 var IS_USER_ROOT2 = process2.getuid ? !process2.getuid() : false;
@@ -281,12 +255,12 @@ var IS_LINUX = process3.platform === "linux";
 var IS_WINDOWS = process3.platform === "win32";
 
 // node_modules/when-exit/dist/node/signals.js
-var Signals = ["SIGABRT", "SIGALRM", "SIGHUP", "SIGINT", "SIGTERM"];
+var Signals = ["SIGHUP", "SIGINT", "SIGTERM"];
 if (!IS_WINDOWS) {
-  Signals.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+  Signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
 }
 if (IS_LINUX) {
-  Signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+  Signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
 }
 var signals_default = Signals;
 
@@ -339,6 +313,7 @@ var node_default = whenExit;
 var Temp = {
   /* VARIABLES */
   store: {},
+  // filePath => purge
   /* API */
   create: (filePath) => {
     const randomness = `000000${Math.floor(Math.random() * 16777215).toString(16)}`.slice(-6);
@@ -391,8 +366,9 @@ var temp_default = Temp;
 function readFile(filePath, options = DEFAULT_READ_OPTIONS) {
   if (isString(options))
     return readFile(filePath, { encoding: options });
-  const timeout = Date.now() + ((options.timeout ?? DEFAULT_TIMEOUT_ASYNC) || -1);
-  return dist_default.retry.readFile(timeout)(filePath, options);
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_ASYNC;
+  const retryOptions = { timeout, interval: DEFAULT_INTERVAL_ASYNC };
+  return dist_default.retry.readFile(retryOptions)(filePath, options);
 }
 function writeFile(filePath, data, options, callback) {
   if (isFunction(options))
@@ -405,7 +381,8 @@ function writeFile(filePath, data, options, callback) {
 async function writeFileAsync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
   if (isString(options))
     return writeFileAsync(filePath, data, { encoding: options });
-  const timeout = Date.now() + ((options.timeout ?? DEFAULT_TIMEOUT_ASYNC) || -1);
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_ASYNC;
+  const retryOptions = { timeout, interval: DEFAULT_INTERVAL_ASYNC };
   let schedulerCustomDisposer = null;
   let schedulerDisposer = null;
   let tempDisposer = null;
@@ -440,23 +417,28 @@ async function writeFileAsync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
         recursive: true
       });
     }
-    fd = await dist_default.retry.open(timeout)(tempPath, "w", options.mode || DEFAULT_FILE_MODE);
+    fd = await dist_default.retry.open(retryOptions)(tempPath, "w", options.mode || DEFAULT_FILE_MODE);
     if (options.tmpCreated) {
       options.tmpCreated(tempPath);
     }
     if (isString(data)) {
-      await dist_default.retry.write(timeout)(fd, data, 0, options.encoding || DEFAULT_ENCODING);
+      await dist_default.retry.write(retryOptions)(fd, data, 0, options.encoding || DEFAULT_ENCODING);
+    } else if (data instanceof Readable) {
+      const writeStream = createWriteStream(tempPath, { fd, autoClose: false });
+      const finishPromise = once(writeStream, "finish");
+      data.pipe(writeStream);
+      await finishPromise;
     } else if (!isUndefined(data)) {
-      await dist_default.retry.write(timeout)(fd, data, 0, data.length, 0);
+      await dist_default.retry.write(retryOptions)(fd, data, 0, data.length, 0);
     }
     if (options.fsync !== false) {
       if (options.fsyncWait !== false) {
-        await dist_default.retry.fsync(timeout)(fd);
+        await dist_default.retry.fsync(retryOptions)(fd);
       } else {
         dist_default.attempt.fsync(fd);
       }
     }
-    await dist_default.retry.close(timeout)(fd);
+    await dist_default.retry.close(retryOptions)(fd);
     fd = null;
     if (options.chown && (options.chown.uid !== DEFAULT_USER_UID || options.chown.gid !== DEFAULT_USER_GID)) {
       await dist_default.attempt.chown(tempPath, options.chown.uid, options.chown.gid);
@@ -465,13 +447,13 @@ async function writeFileAsync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       await dist_default.attempt.chmod(tempPath, options.mode);
     }
     try {
-      await dist_default.retry.rename(timeout)(tempPath, filePath);
+      await dist_default.retry.rename(retryOptions)(tempPath, filePath);
     } catch (error) {
       if (!isException(error))
         throw error;
       if (error.code !== "ENAMETOOLONG")
         throw error;
-      await dist_default.retry.rename(timeout)(tempPath, temp_default.truncate(filePath));
+      await dist_default.retry.rename(retryOptions)(tempPath, temp_default.truncate(filePath));
     }
     tempDisposer();
     tempPath = null;
@@ -491,8 +473,32 @@ async function writeFileAsync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
 import process8 from "process";
 import * as prettier from "../index.mjs";
 
+// scripts/build/shims/shared.js
+var OPTIONAL_OBJECT = 1;
+var createMethodShim = (methodName, getImplementation) => (flags, object, ...arguments_) => {
+  if (flags | OPTIONAL_OBJECT && (object === void 0 || object === null)) {
+    return;
+  }
+  const implementation = getImplementation.call(object) ?? object[methodName];
+  return implementation.apply(object, arguments_);
+};
+
+// scripts/build/shims/method-replace-all.js
+var stringReplaceAll = String.prototype.replaceAll ?? function(pattern, replacement) {
+  if (pattern.global) {
+    return this.replace(pattern, replacement);
+  }
+  return this.split(pattern).join(replacement);
+};
+var replaceAll = createMethodShim("replaceAll", function() {
+  if (typeof this === "string") {
+    return stringReplaceAll;
+  }
+});
+var method_replace_all_default = replaceAll;
+
 // node_modules/function-once/dist/index.js
-var once = (fn) => {
+var once2 = (fn) => {
   let called = false;
   let result;
   return () => {
@@ -503,13 +509,13 @@ var once = (fn) => {
     return result;
   };
 };
-var dist_default3 = once;
+var dist_default3 = once2;
 
 // node_modules/import-meta-resolve/lib/resolve.js
 import assert2 from "assert";
 import { statSync, realpathSync } from "fs";
 import process5 from "process";
-import { URL as URL2, fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 import path4 from "path";
 import { builtinModules } from "module";
 
@@ -554,7 +560,7 @@ codes.ERR_INVALID_ARG_TYPE = createError(
    * @param {unknown} actual
    */
   (name, expected, actual) => {
-    assert(typeof name === "string", "'name' must be a string");
+    assert.ok(typeof name === "string", "'name' must be a string");
     if (!Array.isArray(expected)) {
       expected = [expected];
     }
@@ -570,14 +576,14 @@ codes.ERR_INVALID_ARG_TYPE = createError(
     const instances = [];
     const other = [];
     for (const value of expected) {
-      assert(
+      assert.ok(
         typeof value === "string",
         "All expected entries have to be of type string"
       );
       if (kTypes.has(value)) {
         types.push(value.toLowerCase());
       } else if (classRegExp.exec(value) === null) {
-        assert(
+        assert.ok(
           value !== "object",
           'The value "object" should be written as "Object"'
         );
@@ -653,7 +659,7 @@ codes.ERR_INVALID_PACKAGE_TARGET = createError(
   (packagePath, key, target, isImport = false, base = void 0) => {
     const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
     if (key === ".") {
-      assert(isImport === false);
+      assert.ok(isImport === false);
       return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
     }
     return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
@@ -818,19 +824,19 @@ var captureLargerStackTrace = hideStackFrames(
 );
 function getMessage(key, parameters, self) {
   const message = messages.get(key);
-  assert(message !== void 0, "expected `message` to be found");
+  assert.ok(message !== void 0, "expected `message` to be found");
   if (typeof message === "function") {
-    assert(
+    assert.ok(
       message.length <= parameters.length,
       // Default options do not count.
       `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`
     );
     return Reflect.apply(message, self, parameters);
   }
-  const regex2 = /%[dfijoOs]/g;
+  const regex3 = /%[dfijoOs]/g;
   let expectedLength = 0;
-  while (regex2.exec(message) !== null) expectedLength++;
-  assert(
+  while (regex3.exec(message) !== null) expectedLength++;
+  assert.ok(
     expectedLength === parameters.length,
     `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`
   );
@@ -1038,6 +1044,30 @@ function defaultGetFormatWithoutErrors(url2, context) {
   return protocolHandlers[protocol](url2, context, true) || null;
 }
 
+// node_modules/import-meta-resolve/lib/utils.js
+var { ERR_INVALID_ARG_VALUE } = codes;
+var DEFAULT_CONDITIONS = Object.freeze(["node", "import"]);
+var DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS);
+function getDefaultConditions() {
+  return DEFAULT_CONDITIONS;
+}
+function getDefaultConditionsSet() {
+  return DEFAULT_CONDITIONS_SET;
+}
+function getConditionsSet(conditions) {
+  if (conditions !== void 0 && conditions !== getDefaultConditions()) {
+    if (!Array.isArray(conditions)) {
+      throw new ERR_INVALID_ARG_VALUE(
+        "conditions",
+        conditions,
+        "expected an array"
+      );
+    }
+    return new Set(conditions);
+  }
+  return getDefaultConditionsSet();
+}
+
 // node_modules/import-meta-resolve/lib/resolve.js
 var RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
 var {
@@ -1078,7 +1108,7 @@ function emitLegacyIndexDeprecation(url2, packageJsonUrl, base, main) {
   const format3 = defaultGetFormatWithoutErrors(url2, { parentURL: base.href });
   if (format3 !== "module") return;
   const urlPath = fileURLToPath3(url2.href);
-  const packagePath = fileURLToPath3(new URL2(".", packageJsonUrl));
+  const packagePath = fileURLToPath3(new URL(".", packageJsonUrl));
   const basePath = fileURLToPath3(base);
   if (!main) {
     process5.emitWarning(
@@ -1114,7 +1144,7 @@ function fileExists(url2) {
 function legacyMainResolve(packageJsonUrl, packageConfig, base) {
   let guess;
   if (packageConfig.main !== void 0) {
-    guess = new URL2(packageConfig.main, packageJsonUrl);
+    guess = new URL(packageConfig.main, packageJsonUrl);
     if (fileExists(guess)) return guess;
     const tries2 = [
       `./${packageConfig.main}.js`,
@@ -1126,7 +1156,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
     ];
     let i2 = -1;
     while (++i2 < tries2.length) {
-      guess = new URL2(tries2[i2], packageJsonUrl);
+      guess = new URL(tries2[i2], packageJsonUrl);
       if (fileExists(guess)) break;
       guess = void 0;
     }
@@ -1143,7 +1173,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
   const tries = ["./index.js", "./index.json", "./index.node"];
   let i = -1;
   while (++i < tries.length) {
-    guess = new URL2(tries[i], packageJsonUrl);
+    guess = new URL(tries[i], packageJsonUrl);
     if (fileExists(guess)) break;
     guess = void 0;
   }
@@ -1152,7 +1182,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
     return guess;
   }
   throw new ERR_MODULE_NOT_FOUND(
-    fileURLToPath3(new URL2(".", packageJsonUrl)),
+    fileURLToPath3(new URL(".", packageJsonUrl)),
     fileURLToPath3(base)
   );
 }
@@ -1205,13 +1235,13 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
 function importNotDefined(specifier, packageJsonUrl, base) {
   return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
     specifier,
-    packageJsonUrl && fileURLToPath3(new URL2(".", packageJsonUrl)),
+    packageJsonUrl && fileURLToPath3(new URL(".", packageJsonUrl)),
     fileURLToPath3(base)
   );
 }
 function exportsNotFound(subpath, packageJsonUrl, base) {
   return new ERR_PACKAGE_PATH_NOT_EXPORTED(
-    fileURLToPath3(new URL2(".", packageJsonUrl)),
+    fileURLToPath3(new URL(".", packageJsonUrl)),
     subpath,
     base && fileURLToPath3(base)
   );
@@ -1227,7 +1257,7 @@ function throwInvalidSubpath(request, match2, packageJsonUrl, internal, base) {
 function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
   target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
   return new ERR_INVALID_PACKAGE_TARGET(
-    fileURLToPath3(new URL2(".", packageJsonUrl)),
+    fileURLToPath3(new URL(".", packageJsonUrl)),
     subpath,
     target,
     internal,
@@ -1241,7 +1271,7 @@ function resolvePackageTargetString(target, subpath, match2, packageJsonUrl, bas
     if (internal && !target.startsWith("../") && !target.startsWith("/")) {
       let isURL = false;
       try {
-        new URL2(target);
+        new URL(target);
         isURL = true;
       } catch {
       }
@@ -1279,9 +1309,9 @@ function resolvePackageTargetString(target, subpath, match2, packageJsonUrl, bas
       throw invalidPackageTarget(match2, target, packageJsonUrl, internal, base);
     }
   }
-  const resolved = new URL2(target, packageJsonUrl);
+  const resolved = new URL(target, packageJsonUrl);
   const resolvedPath = resolved.pathname;
-  const packagePath = new URL2(".", packageJsonUrl).pathname;
+  const packagePath = new URL(".", packageJsonUrl).pathname;
   if (!resolvedPath.startsWith(packagePath))
     throw invalidPackageTarget(match2, target, packageJsonUrl, internal, base);
   if (subpath === "") return resolved;
@@ -1309,7 +1339,7 @@ function resolvePackageTargetString(target, subpath, match2, packageJsonUrl, bas
     }
   }
   if (pattern) {
-    return new URL2(
+    return new URL(
       RegExpPrototypeSymbolReplace.call(
         patternRegEx,
         resolved.href,
@@ -1317,7 +1347,7 @@ function resolvePackageTargetString(target, subpath, match2, packageJsonUrl, bas
       )
     );
   }
-  return new URL2(subpath, resolved);
+  return new URL(subpath, resolved);
 }
 function isArrayIndex(key) {
   const keyNumber = Number(key);
@@ -1642,7 +1672,7 @@ function parsePackageName(specifier, base) {
 }
 function packageResolve(specifier, base, conditions) {
   if (builtinModules.includes(specifier)) {
-    return new URL2("node:" + specifier);
+    return new URL("node:" + specifier);
   }
   const { packageName, packageSubpath, isScoped } = parsePackageName(
     specifier,
@@ -1661,7 +1691,7 @@ function packageResolve(specifier, base, conditions) {
       );
     }
   }
-  let packageJsonUrl = new URL2(
+  let packageJsonUrl = new URL(
     "./node_modules/" + packageName + "/package.json",
     base
   );
@@ -1671,7 +1701,7 @@ function packageResolve(specifier, base, conditions) {
     const stat = tryStatSync(packageJsonPath.slice(0, -13));
     if (!stat || !stat.isDirectory()) {
       lastPath = packageJsonPath;
-      packageJsonUrl = new URL2(
+      packageJsonUrl = new URL(
         (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json",
         packageJsonUrl
       );
@@ -1691,7 +1721,7 @@ function packageResolve(specifier, base, conditions) {
     if (packageSubpath === ".") {
       return legacyMainResolve(packageJsonUrl, packageConfig2, base);
     }
-    return new URL2(packageSubpath, packageJsonUrl);
+    return new URL(packageSubpath, packageJsonUrl);
   } while (packageJsonPath.length !== lastPath.length);
   throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath3(base), false);
 }
@@ -1710,13 +1740,16 @@ function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
   return isRelativeSpecifier(specifier);
 }
 function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+  if (conditions === void 0) {
+    conditions = getConditionsSet();
+  }
   const protocol = base.protocol;
   const isData = protocol === "data:";
   const isRemote = isData || protocol === "http:" || protocol === "https:";
   let resolved;
   if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
     try {
-      resolved = new URL2(specifier, base);
+      resolved = new URL(specifier, base);
     } catch (error_) {
       const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
       error.cause = error_;
@@ -1726,7 +1759,7 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
     resolved = packageImportsResolve(specifier, base, conditions);
   } else {
     try {
-      resolved = new URL2(specifier);
+      resolved = new URL(specifier);
     } catch (error_) {
       if (isRemote && !builtinModules.includes(specifier)) {
         const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
@@ -1736,7 +1769,7 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
       resolved = packageResolve(specifier, base, conditions);
     }
   }
-  assert2(resolved !== void 0, "expected to be defined");
+  assert2.ok(resolved !== void 0, "expected to be defined");
   if (resolved.protocol !== "file:") {
     return resolved;
   }
@@ -1784,12 +1817,9 @@ function resolveTimeout(timeout, value) {
 var dist_default5 = resolveTimeout;
 
 // node_modules/tiny-colors/dist/constants.js
-var _a;
-var ENV = ((_a = globalThis.process) == null ? void 0 : _a.env) || {};
-var _a2;
-var ARGV = ((_a2 = globalThis.process) == null ? void 0 : _a2.argv) || [];
-var _a3, _b, _c;
-var ENABLED = !("NO_COLOR" in ENV) && ENV.COLOR !== "0" && ENV.TERM !== "dumb" && !ARGV.includes("--no-color") && !ARGV.includes("--no-colors") && (ENV.COLOR === "1" || !((_a3 = globalThis.process) == null ? void 0 : _a3.stdout) || ((_c = (_b = globalThis.process) == null ? void 0 : _b.stdout) == null ? void 0 : _c.isTTY) === true);
+var ENV = globalThis.process?.env || {};
+var ARGV = globalThis.process?.argv || [];
+var ENABLED = !("NO_COLOR" in ENV) && ENV.COLOR !== "0" && ENV.TERM !== "dumb" && !ARGV.includes("--no-color") && !ARGV.includes("--no-colors") && (ENV.COLOR === "1" || !globalThis.process?.stdout || globalThis.process?.stdout?.isTTY === true);
 
 // node_modules/tiny-colors/dist/index.js
 var chain = (modifier) => {
@@ -1846,7 +1876,7 @@ var dist_default7 = colors;
 
 // node_modules/ionstore/dist/node.js
 import fs3 from "fs";
-import os2 from "os";
+import os from "os";
 import path5 from "path";
 
 // node_modules/ionstore/dist/utils.js
@@ -1921,12 +1951,12 @@ var NodeStore = class extends abstract_default {
       id,
       backend: {
         read: (id2) => {
-          const filePath = path5.join(os2.tmpdir(), `ionstore_${id2}.json`);
+          const filePath = path5.join(os.tmpdir(), `ionstore_${id2}.json`);
           const content = fs3.readFileSync(filePath, "utf8");
           return JSON.parse(content);
         },
         write: (id2, data) => {
-          const filePath = path5.join(os2.tmpdir(), `ionstore_${id2}.json`);
+          const filePath = path5.join(os.tmpdir(), `ionstore_${id2}.json`);
           const content = JSON.stringify(Array.from(data));
           return fs3.writeFileSync(filePath, content);
         }
@@ -1988,8 +2018,7 @@ var Utils = {
     return;
   },
   notify: (name, version, latest) => {
-    var _a4, _b2;
-    if (!((_b2 = (_a4 = globalThis.process) == null ? void 0 : _a4.stdout) == null ? void 0 : _b2.isTTY))
+    if (!globalThis.process?.stdout?.isTTY)
       return;
     const log = () => console.log(`
 
@@ -2042,6 +2071,109 @@ var exit = (message, code = 1) => {
 };
 var exit_default = exit;
 
+// node_modules/graphmatch/dist/utils.js
+var getNodes = (node) => {
+  const nodes = /* @__PURE__ */ new Set();
+  const queue = [node];
+  for (let i = 0; i < queue.length; i++) {
+    const node2 = queue[i];
+    if (nodes.has(node2))
+      continue;
+    nodes.add(node2);
+    const { children } = node2;
+    if (!children?.length)
+      continue;
+    for (let ci = 0, cl = children.length; ci < cl; ci++) {
+      queue.push(children[ci]);
+    }
+  }
+  return Array.from(nodes);
+};
+var getNodeFlags = (node) => {
+  let flags = "";
+  const nodes = getNodes(node);
+  for (let i = 0, l = nodes.length; i < l; i++) {
+    const node2 = nodes[i];
+    if (!node2.regex)
+      continue;
+    const nodeFlags = node2.regex.flags;
+    flags || (flags = nodeFlags);
+    if (flags === nodeFlags)
+      continue;
+    throw new Error(`Inconsistent RegExp flags used: "${flags}" and "${nodeFlags}"`);
+  }
+  return flags;
+};
+var getNodeSourceWithCache = (node, partial, cache2) => {
+  const cached = cache2.get(node);
+  if (cached !== void 0)
+    return cached;
+  const isNodePartial = node.partial ?? partial;
+  let source = "";
+  if (node.regex) {
+    source += isNodePartial ? "(?:$|" : "";
+    source += node.regex.source;
+  }
+  if (node.children?.length) {
+    const children = uniq2(node.children.map((node2) => getNodeSourceWithCache(node2, partial, cache2)).filter(Boolean));
+    if (children?.length) {
+      const isSomeChildNonPartial = node.children.some((child) => !child.regex || !(child.partial ?? partial));
+      const needsWrapperGroup = children.length > 1 || isNodePartial && (!source.length || isSomeChildNonPartial);
+      source += needsWrapperGroup ? isNodePartial ? "(?:$|" : "(?:" : "";
+      source += children.join("|");
+      source += needsWrapperGroup ? ")" : "";
+    }
+  }
+  if (node.regex) {
+    source += isNodePartial ? ")" : "";
+  }
+  cache2.set(node, source);
+  return source;
+};
+var getNodeSource = (node, partial) => {
+  const cache2 = /* @__PURE__ */ new Map();
+  const nodes = getNodes(node);
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    const source = getNodeSourceWithCache(nodes[i], partial, cache2);
+    if (i > 0)
+      continue;
+    return source;
+  }
+  return "";
+};
+var uniq2 = (values) => {
+  return Array.from(new Set(values));
+};
+
+// node_modules/graphmatch/dist/index.js
+var graphmatch = (node, input, options) => {
+  return graphmatch.compile(node, options).test(input);
+};
+graphmatch.compile = (node, options) => {
+  const partial = options?.partial ?? false;
+  const source = getNodeSource(node, partial);
+  const flags = getNodeFlags(node);
+  return new RegExp(`^(?:${source})$`, flags);
+};
+var dist_default18 = graphmatch;
+
+// node_modules/zeptomatch/dist/compile/index.js
+var compile = (node, options) => {
+  const re = dist_default18.compile(node, options);
+  const source = `${re.source.slice(0, -1)}[\\\\/]?$`;
+  const flags = re.flags;
+  return new RegExp(source, flags);
+};
+var compile_default = compile;
+
+// node_modules/zeptomatch/dist/merge/index.js
+var merge = (res) => {
+  const source = res.map((re) => re.source).join("|") || "$^";
+  const flags = res[0]?.flags;
+  return new RegExp(source, flags);
+};
+var merge_default = merge;
+
 // node_modules/grammex/dist/utils.js
 var isArray2 = (value) => {
   return Array.isArray(value);
@@ -2247,6 +2379,9 @@ var optional = (rule, handler) => {
 var star = (rule, handler) => {
   return repeat(rule, 0, Infinity, handler);
 };
+var plus = (rule, handler) => {
+  return repeat(rule, 1, Infinity, handler);
+};
 var and = (rules, handler) => {
   const erules = rules.map(resolve);
   return memoizable(handleable(backtrackable((state) => {
@@ -2314,12 +2449,11 @@ var memoizable = /* @__PURE__ */ (() => {
     const erule = resolve(rule);
     const ruleId = RULE_ID += 1;
     return (state) => {
-      var _a5;
-      var _a4;
+      var _a;
       if (state.options.memoization === false)
         return erule(state);
       const indexStart = state.index;
-      const cache2 = (_a4 = state.cache)[ruleId] || (_a4[ruleId] = { indexMax: -1, queue: [] });
+      const cache2 = (_a = state.cache)[ruleId] || (_a[ruleId] = { indexMax: -1, queue: [] });
       const cacheQueue = cache2.queue;
       const isPotentiallyCached = indexStart <= cache2.indexMax;
       if (isPotentiallyCached) {
@@ -2340,7 +2474,7 @@ var memoizable = /* @__PURE__ */ (() => {
           return true;
         } else if (cached) {
           state.index = cached.index;
-          if ((_a5 = cached.output) == null ? void 0 : _a5.length) {
+          if (cached.output?.length) {
             state.output.push(...cached.output);
           }
           return true;
@@ -2397,18 +2531,46 @@ var resolve = memoize2((rule) => {
 var identity2 = (value) => {
   return value;
 };
-var makeParser = (grammar) => {
-  return (input) => {
-    return parse(input, grammar, { memoization: false }).join("");
+var isString3 = (value) => {
+  return typeof value === "string";
+};
+var memoizeByObject = (fn) => {
+  const cacheFull = /* @__PURE__ */ new WeakMap();
+  const cachePartial = /* @__PURE__ */ new WeakMap();
+  return (globs, options) => {
+    const cache2 = options?.partial ? cachePartial : cacheFull;
+    const cached = cache2.get(globs);
+    if (cached !== void 0)
+      return cached;
+    const result = fn(globs, options);
+    cache2.set(globs, result);
+    return result;
   };
 };
-var memoize3 = (fn) => {
-  const cache2 = {};
-  return (arg) => {
-    return cache2[arg] ?? (cache2[arg] = fn(arg));
+var memoizeByPrimitive = (fn) => {
+  const cacheFull = {};
+  const cachePartial = {};
+  return (glob, options) => {
+    const cache2 = options?.partial ? cachePartial : cacheFull;
+    return cache2[glob] ?? (cache2[glob] = fn(glob, options));
   };
 };
 
+// node_modules/zeptomatch/dist/normalize/grammar.js
+var Escaped = match(/\\./, identity2);
+var Passthrough = match(/./, identity2);
+var StarStarStar = match(/\*\*\*+/, "*");
+var StarStarNoLeft = match(/([^/{[(!])\*\*/, (_, $1) => `${$1}*`);
+var StarStarNoRight = match(/(^|.)\*\*(?=[^*/)\]}])/, (_, $1) => `${$1}*`);
+var Grammar = star(or([Escaped, StarStarStar, StarStarNoLeft, StarStarNoRight, Passthrough]));
+var grammar_default = Grammar;
+
+// node_modules/zeptomatch/dist/normalize/index.js
+var normalize = (glob) => {
+  return parse(glob, grammar_default, { memoization: false }).join("");
+};
+var normalize_default = normalize;
+
 // node_modules/zeptomatch/dist/range.js
 var ALPHABET = "abcdefghijklmnopqrstuvwxyz";
 var int2alpha = (int) => {
@@ -2443,81 +2605,121 @@ var makeRangeAlpha = (start, end) => {
   return makeRangeInt(alpha2int(start), alpha2int(end)).map(int2alpha);
 };
 
-// node_modules/zeptomatch/dist/convert/grammar.js
-var Escaped = match(/\\./, identity2);
-var Escape = match(/[$.*+?^(){}[\]\|]/, (char) => `\\${char}`);
-var Slash = match(/[\\/]/, "[\\\\/]");
-var Passthrough = match(/./, identity2);
-var NegationOdd = match(/^(?:!!)*!(.*)$/, (_, glob) => `(?!^${parser_default(glob)}$).*?`);
-var NegationEven = match(/^(!!)+/, "");
+// node_modules/zeptomatch/dist/parse/utils.js
+var regex2 = (source) => {
+  const regex3 = new RegExp(source, "s");
+  return { partial: false, regex: regex3, children: [] };
+};
+var alternation = (children) => {
+  return { children };
+};
+var sequence = /* @__PURE__ */ (() => {
+  const pushToLeaves = (parent, child, handled) => {
+    if (handled.has(parent))
+      return;
+    handled.add(parent);
+    const { children } = parent;
+    if (!children.length) {
+      children.push(child);
+    } else {
+      for (let i = 0, l = children.length; i < l; i++) {
+        pushToLeaves(children[i], child, handled);
+      }
+    }
+  };
+  return (nodes) => {
+    if (!nodes.length) {
+      return alternation([]);
+    }
+    for (let i = nodes.length - 1; i >= 1; i--) {
+      const handled = /* @__PURE__ */ new Set();
+      const parent = nodes[i - 1];
+      const child = nodes[i];
+      pushToLeaves(parent, child, handled);
+    }
+    return nodes[0];
+  };
+})();
+var slash = () => {
+  const regex3 = new RegExp("[\\\\/]", "s");
+  return { regex: regex3, children: [] };
+};
+
+// node_modules/zeptomatch/dist/parse/grammar.js
+var Escaped2 = match(/\\./, regex2);
+var Escape = match(/[$.*+?^(){}[\]\|]/, (char) => regex2(`\\${char}`));
+var Slash = match(/[\\\/]/, slash);
+var Passthrough2 = match(/[^$.*+?^(){}[\]\|\\\/]+/, regex2);
+var NegationOdd = match(/^(?:!!)*!(.*)$/, (_, glob) => regex2(`(?!^${dist_default19.compile(glob).source}$).*?`));
+var NegationEven = match(/^(!!)+/);
 var Negation = or([NegationOdd, NegationEven]);
-var StarStarBetween = match(/\/(\*\*\/)+/, "(?:[\\\\/].+[\\\\/]|[\\\\/])");
-var StarStarStart = match(/^(\*\*\/)+/, "(?:^|.*[\\\\/])");
-var StarStarEnd = match(/\/(\*\*)$/, "(?:[\\\\/].*|$)");
-var StarStarNone = match(/\*\*/, ".*");
+var StarStarBetween = match(/\/(\*\*\/)+/, () => alternation([sequence([slash(), regex2(".+?"), slash()]), slash()]));
+var StarStarStart = match(/^(\*\*\/)+/, () => alternation([regex2("^"), sequence([regex2(".*?"), slash()])]));
+var StarStarEnd = match(/\/(\*\*)$/, () => alternation([sequence([slash(), regex2(".*?")]), regex2("$")]));
+var StarStarNone = match(/\*\*/, () => regex2(".*?"));
 var StarStar = or([StarStarBetween, StarStarStart, StarStarEnd, StarStarNone]);
-var StarDouble = match(/\*\/(?!\*\*\/|\*$)/, "[^\\\\/]*[\\\\/]");
-var StarSingle = match(/\*/, "[^\\\\/]*");
+var StarDouble = match(/\*\/(?!\*\*\/|\*$)/, () => sequence([regex2("[^\\\\/]*?"), slash()]));
+var StarSingle = match(/\*/, () => regex2("[^\\\\/]*"));
 var Star = or([StarDouble, StarSingle]);
-var Question = match("?", "[^\\\\/]");
+var Question = match("?", () => regex2("[^\\\\/]"));
 var ClassOpen = match("[", identity2);
 var ClassClose = match("]", identity2);
 var ClassNegation = match(/[!^]/, "^\\\\/");
 var ClassRange = match(/[a-z]-[a-z]|[0-9]-[0-9]/i, identity2);
+var ClassEscaped = match(/\\./, identity2);
 var ClassEscape = match(/[$.*+?^(){}[\|]/, (char) => `\\${char}`);
-var ClassPassthrough = match(/[^\]]/, identity2);
-var ClassValue = or([Escaped, ClassEscape, ClassRange, ClassPassthrough]);
-var Class = and([ClassOpen, optional(ClassNegation), star(ClassValue), ClassClose]);
+var ClassSlash = match(/[\\\/]/, "\\\\/");
+var ClassPassthrough = match(/[^$.*+?^(){}[\]\|\\\/]+/, identity2);
+var ClassValue = or([ClassEscaped, ClassEscape, ClassSlash, ClassRange, ClassPassthrough]);
+var Class = and([ClassOpen, optional(ClassNegation), star(ClassValue), ClassClose], (_) => regex2(_.join("")));
 var RangeOpen = match("{", "(?:");
 var RangeClose = match("}", ")");
 var RangeNumeric = match(/(\d+)\.\.(\d+)/, (_, $1, $2) => makeRangePaddedInt(+$1, +$2, Math.min($1.length, $2.length)).join("|"));
 var RangeAlphaLower = match(/([a-z]+)\.\.([a-z]+)/, (_, $1, $2) => makeRangeAlpha($1, $2).join("|"));
 var RangeAlphaUpper = match(/([A-Z]+)\.\.([A-Z]+)/, (_, $1, $2) => makeRangeAlpha($1.toLowerCase(), $2.toLowerCase()).join("|").toUpperCase());
 var RangeValue = or([RangeNumeric, RangeAlphaLower, RangeAlphaUpper]);
-var Range = and([RangeOpen, RangeValue, RangeClose]);
-var BracesOpen = match("{", "(?:");
-var BracesClose = match("}", ")");
-var BracesComma = match(",", "|");
-var BracesEscape = match(/[$.*+?^(){[\]\|]/, (char) => `\\${char}`);
-var BracesPassthrough = match(/[^}]/, identity2);
+var Range = and([RangeOpen, RangeValue, RangeClose], (_) => regex2(_.join("")));
+var BracesOpen = match("{");
+var BracesClose = match("}");
+var BracesComma = match(",");
+var BracesEscaped = match(/\\./, regex2);
+var BracesEscape = match(/[$.*+?^(){[\]\|]/, (char) => regex2(`\\${char}`));
+var BracesSlash = match(/[\\\/]/, slash);
+var BracesPassthrough = match(/[^$.*+?^(){}[\]\|\\\/,]+/, regex2);
 var BracesNested = lazy(() => Braces);
-var BracesValue = or([StarStar, Star, Question, Class, Range, BracesNested, Escaped, BracesEscape, BracesComma, BracesPassthrough]);
-var Braces = and([BracesOpen, star(BracesValue), BracesClose]);
-var Grammar = star(or([Negation, StarStar, Star, Question, Class, Range, Braces, Escaped, Escape, Slash, Passthrough]));
-var grammar_default = Grammar;
-
-// node_modules/zeptomatch/dist/convert/parser.js
-var parser = makeParser(grammar_default);
-var parser_default = parser;
-
-// node_modules/zeptomatch/dist/normalize/grammar.js
-var Escaped2 = match(/\\./, identity2);
-var Passthrough2 = match(/./, identity2);
-var StarStarStar = match(/\*\*\*+/, "*");
-var StarStarNoLeft = match(/([^/{[(!])\*\*/, (_, $1) => `${$1}*`);
-var StarStarNoRight = match(/(^|.)\*\*(?=[^*/)\]}])/, (_, $1) => `${$1}*`);
-var Grammar2 = star(or([Escaped2, StarStarStar, StarStarNoLeft, StarStarNoRight, Passthrough2]));
+var BracesEmptyValue = match("", () => regex2("(?:)"));
+var BracesFullValue = plus(or([StarStar, Star, Question, Class, Range, BracesNested, BracesEscaped, BracesEscape, BracesSlash, BracesPassthrough]), sequence);
+var BracesValue = or([BracesFullValue, BracesEmptyValue]);
+var Braces = and([BracesOpen, optional(and([BracesValue, star(and([BracesComma, BracesValue]))])), BracesClose], alternation);
+var Grammar2 = star(or([Negation, StarStar, Star, Question, Class, Range, Braces, Escaped2, Escape, Slash, Passthrough2]), sequence);
 var grammar_default2 = Grammar2;
 
-// node_modules/zeptomatch/dist/normalize/parser.js
-var parser2 = makeParser(grammar_default2);
-var parser_default2 = parser2;
+// node_modules/zeptomatch/dist/parse/index.js
+var _parse = (glob) => {
+  return parse(glob, grammar_default2, { memoization: false })[0];
+};
+var parse_default = _parse;
 
 // node_modules/zeptomatch/dist/index.js
-var zeptomatch = (glob, path7) => {
-  if (Array.isArray(glob)) {
-    const res = glob.map(zeptomatch.compile);
-    const isMatch = res.some((re) => re.test(path7));
-    return isMatch;
-  } else {
-    const re = zeptomatch.compile(glob);
-    const isMatch = re.test(path7);
-    return isMatch;
-  }
+var zeptomatch = (glob, path7, options) => {
+  return zeptomatch.compile(glob, options).test(path7);
 };
-zeptomatch.compile = memoize3((glob) => {
-  return new RegExp(`^${parser_default(parser_default2(glob))}[\\\\/]?$`, "s");
-});
+zeptomatch.compile = (() => {
+  const compileGlob = memoizeByPrimitive((glob, options) => {
+    return compile_default(parse_default(normalize_default(glob)), options);
+  });
+  const compileGlobs = memoizeByObject((globs, options) => {
+    return merge_default(globs.map((glob) => compileGlob(glob, options)));
+  });
+  return (glob, options) => {
+    if (isString3(glob)) {
+      return compileGlob(glob, options);
+    } else {
+      return compileGlobs(glob, options);
+    }
+  };
+})();
+var dist_default19 = zeptomatch;
 
 // node_modules/@prettier/cli/dist/utils.js
 async function getModule(modulePath) {
@@ -2555,8 +2757,7 @@ function getPluginPath(name) {
   }
 }
 async function getPluginsOrExit(names) {
-  if (!names.length)
-    return [];
+  if (!names.length) return [];
   return await Promise.all(names.map((name) => getPluginOrExit(name)));
 }
 var getStdin = dist_default3(async () => {
@@ -2572,7 +2773,13 @@ function isFunction4(value) {
 var normalizePathSeparatorsToPosix = (() => {
   if (path6.sep === "\\") {
     return (filePath) => {
-      return filePath.replaceAll("\\", "/");
+      return method_replace_all_default(
+        /* OPTIONAL_OBJECT: false */
+        0,
+        filePath,
+        "\\",
+        "/"
+      );
     };
   } else {
     return identity3;