prettier 3.0.0-alpha.6 → 3.0.0-alpha.8-for-vscode

package/internal/cli.mjs

@@ -193,14 +193,14 @@ var require_clone = __commonJS({
 var require_defaults = __commonJS({
   "node_modules/defaults/index.js"(exports, module) {
     var clone = require_clone();
-    module.exports = function(options2, defaults) {
-      options2 = options2 || {};
+    module.exports = function(options, defaults) {
+      options = options || {};
       Object.keys(defaults).forEach(function(key) {
-        if (typeof options2[key] === "undefined") {
-          options2[key] = clone(defaults[key]);
+        if (typeof options[key] === "undefined") {
+          options[key] = clone(defaults[key]);
         }
       });
-      return options2;
+      return options;
     };
   }
 });
@@ -426,10 +426,10 @@ var require_wcwidth = __commonJS({
 var require_dashify = __commonJS({
   "node_modules/dashify/index.js"(exports, module) {
     "use strict";
-    module.exports = (str, options2) => {
+    module.exports = (str, options) => {
       if (typeof str !== "string")
         throw new TypeError("expected a string");
-      return str.trim().replace(/([a-z])([A-Z])/g, "$1-$2").replace(/\W/g, (m) => /[À-ž]/.test(m) ? m : "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, (m) => options2 && options2.condense ? "-" : m).toLowerCase();
+      return str.trim().replace(/([a-z])([A-Z])/g, "$1-$2").replace(/\W/g, (m) => /[À-ž]/.test(m) ? m : "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, (m) => options && options.condense ? "-" : m).toLowerCase();
     };
   }
 });
@@ -670,13 +670,13 @@ var require_base = __commonJS({
       /*istanbul ignore start*/
       /*istanbul ignore end*/
       diff: function diff2(oldString, newString) {
-        var options2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-        var callback = options2.callback;
-        if (typeof options2 === "function") {
-          callback = options2;
-          options2 = {};
+        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+        var callback = options.callback;
+        if (typeof options === "function") {
+          callback = options;
+          options = {};
         }
-        this.options = options2;
+        this.options = options;
         var self = this;
         function done(value) {
           if (callback) {
@@ -695,8 +695,8 @@ var require_base = __commonJS({
         var newLen = newString.length, oldLen = oldString.length;
         var editLength = 1;
         var maxEditLength = newLen + oldLen;
-        if (options2.maxEditLength) {
-          maxEditLength = Math.min(maxEditLength, options2.maxEditLength);
+        if (options.maxEditLength) {
+          maxEditLength = Math.min(maxEditLength, options.maxEditLength);
         }
         var bestPath = [{
           newPos: -1,
@@ -885,13 +885,13 @@ var require_params = __commonJS({
       value: true
     });
     exports.generateOptions = generateOptions;
-    function generateOptions(options2, defaults) {
-      if (typeof options2 === "function") {
-        defaults.callback = options2;
-      } else if (options2) {
-        for (var name in options2) {
-          if (options2.hasOwnProperty(name)) {
-            defaults[name] = options2[name];
+    function generateOptions(options, defaults) {
+      if (typeof options === "function") {
+        defaults.callback = options;
+      } else if (options) {
+        for (var name in options) {
+          if (options.hasOwnProperty(name)) {
+            defaults[name] = options[name];
           }
         }
       }
@@ -944,7 +944,7 @@ var require_line = __commonJS({
       return lineDiff.diff(oldStr, newStr, callback);
     }
     function diffTrimmedLines(oldStr, newStr, callback) {
-      var options2 = (
+      var options = (
         /*istanbul ignore start*/
         (0, /*istanbul ignore end*/
         /*istanbul ignore start*/
@@ -952,7 +952,7 @@ var require_line = __commonJS({
           ignoreWhitespace: true
         })
       );
-      return lineDiff.diff(oldStr, newStr, options2);
+      return lineDiff.diff(oldStr, newStr, options);
     }
   }
 });
@@ -1004,18 +1004,18 @@ var require_create = __commonJS({
       }
       return arr2;
     }
-    function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options2) {
-      if (!options2) {
-        options2 = {};
+    function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+      if (!options) {
+        options = {};
       }
-      if (typeof options2.context === "undefined") {
-        options2.context = 4;
+      if (typeof options.context === "undefined") {
+        options.context = 4;
       }
       var diff2 = (
         /*istanbul ignore start*/
         (0, /*istanbul ignore end*/
         /*istanbul ignore start*/
-        _line.diffLines)(oldStr, newStr, options2)
+        _line.diffLines)(oldStr, newStr, options)
       );
       if (!diff2) {
         return;
@@ -1041,7 +1041,7 @@ var require_create = __commonJS({
             oldRangeStart = oldLine;
             newRangeStart = newLine;
             if (prev) {
-              curRange = options2.context > 0 ? contextLines(prev.lines.slice(-options2.context)) : [];
+              curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
               oldRangeStart -= curRange.length;
               newRangeStart -= curRange.length;
             }
@@ -1065,7 +1065,7 @@ var require_create = __commonJS({
           }
         } else {
           if (oldRangeStart) {
-            if (lines.length <= options2.context * 2 && i2 < diff2.length - 2) {
+            if (lines.length <= options.context * 2 && i2 < diff2.length - 2) {
               var _curRange2;
               (_curRange2 = /*istanbul ignore end*/
               curRange).push.apply(
@@ -1079,7 +1079,7 @@ var require_create = __commonJS({
               );
             } else {
               var _curRange3;
-              var contextSize = Math.min(lines.length, options2.context);
+              var contextSize = Math.min(lines.length, options.context);
               (_curRange3 = /*istanbul ignore end*/
               curRange).push.apply(
                 /*istanbul ignore start*/
@@ -1097,7 +1097,7 @@ var require_create = __commonJS({
                 newLines: newLine - newRangeStart + contextSize,
                 lines: curRange
               };
-              if (i2 >= diff2.length - 2 && lines.length <= options2.context) {
+              if (i2 >= diff2.length - 2 && lines.length <= options.context) {
                 var oldEOFNewline = /\n$/.test(oldStr);
                 var newEOFNewline = /\n$/.test(newStr);
                 var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;
@@ -1153,11 +1153,11 @@ var require_create = __commonJS({
       }
       return ret.join("\n") + "\n";
     }
-    function createTwoFilesPatch2(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options2) {
-      return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options2));
+    function createTwoFilesPatch2(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+      return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options));
     }
-    function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options2) {
-      return createTwoFilesPatch2(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options2);
+    function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
+      return createTwoFilesPatch2(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
     }
   }
 });
@@ -1860,10 +1860,10 @@ var require_minimatch = __commonJS({
     }
     var slashSplit = /\/+/;
     minimatch.filter = filter;
-    function filter(pattern, options2) {
-      options2 = options2 || {};
+    function filter(pattern, options) {
+      options = options || {};
       return function(p, i, list) {
-        return minimatch(p, pattern, options2);
+        return minimatch(p, pattern, options);
       };
     }
     function ext(a, b) {
@@ -1882,63 +1882,63 @@ var require_minimatch = __commonJS({
         return minimatch;
       }
       var orig = minimatch;
-      var m = function minimatch2(p, pattern, options2) {
-        return orig(p, pattern, ext(def, options2));
+      var m = function minimatch2(p, pattern, options) {
+        return orig(p, pattern, ext(def, options));
       };
-      m.Minimatch = function Minimatch2(pattern, options2) {
-        return new orig.Minimatch(pattern, ext(def, options2));
+      m.Minimatch = function Minimatch2(pattern, options) {
+        return new orig.Minimatch(pattern, ext(def, options));
       };
-      m.Minimatch.defaults = function defaults(options2) {
-        return orig.defaults(ext(def, options2)).Minimatch;
+      m.Minimatch.defaults = function defaults(options) {
+        return orig.defaults(ext(def, options)).Minimatch;
       };
-      m.filter = function filter2(pattern, options2) {
-        return orig.filter(pattern, ext(def, options2));
+      m.filter = function filter2(pattern, options) {
+        return orig.filter(pattern, ext(def, options));
       };
-      m.defaults = function defaults(options2) {
-        return orig.defaults(ext(def, options2));
+      m.defaults = function defaults(options) {
+        return orig.defaults(ext(def, options));
       };
-      m.makeRe = function makeRe2(pattern, options2) {
-        return orig.makeRe(pattern, ext(def, options2));
+      m.makeRe = function makeRe2(pattern, options) {
+        return orig.makeRe(pattern, ext(def, options));
       };
-      m.braceExpand = function braceExpand2(pattern, options2) {
-        return orig.braceExpand(pattern, ext(def, options2));
+      m.braceExpand = function braceExpand2(pattern, options) {
+        return orig.braceExpand(pattern, ext(def, options));
       };
-      m.match = function(list, pattern, options2) {
-        return orig.match(list, pattern, ext(def, options2));
+      m.match = function(list, pattern, options) {
+        return orig.match(list, pattern, ext(def, options));
       };
       return m;
     };
     Minimatch.defaults = function(def) {
       return minimatch.defaults(def).Minimatch;
     };
-    function minimatch(p, pattern, options2) {
+    function minimatch(p, pattern, options) {
       assertValidPattern(pattern);
-      if (!options2)
-        options2 = {};
-      if (!options2.nocomment && pattern.charAt(0) === "#") {
+      if (!options)
+        options = {};
+      if (!options.nocomment && pattern.charAt(0) === "#") {
         return false;
       }
-      return new Minimatch(pattern, options2).match(p);
+      return new Minimatch(pattern, options).match(p);
     }
-    function Minimatch(pattern, options2) {
+    function Minimatch(pattern, options) {
       if (!(this instanceof Minimatch)) {
-        return new Minimatch(pattern, options2);
+        return new Minimatch(pattern, options);
       }
       assertValidPattern(pattern);
-      if (!options2)
-        options2 = {};
+      if (!options)
+        options = {};
       pattern = pattern.trim();
-      if (!options2.allowWindowsEscape && path10.sep !== "/") {
+      if (!options.allowWindowsEscape && path10.sep !== "/") {
         pattern = pattern.split(path10.sep).join("/");
       }
-      this.options = options2;
+      this.options = options;
       this.set = [];
       this.pattern = pattern;
       this.regexp = null;
       this.negate = false;
       this.comment = false;
       this.empty = false;
-      this.partial = !!options2.partial;
+      this.partial = !!options.partial;
       this.make();
     }
     Minimatch.prototype.debug = function() {
@@ -1946,8 +1946,8 @@ var require_minimatch = __commonJS({
     Minimatch.prototype.make = make;
     function make() {
       var pattern = this.pattern;
-      var options2 = this.options;
-      if (!options2.nocomment && pattern.charAt(0) === "#") {
+      var options = this.options;
+      if (!options.nocomment && pattern.charAt(0) === "#") {
         this.comment = true;
         return;
       }
@@ -1957,7 +1957,7 @@ var require_minimatch = __commonJS({
       }
       this.parseNegate();
       var set = this.globSet = this.braceExpand();
-      if (options2.debug)
+      if (options.debug)
         this.debug = function debug() {
           console.error.apply(console, arguments);
         };
@@ -1980,9 +1980,9 @@ var require_minimatch = __commonJS({
     function parseNegate() {
       var pattern = this.pattern;
       var negate = false;
-      var options2 = this.options;
+      var options = this.options;
       var negateOffset = 0;
-      if (options2.nonegate)
+      if (options.nonegate)
         return;
       for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) {
         negate = !negate;
@@ -1992,21 +1992,21 @@ var require_minimatch = __commonJS({
         this.pattern = pattern.substr(negateOffset);
       this.negate = negate;
     }
-    minimatch.braceExpand = function(pattern, options2) {
-      return braceExpand(pattern, options2);
+    minimatch.braceExpand = function(pattern, options) {
+      return braceExpand(pattern, options);
     };
     Minimatch.prototype.braceExpand = braceExpand;
-    function braceExpand(pattern, options2) {
-      if (!options2) {
+    function braceExpand(pattern, options) {
+      if (!options) {
         if (this instanceof Minimatch) {
-          options2 = this.options;
+          options = this.options;
         } else {
-          options2 = {};
+          options = {};
         }
       }
       pattern = typeof pattern === "undefined" ? this.pattern : pattern;
       assertValidPattern(pattern);
-      if (options2.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+      if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
         return [pattern];
       }
       return expand(pattern);
@@ -2024,9 +2024,9 @@ var require_minimatch = __commonJS({
     var SUBPARSE = {};
     function parse(pattern, isSub) {
       assertValidPattern(pattern);
-      var options2 = this.options;
+      var options = this.options;
       if (pattern === "**") {
-        if (!options2.noglobstar)
+        if (!options.noglobstar)
           return GLOBSTAR;
         else
           pattern = "*";
@@ -2034,7 +2034,7 @@ var require_minimatch = __commonJS({
       if (pattern === "")
         return "";
       var re = "";
-      var hasMagic = !!options2.nocase;
+      var hasMagic = !!options.nocase;
       var escaping = false;
       var patternListStack = [];
       var negativeLists = [];
@@ -2042,7 +2042,7 @@ var require_minimatch = __commonJS({
       var inClass = false;
       var reClassStart = -1;
       var classStart = -1;
-      var patternStart = pattern.charAt(0) === "." ? "" : options2.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+      var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
       var self = this;
       function clearStateChar() {
         if (stateChar) {
@@ -2094,7 +2094,7 @@ var require_minimatch = __commonJS({
             self.debug("call clearStateChar %j", stateChar);
             clearStateChar();
             stateChar = c;
-            if (options2.noext)
+            if (options.noext)
               clearStateChar();
             continue;
           case "(":
@@ -2244,7 +2244,7 @@ var require_minimatch = __commonJS({
       if (!hasMagic) {
         return globUnescape(pattern);
       }
-      var flags = options2.nocase ? "i" : "";
+      var flags = options.nocase ? "i" : "";
       try {
         var regExp = new RegExp("^" + re + "$", flags);
       } catch (er) {
@@ -2254,8 +2254,8 @@ var require_minimatch = __commonJS({
       regExp._src = re;
       return regExp;
     }
-    minimatch.makeRe = function(pattern, options2) {
-      return new Minimatch(pattern, options2 || {}).makeRe();
+    minimatch.makeRe = function(pattern, options) {
+      return new Minimatch(pattern, options || {}).makeRe();
     };
     Minimatch.prototype.makeRe = makeRe;
     function makeRe() {
@@ -2266,9 +2266,9 @@ var require_minimatch = __commonJS({
         this.regexp = false;
         return this.regexp;
       }
-      var options2 = this.options;
-      var twoStar = options2.noglobstar ? star : options2.dot ? twoStarDot : twoStarNoDot;
-      var flags = options2.nocase ? "i" : "";
+      var options = this.options;
+      var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+      var flags = options.nocase ? "i" : "";
       var re = set.map(function(pattern) {
         return pattern.map(function(p) {
           return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
@@ -2284,9 +2284,9 @@ var require_minimatch = __commonJS({
       }
       return this.regexp;
     }
-    minimatch.match = function(list, pattern, options2) {
-      options2 = options2 || {};
-      var mm = new Minimatch(pattern, options2);
+    minimatch.match = function(list, pattern, options) {
+      options = options || {};
+      var mm = new Minimatch(pattern, options);
       list = list.filter(function(f) {
         return mm.match(f);
       });
@@ -2305,7 +2305,7 @@ var require_minimatch = __commonJS({
         return f === "";
       if (f === "/" && partial)
         return true;
-      var options2 = this.options;
+      var options = this.options;
       if (path10.sep !== "/") {
         f = f.split(path10.sep).join("/");
       }
@@ -2323,22 +2323,22 @@ var require_minimatch = __commonJS({
       for (i = 0; i < set.length; i++) {
         var pattern = set[i];
         var file = f;
-        if (options2.matchBase && pattern.length === 1) {
+        if (options.matchBase && pattern.length === 1) {
           file = [filename];
         }
         var hit = this.matchOne(file, pattern, partial);
         if (hit) {
-          if (options2.flipNegate)
+          if (options.flipNegate)
             return true;
           return !this.negate;
         }
       }
-      if (options2.flipNegate)
+      if (options.flipNegate)
         return false;
       return this.negate;
     };
     Minimatch.prototype.matchOne = function(file, pattern, partial) {
-      var options2 = this.options;
+      var options = this.options;
       this.debug(
         "matchOne",
         { "this": this, file, pattern }
@@ -2358,7 +2358,7 @@ var require_minimatch = __commonJS({
           if (pr === pl) {
             this.debug("** at the end");
             for (; fi < fl; fi++) {
-              if (file[fi] === "." || file[fi] === ".." || !options2.dot && file[fi].charAt(0) === ".")
+              if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
                 return false;
             }
             return true;
@@ -2370,7 +2370,7 @@ var require_minimatch = __commonJS({
               this.debug("globstar found match!", fr, fl, swallowee);
               return true;
             } else {
-              if (swallowee === "." || swallowee === ".." || !options2.dot && swallowee.charAt(0) === ".") {
+              if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
                 this.debug("dot detected!", file, fr, pattern, pr);
                 break;
               }
@@ -2502,8 +2502,8 @@ var require_common = __commonJS({
     function alphasort(a, b) {
       return a.localeCompare(b, "en");
     }
-    function setupIgnores(self, options2) {
-      self.ignore = options2.ignore || [];
+    function setupIgnores(self, options) {
+      self.ignore = options.ignore || [];
       if (!Array.isArray(self.ignore))
         self.ignore = [self.ignore];
       if (self.ignore.length) {
@@ -2521,60 +2521,60 @@ var require_common = __commonJS({
         gmatcher
       };
     }
-    function setopts(self, pattern, options2) {
-      if (!options2)
-        options2 = {};
-      if (options2.matchBase && -1 === pattern.indexOf("/")) {
-        if (options2.noglobstar) {
+    function setopts(self, pattern, options) {
+      if (!options)
+        options = {};
+      if (options.matchBase && -1 === pattern.indexOf("/")) {
+        if (options.noglobstar) {
           throw new Error("base matching requires globstar");
         }
         pattern = "**/" + pattern;
       }
-      self.silent = !!options2.silent;
+      self.silent = !!options.silent;
       self.pattern = pattern;
-      self.strict = options2.strict !== false;
-      self.realpath = !!options2.realpath;
-      self.realpathCache = options2.realpathCache || /* @__PURE__ */ Object.create(null);
-      self.follow = !!options2.follow;
-      self.dot = !!options2.dot;
-      self.mark = !!options2.mark;
-      self.nodir = !!options2.nodir;
+      self.strict = options.strict !== false;
+      self.realpath = !!options.realpath;
+      self.realpathCache = options.realpathCache || /* @__PURE__ */ Object.create(null);
+      self.follow = !!options.follow;
+      self.dot = !!options.dot;
+      self.mark = !!options.mark;
+      self.nodir = !!options.nodir;
       if (self.nodir)
         self.mark = true;
-      self.sync = !!options2.sync;
-      self.nounique = !!options2.nounique;
-      self.nonull = !!options2.nonull;
-      self.nosort = !!options2.nosort;
-      self.nocase = !!options2.nocase;
-      self.stat = !!options2.stat;
-      self.noprocess = !!options2.noprocess;
-      self.absolute = !!options2.absolute;
-      self.fs = options2.fs || fs6;
-      self.maxLength = options2.maxLength || Infinity;
-      self.cache = options2.cache || /* @__PURE__ */ Object.create(null);
-      self.statCache = options2.statCache || /* @__PURE__ */ Object.create(null);
-      self.symlinks = options2.symlinks || /* @__PURE__ */ Object.create(null);
-      setupIgnores(self, options2);
+      self.sync = !!options.sync;
+      self.nounique = !!options.nounique;
+      self.nonull = !!options.nonull;
+      self.nosort = !!options.nosort;
+      self.nocase = !!options.nocase;
+      self.stat = !!options.stat;
+      self.noprocess = !!options.noprocess;
+      self.absolute = !!options.absolute;
+      self.fs = options.fs || fs6;
+      self.maxLength = options.maxLength || Infinity;
+      self.cache = options.cache || /* @__PURE__ */ Object.create(null);
+      self.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
+      self.symlinks = options.symlinks || /* @__PURE__ */ Object.create(null);
+      setupIgnores(self, options);
       self.changedCwd = false;
       var cwd2 = process.cwd();
-      if (!ownProp(options2, "cwd"))
+      if (!ownProp(options, "cwd"))
         self.cwd = cwd2;
       else {
-        self.cwd = path10.resolve(options2.cwd);
+        self.cwd = path10.resolve(options.cwd);
         self.changedCwd = self.cwd !== cwd2;
       }
-      self.root = options2.root || path10.resolve(self.cwd, "/");
+      self.root = options.root || path10.resolve(self.cwd, "/");
       self.root = path10.resolve(self.root);
       if (process.platform === "win32")
         self.root = self.root.replace(/\\/g, "/");
       self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
       if (process.platform === "win32")
         self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
-      self.nomount = !!options2.nomount;
-      options2.nonegate = true;
-      options2.nocomment = true;
-      options2.allowWindowsEscape = false;
-      self.minimatch = new Minimatch(pattern, options2);
+      self.nomount = !!options.nomount;
+      options.nonegate = true;
+      options.nocomment = true;
+      options.allowWindowsEscape = false;
+      self.minimatch = new Minimatch(pattern, options);
       self.options = self.minimatch.options;
     }
     function finish(self) {
@@ -2693,19 +2693,19 @@ var require_sync = __commonJS({
     var ownProp = common.ownProp;
     var childrenIgnored = common.childrenIgnored;
     var isIgnored = common.isIgnored;
-    function globSync(pattern, options2) {
-      if (typeof options2 === "function" || arguments.length === 3)
+    function globSync(pattern, options) {
+      if (typeof options === "function" || arguments.length === 3)
         throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
-      return new GlobSync(pattern, options2).found;
+      return new GlobSync(pattern, options).found;
     }
-    function GlobSync(pattern, options2) {
+    function GlobSync(pattern, options) {
       if (!pattern)
         throw new Error("must provide pattern");
-      if (typeof options2 === "function" || arguments.length === 3)
+      if (typeof options === "function" || arguments.length === 3)
         throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
       if (!(this instanceof GlobSync))
-        return new GlobSync(pattern, options2);
-      setopts(this, pattern, options2);
+        return new GlobSync(pattern, options);
+      setopts(this, pattern, options);
       if (this.noprocess)
         return this;
       var n = this.minimatch.set.length;
@@ -3171,17 +3171,17 @@ var require_glob = __commonJS({
     var childrenIgnored = common.childrenIgnored;
     var isIgnored = common.isIgnored;
     var once = require_once();
-    function glob(pattern, options2, cb) {
-      if (typeof options2 === "function")
-        cb = options2, options2 = {};
-      if (!options2)
-        options2 = {};
-      if (options2.sync) {
+    function glob(pattern, options, cb) {
+      if (typeof options === "function")
+        cb = options, options = {};
+      if (!options)
+        options = {};
+      if (options.sync) {
         if (cb)
           throw new TypeError("callback provided to sync glob");
-        return globSync(pattern, options2);
+        return globSync(pattern, options);
       }
-      return new Glob(pattern, options2, cb);
+      return new Glob(pattern, options, cb);
     }
     glob.sync = globSync;
     var GlobSync = glob.GlobSync = globSync.GlobSync;
@@ -3198,9 +3198,9 @@ var require_glob = __commonJS({
       return origin;
     }
     glob.hasMagic = function(pattern, options_) {
-      var options2 = extend({}, options_);
-      options2.noprocess = true;
-      var g = new Glob(pattern, options2);
+      var options = extend({}, options_);
+      options.noprocess = true;
+      var g = new Glob(pattern, options);
       var set = g.minimatch.set;
       if (!pattern)
         return false;
@@ -3214,19 +3214,19 @@ var require_glob = __commonJS({
     };
     glob.Glob = Glob;
     inherits(Glob, EE);
-    function Glob(pattern, options2, cb) {
-      if (typeof options2 === "function") {
-        cb = options2;
-        options2 = null;
+    function Glob(pattern, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = null;
       }
-      if (options2 && options2.sync) {
+      if (options && options.sync) {
         if (cb)
           throw new TypeError("callback provided to sync glob");
-        return new GlobSync(pattern, options2);
+        return new GlobSync(pattern, options);
       }
       if (!(this instanceof Glob))
-        return new Glob(pattern, options2, cb);
-      setopts(this, pattern, options2);
+        return new Glob(pattern, options, cb);
+      setopts(this, pattern, options);
       this._didRealPath = false;
       var n = this.minimatch.set.length;
       this.matches = new Array(n);
@@ -3722,7 +3722,7 @@ var require_rimraf = __commonJS({
     };
     var timeout = 0;
     var isWindows = process.platform === "win32";
-    var defaults = (options2) => {
+    var defaults = (options) => {
       const methods = [
         "unlink",
         "chmod",
@@ -3732,32 +3732,32 @@ var require_rimraf = __commonJS({
         "readdir"
       ];
       methods.forEach((m) => {
-        options2[m] = options2[m] || fs6[m];
+        options[m] = options[m] || fs6[m];
         m = m + "Sync";
-        options2[m] = options2[m] || fs6[m];
+        options[m] = options[m] || fs6[m];
       });
-      options2.maxBusyTries = options2.maxBusyTries || 3;
-      options2.emfileWait = options2.emfileWait || 1e3;
-      if (options2.glob === false) {
-        options2.disableGlob = true;
+      options.maxBusyTries = options.maxBusyTries || 3;
+      options.emfileWait = options.emfileWait || 1e3;
+      if (options.glob === false) {
+        options.disableGlob = true;
       }
-      if (options2.disableGlob !== true && glob === void 0) {
+      if (options.disableGlob !== true && glob === void 0) {
         throw Error("glob dependency not found, set `options.disableGlob = true` if intentional");
       }
-      options2.disableGlob = options2.disableGlob || false;
-      options2.glob = options2.glob || defaultGlobOpts;
+      options.disableGlob = options.disableGlob || false;
+      options.glob = options.glob || defaultGlobOpts;
     };
-    var rimraf = (p, options2, cb) => {
-      if (typeof options2 === "function") {
-        cb = options2;
-        options2 = {};
+    var rimraf = (p, options, cb) => {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
       }
       assert(p, "rimraf: missing path");
       assert.equal(typeof p, "string", "rimraf: path should be a string");
       assert.equal(typeof cb, "function", "rimraf: callback function required");
-      assert(options2, "rimraf: invalid options argument provided");
-      assert.equal(typeof options2, "object", "rimraf: options should be object");
-      defaults(options2);
+      assert(options, "rimraf: invalid options argument provided");
+      assert.equal(typeof options, "object", "rimraf: options should be object");
+      defaults(options);
       let busyTries = 0;
       let errState = null;
       let n = 0;
@@ -3775,12 +3775,12 @@ var require_rimraf = __commonJS({
         results.forEach((p2) => {
           const CB = (er2) => {
             if (er2) {
-              if ((er2.code === "EBUSY" || er2.code === "ENOTEMPTY" || er2.code === "EPERM") && busyTries < options2.maxBusyTries) {
+              if ((er2.code === "EBUSY" || er2.code === "ENOTEMPTY" || er2.code === "EPERM") && busyTries < options.maxBusyTries) {
                 busyTries++;
-                return setTimeout(() => rimraf_(p2, options2, CB), busyTries * 100);
+                return setTimeout(() => rimraf_(p2, options, CB), busyTries * 100);
               }
-              if (er2.code === "EMFILE" && timeout < options2.emfileWait) {
-                return setTimeout(() => rimraf_(p2, options2, CB), timeout++);
+              if (er2.code === "EMFILE" && timeout < options.emfileWait) {
+                return setTimeout(() => rimraf_(p2, options, CB), timeout++);
               }
               if (er2.code === "ENOENT")
                 er2 = null;
@@ -3788,64 +3788,64 @@ var require_rimraf = __commonJS({
             timeout = 0;
             next(er2);
           };
-          rimraf_(p2, options2, CB);
+          rimraf_(p2, options, CB);
         });
       };
-      if (options2.disableGlob || !glob.hasMagic(p))
+      if (options.disableGlob || !glob.hasMagic(p))
         return afterGlob(null, [p]);
-      options2.lstat(p, (er, stat) => {
+      options.lstat(p, (er, stat) => {
         if (!er)
           return afterGlob(null, [p]);
-        glob(p, options2.glob, afterGlob);
+        glob(p, options.glob, afterGlob);
       });
     };
-    var rimraf_ = (p, options2, cb) => {
+    var rimraf_ = (p, options, cb) => {
       assert(p);
-      assert(options2);
+      assert(options);
       assert(typeof cb === "function");
-      options2.lstat(p, (er, st) => {
+      options.lstat(p, (er, st) => {
         if (er && er.code === "ENOENT")
           return cb(null);
         if (er && er.code === "EPERM" && isWindows)
-          fixWinEPERM(p, options2, er, cb);
+          fixWinEPERM(p, options, er, cb);
         if (st && st.isDirectory())
-          return rmdir(p, options2, er, cb);
-        options2.unlink(p, (er2) => {
+          return rmdir(p, options, er, cb);
+        options.unlink(p, (er2) => {
           if (er2) {
             if (er2.code === "ENOENT")
               return cb(null);
             if (er2.code === "EPERM")
-              return isWindows ? fixWinEPERM(p, options2, er2, cb) : rmdir(p, options2, er2, cb);
+              return isWindows ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb);
             if (er2.code === "EISDIR")
-              return rmdir(p, options2, er2, cb);
+              return rmdir(p, options, er2, cb);
           }
           return cb(er2);
         });
       });
     };
-    var fixWinEPERM = (p, options2, er, cb) => {
+    var fixWinEPERM = (p, options, er, cb) => {
       assert(p);
-      assert(options2);
+      assert(options);
       assert(typeof cb === "function");
-      options2.chmod(p, 438, (er2) => {
+      options.chmod(p, 438, (er2) => {
         if (er2)
           cb(er2.code === "ENOENT" ? null : er);
         else
-          options2.stat(p, (er3, stats) => {
+          options.stat(p, (er3, stats) => {
             if (er3)
               cb(er3.code === "ENOENT" ? null : er);
             else if (stats.isDirectory())
-              rmdir(p, options2, er, cb);
+              rmdir(p, options, er, cb);
             else
-              options2.unlink(p, cb);
+              options.unlink(p, cb);
           });
       });
     };
-    var fixWinEPERMSync = (p, options2, er) => {
+    var fixWinEPERMSync = (p, options, er) => {
       assert(p);
-      assert(options2);
+      assert(options);
       try {
-        options2.chmodSync(p, 438);
+        options.chmodSync(p, 438);
       } catch (er2) {
         if (er2.code === "ENOENT")
           return;
@@ -3854,7 +3854,7 @@ var require_rimraf = __commonJS({
       }
       let stats;
       try {
-        stats = options2.statSync(p);
+        stats = options.statSync(p);
       } catch (er3) {
         if (er3.code === "ENOENT")
           return;
@@ -3862,62 +3862,62 @@ var require_rimraf = __commonJS({
           throw er;
       }
       if (stats.isDirectory())
-        rmdirSync(p, options2, er);
+        rmdirSync(p, options, er);
       else
-        options2.unlinkSync(p);
+        options.unlinkSync(p);
     };
-    var rmdir = (p, options2, originalEr, cb) => {
+    var rmdir = (p, options, originalEr, cb) => {
       assert(p);
-      assert(options2);
+      assert(options);
       assert(typeof cb === "function");
-      options2.rmdir(p, (er) => {
+      options.rmdir(p, (er) => {
         if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
-          rmkids(p, options2, cb);
+          rmkids(p, options, cb);
         else if (er && er.code === "ENOTDIR")
           cb(originalEr);
         else
           cb(er);
       });
     };
-    var rmkids = (p, options2, cb) => {
+    var rmkids = (p, options, cb) => {
       assert(p);
-      assert(options2);
+      assert(options);
       assert(typeof cb === "function");
-      options2.readdir(p, (er, files) => {
+      options.readdir(p, (er, files) => {
         if (er)
           return cb(er);
         let n = files.length;
         if (n === 0)
-          return options2.rmdir(p, cb);
+          return options.rmdir(p, cb);
         let errState;
         files.forEach((f) => {
-          rimraf(path10.join(p, f), options2, (er2) => {
+          rimraf(path10.join(p, f), options, (er2) => {
             if (errState)
               return;
             if (er2)
               return cb(errState = er2);
             if (--n === 0)
-              options2.rmdir(p, cb);
+              options.rmdir(p, cb);
           });
         });
       });
     };
-    var rimrafSync = (p, options2) => {
-      options2 = options2 || {};
-      defaults(options2);
+    var rimrafSync = (p, options) => {
+      options = options || {};
+      defaults(options);
       assert(p, "rimraf: missing path");
       assert.equal(typeof p, "string", "rimraf: path should be a string");
-      assert(options2, "rimraf: missing options");
-      assert.equal(typeof options2, "object", "rimraf: options should be object");
+      assert(options, "rimraf: missing options");
+      assert.equal(typeof options, "object", "rimraf: options should be object");
       let results;
-      if (options2.disableGlob || !glob.hasMagic(p)) {
+      if (options.disableGlob || !glob.hasMagic(p)) {
         results = [p];
       } else {
         try {
-          options2.lstatSync(p);
+          options.lstatSync(p);
           results = [p];
         } catch (er) {
-          results = glob.sync(p, options2.glob);
+          results = glob.sync(p, options.glob);
         }
       }
       if (!results.length)
@@ -3926,53 +3926,53 @@ var require_rimraf = __commonJS({
         const p2 = results[i];
         let st;
         try {
-          st = options2.lstatSync(p2);
+          st = options.lstatSync(p2);
         } catch (er) {
           if (er.code === "ENOENT")
             return;
           if (er.code === "EPERM" && isWindows)
-            fixWinEPERMSync(p2, options2, er);
+            fixWinEPERMSync(p2, options, er);
         }
         try {
           if (st && st.isDirectory())
-            rmdirSync(p2, options2, null);
+            rmdirSync(p2, options, null);
           else
-            options2.unlinkSync(p2);
+            options.unlinkSync(p2);
         } catch (er) {
           if (er.code === "ENOENT")
             return;
           if (er.code === "EPERM")
-            return isWindows ? fixWinEPERMSync(p2, options2, er) : rmdirSync(p2, options2, er);
+            return isWindows ? fixWinEPERMSync(p2, options, er) : rmdirSync(p2, options, er);
           if (er.code !== "EISDIR")
             throw er;
-          rmdirSync(p2, options2, er);
+          rmdirSync(p2, options, er);
         }
       }
     };
-    var rmdirSync = (p, options2, originalEr) => {
+    var rmdirSync = (p, options, originalEr) => {
       assert(p);
-      assert(options2);
+      assert(options);
       try {
-        options2.rmdirSync(p);
+        options.rmdirSync(p);
       } catch (er) {
         if (er.code === "ENOENT")
           return;
         if (er.code === "ENOTDIR")
           throw originalEr;
         if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
-          rmkidsSync(p, options2);
+          rmkidsSync(p, options);
       }
     };
-    var rmkidsSync = (p, options2) => {
+    var rmkidsSync = (p, options) => {
       assert(p);
-      assert(options2);
-      options2.readdirSync(p).forEach((f) => rimrafSync(path10.join(p, f), options2));
+      assert(options);
+      options.readdirSync(p).forEach((f) => rimrafSync(path10.join(p, f), options));
       const retries = isWindows ? 100 : 1;
       let i = 0;
       do {
         let threw = true;
         try {
-          const ret = options2.rmdirSync(p, options2);
+          const ret = options.rmdirSync(p, options);
           threw = false;
           return ret;
         } finally {
@@ -4816,10 +4816,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
   }
   return min;
 }
-function createSupportsColor(stream, options2 = {}) {
+function createSupportsColor(stream, options = {}) {
   const level = _supportsColor(stream, {
     streamIsTTY: stream && stream.isTTY,
-    ...options2
+    ...options
   });
   return translateLevel(level);
 }
@@ -4871,21 +4871,21 @@ var levelMapping = [
   "ansi16m"
 ];
 var styles2 = /* @__PURE__ */ Object.create(null);
-var applyOptions = (object, options2 = {}) => {
-  if (options2.level && !(Number.isInteger(options2.level) && options2.level >= 0 && options2.level <= 3)) {
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
     throw new Error("The `level` option should be an integer from 0 to 3");
   }
   const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options2.level === void 0 ? colorLevel : options2.level;
+  object.level = options.level === void 0 ? colorLevel : options.level;
 };
-var chalkFactory = (options2) => {
+var chalkFactory = (options) => {
   const chalk2 = (...strings) => strings.join(" ");
-  applyOptions(chalk2, options2);
+  applyOptions(chalk2, options);
   Object.setPrototypeOf(chalk2, createChalk.prototype);
   return chalk2;
 };
-function createChalk(options2) {
-  return chalkFactory(options2);
+function createChalk(options) {
+  return chalkFactory(options);
 }
 Object.setPrototypeOf(createChalk.prototype, Function.prototype);
 for (const [styleName, style] of Object.entries(ansi_styles_default)) {
@@ -5062,11 +5062,11 @@ function createLogger(logLevel = "log") {
     const stream = process[loggerName === "log" ? "stdout" : "stderr"];
     const chalkInstance = loggerName === "log" ? source_default : chalkStderr;
     const prefix = color ? `[${chalkInstance[color](loggerName)}] ` : "";
-    return (message, options2) => {
-      options2 = {
+    return (message, options) => {
+      options = {
         newline: true,
         clearable: false,
-        ...options2
+        ...options
       };
       message = string_replace_all_default(
         /* isOptionalObject*/
@@ -5074,9 +5074,9 @@ function createLogger(logLevel = "log") {
         message,
         /^/gm,
         prefix
-      ) + (options2.newline ? "\n" : "");
+      ) + (options.newline ? "\n" : "");
       stream.write(message);
-      if (options2.clearable) {
+      if (options.clearable) {
         return {
           clear: clear(stream, message)
         };
@@ -5111,7 +5111,10 @@ var at = (isOptionalObject, object, index) => {
   if (isOptionalObject && (object === void 0 || object === null)) {
     return;
   }
-  return object.at ? object.at(index) : object[index < 0 ? object.length + index : index];
+  if (Array.isArray(object) || typeof object === "string") {
+    return object[index < 0 ? object.length + index : index];
+  }
+  return object.at(index);
 };
 var at_default = at;
 
@@ -5123,34 +5126,28 @@ import { getSupportInfo } from "../index.mjs";
 import { __internal as sharedWithCli } from "../index.mjs";
 var {
   errors,
-  coreOptions,
+  optionCategories,
   createIsIgnoredFunction,
   formatOptionsHiddenDefaults,
   normalizeOptions,
   getSupportInfoWithoutPlugins,
+  normalizeOptionSettings,
   vnopts,
   fastGlob
 } = sharedWithCli;
 
-// src/cli/constants.evaluate.js
-var categoryOrder = [
-  "Output",
-  "Format",
-  "Config",
-  "Editor",
-  "Other"
-];
-var options = {
+// src/cli/cli-options.evaluate.js
+var cli_options_evaluate_default = {
   "cache": {
     "default": false,
     "description": "Only format changed files. Cannot use with --stdin-filepath.",
     "type": "boolean"
   },
-  "cache-location": {
+  "cacheLocation": {
     "description": "Path to the cache file.",
     "type": "path"
   },
-  "cache-strategy": {
+  "cacheStrategy": {
     "choices": [
       {
         "description": "Use the file metadata such as timestamps as cache keys",
@@ -5183,7 +5180,7 @@ var options = {
     "oppositeDescription": "Do not look for a configuration file.",
     "type": "path"
   },
-  "config-precedence": {
+  "configPrecedence": {
     "category": "Config",
     "choices": [
       {
@@ -5203,22 +5200,22 @@ var options = {
     "description": "Define in which order config files and CLI options should be evaluated.",
     "type": "choice"
   },
-  "debug-benchmark": {
+  "debugBenchmark": {
     "type": "boolean"
   },
-  "debug-check": {
+  "debugCheck": {
     "type": "boolean"
   },
-  "debug-print-ast": {
+  "debugPrintAst": {
     "type": "boolean"
   },
-  "debug-print-comments": {
+  "debugPrintComments": {
     "type": "boolean"
   },
-  "debug-print-doc": {
+  "debugPrintDoc": {
     "type": "boolean"
   },
-  "debug-repeat": {
+  "debugRepeat": {
     "default": 0,
     "type": "int"
   },
@@ -5229,15 +5226,15 @@ var options = {
     "oppositeDescription": "Don't take .editorconfig into account when parsing configuration.",
     "type": "boolean"
   },
-  "error-on-unmatched-pattern": {
+  "errorOnUnmatchedPattern": {
     "oppositeDescription": "Prevent errors when pattern is unmatched.",
     "type": "boolean"
   },
-  "file-info": {
+  "fileInfo": {
     "description": "Extract the following info (as JSON) for a given file path. Reported fields:\n* ignored (boolean) - true if file path is filtered by --ignore-path\n* inferredParser (string | null) - name of parser inferred from file path",
     "type": "path"
   },
-  "find-config-path": {
+  "findConfigPath": {
     "category": "Config",
     "description": "Find and print the path to a configuration file for the given input file.",
     "type": "path"
@@ -5248,24 +5245,31 @@ var options = {
     "exception": (value) => value === "",
     "type": "flag"
   },
-  "ignore-path": {
+  "ignorePath": {
+    "array": true,
     "category": "Config",
-    "default": ".prettierignore",
-    "description": "Path to a file with patterns describing files to ignore.",
+    "default": [
+      {
+        "value": [
+          ".prettierignore"
+        ]
+      }
+    ],
+    "description": "Path to a file with patterns describing files to ignore.\nMultiple values are accepted.",
     "type": "path"
   },
-  "ignore-unknown": {
+  "ignoreUnknown": {
     "alias": "u",
     "description": "Ignore unknown files.",
     "type": "boolean"
   },
-  "list-different": {
+  "listDifferent": {
     "alias": "l",
     "category": "Output",
     "description": "Print the names of files that are different from Prettier's formatting (see also --check).",
     "type": "boolean"
   },
-  "log-level": {
+  "logLevel": {
     "choices": [
       "silent",
       "error",
@@ -5277,11 +5281,11 @@ var options = {
     "description": "What level of logs to report.",
     "type": "choice"
   },
-  "plugin-search": {
+  "pluginSearch": {
     "oppositeDescription": "Disable plugin autoloading.",
     "type": "boolean"
   },
-  "support-info": {
+  "supportInfo": {
     "description": "Print support information as JSON.",
     "type": "boolean"
   },
@@ -5290,7 +5294,7 @@ var options = {
     "description": "Print Prettier version.",
     "type": "boolean"
   },
-  "with-node-modules": {
+  "withNodeModules": {
     "category": "Config",
     "description": "Process files inside 'node_modules' directory.",
     "type": "boolean"
@@ -5302,83 +5306,16 @@ var options = {
     "type": "boolean"
   }
 };
-var usageSummary = "Usage: prettier [options] [file/dir/glob ...]\n\nBy default, output is written to stdout.\nStdin is read if it is piped to Prettier and no files are given.";
-
-// src/cli/utils.js
-import fs from "fs/promises";
-import path from "path";
-
-// node_modules/sdbm/index.js
-function sdbm(string) {
-  let hash = 0;
-  for (let i = 0; i < string.length; i++) {
-    hash = string.charCodeAt(i) + (hash << 6) + (hash << 16) - hash;
-  }
-  return hash >>> 0;
-}
-
-// src/cli/utils.js
-import { __internal as sharedWithCli2 } from "../index.mjs";
-var {
-  arrayify,
-  isNonEmptyArray,
-  partition
-} = sharedWithCli2.utils;
-var printToScreen = console.log.bind(console);
-function groupBy(array2, iteratee) {
-  const result = /* @__PURE__ */ Object.create(null);
-  for (const value of array2) {
-    const key = iteratee(value);
-    if (Array.isArray(result[key])) {
-      result[key].push(value);
-    } else {
-      result[key] = [value];
-    }
-  }
-  return result;
-}
-function pick(object, keys) {
-  const entries = keys.map((key) => [key, object[key]]);
-  return Object.fromEntries(entries);
-}
-function createHash(source) {
-  return String(sdbm(source));
-}
-async function statSafe(filePath) {
-  try {
-    return await fs.stat(filePath);
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-}
-function isJson(value) {
-  try {
-    JSON.parse(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var normalizeToPosix = path.sep === "\\" ? (filepath) => string_replace_all_default(
-  /* isOptionalObject*/
-  false,
-  filepath,
-  "\\",
-  "/"
-) : (filepath) => filepath;
 
 // src/cli/options/get-context-options.js
-var detailedCliOptions = arrayify(options, "name").map(
+var detailedCliOptions = normalizeOptionSettings(cli_options_evaluate_default).map(
   (option) => normalizeDetailedOption(option)
 );
 function apiOptionToCliOption(apiOption) {
   const cliOption = {
     ...apiOption,
-    name: apiOption.cliName || (0, import_dashify.default)(apiOption.name),
-    description: apiOption.cliDescription || apiOption.description,
-    category: apiOption.cliCategory || coreOptions.CATEGORY_FORMAT,
+    description: apiOption.cliDescription ?? apiOption.description,
+    category: apiOption.cliCategory ?? optionCategories.CATEGORY_FORMAT,
     forwardToApi: apiOption.name
   };
   if (apiOption.deprecated) {
@@ -5392,8 +5329,9 @@ function apiOptionToCliOption(apiOption) {
 function normalizeDetailedOption(option) {
   var _a;
   return {
-    category: coreOptions.CATEGORY_OTHER,
+    category: optionCategories.CATEGORY_OTHER,
     ...option,
+    name: option.cliName ?? (0, import_dashify.default)(option.name),
     choices: (_a = option.choices) == null ? void 0 : _a.map((choice) => {
       const newChoice = {
         description: "",
@@ -5421,14 +5359,13 @@ function supportInfoToContextOptions({ options: supportOptions, languages }) {
 async function getContextOptions(plugins, pluginSearchDirs) {
   const supportInfo = await getSupportInfo({
     showDeprecated: true,
-    showInternal: true,
     plugins,
     pluginSearchDirs
   });
   return supportInfoToContextOptions(supportInfo);
 }
 function getContextOptionsWithoutPlugins() {
-  const supportInfo = getSupportInfoWithoutPlugins({ showInternal: true });
+  const supportInfo = getSupportInfoWithoutPlugins();
   return supportInfoToContextOptions(supportInfo);
 }
 
@@ -5477,14 +5414,14 @@ var postProcess = (input, toUpperCase) => {
   NUMBERS_AND_IDENTIFIER.lastIndex = 0;
   return input.replace(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier)).replace(NUMBERS_AND_IDENTIFIER, (m) => toUpperCase(m));
 };
-function camelCase(input, options2) {
+function camelCase(input, options) {
   if (!(typeof input === "string" || Array.isArray(input))) {
     throw new TypeError("Expected the input to be `string | string[]`");
   }
-  options2 = {
+  options = {
     pascalCase: false,
     preserveConsecutiveUppercase: false,
-    ...options2
+    ...options
   };
   if (Array.isArray(input)) {
     input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
@@ -5494,32 +5431,97 @@ function camelCase(input, options2) {
   if (input.length === 0) {
     return "";
   }
-  const toLowerCase = options2.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options2.locale);
-  const toUpperCase = options2.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options2.locale);
+  const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
+  const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
   if (input.length === 1) {
     if (SEPARATORS.test(input)) {
       return "";
     }
-    return options2.pascalCase ? toUpperCase(input) : toLowerCase(input);
+    return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
   }
   const hasUpperCase = input !== toLowerCase(input);
   if (hasUpperCase) {
-    input = preserveCamelCase(input, toLowerCase, toUpperCase, options2.preserveConsecutiveUppercase);
+    input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase);
   }
   input = input.replace(LEADING_SEPARATORS, "");
-  input = options2.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
-  if (options2.pascalCase) {
+  input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
+  if (options.pascalCase) {
     input = toUpperCase(input.charAt(0)) + input.slice(1);
   }
   return postProcess(input, toUpperCase);
 }
 
+// src/cli/utils.js
+import fs from "fs/promises";
+import path from "path";
+
+// node_modules/sdbm/index.js
+function sdbm(string) {
+  let hash = 0;
+  for (let i = 0; i < string.length; i++) {
+    hash = string.charCodeAt(i) + (hash << 6) + (hash << 16) - hash;
+  }
+  return hash >>> 0;
+}
+
+// src/cli/utils.js
+import { __internal as sharedWithCli2 } from "../index.mjs";
+var printToScreen = console.log.bind(console);
+function groupBy(array2, iteratee) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const value of array2) {
+    const key = iteratee(value);
+    if (Array.isArray(result[key])) {
+      result[key].push(value);
+    } else {
+      result[key] = [value];
+    }
+  }
+  return result;
+}
+function pick(object, keys) {
+  const entries = keys.map((key) => [key, object[key]]);
+  return Object.fromEntries(entries);
+}
+function createHash(source) {
+  return String(sdbm(source));
+}
+async function statSafe(filePath) {
+  try {
+    return await fs.stat(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+function isJson(value) {
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var normalizeToPosix = path.sep === "\\" ? (filepath) => string_replace_all_default(
+  /* isOptionalObject*/
+  false,
+  filepath,
+  "\\",
+  "/"
+) : (filepath) => filepath;
+var {
+  isNonEmptyArray,
+  partition,
+  omit
+} = sharedWithCli2.utils;
+
 // src/cli/options/minimist.js
 var import_minimist = __toESM(require_minimist(), 1);
 var PLACEHOLDER = null;
-function minimistParse(args, options2) {
-  const boolean = options2.boolean ?? [];
-  const defaults = options2.default ?? {};
+function minimistParse(args, options) {
+  const boolean = options.boolean ?? [];
+  const defaults = options.default ?? {};
   const booleanWithoutDefault = boolean.filter((key) => !(key in defaults));
   const newDefaults = {
     ...defaults,
@@ -5527,7 +5529,7 @@ function minimistParse(args, options2) {
       booleanWithoutDefault.map((key) => [key, PLACEHOLDER])
     )
   };
-  const parsed = (0, import_minimist.default)(args, { ...options2, default: newDefaults });
+  const parsed = (0, import_minimist.default)(args, { ...options, default: newDefaults });
   return Object.fromEntries(
     Object.entries(parsed).filter(([, value]) => value !== PLACEHOLDER)
   );
@@ -5641,8 +5643,8 @@ var FlagSchema = class extends vnopts.ChoiceSchema {
   }
 };
 _flags = new WeakMap();
-function normalizeCliOptions(options2, optionInfos, opts) {
-  return normalizeOptions(options2, optionInfos, {
+function normalizeCliOptions(options, optionInfos, opts) {
+  return normalizeOptions(options, optionInfos, {
     ...opts,
     isCLI: true,
     FlagSchema,
@@ -5719,9 +5721,9 @@ var Context = class {
    * @param {string[]=} pluginSearchDirs
    */
   async pushContextPlugins(plugins, pluginSearchDirs) {
-    const options2 = await getContextOptions(plugins, pluginSearchDirs);
-    __privateGet(this, _stack).push(options2);
-    Object.assign(this, options2);
+    const options = await getContextOptions(plugins, pluginSearchDirs);
+    __privateGet(this, _stack).push(options);
+    Object.assign(this, options);
   }
   popContextPlugins() {
     __privateGet(this, _stack).pop();
@@ -5764,6 +5766,16 @@ var Context = class {
 _stack = new WeakMap();
 var context_default = Context;
 
+// src/cli/constants.evaluate.js
+var categoryOrder = [
+  "Output",
+  "Format",
+  "Config",
+  "Editor",
+  "Other"
+];
+var usageSummary = "Usage: prettier [options] [file/dir/glob ...]\n\nBy default, output is written to stdout.\nStdin is read if it is piped to Prettier and no files are given.";
+
 // src/cli/usage.js
 var OPTION_USAGE_THRESHOLD = 25;
 var CHOICE_USAGE_MARGIN = 3;
@@ -5831,8 +5843,8 @@ function createOptionUsage(context, option, threshold) {
   return createOptionUsageRow(header, `${option.description}${optionDefaultValue === void 0 ? "" : `
 Defaults to ${createDefaultValueDisplay(optionDefaultValue)}.`}`, threshold);
 }
-function getOptionsWithOpposites(options2) {
-  const optionsWithOpposites = options2.map((option) => [option.description ? option : null, option.oppositeDescription ? {
+function getOptionsWithOpposites(options) {
+  const optionsWithOpposites = options.map((option) => [option.description ? option : null, option.oppositeDescription ? {
     ...option,
     name: `no-${option.name}`,
     type: "boolean",
@@ -5842,11 +5854,11 @@ function getOptionsWithOpposites(options2) {
 }
 function createUsage(context) {
   const sortedOptions = context.detailedOptions.sort((optionA, optionB) => optionA.name.localeCompare(optionB.name));
-  const options2 = getOptionsWithOpposites(sortedOptions).filter(
+  const options = getOptionsWithOpposites(sortedOptions).filter(
     // remove unnecessary option (e.g. `semi`, `color`, etc.), which is only used for --help <flag>
     (option) => !(option.type === "boolean" && option.oppositeDescription && !option.name.startsWith("no-"))
   );
-  const groupedOptions = groupBy(options2, (option) => option.category);
+  const groupedOptions = groupBy(options, (option) => option.category);
   const firstCategories = categoryOrder.slice(0, -1);
   const lastCategories = categoryOrder.slice(-1);
   const restCategories = Object.keys(groupedOptions).filter((category) => !categoryOrder.includes(category));
@@ -5892,12 +5904,11 @@ import fs5 from "fs/promises";
 import path8 from "path";
 var import_diff = __toESM(require_create(), 1);
 import * as prettier from "../index.mjs";
-import thirdParty2 from "./third-party.mjs";
+import mockable2 from "./internal.mjs";
 
 // src/cli/expand-patterns.js
 import path2 from "path";
 async function* expandPatterns(context) {
-  const cwd2 = process.cwd();
   const seen = /* @__PURE__ */ new Set();
   let noResults = true;
   for await (const pathOrError of expandPatternsInternal(context)) {
@@ -5906,12 +5917,12 @@ async function* expandPatterns(context) {
       yield pathOrError;
       continue;
     }
-    const relativePath = path2.relative(cwd2, pathOrError);
-    if (seen.has(relativePath)) {
+    const fileName = path2.resolve(pathOrError);
+    if (seen.has(fileName)) {
       continue;
     }
-    seen.add(relativePath);
-    yield relativePath;
+    seen.add(fileName);
+    yield fileName;
   }
   if (noResults && context.argv.errorOnUnmatchedPattern !== false) {
     yield {
@@ -5974,7 +5985,7 @@ async function* expandPatternsInternal(context) {
       message
     }) {
       yield {
-        error: `${errorMessages.globError[type]}: ${input}
+        error: `${errorMessages.globError[type]}: "${input}".
 ${message}`
       };
       continue;
@@ -6095,28 +6106,29 @@ async function getOptionsOrDie(context, filePath) {
     context.logger.debug(
       context.argv.config ? `load config file from '${context.argv.config}'` : `resolve config from '${filePath}'`
     );
-    const options2 = await resolveConfig(filePath, {
+    const options = await resolveConfig(filePath, {
       editorconfig: context.argv.editorconfig,
       config: context.argv.config
     });
-    context.logger.debug("loaded options `" + JSON.stringify(options2) + "`");
-    return options2;
+    context.logger.debug("loaded options `" + JSON.stringify(options) + "`");
+    return options;
   } catch (error) {
     context.logger.error(
-      `Invalid configuration file \`${filePath}\`: ` + error.message
+      `Invalid configuration for file "${filePath}":
+` + error.message
     );
     process.exit(2);
   }
 }
-function applyConfigPrecedence(context, options2) {
+function applyConfigPrecedence(context, options) {
   try {
     switch (context.argv.configPrecedence) {
       case "cli-override":
-        return parseArgsToOptions(context, options2);
+        return parseArgsToOptions(context, options);
       case "file-override":
-        return { ...parseArgsToOptions(context), ...options2 };
+        return { ...parseArgsToOptions(context), ...options };
       case "prefer-file":
-        return options2 || parseArgsToOptions(context);
+        return options || parseArgsToOptions(context);
     }
   } catch (error) {
     context.logger.error(error.toString());
@@ -6124,16 +6136,16 @@ function applyConfigPrecedence(context, options2) {
   }
 }
 async function getOptionsForFile(context, filepath) {
-  const options2 = await getOptionsOrDie(context, filepath);
-  const hasPlugins = options2 == null ? void 0 : options2.plugins;
+  const options = await getOptionsOrDie(context, filepath);
+  const hasPlugins = options == null ? void 0 : options.plugins;
   if (hasPlugins) {
-    await context.pushContextPlugins(options2.plugins);
+    await context.pushContextPlugins(options.plugins);
   }
   const appliedOptions = {
     filepath,
     ...applyConfigPrecedence(
       context,
-      options2 && normalizeOptions(options2, context.supportOptions, {
+      options && normalizeOptions(options, context.supportOptions, {
         logger: context.logger
       })
     )
@@ -6149,9 +6161,9 @@ async function getOptionsForFile(context, filepath) {
 var get_options_for_file_default = getOptionsForFile;
 
 // src/cli/is-tty.js
-import thirdParty from "./third-party.mjs";
+import mockable from "./internal.mjs";
 function isTTY() {
-  return process.stdout.isTTY && !thirdParty.isCI();
+  return process.stdout.isTTY && !mockable.isCI();
 }
 
 // src/cli/find-cache-file.js
@@ -6269,11 +6281,11 @@ function locatePathSync(paths, {
 // 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, options2 = {}) {
-  let directory = path4.resolve(toPath2(options2.cwd) || "");
+function findUpMultipleSync(name, options = {}) {
+  let directory = path4.resolve(toPath2(options.cwd) || "");
   const { root } = path4.parse(directory);
-  const stopAt = options2.stopAt || root;
-  const limit = options2.limit || Number.POSITIVE_INFINITY;
+  const stopAt = options.stopAt || root;
+  const limit = options.limit || Number.POSITIVE_INFINITY;
   const paths = [name].flat();
   const runMatcher = (locateOptions) => {
     if (typeof name !== "function") {
@@ -6287,7 +6299,7 @@ function findUpMultipleSync(name, options2 = {}) {
   };
   const matches = [];
   while (true) {
-    const foundPath = runMatcher({ ...options2, cwd: directory });
+    const foundPath = runMatcher({ ...options, cwd: directory });
     if (foundPath === findUpStop) {
       break;
     }
@@ -6301,8 +6313,8 @@ function findUpMultipleSync(name, options2 = {}) {
   }
   return matches;
 }
-function findUpSync(name, options2 = {}) {
-  const matches = findUpMultipleSync(name, { ...options2, limit: 1 });
+function findUpSync(name, options = {}) {
+  const matches = findUpMultipleSync(name, { ...options, limit: 1 });
   return matches[0];
 }
 
@@ -6322,11 +6334,11 @@ var isWritable = (path10) => {
     return false;
   }
 };
-function useDirectory(directory, options2) {
-  if (options2.create) {
+function useDirectory(directory, options) {
+  if (options.create) {
     fs3.mkdirSync(directory, { recursive: true });
   }
-  if (options2.thunk) {
+  if (options.thunk) {
     return (...arguments_) => path6.join(directory, ...arguments_);
   }
   return directory;
@@ -6338,13 +6350,13 @@ function getNodeModuleDirectory(directory) {
   }
   return nodeModules;
 }
-function findCacheDirectory(options2 = {}) {
+function findCacheDirectory(options = {}) {
   if (env2.CACHE_DIR && !["true", "false", "1", "0"].includes(env2.CACHE_DIR)) {
-    return useDirectory(path6.join(env2.CACHE_DIR, options2.name), options2);
+    return useDirectory(path6.join(env2.CACHE_DIR, options.name), options);
   }
-  let { cwd: directory = cwd() } = options2;
-  if (options2.files) {
-    directory = (0, import_common_path_prefix.default)(options2.files.map((file) => path6.resolve(directory, file)));
+  let { cwd: directory = cwd() } = options;
+  if (options.files) {
+    directory = (0, import_common_path_prefix.default)(options.files.map((file) => path6.resolve(directory, file)));
   }
   directory = packageDirectorySync({ cwd: directory });
   if (!directory) {
@@ -6354,7 +6366,7 @@ function findCacheDirectory(options2 = {}) {
   if (!nodeModules) {
     return;
   }
-  return useDirectory(path6.join(directory, "node_modules", ".cache", options2.name), options2);
+  return useDirectory(path6.join(directory, "node_modules", ".cache", options.name), options);
 }
 
 // src/cli/find-cache-file.js
@@ -6394,14 +6406,14 @@ var import_fast_json_stable_stringify = __toESM(require_fast_json_stable_stringi
 import { version as prettierVersion } from "../index.mjs";
 var optionsHashCache = /* @__PURE__ */ new WeakMap();
 var nodeVersion = process.version;
-function getHashOfOptions(options2) {
-  if (optionsHashCache.has(options2)) {
-    return optionsHashCache.get(options2);
+function getHashOfOptions(options) {
+  if (optionsHashCache.has(options)) {
+    return optionsHashCache.get(options);
   }
   const hash = createHash(
-    `${prettierVersion}_${nodeVersion}_${(0, import_fast_json_stable_stringify.default)(options2)}`
+    `${prettierVersion}_${nodeVersion}_${(0, import_fast_json_stable_stringify.default)(options)}`
   );
-  optionsHashCache.set(options2, hash);
+  optionsHashCache.set(options, hash);
   return hash;
 }
 function getMetadataFromFileDescriptor(fileDescriptor) {
@@ -6428,12 +6440,12 @@ var FormatResultsCache = class {
    * @param {string} filePath
    * @param {any} options
    */
-  existsAvailableFormatResultsCache(filePath, options2) {
+  existsAvailableFormatResultsCache(filePath, options) {
     const fileDescriptor = __privateGet(this, _fileEntryCache).getFileDescriptor(filePath);
     if (fileDescriptor.notFound) {
       return false;
     }
-    const hashOfOptions = getHashOfOptions(options2);
+    const hashOfOptions = getHashOfOptions(options);
     const meta = getMetadataFromFileDescriptor(fileDescriptor);
     const changed = fileDescriptor.changed || meta.hashOfOptions !== hashOfOptions;
     return !changed;
@@ -6442,11 +6454,11 @@ var FormatResultsCache = class {
    * @param {string} filePath
    * @param {any} options
    */
-  setFormatResultsCache(filePath, options2) {
+  setFormatResultsCache(filePath, options) {
     const fileDescriptor = __privateGet(this, _fileEntryCache).getFileDescriptor(filePath);
     const meta = getMetadataFromFileDescriptor(fileDescriptor);
     if (fileDescriptor && !fileDescriptor.notFound) {
-      meta.hashOfOptions = getHashOfOptions(options2);
+      meta.hashOfOptions = getHashOfOptions(options);
     }
   }
   /**
@@ -6463,10 +6475,12 @@ _fileEntryCache = new WeakMap();
 var format_results_cache_default = FormatResultsCache;
 
 // src/cli/format.js
-var { getStdin } = thirdParty2;
+var { getStdin, writeFormattedFile } = mockable2;
 function diff(a, b) {
   return (0, import_diff.createTwoFilesPatch)("", "", a, b, "", "", { context: 2 });
 }
+var DebugError = class extends Error {
+};
 function handleError(context, filename, error, printedFilename) {
   if (error instanceof errors.UndefinedParserError) {
     if ((context.argv.write || context.argv.ignoreUnknown) && printedFilename) {
@@ -6491,32 +6505,27 @@ function handleError(context, filename, error, printedFilename) {
   } else if (isValidationError || error instanceof errors.ConfigError) {
     context.logger.error(error.message);
     process.exit(1);
-  } else if (error instanceof errors.DebugError) {
+  } else if (error instanceof DebugError) {
     context.logger.error(`${filename}: ${error.message}`);
   } else {
     context.logger.error(filename + ": " + (error.stack || error));
   }
   process.exitCode = 2;
 }
-function writeOutput(context, result, options2) {
+function writeOutput(context, result, options) {
   process.stdout.write(
     context.argv.debugCheck ? result.filepath : result.formatted
   );
-  if (options2 && options2.cursorOffset >= 0) {
+  if (options && options.cursorOffset >= 0) {
     process.stderr.write(result.cursorOffset + "\n");
   }
 }
-async function listDifferent(context, input, options2, filename) {
+async function listDifferent(context, input, options, filename) {
   if (!context.argv.check && !context.argv.listDifferent) {
     return;
   }
   try {
-    if (!options2.filepath && !options2.parser) {
-      throw new errors.UndefinedParserError(
-        "No parser and no file path given, couldn't infer a parser."
-      );
-    }
-    if (!await prettier.check(input, options2) && !context.argv.write) {
+    if (!await prettier.check(input, options) && !context.argv.write) {
       context.logger.log(filename);
       process.exitCode = 1;
     }
@@ -6526,11 +6535,6 @@ async function listDifferent(context, input, options2, filename) {
   return true;
 }
 async function format2(context, input, opt) {
-  if (!opt.parser && !opt.filepath) {
-    throw new errors.UndefinedParserError(
-      "No parser and no file path given, couldn't infer a parser."
-    );
-  }
   if (context.argv.debugPrintDoc) {
     const doc = await prettier.__debug.printToDoc(input, opt);
     return { formatted: await prettier.__debug.formatDoc(doc) + "\n" };
@@ -6555,7 +6559,7 @@ async function format2(context, input, opt) {
     const pp = await prettier.format(input, opt);
     const pppp = await prettier.format(pp, opt);
     if (pp !== pppp) {
-      throw new errors.DebugError(
+      throw new DebugError(
         "prettier(input) !== prettier(prettier(input))\n" + diff(pp, pppp)
       );
     } else {
@@ -6569,7 +6573,7 @@ async function format2(context, input, opt) {
       if (ast !== past) {
         const MAX_AST_SIZE = 2097152;
         const astDiff = ast.length > MAX_AST_SIZE || past.length > MAX_AST_SIZE ? "AST diff too large to render" : diff(ast, past);
-        throw new errors.DebugError(
+        throw new DebugError(
           "ast(input) !== ast(prettier(input))\n" + astDiff + "\n" + diff(input, pp)
         );
       }
@@ -6611,9 +6615,9 @@ async function format2(context, input, opt) {
       "'--debug-benchmark' measurements for formatWithCursor: " + JSON.stringify(result, null, 2)
     );
   } else if (performanceTestFlag == null ? void 0 : performanceTestFlag.debugRepeat) {
-    const repeat = context.argv.debugRepeat;
+    const repeat = performanceTestFlag.debugRepeat;
     context.logger.debug(
-      "'--debug-repeat' option found, running formatWithCursor " + repeat + " times."
+      `'${performanceTestFlag.name}' found, running formatWithCursor ${repeat} times.`
     );
     let totalMs = 0;
     for (let i = 0; i < repeat; ++i) {
@@ -6628,7 +6632,7 @@ async function format2(context, input, opt) {
       ms: averageMs
     };
     context.logger.debug(
-      "'--debug-repeat' measurements for formatWithCursor: " + JSON.stringify(results, null, 2)
+      `'${performanceTestFlag.name}' measurements for formatWithCursor: ${JSON.stringify(results, null, 2)}`
     );
   }
   return prettier.formatWithCursor(input, opt);
@@ -6657,14 +6661,14 @@ async function formatStdin(context) {
       writeOutput(context, { formatted: input });
       return;
     }
-    const options2 = await get_options_for_file_default(
+    const options = await get_options_for_file_default(
       context,
       filepath ? path8.resolve(process.cwd(), filepath) : process.cwd()
     );
-    if (await listDifferent(context, input, options2, "(stdin)")) {
+    if (await listDifferent(context, input, options, "(stdin)")) {
       return;
     }
-    const formatted = await format2(context, input, options2);
+    const formatted = await format2(context, input, options);
     const { performanceTestFlag } = context;
     if (performanceTestFlag) {
       context.logger.log(
@@ -6672,13 +6676,14 @@ async function formatStdin(context) {
       );
       return;
     }
-    writeOutput(context, formatted, options2);
+    writeOutput(context, formatted, options);
   } catch (error) {
     handleError(context, filepath || "stdin", error);
   }
 }
 async function formatFiles(context) {
   const isIgnored = await createIsIgnoredFromContextOrDie(context);
+  const cwd2 = process.cwd();
   let numberOfUnformattedFilesFound = 0;
   const { performanceTestFlag } = context;
   if (context.argv.check && !performanceTestFlag) {
@@ -6716,13 +6721,14 @@ async function formatFiles(context) {
     if (isFileIgnored && (context.argv.debugCheck || context.argv.write || context.argv.check || context.argv.listDifferent)) {
       continue;
     }
-    const options2 = {
+    const options = {
       ...await get_options_for_file_default(context, filename),
       filepath: filename
     };
+    const fileNameToDisplay = normalizeToPosix(path8.relative(cwd2, filename));
     let printedFilename;
     if (isTTY()) {
-      printedFilename = context.logger.log(normalizeToPosix(filename), {
+      printedFilename = context.logger.log(fileNameToDisplay, {
         newline: false,
         clearable: true
       });
@@ -6733,20 +6739,20 @@ async function formatFiles(context) {
     } catch (error) {
       context.logger.log("");
       context.logger.error(
-        `Unable to read file: ${filename}
+        `Unable to read file "${fileNameToDisplay}":
 ${error.message}`
       );
       process.exitCode = 2;
       continue;
     }
     if (isFileIgnored) {
-      writeOutput(context, { formatted: input }, options2);
+      writeOutput(context, { formatted: input }, options);
       continue;
     }
     const start = Date.now();
     const isCacheExists = formatResultsCache == null ? void 0 : formatResultsCache.existsAvailableFormatResultsCache(
       filename,
-      options2
+      options
     );
     let result;
     let output;
@@ -6754,11 +6760,11 @@ ${error.message}`
       if (isCacheExists) {
         result = { formatted: input };
       } else {
-        result = await format2(context, input, options2);
+        result = await format2(context, input, options);
       }
       output = result.formatted;
     } catch (error) {
-      handleError(context, filename, error, printedFilename);
+      handleError(context, fileNameToDisplay, error, printedFilename);
       continue;
     }
     const isDifferent = output !== input;
@@ -6775,22 +6781,20 @@ ${error.message}`
     if (context.argv.write) {
       if (isDifferent) {
         if (!context.argv.check && !context.argv.listDifferent) {
-          context.logger.log(
-            `${normalizeToPosix(filename)} ${Date.now() - start}ms`
-          );
+          context.logger.log(`${fileNameToDisplay} ${Date.now() - start}ms`);
         }
         try {
-          await fs5.writeFile(filename, output, "utf8");
+          await writeFormattedFile(filename, output);
           shouldSetCache = true;
         } catch (error) {
           context.logger.error(
-            `Unable to write file: ${filename}
+            `Unable to write file "${fileNameToDisplay}":
 ${error.message}`
           );
           process.exitCode = 2;
         }
       } else if (!context.argv.check && !context.argv.listDifferent) {
-        const message = `${source_default.grey(normalizeToPosix(filename))} ${Date.now() - start}ms`;
+        const message = `${source_default.grey(fileNameToDisplay)} ${Date.now() - start}ms`;
         if (isCacheExists) {
           context.logger.log(`${message} (cached)`);
         } else {
@@ -6799,23 +6803,23 @@ ${error.message}`
       }
     } else if (context.argv.debugCheck) {
       if (result.filepath) {
-        context.logger.log(normalizeToPosix(result.filepath));
+        context.logger.log(fileNameToDisplay);
       } else {
         process.exitCode = 2;
       }
     } else if (!context.argv.check && !context.argv.listDifferent) {
-      writeOutput(context, result, options2);
+      writeOutput(context, result, options);
     }
     if (shouldSetCache) {
-      formatResultsCache == null ? void 0 : formatResultsCache.setFormatResultsCache(filename, options2);
+      formatResultsCache == null ? void 0 : formatResultsCache.setFormatResultsCache(filename, options);
     } else {
       formatResultsCache == null ? void 0 : formatResultsCache.removeFormatResultsCache(filename);
     }
     if (isDifferent) {
       if (context.argv.check) {
-        context.logger.warn(normalizeToPosix(filename));
+        context.logger.warn(fileNameToDisplay);
       } else if (context.argv.listDifferent) {
-        context.logger.log(normalizeToPosix(filename));
+        context.logger.log(fileNameToDisplay);
       }
       numberOfUnformattedFilesFound += 1;
     }
@@ -6866,9 +6870,9 @@ async function logResolvedConfigPathOrDie(context) {
   const file = context.argv.findConfigPath;
   const configFile = await resolveConfigFile(file);
   if (configFile) {
-    printToScreen(path9.relative(process.cwd(), configFile));
+    printToScreen(normalizeToPosix(path9.relative(process.cwd(), configFile)));
   } else {
-    throw new Error(`Can not find configure file for "${file}"`);
+    throw new Error(`Can not find configure file for "${file}".`);
   }
 }
 var find_config_path_default = logResolvedConfigPathOrDie;
@@ -6876,11 +6880,15 @@ var find_config_path_default = logResolvedConfigPathOrDie;
 // src/cli/print-support-info.js
 var import_fast_json_stable_stringify3 = __toESM(require_fast_json_stable_stringify(), 1);
 import { getSupportInfo as getSupportInfo2, format as format4 } from "../index.mjs";
+var sortByName = (array2) => array2.sort((a, b) => a.name.localeCompare(b.name));
 async function printSupportInfo() {
-  const supportInfo = await getSupportInfo2();
-  supportInfo.languages.sort(
-    (languageA, languageB) => (languageA.name ?? "").toLowerCase().localeCompare(languageB.name ?? "")
-  );
+  const { languages, options } = await getSupportInfo2();
+  const supportInfo = {
+    languages: sortByName(languages),
+    options: sortByName(options).map(
+      (option) => omit(option, ["cliName", "cliCategory", "cliDescription"])
+    )
+  };
   printToScreen(await format4((0, import_fast_json_stable_stringify3.default)(supportInfo), { parser: "json" }));
 }
 var print_support_info_default = printSupportInfo;