npm - prettier - Versions diffs - 3.0.0-alpha.10 → 3.0.0-alpha.11 - Mend

prettier 3.0.0-alpha.10 → 3.0.0-alpha.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (34) hide show

package/index.mjs CHANGED Viewed

@@ -1841,16 +1841,16 @@ var require_chalk = __commonJS({
     var levelMapping = ["ansi", "ansi", "ansi256", "ansi16m"];
     var skipModels = /* @__PURE__ */ new Set(["gray"]);
     var styles = /* @__PURE__ */ Object.create(null);
-    function applyOptions(obj, options) {
-      options = options || {};
+    function applyOptions(obj, options8) {
+      options8 = options8 || {};
       const scLevel = stdoutColor ? stdoutColor.level : 0;
-      obj.level = options.level === void 0 ? scLevel : options.level;
-      obj.enabled = "enabled" in options ? options.enabled : obj.level > 0;
+      obj.level = options8.level === void 0 ? scLevel : options8.level;
+      obj.enabled = "enabled" in options8 ? options8.enabled : obj.level > 0;
     }
-    function Chalk(options) {
+    function Chalk(options8) {
       if (!this || !(this instanceof Chalk) || this.template) {
         const chalk = {};
-        applyOptions(chalk, options);
+        applyOptions(chalk, options8);
         chalk.template = function() {
           const args = [].slice.call(arguments);
           return chalkTag.apply(null, [chalk.template].concat(args));
@@ -1860,7 +1860,7 @@ var require_chalk = __commonJS({
         chalk.template.constructor = Chalk;
         return chalk.template;
       }
-      applyOptions(this, options);
+      applyOptions(this, options8);
     }
     if (isSimpleWindowsTerm) {
       ansiStyles.blue.open = "\x1B[94m";
@@ -2599,7 +2599,7 @@ var require_normalize = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     var defaults_1 = require_defaults();
     var utils_1 = require_utils();
-    exports.normalize = (options, schemas, opts) => new Normalizer(schemas, opts).normalize(options);
+    exports.normalize = (options8, schemas, opts) => new Normalizer(schemas, opts).normalize(options8);
     var Normalizer = class {
       constructor(schemas, opts) {
         const { logger = console, descriptor = defaults_1.defaultDescriptor, unknown = defaults_1.defaultUnknownHandler, invalid = defaults_1.defaultInvalidHandler, deprecated = defaults_1.defaultDeprecatedHandler } = opts || {};
@@ -2625,9 +2625,9 @@ var require_normalize = __commonJS({
       cleanHistory() {
         this._hasDeprecationWarned = utils_1.createAutoChecklist();
       }
-      normalize(options) {
+      normalize(options8) {
         const normalized = {};
-        const restOptionsArray = [options];
+        const restOptionsArray = [options8];
         const applyNormalization = () => {
           while (restOptionsArray.length !== 0) {
             const currentOptions = restOptionsArray.shift();
@@ -2654,12 +2654,12 @@ var require_normalize = __commonJS({
         }
         return normalized;
       }
-      _applyNormalization(options, normalized) {
+      _applyNormalization(options8, normalized) {
         const transferredOptionsArray = [];
-        const [knownOptionNames, unknownOptionNames] = utils_1.partition(Object.keys(options), (key) => key in this._utils.schemas);
+        const [knownOptionNames, unknownOptionNames] = utils_1.partition(Object.keys(options8), (key) => key in this._utils.schemas);
         for (const key of knownOptionNames) {
           const schema = this._utils.schemas[key];
-          const value = schema.preprocess(options[key], this._utils);
+          const value = schema.preprocess(options8[key], this._utils);
           const validateResult = utils_1.normalizeValidateResult(schema.validate(value, this._utils), value);
           if (validateResult !== true) {
             const { value: invalidValue } = validateResult;
@@ -2710,7 +2710,7 @@ var require_normalize = __commonJS({
           }
         }
         for (const key of unknownOptionNames) {
-          const value = options[key];
+          const value = options8[key];
           const unknownResult = this._unknownHandler(key, value, this._utils);
           if (unknownResult) {
             for (const unknownKey of Object.keys(unknownResult)) {
@@ -2976,7 +2976,7 @@ var require_is_glob = __commonJS({
       }
       return false;
     };
-    module.exports = function isGlob(str, options) {
+    module.exports = function isGlob(str, options8) {
       if (typeof str !== "string" || str === "") {
         return false;
       }
@@ -2984,7 +2984,7 @@ var require_is_glob = __commonJS({
         return true;
       }
       var check2 = strictCheck;
-      if (options && options.strict === false) {
+      if (options8 && options8.strict === false) {
         check2 = relaxedCheck;
       }
       return check2(str);
@@ -3005,8 +3005,8 @@ var require_glob_parent = __commonJS({
     var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
     var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
     module.exports = function globParent(str, opts) {
-      var options = Object.assign({ flipBackslashes: true }, opts);
-      if (options.flipBackslashes && isWin32 && str.indexOf(slash2) < 0) {
+      var options8 = Object.assign({ flipBackslashes: true }, opts);
+      if (options8.flipBackslashes && isWin32 && str.indexOf(slash2) < 0) {
         str = str.replace(backslash, slash2);
       }
       if (enclosure.test(str)) {
@@ -3110,10 +3110,10 @@ var require_stringify = __commonJS({
   "node_modules/braces/lib/stringify.js"(exports, module) {
     "use strict";
     var utils = require_utils2();
-    module.exports = (ast, options = {}) => {
+    module.exports = (ast, options8 = {}) => {
       let stringify = (node, parent = {}) => {
-        let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
-        let invalidNode = node.invalid === true && options.escapeInvalid === true;
+        let invalidBlock = options8.escapeInvalid && utils.isInvalidBrace(parent);
+        let invalidNode = node.invalid === true && options8.escapeInvalid === true;
         let output = "";
         if (node.value) {
           if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
@@ -3157,7 +3157,7 @@ var require_to_regex_range = __commonJS({
   "node_modules/to-regex-range/index.js"(exports, module) {
     "use strict";
     var isNumber = require_is_number();
-    var toRegexRange = (min, max, options) => {
+    var toRegexRange = (min, max, options8) => {
       if (isNumber(min) === false) {
         throw new TypeError("toRegexRange: expected the first argument to be a number");
       }
@@ -3167,7 +3167,7 @@ var require_to_regex_range = __commonJS({
       if (isNumber(max) === false) {
         throw new TypeError("toRegexRange: expected the second argument to be a number.");
       }
-      let opts = { relaxZeros: true, ...options };
+      let opts = { relaxZeros: true, ...options8 };
       if (typeof opts.strictZeros === "boolean") {
         opts.relaxZeros = opts.strictZeros === false;
       }
@@ -3218,10 +3218,10 @@ var require_to_regex_range = __commonJS({
       toRegexRange.cache[cacheKey] = state;
       return state.result;
     };
-    function collatePatterns(neg, pos, options) {
-      let onlyNegative = filterPatterns(neg, pos, "-", false, options) || [];
-      let onlyPositive = filterPatterns(pos, neg, "", false, options) || [];
-      let intersected = filterPatterns(neg, pos, "-?", true, options) || [];
+    function collatePatterns(neg, pos, options8) {
+      let onlyNegative = filterPatterns(neg, pos, "-", false, options8) || [];
+      let onlyPositive = filterPatterns(pos, neg, "", false, options8) || [];
+      let intersected = filterPatterns(neg, pos, "-?", true, options8) || [];
       let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
       return subpatterns.join("|");
     }
@@ -3245,7 +3245,7 @@ var require_to_regex_range = __commonJS({
       stops.sort(compare);
       return stops;
     }
-    function rangeToPattern(start, stop, options) {
+    function rangeToPattern(start, stop, options8) {
       if (start === stop) {
         return { pattern: start, count: [], digits: 0 };
       }
@@ -3258,24 +3258,24 @@ var require_to_regex_range = __commonJS({
         if (startDigit === stopDigit) {
           pattern += startDigit;
         } else if (startDigit !== "0" || stopDigit !== "9") {
-          pattern += toCharacterClass(startDigit, stopDigit, options);
+          pattern += toCharacterClass(startDigit, stopDigit, options8);
         } else {
           count++;
         }
       }
       if (count) {
-        pattern += options.shorthand === true ? "\\d" : "[0-9]";
+        pattern += options8.shorthand === true ? "\\d" : "[0-9]";
       }
       return { pattern, count: [count], digits };
     }
-    function splitToPatterns(min, max, tok, options) {
+    function splitToPatterns(min, max, tok, options8) {
       let ranges = splitToRanges(min, max);
       let tokens = [];
       let start = min;
       let prev;
       for (let i = 0; i < ranges.length; i++) {
         let max2 = ranges[i];
-        let obj = rangeToPattern(String(start), String(max2), options);
+        let obj = rangeToPattern(String(start), String(max2), options8);
         let zeros = "";
         if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
           if (prev.count.length > 1) {
@@ -3287,7 +3287,7 @@ var require_to_regex_range = __commonJS({
           continue;
         }
         if (tok.isPadded) {
-          zeros = padZeros(max2, tok, options);
+          zeros = padZeros(max2, tok, options8);
         }
         obj.string = zeros + obj.pattern + toQuantifier(obj.count);
         tokens.push(obj);
@@ -3296,7 +3296,7 @@ var require_to_regex_range = __commonJS({
       }
       return tokens;
     }
-    function filterPatterns(arr, comparison, prefix, intersection, options) {
+    function filterPatterns(arr, comparison, prefix, intersection, options8) {
       let result = [];
       for (let ele of arr) {
         let { string } = ele;
@@ -3334,18 +3334,18 @@ var require_to_regex_range = __commonJS({
       }
       return "";
     }
-    function toCharacterClass(a, b, options) {
+    function toCharacterClass(a, b, options8) {
       return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
     }
     function hasPadding(str) {
       return /^-?(0+)\d/.test(str);
     }
-    function padZeros(value, tok, options) {
+    function padZeros(value, tok, options8) {
       if (!tok.isPadded) {
         return value;
       }
       let diff = Math.abs(tok.maxLen - String(value).length);
-      let relax = options.relaxZeros !== false;
+      let relax = options8.relaxZeros !== false;
       switch (diff) {
         case 0:
           return "";
@@ -3389,11 +3389,11 @@ var require_fill_range = __commonJS({
         ;
       return index > 0;
     };
-    var stringify = (start, end, options) => {
+    var stringify = (start, end, options8) => {
       if (typeof start === "string" || typeof end === "string") {
         return true;
       }
-      return options.stringify === true;
+      return options8.stringify === true;
     };
     var pad = (input, maxLength, toNumber) => {
       if (maxLength > 0) {
@@ -3417,10 +3417,10 @@ var require_fill_range = __commonJS({
         input = "0" + input;
       return negative ? "-" + input : input;
     };
-    var toSequence = (parts, options) => {
+    var toSequence = (parts, options8) => {
       parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
       parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-      let prefix = options.capture ? "" : "?:";
+      let prefix = options8.capture ? "" : "?:";
       let positives = "";
       let negatives = "";
       let result;
@@ -3435,14 +3435,14 @@ var require_fill_range = __commonJS({
       } else {
         result = positives || negatives;
       }
-      if (options.wrap) {
+      if (options8.wrap) {
         return `(${prefix}${result})`;
       }
       return result;
     };
-    var toRange = (a, b, isNumbers, options) => {
+    var toRange = (a, b, isNumbers, options8) => {
       if (isNumbers) {
-        return toRegexRange(a, b, { wrap: false, ...options });
+        return toRegexRange(a, b, { wrap: false, ...options8 });
       }
       let start = String.fromCharCode(a);
       if (a === b)
@@ -3450,33 +3450,33 @@ var require_fill_range = __commonJS({
       let stop = String.fromCharCode(b);
       return `[${start}-${stop}]`;
     };
-    var toRegex = (start, end, options) => {
+    var toRegex = (start, end, options8) => {
       if (Array.isArray(start)) {
-        let wrap = options.wrap === true;
-        let prefix = options.capture ? "" : "?:";
+        let wrap = options8.wrap === true;
+        let prefix = options8.capture ? "" : "?:";
         return wrap ? `(${prefix}${start.join("|")})` : start.join("|");
       }
-      return toRegexRange(start, end, options);
+      return toRegexRange(start, end, options8);
     };
     var rangeError = (...args) => {
       return new RangeError("Invalid range arguments: " + util.inspect(...args));
     };
-    var invalidRange = (start, end, options) => {
-      if (options.strictRanges === true)
+    var invalidRange = (start, end, options8) => {
+      if (options8.strictRanges === true)
         throw rangeError([start, end]);
       return [];
     };
-    var invalidStep = (step, options) => {
-      if (options.strictRanges === true) {
+    var invalidStep = (step, options8) => {
+      if (options8.strictRanges === true) {
         throw new TypeError(`Expected step "${step}" to be a number`);
       }
       return [];
     };
-    var fillNumbers = (start, end, step = 1, options = {}) => {
+    var fillNumbers = (start, end, step = 1, options8 = {}) => {
       let a = Number(start);
       let b = Number(end);
       if (!Number.isInteger(a) || !Number.isInteger(b)) {
-        if (options.strictRanges === true)
+        if (options8.strictRanges === true)
           throw rangeError([start, end]);
         return [];
       }
@@ -3491,17 +3491,17 @@ var require_fill_range = __commonJS({
       step = Math.max(Math.abs(step), 1);
       let padded = zeros(startString) || zeros(endString) || zeros(stepString);
       let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
-      let toNumber = padded === false && stringify(start, end, options) === false;
-      let format3 = options.transform || transform2(toNumber);
-      if (options.toRegex && step === 1) {
-        return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+      let toNumber = padded === false && stringify(start, end, options8) === false;
+      let format3 = options8.transform || transform2(toNumber);
+      if (options8.toRegex && step === 1) {
+        return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options8);
       }
       let parts = { negatives: [], positives: [] };
       let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
       let range = [];
       let index = 0;
       while (descending ? a >= b : a <= b) {
-        if (options.toRegex === true && step > 1) {
+        if (options8.toRegex === true && step > 1) {
           push(a);
         } else {
           range.push(pad(format3(a, index), maxLen, toNumber));
@@ -3509,23 +3509,23 @@ var require_fill_range = __commonJS({
         a = descending ? a - step : a + step;
         index++;
       }
-      if (options.toRegex === true) {
-        return step > 1 ? toSequence(parts, options) : toRegex(range, null, { wrap: false, ...options });
+      if (options8.toRegex === true) {
+        return step > 1 ? toSequence(parts, options8) : toRegex(range, null, { wrap: false, ...options8 });
       }
       return range;
     };
-    var fillLetters = (start, end, step = 1, options = {}) => {
+    var fillLetters = (start, end, step = 1, options8 = {}) => {
       if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) {
-        return invalidRange(start, end, options);
+        return invalidRange(start, end, options8);
       }
-      let format3 = options.transform || ((val) => String.fromCharCode(val));
+      let format3 = options8.transform || ((val) => String.fromCharCode(val));
       let a = `${start}`.charCodeAt(0);
       let b = `${end}`.charCodeAt(0);
       let descending = a > b;
       let min = Math.min(a, b);
       let max = Math.max(a, b);
-      if (options.toRegex && step === 1) {
-        return toRange(min, max, false, options);
+      if (options8.toRegex && step === 1) {
+        return toRange(min, max, false, options8);
       }
       let range = [];
       let index = 0;
@@ -3534,17 +3534,17 @@ var require_fill_range = __commonJS({
         a = descending ? a - step : a + step;
         index++;
       }
-      if (options.toRegex === true) {
-        return toRegex(range, null, { wrap: false, options });
+      if (options8.toRegex === true) {
+        return toRegex(range, null, { wrap: false, options: options8 });
       }
       return range;
     };
-    var fill2 = (start, end, step, options = {}) => {
+    var fill2 = (start, end, step, options8 = {}) => {
       if (end == null && isValidValue(start)) {
         return [start];
       }
       if (!isValidValue(start) || !isValidValue(end)) {
-        return invalidRange(start, end, options);
+        return invalidRange(start, end, options8);
       }
       if (typeof step === "function") {
         return fill2(start, end, 1, { transform: step });
@@ -3552,7 +3552,7 @@ var require_fill_range = __commonJS({
       if (isObject2(step)) {
         return fill2(start, end, 0, step);
       }
-      let opts = { ...options };
+      let opts = { ...options8 };
       if (opts.capture === true)
         opts.wrap = true;
       step = step || opts.step || 1;
@@ -3576,12 +3576,12 @@ var require_compile = __commonJS({
     "use strict";
     var fill2 = require_fill_range();
     var utils = require_utils2();
-    var compile = (ast, options = {}) => {
+    var compile = (ast, options8 = {}) => {
       let walk = (node, parent = {}) => {
         let invalidBlock = utils.isInvalidBrace(parent);
-        let invalidNode = node.invalid === true && options.escapeInvalid === true;
+        let invalidNode = node.invalid === true && options8.escapeInvalid === true;
         let invalid = invalidBlock === true || invalidNode === true;
-        let prefix = options.escapeInvalid === true ? "\\" : "";
+        let prefix = options8.escapeInvalid === true ? "\\" : "";
         let output = "";
         if (node.isOpen === true) {
           return prefix + node.value;
@@ -3603,7 +3603,7 @@ var require_compile = __commonJS({
         }
         if (node.nodes && node.ranges > 0) {
           let args = utils.reduce(node.nodes);
-          let range = fill2(...args, { ...options, wrap: false, toRegex: true });
+          let range = fill2(...args, { ...options8, wrap: false, toRegex: true });
           if (range.length !== 0) {
             return args.length > 1 && range.length > 1 ? `(${range})` : range;
           }
@@ -3652,8 +3652,8 @@ var require_expand = __commonJS({
       }
       return utils.flatten(result);
     };
-    var expand = (ast, options = {}) => {
-      let rangeLimit = options.rangeLimit === void 0 ? 1e3 : options.rangeLimit;
+    var expand = (ast, options8 = {}) => {
+      let rangeLimit = options8.rangeLimit === void 0 ? 1e3 : options8.rangeLimit;
       let walk = (node, parent = {}) => {
         node.queue = [];
         let p = parent;
@@ -3663,7 +3663,7 @@ var require_expand = __commonJS({
           q = p.queue;
         }
         if (node.invalid || node.dollar) {
-          q.push(append(q.pop(), stringify(node, options)));
+          q.push(append(q.pop(), stringify(node, options8)));
           return;
         }
         if (node.type === "brace" && node.invalid !== true && node.nodes.length === 2) {
@@ -3672,12 +3672,12 @@ var require_expand = __commonJS({
         }
         if (node.nodes && node.ranges > 0) {
           let args = utils.reduce(node.nodes);
-          if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+          if (utils.exceedsLimit(...args, options8.step, rangeLimit)) {
             throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
           }
-          let range = fill2(...args, options);
+          let range = fill2(...args, options8);
           if (range.length === 0) {
-            range = stringify(node, options);
+            range = stringify(node, options8);
           }
           q.push(append(q.pop(), range));
           node.nodes = [];
@@ -3853,11 +3853,11 @@ var require_parse = __commonJS({
       CHAR_NO_BREAK_SPACE,
       CHAR_ZERO_WIDTH_NOBREAK_SPACE
     } = require_constants();
-    var parse3 = (input, options = {}) => {
+    var parse3 = (input, options8 = {}) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
-      let opts = options || {};
+      let opts = options8 || {};
       let max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
       if (input.length > max) {
         throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
@@ -3895,7 +3895,7 @@ var require_parse = __commonJS({
           continue;
         }
         if (value === CHAR_BACKSLASH) {
-          push({ type: "text", value: (options.keepEscaping ? value : "") + advance() });
+          push({ type: "text", value: (options8.keepEscaping ? value : "") + advance() });
           continue;
         }
         if (value === CHAR_RIGHT_SQUARE_BRACKET) {
@@ -3945,7 +3945,7 @@ var require_parse = __commonJS({
         if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
           let open = value;
           let next;
-          if (options.keepQuotes !== true) {
+          if (options8.keepQuotes !== true) {
             value = "";
           }
           while (index < length && (next = advance())) {
@@ -3954,7 +3954,7 @@ var require_parse = __commonJS({
               continue;
             }
             if (next === open) {
-              if (options.keepQuotes === true)
+              if (options8.keepQuotes === true)
                 value += next;
               break;
             }
@@ -4071,11 +4071,11 @@ var require_braces = __commonJS({
     var compile = require_compile();
     var expand = require_expand();
     var parse3 = require_parse();
-    var braces = (input, options = {}) => {
+    var braces = (input, options8 = {}) => {
       let output = [];
       if (Array.isArray(input)) {
         for (let pattern of input) {
-          let result = braces.create(pattern, options);
+          let result = braces.create(pattern, options8);
           if (Array.isArray(result)) {
             output.push(...result);
           } else {
@@ -4083,44 +4083,44 @@ var require_braces = __commonJS({
           }
         }
       } else {
-        output = [].concat(braces.create(input, options));
+        output = [].concat(braces.create(input, options8));
       }
-      if (options && options.expand === true && options.nodupes === true) {
+      if (options8 && options8.expand === true && options8.nodupes === true) {
         output = [...new Set(output)];
       }
       return output;
     };
-    braces.parse = (input, options = {}) => parse3(input, options);
-    braces.stringify = (input, options = {}) => {
+    braces.parse = (input, options8 = {}) => parse3(input, options8);
+    braces.stringify = (input, options8 = {}) => {
       if (typeof input === "string") {
-        return stringify(braces.parse(input, options), options);
+        return stringify(braces.parse(input, options8), options8);
       }
-      return stringify(input, options);
+      return stringify(input, options8);
     };
-    braces.compile = (input, options = {}) => {
+    braces.compile = (input, options8 = {}) => {
       if (typeof input === "string") {
-        input = braces.parse(input, options);
+        input = braces.parse(input, options8);
       }
-      return compile(input, options);
+      return compile(input, options8);
     };
-    braces.expand = (input, options = {}) => {
+    braces.expand = (input, options8 = {}) => {
       if (typeof input === "string") {
-        input = braces.parse(input, options);
+        input = braces.parse(input, options8);
       }
-      let result = expand(input, options);
-      if (options.noempty === true) {
+      let result = expand(input, options8);
+      if (options8.noempty === true) {
         result = result.filter(Boolean);
       }
-      if (options.nodupes === true) {
+      if (options8.nodupes === true) {
         result = [...new Set(result)];
       }
       return result;
     };
-    braces.create = (input, options = {}) => {
+    braces.create = (input, options8 = {}) => {
       if (input === "" || input.length < 3) {
         return [input];
       }
-      return options.expand !== true ? braces.compile(input, options) : braces.expand(input, options);
+      return options8.expand !== true ? braces.compile(input, options8) : braces.expand(input, options8);
     };
     module.exports = braces;
   }
@@ -4352,9 +4352,9 @@ var require_utils3 = __commonJS({
       }
       return false;
     };
-    exports.isWindows = (options) => {
-      if (options && typeof options.windows === "boolean") {
-        return options.windows;
+    exports.isWindows = (options8) => {
+      if (options8 && typeof options8.windows === "boolean") {
+        return options8.windows;
       }
       return win32 === true || path11.sep === "\\";
     };
@@ -4374,9 +4374,9 @@ var require_utils3 = __commonJS({
       }
       return output;
     };
-    exports.wrapOutput = (input, state = {}, options = {}) => {
-      const prepend = options.contains ? "" : "^";
-      const append = options.contains ? "" : "$";
+    exports.wrapOutput = (input, state = {}, options8 = {}) => {
+      const prepend = options8.contains ? "" : "^";
+      const append = options8.contains ? "" : "$";
       let output = `${prepend}(?:${input})${append}`;
       if (state.negated === true) {
         output = `(?:^(?!${output}).*$)`;
@@ -4431,8 +4431,8 @@ var require_scan = __commonJS({
         token.depth = token.isGlobstar ? Infinity : 1;
       }
     };
-    var scan = (input, options) => {
-      const opts = options || {};
+    var scan = (input, options8) => {
+      const opts = options8 || {};
       const length = input.length - 1;
       const scanToEnd = opts.parts === true || opts.scanToEnd === true;
       const slashes = [];
@@ -4732,9 +4732,9 @@ var require_parse2 = __commonJS({
       REGEX_SPECIAL_CHARS_BACKREF,
       REPLACEMENTS
     } = constants;
-    var expandRange = (args, options) => {
-      if (typeof options.expandRange === "function") {
-        return options.expandRange(...args, options);
+    var expandRange = (args, options8) => {
+      if (typeof options8.expandRange === "function") {
+        return options8.expandRange(...args, options8);
       }
       args.sort();
       const value = `[${args.join("-")}]`;
@@ -4748,12 +4748,12 @@ var require_parse2 = __commonJS({
     var syntaxError = (type, char) => {
       return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
     };
-    var parse3 = (input, options) => {
+    var parse3 = (input, options8) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
       input = REPLACEMENTS[input] || input;
-      const opts = { ...options };
+      const opts = { ...options8 };
       const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
       let len = input.length;
       if (len > max) {
@@ -4762,7 +4762,7 @@ var require_parse2 = __commonJS({
       const bos = { type: "bos", value: "", output: opts.prepend || "" };
       const tokens = [bos];
       const capture = opts.capture ? "" : "?:";
-      const win32 = utils.isWindows(options);
+      const win32 = utils.isWindows(options8);
       const PLATFORM_CHARS = constants.globChars(win32);
       const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
       const {
@@ -4898,7 +4898,7 @@ var require_parse2 = __commonJS({
             output = token.close = `)$))${extglobStar}`;
           }
           if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-            const expression = parse3(rest, { ...options, fastpaths: false }).output;
+            const expression = parse3(rest, { ...options8, fastpaths: false }).output;
             output = token.close = `)${expression})${extglobStar})`;
           }
           if (token.prev.type === "bos") {
@@ -4948,7 +4948,7 @@ var require_parse2 = __commonJS({
           state.output = input;
           return state;
         }
-        state.output = utils.wrapOutput(output, state, options);
+        state.output = utils.wrapOutput(output, state, options8);
         return state;
       }
       while (!eos()) {
@@ -5427,15 +5427,15 @@ var require_parse2 = __commonJS({
       }
       return state;
     };
-    parse3.fastpaths = (input, options) => {
-      const opts = { ...options };
+    parse3.fastpaths = (input, options8) => {
+      const opts = { ...options8 };
       const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
       const len = input.length;
       if (len > max) {
         throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
       }
       input = REPLACEMENTS[input] || input;
-      const win32 = utils.isWindows(options);
+      const win32 = utils.isWindows(options8);
       const {
         DOT_LITERAL,
         SLASH_LITERAL,
@@ -5510,9 +5510,9 @@ var require_picomatch = __commonJS({
     var utils = require_utils3();
     var constants = require_constants2();
     var isObject2 = (val) => val && typeof val === "object" && !Array.isArray(val);
-    var picomatch = (glob, options, returnState = false) => {
+    var picomatch = (glob, options8, returnState = false) => {
       if (Array.isArray(glob)) {
-        const fns = glob.map((input) => picomatch(input, options, returnState));
+        const fns = glob.map((input) => picomatch(input, options8, returnState));
         const arrayMatcher = (str) => {
           for (const isMatch of fns) {
             const state2 = isMatch(str);
@@ -5527,18 +5527,18 @@ var require_picomatch = __commonJS({
       if (glob === "" || typeof glob !== "string" && !isState) {
         throw new TypeError("Expected pattern to be a non-empty string");
       }
-      const opts = options || {};
-      const posix = utils.isWindows(options);
-      const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+      const opts = options8 || {};
+      const posix = utils.isWindows(options8);
+      const regex = isState ? picomatch.compileRe(glob, options8) : picomatch.makeRe(glob, options8, false, true);
       const state = regex.state;
       delete regex.state;
       let isIgnored2 = () => false;
       if (opts.ignore) {
-        const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+        const ignoreOpts = { ...options8, ignore: null, onMatch: null, onResult: null };
         isIgnored2 = picomatch(opts.ignore, ignoreOpts, returnState);
       }
       const matcher = (input, returnObject = false) => {
-        const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+        const { isMatch, match, output } = picomatch.test(input, regex, options8, { glob, posix });
         const result = { glob, state, regex, posix, input, output, match, isMatch };
         if (typeof opts.onResult === "function") {
           opts.onResult(result);
@@ -5564,14 +5564,14 @@ var require_picomatch = __commonJS({
       }
       return matcher;
     };
-    picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+    picomatch.test = (input, regex, options8, { glob, posix } = {}) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected input to be a string");
       }
       if (input === "") {
         return { isMatch: false, output: "" };
       }
-      const opts = options || {};
+      const opts = options8 || {};
       const format3 = opts.format || (posix ? utils.toPosixSlashes : null);
       let match = input === glob;
       let output = match && format3 ? format3(input) : input;
@@ -5581,60 +5581,60 @@ var require_picomatch = __commonJS({
       }
       if (match === false || opts.capture === true) {
         if (opts.matchBase === true || opts.basename === true) {
-          match = picomatch.matchBase(input, regex, options, posix);
+          match = picomatch.matchBase(input, regex, options8, posix);
         } else {
           match = regex.exec(output);
         }
       }
       return { isMatch: Boolean(match), match, output };
     };
-    picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-      const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+    picomatch.matchBase = (input, glob, options8, posix = utils.isWindows(options8)) => {
+      const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options8);
       return regex.test(path11.basename(input));
     };
-    picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
-    picomatch.parse = (pattern, options) => {
+    picomatch.isMatch = (str, patterns, options8) => picomatch(patterns, options8)(str);
+    picomatch.parse = (pattern, options8) => {
       if (Array.isArray(pattern))
-        return pattern.map((p) => picomatch.parse(p, options));
-      return parse3(pattern, { ...options, fastpaths: false });
+        return pattern.map((p) => picomatch.parse(p, options8));
+      return parse3(pattern, { ...options8, fastpaths: false });
     };
-    picomatch.scan = (input, options) => scan(input, options);
-    picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+    picomatch.scan = (input, options8) => scan(input, options8);
+    picomatch.compileRe = (state, options8, returnOutput = false, returnState = false) => {
       if (returnOutput === true) {
         return state.output;
       }
-      const opts = options || {};
+      const opts = options8 || {};
       const prepend = opts.contains ? "" : "^";
       const append = opts.contains ? "" : "$";
       let source = `${prepend}(?:${state.output})${append}`;
       if (state && state.negated === true) {
         source = `^(?!${source}).*$`;
       }
-      const regex = picomatch.toRegex(source, options);
+      const regex = picomatch.toRegex(source, options8);
       if (returnState === true) {
         regex.state = state;
       }
       return regex;
     };
-    picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+    picomatch.makeRe = (input, options8 = {}, returnOutput = false, returnState = false) => {
       if (!input || typeof input !== "string") {
         throw new TypeError("Expected a non-empty string");
       }
       let parsed = { negated: false, fastpaths: true };
-      if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-        parsed.output = parse3.fastpaths(input, options);
+      if (options8.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+        parsed.output = parse3.fastpaths(input, options8);
       }
       if (!parsed.output) {
-        parsed = parse3(input, options);
+        parsed = parse3(input, options8);
       }
-      return picomatch.compileRe(parsed, options, returnOutput, returnState);
+      return picomatch.compileRe(parsed, options8, returnOutput, returnState);
     };
-    picomatch.toRegex = (source, options) => {
+    picomatch.toRegex = (source, options8) => {
       try {
-        const opts = options || {};
+        const opts = options8 || {};
         return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
       } catch (err) {
-        if (options && options.debug === true)
+        if (options8 && options8.debug === true)
           throw err;
         return /$^/;
       }
@@ -5661,7 +5661,7 @@ var require_micromatch = __commonJS({
     var picomatch = require_picomatch2();
     var utils = require_utils3();
     var isEmptyString = (val) => val === "" || val === "./";
-    var micromatch2 = (list, patterns, options) => {
+    var micromatch2 = (list, patterns, options8) => {
       patterns = [].concat(patterns);
       list = [].concat(list);
       let omit2 = /* @__PURE__ */ new Set();
@@ -5670,12 +5670,12 @@ var require_micromatch = __commonJS({
       let negatives = 0;
       let onResult = (state) => {
         items.add(state.output);
-        if (options && options.onResult) {
-          options.onResult(state);
+        if (options8 && options8.onResult) {
+          options8.onResult(state);
         }
       };
       for (let i = 0; i < patterns.length; i++) {
-        let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);
+        let isMatch = picomatch(String(patterns[i]), { ...options8, onResult }, true);
         let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
         if (negated)
           negatives++;
@@ -5694,30 +5694,30 @@ var require_micromatch = __commonJS({
       }
       let result = negatives === patterns.length ? [...items] : [...keep];
       let matches = result.filter((item) => !omit2.has(item));
-      if (options && matches.length === 0) {
-        if (options.failglob === true) {
+      if (options8 && matches.length === 0) {
+        if (options8.failglob === true) {
           throw new Error(`No matches found for "${patterns.join(", ")}"`);
         }
-        if (options.nonull === true || options.nullglob === true) {
-          return options.unescape ? patterns.map((p) => p.replace(/\\/g, "")) : patterns;
+        if (options8.nonull === true || options8.nullglob === true) {
+          return options8.unescape ? patterns.map((p) => p.replace(/\\/g, "")) : patterns;
         }
       }
       return matches;
     };
     micromatch2.match = micromatch2;
-    micromatch2.matcher = (pattern, options) => picomatch(pattern, options);
-    micromatch2.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+    micromatch2.matcher = (pattern, options8) => picomatch(pattern, options8);
+    micromatch2.isMatch = (str, patterns, options8) => picomatch(patterns, options8)(str);
     micromatch2.any = micromatch2.isMatch;
-    micromatch2.not = (list, patterns, options = {}) => {
+    micromatch2.not = (list, patterns, options8 = {}) => {
       patterns = [].concat(patterns).map(String);
       let result = /* @__PURE__ */ new Set();
       let items = [];
       let onResult = (state) => {
-        if (options.onResult)
-          options.onResult(state);
+        if (options8.onResult)
+          options8.onResult(state);
         items.push(state.output);
       };
-      let matches = new Set(micromatch2(list, patterns, { ...options, onResult }));
+      let matches = new Set(micromatch2(list, patterns, { ...options8, onResult }));
       for (let item of items) {
         if (!matches.has(item)) {
           result.add(item);
@@ -5725,12 +5725,12 @@ var require_micromatch = __commonJS({
       }
       return [...result];
     };
-    micromatch2.contains = (str, pattern, options) => {
+    micromatch2.contains = (str, pattern, options8) => {
       if (typeof str !== "string") {
         throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
       }
       if (Array.isArray(pattern)) {
-        return pattern.some((p) => micromatch2.contains(str, p, options));
+        return pattern.some((p) => micromatch2.contains(str, p, options8));
       }
       if (typeof pattern === "string") {
         if (isEmptyString(str) || isEmptyString(pattern)) {
@@ -5740,47 +5740,47 @@ var require_micromatch = __commonJS({
           return true;
         }
       }
-      return micromatch2.isMatch(str, pattern, { ...options, contains: true });
+      return micromatch2.isMatch(str, pattern, { ...options8, contains: true });
     };
-    micromatch2.matchKeys = (obj, patterns, options) => {
+    micromatch2.matchKeys = (obj, patterns, options8) => {
       if (!utils.isObject(obj)) {
         throw new TypeError("Expected the first argument to be an object");
       }
-      let keys = micromatch2(Object.keys(obj), patterns, options);
+      let keys = micromatch2(Object.keys(obj), patterns, options8);
       let res = {};
       for (let key of keys)
         res[key] = obj[key];
       return res;
     };
-    micromatch2.some = (list, patterns, options) => {
+    micromatch2.some = (list, patterns, options8) => {
       let items = [].concat(list);
       for (let pattern of [].concat(patterns)) {
-        let isMatch = picomatch(String(pattern), options);
+        let isMatch = picomatch(String(pattern), options8);
         if (items.some((item) => isMatch(item))) {
           return true;
         }
       }
       return false;
     };
-    micromatch2.every = (list, patterns, options) => {
+    micromatch2.every = (list, patterns, options8) => {
       let items = [].concat(list);
       for (let pattern of [].concat(patterns)) {
-        let isMatch = picomatch(String(pattern), options);
+        let isMatch = picomatch(String(pattern), options8);
         if (!items.every((item) => isMatch(item))) {
           return false;
         }
       }
       return true;
     };
-    micromatch2.all = (str, patterns, options) => {
+    micromatch2.all = (str, patterns, options8) => {
       if (typeof str !== "string") {
         throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
       }
-      return [].concat(patterns).every((p) => picomatch(p, options)(str));
+      return [].concat(patterns).every((p) => picomatch(p, options8)(str));
     };
-    micromatch2.capture = (glob, input, options) => {
-      let posix = utils.isWindows(options);
-      let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
+    micromatch2.capture = (glob, input, options8) => {
+      let posix = utils.isWindows(options8);
+      let regex = picomatch.makeRe(String(glob), { ...options8, capture: true });
       let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
       if (match) {
         return match.slice(1).map((v) => v === void 0 ? "" : v);
@@ -5788,27 +5788,27 @@ var require_micromatch = __commonJS({
     };
     micromatch2.makeRe = (...args) => picomatch.makeRe(...args);
     micromatch2.scan = (...args) => picomatch.scan(...args);
-    micromatch2.parse = (patterns, options) => {
+    micromatch2.parse = (patterns, options8) => {
       let res = [];
       for (let pattern of [].concat(patterns || [])) {
-        for (let str of braces(String(pattern), options)) {
-          res.push(picomatch.parse(str, options));
+        for (let str of braces(String(pattern), options8)) {
+          res.push(picomatch.parse(str, options8));
         }
       }
       return res;
     };
-    micromatch2.braces = (pattern, options) => {
+    micromatch2.braces = (pattern, options8) => {
       if (typeof pattern !== "string")
         throw new TypeError("Expected a string");
-      if (options && options.nobrace === true || !/\{.*\}/.test(pattern)) {
+      if (options8 && options8.nobrace === true || !/\{.*\}/.test(pattern)) {
         return [pattern];
       }
-      return braces(pattern, options);
+      return braces(pattern, options8);
     };
-    micromatch2.braceExpand = (pattern, options) => {
+    micromatch2.braceExpand = (pattern, options8) => {
       if (typeof pattern !== "string")
         throw new TypeError("Expected a string");
-      return micromatch2.braces(pattern, { ...options, expand: true });
+      return micromatch2.braces(pattern, { ...options8, expand: true });
     };
     module.exports = micromatch2;
   }
@@ -5830,24 +5830,24 @@ var require_pattern = __commonJS({
     var REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
     var GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
     var BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
-    function isStaticPattern(pattern, options = {}) {
-      return !isDynamicPattern(pattern, options);
+    function isStaticPattern(pattern, options8 = {}) {
+      return !isDynamicPattern(pattern, options8);
     }
     exports.isStaticPattern = isStaticPattern;
-    function isDynamicPattern(pattern, options = {}) {
+    function isDynamicPattern(pattern, options8 = {}) {
       if (pattern === "") {
         return false;
       }
-      if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
+      if (options8.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
         return true;
       }
       if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
         return true;
       }
-      if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
+      if (options8.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
         return true;
       }
-      if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
+      if (options8.braceExpansion !== false && hasBraceExpansion(pattern)) {
         return true;
       }
       return false;
@@ -5931,8 +5931,8 @@ var require_pattern = __commonJS({
       });
     }
     exports.expandBraceExpansion = expandBraceExpansion;
-    function getPatternParts(pattern, options) {
-      let { parts } = micromatch2.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
+    function getPatternParts(pattern, options8) {
+      let { parts } = micromatch2.scan(pattern, Object.assign(Object.assign({}, options8), { parts: true }));
       if (parts.length === 0) {
         parts = [pattern];
       }
@@ -5943,12 +5943,12 @@ var require_pattern = __commonJS({
       return parts;
     }
     exports.getPatternParts = getPatternParts;
-    function makeRe(pattern, options) {
-      return micromatch2.makeRe(pattern, options);
+    function makeRe(pattern, options8) {
+      return micromatch2.makeRe(pattern, options8);
     }
     exports.makeRe = makeRe;
-    function convertPatternsToRe(patterns, options) {
-      return patterns.map((pattern) => makeRe(pattern, options));
+    function convertPatternsToRe(patterns, options8) {
+      return patterns.map((pattern) => makeRe(pattern, options8));
     }
     exports.convertPatternsToRe = convertPatternsToRe;
     function matchAny(entry, patternsRe) {
@@ -5970,24 +5970,24 @@ var require_merge2 = __commonJS({
       const streamsQueue = [];
       const args = slice.call(arguments);
       let merging = false;
-      let options = args[args.length - 1];
-      if (options && !Array.isArray(options) && options.pipe == null) {
+      let options8 = args[args.length - 1];
+      if (options8 && !Array.isArray(options8) && options8.pipe == null) {
         args.pop();
       } else {
-        options = {};
+        options8 = {};
       }
-      const doEnd = options.end !== false;
-      const doPipeError = options.pipeError === true;
-      if (options.objectMode == null) {
-        options.objectMode = true;
+      const doEnd = options8.end !== false;
+      const doPipeError = options8.pipeError === true;
+      if (options8.objectMode == null) {
+        options8.objectMode = true;
       }
-      if (options.highWaterMark == null) {
-        options.highWaterMark = 64 * 1024;
+      if (options8.highWaterMark == null) {
+        options8.highWaterMark = 64 * 1024;
       }
-      const mergedStream = PassThrough(options);
+      const mergedStream = PassThrough(options8);
       function addStream() {
         for (let i = 0, len = arguments.length; i < len; i++) {
-          streamsQueue.push(pauseStreams(arguments[i], options));
+          streamsQueue.push(pauseStreams(arguments[i], options8));
         }
         mergeStream();
         return this;
@@ -6058,10 +6058,10 @@ var require_merge2 = __commonJS({
       }
       return mergedStream;
     }
-    function pauseStreams(streams, options) {
+    function pauseStreams(streams, options8) {
       if (!Array.isArray(streams)) {
         if (!streams._readableState && streams.pipe) {
-          streams = streams.pipe(PassThrough(options));
+          streams = streams.pipe(PassThrough(options8));
         }
         if (!streams._readableState || !streams.pause || !streams.pipe) {
           throw new Error("Only readable stream can be merged.");
@@ -6069,7 +6069,7 @@ var require_merge2 = __commonJS({
         streams.pause();
       } else {
         for (let i = 0, len = streams.length; i < len; i++) {
-          streams[i] = pauseStreams(streams[i], options);
+          streams[i] = pauseStreams(streams[i], options8);
         }
       }
       return streams;
@@ -7488,15 +7488,15 @@ var require_stream3 = __commonJS({
         this._walkStream = fsWalk.walkStream;
         this._stat = fsStat.stat;
       }
-      dynamic(root, options) {
-        return this._walkStream(root, options);
+      dynamic(root, options8) {
+        return this._walkStream(root, options8);
       }
-      static(patterns, options) {
+      static(patterns, options8) {
         const filepaths = patterns.map(this._getFullEntryPath, this);
         const stream = new stream_1.PassThrough({ objectMode: true });
         stream._write = (index, _enc, done) => {
-          return this._getEntry(filepaths[index], patterns[index], options).then((entry) => {
-            if (entry !== null && options.entryFilter(entry)) {
+          return this._getEntry(filepaths[index], patterns[index], options8).then((entry) => {
+            if (entry !== null && options8.entryFilter(entry)) {
               stream.push(entry);
             }
             if (index === filepaths.length - 1) {
@@ -7510,9 +7510,9 @@ var require_stream3 = __commonJS({
         }
         return stream;
       }
-      _getEntry(filepath, pattern, options) {
+      _getEntry(filepath, pattern, options8) {
         return this._getStat(filepath).then((stats) => this._makeEntry(stats, pattern)).catch((error) => {
-          if (options.errorFilter(error)) {
+          if (options8.errorFilter(error)) {
             return null;
           }
           throw error;
@@ -7544,9 +7544,9 @@ var require_async5 = __commonJS({
         this._walkAsync = fsWalk.walk;
         this._readerStream = new stream_1.default(this._settings);
       }
-      dynamic(root, options) {
+      dynamic(root, options8) {
         return new Promise((resolve2, reject) => {
-          this._walkAsync(root, options, (error, entries) => {
+          this._walkAsync(root, options8, (error, entries) => {
             if (error === null) {
               resolve2(entries);
             } else {
@@ -7555,9 +7555,9 @@ var require_async5 = __commonJS({
           });
         });
       }
-      async static(patterns, options) {
+      async static(patterns, options8) {
         const entries = [];
-        const stream = this._readerStream.static(patterns, options);
+        const stream = this._readerStream.static(patterns, options8);
         return new Promise((resolve2, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
@@ -7911,15 +7911,15 @@ var require_async6 = __commonJS({
       }
       async read(task) {
         const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const entries = await this.api(root, task, options);
-        return entries.map((entry) => options.transform(entry));
+        const options8 = this._getReaderOptions(task);
+        const entries = await this.api(root, task, options8);
+        return entries.map((entry) => options8.transform(entry));
       }
-      api(root, task, options) {
+      api(root, task, options8) {
         if (task.dynamic) {
-          return this._reader.dynamic(root, options);
+          return this._reader.dynamic(root, options8);
         }
-        return this._reader.static(task.patterns, options);
+        return this._reader.static(task.patterns, options8);
       }
     };
     exports.default = ProviderAsync;
@@ -7941,19 +7941,19 @@ var require_stream4 = __commonJS({
       }
       read(task) {
         const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const source = this.api(root, task, options);
+        const options8 = this._getReaderOptions(task);
+        const source = this.api(root, task, options8);
         const destination = new stream_1.Readable({ objectMode: true, read: () => {
         } });
-        source.once("error", (error) => destination.emit("error", error)).on("data", (entry) => destination.emit("data", options.transform(entry))).once("end", () => destination.emit("end"));
+        source.once("error", (error) => destination.emit("error", error)).on("data", (entry) => destination.emit("data", options8.transform(entry))).once("end", () => destination.emit("end"));
         destination.once("close", () => source.destroy());
         return destination;
       }
-      api(root, task, options) {
+      api(root, task, options8) {
         if (task.dynamic) {
-          return this._reader.dynamic(root, options);
+          return this._reader.dynamic(root, options8);
         }
-        return this._reader.static(task.patterns, options);
+        return this._reader.static(task.patterns, options8);
       }
     };
     exports.default = ProviderStream;
@@ -7974,27 +7974,27 @@ var require_sync5 = __commonJS({
         this._walkSync = fsWalk.walkSync;
         this._statSync = fsStat.statSync;
       }
-      dynamic(root, options) {
-        return this._walkSync(root, options);
+      dynamic(root, options8) {
+        return this._walkSync(root, options8);
       }
-      static(patterns, options) {
+      static(patterns, options8) {
         const entries = [];
         for (const pattern of patterns) {
           const filepath = this._getFullEntryPath(pattern);
-          const entry = this._getEntry(filepath, pattern, options);
-          if (entry === null || !options.entryFilter(entry)) {
+          const entry = this._getEntry(filepath, pattern, options8);
+          if (entry === null || !options8.entryFilter(entry)) {
             continue;
           }
           entries.push(entry);
         }
         return entries;
       }
-      _getEntry(filepath, pattern, options) {
+      _getEntry(filepath, pattern, options8) {
         try {
           const stats = this._getStat(filepath);
           return this._makeEntry(stats, pattern);
         } catch (error) {
-          if (options.errorFilter(error)) {
+          if (options8.errorFilter(error)) {
             return null;
           }
           throw error;
@@ -8022,15 +8022,15 @@ var require_sync6 = __commonJS({
       }
       read(task) {
         const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const entries = this.api(root, task, options);
-        return entries.map(options.transform);
+        const options8 = this._getReaderOptions(task);
+        const entries = this.api(root, task, options8);
+        return entries.map(options8.transform);
       }
-      api(root, task, options) {
+      api(root, task, options8) {
         if (task.dynamic) {
-          return this._reader.dynamic(root, options);
+          return this._reader.dynamic(root, options8);
         }
-        return this._reader.static(task.patterns, options);
+        return this._reader.static(task.patterns, options8);
       }
     };
     exports.default = ProviderSync;
@@ -8107,35 +8107,35 @@ var require_out4 = __commonJS({
     var sync_1 = require_sync6();
     var settings_1 = require_settings4();
     var utils = require_utils4();
-    async function FastGlob(source, options) {
+    async function FastGlob(source, options8) {
       assertPatternsInput(source);
-      const works = getWorks(source, async_1.default, options);
+      const works = getWorks(source, async_1.default, options8);
       const result = await Promise.all(works);
       return utils.array.flatten(result);
     }
     (function(FastGlob2) {
-      function sync(source, options) {
+      function sync(source, options8) {
         assertPatternsInput(source);
-        const works = getWorks(source, sync_1.default, options);
+        const works = getWorks(source, sync_1.default, options8);
         return utils.array.flatten(works);
       }
       FastGlob2.sync = sync;
-      function stream(source, options) {
+      function stream(source, options8) {
         assertPatternsInput(source);
-        const works = getWorks(source, stream_1.default, options);
+        const works = getWorks(source, stream_1.default, options8);
         return utils.stream.merge(works);
       }
       FastGlob2.stream = stream;
-      function generateTasks(source, options) {
+      function generateTasks(source, options8) {
         assertPatternsInput(source);
         const patterns = patternManager.transform([].concat(source));
-        const settings = new settings_1.default(options);
+        const settings = new settings_1.default(options8);
         return taskManager.generate(patterns, settings);
       }
       FastGlob2.generateTasks = generateTasks;
-      function isDynamicPattern(source, options) {
+      function isDynamicPattern(source, options8) {
         assertPatternsInput(source);
-        const settings = new settings_1.default(options);
+        const settings = new settings_1.default(options8);
         return utils.pattern.isDynamicPattern(source, settings);
       }
       FastGlob2.isDynamicPattern = isDynamicPattern;
@@ -8145,9 +8145,9 @@ var require_out4 = __commonJS({
       }
       FastGlob2.escapePath = escapePath;
     })(FastGlob || (FastGlob = {}));
-    function getWorks(source, _Provider, options) {
+    function getWorks(source, _Provider, options8) {
       const patterns = patternManager.transform([].concat(source));
-      const settings = new settings_1.default(options);
+      const settings = new settings_1.default(options8);
       const tasks = taskManager.generate(patterns, settings);
       const provider = new _Provider(settings);
       return tasks.map(provider.read, provider);
@@ -8177,13 +8177,13 @@ var require_base = __commonJS({
       /*istanbul ignore start*/
       /*istanbul ignore end*/
       diff: function diff(oldString, newString) {
-        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-        var callback = options.callback;
-        if (typeof options === "function") {
-          callback = options;
-          options = {};
+        var options8 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+        var callback = options8.callback;
+        if (typeof options8 === "function") {
+          callback = options8;
+          options8 = {};
         }
-        this.options = options;
+        this.options = options8;
         var self = this;
         function done(value) {
           if (callback) {
@@ -8202,8 +8202,8 @@ var require_base = __commonJS({
         var newLen = newString.length, oldLen = oldString.length;
         var editLength = 1;
         var maxEditLength = newLen + oldLen;
-        if (options.maxEditLength) {
-          maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+        if (options8.maxEditLength) {
+          maxEditLength = Math.min(maxEditLength, options8.maxEditLength);
         }
         var bestPath = [{
           newPos: -1,
@@ -8432,22 +8432,22 @@ var require_readlines = __commonJS({
     "use strict";
     var fs6 = __require("fs");
     var LineByLine = class {
-      constructor(file, options) {
-        options = options || {};
-        if (!options.readChunk)
-          options.readChunk = 1024;
-        if (!options.newLineCharacter) {
-          options.newLineCharacter = 10;
+      constructor(file, options8) {
+        options8 = options8 || {};
+        if (!options8.readChunk)
+          options8.readChunk = 1024;
+        if (!options8.newLineCharacter) {
+          options8.newLineCharacter = 10;
         } else {
-          options.newLineCharacter = options.newLineCharacter.charCodeAt(0);
+          options8.newLineCharacter = options8.newLineCharacter.charCodeAt(0);
         }
         if (typeof file === "number") {
           this.fd = file;
         } else {
           this.fd = fs6.openSync(file, "r");
         }
-        this.options = options;
-        this.newLineCharacter = options.newLineCharacter;
+        this.options = options8;
+        this.newLineCharacter = options8.newLineCharacter;
         this.reset();
       }
       _searchInBuffer(buffer, hexNeedle) {
@@ -9008,16 +9008,16 @@ var require_chalk2 = __commonJS({
     var levelMapping = ["ansi", "ansi", "ansi256", "ansi16m"];
     var skipModels = /* @__PURE__ */ new Set(["gray"]);
     var styles = /* @__PURE__ */ Object.create(null);
-    function applyOptions(obj, options) {
-      options = options || {};
+    function applyOptions(obj, options8) {
+      options8 = options8 || {};
       const scLevel = stdoutColor ? stdoutColor.level : 0;
-      obj.level = options.level === void 0 ? scLevel : options.level;
-      obj.enabled = "enabled" in options ? options.enabled : obj.level > 0;
+      obj.level = options8.level === void 0 ? scLevel : options8.level;
+      obj.enabled = "enabled" in options8 ? options8.enabled : obj.level > 0;
     }
-    function Chalk(options) {
+    function Chalk(options8) {
       if (!this || !(this instanceof Chalk) || this.template) {
         const chalk = {};
-        applyOptions(chalk, options);
+        applyOptions(chalk, options8);
         chalk.template = function() {
           const args = [].slice.call(arguments);
           return chalkTag.apply(null, [chalk.template].concat(args));
@@ -9027,7 +9027,7 @@ var require_chalk2 = __commonJS({
         chalk.template.constructor = Chalk;
         return chalk.template;
       }
-      applyOptions(this, options);
+      applyOptions(this, options8);
     }
     if (isSimpleWindowsTerm) {
       ansiStyles.blue.open = "\x1B[94m";
@@ -9241,18 +9241,18 @@ var require_lib3 = __commonJS({
       }
       return highlighted;
     }
-    function shouldHighlight(options) {
-      return !!_chalk.supportsColor || options.forceColor;
+    function shouldHighlight(options8) {
+      return !!_chalk.supportsColor || options8.forceColor;
     }
-    function getChalk(options) {
-      return options.forceColor ? new _chalk.constructor({
+    function getChalk(options8) {
+      return options8.forceColor ? new _chalk.constructor({
         enabled: true,
         level: 1
       }) : _chalk;
     }
-    function highlight(code, options = {}) {
-      if (code !== "" && shouldHighlight(options)) {
-        const chalk = getChalk(options);
+    function highlight(code, options8 = {}) {
+      if (code !== "" && shouldHighlight(options8)) {
+        const chalk = getChalk(options8);
         const defs = getDefs(chalk);
         return highlightTokens(defs, code);
       } else {
@@ -9617,7 +9617,7 @@ var require_re = __commonJS({
 var require_parse_options = __commonJS({
   "node_modules/semver/internal/parse-options.js"(exports, module) {
     var opts = ["includePrerelease", "loose", "rtl"];
-    var parseOptions = (options) => !options ? {} : typeof options !== "object" ? { loose: true } : opts.filter((k) => options[k]).reduce((o, k) => {
+    var parseOptions = (options8) => !options8 ? {} : typeof options8 !== "object" ? { loose: true } : opts.filter((k) => options8[k]).reduce((o, k) => {
       o[k] = true;
       return o;
     }, {});
@@ -9655,10 +9655,10 @@ var require_semver = __commonJS({
     var parseOptions = require_parse_options();
     var { compareIdentifiers } = require_identifiers();
     var SemVer = class {
-      constructor(version, options) {
-        options = parseOptions(options);
+      constructor(version, options8) {
+        options8 = parseOptions(options8);
         if (version instanceof SemVer) {
-          if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+          if (version.loose === !!options8.loose && version.includePrerelease === !!options8.includePrerelease) {
             return version;
           } else {
             version = version.version;
@@ -9671,11 +9671,11 @@ var require_semver = __commonJS({
             `version is longer than ${MAX_LENGTH} characters`
           );
         }
-        debug("SemVer", version, options);
-        this.options = options;
-        this.loose = !!options.loose;
-        this.includePrerelease = !!options.includePrerelease;
-        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        debug("SemVer", version, options8);
+        this.options = options8;
+        this.loose = !!options8.loose;
+        this.includePrerelease = !!options8.includePrerelease;
+        const m = version.trim().match(options8.loose ? re[t.LOOSE] : re[t.FULL]);
         if (!m) {
           throw new TypeError(`Invalid Version: ${version}`);
         }
@@ -10357,29 +10357,29 @@ var require_lru_cache = __commonJS({
     function naiveLength() {
       return 1;
     }
-    function LRUCache(options) {
+    function LRUCache(options8) {
       if (!(this instanceof LRUCache)) {
-        return new LRUCache(options);
+        return new LRUCache(options8);
       }
-      if (typeof options === "number") {
-        options = { max: options };
+      if (typeof options8 === "number") {
+        options8 = { max: options8 };
       }
-      if (!options) {
-        options = {};
+      if (!options8) {
+        options8 = {};
       }
-      var max = this[MAX] = options.max;
+      var max = this[MAX] = options8.max;
       if (!max || !(typeof max === "number") || max <= 0) {
         this[MAX] = Infinity;
       }
-      var lc = options.length || naiveLength;
+      var lc = options8.length || naiveLength;
       if (typeof lc !== "function") {
         lc = naiveLength;
       }
       this[LENGTH_CALCULATOR] = lc;
-      this[ALLOW_STALE] = options.stale || false;
-      this[MAX_AGE] = options.maxAge || 0;
-      this[DISPOSE] = options.dispose;
-      this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+      this[ALLOW_STALE] = options8.stale || false;
+      this[MAX_AGE] = options8.maxAge || 0;
+      this[DISPOSE] = options8.dispose;
+      this[NO_DISPOSE_ON_SET] = options8.noDisposeOnSet || false;
       this.reset();
     }
     Object.defineProperty(LRUCache.prototype, "max", {
@@ -10799,10 +10799,10 @@ var require_fnmatch = __commonJS({
       Object.defineProperty(String.prototype, desc);
     }
     minimatch.filter = filter;
-    function filter(pattern, options) {
-      options = options || {};
+    function filter(pattern, options8) {
+      options8 = options8 || {};
       return function(p, i, list) {
-        return minimatch(p, pattern, options);
+        return minimatch(p, pattern, options8);
       };
     }
     function ext(a, b) {
@@ -10821,11 +10821,11 @@ var require_fnmatch = __commonJS({
       if (!def || !Object.keys(def).length)
         return minimatch;
       var orig = minimatch;
-      var m = function minimatch2(p, pattern, options) {
-        return orig.minimatch(p, pattern, ext(def, options));
+      var m = function minimatch2(p, pattern, options8) {
+        return orig.minimatch(p, pattern, ext(def, options8));
       };
-      m.Minimatch = function Minimatch2(pattern, options) {
-        return new orig.Minimatch(pattern, ext(def, options));
+      m.Minimatch = function Minimatch2(pattern, options8) {
+        return new orig.Minimatch(pattern, ext(def, options8));
       };
       return m;
     };
@@ -10834,37 +10834,37 @@ var require_fnmatch = __commonJS({
         return Minimatch;
       return minimatch.defaults(def).Minimatch;
     };
-    function minimatch(p, pattern, options) {
+    function minimatch(p, pattern, options8) {
       if (typeof pattern !== "string") {
         throw new TypeError("glob pattern string required");
       }
-      if (!options)
-        options = {};
-      if (!options.nocomment && pattern.charAt(0) === "#") {
+      if (!options8)
+        options8 = {};
+      if (!options8.nocomment && pattern.charAt(0) === "#") {
         return false;
       }
       if (pattern.trim() === "")
         return p === "";
-      return new Minimatch(pattern, options).match(p);
+      return new Minimatch(pattern, options8).match(p);
     }
-    function Minimatch(pattern, options) {
+    function Minimatch(pattern, options8) {
       if (!(this instanceof Minimatch)) {
-        return new Minimatch(pattern, options, cache);
+        return new Minimatch(pattern, options8, cache);
       }
       if (typeof pattern !== "string") {
         throw new TypeError("glob pattern string required");
       }
-      if (!options)
-        options = {};
+      if (!options8)
+        options8 = {};
       if (platform === "win32") {
         pattern = pattern.split("\\").join("/");
       }
-      var cacheKey = pattern + "\n" + sigmund(options);
+      var cacheKey = pattern + "\n" + sigmund(options8);
       var cached = minimatch.cache.get(cacheKey);
       if (cached)
         return cached;
       minimatch.cache.set(cacheKey, this);
-      this.options = options;
+      this.options = options8;
       this.set = [];
       this.pattern = pattern;
       this.regexp = null;
@@ -10878,8 +10878,8 @@ var require_fnmatch = __commonJS({
       if (this._made)
         return;
       var pattern = this.pattern;
-      var options = this.options;
-      if (!options.nocomment && pattern.charAt(0) === "#") {
+      var options8 = this.options;
+      if (!options8.nocomment && pattern.charAt(0) === "#") {
         this.comment = true;
         return;
       }
@@ -10889,29 +10889,29 @@ var require_fnmatch = __commonJS({
       }
       this.parseNegate();
       var set = this.globSet = this.braceExpand();
-      if (options.debug)
+      if (options8.debug)
         console.error(this.pattern, set);
       set = this.globParts = set.map(function(s) {
         return s.split(slashSplit);
       });
-      if (options.debug)
+      if (options8.debug)
         console.error(this.pattern, set);
       set = set.map(function(s, si, set2) {
         return s.map(this.parse, this);
       }, this);
-      if (options.debug)
+      if (options8.debug)
         console.error(this.pattern, set);
       set = set.filter(function(s) {
         return -1 === s.indexOf(false);
       });
-      if (options.debug)
+      if (options8.debug)
         console.error(this.pattern, set);
       this.set = set;
     }
     Minimatch.prototype.parseNegate = parseNegate;
     function parseNegate() {
-      var pattern = this.pattern, negate = false, options = this.options, negateOffset = 0;
-      if (options.nonegate)
+      var pattern = this.pattern, negate = false, options8 = this.options, negateOffset = 0;
+      if (options8.nonegate)
         return;
       for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) {
         negate = !negate;
@@ -10921,17 +10921,17 @@ var require_fnmatch = __commonJS({
         this.pattern = pattern.substr(negateOffset);
       this.negate = negate;
     }
-    minimatch.braceExpand = function(pattern, options) {
-      return new Minimatch(pattern, options).braceExpand();
+    minimatch.braceExpand = function(pattern, options8) {
+      return new Minimatch(pattern, options8).braceExpand();
     };
     Minimatch.prototype.braceExpand = braceExpand;
-    function braceExpand(pattern, options) {
-      options = options || this.options;
+    function braceExpand(pattern, options8) {
+      options8 = options8 || this.options;
       pattern = typeof pattern === "undefined" ? this.pattern : pattern;
       if (typeof pattern === "undefined") {
         throw new Error("undefined pattern");
       }
-      if (options.nobrace || !pattern.match(/\{.*\}/)) {
+      if (options8.nobrace || !pattern.match(/\{.*\}/)) {
         return [pattern];
       }
       var escaping = false;
@@ -10949,14 +10949,14 @@ var require_fnmatch = __commonJS({
         if (prefix === null) {
           return [pattern];
         }
-        var tail = braceExpand(pattern.substr(i), options);
+        var tail = braceExpand(pattern.substr(i), options8);
         return tail.map(function(t) {
           return prefix + t;
         });
       }
       var numset = pattern.match(/^\{(-?[0-9]+)\.\.(-?[0-9]+)\}/);
       if (numset) {
-        var suf = braceExpand(pattern.substr(numset[0].length), options), start = +numset[1], end = +numset[2], inc = start > end ? -1 : 1, set = [];
+        var suf = braceExpand(pattern.substr(numset[0].length), options8), start = +numset[1], end = +numset[2], inc = start > end ? -1 : 1, set = [];
         for (var i = start; i != end + inc; i += inc) {
           for (var ii = 0, ll = suf.length; ii < ll; ii++) {
             set.push(i + suf[ii]);
@@ -11008,12 +11008,12 @@ var require_fnmatch = __commonJS({
           }
         }
       if (depth !== 0) {
-        return braceExpand("\\" + pattern, options);
+        return braceExpand("\\" + pattern, options8);
       }
-      var suf = braceExpand(pattern.substr(i), options);
+      var suf = braceExpand(pattern.substr(i), options8);
       var addBraces = set.length === 1;
       set = set.map(function(p) {
-        return braceExpand(p, options);
+        return braceExpand(p, options8);
       });
       set = set.reduce(function(l2, r) {
         return l2.concat(r);
@@ -11034,12 +11034,12 @@ var require_fnmatch = __commonJS({
     Minimatch.prototype.parse = parse3;
     var SUBPARSE = {};
     function parse3(pattern, isSub) {
-      var options = this.options;
-      if (!options.noglobstar && pattern === "**")
+      var options8 = this.options;
+      if (!options8.noglobstar && pattern === "**")
         return GLOBSTAR;
       if (pattern === "")
         return "";
-      var re = "", hasMagic = !!options.nocase, escaping = false, patternListStack = [], plType, stateChar, inClass = false, reClassStart = -1, classStart = -1, patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+      var re = "", hasMagic = !!options8.nocase, escaping = false, patternListStack = [], plType, stateChar, inClass = false, reClassStart = -1, classStart = -1, patternStart = pattern.charAt(0) === "." ? "" : options8.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
       function clearStateChar() {
         if (stateChar) {
           switch (stateChar) {
@@ -11059,7 +11059,7 @@ var require_fnmatch = __commonJS({
         }
       }
       for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
-        if (options.debug) {
+        if (options8.debug) {
           console.error("%s	%s %s %j", pattern, i, re, c);
         }
         if (escaping && reSpecials[c]) {
@@ -11080,7 +11080,7 @@ var require_fnmatch = __commonJS({
             case "+":
             case "@":
             case "!":
-              if (options.debug) {
+              if (options8.debug) {
                 console.error("%s	%s %s %j <-- stateChar", pattern, i, re, c);
               }
               if (inClass) {
@@ -11091,7 +11091,7 @@ var require_fnmatch = __commonJS({
               }
               clearStateChar();
               stateChar = c;
-              if (options.noext)
+              if (options8.noext)
                 clearStateChar();
               continue;
             case "(":
@@ -11210,13 +11210,13 @@ var require_fnmatch = __commonJS({
       if (!hasMagic) {
         return globUnescape(pattern);
       }
-      var flags = options.nocase ? "i" : "", regExp = new RegExp("^" + re + "$", flags);
+      var flags = options8.nocase ? "i" : "", regExp = new RegExp("^" + re + "$", flags);
       regExp._glob = pattern;
       regExp._src = re;
       return regExp;
     }
-    minimatch.makeRe = function(pattern, options) {
-      return new Minimatch(pattern, options || {}).makeRe();
+    minimatch.makeRe = function(pattern, options8) {
+      return new Minimatch(pattern, options8 || {}).makeRe();
     };
     Minimatch.prototype.makeRe = makeRe;
     function makeRe() {
@@ -11225,8 +11225,8 @@ var require_fnmatch = __commonJS({
       var set = this.set;
       if (!set.length)
         return this.regexp = false;
-      var options = this.options;
-      var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot, flags = options.nocase ? "i" : "";
+      var options8 = this.options;
+      var twoStar = options8.noglobstar ? star : options8.dot ? twoStarDot : twoStarNoDot, flags = options8.nocase ? "i" : "";
       var re = set.map(function(pattern) {
         return pattern.map(function(p) {
           return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
@@ -11241,12 +11241,12 @@ var require_fnmatch = __commonJS({
         return this.regexp = false;
       }
     }
-    minimatch.match = function(list, pattern, options) {
-      var mm = new Minimatch(pattern, options);
+    minimatch.match = function(list, pattern, options8) {
+      var mm = new Minimatch(pattern, options8);
       list = list.filter(function(f) {
         return mm.match(f);
       });
-      if (options.nonull && !list.length) {
+      if (options8.nonull && !list.length) {
         list.push(pattern);
       }
       return list;
@@ -11259,12 +11259,12 @@ var require_fnmatch = __commonJS({
         return f === "";
       if (f === "/" && partial)
         return true;
-      var options = this.options;
+      var options8 = this.options;
       if (platform === "win32") {
         f = f.split("\\").join("/");
       }
       f = f.split(slashSplit);
-      if (options.debug) {
+      if (options8.debug) {
         console.error(this.pattern, "split", f);
       }
       var set = this.set;
@@ -11272,18 +11272,18 @@ var require_fnmatch = __commonJS({
         var pattern = set[i];
         var hit = this.matchOne(f, pattern, partial);
         if (hit) {
-          if (options.flipNegate)
+          if (options8.flipNegate)
             return true;
           return !this.negate;
         }
       }
-      if (options.flipNegate)
+      if (options8.flipNegate)
         return false;
       return this.negate;
     }
     Minimatch.prototype.matchOne = function(file, pattern, partial) {
-      var options = this.options;
-      if (options.debug) {
+      var options8 = this.options;
+      if (options8.debug) {
         console.error(
           "matchOne",
           {
@@ -11293,31 +11293,31 @@ var require_fnmatch = __commonJS({
           }
         );
       }
-      if (options.matchBase && pattern.length === 1) {
+      if (options8.matchBase && pattern.length === 1) {
         file = path11.basename(file.join("/")).split("/");
       }
-      if (options.debug) {
+      if (options8.debug) {
         console.error("matchOne", file.length, pattern.length);
       }
       for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
-        if (options.debug) {
+        if (options8.debug) {
           console.error("matchOne loop");
         }
         var p = pattern[pi], f = file[fi];
-        if (options.debug) {
+        if (options8.debug) {
           console.error(pattern, p, f);
         }
         if (p === false)
           return false;
         if (p === GLOBSTAR) {
-          if (options.debug)
+          if (options8.debug)
             console.error("GLOBSTAR", [pattern, p, f]);
           var fr = fi, pr = pi + 1;
           if (pr === pl) {
-            if (options.debug)
+            if (options8.debug)
               console.error("** at the end");
             for (; fi < fl; fi++) {
-              if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
+              if (file[fi] === "." || file[fi] === ".." || !options8.dot && file[fi].charAt(0) === ".")
                 return false;
             }
             return true;
@@ -11325,7 +11325,7 @@ var require_fnmatch = __commonJS({
           WHILE:
             while (fr < fl) {
               var swallowee = file[fr];
-              if (options.debug) {
+              if (options8.debug) {
                 console.error(
                   "\nglobstar while",
                   file,
@@ -11336,16 +11336,16 @@ var require_fnmatch = __commonJS({
                 );
               }
               if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-                if (options.debug)
+                if (options8.debug)
                   console.error("globstar found match!", fr, fl, swallowee);
                 return true;
               } else {
-                if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
-                  if (options.debug)
+                if (swallowee === "." || swallowee === ".." || !options8.dot && swallowee.charAt(0) === ".") {
+                  if (options8.debug)
                     console.error("dot detected!", file, fr, pattern, pr);
                   break WHILE;
                 }
-                if (options.debug)
+                if (options8.debug)
                   console.error("globstar swallow a segment, and continue");
                 fr++;
               }
@@ -11358,17 +11358,17 @@ var require_fnmatch = __commonJS({
         }
         var hit;
         if (typeof p === "string") {
-          if (options.nocase) {
+          if (options8.nocase) {
             hit = f.toLowerCase() === p.toLowerCase();
           } else {
             hit = f === p;
           }
-          if (options.debug) {
+          if (options8.debug) {
             console.error("string match", p, f, hit);
           }
         } else {
           hit = f.match(p);
-          if (options.debug) {
+          if (options8.debug) {
             console.error("pattern match", p, f, hit);
           }
         }
@@ -11770,12 +11770,12 @@ var require_src = __commonJS({
       glob = glob.replace(/\*\*/g, "{*,**/**/**}");
       return fnmatch_1.default(filepath, glob, matchOptions);
     }
-    function getConfigFileNames(filepath, options) {
+    function getConfigFileNames(filepath, options8) {
       var paths = [];
       do {
         filepath = path11.dirname(filepath);
-        paths.push(path11.join(filepath, options.config));
-      } while (filepath !== options.root);
+        paths.push(path11.join(filepath, options8.config));
+      } while (filepath !== options8.root);
       return paths;
     }
     function processMatches(matches, version) {
@@ -11790,14 +11790,14 @@ var require_src = __commonJS({
       }
       return matches;
     }
-    function processOptions(options, filepath) {
-      if (options === void 0) {
-        options = {};
+    function processOptions(options8, filepath) {
+      if (options8 === void 0) {
+        options8 = {};
       }
       return {
-        config: options.config || ".editorconfig",
-        version: options.version || package_json_1.default.version,
-        root: path11.resolve(options.root || path11.parse(filepath).root)
+        config: options8.config || ".editorconfig",
+        version: options8.version || package_json_1.default.version,
+        root: path11.resolve(options8.root || path11.parse(filepath).root)
       };
     }
     function buildFullGlob(pathPrefix, glob) {
@@ -11813,16 +11813,16 @@ var require_src = __commonJS({
       }
       return path11.join(pathPrefix, glob);
     }
-    function extendProps(props, options) {
+    function extendProps(props, options8) {
       if (props === void 0) {
         props = {};
       }
-      if (options === void 0) {
-        options = {};
+      if (options8 === void 0) {
+        options8 = {};
       }
-      for (var key in options) {
-        if (options.hasOwnProperty(key)) {
-          var value = options[key];
+      for (var key in options8) {
+        if (options8.hasOwnProperty(key)) {
+          var value = options8[key];
           var key2 = key.toLowerCase();
           var value2 = value;
           if (knownProps[key2]) {
@@ -11840,12 +11840,12 @@ var require_src = __commonJS({
       }
       return props;
     }
-    function parseFromConfigs(configs, filepath, options) {
+    function parseFromConfigs(configs, filepath, options8) {
       return processMatches(configs.reverse().reduce(function(matches, file) {
         var pathPrefix = path11.dirname(file.name);
         file.contents.forEach(function(section) {
           var glob = section[0];
-          var options2 = section[1];
+          var options22 = section[1];
           if (!glob) {
             return;
           }
@@ -11853,10 +11853,10 @@ var require_src = __commonJS({
           if (!fnmatch(filepath, fullGlob)) {
             return;
           }
-          matches = extendProps(matches, options2);
+          matches = extendProps(matches, options22);
         });
         return matches;
-      }, {}), options.version);
+      }, {}), options8.version);
     }
     function getConfigsForFiles(files) {
       var configs = [];
@@ -11907,24 +11907,24 @@ var require_src = __commonJS({
       });
       return files;
     }
-    function opts(filepath, options) {
-      if (options === void 0) {
-        options = {};
+    function opts(filepath, options8) {
+      if (options8 === void 0) {
+        options8 = {};
       }
       var resolvedFilePath = path11.resolve(filepath);
       return [
         resolvedFilePath,
-        processOptions(options, resolvedFilePath)
+        processOptions(options8, resolvedFilePath)
       ];
     }
-    function parseFromFiles(filepath, files, options) {
-      if (options === void 0) {
-        options = {};
+    function parseFromFiles(filepath, files, options8) {
+      if (options8 === void 0) {
+        options8 = {};
       }
       return __awaiter2(this, void 0, void 0, function() {
         var _a, resolvedFilePath, processedOptions;
         return __generator2(this, function(_b) {
-          _a = opts(filepath, options), resolvedFilePath = _a[0], processedOptions = _a[1];
+          _a = opts(filepath, options8), resolvedFilePath = _a[0], processedOptions = _a[1];
           return [2, files.then(getConfigsForFiles).then(function(configs) {
             return parseFromConfigs(configs, resolvedFilePath, processedOptions);
           })];
@@ -11932,11 +11932,11 @@ var require_src = __commonJS({
       });
     }
     exports.parseFromFiles = parseFromFiles;
-    function parseFromFilesSync(filepath, files, options) {
-      if (options === void 0) {
-        options = {};
+    function parseFromFilesSync(filepath, files, options8) {
+      if (options8 === void 0) {
+        options8 = {};
       }
-      var _a = opts(filepath, options), resolvedFilePath = _a[0], processedOptions = _a[1];
+      var _a = opts(filepath, options8), resolvedFilePath = _a[0], processedOptions = _a[1];
       return parseFromConfigs(getConfigsForFiles(files), resolvedFilePath, processedOptions);
     }
     exports.parseFromFilesSync = parseFromFilesSync;
@@ -14908,7 +14908,7 @@ var require_ignore = __commonJS({
         return this._test(path11, this._testCache, true);
       }
     };
-    var factory = (options) => new Ignore(options);
+    var factory = (options8) => new Ignore(options8);
     var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
@@ -15568,19 +15568,19 @@ function rootIndent() {
     queue: []
   };
 }
-function makeIndent(ind, options) {
+function makeIndent(ind, options8) {
   return generateInd(ind, {
     type: "indent"
-  }, options);
+  }, options8);
 }
-function makeAlign(indent2, widthOrDoc, options) {
+function makeAlign(indent2, widthOrDoc, options8) {
   if (widthOrDoc === Number.NEGATIVE_INFINITY) {
     return indent2.root || rootIndent();
   }
   if (widthOrDoc < 0) {
     return generateInd(indent2, {
       type: "dedent"
-    }, options);
+    }, options8);
   }
   if (!widthOrDoc) {
     return indent2;
@@ -15595,9 +15595,9 @@ function makeAlign(indent2, widthOrDoc, options) {
   return generateInd(indent2, {
     type: alignType,
     n: widthOrDoc
-  }, options);
+  }, options8);
 }
-function generateInd(ind, newPart, options) {
+function generateInd(ind, newPart, options8) {
   const queue = newPart.type === "dedent" ? ind.queue.slice(0, -1) : [...ind.queue, newPart];
   let value = "";
   let length = 0;
@@ -15607,10 +15607,10 @@ function generateInd(ind, newPart, options) {
     switch (part.type) {
       case "indent":
         flush();
-        if (options.useTabs) {
+        if (options8.useTabs) {
           addTabs(1);
         } else {
-          addSpaces(options.tabWidth);
+          addSpaces(options8.tabWidth);
         }
         break;
       case "stringAlign":
@@ -15635,14 +15635,14 @@ function generateInd(ind, newPart, options) {
   };
   function addTabs(count) {
     value += "	".repeat(count);
-    length += options.tabWidth * count;
+    length += options8.tabWidth * count;
   }
   function addSpaces(count) {
     value += " ".repeat(count);
     length += count;
   }
   function flush() {
-    if (options.useTabs) {
+    if (options8.useTabs) {
       flushTabs();
     } else {
       flushSpaces();
@@ -15793,10 +15793,10 @@ function fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat
   }
   return false;
 }
-function printDocToString(doc2, options) {
+function printDocToString(doc2, options8) {
   const groupModeMap = {};
-  const width = options.printWidth;
-  const newLine = convertEndOfLineToChars(options.endOfLine);
+  const width = options8.printWidth;
+  const newLine = convertEndOfLineToChars(options8.endOfLine);
   let pos = 0;
   const cmds = [{
     ind: rootIndent(),
@@ -15847,14 +15847,14 @@ function printDocToString(doc2, options) {
         break;
       case DOC_TYPE_INDENT:
         cmds.push({
-          ind: makeIndent(ind, options),
+          ind: makeIndent(ind, options8),
           mode,
           doc: doc3.contents
         });
         break;
       case DOC_TYPE_ALIGN:
         cmds.push({
-          ind: makeAlign(ind, doc3.n, options),
+          ind: makeAlign(ind, doc3.n, options8),
           mode,
           doc: doc3.contents
         });
@@ -16215,8 +16215,8 @@ function printDocToDebug(doc2) {
       if (doc3.groupId) {
         optionsParts.push(`groupId: ${printGroupId(doc3.groupId)}`);
       }
-      const options = optionsParts.length > 0 ? `, { ${optionsParts.join(", ")} }` : "";
-      return `indentIfBreak(${printDoc(doc3.contents)}${options})`;
+      const options8 = optionsParts.length > 0 ? `, { ${optionsParts.join(", ")} }` : "";
+      return `indentIfBreak(${printDoc(doc3.contents)}${options8})`;
     }
     if (doc3.type === DOC_TYPE_GROUP) {
       const optionsParts = [];
@@ -16226,11 +16226,11 @@ function printDocToDebug(doc2) {
       if (doc3.id) {
         optionsParts.push(`id: ${printGroupId(doc3.id)}`);
       }
-      const options = optionsParts.length > 0 ? `, { ${optionsParts.join(", ")} }` : "";
+      const options8 = optionsParts.length > 0 ? `, { ${optionsParts.join(", ")} }` : "";
       if (doc3.expandedStates) {
-        return `conditionalGroup([${doc3.expandedStates.map((part) => printDoc(part)).join(",")}]${options})`;
+        return `conditionalGroup([${doc3.expandedStates.map((part) => printDoc(part)).join(",")}]${options8})`;
       }
-      return `group(${printDoc(doc3.contents)}${options})`;
+      return `group(${printDoc(doc3.contents)}${options8})`;
     }
     if (doc3.type === DOC_TYPE_FILL) {
       return `fill([${doc3.parts.map((part) => printDoc(part)).join(", ")}])`;
@@ -16556,11 +16556,11 @@ function getSupportInfo({
   plugins = [],
   showDeprecated = false
 } = {}) {
-  const languages = plugins.flatMap((plugin) => plugin.languages ?? []);
-  const options = [];
+  const languages2 = plugins.flatMap((plugin) => plugin.languages ?? []);
+  const options8 = [];
   for (const option of normalizeOptionSettings(Object.assign({}, ...plugins.map(({
-    options: options2
-  }) => options2), core_options_evaluate_default))) {
+    options: options9
+  }) => options9), core_options_evaluate_default))) {
     if (!showDeprecated && option.deprecated) {
       continue;
     }
@@ -16569,23 +16569,23 @@ function getSupportInfo({
         option.choices = option.choices.filter((choice) => !choice.deprecated);
       }
       if (option.name === "parser") {
-        option.choices = [...option.choices, ...collectParsersFromLanguages(option.choices, languages, plugins)];
+        option.choices = [...option.choices, ...collectParsersFromLanguages(option.choices, languages2, plugins)];
       }
     }
     option.pluginDefaults = Object.fromEntries(plugins.filter((plugin) => {
       var _a;
       return ((_a = plugin.defaultOptions) == null ? void 0 : _a[option.name]) !== void 0;
     }).map((plugin) => [plugin.name, plugin.defaultOptions[option.name]]));
-    options.push(option);
+    options8.push(option);
   }
   return {
-    languages,
-    options
+    languages: languages2,
+    options: options8
   };
 }
-function* collectParsersFromLanguages(parserChoices, languages, plugins) {
+function* collectParsersFromLanguages(parserChoices, languages2, plugins) {
   const existingParsers = new Set(parserChoices.map((choice) => choice.value));
-  for (const language of languages) {
+  for (const language of languages2) {
     if (language.parsers) {
       for (const parserName of language.parsers) {
         if (!existingParsers.has(parserName)) {
@@ -16605,7 +16605,7 @@ function* collectParsersFromLanguages(parserChoices, languages, plugins) {
   }
 }
 function normalizeOptionSettings(settings) {
-  const options = [];
+  const options8 = [];
   for (const [name, originalOption] of Object.entries(settings)) {
     const option = {
       name,
@@ -16619,9 +16619,9 @@ function normalizeOptionSettings(settings) {
         -1
       ).value;
     }
-    options.push(option);
+    options8.push(option);
   }
-  return options;
+  return options8;
 }
 // src/utils/get-interpreter.js
@@ -16662,25 +16662,25 @@ var get_interpreter_default = getInterpreter;
 // src/utils/infer-parser.js
 var getFileBasename = (file) => file.split(/[/\\]/).pop();
-function getLanguageByFilename(languages, filename) {
+function getLanguageByFilename(languages2, filename) {
   if (!filename) {
     return;
   }
   const basename = getFileBasename(filename).toLowerCase();
-  return languages.find(
+  return languages2.find(
     (language) => {
       var _a, _b;
       return ((_a = language.extensions) == null ? void 0 : _a.some((extension) => basename.endsWith(extension))) || ((_b = language.filenames) == null ? void 0 : _b.some((name) => name.toLowerCase() === basename));
     }
   );
 }
-function getLanguageByName(languages, languageName) {
+function getLanguageByName(languages2, languageName) {
   if (!languageName) {
     return;
   }
-  return languages.find(({ name }) => name.toLowerCase() === languageName) ?? languages.find(({ aliases }) => aliases == null ? void 0 : aliases.includes(languageName)) ?? languages.find(({ extensions }) => extensions == null ? void 0 : extensions.includes(`.${languageName}`));
+  return languages2.find(({ name }) => name.toLowerCase() === languageName) ?? languages2.find(({ aliases }) => aliases == null ? void 0 : aliases.includes(languageName)) ?? languages2.find(({ extensions }) => extensions == null ? void 0 : extensions.includes(`.${languageName}`));
 }
-function getLanguageByInterpreter(languages, file) {
+function getLanguageByInterpreter(languages2, file) {
   if (!file || getFileBasename(file).includes(".")) {
     return;
   }
@@ -16688,21 +16688,21 @@ function getLanguageByInterpreter(languages, file) {
   if (!interpreter) {
     return;
   }
-  return languages.find(
+  return languages2.find(
     (language) => {
       var _a;
       return (_a = language.interpreters) == null ? void 0 : _a.includes(interpreter);
     }
   );
 }
-function inferParser(options, fileInfo) {
-  const languages = options.plugins.flatMap(
+function inferParser(options8, fileInfo) {
+  const languages2 = options8.plugins.flatMap(
     (plugin) => (
       // @ts-expect-error -- Safe
       plugin.languages ?? []
     )
   );
-  const language = getLanguageByName(languages, fileInfo.language) ?? getLanguageByFilename(languages, fileInfo.physicalFile) ?? getLanguageByFilename(languages, fileInfo.file) ?? getLanguageByInterpreter(languages, fileInfo.physicalFile);
+  const language = getLanguageByName(languages2, fileInfo.language) ?? getLanguageByFilename(languages2, fileInfo.physicalFile) ?? getLanguageByFilename(languages2, fileInfo.file) ?? getLanguageByInterpreter(languages2, fileInfo.physicalFile);
   return language == null ? void 0 : language.parsers[0];
 }
 var infer_parser_default = inferParser;
@@ -16710,7 +16710,7 @@ var infer_parser_default = inferParser;
 // src/main/normalize-options.js
 var import_vnopts = __toESM(require_lib(), 1);
 var hasDeprecationWarned;
-function normalizeOptions(options, optionInfos, {
+function normalizeOptions(options8, optionInfos, {
   logger = false,
   isCLI = false,
   passThrough = false,
@@ -16727,13 +16727,13 @@ function normalizeOptions(options, optionInfos, {
   } else {
     descriptor = import_vnopts.default.apiDescriptor;
   }
-  const unknown = !passThrough ? (key, value, options2) => {
+  const unknown = !passThrough ? (key, value, options9) => {
     const {
       _,
       ...schemas2
-    } = options2.schemas;
+    } = options9.schemas;
     return import_vnopts.default.levenUnknownHandler(key, value, {
-      ...options2,
+      ...options9,
       schemas: schemas2
     });
   } : Array.isArray(passThrough) ? (key, value) => !passThrough.includes(key) ? void 0 : {
@@ -16754,7 +16754,7 @@ function normalizeOptions(options, optionInfos, {
   if (shouldSuppressDuplicateDeprecationWarnings && hasDeprecationWarned) {
     normalizer._hasDeprecationWarned = hasDeprecationWarned;
   }
-  const normalized = normalizer.normalize(options);
+  const normalized = normalizer.normalize(options8);
   if (shouldSuppressDuplicateDeprecationWarnings) {
     hasDeprecationWarned = normalizer._hasDeprecationWarned;
   }
@@ -16945,6 +16945,10 @@ function initParser(plugin, parserName) {
   const parserOrParserInitFunction = plugin.parsers[parserName];
   return typeof parserOrParserInitFunction === "function" ? parserOrParserInitFunction() : parserOrParserInitFunction;
 }
+function initPrinter(plugin, astFormat) {
+  const printerOrPrinterInitFunction = plugin.printers[astFormat];
+  return typeof printerOrPrinterInitFunction === "function" ? printerOrPrinterInitFunction() : printerOrPrinterInitFunction;
+}
 // src/main/normalize-format-options.js
 var formatOptionsHiddenDefaults = {
@@ -16954,9 +16958,9 @@ var formatOptionsHiddenDefaults = {
   locStart: null,
   locEnd: null
 };
-async function normalizeFormatOptions(options, opts = {}) {
+async function normalizeFormatOptions(options8, opts = {}) {
   var _a;
-  const rawOptions = { ...options };
+  const rawOptions = { ...options8 };
   if (!rawOptions.parser) {
     if (!rawOptions.filepath) {
       throw new UndefinedParserError(
@@ -16974,7 +16978,7 @@ async function normalizeFormatOptions(options, opts = {}) {
     }
   }
   const supportOptions = getSupportInfo({
-    plugins: options.plugins,
+    plugins: options8.plugins,
     showDeprecated: true
   }).options;
   const defaults = {
@@ -16992,7 +16996,7 @@ async function normalizeFormatOptions(options, opts = {}) {
   rawOptions.locEnd = parser.locEnd;
   rawOptions.locStart = parser.locStart;
   const printerPlugin = ((_a = parserPlugin.printers) == null ? void 0 : _a[parser.astFormat]) ? parserPlugin : getPrinterPluginByAstFormat(rawOptions.plugins, parser.astFormat);
-  const printer = printerPlugin.printers[parser.astFormat];
+  const printer = await initPrinter(printerPlugin, parser.astFormat);
   rawOptions.printer = printer;
   const pluginDefaults = printerPlugin.defaultOptions ? Object.fromEntries(
     Object.entries(printerPlugin.defaultOptions).filter(
@@ -17031,13 +17035,13 @@ function createGetVisitorKeysFunction(printerGetVisitorKeys) {
 var create_get_visitor_keys_function_default = createGetVisitorKeysFunction;
 // src/main/massage-ast.js
-function massageAst(ast, options) {
+function massageAst(ast, options8) {
   const {
     printer: {
       massageAstNode: cleanFunction,
       getVisitorKeys: printerGetVisitorKeys
     }
-  } = options;
+  } = options8;
   if (!cleanFunction) {
     return ast;
   }
@@ -17074,18 +17078,18 @@ var massage_ast_default = massageAst;
 // src/main/parse.js
 var import_code_frame = __toESM(require_lib4(), 1);
-async function parse(originalText, options) {
-  const parser = await resolveParser(options);
-  const text = parser.preprocess ? parser.preprocess(originalText, options) : originalText;
-  options.originalText = text;
+async function parse(originalText, options8) {
+  const parser = await resolveParser(options8);
+  const text = parser.preprocess ? parser.preprocess(originalText, options8) : originalText;
+  options8.originalText = text;
   let ast;
   try {
     ast = await parser.parse(
       text,
-      options,
+      options8,
       // TODO: remove the third argument in v4
       // The duplicated argument is passed as intended, see #10156
-      options
+      options8
     );
   } catch (error) {
     handleParseError(error, originalText);
@@ -17410,8 +17414,8 @@ import assert from "assert";
 // src/utils/skip.js
 function skip(characters) {
-  return (text, startIndex, options) => {
-    const backwards = Boolean(options == null ? void 0 : options.backwards);
+  return (text, startIndex, options8) => {
+    const backwards = Boolean(options8 == null ? void 0 : options8.backwards);
     if (startIndex === false) {
       return false;
     }
@@ -17440,8 +17444,8 @@ var skipToLineEnd = skip(",; 	");
 var skipEverythingButNewLine = skip(/[^\n\r]/);
 // src/utils/skip-newline.js
-function skipNewline(text, startIndex, options) {
-  const backwards = Boolean(options == null ? void 0 : options.backwards);
+function skipNewline(text, startIndex, options8) {
+  const backwards = Boolean(options8 == null ? void 0 : options8.backwards);
   if (startIndex === false) {
     return false;
   }
@@ -17466,13 +17470,13 @@ function skipNewline(text, startIndex, options) {
 var skip_newline_default = skipNewline;
 // src/utils/has-newline.js
-function hasNewline(text, startIndex, options = {}) {
+function hasNewline(text, startIndex, options8 = {}) {
   const idx = skipSpaces(
     text,
-    options.backwards ? startIndex - 1 : startIndex,
-    options
+    options8.backwards ? startIndex - 1 : startIndex,
+    options8
   );
-  const idx2 = skip_newline_default(text, idx, options);
+  const idx2 = skip_newline_default(text, idx, options8);
   return idx !== idx2;
 }
 var has_newline_default = hasNewline;
@@ -17490,8 +17494,8 @@ function isObject(object) {
 var is_object_default = isObject;
 // src/utils/ast-utils.js
-function* getChildren(node, options) {
-  const { getVisitorKeys, filter = () => true } = options;
+function* getChildren(node, options8) {
+  const { getVisitorKeys, filter = () => true } = options8;
   const isMatchedNode = (node2) => is_object_default(node2) && filter(node2);
   for (const key of getVisitorKeys(node)) {
     const value = node[key];
@@ -17506,11 +17510,11 @@ function* getChildren(node, options) {
     }
   }
 }
-function* getDescendants(node, options) {
+function* getDescendants(node, options8) {
   const queue = [node];
   for (let index = 0; index < queue.length; index++) {
     const node2 = queue[index];
-    for (const child of getChildren(node2, options)) {
+    for (const child of getChildren(node2, options8)) {
       yield child;
       queue.push(child);
     }
@@ -17555,7 +17559,7 @@ function addTrailingComment(node, comment) {
 // src/main/comments/attach.js
 var childNodesCache = /* @__PURE__ */ new WeakMap();
-function getSortedChildNodes(node, options) {
+function getSortedChildNodes(node, options8) {
   if (childNodesCache.has(node)) {
     return childNodesCache.get(node);
   }
@@ -17567,16 +17571,16 @@ function getSortedChildNodes(node, options) {
     },
     locStart,
     locEnd
-  } = options;
+  } = options8;
   if (!canAttachComment) {
     return [];
   }
-  const childNodes = ((getCommentChildNodes == null ? void 0 : getCommentChildNodes(node, options)) ?? [
+  const childNodes = ((getCommentChildNodes == null ? void 0 : getCommentChildNodes(node, options8)) ?? [
     ...getChildren(node, {
       getVisitorKeys: create_get_visitor_keys_function_default(printerGetVisitorKeys)
     })
   ]).flatMap(
-    (node2) => canAttachComment(node2) ? [node2] : getSortedChildNodes(node2, options)
+    (node2) => canAttachComment(node2) ? [node2] : getSortedChildNodes(node2, options8)
   );
   childNodes.sort(
     (nodeA, nodeB) => locStart(nodeA) - locStart(nodeB) || locEnd(nodeA) - locEnd(nodeB)
@@ -17584,11 +17588,11 @@ function getSortedChildNodes(node, options) {
   childNodesCache.set(node, childNodes);
   return childNodes;
 }
-function decorateComment(node, comment, options, enclosingNode) {
-  const { locStart, locEnd } = options;
+function decorateComment(node, comment, options8, enclosingNode) {
+  const { locStart, locEnd } = options8;
   const commentStart = locStart(comment);
   const commentEnd = locEnd(comment);
-  const childNodes = getSortedChildNodes(node, options);
+  const childNodes = getSortedChildNodes(node, options8);
   let precedingNode;
   let followingNode;
   let left = 0;
@@ -17599,7 +17603,7 @@ function decorateComment(node, comment, options, enclosingNode) {
     const start = locStart(child);
     const end = locEnd(child);
     if (start <= commentStart && commentEnd <= end) {
-      return decorateComment(child, comment, options, child);
+      return decorateComment(child, comment, options8, child);
     }
     if (end <= commentStart) {
       precedingNode = child;
@@ -17618,22 +17622,22 @@ function decorateComment(node, comment, options, enclosingNode) {
     const commentIndex = findExpressionIndexForComment(
       quasis,
       comment,
-      options
+      options8
     );
-    if (precedingNode && findExpressionIndexForComment(quasis, precedingNode, options) !== commentIndex) {
+    if (precedingNode && findExpressionIndexForComment(quasis, precedingNode, options8) !== commentIndex) {
       precedingNode = null;
     }
-    if (followingNode && findExpressionIndexForComment(quasis, followingNode, options) !== commentIndex) {
+    if (followingNode && findExpressionIndexForComment(quasis, followingNode, options8) !== commentIndex) {
       followingNode = null;
     }
   }
   return { enclosingNode, precedingNode, followingNode };
 }
 var returnFalse = () => false;
-function attachComments(ast, options) {
+function attachComments(ast, options8) {
   const { comments } = ast;
   delete ast.comments;
-  if (!is_non_empty_array_default(comments) || !options.printer.canAttachComment) {
+  if (!is_non_empty_array_default(comments) || !options8.printer.canAttachComment) {
     return;
   }
   const tiesToBreak = [];
@@ -17648,17 +17652,17 @@ function attachComments(ast, options) {
       handleComments = {}
     },
     originalText: text
-  } = options;
+  } = options8;
   const {
     ownLine: handleOwnLineComment = returnFalse,
     endOfLine: handleEndOfLineComment = returnFalse,
     remaining: handleRemainingComment = returnFalse
   } = handleComments;
   const decoratedComments = comments.map((comment, index) => ({
-    ...decorateComment(ast, comment, options),
+    ...decorateComment(ast, comment, options8),
     comment,
     text,
-    options,
+    options: options8,
     ast,
     isLastComment: comments.length - 1 === index
   }));
@@ -17669,11 +17673,11 @@ function attachComments(ast, options) {
       enclosingNode,
       followingNode,
       text: text2,
-      options: options2,
+      options: options9,
       ast: ast2,
       isLastComment
     } = context;
-    if (options2.parser === "json" || options2.parser === "json5" || options2.parser === "__js_expression" || options2.parser === "__ts_expression" || options2.parser === "__vue_expression" || options2.parser === "__vue_ts_expression") {
+    if (options9.parser === "json" || options9.parser === "json5" || options9.parser === "__js_expression" || options9.parser === "__ts_expression" || options9.parser === "__vue_expression" || options9.parser === "__vue_ts_expression") {
       if (locStart(comment) - locStart(ast2) <= 0) {
         addLeadingComment(ast2, comment);
         continue;
@@ -17690,9 +17694,9 @@ function attachComments(ast, options) {
       comment.enclosingNode = enclosingNode;
       comment.precedingNode = precedingNode;
       comment.followingNode = followingNode;
-      args = [comment, text2, options2, ast2, isLastComment];
+      args = [comment, text2, options9, ast2, isLastComment];
     }
-    if (isOwnLineComment(text2, options2, decoratedComments, index)) {
+    if (isOwnLineComment(text2, options9, decoratedComments, index)) {
       comment.placement = "ownLine";
       if (handleOwnLineComment(...args)) {
       } else if (followingNode) {
@@ -17704,7 +17708,7 @@ function attachComments(ast, options) {
       } else {
         addDanglingComment(ast2, comment);
       }
-    } else if (isEndOfLineComment(text2, options2, decoratedComments, index)) {
+    } else if (isEndOfLineComment(text2, options9, decoratedComments, index)) {
       comment.placement = "endOfLine";
       if (handleEndOfLineComment(...args)) {
       } else if (precedingNode) {
@@ -17724,7 +17728,7 @@ function attachComments(ast, options) {
         if (tieCount > 0) {
           const lastTie = tiesToBreak[tieCount - 1];
           if (lastTie.followingNode !== followingNode) {
-            breakTies(tiesToBreak, options2);
+            breakTies(tiesToBreak, options9);
           }
         }
         tiesToBreak.push(context);
@@ -17739,7 +17743,7 @@ function attachComments(ast, options) {
       }
     }
   }
-  breakTies(tiesToBreak, options);
+  breakTies(tiesToBreak, options8);
   if (!avoidAstMutation) {
     for (const comment of comments) {
       delete comment.precedingNode;
@@ -17749,9 +17753,9 @@ function attachComments(ast, options) {
   }
 }
 var isAllEmptyAndNoLineBreak = (text) => !/[\S\n\u2028\u2029]/.test(text);
-function isOwnLineComment(text, options, decoratedComments, commentIndex) {
+function isOwnLineComment(text, options8, decoratedComments, commentIndex) {
   const { comment, precedingNode } = decoratedComments[commentIndex];
-  const { locStart, locEnd } = options;
+  const { locStart, locEnd } = options8;
   let start = locStart(comment);
   if (precedingNode) {
     for (let index = commentIndex - 1; index >= 0; index--) {
@@ -17764,9 +17768,9 @@ function isOwnLineComment(text, options, decoratedComments, commentIndex) {
   }
   return has_newline_default(text, start, { backwards: true });
 }
-function isEndOfLineComment(text, options, decoratedComments, commentIndex) {
+function isEndOfLineComment(text, options8, decoratedComments, commentIndex) {
   const { comment, followingNode } = decoratedComments[commentIndex];
-  const { locStart, locEnd } = options;
+  const { locStart, locEnd } = options8;
   let end = locEnd(comment);
   if (followingNode) {
     for (let index = commentIndex + 1; index < decoratedComments.length; index++) {
@@ -17779,14 +17783,14 @@ function isEndOfLineComment(text, options, decoratedComments, commentIndex) {
   }
   return has_newline_default(text, end);
 }
-function breakTies(tiesToBreak, options) {
+function breakTies(tiesToBreak, options8) {
   var _a, _b;
   const tieCount = tiesToBreak.length;
   if (tieCount === 0) {
     return;
   }
   const { precedingNode, followingNode } = tiesToBreak[0];
-  let gapEndPos = options.locStart(followingNode);
+  let gapEndPos = options8.locStart(followingNode);
   let indexOfFirstLeadingComment;
   for (indexOfFirstLeadingComment = tieCount; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) {
     const {
@@ -17796,9 +17800,9 @@ function breakTies(tiesToBreak, options) {
     } = tiesToBreak[indexOfFirstLeadingComment - 1];
     assert.strictEqual(currentCommentPrecedingNode, precedingNode);
     assert.strictEqual(currentCommentFollowingNode, followingNode);
-    const gap = options.originalText.slice(options.locEnd(comment), gapEndPos);
-    if (((_b = (_a = options.printer).isGap) == null ? void 0 : _b.call(_a, gap, options)) ?? /^[\s(]*$/.test(gap)) {
-      gapEndPos = options.locStart(comment);
+    const gap = options8.originalText.slice(options8.locEnd(comment), gapEndPos);
+    if (((_b = (_a = options8.printer).isGap) == null ? void 0 : _b.call(_a, gap, options8)) ?? /^[\s(]*$/.test(gap)) {
+      gapEndPos = options8.locStart(comment);
     } else {
       break;
     }
@@ -17812,15 +17816,15 @@ function breakTies(tiesToBreak, options) {
   }
   for (const node of [precedingNode, followingNode]) {
     if (node.comments && node.comments.length > 1) {
-      node.comments.sort((a, b) => options.locStart(a) - options.locStart(b));
+      node.comments.sort((a, b) => options8.locStart(a) - options8.locStart(b));
     }
   }
   tiesToBreak.length = 0;
 }
-function findExpressionIndexForComment(quasis, comment, options) {
-  const startPos = options.locStart(comment) - 1;
+function findExpressionIndexForComment(quasis, comment, options8) {
+  const startPos = options8.locStart(comment) - 1;
   for (let i = 1; i < quasis.length; ++i) {
-    if (startPos < options.locStart(quasis[i])) {
+    if (startPos < options8.locStart(quasis[i])) {
       return i - 1;
     }
   }
@@ -17839,16 +17843,16 @@ function isPreviousLineEmpty(text, startIndex) {
 var is_previous_line_empty_default = isPreviousLineEmpty;
 // src/main/comments/print.js
-function printComment(path11, options) {
+function printComment(path11, options8) {
   const comment = path11.node;
   comment.printed = true;
-  return options.printer.printComment(path11, options);
+  return options8.printer.printComment(path11, options8);
 }
-function printLeadingComment(path11, options) {
+function printLeadingComment(path11, options8) {
   var _a;
   const comment = path11.node;
-  const parts = [printComment(path11, options)];
-  const { printer, originalText, locStart, locEnd } = options;
+  const parts = [printComment(path11, options8)];
+  const { printer, originalText, locStart, locEnd } = options8;
   const isBlock = (_a = printer.isBlockComment) == null ? void 0 : _a.call(printer, comment);
   if (isBlock) {
     const lineBreak = has_newline_default(originalText, locEnd(comment)) ? has_newline_default(originalText, locStart(comment), {
@@ -17867,11 +17871,11 @@ function printLeadingComment(path11, options) {
   }
   return parts;
 }
-function printTrailingComment(path11, options, previousComment) {
+function printTrailingComment(path11, options8, previousComment) {
   var _a;
   const comment = path11.node;
-  const printed = printComment(path11, options);
-  const { printer, originalText, locStart } = options;
+  const printed = printComment(path11, options8);
+  const { printer, originalText, locStart } = options8;
   const isBlock = (_a = printer.isBlockComment) == null ? void 0 : _a.call(printer, comment);
   if ((previousComment == null ? void 0 : previousComment.hasLineSuffix) && !(previousComment == null ? void 0 : previousComment.isBlock) || has_newline_default(originalText, locStart(comment), { backwards: true })) {
     const isLineBeforeEmpty = is_previous_line_empty_default(
@@ -17893,12 +17897,12 @@ function printTrailingComment(path11, options, previousComment) {
   }
   return { doc: [" ", printed], isBlock, hasLineSuffix: false };
 }
-function printCommentsSeparately(path11, options) {
+function printCommentsSeparately(path11, options8) {
   const value = path11.node;
   if (!value) {
     return {};
   }
-  const ignored = options[Symbol.for("printedComments")];
+  const ignored = options8[Symbol.for("printedComments")];
   const comments = (value.comments || []).filter(
     (comment) => !ignored.has(comment)
   );
@@ -17915,11 +17919,11 @@ function printCommentsSeparately(path11, options) {
     }
     const { leading, trailing } = comment;
     if (leading) {
-      leadingParts.push(printLeadingComment(path11, options));
+      leadingParts.push(printLeadingComment(path11, options8));
     } else if (trailing) {
       printedTrailingComment = printTrailingComment(
         path11,
-        options,
+        options8,
         printedTrailingComment
       );
       trailingParts.push(printedTrailingComment.doc);
@@ -17927,18 +17931,18 @@ function printCommentsSeparately(path11, options) {
   }, "comments");
   return { leading: leadingParts, trailing: trailingParts };
 }
-function printComments(path11, doc2, options) {
-  const { leading, trailing } = printCommentsSeparately(path11, options);
+function printComments(path11, doc2, options8) {
+  const { leading, trailing } = printCommentsSeparately(path11, options8);
   if (!leading && !trailing) {
     return doc2;
   }
   return inheritLabel(doc2, (doc3) => [leading, doc3, trailing]);
 }
-function ensureAllCommentsPrinted(options) {
+function ensureAllCommentsPrinted(options8) {
   const {
     [Symbol.for("comments")]: comments,
     [Symbol.for("printedComments")]: printedComments
-  } = options;
+  } = options8;
   for (const comment of comments) {
     if (!comment.printed && !printedComments.has(comment)) {
       throw new Error(
@@ -17950,7 +17954,7 @@ function ensureAllCommentsPrinted(options) {
 }
 // src/main/multiparser.js
-async function printEmbeddedLanguages(path11, genericPrint, options, printAstToDoc2, embeds) {
+async function printEmbeddedLanguages(path11, genericPrint, options8, printAstToDoc2, embeds) {
   const {
     embeddedLanguageFormatting,
     printer: {
@@ -17958,7 +17962,7 @@ async function printEmbeddedLanguages(path11, genericPrint, options, printAstToD
       hasPrettierIgnore = () => false,
       getVisitorKeys: printerGetVisitorKeys
     }
-  } = options;
+  } = options8;
   if (!embed || embeddedLanguageFormatting !== "auto") {
     return;
   }
@@ -17976,7 +17980,7 @@ async function printEmbeddedLanguages(path11, genericPrint, options, printAstToD
   for (const { print, node, pathStack } of embedCallResults) {
     try {
       path11.stack = pathStack;
-      const doc2 = await print(textToDocForEmbed, genericPrint, path11, options);
+      const doc2 = await print(textToDocForEmbed, genericPrint, path11, options8);
       if (doc2) {
         embeds.set(node, doc2);
       }
@@ -17988,7 +17992,7 @@ async function printEmbeddedLanguages(path11, genericPrint, options, printAstToD
   }
   path11.stack = originalPathStack;
   function textToDocForEmbed(text, partialNextOptions) {
-    return textToDoc(text, partialNextOptions, options, printAstToDoc2);
+    return textToDoc(text, partialNextOptions, options8, printAstToDoc2);
   }
   function recurse() {
     const { node } = path11;
@@ -18002,7 +18006,7 @@ async function printEmbeddedLanguages(path11, genericPrint, options, printAstToD
         path11.call(recurse, key);
       }
     }
-    const result = embed(path11, options);
+    const result = embed(path11, options8);
     if (!result) {
       return;
     }
@@ -18023,7 +18027,7 @@ async function printEmbeddedLanguages(path11, genericPrint, options, printAstToD
   }
 }
 async function textToDoc(text, partialNextOptions, parentOptions, printAstToDoc2) {
-  const options = await normalize_format_options_default(
+  const options8 = await normalize_format_options_default(
     {
       ...parentOptions,
       ...partialNextOptions,
@@ -18032,19 +18036,19 @@ async function textToDoc(text, partialNextOptions, parentOptions, printAstToDoc2
     },
     { passThrough: true }
   );
-  const { ast } = await parse_default(text, options);
-  const doc2 = await printAstToDoc2(ast, options);
+  const { ast } = await parse_default(text, options8);
+  const doc2 = await printAstToDoc2(ast, options8);
   return stripTrailingHardline(doc2);
 }
 // src/main/create-print-pre-check-function.js
-function createPrintPreCheckFunction(options) {
+function createPrintPreCheckFunction(options8) {
   if (true) {
     return () => {
     };
   }
   const getVisitorKeys = create_get_visitor_keys_function_default(
-    options.printer.getVisitorKeys
+    options8.printer.getVisitorKeys
   );
   return function(path11) {
     if (path11.isRoot) {
@@ -18067,14 +18071,14 @@ function createPrintPreCheckFunction(options) {
 var create_print_pre_check_function_default = createPrintPreCheckFunction;
 // src/main/print-ignored.js
-function printIgnored(path11, options) {
+function printIgnored(path11, options8) {
   const {
     originalText,
     [Symbol.for("comments")]: comments,
     locStart,
     locEnd,
     [Symbol.for("printedComments")]: printedComments
-  } = options;
+  } = options8;
   const { node } = path11;
   const start = locStart(node);
   const end = locEnd(node);
@@ -18088,21 +18092,21 @@ function printIgnored(path11, options) {
 var print_ignored_default = printIgnored;
 // src/main/ast-to-doc.js
-async function printAstToDoc(ast, options) {
-  ({ ast } = await prepareToPrint(ast, options));
+async function printAstToDoc(ast, options8) {
+  ({ ast } = await prepareToPrint(ast, options8));
   const cache = /* @__PURE__ */ new Map();
   const path11 = new ast_path_default(ast);
-  const ensurePrintingNode = create_print_pre_check_function_default(options);
+  const ensurePrintingNode = create_print_pre_check_function_default(options8);
   const embeds = /* @__PURE__ */ new Map();
-  await printEmbeddedLanguages(path11, mainPrint, options, printAstToDoc, embeds);
+  await printEmbeddedLanguages(path11, mainPrint, options8, printAstToDoc, embeds);
   const doc2 = await callPluginPrintFunction(
     path11,
-    options,
+    options8,
     mainPrint,
     void 0,
     embeds
   );
-  ensureAllCommentsPrinted(options);
+  ensureAllCommentsPrinted(options8);
   return doc2;
   function mainPrint(selector, args) {
     if (selector === void 0 || selector === path11) {
@@ -18123,43 +18127,43 @@ async function printAstToDoc(ast, options) {
     if (shouldCache && cache.has(value)) {
       return cache.get(value);
     }
-    const doc3 = callPluginPrintFunction(path11, options, mainPrint, args, embeds);
+    const doc3 = callPluginPrintFunction(path11, options8, mainPrint, args, embeds);
     if (shouldCache) {
       cache.set(value, doc3);
     }
     return doc3;
   }
 }
-function callPluginPrintFunction(path11, options, printPath, args, embeds) {
+function callPluginPrintFunction(path11, options8, printPath, args, embeds) {
   var _a;
   const { node } = path11;
-  const { printer } = options;
+  const { printer } = options8;
   let doc2;
   if ((_a = printer.hasPrettierIgnore) == null ? void 0 : _a.call(printer, path11)) {
-    doc2 = print_ignored_default(path11, options);
+    doc2 = print_ignored_default(path11, options8);
   } else if (embeds.has(node)) {
     doc2 = embeds.get(node);
   } else {
-    doc2 = printer.print(path11, options, printPath, args);
+    doc2 = printer.print(path11, options8, printPath, args);
   }
-  if (printer.printComment && (!printer.willPrintOwnComments || !printer.willPrintOwnComments(path11, options))) {
-    doc2 = printComments(path11, doc2, options);
+  if (printer.printComment && (!printer.willPrintOwnComments || !printer.willPrintOwnComments(path11, options8))) {
+    doc2 = printComments(path11, doc2, options8);
   }
-  if (node === options.cursorNode) {
+  if (node === options8.cursorNode) {
     doc2 = inheritLabel(doc2, (doc3) => [cursor, doc3, cursor]);
   }
   return doc2;
 }
-async function prepareToPrint(ast, options) {
+async function prepareToPrint(ast, options8) {
   const comments = ast.comments ?? [];
-  options[Symbol.for("comments")] = comments;
-  options[Symbol.for("tokens")] = ast.tokens ?? [];
-  options[Symbol.for("printedComments")] = /* @__PURE__ */ new Set();
-  attachComments(ast, options);
+  options8[Symbol.for("comments")] = comments;
+  options8[Symbol.for("tokens")] = ast.tokens ?? [];
+  options8[Symbol.for("printedComments")] = /* @__PURE__ */ new Set();
+  attachComments(ast, options8);
   const {
     printer: { preprocess }
-  } = options;
-  ast = preprocess ? await preprocess(ast, options) : ast;
+  } = options8;
+  ast = preprocess ? await preprocess(ast, options8) : ast;
   return { ast, comments };
 }
@@ -18224,18 +18228,18 @@ function findSiblingAncestors(startNodeAndParents, endNodeAndParents, { locStart
     endNode: resultEndNode
   };
 }
-function findNodeAtOffset(node, offset, options, predicate, parentNodes = [], type) {
-  const { locStart, locEnd } = options;
+function findNodeAtOffset(node, offset, options8, predicate, parentNodes = [], type) {
+  const { locStart, locEnd } = options8;
   const start = locStart(node);
   const end = locEnd(node);
   if (offset > end || offset < start || type === "rangeEnd" && offset === start || type === "rangeStart" && offset === end) {
     return;
   }
-  for (const childNode of getSortedChildNodes(node, options)) {
+  for (const childNode of getSortedChildNodes(node, options8)) {
     const childResult = findNodeAtOffset(
       childNode,
       offset,
-      options,
+      options8,
       predicate,
       [node, ...parentNodes],
       type
@@ -18370,10 +18374,10 @@ function calculateRange(text, opts, ast) {
 }
 // src/main/get-cursor-node.js
-function getCursorNode(ast, options) {
-  const { cursorOffset, locStart, locEnd } = options;
+function getCursorNode(ast, options8) {
+  const { cursorOffset, locStart, locEnd } = options8;
   const getVisitorKeys = create_get_visitor_keys_function_default(
-    options.printer.getVisitorKeys
+    options8.printer.getVisitorKeys
   );
   const nodeContainsCursor = (node) => locStart(node) <= cursorOffset && locEnd(node) >= cursorOffset;
   let cursorNode = ast;
@@ -18527,29 +18531,29 @@ function ensureIndexInText(text, index, defaultValue) {
   }
   return index;
 }
-function normalizeIndexes(text, options) {
+function normalizeIndexes(text, options8) {
   let {
     cursorOffset,
     rangeStart,
     rangeEnd
-  } = options;
+  } = options8;
   cursorOffset = ensureIndexInText(text, cursorOffset, -1);
   rangeStart = ensureIndexInText(text, rangeStart, 0);
   rangeEnd = ensureIndexInText(text, rangeEnd, text.length);
   return {
-    ...options,
+    ...options8,
     cursorOffset,
     rangeStart,
     rangeEnd
   };
 }
-function normalizeInputAndOptions(text, options) {
+function normalizeInputAndOptions(text, options8) {
   let {
     cursorOffset,
     rangeStart,
     rangeEnd,
     endOfLine
-  } = normalizeIndexes(text, options);
+  } = normalizeIndexes(text, options8);
   const hasBOM = text.charAt(0) === BOM;
   if (hasBOM) {
     text = text.slice(1);
@@ -18571,7 +18575,7 @@ function normalizeInputAndOptions(text, options) {
     hasBOM,
     text,
     options: normalizeIndexes(text, {
-      ...options,
+      ...options8,
       cursorOffset,
       rangeStart,
       rangeEnd,
@@ -18579,17 +18583,17 @@ function normalizeInputAndOptions(text, options) {
     })
   };
 }
-async function hasPragma(text, options) {
-  const selectedParser = await resolveParser(options);
+async function hasPragma(text, options8) {
+  const selectedParser = await resolveParser(options8);
   return !selectedParser.hasPragma || selectedParser.hasPragma(text);
 }
 async function formatWithCursor(originalText, originalOptions) {
   let {
     hasBOM,
     text,
-    options
+    options: options8
   } = normalizeInputAndOptions(originalText, await normalize_format_options_default(originalOptions));
-  if (options.rangeStart >= options.rangeEnd && text !== "" || options.requirePragma && !await hasPragma(text, options)) {
+  if (options8.rangeStart >= options8.rangeEnd && text !== "" || options8.requirePragma && !await hasPragma(text, options8)) {
     return {
       formatted: originalText,
       cursorOffset: originalOptions.cursorOffset,
@@ -18597,13 +18601,13 @@ async function formatWithCursor(originalText, originalOptions) {
     };
   }
   let result;
-  if (options.rangeStart > 0 || options.rangeEnd < text.length) {
-    result = await formatRange(text, options);
+  if (options8.rangeStart > 0 || options8.rangeEnd < text.length) {
+    result = await formatRange(text, options8);
   } else {
-    if (!options.requirePragma && options.insertPragma && options.printer.insertPragma && !await hasPragma(text, options)) {
-      text = options.printer.insertPragma(text);
+    if (!options8.requirePragma && options8.insertPragma && options8.printer.insertPragma && !await hasPragma(text, options8)) {
+      text = options8.printer.insertPragma(text);
     }
-    result = await coreFormat(text, options);
+    result = await coreFormat(text, options8);
   }
   if (hasBOM) {
     result.formatted = BOM + result.formatted;
@@ -18616,43 +18620,43 @@ async function formatWithCursor(originalText, originalOptions) {
 async function parse2(originalText, originalOptions, devOptions) {
   const {
     text,
-    options
+    options: options8
   } = normalizeInputAndOptions(originalText, await normalize_format_options_default(originalOptions));
-  const parsed = await parse_default(text, options);
+  const parsed = await parse_default(text, options8);
   if (devOptions) {
     if (devOptions.preprocessForPrint) {
-      parsed.ast = await prepareToPrint(parsed.ast, options);
+      parsed.ast = await prepareToPrint(parsed.ast, options8);
     }
     if (devOptions.massage) {
-      parsed.ast = massage_ast_default(parsed.ast, options);
+      parsed.ast = massage_ast_default(parsed.ast, options8);
     }
   }
   return parsed;
 }
-async function formatAst(ast, options) {
-  options = await normalize_format_options_default(options);
-  const doc2 = await printAstToDoc(ast, options);
-  return printDocToString(doc2, options);
+async function formatAst(ast, options8) {
+  options8 = await normalize_format_options_default(options8);
+  const doc2 = await printAstToDoc(ast, options8);
+  return printDocToString(doc2, options8);
 }
-async function formatDoc(doc2, options) {
+async function formatDoc(doc2, options8) {
   const text = printDocToDebug(doc2);
   const {
     formatted
   } = await formatWithCursor(text, {
-    ...options,
+    ...options8,
     parser: "__js_expression"
   });
   return formatted;
 }
-async function printToDoc(originalText, options) {
-  options = await normalize_format_options_default(options);
+async function printToDoc(originalText, options8) {
+  options8 = await normalize_format_options_default(options8);
   const {
     ast
-  } = await parse_default(originalText, options);
-  return printAstToDoc(ast, options);
+  } = await parse_default(originalText, options8);
+  return printAstToDoc(ast, options8);
 }
-async function printDocToString2(doc2, options) {
-  return printDocToString(doc2, await normalize_format_options_default(options));
+async function printDocToString2(doc2, options8) {
+  return printDocToString(doc2, await normalize_format_options_default(options8));
 }
 // src/config/resolve-config.js
@@ -20139,9 +20143,9 @@ async function transform(result) {
   delete config.$schema;
   return result;
 }
-function getExplorer(options) {
+function getExplorer(options8) {
   return cosmiconfig("prettier", {
-    cache: options.cache,
+    cache: options8.cache,
     transform,
     searchPlaces,
     loaders
@@ -20151,31 +20155,31 @@ var get_prettier_config_explorer_default = getExplorer;
 // src/config/resolve-config.js
 var getPrettierConfigExplorer = mem(get_prettier_config_explorer_default, {
-  cacheKey: ([options]) => options.cache
+  cacheKey: ([options8]) => options8.cache
 });
 var memoizedLoadEditorConfig = mem(resolve_editorconfig_default);
 function clearCache() {
   memClear(getPrettierConfigExplorer);
   memClear(memoizedLoadEditorConfig);
 }
-function loadEditorConfig2(filePath, options) {
-  if (!filePath || !options.editorconfig) {
+function loadEditorConfig2(filePath, options8) {
+  if (!filePath || !options8.editorconfig) {
     return;
   }
-  return (options.useCache ? memoizedLoadEditorConfig : resolve_editorconfig_default)(filePath);
+  return (options8.useCache ? memoizedLoadEditorConfig : resolve_editorconfig_default)(filePath);
 }
-function loadPrettierConfig(filePath, options) {
-  const { useCache, config: configPath } = options;
+function loadPrettierConfig(filePath, options8) {
+  const { useCache, config: configPath } = options8;
   const { load, search } = getPrettierConfigExplorer({
     cache: Boolean(useCache)
   });
   return configPath ? load(configPath) : search(filePath);
 }
-async function resolveConfig(filePath, options) {
-  options = { useCache: true, ...options };
+async function resolveConfig(filePath, options8) {
+  options8 = { useCache: true, ...options8 };
   const [result, editorConfigured] = await Promise.all([
-    loadPrettierConfig(filePath, options),
-    loadEditorConfig2(filePath, options)
+    loadPrettierConfig(filePath, options8),
+    loadEditorConfig2(filePath, options8)
   ]);
   if (!result && !editorConfigured) {
     return null;
@@ -20200,7 +20204,7 @@ async function resolveConfigFile(filePath) {
 }
 function mergeOverrides(configResult, filePath) {
   const { config, filepath: configPath } = configResult || {};
-  const { overrides, ...options } = config || {};
+  const { overrides, ...options8 } = config || {};
   if (filePath && overrides) {
     const relativeFilePath = path6.relative(path6.dirname(configPath), filePath);
     for (const override of overrides) {
@@ -20209,11 +20213,11 @@ function mergeOverrides(configResult, filePath) {
         override.files,
         override.excludeFiles
       )) {
-        Object.assign(options, override.options);
+        Object.assign(options8, override.options);
       }
     }
   }
-  return options;
+  return options8;
 }
 function pathMatchesGlobs(filePath, patterns, excludedPatterns) {
   const patternList = Array.isArray(patterns) ? patterns : [patterns];
@@ -20286,42 +20290,42 @@ async function createIsIgnoredFunction(ignoreFilePaths, withNodeModules) {
   const isIgnoredFunctions = (await Promise.all(ignoreFilePaths.map((ignoreFilePath) => createSingleIsIgnoredFunction(ignoreFilePath, withNodeModules)))).filter(Boolean);
   return (filepath) => isIgnoredFunctions.some((isIgnored2) => isIgnored2(filepath));
 }
-async function isIgnored(filepath, options) {
+async function isIgnored(filepath, options8) {
   const {
     ignorePath,
     withNodeModules
-  } = options;
+  } = options8;
   const isIgnored2 = await createIsIgnoredFunction(ignorePath, withNodeModules);
   return isIgnored2(filepath);
 }
 // src/common/get-file-info.js
-async function getFileInfo(filePath, options) {
+async function getFileInfo(filePath, options8) {
   if (typeof filePath !== "string") {
     throw new TypeError(
       `expect \`filePath\` to be a string, got \`${typeof filePath}\``
     );
   }
-  let { ignorePath, withNodeModules } = options;
+  let { ignorePath, withNodeModules } = options8;
   if (!Array.isArray(ignorePath)) {
     ignorePath = [ignorePath];
   }
   const ignored = await isIgnored(filePath, { ignorePath, withNodeModules });
   let inferredParser;
   if (!ignored) {
-    inferredParser = await getParser(filePath, options);
+    inferredParser = await getParser(filePath, options8);
   }
   return {
     ignored,
     inferredParser: inferredParser ?? null
   };
 }
-async function getParser(filePath, options) {
+async function getParser(filePath, options8) {
   let config;
-  if (options.resolveConfig !== false) {
+  if (options8.resolveConfig !== false) {
     config = await resolveConfig(filePath);
   }
-  return (config == null ? void 0 : config.parser) ?? infer_parser_default(options, { physicalFile: filePath });
+  return (config == null ? void 0 : config.parser) ?? infer_parser_default(options8, { physicalFile: filePath });
 }
 var get_file_info_default = getFileInfo;
@@ -20430,25 +20434,1018 @@ function clearCache3() {
   memClear(findNodeModules);
 }
+// src/plugins/builtin-plugins-proxy.js
+var builtin_plugins_proxy_exports = {};
+__export(builtin_plugins_proxy_exports, {
+  languages: () => languages,
+  options: () => options7,
+  parsers: () => parsers,
+  printers: () => printers
+});
+// src/common/common-options.evaluate.js
+var common_options_evaluate_default = {
+  "bracketSpacing": {
+    "category": "Common",
+    "type": "boolean",
+    "default": true,
+    "description": "Print spaces between brackets.",
+    "oppositeDescription": "Do not print spaces between brackets."
+  },
+  "singleQuote": {
+    "category": "Common",
+    "type": "boolean",
+    "default": false,
+    "description": "Use single quotes instead of double quotes."
+  },
+  "proseWrap": {
+    "category": "Common",
+    "type": "choice",
+    "default": "preserve",
+    "description": "How to wrap prose.",
+    "choices": [
+      {
+        "value": "always",
+        "description": "Wrap prose if it exceeds the print width."
+      },
+      {
+        "value": "never",
+        "description": "Do not wrap prose."
+      },
+      {
+        "value": "preserve",
+        "description": "Wrap prose as-is."
+      }
+    ]
+  },
+  "bracketSameLine": {
+    "category": "Common",
+    "type": "boolean",
+    "default": false,
+    "description": "Put > of opening tags on the last line instead of on a new line."
+  },
+  "singleAttributePerLine": {
+    "category": "Common",
+    "type": "boolean",
+    "default": false,
+    "description": "Enforce single attribute per line in HTML, Vue and JSX."
+  }
+};
+// src/language-css/options.js
+var options = {
+  singleQuote: common_options_evaluate_default.singleQuote
+};
+var options_default = options;
+// src/language-css/languages.evaluate.js
+var languages_evaluate_default = [
+  {
+    "linguistLanguageId": 50,
+    "name": "CSS",
+    "type": "markup",
+    "tmScope": "source.css",
+    "aceMode": "css",
+    "codemirrorMode": "css",
+    "codemirrorMimeType": "text/css",
+    "color": "#563d7c",
+    "extensions": [
+      ".css",
+      ".wxss"
+    ],
+    "parsers": [
+      "css"
+    ],
+    "vscodeLanguageIds": [
+      "css"
+    ]
+  },
+  {
+    "linguistLanguageId": 262764437,
+    "name": "PostCSS",
+    "type": "markup",
+    "color": "#dc3a0c",
+    "tmScope": "source.postcss",
+    "group": "CSS",
+    "extensions": [
+      ".pcss",
+      ".postcss"
+    ],
+    "aceMode": "text",
+    "parsers": [
+      "css"
+    ],
+    "vscodeLanguageIds": [
+      "postcss"
+    ]
+  },
+  {
+    "linguistLanguageId": 198,
+    "name": "Less",
+    "type": "markup",
+    "color": "#1d365d",
+    "aliases": [
+      "less-css"
+    ],
+    "extensions": [
+      ".less"
+    ],
+    "tmScope": "source.css.less",
+    "aceMode": "less",
+    "codemirrorMode": "css",
+    "codemirrorMimeType": "text/css",
+    "parsers": [
+      "less"
+    ],
+    "vscodeLanguageIds": [
+      "less"
+    ]
+  },
+  {
+    "linguistLanguageId": 329,
+    "name": "SCSS",
+    "type": "markup",
+    "color": "#c6538c",
+    "tmScope": "source.css.scss",
+    "aceMode": "scss",
+    "codemirrorMode": "css",
+    "codemirrorMimeType": "text/x-scss",
+    "extensions": [
+      ".scss"
+    ],
+    "parsers": [
+      "scss"
+    ],
+    "vscodeLanguageIds": [
+      "scss"
+    ]
+  }
+];
+// src/language-graphql/options.js
+var options2 = {
+  bracketSpacing: common_options_evaluate_default.bracketSpacing
+};
+var options_default2 = options2;
+// src/language-graphql/languages.evaluate.js
+var languages_evaluate_default2 = [
+  {
+    "linguistLanguageId": 139,
+    "name": "GraphQL",
+    "type": "data",
+    "color": "#e10098",
+    "extensions": [
+      ".graphql",
+      ".gql",
+      ".graphqls"
+    ],
+    "tmScope": "source.graphql",
+    "aceMode": "text",
+    "parsers": [
+      "graphql"
+    ],
+    "vscodeLanguageIds": [
+      "graphql"
+    ]
+  }
+];
+// src/language-handlebars/languages.evaluate.js
+var languages_evaluate_default3 = [
+  {
+    "linguistLanguageId": 155,
+    "name": "Handlebars",
+    "type": "markup",
+    "color": "#f7931e",
+    "aliases": [
+      "hbs",
+      "htmlbars"
+    ],
+    "extensions": [
+      ".handlebars",
+      ".hbs"
+    ],
+    "tmScope": "text.html.handlebars",
+    "aceMode": "handlebars",
+    "parsers": [
+      "glimmer"
+    ],
+    "vscodeLanguageIds": [
+      "handlebars"
+    ]
+  }
+];
+// src/language-html/options.js
+var CATEGORY_HTML = "HTML";
+var options3 = {
+  bracketSameLine: common_options_evaluate_default.bracketSameLine,
+  htmlWhitespaceSensitivity: {
+    category: CATEGORY_HTML,
+    type: "choice",
+    default: "css",
+    description: "How to handle whitespaces in HTML.",
+    choices: [
+      {
+        value: "css",
+        description: "Respect the default value of CSS display property."
+      },
+      {
+        value: "strict",
+        description: "Whitespaces are considered sensitive."
+      },
+      {
+        value: "ignore",
+        description: "Whitespaces are considered insensitive."
+      }
+    ]
+  },
+  singleAttributePerLine: common_options_evaluate_default.singleAttributePerLine,
+  vueIndentScriptAndStyle: {
+    category: CATEGORY_HTML,
+    type: "boolean",
+    default: false,
+    description: "Indent script and style tags in Vue files."
+  }
+};
+var options_default3 = options3;
+// src/language-html/languages.evaluate.js
+var languages_evaluate_default4 = [
+  {
+    "linguistLanguageId": 146,
+    "name": "Angular",
+    "type": "markup",
+    "tmScope": "text.html.basic",
+    "aceMode": "html",
+    "codemirrorMode": "htmlmixed",
+    "codemirrorMimeType": "text/html",
+    "color": "#e34c26",
+    "aliases": [
+      "xhtml"
+    ],
+    "extensions": [
+      ".component.html"
+    ],
+    "parsers": [
+      "angular"
+    ],
+    "vscodeLanguageIds": [
+      "html"
+    ],
+    "filenames": []
+  },
+  {
+    "linguistLanguageId": 146,
+    "name": "HTML",
+    "type": "markup",
+    "tmScope": "text.html.basic",
+    "aceMode": "html",
+    "codemirrorMode": "htmlmixed",
+    "codemirrorMimeType": "text/html",
+    "color": "#e34c26",
+    "aliases": [
+      "xhtml"
+    ],
+    "extensions": [
+      ".html",
+      ".hta",
+      ".htm",
+      ".html.hl",
+      ".inc",
+      ".xht",
+      ".xhtml",
+      ".mjml"
+    ],
+    "parsers": [
+      "html"
+    ],
+    "vscodeLanguageIds": [
+      "html"
+    ]
+  },
+  {
+    "linguistLanguageId": 146,
+    "name": "Lightning Web Components",
+    "type": "markup",
+    "tmScope": "text.html.basic",
+    "aceMode": "html",
+    "codemirrorMode": "htmlmixed",
+    "codemirrorMimeType": "text/html",
+    "color": "#e34c26",
+    "aliases": [
+      "xhtml"
+    ],
+    "extensions": [],
+    "parsers": [
+      "lwc"
+    ],
+    "vscodeLanguageIds": [
+      "html"
+    ],
+    "filenames": []
+  },
+  {
+    "linguistLanguageId": 391,
+    "name": "Vue",
+    "type": "markup",
+    "color": "#41b883",
+    "extensions": [
+      ".vue"
+    ],
+    "tmScope": "text.html.vue",
+    "aceMode": "html",
+    "parsers": [
+      "vue"
+    ],
+    "vscodeLanguageIds": [
+      "vue"
+    ]
+  }
+];
+// src/language-js/options.js
+var CATEGORY_JAVASCRIPT = "JavaScript";
+var options4 = {
+  arrowParens: {
+    category: CATEGORY_JAVASCRIPT,
+    type: "choice",
+    default: "always",
+    description: "Include parentheses around a sole arrow function parameter.",
+    choices: [
+      {
+        value: "always",
+        description: "Always include parens. Example: `(x) => x`"
+      },
+      {
+        value: "avoid",
+        description: "Omit parens when possible. Example: `x => x`"
+      }
+    ]
+  },
+  bracketSameLine: common_options_evaluate_default.bracketSameLine,
+  bracketSpacing: common_options_evaluate_default.bracketSpacing,
+  jsxBracketSameLine: {
+    category: CATEGORY_JAVASCRIPT,
+    type: "boolean",
+    description: "Put > on the last line instead of at a new line.",
+    deprecated: "2.4.0"
+  },
+  semi: {
+    category: CATEGORY_JAVASCRIPT,
+    type: "boolean",
+    default: true,
+    description: "Print semicolons.",
+    oppositeDescription: "Do not print semicolons, except at the beginning of lines which may need them."
+  },
+  singleQuote: common_options_evaluate_default.singleQuote,
+  jsxSingleQuote: {
+    category: CATEGORY_JAVASCRIPT,
+    type: "boolean",
+    default: false,
+    description: "Use single quotes in JSX."
+  },
+  quoteProps: {
+    category: CATEGORY_JAVASCRIPT,
+    type: "choice",
+    default: "as-needed",
+    description: "Change when properties in objects are quoted.",
+    choices: [
+      {
+        value: "as-needed",
+        description: "Only add quotes around object properties where required."
+      },
+      {
+        value: "consistent",
+        description: "If at least one property in an object requires quotes, quote all properties."
+      },
+      {
+        value: "preserve",
+        description: "Respect the input use of quotes in object properties."
+      }
+    ]
+  },
+  trailingComma: {
+    category: CATEGORY_JAVASCRIPT,
+    type: "choice",
+    default: "all",
+    description: "Print trailing commas wherever possible when multi-line.",
+    choices: [
+      {
+        value: "all",
+        description: "Trailing commas wherever possible (including function arguments)."
+      },
+      {
+        value: "es5",
+        description: "Trailing commas where valid in ES5 (objects, arrays, etc.)"
+      },
+      { value: "none", description: "No trailing commas." }
+    ]
+  },
+  singleAttributePerLine: common_options_evaluate_default.singleAttributePerLine
+};
+var options_default4 = options4;
+// src/language-js/languages.evaluate.js
+var languages_evaluate_default5 = [
+  {
+    "linguistLanguageId": 183,
+    "name": "JavaScript",
+    "type": "programming",
+    "tmScope": "source.js",
+    "aceMode": "javascript",
+    "codemirrorMode": "javascript",
+    "codemirrorMimeType": "text/javascript",
+    "color": "#f1e05a",
+    "aliases": [
+      "js",
+      "node"
+    ],
+    "extensions": [
+      ".js",
+      "._js",
+      ".bones",
+      ".cjs",
+      ".es",
+      ".es6",
+      ".frag",
+      ".gs",
+      ".jake",
+      ".javascript",
+      ".jsb",
+      ".jscad",
+      ".jsfl",
+      ".jslib",
+      ".jsm",
+      ".jspre",
+      ".jss",
+      ".mjs",
+      ".njs",
+      ".pac",
+      ".sjs",
+      ".ssjs",
+      ".xsjs",
+      ".xsjslib",
+      ".wxs"
+    ],
+    "filenames": [
+      "Jakefile"
+    ],
+    "interpreters": [
+      "chakra",
+      "d8",
+      "gjs",
+      "js",
+      "node",
+      "nodejs",
+      "qjs",
+      "rhino",
+      "v8",
+      "v8-shell",
+      "zx"
+    ],
+    "parsers": [
+      "babel",
+      "acorn",
+      "espree",
+      "meriyah",
+      "babel-flow",
+      "babel-ts",
+      "flow",
+      "typescript"
+    ],
+    "vscodeLanguageIds": [
+      "javascript",
+      "mongo"
+    ]
+  },
+  {
+    "linguistLanguageId": 183,
+    "name": "Flow",
+    "type": "programming",
+    "tmScope": "source.js",
+    "aceMode": "javascript",
+    "codemirrorMode": "javascript",
+    "codemirrorMimeType": "text/javascript",
+    "color": "#f1e05a",
+    "aliases": [],
+    "extensions": [
+      ".js.flow"
+    ],
+    "filenames": [],
+    "interpreters": [
+      "chakra",
+      "d8",
+      "gjs",
+      "js",
+      "node",
+      "nodejs",
+      "qjs",
+      "rhino",
+      "v8",
+      "v8-shell"
+    ],
+    "parsers": [
+      "flow",
+      "babel-flow"
+    ],
+    "vscodeLanguageIds": [
+      "javascript"
+    ]
+  },
+  {
+    "linguistLanguageId": 183,
+    "name": "JSX",
+    "type": "programming",
+    "tmScope": "source.js.jsx",
+    "aceMode": "javascript",
+    "codemirrorMode": "jsx",
+    "codemirrorMimeType": "text/jsx",
+    "color": void 0,
+    "aliases": void 0,
+    "extensions": [
+      ".jsx"
+    ],
+    "filenames": void 0,
+    "interpreters": void 0,
+    "parsers": [
+      "babel",
+      "babel-flow",
+      "babel-ts",
+      "flow",
+      "typescript",
+      "espree",
+      "meriyah"
+    ],
+    "vscodeLanguageIds": [
+      "javascriptreact"
+    ],
+    "group": "JavaScript"
+  },
+  {
+    "linguistLanguageId": 378,
+    "name": "TypeScript",
+    "type": "programming",
+    "color": "#3178c6",
+    "aliases": [
+      "ts"
+    ],
+    "interpreters": [
+      "deno",
+      "ts-node"
+    ],
+    "extensions": [
+      ".ts",
+      ".cts",
+      ".mts"
+    ],
+    "tmScope": "source.ts",
+    "aceMode": "typescript",
+    "codemirrorMode": "javascript",
+    "codemirrorMimeType": "application/typescript",
+    "parsers": [
+      "typescript",
+      "babel-ts"
+    ],
+    "vscodeLanguageIds": [
+      "typescript"
+    ]
+  },
+  {
+    "linguistLanguageId": 94901924,
+    "name": "TSX",
+    "type": "programming",
+    "color": "#3178c6",
+    "group": "TypeScript",
+    "extensions": [
+      ".tsx"
+    ],
+    "tmScope": "source.tsx",
+    "aceMode": "javascript",
+    "codemirrorMode": "jsx",
+    "codemirrorMimeType": "text/jsx",
+    "parsers": [
+      "typescript",
+      "babel-ts"
+    ],
+    "vscodeLanguageIds": [
+      "typescriptreact"
+    ]
+  }
+];
+// src/language-json/languages.evaluate.js
+var languages_evaluate_default6 = [
+  {
+    "linguistLanguageId": 174,
+    "name": "JSON.stringify",
+    "type": "data",
+    "color": "#292929",
+    "tmScope": "source.json",
+    "aceMode": "json",
+    "codemirrorMode": "javascript",
+    "codemirrorMimeType": "application/json",
+    "aliases": [
+      "geojson",
+      "jsonl",
+      "topojson"
+    ],
+    "extensions": [
+      ".importmap"
+    ],
+    "filenames": [
+      "package.json",
+      "package-lock.json",
+      "composer.json"
+    ],
+    "parsers": [
+      "json-stringify"
+    ],
+    "vscodeLanguageIds": [
+      "json"
+    ]
+  },
+  {
+    "linguistLanguageId": 174,
+    "name": "JSON",
+    "type": "data",
+    "color": "#292929",
+    "tmScope": "source.json",
+    "aceMode": "json",
+    "codemirrorMode": "javascript",
+    "codemirrorMimeType": "application/json",
+    "aliases": [
+      "geojson",
+      "jsonl",
+      "topojson"
+    ],
+    "extensions": [
+      ".json",
+      ".4DForm",
+      ".4DProject",
+      ".avsc",
+      ".geojson",
+      ".gltf",
+      ".har",
+      ".ice",
+      ".JSON-tmLanguage",
+      ".mcmeta",
+      ".tfstate",
+      ".tfstate.backup",
+      ".topojson",
+      ".webapp",
+      ".webmanifest",
+      ".yy",
+      ".yyp"
+    ],
+    "filenames": [
+      ".arcconfig",
+      ".auto-changelog",
+      ".c8rc",
+      ".htmlhintrc",
+      ".imgbotconfig",
+      ".nycrc",
+      ".tern-config",
+      ".tern-project",
+      ".watchmanconfig",
+      "Pipfile.lock",
+      "composer.lock",
+      "mcmod.info"
+    ],
+    "parsers": [
+      "json"
+    ],
+    "vscodeLanguageIds": [
+      "json"
+    ]
+  },
+  {
+    "linguistLanguageId": 423,
+    "name": "JSON with Comments",
+    "type": "data",
+    "color": "#292929",
+    "group": "JSON",
+    "tmScope": "source.js",
+    "aceMode": "javascript",
+    "codemirrorMode": "javascript",
+    "codemirrorMimeType": "text/javascript",
+    "aliases": [
+      "jsonc"
+    ],
+    "extensions": [
+      ".jsonc",
+      ".code-snippets",
+      ".sublime-build",
+      ".sublime-commands",
+      ".sublime-completions",
+      ".sublime-keymap",
+      ".sublime-macro",
+      ".sublime-menu",
+      ".sublime-mousemap",
+      ".sublime-project",
+      ".sublime-settings",
+      ".sublime-theme",
+      ".sublime-workspace",
+      ".sublime_metrics",
+      ".sublime_session"
+    ],
+    "filenames": [
+      ".babelrc",
+      ".devcontainer.json",
+      ".eslintrc.json",
+      ".jscsrc",
+      ".jshintrc",
+      ".jslintrc",
+      "api-extractor.json",
+      "devcontainer.json",
+      "jsconfig.json",
+      "language-configuration.json",
+      "tsconfig.json",
+      "tslint.json",
+      ".eslintrc",
+      ".swcrc"
+    ],
+    "parsers": [
+      "json"
+    ],
+    "vscodeLanguageIds": [
+      "jsonc"
+    ]
+  },
+  {
+    "linguistLanguageId": 175,
+    "name": "JSON5",
+    "type": "data",
+    "color": "#267CB9",
+    "extensions": [
+      ".json5"
+    ],
+    "tmScope": "source.js",
+    "aceMode": "javascript",
+    "codemirrorMode": "javascript",
+    "codemirrorMimeType": "application/json",
+    "parsers": [
+      "json5"
+    ],
+    "vscodeLanguageIds": [
+      "json5"
+    ]
+  }
+];
+// src/language-markdown/options.js
+var options5 = {
+  proseWrap: common_options_evaluate_default.proseWrap,
+  singleQuote: common_options_evaluate_default.singleQuote
+};
+var options_default5 = options5;
+// src/language-markdown/languages.evaluate.js
+var languages_evaluate_default7 = [
+  {
+    "linguistLanguageId": 222,
+    "name": "Markdown",
+    "type": "prose",
+    "color": "#083fa1",
+    "aliases": [
+      "pandoc"
+    ],
+    "aceMode": "markdown",
+    "codemirrorMode": "gfm",
+    "codemirrorMimeType": "text/x-gfm",
+    "wrap": true,
+    "extensions": [
+      ".md",
+      ".livemd",
+      ".markdown",
+      ".mdown",
+      ".mdwn",
+      ".mkd",
+      ".mkdn",
+      ".mkdown",
+      ".ronn",
+      ".scd",
+      ".workbook"
+    ],
+    "filenames": [
+      "contents.lr",
+      "README"
+    ],
+    "tmScope": "source.gfm",
+    "parsers": [
+      "markdown"
+    ],
+    "vscodeLanguageIds": [
+      "markdown"
+    ]
+  },
+  {
+    "linguistLanguageId": 222,
+    "name": "MDX",
+    "type": "prose",
+    "color": "#083fa1",
+    "aliases": [
+      "pandoc"
+    ],
+    "aceMode": "markdown",
+    "codemirrorMode": "gfm",
+    "codemirrorMimeType": "text/x-gfm",
+    "wrap": true,
+    "extensions": [
+      ".mdx"
+    ],
+    "filenames": [],
+    "tmScope": "source.gfm",
+    "parsers": [
+      "mdx"
+    ],
+    "vscodeLanguageIds": [
+      "mdx"
+    ]
+  }
+];
+// src/language-yaml/options.js
+var options6 = {
+  bracketSpacing: common_options_evaluate_default.bracketSpacing,
+  singleQuote: common_options_evaluate_default.singleQuote,
+  proseWrap: common_options_evaluate_default.proseWrap
+};
+var options_default6 = options6;
+// src/language-yaml/languages.evaluate.js
+var languages_evaluate_default8 = [
+  {
+    "linguistLanguageId": 407,
+    "name": "YAML",
+    "type": "data",
+    "color": "#cb171e",
+    "tmScope": "source.yaml",
+    "aliases": [
+      "yml"
+    ],
+    "extensions": [
+      ".yml",
+      ".mir",
+      ".reek",
+      ".rviz",
+      ".sublime-syntax",
+      ".syntax",
+      ".yaml",
+      ".yaml-tmlanguage",
+      ".yaml.sed",
+      ".yml.mysql"
+    ],
+    "filenames": [
+      ".clang-format",
+      ".clang-tidy",
+      ".gemrc",
+      "CITATION.cff",
+      "glide.lock",
+      ".prettierrc",
+      ".stylelintrc",
+      ".lintstagedrc"
+    ],
+    "aceMode": "yaml",
+    "codemirrorMode": "yaml",
+    "codemirrorMimeType": "text/x-yaml",
+    "parsers": [
+      "yaml"
+    ],
+    "vscodeLanguageIds": [
+      "yaml",
+      "ansible",
+      "home-assistant"
+    ]
+  }
+];
+// src/plugins/builtin-plugins-proxy.js
+function createParsersAndParsers(modules) {
+  const parsers2 = /* @__PURE__ */ Object.create(null);
+  const printers2 = /* @__PURE__ */ Object.create(null);
+  for (const {
+    importPlugin: importPlugin2,
+    parsers: parserNames = [],
+    printers: printerNames = []
+  } of modules) {
+    const loadPlugin2 = async () => {
+      const plugin = await importPlugin2();
+      Object.assign(parsers2, plugin.parsers);
+      Object.assign(printers2, plugin.printers);
+      return plugin;
+    };
+    for (const parserName of parserNames) {
+      parsers2[parserName] = async () => (await loadPlugin2()).parsers[parserName];
+    }
+    for (const printerName of printerNames) {
+      printers2[printerName] = async () => (await loadPlugin2()).printers[printerName];
+    }
+  }
+  return { parsers: parsers2, printers: printers2 };
+}
+var options7 = {
+  ...options_default,
+  ...options_default2,
+  ...options_default3,
+  ...options_default4,
+  ...options_default5,
+  ...options_default6
+};
+var languages = [
+  ...languages_evaluate_default,
+  ...languages_evaluate_default2,
+  ...languages_evaluate_default3,
+  ...languages_evaluate_default4,
+  ...languages_evaluate_default5,
+  ...languages_evaluate_default6,
+  ...languages_evaluate_default7,
+  ...languages_evaluate_default8
+];
+var { parsers, printers } = createParsersAndParsers([
+  {
+    importPlugin: () => import("./plugins/acorn.mjs"),
+    parsers: ["acorn", "espree"]
+  },
+  {
+    importPlugin: () => import("./plugins/angular.mjs"),
+    parsers: [
+      "__ng_action",
+      "__ng_binding",
+      "__ng_interpolation",
+      "__ng_directive"
+    ]
+  },
+  {
+    importPlugin: () => import("./plugins/babel.mjs"),
+    parsers: [
+      "babel",
+      "babel-flow",
+      "babel-ts",
+      "__js_expression",
+      "__ts_expression",
+      "__vue_expression",
+      "__vue_ts_expression",
+      "__vue_event_binding",
+      "__vue_ts_event_binding",
+      "__babel_estree",
+      "json",
+      "json5",
+      "json-stringify"
+    ]
+  },
+  {
+    importPlugin: () => import("./plugins/estree.mjs"),
+    printers: ["estree", "estree-json"]
+  },
+  {
+    importPlugin: () => import("./plugins/flow.mjs"),
+    parsers: ["flow"]
+  },
+  {
+    importPlugin: () => import("./plugins/glimmer.mjs"),
+    parsers: ["glimmer"],
+    printers: ["glimmer"]
+  },
+  {
+    importPlugin: () => import("./plugins/graphql.mjs"),
+    parsers: ["graphql"],
+    printers: ["graphql"]
+  },
+  {
+    importPlugin: () => import("./plugins/html.mjs"),
+    parsers: ["html", "angular", "vue", "lwc"],
+    printers: ["html"]
+  },
+  {
+    importPlugin: () => import("./plugins/markdown.mjs"),
+    parsers: ["markdown", "mdx", "remark"],
+    printers: ["mdast"]
+  },
+  {
+    importPlugin: () => import("./plugins/meriyah.mjs"),
+    parsers: ["meriyah"]
+  },
+  {
+    importPlugin: () => import("./plugins/postcss.mjs"),
+    parsers: ["css", "less", "scss"],
+    printers: ["postcss"]
+  },
+  {
+    importPlugin: () => import("./plugins/typescript.mjs"),
+    parsers: ["typescript"]
+  },
+  {
+    importPlugin: () => import("./plugins/yaml.mjs"),
+    parsers: ["yaml"],
+    printers: ["yaml"]
+  }
+]);
 // src/main/plugins/load-builtin-plugins.js
-var builtinPlugins;
-async function loadBuiltinPlugins() {
-  builtinPlugins ?? (builtinPlugins = await Promise.all([
-    import("./plugins/estree.mjs"),
-    import("./plugins/babel.mjs"),
-    import("./plugins/flow.mjs"),
-    import("./plugins/typescript.mjs"),
-    import("./plugins/acorn.mjs"),
-    import("./plugins/meriyah.mjs"),
-    import("./plugins/angular.mjs"),
-    import("./plugins/postcss.mjs"),
-    import("./plugins/graphql.mjs"),
-    import("./plugins/markdown.mjs"),
-    import("./plugins/glimmer.mjs"),
-    import("./plugins/html.mjs"),
-    import("./plugins/yaml.mjs")
-  ]));
-  return builtinPlugins;
+function loadBuiltinPlugins() {
+  return [builtin_plugins_proxy_exports];
 }
 var load_builtin_plugins_default = loadBuiltinPlugins;
@@ -20629,11 +21626,11 @@ function hasNewlineInRange(text, startIndex, endIndex) {
 var has_newline_in_range_default = hasNewlineInRange;
 // src/utils/has-spaces.js
-function hasSpaces(text, startIndex, options = {}) {
+function hasSpaces(text, startIndex, options8 = {}) {
   const idx = skipSpaces(
     text,
-    options.backwards ? startIndex - 1 : startIndex,
-    options
+    options8.backwards ? startIndex - 1 : startIndex,
+    options8
   );
   return idx !== startIndex;
 }
@@ -20711,35 +21708,35 @@ function isNextLineEmpty2(text, startIndex) {
 import * as doc from "./doc.mjs";
 // src/main/version.evaluate.cjs
-var version_evaluate_default = "3.0.0-alpha.10";
+var version_evaluate_default = "3.0.0-alpha.11";
 // src/index.js
 function withPlugins(fn, optionsArgumentIndex = 1) {
   return async (...args) => {
-    const options = args[optionsArgumentIndex] ?? {};
-    const { plugins = [], pluginSearchDirs } = options;
+    const options8 = args[optionsArgumentIndex] ?? {};
+    const { plugins = [], pluginSearchDirs } = options8;
     args[optionsArgumentIndex] = {
-      ...options,
+      ...options8,
       plugins: (await Promise.all([
         load_builtin_plugins_default(),
         // TODO: standalone version allow `plugins` to be `prettierPlugins` which is an object, should allow that too
         load_plugins_default(plugins),
-        options.pluginSearchDirs === false ? [] : searchPlugins(pluginSearchDirs)
+        options8.pluginSearchDirs === false ? [] : searchPlugins(pluginSearchDirs)
       ])).flat()
     };
     return fn(...args);
   };
 }
 var formatWithCursor2 = withPlugins(formatWithCursor);
-async function format2(text, options) {
+async function format2(text, options8) {
   const { formatted } = await formatWithCursor2(text, {
-    ...options,
+    ...options8,
     cursorOffset: -1
   });
   return formatted;
 }
-async function check(text, options) {
-  return await format2(text, options) === text;
+async function check(text, options8) {
+  return await format2(text, options8) === text;
 }
 async function clearCache5() {
   clearCache();