prettier 3.3.2 → 3.3.3

package/index.mjs

@@ -55,538 +55,6 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
-// node_modules/diff/lib/diff/base.js
-var require_base = __commonJS({
-  "node_modules/diff/lib/diff/base.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports["default"] = Diff;
-    function Diff() {
-    }
-    Diff.prototype = {
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      diff: function diff(oldString, newString) {
-        var _options$timeout;
-        var options8 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-        var callback = options8.callback;
-        if (typeof options8 === "function") {
-          callback = options8;
-          options8 = {};
-        }
-        this.options = options8;
-        var self = this;
-        function done(value) {
-          if (callback) {
-            setTimeout(function() {
-              callback(void 0, value);
-            }, 0);
-            return true;
-          } else {
-            return value;
-          }
-        }
-        oldString = this.castInput(oldString);
-        newString = this.castInput(newString);
-        oldString = this.removeEmpty(this.tokenize(oldString));
-        newString = this.removeEmpty(this.tokenize(newString));
-        var newLen = newString.length, oldLen = oldString.length;
-        var editLength = 1;
-        var maxEditLength = newLen + oldLen;
-        if (options8.maxEditLength) {
-          maxEditLength = Math.min(maxEditLength, options8.maxEditLength);
-        }
-        var maxExecutionTime = (
-          /*istanbul ignore start*/
-          (_options$timeout = /*istanbul ignore end*/
-          options8.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity
-        );
-        var abortAfterTimestamp = Date.now() + maxExecutionTime;
-        var bestPath = [{
-          oldPos: -1,
-          lastComponent: void 0
-        }];
-        var newPos = this.extractCommon(bestPath[0], newString, oldString, 0);
-        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done([{
-            value: this.join(newString),
-            count: newString.length
-          }]);
-        }
-        var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-        function execEditLength() {
-          for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-            var basePath = (
-              /*istanbul ignore start*/
-              void 0
-            );
-            var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-            if (removePath) {
-              bestPath[diagonalPath - 1] = void 0;
-            }
-            var canAdd = false;
-            if (addPath) {
-              var addPathNewPos = addPath.oldPos - diagonalPath;
-              canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-            }
-            var canRemove = removePath && removePath.oldPos + 1 < oldLen;
-            if (!canAdd && !canRemove) {
-              bestPath[diagonalPath] = void 0;
-              continue;
-            }
-            if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) {
-              basePath = self.addToPath(addPath, true, void 0, 0);
-            } else {
-              basePath = self.addToPath(removePath, void 0, true, 1);
-            }
-            newPos = self.extractCommon(basePath, newString, oldString, diagonalPath);
-            if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-              return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
-            } else {
-              bestPath[diagonalPath] = basePath;
-              if (basePath.oldPos + 1 >= oldLen) {
-                maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-              }
-              if (newPos + 1 >= newLen) {
-                minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-              }
-            }
-          }
-          editLength++;
-        }
-        if (callback) {
-          (function exec() {
-            setTimeout(function() {
-              if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-                return callback();
-              }
-              if (!execEditLength()) {
-                exec();
-              }
-            }, 0);
-          })();
-        } else {
-          while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-            var ret = execEditLength();
-            if (ret) {
-              return ret;
-            }
-          }
-        }
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      addToPath: function addToPath(path13, added, removed, oldPosInc) {
-        var last = path13.lastComponent;
-        if (last && last.added === added && last.removed === removed) {
-          return {
-            oldPos: path13.oldPos + oldPosInc,
-            lastComponent: {
-              count: last.count + 1,
-              added,
-              removed,
-              previousComponent: last.previousComponent
-            }
-          };
-        } else {
-          return {
-            oldPos: path13.oldPos + oldPosInc,
-            lastComponent: {
-              count: 1,
-              added,
-              removed,
-              previousComponent: last
-            }
-          };
-        }
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
-        var newLen = newString.length, oldLen = oldString.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
-          newPos++;
-          oldPos++;
-          commonCount++;
-        }
-        if (commonCount) {
-          basePath.lastComponent = {
-            count: commonCount,
-            previousComponent: basePath.lastComponent
-          };
-        }
-        basePath.oldPos = oldPos;
-        return newPos;
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      equals: function equals(left, right) {
-        if (this.options.comparator) {
-          return this.options.comparator(left, right);
-        } else {
-          return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-        }
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      removeEmpty: function removeEmpty(array2) {
-        var ret = [];
-        for (var i = 0; i < array2.length; i++) {
-          if (array2[i]) {
-            ret.push(array2[i]);
-          }
-        }
-        return ret;
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      castInput: function castInput(value) {
-        return value;
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      tokenize: function tokenize(value) {
-        return value.split("");
-      },
-      /*istanbul ignore start*/
-      /*istanbul ignore end*/
-      join: function join2(chars) {
-        return chars.join("");
-      }
-    };
-    function buildValues(diff, lastComponent, newString, oldString, useLongestToken) {
-      var components = [];
-      var nextComponent;
-      while (lastComponent) {
-        components.push(lastComponent);
-        nextComponent = lastComponent.previousComponent;
-        delete lastComponent.previousComponent;
-        lastComponent = nextComponent;
-      }
-      components.reverse();
-      var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
-      for (; componentPos < componentLen; componentPos++) {
-        var component = components[componentPos];
-        if (!component.removed) {
-          if (!component.added && useLongestToken) {
-            var value = newString.slice(newPos, newPos + component.count);
-            value = value.map(function(value2, i) {
-              var oldValue = oldString[oldPos + i];
-              return oldValue.length > value2.length ? oldValue : value2;
-            });
-            component.value = diff.join(value);
-          } else {
-            component.value = diff.join(newString.slice(newPos, newPos + component.count));
-          }
-          newPos += component.count;
-          if (!component.added) {
-            oldPos += component.count;
-          }
-        } else {
-          component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
-          oldPos += component.count;
-          if (componentPos && components[componentPos - 1].added) {
-            var tmp = components[componentPos - 1];
-            components[componentPos - 1] = components[componentPos];
-            components[componentPos] = tmp;
-          }
-        }
-      }
-      var finalComponent = components[componentLen - 1];
-      if (componentLen > 1 && typeof finalComponent.value === "string" && (finalComponent.added || finalComponent.removed) && diff.equals("", finalComponent.value)) {
-        components[componentLen - 2].value += finalComponent.value;
-        components.pop();
-      }
-      return components;
-    }
-  }
-});
-
-// node_modules/diff/lib/util/params.js
-var require_params = __commonJS({
-  "node_modules/diff/lib/util/params.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.generateOptions = generateOptions;
-    function generateOptions(options8, defaults) {
-      if (typeof options8 === "function") {
-        defaults.callback = options8;
-      } else if (options8) {
-        for (var name in options8) {
-          if (options8.hasOwnProperty(name)) {
-            defaults[name] = options8[name];
-          }
-        }
-      }
-      return defaults;
-    }
-  }
-});
-
-// node_modules/diff/lib/diff/line.js
-var require_line = __commonJS({
-  "node_modules/diff/lib/diff/line.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.diffLines = diffLines;
-    exports.diffTrimmedLines = diffTrimmedLines;
-    exports.lineDiff = void 0;
-    var _base = _interopRequireDefault(require_base());
-    var _params = require_params();
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    var lineDiff = new /*istanbul ignore start*/
-    _base[
-      /*istanbul ignore start*/
-      "default"
-      /*istanbul ignore end*/
-    ]();
-    exports.lineDiff = lineDiff;
-    lineDiff.tokenize = function(value) {
-      if (this.options.stripTrailingCr) {
-        value = value.replace(/\r\n/g, "\n");
-      }
-      var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-      if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-        linesAndNewlines.pop();
-      }
-      for (var i = 0; i < linesAndNewlines.length; i++) {
-        var line3 = linesAndNewlines[i];
-        if (i % 2 && !this.options.newlineIsToken) {
-          retLines[retLines.length - 1] += line3;
-        } else {
-          if (this.options.ignoreWhitespace) {
-            line3 = line3.trim();
-          }
-          retLines.push(line3);
-        }
-      }
-      return retLines;
-    };
-    function diffLines(oldStr, newStr, callback) {
-      return lineDiff.diff(oldStr, newStr, callback);
-    }
-    function diffTrimmedLines(oldStr, newStr, callback) {
-      var options8 = (
-        /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _params.generateOptions)(callback, {
-          ignoreWhitespace: true
-        })
-      );
-      return lineDiff.diff(oldStr, newStr, options8);
-    }
-  }
-});
-
-// node_modules/diff/lib/patch/create.js
-var require_create = __commonJS({
-  "node_modules/diff/lib/patch/create.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.structuredPatch = structuredPatch;
-    exports.formatPatch = formatPatch;
-    exports.createTwoFilesPatch = createTwoFilesPatch2;
-    exports.createPatch = createPatch;
-    var _line = require_line();
-    function _toConsumableArray(arr) {
-      return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-    }
-    function _nonIterableSpread() {
-      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    function _unsupportedIterableToArray(o, minLen) {
-      if (!o) return;
-      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-      var n = Object.prototype.toString.call(o).slice(8, -1);
-      if (n === "Object" && o.constructor) n = o.constructor.name;
-      if (n === "Map" || n === "Set") return Array.from(o);
-      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-    }
-    function _iterableToArray(iter) {
-      if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
-    }
-    function _arrayWithoutHoles(arr) {
-      if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-    }
-    function _arrayLikeToArray(arr, len) {
-      if (len == null || len > arr.length) len = arr.length;
-      for (var i = 0, arr2 = new Array(len); i < len; i++) {
-        arr2[i] = arr[i];
-      }
-      return arr2;
-    }
-    function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options8) {
-      if (!options8) {
-        options8 = {};
-      }
-      if (typeof options8.context === "undefined") {
-        options8.context = 4;
-      }
-      var diff = (
-        /*istanbul ignore start*/
-        (0, /*istanbul ignore end*/
-        /*istanbul ignore start*/
-        _line.diffLines)(oldStr, newStr, options8)
-      );
-      if (!diff) {
-        return;
-      }
-      diff.push({
-        value: "",
-        lines: []
-      });
-      function contextLines(lines) {
-        return lines.map(function(entry) {
-          return " " + entry;
-        });
-      }
-      var hunks = [];
-      var oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
-      var _loop = function _loop2(i2) {
-        var current = diff[i2], lines = current.lines || current.value.replace(/\n$/, "").split("\n");
-        current.lines = lines;
-        if (current.added || current.removed) {
-          var _curRange;
-          if (!oldRangeStart) {
-            var prev = diff[i2 - 1];
-            oldRangeStart = oldLine;
-            newRangeStart = newLine;
-            if (prev) {
-              curRange = options8.context > 0 ? contextLines(prev.lines.slice(-options8.context)) : [];
-              oldRangeStart -= curRange.length;
-              newRangeStart -= curRange.length;
-            }
-          }
-          (_curRange = /*istanbul ignore end*/
-          curRange).push.apply(
-            /*istanbul ignore start*/
-            _curRange,
-            /*istanbul ignore start*/
-            _toConsumableArray(
-              /*istanbul ignore end*/
-              lines.map(function(entry) {
-                return (current.added ? "+" : "-") + entry;
-              })
-            )
-          );
-          if (current.added) {
-            newLine += lines.length;
-          } else {
-            oldLine += lines.length;
-          }
-        } else {
-          if (oldRangeStart) {
-            if (lines.length <= options8.context * 2 && i2 < diff.length - 2) {
-              var _curRange2;
-              (_curRange2 = /*istanbul ignore end*/
-              curRange).push.apply(
-                /*istanbul ignore start*/
-                _curRange2,
-                /*istanbul ignore start*/
-                _toConsumableArray(
-                  /*istanbul ignore end*/
-                  contextLines(lines)
-                )
-              );
-            } else {
-              var _curRange3;
-              var contextSize = Math.min(lines.length, options8.context);
-              (_curRange3 = /*istanbul ignore end*/
-              curRange).push.apply(
-                /*istanbul ignore start*/
-                _curRange3,
-                /*istanbul ignore start*/
-                _toConsumableArray(
-                  /*istanbul ignore end*/
-                  contextLines(lines.slice(0, contextSize))
-                )
-              );
-              var hunk = {
-                oldStart: oldRangeStart,
-                oldLines: oldLine - oldRangeStart + contextSize,
-                newStart: newRangeStart,
-                newLines: newLine - newRangeStart + contextSize,
-                lines: curRange
-              };
-              if (i2 >= diff.length - 2 && lines.length <= options8.context) {
-                var oldEOFNewline = /\n$/.test(oldStr);
-                var newEOFNewline = /\n$/.test(newStr);
-                var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;
-                if (!oldEOFNewline && noNlBeforeAdds && oldStr.length > 0) {
-                  curRange.splice(hunk.oldLines, 0, "\");
-                }
-                if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) {
-                  curRange.push("\");
-                }
-              }
-              hunks.push(hunk);
-              oldRangeStart = 0;
-              newRangeStart = 0;
-              curRange = [];
-            }
-          }
-          oldLine += lines.length;
-          newLine += lines.length;
-        }
-      };
-      for (var i = 0; i < diff.length; i++) {
-        _loop(
-          /*istanbul ignore end*/
-          i
-        );
-      }
-      return {
-        oldFileName,
-        newFileName,
-        oldHeader,
-        newHeader,
-        hunks
-      };
-    }
-    function formatPatch(diff) {
-      if (Array.isArray(diff)) {
-        return diff.map(formatPatch).join("\n");
-      }
-      var ret = [];
-      if (diff.oldFileName == diff.newFileName) {
-        ret.push("Index: " + diff.oldFileName);
-      }
-      ret.push("===================================================================");
-      ret.push("--- " + diff.oldFileName + (typeof diff.oldHeader === "undefined" ? "" : "	" + diff.oldHeader));
-      ret.push("+++ " + diff.newFileName + (typeof diff.newHeader === "undefined" ? "" : "	" + diff.newHeader));
-      for (var i = 0; i < diff.hunks.length; i++) {
-        var hunk = diff.hunks[i];
-        if (hunk.oldLines === 0) {
-          hunk.oldStart -= 1;
-        }
-        if (hunk.newLines === 0) {
-          hunk.newStart -= 1;
-        }
-        ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
-        ret.push.apply(ret, hunk.lines);
-      }
-      return ret.join("\n") + "\n";
-    }
-    function createTwoFilesPatch2(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options8) {
-      return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options8));
-    }
-    function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options8) {
-      return createTwoFilesPatch2(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options8);
-    }
-  }
-});
-
 // node_modules/fast-glob/out/utils/array.js
 var require_array = __commonJS({
   "node_modules/fast-glob/out/utils/array.js"(exports) {
@@ -1202,9 +670,9 @@ var require_to_regex_range = __commonJS({
       if (!tok.isPadded) {
         return value;
       }
-      let diff = Math.abs(tok.maxLen - String(value).length);
+      let diff2 = Math.abs(tok.maxLen - String(value).length);
       let relax = options8.relaxZeros !== false;
-      switch (diff) {
+      switch (diff2) {
         case 0:
           return "";
         case 1:
@@ -1212,7 +680,7 @@ var require_to_regex_range = __commonJS({
         case 2:
           return relax ? "0{0,2}" : "00";
         default: {
-          return relax ? `0{0,${diff}}` : `0{${diff}}`;
+          return relax ? `0{0,${diff2}}` : `0{${diff2}}`;
         }
       }
     }
@@ -4627,14 +4095,14 @@ var require_queue = __commonJS({
   "node_modules/fastq/queue.js"(exports, module) {
     "use strict";
     var reusify = require_reusify();
-    function fastqueue(context, worker, concurrency) {
+    function fastqueue(context, worker, _concurrency) {
       if (typeof context === "function") {
-        concurrency = worker;
+        _concurrency = worker;
         worker = context;
         context = null;
       }
-      if (concurrency < 1) {
-        throw new Error("fastqueue concurrency must be greater than 1");
+      if (!(_concurrency >= 1)) {
+        throw new Error("fastqueue concurrency must be equal to or greater than 1");
       }
       var cache3 = reusify(Task);
       var queueHead = null;
@@ -4647,7 +4115,20 @@ var require_queue = __commonJS({
         saturated: noop2,
         pause,
         paused: false,
-        concurrency,
+        get concurrency() {
+          return _concurrency;
+        },
+        set concurrency(value) {
+          if (!(value >= 1)) {
+            throw new Error("fastqueue concurrency must be equal to or greater than 1");
+          }
+          _concurrency = value;
+          if (self.paused) return;
+          for (; queueHead && _running < _concurrency; ) {
+            _running++;
+            release();
+          }
+        },
         running,
         resume,
         idle,
@@ -4687,7 +4168,12 @@ var require_queue = __commonJS({
       function resume() {
         if (!self.paused) return;
         self.paused = false;
-        for (var i = 0; i < self.concurrency; i++) {
+        if (queueHead === null) {
+          _running++;
+          release();
+          return;
+        }
+        for (; queueHead && _running < _concurrency; ) {
           _running++;
           release();
         }
@@ -4702,7 +4188,7 @@ var require_queue = __commonJS({
         current.value = value;
         current.callback = done || noop2;
         current.errorHandler = errorHandler;
-        if (_running === self.concurrency || self.paused) {
+        if (_running >= _concurrency || self.paused) {
           if (queueTail) {
             queueTail.next = current;
             queueTail = current;
@@ -4722,7 +4208,8 @@ var require_queue = __commonJS({
         current.release = release;
         current.value = value;
         current.callback = done || noop2;
-        if (_running === self.concurrency || self.paused) {
+        current.errorHandler = errorHandler;
+        if (_running >= _concurrency || self.paused) {
           if (queueHead) {
             current.next = queueHead;
             queueHead = current;
@@ -4741,7 +4228,7 @@ var require_queue = __commonJS({
           cache3.release(holder);
         }
         var next = queueHead;
-        if (next) {
+        if (next && _running <= _concurrency) {
           if (!self.paused) {
             if (queueTail === queueHead) {
               queueTail = null;
@@ -4797,9 +4284,9 @@ var require_queue = __commonJS({
         self.release(self);
       };
     }
-    function queueAsPromised(context, worker, concurrency) {
+    function queueAsPromised(context, worker, _concurrency) {
       if (typeof context === "function") {
-        concurrency = worker;
+        _concurrency = worker;
         worker = context;
         context = null;
       }
@@ -4808,7 +4295,7 @@ var require_queue = __commonJS({
           cb(null, res);
         }, cb);
       }
-      var queue = fastqueue(context, asyncWrapper, concurrency);
+      var queue = fastqueue(context, asyncWrapper, _concurrency);
       var pushCb = queue.push;
       var unshiftCb = queue.unshift;
       queue.push = push2;
@@ -7401,9 +6888,9 @@ var require_yallist = __commonJS({
   }
 });
 
-// node_modules/editorconfig/node_modules/lru-cache/index.js
+// node_modules/lru-cache/index.js
 var require_lru_cache = __commonJS({
-  "node_modules/editorconfig/node_modules/lru-cache/index.js"(exports, module) {
+  "node_modules/lru-cache/index.js"(exports, module) {
     "use strict";
     module.exports = LRUCache;
     var Map2 = require_map();
@@ -7755,11 +7242,11 @@ var require_lru_cache = __commonJS({
         return false;
       }
       var stale = false;
-      var diff = Date.now() - hit.now;
+      var diff2 = Date.now() - hit.now;
       if (hit.maxAge) {
-        stale = diff > hit.maxAge;
+        stale = diff2 > hit.maxAge;
       } else {
-        stale = self[MAX_AGE] && diff > self[MAX_AGE];
+        stale = self[MAX_AGE] && diff2 > self[MAX_AGE];
       }
       return stale;
     }
@@ -11301,7 +10788,7 @@ var require_lib2 = __commonJS({
     }
     var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
     var BRACKET = /^[()[\]{}]$/;
-    var tokenize;
+    var tokenize2;
     {
       const JSX_TAG = /^[a-z][\w-]*$/i;
       const getTokenType = function(token2, offset, text) {
@@ -11324,7 +10811,7 @@ var require_lib2 = __commonJS({
         }
         return token2.type;
       };
-      tokenize = function* (text) {
+      tokenize2 = function* (text) {
         let match;
         while (match = _jsTokens.default.exec(text)) {
           const token2 = _jsTokens.matchToToken(match);
@@ -11340,7 +10827,7 @@ var require_lib2 = __commonJS({
       for (const {
         type: type2,
         value
-      } of tokenize(text)) {
+      } of tokenize2(text)) {
         const colorize = defs[type2];
         if (colorize) {
           highlighted += value.split(NEWLINE).map((str2) => colorize(str2)).join("\n");
@@ -11463,17 +10950,17 @@ var require_lib3 = __commonJS({
       if (endLine === -1) {
         end = source2.length;
       }
-      const lineDiff = endLine - startLine;
+      const lineDiff2 = endLine - startLine;
       const markerLines = {};
-      if (lineDiff) {
-        for (let i = 0; i <= lineDiff; i++) {
+      if (lineDiff2) {
+        for (let i = 0; i <= lineDiff2; i++) {
           const lineNumber = i + startLine;
           if (!startColumn) {
             markerLines[lineNumber] = true;
           } else if (i === 0) {
             const sourceLength = source2[lineNumber - 1].length;
             markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
-          } else if (i === lineDiff) {
+          } else if (i === lineDiff2) {
             markerLines[lineNumber] = [0, endColumn];
           } else {
             const sourceLength = source2[lineNumber - i].length;
@@ -12069,38 +11556,6 @@ var require_readlines = __commonJS({
   }
 });
 
-// node_modules/diff/lib/diff/array.js
-var require_array2 = __commonJS({
-  "node_modules/diff/lib/diff/array.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.diffArrays = diffArrays2;
-    exports.arrayDiff = void 0;
-    var _base = _interopRequireDefault(require_base());
-    function _interopRequireDefault(obj) {
-      return obj && obj.__esModule ? obj : { "default": obj };
-    }
-    var arrayDiff = new /*istanbul ignore start*/
-    _base[
-      /*istanbul ignore start*/
-      "default"
-      /*istanbul ignore end*/
-    ]();
-    exports.arrayDiff = arrayDiff;
-    arrayDiff.tokenize = function(value) {
-      return value.slice();
-    };
-    arrayDiff.join = arrayDiff.removeEmpty = function(value) {
-      return value;
-    };
-    function diffArrays2(oldArr, newArr, callback) {
-      return arrayDiff.diff(oldArr, newArr, callback);
-    }
-  }
-});
-
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
@@ -12118,7 +11573,510 @@ __export(src_exports, {
   util: () => public_exports,
   version: () => version_evaluate_default
 });
-var import_create = __toESM(require_create(), 1);
+
+// node_modules/diff/lib/index.mjs
+function Diff() {
+}
+Diff.prototype = {
+  diff: function diff(oldString, newString) {
+    var _options$timeout;
+    var options8 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var callback = options8.callback;
+    if (typeof options8 === "function") {
+      callback = options8;
+      options8 = {};
+    }
+    this.options = options8;
+    var self = this;
+    function done(value) {
+      if (callback) {
+        setTimeout(function() {
+          callback(void 0, value);
+        }, 0);
+        return true;
+      } else {
+        return value;
+      }
+    }
+    oldString = this.castInput(oldString);
+    newString = this.castInput(newString);
+    oldString = this.removeEmpty(this.tokenize(oldString));
+    newString = this.removeEmpty(this.tokenize(newString));
+    var newLen = newString.length, oldLen = oldString.length;
+    var editLength = 1;
+    var maxEditLength = newLen + oldLen;
+    if (options8.maxEditLength) {
+      maxEditLength = Math.min(maxEditLength, options8.maxEditLength);
+    }
+    var maxExecutionTime = (_options$timeout = options8.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
+    var abortAfterTimestamp = Date.now() + maxExecutionTime;
+    var bestPath = [{
+      oldPos: -1,
+      lastComponent: void 0
+    }];
+    var newPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done([{
+        value: this.join(newString),
+        count: newString.length
+      }]);
+    }
+    var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    function execEditLength() {
+      for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        var basePath = void 0;
+        var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        var canAdd = false;
+        if (addPath) {
+          var addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        var canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) {
+          basePath = self.addToPath(addPath, true, void 0, 0);
+        } else {
+          basePath = self.addToPath(removePath, void 0, true, 1);
+        }
+        newPos = self.extractCommon(basePath, newString, oldString, diagonalPath);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    }
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback();
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        var ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  },
+  addToPath: function addToPath(path13, added, removed, oldPosInc) {
+    var last = path13.lastComponent;
+    if (last && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path13.oldPos + oldPosInc,
+        lastComponent: {
+          count: last.count + 1,
+          added,
+          removed,
+          previousComponent: last.previousComponent
+        }
+      };
+    } else {
+      return {
+        oldPos: path13.oldPos + oldPosInc,
+        lastComponent: {
+          count: 1,
+          added,
+          removed,
+          previousComponent: last
+        }
+      };
+    }
+  },
+  extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
+    var newLen = newString.length, oldLen = oldString.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+    }
+    if (commonCount) {
+      basePath.lastComponent = {
+        count: commonCount,
+        previousComponent: basePath.lastComponent
+      };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  },
+  equals: function equals(left, right) {
+    if (this.options.comparator) {
+      return this.options.comparator(left, right);
+    } else {
+      return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  },
+  removeEmpty: function removeEmpty(array2) {
+    var ret = [];
+    for (var i = 0; i < array2.length; i++) {
+      if (array2[i]) {
+        ret.push(array2[i]);
+      }
+    }
+    return ret;
+  },
+  castInput: function castInput(value) {
+    return value;
+  },
+  tokenize: function tokenize(value) {
+    return value.split("");
+  },
+  join: function join(chars) {
+    return chars.join("");
+  }
+};
+function buildValues(diff2, lastComponent, newString, oldString, useLongestToken) {
+  var components = [];
+  var nextComponent;
+  while (lastComponent) {
+    components.push(lastComponent);
+    nextComponent = lastComponent.previousComponent;
+    delete lastComponent.previousComponent;
+    lastComponent = nextComponent;
+  }
+  components.reverse();
+  var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
+  for (; componentPos < componentLen; componentPos++) {
+    var component = components[componentPos];
+    if (!component.removed) {
+      if (!component.added && useLongestToken) {
+        var value = newString.slice(newPos, newPos + component.count);
+        value = value.map(function(value2, i) {
+          var oldValue = oldString[oldPos + i];
+          return oldValue.length > value2.length ? oldValue : value2;
+        });
+        component.value = diff2.join(value);
+      } else {
+        component.value = diff2.join(newString.slice(newPos, newPos + component.count));
+      }
+      newPos += component.count;
+      if (!component.added) {
+        oldPos += component.count;
+      }
+    } else {
+      component.value = diff2.join(oldString.slice(oldPos, oldPos + component.count));
+      oldPos += component.count;
+      if (componentPos && components[componentPos - 1].added) {
+        var tmp = components[componentPos - 1];
+        components[componentPos - 1] = components[componentPos];
+        components[componentPos] = tmp;
+      }
+    }
+  }
+  var finalComponent = components[componentLen - 1];
+  if (componentLen > 1 && typeof finalComponent.value === "string" && (finalComponent.added || finalComponent.removed) && diff2.equals("", finalComponent.value)) {
+    components[componentLen - 2].value += finalComponent.value;
+    components.pop();
+  }
+  return components;
+}
+var characterDiff = new Diff();
+var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
+var reWhitespace = /\S/;
+var wordDiff = new Diff();
+wordDiff.equals = function(left, right) {
+  if (this.options.ignoreCase) {
+    left = left.toLowerCase();
+    right = right.toLowerCase();
+  }
+  return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
+};
+wordDiff.tokenize = function(value) {
+  var tokens = value.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/);
+  for (var i = 0; i < tokens.length - 1; i++) {
+    if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
+      tokens[i] += tokens[i + 2];
+      tokens.splice(i + 1, 2);
+      i--;
+    }
+  }
+  return tokens;
+};
+var lineDiff = new Diff();
+lineDiff.tokenize = function(value) {
+  if (this.options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (var i = 0; i < linesAndNewlines.length; i++) {
+    var line3 = linesAndNewlines[i];
+    if (i % 2 && !this.options.newlineIsToken) {
+      retLines[retLines.length - 1] += line3;
+    } else {
+      if (this.options.ignoreWhitespace) {
+        line3 = line3.trim();
+      }
+      retLines.push(line3);
+    }
+  }
+  return retLines;
+};
+function diffLines(oldStr, newStr, callback) {
+  return lineDiff.diff(oldStr, newStr, callback);
+}
+var sentenceDiff = new Diff();
+sentenceDiff.tokenize = function(value) {
+  return value.split(/(\S.+?[.!?])(?=\s+|$)/);
+};
+var cssDiff = new Diff();
+cssDiff.tokenize = function(value) {
+  return value.split(/([{}:;,]|\s+)/);
+};
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+var objectPrototypeToString = Object.prototype.toString;
+var jsonDiff = new Diff();
+jsonDiff.useLongestToken = true;
+jsonDiff.tokenize = lineDiff.tokenize;
+jsonDiff.castInput = function(value) {
+  var _this$options = this.options, undefinedReplacement = _this$options.undefinedReplacement, _this$options$stringi = _this$options.stringifyReplacer, stringifyReplacer = _this$options$stringi === void 0 ? function(k, v) {
+    return typeof v === "undefined" ? undefinedReplacement : v;
+  } : _this$options$stringi;
+  return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, "  ");
+};
+jsonDiff.equals = function(left, right) {
+  return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"));
+};
+function canonicalize(obj, stack2, replacementStack, replacer, key2) {
+  stack2 = stack2 || [];
+  replacementStack = replacementStack || [];
+  if (replacer) {
+    obj = replacer(key2, obj);
+  }
+  var i;
+  for (i = 0; i < stack2.length; i += 1) {
+    if (stack2[i] === obj) {
+      return replacementStack[i];
+    }
+  }
+  var canonicalizedObj;
+  if ("[object Array]" === objectPrototypeToString.call(obj)) {
+    stack2.push(obj);
+    canonicalizedObj = new Array(obj.length);
+    replacementStack.push(canonicalizedObj);
+    for (i = 0; i < obj.length; i += 1) {
+      canonicalizedObj[i] = canonicalize(obj[i], stack2, replacementStack, replacer, key2);
+    }
+    stack2.pop();
+    replacementStack.pop();
+    return canonicalizedObj;
+  }
+  if (obj && obj.toJSON) {
+    obj = obj.toJSON();
+  }
+  if (_typeof(obj) === "object" && obj !== null) {
+    stack2.push(obj);
+    canonicalizedObj = {};
+    replacementStack.push(canonicalizedObj);
+    var sortedKeys = [], _key;
+    for (_key in obj) {
+      if (obj.hasOwnProperty(_key)) {
+        sortedKeys.push(_key);
+      }
+    }
+    sortedKeys.sort();
+    for (i = 0; i < sortedKeys.length; i += 1) {
+      _key = sortedKeys[i];
+      canonicalizedObj[_key] = canonicalize(obj[_key], stack2, replacementStack, replacer, _key);
+    }
+    stack2.pop();
+    replacementStack.pop();
+  } else {
+    canonicalizedObj = obj;
+  }
+  return canonicalizedObj;
+}
+var arrayDiff = new Diff();
+arrayDiff.tokenize = function(value) {
+  return value.slice();
+};
+arrayDiff.join = arrayDiff.removeEmpty = function(value) {
+  return value;
+};
+function diffArrays(oldArr, newArr, callback) {
+  return arrayDiff.diff(oldArr, newArr, callback);
+}
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options8) {
+  if (!options8) {
+    options8 = {};
+  }
+  if (typeof options8.context === "undefined") {
+    options8.context = 4;
+  }
+  var diff2 = diffLines(oldStr, newStr, options8);
+  if (!diff2) {
+    return;
+  }
+  diff2.push({
+    value: "",
+    lines: []
+  });
+  function contextLines(lines) {
+    return lines.map(function(entry) {
+      return " " + entry;
+    });
+  }
+  var hunks = [];
+  var oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+  var _loop = function _loop2(i2) {
+    var current = diff2[i2], lines = current.lines || current.value.replace(/\n$/, "").split("\n");
+    current.lines = lines;
+    if (current.added || current.removed) {
+      var _curRange;
+      if (!oldRangeStart) {
+        var prev = diff2[i2 - 1];
+        oldRangeStart = oldLine;
+        newRangeStart = newLine;
+        if (prev) {
+          curRange = options8.context > 0 ? contextLines(prev.lines.slice(-options8.context)) : [];
+          oldRangeStart -= curRange.length;
+          newRangeStart -= curRange.length;
+        }
+      }
+      (_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function(entry) {
+        return (current.added ? "+" : "-") + entry;
+      })));
+      if (current.added) {
+        newLine += lines.length;
+      } else {
+        oldLine += lines.length;
+      }
+    } else {
+      if (oldRangeStart) {
+        if (lines.length <= options8.context * 2 && i2 < diff2.length - 2) {
+          var _curRange2;
+          (_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines)));
+        } else {
+          var _curRange3;
+          var contextSize = Math.min(lines.length, options8.context);
+          (_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize))));
+          var hunk = {
+            oldStart: oldRangeStart,
+            oldLines: oldLine - oldRangeStart + contextSize,
+            newStart: newRangeStart,
+            newLines: newLine - newRangeStart + contextSize,
+            lines: curRange
+          };
+          if (i2 >= diff2.length - 2 && lines.length <= options8.context) {
+            var oldEOFNewline = /\n$/.test(oldStr);
+            var newEOFNewline = /\n$/.test(newStr);
+            var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;
+            if (!oldEOFNewline && noNlBeforeAdds && oldStr.length > 0) {
+              curRange.splice(hunk.oldLines, 0, "\");
+            }
+            if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) {
+              curRange.push("\");
+            }
+          }
+          hunks.push(hunk);
+          oldRangeStart = 0;
+          newRangeStart = 0;
+          curRange = [];
+        }
+      }
+      oldLine += lines.length;
+      newLine += lines.length;
+    }
+  };
+  for (var i = 0; i < diff2.length; i++) {
+    _loop(i);
+  }
+  return {
+    oldFileName,
+    newFileName,
+    oldHeader,
+    newHeader,
+    hunks
+  };
+}
+function formatPatch(diff2) {
+  if (Array.isArray(diff2)) {
+    return diff2.map(formatPatch).join("\n");
+  }
+  var ret = [];
+  if (diff2.oldFileName == diff2.newFileName) {
+    ret.push("Index: " + diff2.oldFileName);
+  }
+  ret.push("===================================================================");
+  ret.push("--- " + diff2.oldFileName + (typeof diff2.oldHeader === "undefined" ? "" : "	" + diff2.oldHeader));
+  ret.push("+++ " + diff2.newFileName + (typeof diff2.newHeader === "undefined" ? "" : "	" + diff2.newHeader));
+  for (var i = 0; i < diff2.hunks.length; i++) {
+    var hunk = diff2.hunks[i];
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
+    }
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    ret.push.apply(ret, hunk.lines);
+  }
+  return ret.join("\n") + "\n";
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options8) {
+  return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options8));
+}
+
+// src/index.js
 var import_fast_glob = __toESM(require_out4(), 1);
 
 // node_modules/vnopts/lib/descriptors/api.js
@@ -17823,11 +17781,11 @@ function getInterpreter(file) {
   try {
     const liner = new import_n_readlines.default(fd);
     const firstLine = liner.next().toString("utf8");
-    const m1 = firstLine.match(/^#!\/(?:usr\/)?bin\/env\s+(\S+)/);
+    const m1 = firstLine.match(/^#!\/(?:usr\/)?bin\/env\s+(\S+)/u);
     if (m1) {
       return m1[1];
     }
-    const m2 = firstLine.match(/^#!\/(?:usr\/(?:local\/)?)?bin\/(\S+)/);
+    const m2 = firstLine.match(/^#!\/(?:usr\/(?:local\/)?)?bin\/(\S+)/u);
     if (m2) {
       return m2[1];
     }
@@ -17841,7 +17799,7 @@ function getInterpreter(file) {
 var get_interpreter_default = getInterpreter;
 
 // src/utils/infer-parser.js
-var getFileBasename = (file) => String(file).split(/[/\\]/).pop();
+var getFileBasename = (file) => String(file).split(/[/\\]/u).pop();
 function getLanguageByFileName(languages2, file) {
   if (!file) {
     return;
@@ -17913,9 +17871,6 @@ async function getParser(file, options8) {
 }
 var get_file_info_default = getFileInfo;
 
-// src/main/core.js
-var import_array = __toESM(require_array2(), 1);
-
 // src/common/end-of-line.js
 function guessEndOfLine(text) {
   const index = text.indexOf("\r");
@@ -17938,13 +17893,13 @@ function countEndOfLineChars(text, eol) {
   let regex;
   switch (eol) {
     case "\n":
-      regex = /\n/g;
+      regex = /\n/gu;
       break;
     case "\r":
-      regex = /\r/g;
+      regex = /\r/gu;
       break;
     case "\r\n":
-      regex = /\r\n/g;
+      regex = /\r\n/gu;
       break;
     default:
       throw new Error(`Unexpected "eol" ${JSON.stringify(eol)}.`);
@@ -17957,7 +17912,7 @@ function normalizeEndOfLine(text) {
     /* isOptionalObject */
     false,
     text,
-    /\r\n?/g,
+    /\r\n?/gu,
     "\n"
   );
 }
@@ -18334,7 +18289,7 @@ function isWide(x) {
 var _isNarrowWidth = (codePoint) => !(isFullWidth(codePoint) || isWide(codePoint));
 
 // src/utils/get-string-width.js
-var notAsciiRegex = /[^\x20-\x7F]/;
+var notAsciiRegex = /[^\x20-\x7F]/u;
 function getStringWidth(text) {
   if (!text) {
     return 0;
@@ -18524,7 +18479,7 @@ function stripTrailingHardlineFromDoc(doc2) {
     case DOC_TYPE_ARRAY:
       return stripTrailingHardlineFromParts(doc2);
     case DOC_TYPE_STRING:
-      return doc2.replace(/[\n\r]*$/, "");
+      return doc2.replace(/[\n\r]*$/u, "");
     case DOC_TYPE_ALIGN:
     case DOC_TYPE_CURSOR:
     case DOC_TYPE_TRIM:
@@ -19363,6 +19318,12 @@ var AstPath = class {
       stack2.length = length;
     }
   }
+  /**
+   * @template {(path: AstPath) => any} T
+   * @param {T} callback
+   * @param {number} [count=0]
+   * @returns {ReturnType<T>}
+   */
   callParent(callback, count = 0) {
     const stackIndex = __privateMethod(this, _AstPath_instances, getNodeStackIndex_fn).call(this, count + 1);
     const parentValues = this.stack.splice(stackIndex + 1);
@@ -19560,10 +19521,10 @@ function skip(characters) {
     return false;
   };
 }
-var skipWhitespace = skip(/\s/);
+var skipWhitespace = skip(/\s/u);
 var skipSpaces = skip(" 	");
 var skipToLineEnd = skip(",; 	");
-var skipEverythingButNewLine = skip(/[^\n\r]/);
+var skipEverythingButNewLine = skip(/[^\n\r]/u);
 
 // src/utils/skip-newline.js
 function skipNewline(text, startIndex, options8) {
@@ -19855,7 +19816,7 @@ function attachComments(ast, options8) {
     }
   }
 }
-var isAllEmptyAndNoLineBreak = (text) => !/[\S\n\u2028\u2029]/.test(text);
+var isAllEmptyAndNoLineBreak = (text) => !/[\S\n\u2028\u2029]/u.test(text);
 function isOwnLineComment(text, options8, decoratedComments, commentIndex) {
   const { comment, precedingNode } = decoratedComments[commentIndex];
   const { locStart, locEnd } = options8;
@@ -19904,7 +19865,7 @@ function breakTies(tiesToBreak, options8) {
     assert4.strictEqual(currentCommentPrecedingNode, precedingNode);
     assert4.strictEqual(currentCommentFollowingNode, followingNode);
     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)) {
+    if (((_b = (_a = options8.printer).isGap) == null ? void 0 : _b.call(_a, gap, options8)) ?? /^[\s(]*$/u.test(gap)) {
       gapEndPos = options8.locStart(comment);
     } else {
       break;
@@ -20990,35 +20951,50 @@ function massageAst(ast, options8) {
 }
 var massage_ast_default = massageAst;
 
+// scripts/build/shims/array-find-last-index.js
+var arrayFindLastIndex = (isOptionalObject, array2, callback) => {
+  if (isOptionalObject && (array2 === void 0 || array2 === null)) {
+    return;
+  }
+  if (array2.findLastIndex) {
+    return array2.findLastIndex(callback);
+  }
+  for (let index = array2.length - 1; index >= 0; index--) {
+    const element = array2[index];
+    if (callback(element, index, array2)) {
+      return index;
+    }
+  }
+  return -1;
+};
+var array_find_last_index_default = arrayFindLastIndex;
+
 // src/main/range-util.js
 import assert5 from "assert";
-var isJsonParser = ({ parser }) => parser === "json" || parser === "json5" || parser === "jsonc" || parser === "json-stringify";
+var isJsonParser = ({
+  parser
+}) => parser === "json" || parser === "json5" || parser === "jsonc" || parser === "json-stringify";
 function findCommonAncestor(startNodeAndParents, endNodeAndParents) {
-  const startNodeAndAncestors = [
-    startNodeAndParents.node,
-    ...startNodeAndParents.parentNodes
-  ];
-  const endNodeAndAncestors = /* @__PURE__ */ new Set([
-    endNodeAndParents.node,
-    ...endNodeAndParents.parentNodes
-  ]);
-  return startNodeAndAncestors.find(
-    (node) => jsonSourceElements.has(node.type) && endNodeAndAncestors.has(node)
-  );
+  const startNodeAndAncestors = [startNodeAndParents.node, ...startNodeAndParents.parentNodes];
+  const endNodeAndAncestors = /* @__PURE__ */ new Set([endNodeAndParents.node, ...endNodeAndParents.parentNodes]);
+  return startNodeAndAncestors.find((node) => jsonSourceElements.has(node.type) && endNodeAndAncestors.has(node));
 }
 function dropRootParents(parents) {
-  let lastParentIndex = parents.length - 1;
-  while (true) {
-    const parent = parents[lastParentIndex];
-    if ((parent == null ? void 0 : parent.type) === "Program" || (parent == null ? void 0 : parent.type) === "File") {
-      lastParentIndex--;
-    } else {
-      break;
-    }
+  const index = array_find_last_index_default(
+    /* isOptionalObject */
+    false,
+    parents,
+    (node) => node.type !== "Program" && node.type !== "File"
+  );
+  if (index === -1) {
+    return parents;
   }
-  return parents.slice(0, lastParentIndex + 1);
+  return parents.slice(0, index + 1);
 }
-function findSiblingAncestors(startNodeAndParents, endNodeAndParents, { locStart, locEnd }) {
+function findSiblingAncestors(startNodeAndParents, endNodeAndParents, {
+  locStart,
+  locEnd
+}) {
   let resultStartNode = startNodeAndParents.node;
   let resultEndNode = endNodeAndParents.node;
   if (resultStartNode === resultEndNode) {
@@ -21052,21 +21028,17 @@ function findSiblingAncestors(startNodeAndParents, endNodeAndParents, { locStart
   };
 }
 function findNodeAtOffset(node, offset, options8, predicate, parentNodes = [], type2) {
-  const { locStart, locEnd } = options8;
+  const {
+    locStart,
+    locEnd
+  } = options8;
   const start = locStart(node);
   const end = locEnd(node);
   if (offset > end || offset < start || type2 === "rangeEnd" && offset === start || type2 === "rangeStart" && offset === end) {
     return;
   }
   for (const childNode of getSortedChildNodes(node, options8)) {
-    const childResult = findNodeAtOffset(
-      childNode,
-      offset,
-      options8,
-      predicate,
-      [node, ...parentNodes],
-      type2
-    );
+    const childResult = findNodeAtOffset(childNode, offset, options8, predicate, [node, ...parentNodes], type2);
     if (childResult) {
       return childResult;
     }
@@ -21081,35 +21053,8 @@ function findNodeAtOffset(node, offset, options8, predicate, parentNodes = [], t
 function isJsSourceElement(type2, parentType) {
   return parentType !== "DeclareExportDeclaration" && type2 !== "TypeParameterDeclaration" && (type2 === "Directive" || type2 === "TypeAlias" || type2 === "TSExportAssignment" || type2.startsWith("Declare") || type2.startsWith("TSDeclare") || type2.endsWith("Statement") || type2.endsWith("Declaration"));
 }
-var jsonSourceElements = /* @__PURE__ */ new Set([
-  "JsonRoot",
-  "ObjectExpression",
-  "ArrayExpression",
-  "StringLiteral",
-  "NumericLiteral",
-  "BooleanLiteral",
-  "NullLiteral",
-  "UnaryExpression",
-  "TemplateLiteral"
-]);
-var graphqlSourceElements = /* @__PURE__ */ new Set([
-  "OperationDefinition",
-  "FragmentDefinition",
-  "VariableDefinition",
-  "TypeExtensionDefinition",
-  "ObjectTypeDefinition",
-  "FieldDefinition",
-  "DirectiveDefinition",
-  "EnumTypeDefinition",
-  "EnumValueDefinition",
-  "InputValueDefinition",
-  "InputObjectTypeDefinition",
-  "SchemaDefinition",
-  "OperationTypeDefinition",
-  "InterfaceTypeDefinition",
-  "UnionTypeDefinition",
-  "ScalarTypeDefinition"
-]);
+var jsonSourceElements = /* @__PURE__ */ new Set(["JsonRoot", "ObjectExpression", "ArrayExpression", "StringLiteral", "NumericLiteral", "BooleanLiteral", "NullLiteral", "UnaryExpression", "TemplateLiteral"]);
+var graphqlSourceElements = /* @__PURE__ */ new Set(["OperationDefinition", "FragmentDefinition", "VariableDefinition", "TypeExtensionDefinition", "ObjectTypeDefinition", "FieldDefinition", "DirectiveDefinition", "EnumTypeDefinition", "EnumValueDefinition", "InputValueDefinition", "InputObjectTypeDefinition", "SchemaDefinition", "OperationTypeDefinition", "InterfaceTypeDefinition", "UnionTypeDefinition", "ScalarTypeDefinition"]);
 function isSourceElement(opts, node, parentNode) {
   if (!node) {
     return false;
@@ -21138,36 +21083,27 @@ function isSourceElement(opts, node, parentNode) {
   return false;
 }
 function calculateRange(text, opts, ast) {
-  let { rangeStart: start, rangeEnd: end, locStart, locEnd } = opts;
+  let {
+    rangeStart: start,
+    rangeEnd: end,
+    locStart,
+    locEnd
+  } = opts;
   assert5.ok(end > start);
-  const firstNonWhitespaceCharacterIndex = text.slice(start, end).search(/\S/);
+  const firstNonWhitespaceCharacterIndex = text.slice(start, end).search(/\S/u);
   const isAllWhitespace = firstNonWhitespaceCharacterIndex === -1;
   if (!isAllWhitespace) {
     start += firstNonWhitespaceCharacterIndex;
     for (; end > start; --end) {
-      if (/\S/.test(text[end - 1])) {
+      if (/\S/u.test(text[end - 1])) {
         break;
       }
     }
   }
-  const startNodeAndParents = findNodeAtOffset(
-    ast,
-    start,
-    opts,
-    (node, parentNode) => isSourceElement(opts, node, parentNode),
-    [],
-    "rangeStart"
-  );
+  const startNodeAndParents = findNodeAtOffset(ast, start, opts, (node, parentNode) => isSourceElement(opts, node, parentNode), [], "rangeStart");
   const endNodeAndParents = (
     // No need find Node at `end`, it will be the same as `startNodeAndParents`
-    isAllWhitespace ? startNodeAndParents : findNodeAtOffset(
-      ast,
-      end,
-      opts,
-      (node) => isSourceElement(opts, node),
-      [],
-      "rangeEnd"
-    )
+    isAllWhitespace ? startNodeAndParents : findNodeAtOffset(ast, end, opts, (node) => isSourceElement(opts, node), [], "rangeEnd")
   );
   if (!startNodeAndParents || !endNodeAndParents) {
     return {
@@ -21178,18 +21114,14 @@ function calculateRange(text, opts, ast) {
   let startNode;
   let endNode;
   if (isJsonParser(opts)) {
-    const commonAncestor = findCommonAncestor(
-      startNodeAndParents,
-      endNodeAndParents
-    );
+    const commonAncestor = findCommonAncestor(startNodeAndParents, endNodeAndParents);
     startNode = commonAncestor;
     endNode = commonAncestor;
   } else {
-    ({ startNode, endNode } = findSiblingAncestors(
-      startNodeAndParents,
-      endNodeAndParents,
-      opts
-    ));
+    ({
+      startNode,
+      endNode
+    } = findSiblingAncestors(startNodeAndParents, endNodeAndParents, opts));
   }
   return {
     rangeStart: Math.min(locStart(startNode), locStart(endNode)),
@@ -21257,7 +21189,7 @@ async function coreFormat(originalText, opts, addAlignmentSize = 0) {
     const oldCursorNodeCharArray = oldCursorNodeText.split("");
     oldCursorNodeCharArray.splice(cursorOffsetRelativeToOldCursorNode, 0, CURSOR);
     const newCursorNodeCharArray = newCursorNodeText.split("");
-    const cursorNodeDiff = (0, import_array.diffArrays)(oldCursorNodeCharArray, newCursorNodeCharArray);
+    const cursorNodeDiff = diffArrays(oldCursorNodeCharArray, newCursorNodeCharArray);
     let cursorOffset = newCursorNodeStart;
     for (const entry of cursorNodeDiff) {
       if (entry.removed) {
@@ -21291,7 +21223,7 @@ async function formatRange(originalText, opts) {
   } = calculateRange(text, opts, ast);
   const rangeString = text.slice(rangeStart, rangeEnd);
   const rangeStart2 = Math.min(rangeStart, text.lastIndexOf("\n", rangeStart) + 1);
-  const indentString = text.slice(rangeStart2, rangeStart).match(/^\s*/)[0];
+  const indentString = text.slice(rangeStart2, rangeStart).match(/^\s*/u)[0];
   const alignmentSize = get_alignment_size_default(indentString, opts.tabWidth);
   const rangeResult = await coreFormat(rangeString, {
     ...opts,
@@ -22563,7 +22495,7 @@ var object_omit_default = omit;
 import * as doc from "./doc.mjs";
 
 // src/main/version.evaluate.cjs
-var version_evaluate_default = "3.3.2";
+var version_evaluate_default = "3.3.3";
 
 // src/utils/public.js
 var public_exports = {};
@@ -22661,7 +22593,7 @@ function getIndentSize(value, tabWidth) {
   }
   return get_alignment_size_default(
     // All the leading whitespaces
-    value.slice(lastNewlineIndex + 1).match(/^[\t ]*/)[0],
+    value.slice(lastNewlineIndex + 1).match(/^[\t ]*/u)[0],
     tabWidth
   );
 }
@@ -22678,7 +22610,7 @@ function escapeStringRegexp(string) {
 // src/utils/get-max-continuous-count.js
 function getMaxContinuousCount(text, searchString) {
   const results = text.match(
-    new RegExp(`(${escapeStringRegexp(searchString)})+`, "g")
+    new RegExp(`(${escapeStringRegexp(searchString)})+`, "gu")
   );
   if (results === null) {
     return 0;
@@ -22722,7 +22654,7 @@ var has_spaces_default = hasSpaces;
 // src/utils/make-string.js
 function makeString(rawText, enclosingQuote, unescapeUnnecessaryEscapes) {
   const otherQuote = enclosingQuote === '"' ? "'" : '"';
-  const regex = /\\(.)|(["'])/gs;
+  const regex = /\\(.)|(["'])/gsu;
   const raw = string_replace_all_default(
     /* isOptionalObject */
     false,
@@ -22738,7 +22670,7 @@ function makeString(rawText, enclosingQuote, unescapeUnnecessaryEscapes) {
       if (quote) {
         return quote;
       }
-      return unescapeUnnecessaryEscapes && /^[^\n\r"'0-7\\bfnrt-vx\u2028\u2029]$/.test(escaped) ? escaped : "\\" + escaped;
+      return unescapeUnnecessaryEscapes && /^[^\n\r"'0-7\\bfnrt-vx\u2028\u2029]$/u.test(escaped) ? escaped : "\\" + escaped;
     }
   );
   return enclosingQuote + raw + enclosingQuote;
@@ -22826,7 +22758,7 @@ var sharedWithCli = {
     apiDescriptor
   },
   fastGlob: import_fast_glob.default,
-  createTwoFilesPatch: import_create.createTwoFilesPatch,
+  createTwoFilesPatch,
   utils: {
     isNonEmptyArray: is_non_empty_array_default,
     partition: partition_default,