prettier 3.5.3 → 3.6.0

package/internal/{cli.mjs → legacy-cli.mjs}

@@ -14,6 +14,7 @@ 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) {
@@ -39,10 +40,12 @@ 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({
@@ -121,7 +124,7 @@ var require_minimist = __commonJS({
         }
       });
       var defaults = opts.default || {};
-      var argv = { _: [] };
+      var argv2 = { _: [] };
       function argDefined(key2, arg2) {
         return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
       }
@@ -168,9 +171,9 @@ var require_minimist = __commonJS({
           }
         }
         var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
-        setKey(argv, key2.split("."), value2);
+        setKey(argv2, key2.split("."), value2);
         (aliases[key2] || []).forEach(function(x) {
-          setKey(argv, x.split("."), value2);
+          setKey(argv2, x.split("."), value2);
         });
       }
       Object.keys(flags.bools).forEach(function(key2) {
@@ -249,30 +252,30 @@ var require_minimist = __commonJS({
           }
         } else {
           if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
-            argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
+            argv2._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
           }
           if (opts.stopEarly) {
-            argv._.push.apply(argv._, args.slice(i + 1));
+            argv2._.push.apply(argv2._, args.slice(i + 1));
             break;
           }
         }
       }
       Object.keys(defaults).forEach(function(k) {
-        if (!hasKey(argv, k.split("."))) {
-          setKey(argv, k.split("."), defaults[k]);
+        if (!hasKey(argv2, k.split("."))) {
+          setKey(argv2, k.split("."), defaults[k]);
           (aliases[k] || []).forEach(function(x) {
-            setKey(argv, x.split("."), defaults[k]);
+            setKey(argv2, x.split("."), defaults[k]);
           });
         }
       });
       if (opts["--"]) {
-        argv["--"] = notFlags.slice();
+        argv2["--"] = notFlags.slice();
       } else {
         notFlags.forEach(function(k) {
-          argv._.push(k);
+          argv2._.push(k);
         });
       }
-      return argv;
+      return argv2;
     };
   }
 });
