prettier 3.0.1 → 3.0.3

package/internal/cli.mjs

@@ -1197,6 +1197,264 @@ var require_common_path_prefix = __commonJS({
   }
 });
 
+// node_modules/json-buffer/index.js
+var require_json_buffer = __commonJS({
+  "node_modules/json-buffer/index.js"(exports) {
+    exports.stringify = function stringify4(o) {
+      if ("undefined" == typeof o)
+        return o;
+      if (o && Buffer.isBuffer(o))
+        return JSON.stringify(":base64:" + o.toString("base64"));
+      if (o && o.toJSON)
+        o = o.toJSON();
+      if (o && "object" === typeof o) {
+        var s = "";
+        var array2 = Array.isArray(o);
+        s = array2 ? "[" : "{";
+        var first = true;
+        for (var k in o) {
+          var ignore = "function" == typeof o[k] || !array2 && "undefined" === typeof o[k];
+          if (Object.hasOwnProperty.call(o, k) && !ignore) {
+            if (!first)
+              s += ",";
+            first = false;
+            if (array2) {
+              if (o[k] == void 0)
+                s += "null";
+              else
+                s += stringify4(o[k]);
+            } else if (o[k] !== void 0) {
+              s += stringify4(k) + ":" + stringify4(o[k]);
+            }
+          }
+        }
+        s += array2 ? "]" : "}";
+        return s;
+      } else if ("string" === typeof o) {
+        return JSON.stringify(/^:/.test(o) ? ":" + o : o);
+      } else if ("undefined" === typeof o) {
+        return "null";
+      } else
+        return JSON.stringify(o);
+    };
+    exports.parse = function(s) {
+      return JSON.parse(s, function(key, value) {
+        if ("string" === typeof value) {
+          if (/^:base64:/.test(value))
+            return Buffer.from(value.substring(8), "base64");
+          else
+            return /^:/.test(value) ? value.substring(1) : value;
+        }
+        return value;
+      });
+    };
+  }
+});
+
+// node_modules/keyv/src/index.js
+var require_src = __commonJS({
+  "node_modules/keyv/src/index.js"(exports, module) {
+    "use strict";
+    var EventEmitter = __require("events");
+    var JSONB = require_json_buffer();
+    var loadStore = (options) => {
+      const adapters = {
+        redis: "@keyv/redis",
+        rediss: "@keyv/redis",
+        mongodb: "@keyv/mongo",
+        mongo: "@keyv/mongo",
+        sqlite: "@keyv/sqlite",
+        postgresql: "@keyv/postgres",
+        postgres: "@keyv/postgres",
+        mysql: "@keyv/mysql",
+        etcd: "@keyv/etcd",
+        offline: "@keyv/offline",
+        tiered: "@keyv/tiered"
+      };
+      if (options.adapter || options.uri) {
+        const adapter = options.adapter || /^[^:+]*/.exec(options.uri)[0];
+        return new (__require(adapters[adapter]))(options);
+      }
+      return /* @__PURE__ */ new Map();
+    };
+    var iterableAdapters = [
+      "sqlite",
+      "postgres",
+      "mysql",
+      "mongo",
+      "redis",
+      "tiered"
+    ];
+    var Keyv = class extends EventEmitter {
+      constructor(uri, { emitErrors = true, ...options } = {}) {
+        super();
+        this.opts = {
+          namespace: "keyv",
+          serialize: JSONB.stringify,
+          deserialize: JSONB.parse,
+          ...typeof uri === "string" ? { uri } : uri,
+          ...options
+        };
+        if (!this.opts.store) {
+          const adapterOptions = { ...this.opts };
+          this.opts.store = loadStore(adapterOptions);
+        }
+        if (this.opts.compression) {
+          const compression = this.opts.compression;
+          this.opts.serialize = compression.serialize.bind(compression);
+          this.opts.deserialize = compression.deserialize.bind(compression);
+        }
+        if (typeof this.opts.store.on === "function" && emitErrors) {
+          this.opts.store.on("error", (error) => this.emit("error", error));
+        }
+        this.opts.store.namespace = this.opts.namespace;
+        const generateIterator = (iterator) => async function* () {
+          for await (const [key, raw] of typeof iterator === "function" ? iterator(this.opts.store.namespace) : iterator) {
+            const data = await this.opts.deserialize(raw);
+            if (this.opts.store.namespace && !key.includes(this.opts.store.namespace)) {
+              continue;
+            }
+            if (typeof data.expires === "number" && Date.now() > data.expires) {
+              this.delete(key);
+              continue;
+            }
+            yield [this._getKeyUnprefix(key), data.value];
+          }
+        };
+        if (typeof this.opts.store[Symbol.iterator] === "function" && this.opts.store instanceof Map) {
+          this.iterator = generateIterator(this.opts.store);
+        } else if (typeof this.opts.store.iterator === "function" && this.opts.store.opts && this._checkIterableAdaptar()) {
+          this.iterator = generateIterator(this.opts.store.iterator.bind(this.opts.store));
+        }
+      }
+      _checkIterableAdaptar() {
+        return iterableAdapters.includes(this.opts.store.opts.dialect) || iterableAdapters.findIndex((element) => this.opts.store.opts.url.includes(element)) >= 0;
+      }
+      _getKeyPrefix(key) {
+        return `${this.opts.namespace}:${key}`;
+      }
+      _getKeyPrefixArray(keys) {
+        return keys.map((key) => `${this.opts.namespace}:${key}`);
+      }
+      _getKeyUnprefix(key) {
+        return key.split(":").splice(1).join(":");
+      }
+      get(key, options) {
+        const { store } = this.opts;
+        const isArray = Array.isArray(key);
+        const keyPrefixed = isArray ? this._getKeyPrefixArray(key) : this._getKeyPrefix(key);
+        if (isArray && store.getMany === void 0) {
+          const promises = [];
+          for (const key2 of keyPrefixed) {
+            promises.push(
+              Promise.resolve().then(() => store.get(key2)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => {
+                if (data === void 0 || data === null) {
+                  return void 0;
+                }
+                if (typeof data.expires === "number" && Date.now() > data.expires) {
+                  return this.delete(key2).then(() => void 0);
+                }
+                return options && options.raw ? data : data.value;
+              })
+            );
+          }
+          return Promise.allSettled(promises).then((values) => {
+            const data = [];
+            for (const value of values) {
+              data.push(value.value);
+            }
+            return data;
+          });
+        }
+        return Promise.resolve().then(() => isArray ? store.getMany(keyPrefixed) : store.get(keyPrefixed)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => {
+          if (data === void 0 || data === null) {
+            return void 0;
+          }
+          if (isArray) {
+            const result = [];
+            for (let row of data) {
+              if (typeof row === "string") {
+                row = this.opts.deserialize(row);
+              }
+              if (row === void 0 || row === null) {
+                result.push(void 0);
+                continue;
+              }
+              if (typeof row.expires === "number" && Date.now() > row.expires) {
+                this.delete(key).then(() => void 0);
+                result.push(void 0);
+              } else {
+                result.push(options && options.raw ? row : row.value);
+              }
+            }
+            return result;
+          }
+          if (typeof data.expires === "number" && Date.now() > data.expires) {
+            return this.delete(key).then(() => void 0);
+          }
+          return options && options.raw ? data : data.value;
+        });
+      }
+      set(key, value, ttl) {
+        const keyPrefixed = this._getKeyPrefix(key);
+        if (typeof ttl === "undefined") {
+          ttl = this.opts.ttl;
+        }
+        if (ttl === 0) {
+          ttl = void 0;
+        }
+        const { store } = this.opts;
+        return Promise.resolve().then(() => {
+          const expires = typeof ttl === "number" ? Date.now() + ttl : null;
+          if (typeof value === "symbol") {
+            this.emit("error", "symbol cannot be serialized");
+          }
+          value = { value, expires };
+          return this.opts.serialize(value);
+        }).then((value2) => store.set(keyPrefixed, value2, ttl)).then(() => true);
+      }
+      delete(key) {
+        const { store } = this.opts;
+        if (Array.isArray(key)) {
+          const keyPrefixed2 = this._getKeyPrefixArray(key);
+          if (store.deleteMany === void 0) {
+            const promises = [];
+            for (const key2 of keyPrefixed2) {
+              promises.push(store.delete(key2));
+            }
+            return Promise.allSettled(promises).then((values) => values.every((x) => x.value === true));
+          }
+          return Promise.resolve().then(() => store.deleteMany(keyPrefixed2));
+        }
+        const keyPrefixed = this._getKeyPrefix(key);
+        return Promise.resolve().then(() => store.delete(keyPrefixed));
+      }
+      clear() {
+        const { store } = this.opts;
+        return Promise.resolve().then(() => store.clear());
+      }
+      has(key) {
+        const keyPrefixed = this._getKeyPrefix(key);
+        const { store } = this.opts;
+        return Promise.resolve().then(async () => {
+          if (typeof store.has === "function") {
+            return store.has(keyPrefixed);
+          }
+          const value = await store.get(keyPrefixed);
+          return value !== void 0;
+        });
+      }
+      disconnect() {
+        const { store } = this.opts;
+        if (typeof store.disconnect === "function") {
+          return store.disconnect();
+        }
+      }
+    };
+    module.exports = Keyv;
+  }
+});
+
 // node_modules/flatted/cjs/index.js
 var require_cjs = __commonJS({
   "node_modules/flatted/cjs/index.js"(exports) {
@@ -4008,6 +4266,7 @@ var require_cache = __commonJS({
   "node_modules/flat-cache/src/cache.js"(exports, module) {
     var path10 = __require("path");
     var fs6 = __require("fs");
+    var Keyv = require_src();
     var utils = require_utils();
     var del = require_del();
     var writeJSON = utils.writeJSON;
@@ -4023,13 +4282,28 @@ var require_cache = __commonJS({
        */
       load: function(docId, cacheDir) {
         var me = this;
-        me._visited = {};
-        me._persisted = {};
+        me.keyv = new Keyv();
+        me.__visited = {};
+        me.__persisted = {};
         me._pathToFile = cacheDir ? path10.resolve(cacheDir, docId) : path10.resolve(__dirname, "../.cache/", docId);
         if (fs6.existsSync(me._pathToFile)) {
           me._persisted = utils.tryParse(me._pathToFile, {});
         }
       },
+      get _persisted() {
+        return this.__persisted;
+      },
+      set _persisted(value) {
+        this.__persisted = value;
+        this.keyv.set("persisted", value);
+      },
+      get _visited() {
+        return this.__visited;
+      },
+      set _visited(value) {
+        this.__visited = value;
+        this.keyv.set("visited", value);
+      },
       /**
        * Load the cache from the provided file
        * @method loadFile
@@ -5404,12 +5678,30 @@ var preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUp
 };
 var preserveConsecutiveUppercase = (input, toLowerCase) => {
   LEADING_CAPITAL.lastIndex = 0;
-  return input.replace(LEADING_CAPITAL, (m1) => toLowerCase(m1));
+  return string_replace_all_default(
+    /* isOptionalObject*/
+    false,
+    input,
+    LEADING_CAPITAL,
+    (match) => toLowerCase(match)
+  );
 };
 var postProcess = (input, toUpperCase) => {
   SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
   NUMBERS_AND_IDENTIFIER.lastIndex = 0;
-  return input.replace(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier)).replace(NUMBERS_AND_IDENTIFIER, (m) => toUpperCase(m));
+  return string_replace_all_default(
+    /* isOptionalObject*/
+    false,
+    string_replace_all_default(
+      /* isOptionalObject*/
+      false,
+      input,
+      NUMBERS_AND_IDENTIFIER,
+      (match, pattern, offset) => ["_", "-"].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match)
+    ),
+    SEPARATORS_AND_IDENTIFIER,
+    (_, identifier) => toUpperCase(identifier)
+  );
 };
 function camelCase(input, options) {
   if (!(typeof input === "string" || Array.isArray(input))) {
@@ -5963,9 +6255,10 @@ async function* expandPatternsInternal(context) {
         });
       } else if (stat.isDirectory()) {
         const relativePath = path2.relative(cwd2, absolutePath) || ".";
+        const prefix = escapePathForGlob(fixWindowsSlashes(relativePath));
         entries.push({
           type: "dir",
-          glob: escapePathForGlob(fixWindowsSlashes(relativePath)) + "/" + getSupportedFilesGlob(),
+          glob: getSupportedFilesGlob().map((pattern2) => `${prefix}/**/${pattern2}`),
           input: pattern
         });
       }
@@ -6007,13 +6300,20 @@ ${message}`
     }
   }
   function getSupportedFilesGlob() {
-    if (!supportedFilesGlob) {
-      const extensions = context.languages.flatMap((lang) => lang.extensions || []);
-      const filenames = context.languages.flatMap((lang) => lang.filenames || []);
-      supportedFilesGlob = `**/{${[...extensions.map((ext) => "*" + (ext[0] === "." ? ext : "." + ext)), ...filenames]}}`;
-    }
+    supportedFilesGlob ?? (supportedFilesGlob = [...getSupportedFilesGlobWithoutCache()]);
     return supportedFilesGlob;
   }
+  function* getSupportedFilesGlobWithoutCache() {
+    for (const {
+      extensions = [],
+      filenames = []
+    } of context.languages) {
+      yield* filenames;
+      for (const extension of extensions) {
+        yield `*${extension.startsWith(".") ? extension : `.${extension}`}`;
+      }
+    }
+  }
 }
 var errorMessages = {
   globError: {

package/internal/internal.mjs

@@ -673,9 +673,9 @@ var require_lib = __commonJS({
   }
 });
 
-// node_modules/@babel/highlight/node_modules/escape-string-regexp/index.js
+// node_modules/@babel/code-frame/node_modules/escape-string-regexp/index.js
 var require_escape_string_regexp = __commonJS({
-  "node_modules/@babel/highlight/node_modules/escape-string-regexp/index.js"(exports, module) {
+  "node_modules/@babel/code-frame/node_modules/escape-string-regexp/index.js"(exports, module) {
     "use strict";
     var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
     module.exports = function(str) {
@@ -1829,9 +1829,9 @@ var require_ansi_styles = __commonJS({
   }
 });
 
-// node_modules/@babel/highlight/node_modules/has-flag/index.js
+// node_modules/@babel/code-frame/node_modules/has-flag/index.js
 var require_has_flag = __commonJS({
-  "node_modules/@babel/highlight/node_modules/has-flag/index.js"(exports, module) {
+  "node_modules/@babel/code-frame/node_modules/has-flag/index.js"(exports, module) {
     "use strict";
     module.exports = (flag, argv) => {
       argv = argv || process.argv;
@@ -1843,9 +1843,9 @@ var require_has_flag = __commonJS({
   }
 });
 
-// node_modules/@babel/highlight/node_modules/supports-color/index.js
+// node_modules/@babel/code-frame/node_modules/supports-color/index.js
 var require_supports_color = __commonJS({
-  "node_modules/@babel/highlight/node_modules/supports-color/index.js"(exports, module) {
+  "node_modules/@babel/code-frame/node_modules/supports-color/index.js"(exports, module) {
     "use strict";
     var os = __require("os");
     var hasFlag = require_has_flag();
@@ -1938,9 +1938,9 @@ var require_supports_color = __commonJS({
   }
 });
 
-// node_modules/@babel/highlight/node_modules/chalk/templates.js
+// node_modules/@babel/code-frame/node_modules/chalk/templates.js
 var require_templates = __commonJS({
-  "node_modules/@babel/highlight/node_modules/chalk/templates.js"(exports, module) {
+  "node_modules/@babel/code-frame/node_modules/chalk/templates.js"(exports, module) {
     "use strict";
     var TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
     var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
@@ -2049,9 +2049,9 @@ var require_templates = __commonJS({
   }
 });
 
-// node_modules/@babel/highlight/node_modules/chalk/index.js
+// node_modules/@babel/code-frame/node_modules/chalk/index.js
 var require_chalk = __commonJS({
-  "node_modules/@babel/highlight/node_modules/chalk/index.js"(exports, module) {
+  "node_modules/@babel/code-frame/node_modules/chalk/index.js"(exports, module) {
     "use strict";
     var escapeStringRegexp = require_escape_string_regexp();
     var ansiStyles = require_ansi_styles();
@@ -2224,23 +2224,23 @@ var require_lib2 = __commonJS({
       value: true
     });
     exports.default = highlight;
-    exports.getChalk = getChalk;
     exports.shouldHighlight = shouldHighlight;
     var _jsTokens = require_js_tokens();
     var _helperValidatorIdentifier = require_lib();
-    var _chalk = require_chalk();
+    var _chalk2 = require_chalk();
+    var chalk = _chalk2;
     var sometimesKeywords = /* @__PURE__ */ new Set(["as", "async", "from", "get", "of", "set"]);
-    function getDefs(chalk) {
+    function getDefs(chalk2) {
       return {
-        keyword: chalk.cyan,
-        capitalized: chalk.yellow,
-        jsxIdentifier: chalk.yellow,
-        punctuator: chalk.yellow,
-        number: chalk.magenta,
-        string: chalk.green,
-        regex: chalk.magenta,
-        comment: chalk.grey,
-        invalid: chalk.white.bgRed.bold
+        keyword: chalk2.cyan,
+        capitalized: chalk2.yellow,
+        jsxIdentifier: chalk2.yellow,
+        punctuator: chalk2.yellow,
+        number: chalk2.magenta,
+        string: chalk2.green,
+        regex: chalk2.magenta,
+        comment: chalk2.grey,
+        invalid: chalk2.white.bgRed.bold
       };
     }
     var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
@@ -2295,18 +2295,28 @@ var require_lib2 = __commonJS({
       return highlighted;
     }
     function shouldHighlight(options) {
-      return !!_chalk.supportsColor || options.forceColor;
+      return !!chalk.supportsColor || options.forceColor;
+    }
+    var chalkWithForcedColor = void 0;
+    function getChalk(forceColor) {
+      if (forceColor) {
+        var _chalkWithForcedColor;
+        (_chalkWithForcedColor = chalkWithForcedColor) != null ? _chalkWithForcedColor : chalkWithForcedColor = new chalk.constructor({
+          enabled: true,
+          level: 1
+        });
+        return chalkWithForcedColor;
+      }
+      return chalk;
     }
-    function getChalk(options) {
-      return options.forceColor ? new _chalk.constructor({
-        enabled: true,
-        level: 1
-      }) : _chalk;
+    {
+      {
+        exports.getChalk = (options) => getChalk(options.forceColor);
+      }
     }
     function highlight(code, options = {}) {
       if (code !== "" && shouldHighlight(options)) {
-        const chalk = getChalk(options);
-        const defs = getDefs(chalk);
+        const defs = getDefs(getChalk(options.forceColor));
         return highlightTokens(defs, code);
       } else {
         return code;
@@ -2325,12 +2335,26 @@ var require_lib3 = __commonJS({
     exports.codeFrameColumns = codeFrameColumns;
     exports.default = _default;
     var _highlight = require_lib2();
+    var _chalk2 = require_chalk();
+    var chalk = _chalk2;
+    var chalkWithForcedColor = void 0;
+    function getChalk(forceColor) {
+      if (forceColor) {
+        var _chalkWithForcedColor;
+        (_chalkWithForcedColor = chalkWithForcedColor) != null ? _chalkWithForcedColor : chalkWithForcedColor = new chalk.constructor({
+          enabled: true,
+          level: 1
+        });
+        return chalkWithForcedColor;
+      }
+      return chalk;
+    }
     var deprecationWarningShown = false;
-    function getDefs(chalk) {
+    function getDefs(chalk2) {
       return {
-        gutter: chalk.grey,
-        marker: chalk.red.bold,
-        message: chalk.red.bold
+        gutter: chalk2.grey,
+        marker: chalk2.red.bold,
+        message: chalk2.red.bold
       };
     }
     var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
@@ -2392,8 +2416,8 @@ var require_lib3 = __commonJS({
     }
     function codeFrameColumns(rawLines, loc, opts = {}) {
       const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
-      const chalk = (0, _highlight.getChalk)(opts);
-      const defs = getDefs(chalk);
+      const chalk2 = getChalk(opts.forceColor);
+      const defs = getDefs(chalk2);
       const maybeHighlight = (chalkFn, string) => {
         return highlighted ? chalkFn(string) : string;
       };
@@ -2432,7 +2456,7 @@ var require_lib3 = __commonJS({
 ${frame}`;
       }
       if (highlighted) {
-        return chalk.reset(frame);
+        return chalk2.reset(frame);
       } else {
         return frame;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Prettier is an opinionated code formatter",
   "bin": "./bin/prettier.cjs",
   "repository": "prettier/prettier",
@@ -190,5 +190,6 @@
     "standalone.d.ts",
     "standalone.js",
     "standalone.mjs"
-  ]
+  ],
+  "preferUnplugged": true
 }