@@ -339,8 +342,8 @@ var require_common_path_prefix = __commonJS({
     "use strict";
     var { sep: DEFAULT_SEPARATOR } = __require("path");
     var determineSeparator = (paths) => {
-      for (const path12 of paths) {
-        const match = /(\/|\\)/.exec(path12);
+      for (const path13 of paths) {
+        const match = /(\/|\\)/.exec(path13);
         if (match !== null) return match[0];
       }
       return DEFAULT_SEPARATOR;
@@ -350,8 +353,8 @@ var require_common_path_prefix = __commonJS({
       if (first === "" || remaining.length === 0) return "";
       const parts = first.split(sep);
       let endOfPrefix = parts.length;
-      for (const path12 of remaining) {
-        const compare = path12.split(sep);
+      for (const path13 of remaining) {
+        const compare = path13.split(sep);
         for (let i = 0; i < endOfPrefix; i++) {
           if (compare[i] !== parts[i]) {
             endOfPrefix = i;
@@ -365,6 +368,444 @@ var require_common_path_prefix = __commonJS({
   }
 });
 
+// node_modules/ci-info/vendors.json
+var require_vendors = __commonJS({
+  "node_modules/ci-info/vendors.json"(exports, module) {
+    module.exports = [
+      {
+        name: "Agola CI",
+        constant: "AGOLA",
+        env: "AGOLA_GIT_REF",
+        pr: "AGOLA_PULL_REQUEST_ID"
+      },
+      {
+        name: "Appcircle",
+        constant: "APPCIRCLE",
+        env: "AC_APPCIRCLE",
+        pr: {
+          env: "AC_GIT_PR",
+          ne: "false"
+        }
+      },
+      {
+        name: "AppVeyor",
+        constant: "APPVEYOR",
+        env: "APPVEYOR",
+        pr: "APPVEYOR_PULL_REQUEST_NUMBER"
+      },
+      {
+        name: "AWS CodeBuild",
+        constant: "CODEBUILD",
+        env: "CODEBUILD_BUILD_ARN",
+        pr: {
+          env: "CODEBUILD_WEBHOOK_EVENT",
+          any: [
+            "PULL_REQUEST_CREATED",
+            "PULL_REQUEST_UPDATED",
+            "PULL_REQUEST_REOPENED"
+          ]
+        }
+      },
+      {
+        name: "Azure Pipelines",
+        constant: "AZURE_PIPELINES",
+        env: "TF_BUILD",
+        pr: {
+          BUILD_REASON: "PullRequest"
+        }
+      },
+      {
+        name: "Bamboo",
+        constant: "BAMBOO",
+        env: "bamboo_planKey"
+      },
+      {
+        name: "Bitbucket Pipelines",
+        constant: "BITBUCKET",
+        env: "BITBUCKET_COMMIT",
+        pr: "BITBUCKET_PR_ID"
+      },
+      {
+        name: "Bitrise",
+        constant: "BITRISE",
+        env: "BITRISE_IO",
+        pr: "BITRISE_PULL_REQUEST"
+      },
+      {
+        name: "Buddy",
+        constant: "BUDDY",
+        env: "BUDDY_WORKSPACE_ID",
+        pr: "BUDDY_EXECUTION_PULL_REQUEST_ID"
+      },
+      {
+        name: "Buildkite",
+        constant: "BUILDKITE",
+        env: "BUILDKITE",
+        pr: {
+          env: "BUILDKITE_PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "CircleCI",
+        constant: "CIRCLE",
+        env: "CIRCLECI",
+        pr: "CIRCLE_PULL_REQUEST"
+      },
+      {
+        name: "Cirrus CI",
+        constant: "CIRRUS",
+        env: "CIRRUS_CI",
+        pr: "CIRRUS_PR"
+      },
+      {
+        name: "Cloudflare Pages",
+        constant: "CLOUDFLARE_PAGES",
+        env: "CF_PAGES"
+      },
+      {
+        name: "Codefresh",
+        constant: "CODEFRESH",
+        env: "CF_BUILD_ID",
+        pr: {
+          any: [
+            "CF_PULL_REQUEST_NUMBER",
+            "CF_PULL_REQUEST_ID"
+          ]
+        }
+      },
+      {
+        name: "Codemagic",
+        constant: "CODEMAGIC",
+        env: "CM_BUILD_ID",
+        pr: "CM_PULL_REQUEST"
+      },
+      {
+        name: "Codeship",
+        constant: "CODESHIP",
+        env: {
+          CI_NAME: "codeship"
+        }
+      },
+      {
+        name: "Drone",
+        constant: "DRONE",
+        env: "DRONE",
+        pr: {
+          DRONE_BUILD_EVENT: "pull_request"
+        }
+      },
+      {
+        name: "dsari",
+        constant: "DSARI",
+        env: "DSARI"
+      },
+      {
+        name: "Earthly",
+        constant: "EARTHLY",
+        env: "EARTHLY_CI"
+      },
+      {
+        name: "Expo Application Services",
+        constant: "EAS",
+        env: "EAS_BUILD"
+      },
+      {
+        name: "Gerrit",
+        constant: "GERRIT",
+        env: "GERRIT_PROJECT"
+      },
+      {
+        name: "Gitea Actions",
+        constant: "GITEA_ACTIONS",
+        env: "GITEA_ACTIONS"
+      },
+      {
+        name: "GitHub Actions",
+        constant: "GITHUB_ACTIONS",
+        env: "GITHUB_ACTIONS",
+        pr: {
+          GITHUB_EVENT_NAME: "pull_request"
+        }
+      },
+      {
+        name: "GitLab CI",
+        constant: "GITLAB",
+        env: "GITLAB_CI",
+        pr: "CI_MERGE_REQUEST_ID"
+      },
+      {
+        name: "GoCD",
+        constant: "GOCD",
+        env: "GO_PIPELINE_LABEL"
+      },
+      {
+        name: "Google Cloud Build",
+        constant: "GOOGLE_CLOUD_BUILD",
+        env: "BUILDER_OUTPUT"
+      },
+      {
+        name: "Harness CI",
+        constant: "HARNESS",
+        env: "HARNESS_BUILD_ID"
+      },
+      {
+        name: "Heroku",
+        constant: "HEROKU",
+        env: {
+          env: "NODE",
+          includes: "/app/.heroku/node/bin/node"
+        }
+      },
+      {
+        name: "Hudson",
+        constant: "HUDSON",
+        env: "HUDSON_URL"
+      },
+      {
+        name: "Jenkins",
+        constant: "JENKINS",
+        env: [
+          "JENKINS_URL",
+          "BUILD_ID"
+        ],
+        pr: {
+          any: [
+            "ghprbPullId",
+            "CHANGE_ID"
+          ]
+        }
+      },
+      {
+        name: "LayerCI",
+        constant: "LAYERCI",
+        env: "LAYERCI",
+        pr: "LAYERCI_PULL_REQUEST"
+      },
+      {
+        name: "Magnum CI",
+        constant: "MAGNUM",
+        env: "MAGNUM"
+      },
+      {
+        name: "Netlify CI",
+        constant: "NETLIFY",
+        env: "NETLIFY",
+        pr: {
+          env: "PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "Nevercode",
+        constant: "NEVERCODE",
+        env: "NEVERCODE",
+        pr: {
+          env: "NEVERCODE_PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "Prow",
+        constant: "PROW",
+        env: "PROW_JOB_ID"
+      },
+      {
+        name: "ReleaseHub",
+        constant: "RELEASEHUB",
+        env: "RELEASE_BUILD_ID"
+      },
+      {
+        name: "Render",
+        constant: "RENDER",
+        env: "RENDER",
+        pr: {
+          IS_PULL_REQUEST: "true"
+        }
+      },
+      {
+        name: "Sail CI",
+        constant: "SAIL",
+        env: "SAILCI",
+        pr: "SAIL_PULL_REQUEST_NUMBER"
+      },
+      {
+        name: "Screwdriver",
+        constant: "SCREWDRIVER",
+        env: "SCREWDRIVER",
+        pr: {
+          env: "SD_PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "Semaphore",
+        constant: "SEMAPHORE",
+        env: "SEMAPHORE",
+        pr: "PULL_REQUEST_NUMBER"
+      },
+      {
+        name: "Sourcehut",
+        constant: "SOURCEHUT",
+        env: {
+          CI_NAME: "sourcehut"
+        }
+      },
+      {
+        name: "Strider CD",
+        constant: "STRIDER",
+        env: "STRIDER"
+      },
+      {
+        name: "TaskCluster",
+        constant: "TASKCLUSTER",
+        env: [
+          "TASK_ID",
+          "RUN_ID"
+        ]
+      },
+      {
+        name: "TeamCity",
+        constant: "TEAMCITY",
+        env: "TEAMCITY_VERSION"
+      },
+      {
+        name: "Travis CI",
+        constant: "TRAVIS",
+        env: "TRAVIS",
+        pr: {
+          env: "TRAVIS_PULL_REQUEST",
+          ne: "false"
+        }
+      },
+      {
+        name: "Vela",
+        constant: "VELA",
+        env: "VELA",
+        pr: {
+          VELA_PULL_REQUEST: "1"
+        }
+      },
+      {
+        name: "Vercel",
+        constant: "VERCEL",
+        env: {
+          any: [
+            "NOW_BUILDER",
+            "VERCEL"
+          ]
+        },
+        pr: "VERCEL_GIT_PULL_REQUEST_ID"
+      },
+      {
+        name: "Visual Studio App Center",
+        constant: "APPCENTER",
+        env: "APPCENTER_BUILD_ID"
+      },
+      {
+        name: "Woodpecker",
+        constant: "WOODPECKER",
+        env: {
+          CI: "woodpecker"
+        },
+        pr: {
+          CI_BUILD_EVENT: "pull_request"
+        }
+      },
+      {
+        name: "Xcode Cloud",
+        constant: "XCODE_CLOUD",
+        env: "CI_XCODE_PROJECT",
+        pr: "CI_PULL_REQUEST_NUMBER"
+      },
+      {
+        name: "Xcode Server",
+        constant: "XCODE_SERVER",
+        env: "XCS"
+      }
+    ];
+  }
+});
+
+// node_modules/ci-info/index.js
+var require_ci_info = __commonJS({
+  "node_modules/ci-info/index.js"(exports) {
+    "use strict";
+    var vendors = require_vendors();
+    var env3 = process.env;
+    Object.defineProperty(exports, "_vendors", {
+      value: vendors.map(function(v) {
+        return v.constant;
+      })
+    });
+    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);
+      });
+      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_APP_ID || // Appflow
+    env3.CI_BUILD_ID || // Appflow
+    env3.CI_BUILD_NUMBER || // Appflow
+    env3.CI_NAME || // Codeship and others
+    env3.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI
+    env3.RUN_ID || // TaskCluster, dsari
+    exports.name || false));
+    function checkEnv(obj) {
+      if (typeof obj === "string") return !!env3[obj];
+      if ("env" in obj) {
+        return env3[obj.env] && env3[obj.env].includes(obj.includes);
+      }
+      if ("any" in obj) {
+        return obj.any.some(function(k) {
+          return !!env3[k];
+        });
+      }
+      return Object.keys(obj).every(function(k) {
+        return env3[k] === obj[k];
+      });
+    }
+    function checkPR(vendor) {
+      switch (typeof vendor.pr) {
+        case "string":
+          return !!env3[vendor.pr];
+        case "object":
+          if ("env" in vendor.pr) {
+            if ("any" in vendor.pr) {
+              return vendor.pr.any.some(function(key) {
+                return env3[vendor.pr.env] === key;
+              });
+            } else {
+              return vendor.pr.env in env3 && env3[vendor.pr.env] !== vendor.pr.ne;
+            }
+          } else if ("any" in vendor.pr) {
+            return vendor.pr.any.some(function(key) {
+              return !!env3[key];
+            });
+          } else {
+            return checkEnv(vendor.pr);
+          }
+        default:
+          return null;
+      }
+    }
+  }
+});
+
 // src/cli/index.js
 import * as prettier2 from "../index.mjs";
 
@@ -565,7 +1006,8 @@ var {
   vnopts,
   fastGlob,
   createTwoFilesPatch,
-  mockable
+  picocolors,
+  leven
 } = sharedWithCli;
 
 // src/cli/options/get-context-options.js
@@ -760,9 +1202,9 @@ function sdbm(string) {
 // src/cli/utils.js
 import { __internal as sharedWithCli2 } from "../index.mjs";
 var printToScreen = console.log.bind(console);
-function groupBy(array2, iteratee) {
+function groupBy(array, iteratee) {
   const result = /* @__PURE__ */ Object.create(null);
-  for (const value of array2) {
+  for (const value of array) {
     const key = iteratee(value);
     if (Array.isArray(result[key])) {
       result[key].push(value);
@@ -858,640 +1300,101 @@ function minimistParse(args, options) {
   );
 }
 
-// node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    // 21 isn't widely supported and 22 does the same thing
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    // Bright color
-    blackBright: [90, 39],
-    gray: [90, 39],
-    // Alias of `blackBright`
-    grey: [90, 39],
-    // Alias of `blackBright`
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    // Bright color
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    // Alias of `bgBlackBright`
-    bgGrey: [100, 49],
-    // Alias of `bgBlackBright`
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
+// src/cli/options/normalize-cli-options.js
+var descriptor = {
+  key: (key) => key.length === 1 ? `-${key}` : `--${key}`,
+  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 modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = /* @__PURE__ */ new Map();
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
+var _flags;
+var FlagSchema = class extends vnopts.ChoiceSchema {
+  constructor({ name, flags }) {
+    super({ name, choices: flags });
+    __privateAdd(this, _flags, []);
+    __privateSet(this, _flags, [...flags].sort());
   }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
-          }
-          return Math.round((red - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          /* eslint-disable no-bitwise */
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-          /* eslint-enable no-bitwise */
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
-        }
-        if (code < 16) {
-          return 90 + (code - 8);
-        }
-        let red;
-        let green;
-        let blue;
-        if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
-        }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
+  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 (suggestion) {
+        utils.logger.warn(
+          [
+            `Unknown flag ${picocolors.yellow(utils.descriptor.value(value))},`,
+            `did you mean ${picocolors.blue(utils.descriptor.value(suggestion))}?`
+          ].join(" ")
+        );
+        return suggestion;
+      }
     }
+    return value;
+  }
+  expected() {
+    return "a flag";
+  }
+};
+_flags = new WeakMap();
+function normalizeCliOptions(options, optionInfos, opts) {
+  return normalizeOptions(options, optionInfos, {
+    ...opts,
+    isCLI: true,
+    FlagSchema,
+    descriptor
   });
-  return styles;
 }
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
+var normalize_cli_options_default = normalizeCliOptions;
 
-// node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "process";
-import os from "os";
-import tty from "tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
+// 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) {
+    detailedOptions = detailedOptions.filter(
+      (option) => keys2.includes(option.name)
+    );
+    argv2 = pick(argv2, keys2);
   }
+  const normalized = normalize_cli_options_default(argv2, detailedOptions, { logger });
   return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
+    ...Object.fromEntries(
+      Object.entries(normalized).map(([key, value]) => {
+        const option = detailedOptions.find(({ name }) => name === key) || {};
+        return [option.forwardToApi || camelCase(key), value];
+      })
+    ),
+    _: (_a = normalized._) == null ? void 0 : _a.map(String),
+    get __raw() {
+      return argv2;
+    }
   };
 }
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== void 0) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-  }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === void 0) {
-    return 0;
+var { detailedOptions: detailedOptionsWithoutPlugins } = getContextOptionsWithoutPlugins();
+function parseArgvWithoutPlugins(rawArguments, logger, keys2) {
+  return parseArgv(
+    rawArguments,
+    detailedOptionsWithoutPlugins,
+    logger,
+    typeof keys2 === "string" ? [keys2] : keys2
+  );
+}
+
+// src/cli/context.js
+var _stack;
+var Context = class {
+  constructor({ rawArguments, logger }) {
+    __privateAdd(this, _stack, []);
+    this.rawArguments = rawArguments;
+    this.logger = logger;
   }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (process2.platform === "win32") {
-    const osRelease = os.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
-    }
-    return 1;
-  }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
-      return 3;
-    }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
-      return 1;
-    }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env) {
-    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version2 >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
-    }
-  }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// node_modules/chalk/source/utilities.js
-function stringReplaceAll2(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
-    endIndex = index + 1;
-    index = string.indexOf("\n", endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-
-// node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = /* @__PURE__ */ Object.create(null);
-var applyOptions = (object2, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object2.level = options.level === void 0 ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk2 = (...strings) => strings.join(" ");
-  applyOptions(chalk2, options);
-  Object.setPrototypeOf(chalk2, createChalk.prototype);
-  return chalk2;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-}
-var proto = Object.defineProperties(() => {
-}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === void 0) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === void 0) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== void 0) {
-      string = stringReplaceAll2(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf("\n");
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
-// node_modules/leven/index.js
-var array = [];
-var characterCodeCache = [];
-function leven(first, second) {
-  if (first === second) {
-    return 0;
-  }
-  const swap = first;
-  if (first.length > second.length) {
-    first = second;
-    second = swap;
-  }
-  let firstLength = first.length;
-  let secondLength = second.length;
-  while (firstLength > 0 && first.charCodeAt(~-firstLength) === second.charCodeAt(~-secondLength)) {
-    firstLength--;
-    secondLength--;
-  }
-  let start = 0;
-  while (start < firstLength && first.charCodeAt(start) === second.charCodeAt(start)) {
-    start++;
-  }
-  firstLength -= start;
-  secondLength -= start;
-  if (firstLength === 0) {
-    return secondLength;
-  }
-  let bCharacterCode;
-  let result;
-  let temporary;
-  let temporary2;
-  let index = 0;
-  let index2 = 0;
-  while (index < firstLength) {
-    characterCodeCache[index] = first.charCodeAt(start + index);
-    array[index] = ++index;
-  }
-  while (index2 < secondLength) {
-    bCharacterCode = second.charCodeAt(start + index2);
-    temporary = index2++;
-    result = index2;
-    for (index = 0; index < firstLength; index++) {
-      temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
-      temporary = array[index];
-      result = array[index] = temporary > result ? temporary2 > result ? result + 1 : temporary2 : temporary2 > temporary ? temporary + 1 : temporary2;
-    }
-  }
-  return result;
-}
-
-// src/cli/options/normalize-cli-options.js
-var descriptor = {
-  key: (key) => key.length === 1 ? `-${key}` : `--${key}`,
-  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 {
-  constructor({ name, flags }) {
-    super({ name, choices: flags });
-    __privateAdd(this, _flags, []);
-    __privateSet(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 (suggestion) {
-        utils.logger.warn(
-          [
-            `Unknown flag ${source_default.yellow(utils.descriptor.value(value))},`,
-            `did you mean ${source_default.blue(utils.descriptor.value(suggestion))}?`
-          ].join(" ")
-        );
-        return suggestion;
-      }
-    }
-    return value;
-  }
-  expected() {
-    return "a flag";
-  }
-};
-_flags = new WeakMap();
-function normalizeCliOptions(options, optionInfos, opts) {
-  return normalizeOptions(options, optionInfos, {
-    ...opts,
-    isCLI: true,
-    FlagSchema,
-    descriptor
-  });
-}
-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 argv = minimistParse(rawArguments, minimistOptions);
-  if (keys2) {
-    detailedOptions = detailedOptions.filter(
-      (option) => keys2.includes(option.name)
-    );
-    argv = pick(argv, keys2);
-  }
-  const normalized = normalize_cli_options_default(argv, detailedOptions, { logger });
-  return {
-    ...Object.fromEntries(
-      Object.entries(normalized).map(([key, value]) => {
-        const option = detailedOptions.find(({ name }) => name === key) || {};
-        return [option.forwardToApi || camelCase(key), value];
-      })
-    ),
-    _: (_a = normalized._) == null ? void 0 : _a.map(String),
-    get __raw() {
-      return argv;
-    }
-  };
-}
-var { detailedOptions: detailedOptionsWithoutPlugins } = getContextOptionsWithoutPlugins();
-function parseArgvWithoutPlugins(rawArguments, logger, keys2) {
-  return parseArgv(
-    rawArguments,
-    detailedOptionsWithoutPlugins,
-    logger,
-    typeof keys2 === "string" ? [keys2] : keys2
-  );
-}
-
-// src/cli/context.js
-var _stack;
-var Context = class {
-  constructor({ rawArguments, logger }) {
-    __privateAdd(this, _stack, []);
-    this.rawArguments = rawArguments;
-    this.logger = logger;
-  }
-  async init() {
-    const { rawArguments, logger } = this;
-    const { plugins } = parseArgvWithoutPlugins(rawArguments, logger, [
-      "plugin"
-    ]);
-    await this.pushContextPlugins(plugins);
-    const argv = parseArgv(rawArguments, this.detailedOptions, logger);
-    this.argv = argv;
-    this.filePatterns = argv._;
+  async init() {
+    const { rawArguments, logger } = this;
+    const { plugins } = parseArgvWithoutPlugins(rawArguments, logger, [
+      "plugin"
+    ]);
+    await this.pushContextPlugins(plugins);
+    const argv2 = parseArgv(rawArguments, this.detailedOptions, logger);
+    this.argv = argv2;
+    this.filePatterns = argv2._;
   }
   /**
    * @param {string[]} plugins
@@ -1539,33 +1442,35 @@ var context_default = Context;
 
 // src/cli/file-info.js
 var import_fast_json_stable_stringify = __toESM(require_fast_json_stable_stringify(), 1);
+import path2 from "path";
 import { format, getFileInfo } from "../index.mjs";
 async function logFileInfoOrDie(context) {
   const {
     fileInfo: file,
     ignorePath,
-    withNodeModules,
+    withNodeModules: withNodeModules2,
     plugins,
     config
   } = context.argv;
-  const fileInfo = await getFileInfo(file, {
+  const fileInfo = await getFileInfo(path2.resolve(file), {
     ignorePath,
-    withNodeModules,
-    plugins,
+    withNodeModules: withNodeModules2,
+    plugins: plugins.length > 0 ? plugins : void 0,
     resolveConfig: config !== false
   });
-  printToScreen(await format((0, import_fast_json_stable_stringify.default)(fileInfo), { parser: "json" }));
+  const result = await format((0, import_fast_json_stable_stringify.default)(fileInfo), { parser: "json" });
+  printToScreen(result.trim());
 }
 var file_info_default = logFileInfoOrDie;
 
 // src/cli/find-config-path.js
-import path2 from "path";
+import path3 from "path";
 import { resolveConfigFile } from "../index.mjs";
 async function logResolvedConfigPathOrDie(context) {
   const file = context.argv.findConfigPath;
   const configFile = await resolveConfigFile(file);
   if (configFile) {
-    printToScreen(normalizeToPosix(path2.relative(process.cwd(), configFile)));
+    printToScreen(normalizeToPosix(path3.relative(process.cwd(), configFile)));
   } else {
     throw new Error(`Can not find configure file for "${file}".`);
   }
@@ -1573,12 +1478,77 @@ async function logResolvedConfigPathOrDie(context) {
 var find_config_path_default = logResolvedConfigPathOrDie;
 
 // src/cli/format.js
-import fs8 from "fs/promises";
-import path11 from "path";
+import fs9 from "fs/promises";
+import path12 from "path";
+
+// node_modules/get-stdin/index.js
+var { stdin } = process;
+async function getStdin() {
+  let result = "";
+  if (stdin.isTTY) {
+    return result;
+  }
+  stdin.setEncoding("utf8");
+  for await (const chunk of stdin) {
+    result += chunk;
+  }
+  return result;
+}
+getStdin.buffer = async () => {
+  const result = [];
+  let length = 0;
+  if (stdin.isTTY) {
+    return Buffer.concat([]);
+  }
+  for await (const chunk of stdin) {
+    result.push(chunk);
+    length += chunk.length;
+  }
+  return Buffer.concat(result, length);
+};
+
+// src/cli/format.js
 import * as prettier from "../index.mjs";
 
 // src/cli/expand-patterns.js
-import path3 from "path";
+import path5 from "path";
+
+// src/cli/directory-ignorer.js
+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 {
+  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.ignorePatterns = patterns;
+  }
+  /**
+   * @param {string} absolutePathOrPattern
+   */
+  shouldIgnore(absolutePathOrPattern) {
+    const directoryNames = path4.relative(cwd, absolutePathOrPattern).split(path4.sep);
+    return directoryNames.some(
+      (directoryName) => __privateGet(this, _directories).has(directoryName)
+    );
+  }
+};
+_directories = new WeakMap();
+var directoryIgnorerWithNodeModules = new DirectoryIgnorer(
+  /* shouldIgnoreNodeModules */
+  true
+);
+var directoryIgnorerWithoutNodeModules = new DirectoryIgnorer(
+  /* shouldIgnoreNodeModules */
+  false
+);
+
+// src/cli/expand-patterns.js
 async function* expandPatterns(context) {
   const seen = /* @__PURE__ */ new Set();
   let noResults = true;
@@ -1590,7 +1560,7 @@ async function* expandPatterns(context) {
       yield { error };
       continue;
     }
-    const filename = path3.resolve(filePath);
+    const filename = path5.resolve(filePath);
     if (seen.has(filename)) {
       continue;
     }
@@ -1604,20 +1574,17 @@ async function* expandPatterns(context) {
   }
 }
 async function* expandPatternsInternal(context) {
-  const silentlyIgnoredDirs = [".git", ".sl", ".svn", ".hg", ".jj"];
-  if (context.argv.withNodeModules !== true) {
-    silentlyIgnoredDirs.push("node_modules");
-  }
+  const directoryIgnorer = context.argv.withNodeModules === true ? directoryIgnorerWithoutNodeModules : directoryIgnorerWithNodeModules;
   const globOptions = {
     dot: true,
-    ignore: silentlyIgnoredDirs.map((dir) => "**/" + dir),
+    ignore: [...directoryIgnorer.ignorePatterns],
     followSymbolicLinks: false
   };
-  const cwd2 = process.cwd();
+  const cwd3 = process.cwd();
   const entries = [];
   for (const pattern of context.filePatterns) {
-    const absolutePath = path3.resolve(cwd2, pattern);
-    if (containsIgnoredPathSegment(absolutePath, cwd2, silentlyIgnoredDirs)) {
+    const absolutePath = path5.resolve(pattern);
+    if (directoryIgnorer.shouldIgnore(absolutePath)) {
       continue;
     }
     const stat = await lstatSafe(absolutePath);
@@ -1639,7 +1606,7 @@ async function* expandPatternsInternal(context) {
           input: pattern
         });
       } else if (stat.isDirectory()) {
-        const relativePath = path3.relative(cwd2, absolutePath) || ".";
+        const relativePath = path5.relative(cwd3, absolutePath) || ".";
         const prefix = escapePathForGlob(fixWindowsSlashes(relativePath));
         entries.push({
           type: "dir",
@@ -1690,13 +1657,10 @@ var errorMessages = {
     glob: "No files matching the pattern were found"
   }
 };
-function containsIgnoredPathSegment(absolutePath, cwd2, ignoredDirectories) {
-  return path3.relative(cwd2, absolutePath).split(path3.sep).some((dir) => ignoredDirectories.includes(dir));
-}
 function sortPaths(paths) {
   return paths.sort((a, b) => a.localeCompare(b));
 }
-function escapePathForGlob(path12) {
+function escapePathForGlob(path13) {
   return string_replace_all_default(
     /* isOptionalObject */
     false,
@@ -1707,7 +1671,7 @@ function escapePathForGlob(path12) {
         string_replace_all_default(
           /* isOptionalObject */
           false,
-          path12,
+          path13,
           "\\",
           "\0"
         )
@@ -1724,114 +1688,60 @@ var fixWindowsSlashes = normalizeToPosix;
 
 // src/cli/find-cache-file.js
 import fs4 from "fs/promises";
-import os2 from "os";
-import path8 from "path";
+import os from "os";
+import path9 from "path";
 
-// node_modules/find-cache-dir/index.js
+// node_modules/find-cache-directory/index.js
 var import_common_path_prefix = __toESM(require_common_path_prefix(), 1);
-import process4 from "process";
-import path7 from "path";
+import process3 from "process";
+import path8 from "path";
 import fs3 from "fs";
 
 // node_modules/pkg-dir/index.js
-import path6 from "path";
-
-// node_modules/pkg-dir/node_modules/find-up/index.js
-import path5 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import path7 from "path";
 
-// node_modules/locate-path/index.js
-import process3 from "process";
-import path4 from "path";
-import fs2, { promises as fsPromises } from "fs";
+// node_modules/find-up-simple/index.js
+import process2 from "process";
 import { fileURLToPath } from "url";
-var typeMappings = {
-  directory: "isDirectory",
-  file: "isFile"
-};
-function checkType(type) {
-  if (Object.hasOwnProperty.call(typeMappings, type)) {
-    return;
-  }
-  throw new Error(`Invalid type specified: ${type}`);
-}
-var matchType = (type, stat) => stat[typeMappings[type]]();
+import fs2 from "fs";
+import path6 from "path";
 var toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-function locatePathSync(paths, {
-  cwd: cwd2 = process3.cwd(),
+function findUpSync(name, {
+  cwd: cwd3 = process2.cwd(),
   type = "file",
-  allowSymlinks = true
+  stopAt
 } = {}) {
-  checkType(type);
-  cwd2 = toPath(cwd2);
-  const statFunction = allowSymlinks ? fs2.statSync : fs2.lstatSync;
-  for (const path_ of paths) {
+  let directory = path6.resolve(toPath(cwd3) ?? "");
+  const { root } = path6.parse(directory);
+  stopAt = path6.resolve(directory, toPath(stopAt) ?? root);
+  const isAbsoluteName = path6.isAbsolute(name);
+  while (directory) {
+    const filePath = isAbsoluteName ? name : path6.join(directory, name);
     try {
-      const stat = statFunction(path4.resolve(cwd2, path_), {
-        throwIfNoEntry: false
-      });
-      if (!stat) {
-        continue;
-      }
-      if (matchType(type, stat)) {
-        return path_;
+      const stats = fs2.statSync(filePath, { throwIfNoEntry: false });
+      if (type === "file" && (stats == null ? void 0 : stats.isFile()) || type === "directory" && (stats == null ? void 0 : stats.isDirectory())) {
+        return filePath;
       }
     } catch {
     }
-  }
-}
-
-// node_modules/pkg-dir/node_modules/find-up/index.js
-var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
-var findUpStop = Symbol("findUpStop");
-function findUpMultipleSync(name, options = {}) {
-  let directory = path5.resolve(toPath2(options.cwd) || "");
-  const { root } = path5.parse(directory);
-  const stopAt = options.stopAt || root;
-  const limit = options.limit || Number.POSITIVE_INFINITY;
-  const paths = [name].flat();
-  const runMatcher = (locateOptions) => {
-    if (typeof name !== "function") {
-      return locatePathSync(paths, locateOptions);
-    }
-    const foundPath = name(locateOptions.cwd);
-    if (typeof foundPath === "string") {
-      return locatePathSync([foundPath], locateOptions);
-    }
-    return foundPath;
-  };
-  const matches = [];
-  while (true) {
-    const foundPath = runMatcher({ ...options, cwd: directory });
-    if (foundPath === findUpStop) {
-      break;
-    }
-    if (foundPath) {
-      matches.push(path5.resolve(directory, foundPath));
-    }
-    if (directory === stopAt || matches.length >= limit) {
+    if (directory === stopAt || directory === root) {
       break;
     }
-    directory = path5.dirname(directory);
+    directory = path6.dirname(directory);
   }
-  return matches;
-}
-function findUpSync(name, options = {}) {
-  const matches = findUpMultipleSync(name, { ...options, limit: 1 });
-  return matches[0];
 }
 
 // node_modules/pkg-dir/index.js
-function packageDirectorySync({ cwd: cwd2 } = {}) {
-  const filePath = findUpSync("package.json", { cwd: cwd2 });
-  return filePath && path6.dirname(filePath);
+function packageDirectorySync({ cwd: cwd3 } = {}) {
+  const filePath = findUpSync("package.json", { cwd: cwd3 });
+  return filePath && path7.dirname(filePath);
 }
 
-// node_modules/find-cache-dir/index.js
-var { env: env2, cwd } = process4;
-var isWritable = (path12) => {
+// node_modules/find-cache-directory/index.js
+var { env, cwd: cwd2 } = process3;
+var isWritable = (path13) => {
   try {
-    fs3.accessSync(path12, fs3.constants.W_OK);
+    fs3.accessSync(path13, fs3.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -1844,22 +1754,22 @@ function useDirectory(directory, options) {
   return directory;
 }
 function getNodeModuleDirectory(directory) {
-  const nodeModules = path7.join(directory, "node_modules");
-  if (!isWritable(nodeModules) && (fs3.existsSync(nodeModules) || !isWritable(path7.join(directory)))) {
+  const nodeModules = path8.join(directory, "node_modules");
+  if (!isWritable(nodeModules) && (fs3.existsSync(nodeModules) || !isWritable(path8.join(directory)))) {
     return;
   }
   return nodeModules;
 }
 function findCacheDirectory(options = {}) {
-  if (env2.CACHE_DIR && !["true", "false", "1", "0"].includes(env2.CACHE_DIR)) {
-    return useDirectory(path7.join(env2.CACHE_DIR, options.name), options);
+  if (env.CACHE_DIR && !["true", "false", "1", "0"].includes(env.CACHE_DIR)) {
+    return useDirectory(path8.join(env.CACHE_DIR, options.name), options);
   }
-  let { cwd: directory = cwd(), files } = options;
+  let { cwd: directory = cwd2(), files } = options;
   if (files) {
     if (!Array.isArray(files)) {
       throw new TypeError(`Expected \`files\` option to be an array, got \`${typeof files}\`.`);
     }
-    directory = (0, import_common_path_prefix.default)(files.map((file) => path7.resolve(directory, file)));
+    directory = (0, import_common_path_prefix.default)(files.map((file) => path8.resolve(directory, file)));
   }
   directory = packageDirectorySync({ cwd: directory });
   if (!directory) {
@@ -1869,17 +1779,17 @@ function findCacheDirectory(options = {}) {
   if (!nodeModules) {
     return;
   }
-  return useDirectory(path7.join(directory, "node_modules", ".cache", options.name), options);
+  return useDirectory(path8.join(directory, "node_modules", ".cache", options.name), options);
 }
 
 // src/cli/find-cache-file.js
 function findDefaultCacheFile() {
-  const cacheDir = findCacheDirectory({ name: "prettier", create: true }) || os2.tmpdir();
-  const cacheFilePath = path8.join(cacheDir, ".prettier-cache");
+  const cacheDir = findCacheDirectory({ name: "prettier", create: true }) || os.tmpdir();
+  const cacheFilePath = path9.join(cacheDir, ".prettier-cache");
   return cacheFilePath;
 }
 async function findCacheFileFromOption(cacheLocation) {
-  const cacheFile = path8.resolve(cacheLocation);
+  const cacheFile = path9.resolve(cacheLocation);
   const stat = await statSafe(cacheFile);
   if (stat) {
     if (stat.isDirectory()) {
@@ -1910,348 +1820,148 @@ import fs7 from "fs";
 // node_modules/file-entry-cache/dist/index.js
 import crypto2 from "crypto";
 import fs6 from "fs";
-import path10 from "path";
+import path11 from "path";
 
 // node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
-import path9 from "path";
+import path10 from "path";
 import fs5 from "fs";
 
 // node_modules/hookified/dist/node/index.js
-var Eventified = class {
+var n = class {
   _eventListeners;
   _maxListeners;
-  constructor() {
-    this._eventListeners = /* @__PURE__ */ new Map();
-    this._maxListeners = 100;
+  _logger;
+  constructor(e) {
+    this._eventListeners = /* @__PURE__ */ new Map(), this._maxListeners = 100, this._logger = e == null ? void 0 : e.logger;
   }
-  /**
-   * 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_);
+  once(e, t) {
+    let s = (...r) => {
+      this.off(e, s), t(...r);
     };
-    this.on(eventName, onceListener);
-    return this;
+    return this.on(e, s), this;
   }
-  /**
-   * Gets the number of listeners for a specific event. If no event is provided, it returns the total number of listeners
-   * @param {string} eventName The event name. Not required
-   * @returns {number} The number of listeners
-   */
-  listenerCount(eventName) {
-    if (!eventName) {
-      return this.getAllListeners().length;
-    }
-    const listeners = this._eventListeners.get(eventName);
-    return listeners ? listeners.length : 0;
+  listenerCount(e) {
+    if (!e) return this.getAllListeners().length;
+    let t = this._eventListeners.get(e);
+    return t ? t.length : 0;
   }
-  /**
-   * Gets an array of event names
-   * @returns {Array<string | symbol>} An array of event names
-   */
   eventNames() {
-    return Array.from(this._eventListeners.keys());
+    return [...this._eventListeners.keys()];
   }
-  /**
-   * Gets an array of listeners for a specific event. If no event is provided, it returns all listeners
-   * @param {string} [event] (Optional) The event name
-   * @returns {EventListener[]} An array of listeners
-   */
-  rawListeners(event) {
-    if (!event) {
-      return this.getAllListeners();
-    }
-    return this._eventListeners.get(event) ?? [];
+  rawListeners(e) {
+    return e ? this._eventListeners.get(e) ?? [] : this.getAllListeners();
   }
-  /**
-   * 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;
+  prependListener(e, t) {
+    let s = this._eventListeners.get(e) ?? [];
+    return s.unshift(t), this._eventListeners.set(e, s), this;
   }
-  /**
-   * Prepends a one-time listener to the beginning of the listeners array for the specified event
-   * @param {string | symbol} eventName
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  prependOnceListener(eventName, listener) {
-    const onceListener = (...arguments_) => {
-      this.off(eventName, onceListener);
-      listener(...arguments_);
+  prependOnceListener(e, t) {
+    let s = (...r) => {
+      this.off(e, s), t(...r);
     };
-    this.prependListener(eventName, onceListener);
-    return this;
+    return this.prependListener(e, s), this;
   }
-  /**
-   * Gets the maximum number of listeners that can be added for a single event
-   * @returns {number} The maximum number of listeners
-   */
   maxListeners() {
     return this._maxListeners;
   }
-  /**
-   * Adds a listener for a specific event. It is an alias for the on() method
-   * @param {string | symbol} event
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  addListener(event, listener) {
-    this.on(event, listener);
-    return this;
+  addListener(e, t) {
+    return this.on(e, t), 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;
+  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;
   }
-  /**
-   * 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;
+  removeListener(e, t) {
+    return this.off(e, t), 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;
+  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;
   }
-  /**
-   * Calls all listeners for a specific event
-   * @param {string | symbol} event
-   * @param arguments_ The arguments to pass to the listeners
-   * @returns {boolean} Returns true if the event had listeners, false otherwise
-   */
-  emit(event, ...arguments_) {
-    let result = false;
-    const listeners = this._eventListeners.get(event);
-    if (listeners && listeners.length > 0) {
-      for (const listener of listeners) {
-        listener(...arguments_);
-        result = true;
-      }
-    }
-    return result;
+  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;
   }
-  /**
-   * 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) ?? [];
+  listeners(e) {
+    return this._eventListeners.get(e) ?? [];
   }
-  /**
-   * Removes all listeners for a specific event. If no event is provided, it removes all listeners
-   * @param {string} [event] (Optional) The event name
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  removeAllListeners(event) {
-    if (event) {
-      this._eventListeners.delete(event);
-    } else {
-      this._eventListeners.clear();
-    }
-    return this;
+  removeAllListeners(e) {
+    return e ? this._eventListeners.delete(e) : this._eventListeners.clear(), 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);
-      }
-    }
+  setMaxListeners(e) {
+    this._maxListeners = e;
+    for (let t of this._eventListeners.values()) t.length > e && t.splice(e);
   }
-  /**
-   * Gets all listeners
-   * @returns {EventListener[]} An array of listeners
-   */
   getAllListeners() {
-    let result = new Array();
-    for (const listeners of this._eventListeners.values()) {
-      result = result.concat(listeners);
-    }
-    return result;
+    let e = new Array();
+    for (let t of this._eventListeners.values()) e = [...e, ...t];
+    return e;
   }
 };
-var Hookified = class extends Eventified {
+var l = class extends n {
   _hooks;
   _throwHookErrors = false;
-  constructor(options) {
-    super();
-    this._hooks = /* @__PURE__ */ new Map();
-    if ((options == null ? void 0 : options.throwHookErrors) !== void 0) {
-      this._throwHookErrors = options.throwHookErrors;
-    }
+  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);
   }
-  /**
-   * Gets all hooks
-   * @returns {Map<string, Hook[]>}
-   */
   get hooks() {
     return this._hooks;
   }
-  /**
-   * Gets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
-   * @returns {boolean}
-   */
   get throwHookErrors() {
     return this._throwHookErrors;
   }
-  /**
-   * Sets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
-   * @param {boolean} value
-   */
-  set throwHookErrors(value) {
-    this._throwHookErrors = value;
+  set throwHookErrors(e) {
+    this._throwHookErrors = e;
   }
-  /**
-   * Adds a handler function for a specific event
-   * @param {string} event
-   * @param {Hook} handler - this can be async or sync
-   * @returns {void}
-   */
-  onHook(event, handler) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      eventHandlers.push(handler);
-    } else {
-      this._hooks.set(event, [handler]);
-    }
+  get logger() {
+    return this._logger;
   }
-  /**
-   * Adds a handler function for a specific event that runs before all other handlers
-   * @param {string} event
-   * @param {Hook} handler - this can be async or sync
-   * @returns {void}
-   */
-  prependHook(event, handler) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      eventHandlers.unshift(handler);
-    } else {
-      this._hooks.set(event, [handler]);
-    }
+  set logger(e) {
+    this._logger = e;
   }
-  /**
-   * Adds a handler that only executes once for a specific event before all other handlers
-   * @param event
-   * @param handler
-   */
-  prependOnceHook(event, handler) {
-    const hook = async (...arguments_) => {
-      this.removeHook(event, hook);
-      return handler(...arguments_);
-    };
-    this.prependHook(event, hook);
+  onHook(e, t) {
+    let s = this._hooks.get(e);
+    s ? s.push(t) : this._hooks.set(e, [t]);
   }
-  /**
-   * Adds a handler that only executes once for a specific event
-   * @param event
-   * @param handler
-   */
-  onceHook(event, handler) {
-    const hook = async (...arguments_) => {
-      this.removeHook(event, hook);
-      return handler(...arguments_);
-    };
-    this.onHook(event, hook);
+  onHooks(e) {
+    for (let t of e) this.onHook(t.event, t.handler);
   }
-  /**
-   * Removes a handler function for a specific event
-   * @param {string} event
-   * @param {Hook} handler
-   * @returns {void}
-   */
-  removeHook(event, handler) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      const index = eventHandlers.indexOf(handler);
-      if (index !== -1) {
-        eventHandlers.splice(index, 1);
-      }
+  prependHook(e, t) {
+    let s = this._hooks.get(e);
+    s ? s.unshift(t) : this._hooks.set(e, [t]);
+  }
+  prependOnceHook(e, t) {
+    let s = async (...r) => (this.removeHook(e, s), t(...r));
+    this.prependHook(e, s);
+  }
+  onceHook(e, t) {
+    let s = async (...r) => (this.removeHook(e, s), t(...r));
+    this.onHook(e, s);
+  }
+  removeHook(e, t) {
+    let s = this._hooks.get(e);
+    if (s) {
+      let r = s.indexOf(t);
+      r !== -1 && s.splice(r, 1);
     }
   }
-  /**
-   * Calls all handlers for a specific event
-   * @param {string} event
-   * @param {T[]} arguments_
-   * @returns {Promise<void>}
-   */
-  async hook(event, ...arguments_) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      for (const handler of eventHandlers) {
-        try {
-          await handler(...arguments_);
-        } catch (error) {
-          const message = `${event}: ${error.message}`;
-          this.emit("error", new Error(message));
-          if (this._throwHookErrors) {
-            throw new Error(message);
-          }
-        }
-      }
+  removeHooks(e) {
+    for (let t of e) this.removeHook(t.event, t.handler);
+  }
+  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);
     }
   }
-  /**
-   * Gets all hooks for a specific event
-   * @param {string} event
-   * @returns {Hook[]}
-   */
-  getHooks(event) {
-    return this._hooks.get(event);
+  getHooks(e) {
+    return this._hooks.get(e);
   }
-  /**
-   * Removes all hooks
-   * @returns {void}
-   */
   clearHooks() {
     this._hooks.clear();
   }
@@ -2334,6 +2044,26 @@ function hash(object2, algorithm = "sha256") {
   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;
+}
+function djb2Hash(string_, min = 0, max = 10) {
+  let hash2 = 5381;
+  for (let i = 0; i < string_.length; i++) {
+    hash2 = hash2 * 33 ^ string_.charCodeAt(i);
+  }
+  const range = max - min + 1;
+  return min + Math.abs(hash2) % range;
+}
 function wrapSync(function_, options) {
   const { ttl, keyPrefix, cache } = options;
   return function(...arguments_) {
@@ -2430,19 +2160,14 @@ var DoublyLinkedList = class {
     return this.nodesMap.size;
   }
 };
-var CacheableMemory = class extends Hookified {
+var defaultStoreHashSize = 16;
+var maximumMapSize = 16777216;
+var CacheableMemory = class extends l {
   _lru = new DoublyLinkedList();
-  _hashCache = /* @__PURE__ */ new Map();
-  _hash0 = /* @__PURE__ */ new Map();
-  _hash1 = /* @__PURE__ */ new Map();
-  _hash2 = /* @__PURE__ */ new Map();
-  _hash3 = /* @__PURE__ */ new Map();
-  _hash4 = /* @__PURE__ */ new Map();
-  _hash5 = /* @__PURE__ */ new Map();
-  _hash6 = /* @__PURE__ */ new Map();
-  _hash7 = /* @__PURE__ */ new Map();
-  _hash8 = /* @__PURE__ */ new Map();
-  _hash9 = /* @__PURE__ */ new Map();
+  _storeHashSize = defaultStoreHashSize;
+  _storeHashAlgorithm = "djb2Hash";
+  // Default is djb2Hash
+  _store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
   _ttl;
   // Turned off by default
   _useClone = true;
@@ -2465,12 +2190,23 @@ var CacheableMemory = class extends Hookified {
     if ((options == null ? void 0 : options.useClone) !== void 0) {
       this._useClone = options.useClone;
     }
+    if ((options == null ? void 0 : options.storeHashSize) && options.storeHashSize > 0) {
+      this._storeHashSize = options.storeHashSize;
+    }
     if (options == null ? void 0 : options.lruSize) {
-      this._lruSize = options.lruSize;
+      if (options.lruSize > maximumMapSize) {
+        this.emit("error", new Error(`LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`));
+      } else {
+        this._lruSize = options.lruSize;
+      }
     }
     if (options == null ? void 0 : options.checkInterval) {
       this._checkInterval = options.checkInterval;
     }
+    if (options == null ? void 0 : options.storeHashAlgorithm) {
+      this._storeHashAlgorithm = options.storeHashAlgorithm;
+    }
+    this._store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
     this.startIntervalCheck();
   }
   /**
@@ -2503,17 +2239,25 @@ var CacheableMemory = class extends Hookified {
   }
   /**
    * Gets the size of the LRU cache
-   * @returns {number} - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0.
+   * @returns {number} - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0. If you are using LRU then the limit is based on Map() size 17mm.
    */
   get lruSize() {
     return this._lruSize;
   }
   /**
    * Sets the size of the LRU cache
-   * @param {number} value - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0.
+   * @param {number} value - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0. If you are using LRU then the limit is based on Map() size 17mm.
    */
   set lruSize(value) {
+    if (value > maximumMapSize) {
+      this.emit("error", new Error(`LRU size cannot be larger than ${maximumMapSize} due to Map limitations.`));
+      return;
+    }
     this._lruSize = value;
+    if (this._lruSize === 0) {
+      this._lru = new DoublyLinkedList();
+      return;
+    }
     this.lruResize();
   }
   /**
@@ -2535,21 +2279,85 @@ var CacheableMemory = class extends Hookified {
    * @returns {number} - The size of the cache
    */
   get size() {
-    return this._hash0.size + this._hash1.size + this._hash2.size + this._hash3.size + this._hash4.size + this._hash5.size + this._hash6.size + this._hash7.size + this._hash8.size + this._hash9.size;
+    let size = 0;
+    for (const store of this._store) {
+      size += store.size;
+    }
+    return size;
+  }
+  /**
+   * Gets the number of hash stores
+   * @returns {number} - The number of hash stores
+   */
+  get storeHashSize() {
+    return this._storeHashSize;
+  }
+  /**
+   * Sets the number of hash stores. This will recreate the store and all data will be cleared
+   * @param {number} value - The number of hash stores
+   */
+  set storeHashSize(value) {
+    if (value === this._storeHashSize) {
+      return;
+    }
+    this._storeHashSize = value;
+    this._store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
+  }
+  /**
+   * Gets the store hash algorithm
+   * @returns {StoreHashAlgorithm | 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
+   */
+  set storeHashAlgorithm(value) {
+    this._storeHashAlgorithm = value;
   }
   /**
    * Gets the keys
    * @returns {IterableIterator<string>} - The keys
    */
   get keys() {
-    return this.concatStores().keys();
+    const keys2 = new Array();
+    for (const store of this._store) {
+      for (const key of store.keys()) {
+        const item = store.get(key);
+        if (item && this.hasExpired(item)) {
+          store.delete(key);
+          continue;
+        }
+        keys2.push(key);
+      }
+    }
+    return keys2.values();
   }
   /**
    * Gets the items
    * @returns {IterableIterator<CacheableStoreItem>} - The items
    */
   get items() {
-    return this.concatStores().values();
+    const items = new Array();
+    for (const store of this._store) {
+      for (const item of store.values()) {
+        if (this.hasExpired(item)) {
+          store.delete(item.key);
+          continue;
+        }
+        items.push(item);
+      }
+    }
+    return items.values();
+  }
+  /**
+   * Gets the store
+   * @returns {Array<Map<string, CacheableStoreItem>>} - The store
+   */
+  get store() {
+    return this._store;
   }
   /**
    * Gets the value of the key
@@ -2562,7 +2370,7 @@ var CacheableMemory = class extends Hookified {
     if (!item) {
       return void 0;
     }
-    if (item.expires && item.expires && Date.now() > item.expires) {
+    if (item.expires && Date.now() > item.expires) {
       store.delete(key);
       return void 0;
     }
@@ -2745,17 +2553,7 @@ var CacheableMemory = class extends Hookified {
    * @returns {void}
    */
   clear() {
-    this._hash0.clear();
-    this._hash1.clear();
-    this._hash2.clear();
-    this._hash3.clear();
-    this._hash4.clear();
-    this._hash5.clear();
-    this._hash6.clear();
-    this._hash7.clear();
-    this._hash8.clear();
-    this._hash9.clear();
-    this._hashCache.clear();
+    this._store = Array.from({ length: this._storeHashSize }, () => /* @__PURE__ */ new Map());
     this._lru = new DoublyLinkedList();
   }
   /**
@@ -2764,66 +2562,28 @@ var CacheableMemory = class extends Hookified {
    * @returns {CacheableHashStore} - The store
    */
   getStore(key) {
-    const hash2 = this.hashKey(key);
-    return this.getStoreFromHash(hash2);
+    var _a;
+    const hash2 = this.getKeyStoreHash(key);
+    (_a = this._store)[hash2] || (_a[hash2] = /* @__PURE__ */ new Map());
+    return this._store[hash2];
   }
   /**
-   * Get the store based on the hash (internal use)
-   * @param {number} hash
-   * @returns {Map<string, CacheableStoreItem>}
+   * Hash the key for which store to go to (internal use)
+   * @param {string} key - The key to hash
+   * Available algorithms are: SHA256, SHA1, MD5, and djb2Hash.
+   * @returns {number} - The hashed key as a number
    */
-  getStoreFromHash(hash2) {
-    switch (hash2) {
-      case 1: {
-        return this._hash1;
-      }
-      case 2: {
-        return this._hash2;
-      }
-      case 3: {
-        return this._hash3;
-      }
-      case 4: {
-        return this._hash4;
-      }
-      case 5: {
-        return this._hash5;
-      }
-      case 6: {
-        return this._hash6;
-      }
-      case 7: {
-        return this._hash7;
-      }
-      case 8: {
-        return this._hash8;
-      }
-      case 9: {
-        return this._hash9;
-      }
-      default: {
-        return this._hash0;
-      }
+  getKeyStoreHash(key) {
+    if (this._store.length === 1) {
+      return 0;
     }
-  }
-  /**
-   * Hash the key (internal use)
-   * @param key
-   * @returns {number} from 0 to 9
-   */
-  hashKey(key) {
-    const cacheHashNumber = this._hashCache.get(key);
-    if (cacheHashNumber) {
-      return cacheHashNumber;
-    }
-    let hash2 = 0;
-    const primeMultiplier = 31;
-    for (let i = 0; i < key.length; i++) {
-      hash2 = hash2 * primeMultiplier + key.charCodeAt(i);
-    }
-    const result = Math.abs(hash2) % 10;
-    this._hashCache.set(key, result);
-    return result;
+    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);
   }
   /**
    * Clone the value. This is for internal use
@@ -2859,13 +2619,10 @@ var CacheableMemory = class extends Hookified {
     this._lru.moveToFront(key);
   }
   /**
-   * Resize the LRU cache. This is for internal use
+   * Resize the LRU cache. This is for internal use.
    * @returns {void}
    */
   lruResize() {
-    if (this._lruSize === 0) {
-      return;
-    }
     while (this._lru.size > this._lruSize) {
       const oldestKey = this._lru.getOldest();
       if (oldestKey) {
@@ -2879,10 +2636,11 @@ var CacheableMemory = class extends Hookified {
    * @returns {void}
    */
   checkExpiration() {
-    const stores = this.concatStores();
-    for (const item of stores.values()) {
-      if (item.expires && Date.now() > item.expires) {
-        this.delete(item.key);
+    for (const store of this._store) {
+      for (const item of store.values()) {
+        if (item.expires && Date.now() > item.expires) {
+          store.delete(item.key);
+        }
       }
     }
   }
@@ -2911,15 +2669,6 @@ var CacheableMemory = class extends Hookified {
     this._interval = 0;
     this._checkInterval = 0;
   }
-  /**
-   * Hash the object. This is for internal use
-   * @param {any} object - The object to hash
-   * @param {string} [algorithm='sha256'] - The algorithm to hash
-   * @returns {string} - The hashed string
-   */
-  hash(object2, algorithm = "sha256") {
-    return hash(object2, algorithm);
-  }
   /**
    * Wrap the function for caching
    * @param {Function} function_ - The function to wrap
@@ -2944,9 +2693,6 @@ var CacheableMemory = class extends Hookified {
     }
     return result;
   }
-  concatStores() {
-    return new Map([...this._hash0, ...this._hash1, ...this._hash2, ...this._hash3, ...this._hash4, ...this._hash5, ...this._hash6, ...this._hash7, ...this._hash8, ...this._hash9]);
-  }
   setTtl(ttl) {
     if (typeof ttl === "string" || ttl === void 0) {
       this._ttl = ttl;
@@ -2956,6 +2702,12 @@ var CacheableMemory = class extends Hookified {
       this._ttl = void 0;
     }
   }
+  hasExpired(item) {
+    if (item.expires && Date.now() > item.expires) {
+      return true;
+    }
+    return false;
+  }
 };
 
 // node_modules/flatted/esm/index.js
@@ -3031,7 +2783,7 @@ var stringify2 = (value, replacer, space) => {
 };
 
 // node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
-var FlatCache = class extends Hookified {
+var FlatCache = class extends l {
   _cache = new CacheableMemory();
   _cacheDir = ".cache";
   _cacheId = "cache1";
@@ -3147,10 +2899,9 @@ var FlatCache = class extends Hookified {
    * @param cacheId {String} the id of the cache, would also be used as the name of the file cache
    * @param cacheDir {String} directory for the cache entry
    */
-  // eslint-disable-next-line unicorn/prevent-abbreviations
   load(cacheId, cacheDir) {
     try {
-      const filePath = path9.resolve(`${cacheDir ?? this._cacheDir}/${cacheId ?? this._cacheId}`);
+      const filePath = path10.resolve(`${cacheDir ?? this._cacheDir}/${cacheId ?? this._cacheId}`);
       this.loadFile(filePath);
       this.emit(
         "load"
@@ -3182,7 +2933,7 @@ var FlatCache = class extends Hookified {
    */
   all() {
     const result = {};
-    const items = Array.from(this._cache.items);
+    const items = [...this._cache.items];
     for (const item of items) {
       result[item.key] = item.value;
     }
@@ -3194,7 +2945,7 @@ var FlatCache = class extends Hookified {
    * @returns {Array}
    */
   get items() {
-    return Array.from(this._cache.items);
+    return [...this._cache.items];
   }
   /**
    * Returns the path to the file where the cache is persisted
@@ -3202,7 +2953,7 @@ var FlatCache = class extends Hookified {
    * @returns {String}
    */
   get cacheFilePath() {
-    return path9.resolve(`${this._cacheDir}/${this._cacheId}`);
+    return path10.resolve(`${this._cacheDir}/${this._cacheId}`);
   }
   /**
    * Returns the path to the cache directory
@@ -3210,7 +2961,7 @@ var FlatCache = class extends Hookified {
    * @returns {String}
    */
   get cacheDirPath() {
-    return path9.resolve(this._cacheDir);
+    return path10.resolve(this._cacheDir);
   }
   /**
    * Returns an array with all the keys in the cache
@@ -3218,7 +2969,7 @@ var FlatCache = class extends Hookified {
    * @returns {Array}
    */
   keys() {
-    return Array.from(this._cache.keys);
+    return [...this._cache.keys];
   }
   /**
    * (Legacy) set key method. This method will be deprecated in the future
@@ -3302,7 +3053,7 @@ var FlatCache = class extends Hookified {
     try {
       if (this._changesSinceLastSave || force) {
         const filePath = this.cacheFilePath;
-        const items = Array.from(this._cache.items);
+        const items = [...this._cache.items];
         const data = this._stringify(items);
         if (!fs5.existsSync(this._cacheDir)) {
           fs5.mkdirSync(this._cacheDir, { recursive: true });
@@ -3392,8 +3143,8 @@ function createFromFile(filePath, options) {
 
 // node_modules/file-entry-cache/dist/index.js
 function createFromFile2(filePath, useCheckSum, currentWorkingDirectory) {
-  const fname = path10.basename(filePath);
-  const directory = path10.dirname(filePath);
+  const fname = path11.basename(filePath);
+  const directory = path11.dirname(filePath);
   return create(fname, directory, useCheckSum, currentWorkingDirectory);
 }
 function create(cacheId, cacheDirectory, useCheckSum, currentWorkingDirectory) {
@@ -3421,12 +3172,20 @@ var FileEntryDefault = class {
 var FileEntryCache = class {
   _cache = new FlatCache({ useClone: false });
   _useCheckSum = false;
+  _useModifiedTime = true;
   _currentWorkingDirectory;
   _hashAlgorithm = "md5";
+  /**
+   * Create a new FileEntryCache instance
+   * @param options - The options for the FileEntryCache
+   */
   constructor(options) {
     if (options == null ? void 0 : options.cache) {
       this._cache = new FlatCache(options.cache);
     }
+    if (options == null ? void 0 : options.useModifiedTime) {
+      this._useModifiedTime = options.useModifiedTime;
+    }
     if (options == null ? void 0 : options.useCheckSum) {
       this._useCheckSum = options.useCheckSum;
     }
@@ -3437,27 +3196,73 @@ var FileEntryCache = class {
       this._hashAlgorithm = options.hashAlgorithm;
     }
   }
+  /**
+   * Get the cache
+   * @returns {FlatCache} The cache
+   */
   get cache() {
     return this._cache;
   }
+  /**
+   * Set the cache
+   * @param {FlatCache} cache - The cache to set
+   */
   set cache(cache) {
     this._cache = cache;
   }
+  /**
+   * Use the hash to check if the file has changed
+   * @returns {boolean} if the hash is used to check if the file has changed
+   */
   get useCheckSum() {
     return this._useCheckSum;
   }
+  /**
+   * Set the useCheckSum value
+   * @param {boolean} value - The value to set
+   */
   set useCheckSum(value) {
     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 useModifiedTime() {
+    return this._useModifiedTime;
+  }
+  /**
+   * Set the useModifiedTime value
+   * @param {boolean} value - The value to set
+   */
+  set useModifiedTime(value) {
+    this._useModifiedTime = value;
+  }
+  /**
+   * Get the hash algorithm
+   * @returns {string} The hash algorithm
+   */
   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 | undefined} The current working directory
+   */
   get currentWorkingDirectory() {
     return this._currentWorkingDirectory;
   }
+  /**
+   * Set the current working directory
+   * @param {string | undefined} value - The value to set
+   */
   set currentWorkingDirectory(value) {
     this._currentWorkingDirectory = value;
   }
@@ -3467,7 +3272,7 @@ var FileEntryCache = class {
    * @param  {Buffer} buffer   buffer to calculate hash on
    * @return {String}          content hash digest
    */
-  // eslint-disable-next-line @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/no-restricted-types
   getHash(buffer) {
     return crypto2.createHash(this._hashAlgorithm).update(buffer).digest("hex");
   }
@@ -3498,7 +3303,7 @@ var FileEntryCache = class {
    * @returns {boolean} if the file path is a relative path, false otherwise
    */
   isRelativePath(filePath) {
-    return !path10.isAbsolute(filePath);
+    return !path11.isAbsolute(filePath);
   }
   /**
   * Delete the cache file from the disk
@@ -3533,7 +3338,7 @@ var FileEntryCache = class {
    * @method reconcile
    */
   reconcile() {
-    const items = this._cache.items;
+    const { items } = this._cache;
     for (const item of items) {
       const fileDescriptor = this.getFileDescriptor(item.key);
       if (fileDescriptor.notFound) {
@@ -3563,6 +3368,7 @@ 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;
     let fstat;
@@ -3574,6 +3380,7 @@ var FileEntryCache = class {
     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;
     try {
       fstat = fs6.statSync(filePath);
       result.meta = {
@@ -3606,7 +3413,10 @@ var FileEntryCache = class {
     if (result.meta.data === void 0) {
       result.meta.data = metaCache.data;
     }
-    if ((metaCache == null ? void 0 : metaCache.mtime) !== ((_a = result.meta) == null ? void 0 : _a.mtime) || (metaCache == null ? void 0 : metaCache.size) !== ((_b = result.meta) == null ? void 0 : _b.size)) {
+    if (useModifiedTimeValue && (metaCache == null ? void 0 : metaCache.mtime) !== ((_a = result.meta) == null ? void 0 : _a.mtime)) {
+      result.changed = true;
+    }
+    if ((metaCache == null ? void 0 : metaCache.size) !== ((_b = result.meta) == null ? void 0 : _b.size)) {
       result.changed = true;
     }
     if (useCheckSumValue && (metaCache == null ? void 0 : metaCache.hash) !== ((_c = result.meta) == null ? void 0 : _c.hash)) {
@@ -3707,7 +3517,7 @@ var FileEntryCache = class {
   getAbsolutePath(filePath, options) {
     if (this.isRelativePath(filePath)) {
       const currentWorkingDirectory = (options == null ? void 0 : options.currentWorkingDirectory) ?? this._currentWorkingDirectory ?? process.cwd();
-      filePath = path10.resolve(currentWorkingDirectory, filePath);
+      filePath = path11.resolve(currentWorkingDirectory, filePath);
     }
     return filePath;
   }
@@ -3747,13 +3557,15 @@ function getHashOfOptions(options) {
 function getMetadataFromFileDescriptor(fileDescriptor) {
   return fileDescriptor.meta;
 }
-var _fileEntryCache;
+var _useChecksum, _fileEntryCache, _FormatResultsCache_instances, getFileDescriptor_fn;
 var FormatResultsCache = class {
   /**
    * @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";
     try {
@@ -3772,6 +3584,7 @@ var FormatResultsCache = class {
         ));
       }
     }
+    __privateSet(this, _useChecksum, useChecksum);
   }
   /**
    * @param {string} filePath
@@ -3779,7 +3592,7 @@ var FormatResultsCache = class {
    */
   existsAvailableFormatResultsCache(filePath, options) {
     var _a;
-    const fileDescriptor = __privateGet(this, _fileEntryCache).getFileDescriptor(filePath);
+    const fileDescriptor = __privateMethod(this, _FormatResultsCache_instances, getFileDescriptor_fn).call(this, filePath);
     if (fileDescriptor.notFound || fileDescriptor.changed) {
       return false;
     }
@@ -3791,7 +3604,7 @@ var FormatResultsCache = class {
    * @param {any} options
    */
   setFormatResultsCache(filePath, options) {
-    const fileDescriptor = __privateGet(this, _fileEntryCache).getFileDescriptor(filePath);
+    const fileDescriptor = __privateMethod(this, _FormatResultsCache_instances, getFileDescriptor_fn).call(this, filePath);
     if (!fileDescriptor.notFound) {
       const meta = getMetadataFromFileDescriptor(fileDescriptor);
       meta.data = { ...meta.data, hashOfOptions: getHashOfOptions(options) };
@@ -3807,20 +3620,290 @@ var FormatResultsCache = class {
     __privateGet(this, _fileEntryCache).reconcile();
   }
 };
+_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;
 
-// src/cli/is-tty.js
-function isTTY() {
-  return process.stdout.isTTY && !mockable.isCI();
+// src/cli/mockable.js
+var import_ci_info = __toESM(require_ci_info(), 1);
+import fs8 from "fs/promises";
+import { performance } from "perf_hooks";
+import { __internal as sharedWithCli3 } from "../index.mjs";
+
+// src/cli/utilities/clear-stream-text.js
+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("|");
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+// node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  return string.replace(regex, "");
+}
+
+// node_modules/wcwidth.js/combining.js
+var combining_default = [
+  [768, 879],
+  [1155, 1158],
+  [1160, 1161],
+  [1425, 1469],
+  [1471, 1471],
+  [1473, 1474],
+  [1476, 1477],
+  [1479, 1479],
+  [1536, 1539],
+  [1552, 1557],
+  [1611, 1630],
+  [1648, 1648],
+  [1750, 1764],
+  [1767, 1768],
+  [1770, 1773],
+  [1807, 1807],
+  [1809, 1809],
+  [1840, 1866],
+  [1958, 1968],
+  [2027, 2035],
+  [2305, 2306],
+  [2364, 2364],
+  [2369, 2376],
+  [2381, 2381],
+  [2385, 2388],
+  [2402, 2403],
+  [2433, 2433],
+  [2492, 2492],
+  [2497, 2500],
+  [2509, 2509],
+  [2530, 2531],
+  [2561, 2562],
+  [2620, 2620],
+  [2625, 2626],
+  [2631, 2632],
+  [2635, 2637],
+  [2672, 2673],
+  [2689, 2690],
+  [2748, 2748],
+  [2753, 2757],
+  [2759, 2760],
+  [2765, 2765],
+  [2786, 2787],
+  [2817, 2817],
+  [2876, 2876],
+  [2879, 2879],
+  [2881, 2883],
+  [2893, 2893],
+  [2902, 2902],
+  [2946, 2946],
+  [3008, 3008],
+  [3021, 3021],
+  [3134, 3136],
+  [3142, 3144],
+  [3146, 3149],
+  [3157, 3158],
+  [3260, 3260],
+  [3263, 3263],
+  [3270, 3270],
+  [3276, 3277],
+  [3298, 3299],
+  [3393, 3395],
+  [3405, 3405],
+  [3530, 3530],
+  [3538, 3540],
+  [3542, 3542],
+  [3633, 3633],
+  [3636, 3642],
+  [3655, 3662],
+  [3761, 3761],
+  [3764, 3769],
+  [3771, 3772],
+  [3784, 3789],
+  [3864, 3865],
+  [3893, 3893],
+  [3895, 3895],
+  [3897, 3897],
+  [3953, 3966],
+  [3968, 3972],
+  [3974, 3975],
+  [3984, 3991],
+  [3993, 4028],
+  [4038, 4038],
+  [4141, 4144],
+  [4146, 4146],
+  [4150, 4151],
+  [4153, 4153],
+  [4184, 4185],
+  [4448, 4607],
+  [4959, 4959],
+  [5906, 5908],
+  [5938, 5940],
+  [5970, 5971],
+  [6002, 6003],
+  [6068, 6069],
+  [6071, 6077],
+  [6086, 6086],
+  [6089, 6099],
+  [6109, 6109],
+  [6155, 6157],
+  [6313, 6313],
+  [6432, 6434],
+  [6439, 6440],
+  [6450, 6450],
+  [6457, 6459],
+  [6679, 6680],
+  [6912, 6915],
+  [6964, 6964],
+  [6966, 6970],
+  [6972, 6972],
+  [6978, 6978],
+  [7019, 7027],
+  [7616, 7626],
+  [7678, 7679],
+  [8203, 8207],
+  [8234, 8238],
+  [8288, 8291],
+  [8298, 8303],
+  [8400, 8431],
+  [12330, 12335],
+  [12441, 12442],
+  [43014, 43014],
+  [43019, 43019],
+  [43045, 43046],
+  [64286, 64286],
+  [65024, 65039],
+  [65056, 65059],
+  [65279, 65279],
+  [65529, 65531],
+  [68097, 68099],
+  [68101, 68102],
+  [68108, 68111],
+  [68152, 68154],
+  [68159, 68159],
+  [119143, 119145],
+  [119155, 119170],
+  [119173, 119179],
+  [119210, 119213],
+  [119362, 119364],
+  [917505, 917505],
+  [917536, 917631],
+  [917760, 917999]
+];
+
+// node_modules/wcwidth.js/index.js
+var DEFAULTS = {
+  nul: 0,
+  control: 0
+};
+function bisearch(ucs) {
+  let min = 0;
+  let max = combining_default.length - 1;
+  let mid;
+  if (ucs < combining_default[0][0] || ucs > combining_default[max][1]) return false;
+  while (max >= min) {
+    mid = Math.floor((min + max) / 2);
+    if (ucs > combining_default[mid][1]) min = mid + 1;
+    else if (ucs < combining_default[mid][0]) max = mid - 1;
+    else return true;
+  }
+  return false;
+}
+function wcwidth(ucs, opts) {
+  if (ucs === 0) return opts.nul;
+  if (ucs < 32 || ucs >= 127 && ucs < 160) return opts.control;
+  if (bisearch(ucs)) return 0;
+  return 1 + (ucs >= 4352 && (ucs <= 4447 || // Hangul Jamo init. consonants
+  ucs == 9001 || ucs == 9002 || ucs >= 11904 && ucs <= 42191 && ucs != 12351 || // CJK ... Yi
+  ucs >= 44032 && ucs <= 55203 || // Hangul Syllables
+  ucs >= 63744 && ucs <= 64255 || // CJK Compatibility Ideographs
+  ucs >= 65040 && ucs <= 65049 || // Vertical forms
+  ucs >= 65072 && ucs <= 65135 || // CJK Compatibility Forms
+  ucs >= 65280 && ucs <= 65376 || // Fullwidth Forms
+  ucs >= 65504 && ucs <= 65510 || ucs >= 131072 && ucs <= 196605 || ucs >= 196608 && ucs <= 262141));
+}
+function wcswidth(str, opts) {
+  let h;
+  let l2;
+  let s = 0;
+  let n2;
+  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;
+      } else {
+        i--;
+      }
+    }
+    n2 = wcwidth(h, opts);
+    if (n2 < 0) return -1;
+    s += n2;
+  }
+  return s;
+}
+var _ = (str) => wcswidth(str, DEFAULTS);
+_.config = (opts = {}) => {
+  opts = {
+    ...DEFAULTS,
+    ...opts
+  };
+  return (str) => wcswidth(str, opts);
+};
+var wcwidth_default = _;
+
+// src/cli/utilities/clear-stream-text.js
+var countLines = (stream, text) => {
+  const columns = stream.columns || 80;
+  let lineCount = 0;
+  for (const line of stripAnsi(text).split("\n")) {
+    lineCount += Math.max(1, Math.ceil(wcwidth_default(line) / columns));
+  }
+  return lineCount;
+};
+function clearStreamText(stream, text) {
+  const lineCount = countLines(stream, text);
+  for (let line = 0; line < lineCount; line++) {
+    if (line > 0) {
+      readline.moveCursor(stream, 0, -1);
+    }
+    readline.clearLine(stream, 0);
+    readline.cursorTo(stream, 0);
+  }
 }
+var clear_stream_text_default = clearStreamText;
+
+// src/cli/mockable.js
+var mockable = sharedWithCli3.utils.createMockable({
+  clearStreamText: clear_stream_text_default,
+  getTimestamp: performance.now.bind(performance),
+  isCI: () => import_ci_info.isCI,
+  isStreamTTY: (stream) => stream.isTTY,
+  writeFormattedFile: (file, data) => fs8.writeFile(file, data)
+});
+var mockable_default = mockable.mocked;
 
 // src/cli/options/get-options-for-file.js
 var import_dashify2 = __toESM(require_dashify(), 1);
 import { resolveConfig } from "../index.mjs";
-function getOptions(argv, detailedOptions) {
+function getOptions(argv2, detailedOptions) {
   return Object.fromEntries(
-    detailedOptions.filter(({ forwardToApi }) => forwardToApi).map(({ forwardToApi, name }) => [forwardToApi, argv[name]])
+    detailedOptions.filter(({ forwardToApi }) => forwardToApi).map(({ forwardToApi, name }) => [forwardToApi, argv2[name]])
   );
 }
 function cliifyOptions(object2, apiDetailedOptionMap) {
@@ -3923,7 +4006,6 @@ async function getOptionsForFile(context, filepath) {
 var get_options_for_file_default = getOptionsForFile;
 
 // src/cli/format.js
-var { getStdin, writeFormattedFile } = mockable;
 function diff(a, b) {
   return createTwoFilesPatch("", "", a, b, "", "", { context: 2 });
 }
@@ -3933,21 +4015,16 @@ var DebugError = class extends Error {
 function handleError(context, filename, error, printedFilename, ignoreUnknown) {
   ignoreUnknown || (ignoreUnknown = context.argv.ignoreUnknown);
   const errorIsUndefinedParseError = error instanceof errors.UndefinedParserError;
-  if (printedFilename) {
-    if ((context.argv.write || ignoreUnknown) && errorIsUndefinedParseError) {
-      printedFilename.clear();
-    } else {
-      process.stdout.write("\n");
-    }
+  if (errorIsUndefinedParseError && ignoreUnknown) {
+    printedFilename == null ? void 0 : printedFilename.clear();
+    return true;
+  }
+  if (printedFilename) {
+    process.stdout.write("\n");
   }
   if (errorIsUndefinedParseError) {
-    if (ignoreUnknown) {
-      return;
-    }
-    if (!context.argv.check && !context.argv.listDifferent) {
-      process.exitCode = 2;
-    }
     context.logger.error(error.message);
+    process.exitCode = 2;
     return;
   }
   const isParseError = Boolean(error == null ? void 0 : error.loc);
@@ -4034,50 +4111,35 @@ async function format3(context, input, opt) {
   }
   const { performanceTestFlag } = context;
   if (performanceTestFlag == null ? void 0 : performanceTestFlag.debugBenchmark) {
-    let benchmark;
+    let Bench;
     try {
-      ({ default: benchmark } = await import("benchmark"));
+      ({ Bench } = await import("tinybench"));
     } catch {
       context.logger.debug(
-        "'--debug-benchmark' requires the 'benchmark' package to be installed."
+        "'--debug-benchmark' requires the 'tinybench' package to be installed."
       );
       process.exit(2);
     }
     context.logger.debug(
-      "'--debug-benchmark' option found, measuring formatWithCursor with 'benchmark' module."
+      "'--debug-benchmark' option found, measuring formatWithCursor with 'tinybench' module."
     );
-    const suite = new benchmark.Suite();
-    suite.add("format", {
-      defer: true,
-      async fn(deferred) {
-        await prettier.formatWithCursor(input, opt);
-        deferred.resolve();
-      }
-    });
-    const result = await new Promise((resolve) => {
-      suite.on("complete", (event) => {
-        resolve({
-          benchmark: String(event.target),
-          hz: event.target.hz,
-          ms: event.target.times.cycle * 1e3
-        });
-      }).run({ async: false });
-    });
+    const bench = new Bench();
+    bench.add("Format", () => prettier.formatWithCursor(input, opt));
+    await bench.run();
+    const [result] = bench.table();
     context.logger.debug(
-      "'--debug-benchmark' measurements for formatWithCursor: " + JSON.stringify(result, null, 2)
+      "'--debug-benchmark' measurements for formatWithCursor: " + JSON.stringify(result, void 0, 2)
     );
   } else if (performanceTestFlag == null ? void 0 : performanceTestFlag.debugRepeat) {
     const repeat = performanceTestFlag.debugRepeat;
     context.logger.debug(
       `'${performanceTestFlag.name}' found, running formatWithCursor ${repeat} times.`
     );
-    let totalMs = 0;
+    const start = mockable_default.getTimestamp();
     for (let i = 0; i < repeat; ++i) {
-      const startMs = Date.now();
       await prettier.formatWithCursor(input, opt);
-      totalMs += Date.now() - startMs;
     }
-    const averageMs = totalMs / repeat;
+    const averageMs = (mockable_default.getTimestamp() - start) / repeat;
     const results = {
       repeat,
       hz: 1e3 / averageMs,
@@ -4108,19 +4170,21 @@ async function formatStdin(context) {
   const { filepath } = context.argv;
   try {
     const input = await getStdin();
+    const absoluteFilepath = filepath ? path12.resolve(filepath) : void 0;
     let isFileIgnored = false;
-    if (filepath) {
+    if (absoluteFilepath) {
       const isIgnored = await createIsIgnoredFromContextOrDie(context);
-      isFileIgnored = isIgnored(filepath);
+      isFileIgnored = isIgnored(absoluteFilepath);
     }
     if (isFileIgnored) {
       writeOutput(context, { formatted: input });
       return;
     }
-    const options = await get_options_for_file_default(
-      context,
-      filepath ? path11.resolve(filepath) : void 0
-    );
+    const options = {
+      ...await get_options_for_file_default(context, absoluteFilepath),
+      // `getOptionsForFile` forwards `--stdin-filepath` directly, which can be a relative path
+      filepath: absoluteFilepath
+    };
     if (await listDifferent(context, input, options, "(stdin)")) {
       return;
     }
@@ -4139,8 +4203,9 @@ async function formatStdin(context) {
 }
 async function formatFiles(context) {
   const isIgnored = await createIsIgnoredFromContextOrDie(context);
-  const cwd2 = process.cwd();
+  const cwd3 = process.cwd();
   let numberOfUnformattedFilesFound = 0;
+  let numberOfFilesWithError = 0;
   const { performanceTestFlag } = context;
   if (context.argv.check && !performanceTestFlag) {
     context.logger.log("Checking formatting...");
@@ -4155,9 +4220,10 @@ async function formatFiles(context) {
   } else if (!context.argv.cacheLocation) {
     const stat = await statSafe(cacheFilePath);
     if (stat) {
-      await fs8.unlink(cacheFilePath);
+      await fs9.unlink(cacheFilePath);
     }
   }
+  const isTTY = mockable_default.isStreamTTY(process.stdout) && !mockable_default.isCI();
   for await (const { error, filename, ignoreUnknown } of expandPatterns(
     context
   )) {
@@ -4174,9 +4240,9 @@ async function formatFiles(context) {
       ...await get_options_for_file_default(context, filename),
       filepath: filename
     };
-    const fileNameToDisplay = normalizeToPosix(path11.relative(cwd2, filename));
+    const fileNameToDisplay = normalizeToPosix(path12.relative(cwd3, filename));
     let printedFilename;
-    if (isTTY()) {
+    if (isTTY) {
       printedFilename = context.logger.log(fileNameToDisplay, {
         newline: false,
         clearable: true
@@ -4184,7 +4250,7 @@ async function formatFiles(context) {
     }
     let input;
     try {
-      input = await fs8.readFile(filename, "utf8");
+      input = await fs9.readFile(filename, "utf8");
     } catch (error2) {
       context.logger.log("");
       context.logger.error(
@@ -4199,7 +4265,7 @@ ${error2.message}`
       writeOutput(context, { formatted: input }, options);
       continue;
     }
-    const start = Date.now();
+    const start = mockable_default.getTimestamp();
     const isCacheExists = formatResultsCache == null ? void 0 : formatResultsCache.existsAvailableFormatResultsCache(
       filename,
       options
@@ -4214,13 +4280,16 @@ ${error2.message}`
       }
       output = result.formatted;
     } catch (error2) {
-      handleError(
+      const errorIsIgnored = handleError(
         context,
         fileNameToDisplay,
         error2,
         printedFilename,
         ignoreUnknown
       );
+      if (!errorIsIgnored) {
+        numberOfFilesWithError += 1;
+      }
       continue;
     }
     const isDifferent = output !== input;
@@ -4233,12 +4302,13 @@ ${error2.message}`
       return;
     }
     if (context.argv.write) {
+      const timeToDisplay = `${Math.round(mockable_default.getTimestamp() - start)}ms`;
       if (isDifferent) {
         if (!context.argv.check && !context.argv.listDifferent) {
-          context.logger.log(`${fileNameToDisplay} ${Date.now() - start}ms`);
+          context.logger.log(`${fileNameToDisplay} ${timeToDisplay}`);
         }
         try {
-          await writeFormattedFile(filename, output);
+          await mockable_default.writeFormattedFile(filename, output);
           shouldSetCache = true;
         } catch (error2) {
           context.logger.error(
@@ -4248,7 +4318,7 @@ ${error2.message}`
           process.exitCode = 2;
         }
       } else if (!context.argv.check && !context.argv.listDifferent) {
-        const message = `${source_default.grey(fileNameToDisplay)} ${Date.now() - start}ms (unchanged)`;
+        const message = `${picocolors.gray(fileNameToDisplay)} ${timeToDisplay} (unchanged)`;
         if (isCacheExists) {
           context.logger.log(`${message} (cached)`);
         } else {
@@ -4280,7 +4350,12 @@ ${error2.message}`
   }
   formatResultsCache == null ? void 0 : formatResultsCache.reconcile();
   if (context.argv.check) {
-    if (numberOfUnformattedFilesFound === 0) {
+    if (numberOfFilesWithError > 0) {
+      const files = numberOfFilesWithError === 1 ? "the above file" : `${numberOfFilesWithError} files`;
+      context.logger.log(
+        `Error occurred when checking code style in ${files}.`
+      );
+    } else if (numberOfUnformattedFilesFound === 0) {
       context.logger.log("All matched files use Prettier code style!");
     } else {
       const files = numberOfUnformattedFilesFound === 1 ? "the above file" : `${numberOfUnformattedFilesFound} files`;
@@ -4295,255 +4370,9 @@ ${error2.message}`
 }
 
 // src/cli/logger.js
-import readline from "readline";
-
-// node_modules/strip-ansi/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("|");
-  return new RegExp(pattern, onlyFirst ? void 0 : "g");
-}
-
-// node_modules/strip-ansi/index.js
-var regex = ansiRegex();
-function stripAnsi(string) {
-  if (typeof string !== "string") {
-    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
-  }
-  return string.replace(regex, "");
-}
-
-// node_modules/wcwidth.js/combining.js
-var combining_default = [
-  [768, 879],
-  [1155, 1158],
-  [1160, 1161],
-  [1425, 1469],
-  [1471, 1471],
-  [1473, 1474],
-  [1476, 1477],
-  [1479, 1479],
-  [1536, 1539],
-  [1552, 1557],
-  [1611, 1630],
-  [1648, 1648],
-  [1750, 1764],
-  [1767, 1768],
-  [1770, 1773],
-  [1807, 1807],
-  [1809, 1809],
-  [1840, 1866],
-  [1958, 1968],
-  [2027, 2035],
-  [2305, 2306],
-  [2364, 2364],
-  [2369, 2376],
-  [2381, 2381],
-  [2385, 2388],
-  [2402, 2403],
-  [2433, 2433],
-  [2492, 2492],
-  [2497, 2500],
-  [2509, 2509],
-  [2530, 2531],
-  [2561, 2562],
-  [2620, 2620],
-  [2625, 2626],
-  [2631, 2632],
-  [2635, 2637],
-  [2672, 2673],
-  [2689, 2690],
-  [2748, 2748],
-  [2753, 2757],
-  [2759, 2760],
-  [2765, 2765],
-  [2786, 2787],
-  [2817, 2817],
-  [2876, 2876],
-  [2879, 2879],
-  [2881, 2883],
-  [2893, 2893],
-  [2902, 2902],
-  [2946, 2946],
-  [3008, 3008],
-  [3021, 3021],
-  [3134, 3136],
-  [3142, 3144],
-  [3146, 3149],
-  [3157, 3158],
-  [3260, 3260],
-  [3263, 3263],
-  [3270, 3270],
-  [3276, 3277],
-  [3298, 3299],
-  [3393, 3395],
-  [3405, 3405],
-  [3530, 3530],
-  [3538, 3540],
-  [3542, 3542],
-  [3633, 3633],
-  [3636, 3642],
-  [3655, 3662],
-  [3761, 3761],
-  [3764, 3769],
-  [3771, 3772],
-  [3784, 3789],
-  [3864, 3865],
-  [3893, 3893],
-  [3895, 3895],
-  [3897, 3897],
-  [3953, 3966],
-  [3968, 3972],
-  [3974, 3975],
-  [3984, 3991],
-  [3993, 4028],
-  [4038, 4038],
-  [4141, 4144],
-  [4146, 4146],
-  [4150, 4151],
-  [4153, 4153],
-  [4184, 4185],
-  [4448, 4607],
-  [4959, 4959],
-  [5906, 5908],
-  [5938, 5940],
-  [5970, 5971],
-  [6002, 6003],
-  [6068, 6069],
-  [6071, 6077],
-  [6086, 6086],
-  [6089, 6099],
-  [6109, 6109],
-  [6155, 6157],
-  [6313, 6313],
-  [6432, 6434],
-  [6439, 6440],
-  [6450, 6450],
-  [6457, 6459],
-  [6679, 6680],
-  [6912, 6915],
-  [6964, 6964],
-  [6966, 6970],
-  [6972, 6972],
-  [6978, 6978],
-  [7019, 7027],
-  [7616, 7626],
-  [7678, 7679],
-  [8203, 8207],
-  [8234, 8238],
-  [8288, 8291],
-  [8298, 8303],
-  [8400, 8431],
-  [12330, 12335],
-  [12441, 12442],
-  [43014, 43014],
-  [43019, 43019],
-  [43045, 43046],
-  [64286, 64286],
-  [65024, 65039],
-  [65056, 65059],
-  [65279, 65279],
-  [65529, 65531],
-  [68097, 68099],
-  [68101, 68102],
-  [68108, 68111],
-  [68152, 68154],
-  [68159, 68159],
-  [119143, 119145],
-  [119155, 119170],
-  [119173, 119179],
-  [119210, 119213],
-  [119362, 119364],
-  [917505, 917505],
-  [917536, 917631],
-  [917760, 917999]
-];
-
-// node_modules/wcwidth.js/index.js
-var DEFAULTS = {
-  nul: 0,
-  control: 0
-};
-function bisearch(ucs) {
-  let min = 0;
-  let max = combining_default.length - 1;
-  let mid;
-  if (ucs < combining_default[0][0] || ucs > combining_default[max][1]) return false;
-  while (max >= min) {
-    mid = Math.floor((min + max) / 2);
-    if (ucs > combining_default[mid][1]) min = mid + 1;
-    else if (ucs < combining_default[mid][0]) max = mid - 1;
-    else return true;
-  }
-  return false;
-}
-function wcwidth(ucs, opts) {
-  if (ucs === 0) return opts.nul;
-  if (ucs < 32 || ucs >= 127 && ucs < 160) return opts.control;
-  if (bisearch(ucs)) return 0;
-  return 1 + (ucs >= 4352 && (ucs <= 4447 || // Hangul Jamo init. consonants
-  ucs == 9001 || ucs == 9002 || ucs >= 11904 && ucs <= 42191 && ucs != 12351 || // CJK ... Yi
-  ucs >= 44032 && ucs <= 55203 || // Hangul Syllables
-  ucs >= 63744 && ucs <= 64255 || // CJK Compatibility Ideographs
-  ucs >= 65040 && ucs <= 65049 || // Vertical forms
-  ucs >= 65072 && ucs <= 65135 || // CJK Compatibility Forms
-  ucs >= 65280 && ucs <= 65376 || // Fullwidth Forms
-  ucs >= 65504 && ucs <= 65510 || ucs >= 131072 && ucs <= 196605 || ucs >= 196608 && ucs <= 262141));
-}
-function wcswidth(str, opts) {
-  let h;
-  let l;
-  let s = 0;
-  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) {
-      l = str.charCodeAt(++i);
-      if (l >= 56320 && l <= 57343) {
-        h = (h - 55296) * 1024 + (l - 56320) + 65536;
-      } else {
-        i--;
-      }
-    }
-    n = wcwidth(h, opts);
-    if (n < 0) return -1;
-    s += n;
-  }
-  return s;
-}
-var _ = (str) => wcswidth(str, DEFAULTS);
-_.config = (opts = {}) => {
-  opts = {
-    ...DEFAULTS,
-    ...opts
-  };
-  return (str) => wcswidth(str, opts);
-};
-var wcwidth_default = _;
-
-// src/cli/logger.js
-var countLines = (stream, text) => {
-  const columns = stream.columns || 80;
-  let lineCount = 0;
-  for (const line of stripAnsi(text).split("\n")) {
-    lineCount += Math.max(1, Math.ceil(wcwidth_default(line) / columns));
-  }
-  return lineCount;
-};
-var clear = (stream, text) => () => {
-  const lineCount = countLines(stream, text);
-  for (let line = 0; line < lineCount; line++) {
-    if (line > 0) {
-      readline.moveCursor(stream, 0, -1);
-    }
-    readline.clearLine(stream, 0);
-    readline.cursorTo(stream, 0);
-  }
-};
+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() {
 } };
 function createLogger(logLevel = "log") {
@@ -4559,8 +4388,8 @@ function createLogger(logLevel = "log") {
       return () => emptyLogResult;
     }
     const stream = process[loggerName === "log" ? "stdout" : "stderr"];
-    const chalkInstance = loggerName === "log" ? source_default : chalkStderr;
-    const prefix = color ? `[${chalkInstance[color](loggerName)}] ` : "";
+    const colors = loggerName === "log" ? picocolors : picocolorsStderr;
+    const prefix = color ? `[${colors[color](loggerName)}] ` : "";
     return (message, options) => {
       options = {
         newline: true,
@@ -4577,7 +4406,7 @@ function createLogger(logLevel = "log") {
       stream.write(message);
       if (options.clearable) {
         return {
-          clear: clear(stream, message)
+          clear: () => mockable_default.clearStreamText(stream, message)
         };
       }
     };
@@ -4611,7 +4440,7 @@ var logger_default = createLogger;
 // src/cli/print-support-info.js
 var import_fast_json_stable_stringify3 = __toESM(require_fast_json_stable_stringify(), 1);
 import { format as format4, getSupportInfo as getSupportInfo2 } from "../index.mjs";
-var sortByName = (array2) => array2.sort((a, b) => a.name.localeCompare(b.name));
+var sortByName = (array) => array.sort((a, b) => a.name.localeCompare(b.name));
 async function printSupportInfo() {
   const { languages, options } = await getSupportInfo2();
   const supportInfo = {
@@ -4620,7 +4449,8 @@ async function printSupportInfo() {
       (option) => omit(option, ["cliName", "cliCategory", "cliDescription"])
     )
   };
-  printToScreen(await format4((0, import_fast_json_stable_stringify3.default)(supportInfo), { parser: "json" }));
+  const result = await format4((0, import_fast_json_stable_stringify3.default)(supportInfo), { parser: "json" });
+  printToScreen(result.trim());
 }
 var print_support_info_default = printSupportInfo;
 
@@ -4816,6 +4646,9 @@ async function run(rawArguments = process.argv.slice(2)) {
 }
 async function main(context) {
   context.logger.debug(`normalized argv: ${JSON.stringify(context.argv)}`);
+  if (context.argv.config === false && context.argv.__raw.config !== false || context.argv.config && context.rawArguments.includes("--no-config")) {
+    throw new Error("Cannot use --no-config and --config together.");
+  }
   if (context.argv.check && context.argv.listDifferent) {
     throw new Error("Cannot use --check and --list-different together.");
   }
@@ -4853,7 +4686,7 @@ async function main(context) {
     return;
   }
   const hasFilePatterns = context.filePatterns.length > 0;
-  const useStdin = !hasFilePatterns && (!process.stdin.isTTY || context.argv.filepath);
+  const useStdin = !hasFilePatterns && (!mockable_default.isStreamTTY(process.stdin) || context.argv.filepath);
   if (useStdin) {
     if (context.argv.cache) {
       throw new Error("`--cache` cannot be used when formatting stdin.");
@@ -4869,5 +4702,6 @@ async function main(context) {
   printToScreen(createUsage(context));
 }
 export {
+  mockable,
   run
 };