@storm-software/linting-tools 1.47.0 → 1.47.2

package/src/manypkg/index.js

@@ -2630,7 +2630,7 @@ var require_ansi_styles = __commonJS({
       });
     };
     var colorConvert;
-    var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+    var makeDynamicStyles = (wrap, targetSpace, identity2, isBackground) => {
       if (colorConvert === void 0) {
         colorConvert = require_color_convert();
       }
@@ -2639,7 +2639,7 @@ var require_ansi_styles = __commonJS({
       for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
         const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
         if (sourceSpace === targetSpace) {
-          styles[name] = wrap(identity, offset);
+          styles[name] = wrap(identity2, offset);
         } else if (typeof suite === "object") {
           styles[name] = wrap(suite[targetSpace], offset);
         }
@@ -2927,14 +2927,14 @@ var require_templates = __commonJS({
       const results = [];
       const chunks = arguments_.trim().split(/\s*,\s*/g);
       let matches;
-      for (const chunk of chunks) {
-        const number = Number(chunk);
+      for (const chunk2 of chunks) {
+        const number = Number(chunk2);
         if (!Number.isNaN(number)) {
           results.push(number);
-        } else if (matches = chunk.match(STRING_REGEX)) {
+        } else if (matches = chunk2.match(STRING_REGEX)) {
           results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
         } else {
-          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+          throw new Error(`Invalid Chalk template style argument: ${chunk2} (in style '${name}')`);
         }
       }
       return results;
@@ -2976,27 +2976,27 @@ var require_templates = __commonJS({
     module.exports = (chalk3, temporary) => {
       const styles = [];
       const chunks = [];
-      let chunk = [];
+      let chunk2 = [];
       temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
         if (escapeCharacter) {
-          chunk.push(unescape(escapeCharacter));
+          chunk2.push(unescape(escapeCharacter));
         } else if (style) {
-          const string = chunk.join("");
-          chunk = [];
+          const string = chunk2.join("");
+          chunk2 = [];
           chunks.push(styles.length === 0 ? string : buildStyle(chalk3, styles)(string));
           styles.push({ inverse, styles: parseStyle(style) });
         } else if (close) {
           if (styles.length === 0) {
             throw new Error("Found extraneous } in Chalk template literal");
           }
-          chunks.push(buildStyle(chalk3, styles)(chunk.join("")));
-          chunk = [];
+          chunks.push(buildStyle(chalk3, styles)(chunk2.join("")));
+          chunk2 = [];
           styles.pop();
         } else {
-          chunk.push(character);
+          chunk2.push(character);
         }
       });
-      chunks.push(chunk.join(""));
+      chunks.push(chunk2.join(""));
       if (styles.length > 0) {
         const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
         throw new Error(errMessage);
@@ -3016,7 +3016,7 @@ var require_source = __commonJS({
       stringReplaceAll,
       stringEncaseCRLFWithFirstIndex
     } = require_util();
-    var { isArray } = Array;
+    var { isArray: isArray2 } = Array;
     var levelMapping = [
       "ansi",
       "ansi",
@@ -3124,7 +3124,7 @@ var require_source = __commonJS({
     };
     var createBuilder = (self, _styler, _isEmpty) => {
       const builder = (...arguments_) => {
-        if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+        if (isArray2(arguments_[0]) && isArray2(arguments_[0].raw)) {
           return applyStyle(builder, chalkTag(builder, ...arguments_));
         }
         return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
@@ -3159,7 +3159,7 @@ var require_source = __commonJS({
     var template;
     var chalkTag = (chalk4, ...strings) => {
       const [firstString] = strings;
-      if (!isArray(firstString) || !isArray(firstString.raw)) {
+      if (!isArray2(firstString) || !isArray2(firstString.raw)) {
         return strings.join(" ");
       }
       const arguments_ = strings.slice(1);
@@ -4094,7 +4094,7 @@ var require_graceful_fs = __commonJS({
       gracefulQueue = "___graceful-fs.queue";
       previousSymbol = "___graceful-fs.previous";
     }
-    function noop3() {
+    function noop4() {
     }
     function publishQueue(context, queue2) {
       Object.defineProperty(context, gracefulQueue, {
@@ -4103,7 +4103,7 @@ var require_graceful_fs = __commonJS({
         }
       });
     }
-    var debug = noop3;
+    var debug = noop4;
     if (util2.debuglog)
       debug = util2.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
@@ -6998,15 +6998,15 @@ var require_to_regex_range = __commonJS({
      * Copyright (c) 2015-present, Jon Schlinkert.
      * Released under the MIT License.
      */
-    var isNumber = require_is_number();
+    var isNumber2 = require_is_number();
     var toRegexRange = (min, max, options) => {
-      if (isNumber(min) === false) {
+      if (isNumber2(min) === false) {
         throw new TypeError("toRegexRange: expected the first argument to be a number");
       }
       if (max === void 0 || min === max) {
         return String(min);
       }
-      if (isNumber(max) === false) {
+      if (isNumber2(max) === false) {
         throw new TypeError("toRegexRange: expected the second argument to be a number.");
       }
       let opts = { relaxZeros: true, ...options };
@@ -7218,14 +7218,14 @@ var require_fill_range = __commonJS({
      */
     var util2 = __require("util");
     var toRegexRange = require_to_regex_range();
-    var isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+    var isObject2 = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
     var transform = (toNumber) => {
       return (value) => toNumber === true ? Number(value) : String(value);
     };
     var isValidValue = (value) => {
       return typeof value === "number" || typeof value === "string" && value !== "";
     };
-    var isNumber = (num) => Number.isInteger(+num);
+    var isNumber2 = (num) => Number.isInteger(+num);
     var zeros = (input) => {
       let value = `${input}`;
       let index = -1;
@@ -7363,7 +7363,7 @@ var require_fill_range = __commonJS({
       return range;
     };
     var fillLetters = (start, end, step = 1, options = {}) => {
-      if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) {
+      if (!isNumber2(start) && start.length > 1 || !isNumber2(end) && end.length > 1) {
         return invalidRange(start, end, options);
       }
       let format2 = options.transform || ((val) => String.fromCharCode(val));
@@ -7397,19 +7397,19 @@ var require_fill_range = __commonJS({
       if (typeof step === "function") {
         return fill(start, end, 1, { transform: step });
       }
-      if (isObject(step)) {
+      if (isObject2(step)) {
         return fill(start, end, 0, step);
       }
       let opts = { ...options };
       if (opts.capture === true)
         opts.wrap = true;
       step = step || opts.step || 1;
-      if (!isNumber(step)) {
-        if (step != null && !isObject(step))
+      if (!isNumber2(step)) {
+        if (step != null && !isObject2(step))
           return invalidStep(step, opts);
         return fill(start, end, 1, step);
       }
-      if (isNumber(start) && isNumber(end)) {
+      if (isNumber2(start) && isNumber2(end)) {
         return fillNumbers(start, end, step, opts);
       }
       return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
@@ -9357,7 +9357,7 @@ var require_picomatch = __commonJS({
     var parse = require_parse2();
     var utils = require_utils2();
     var constants = require_constants2();
-    var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+    var isObject2 = (val) => val && typeof val === "object" && !Array.isArray(val);
     var picomatch = (glob, options, returnState = false) => {
       if (Array.isArray(glob)) {
         const fns = glob.map((input) => picomatch(input, options, returnState));
@@ -9371,7 +9371,7 @@ var require_picomatch = __commonJS({
         };
         return arrayMatcher;
       }
-      const isState = isObject(glob) && glob.tokens && glob.input;
+      const isState = isObject2(glob) && glob.tokens && glob.input;
       if (glob === "" || typeof glob !== "string" && !isState) {
         throw new TypeError("Expected pattern to be a non-empty string");
       }
@@ -9508,7 +9508,7 @@ var require_micromatch = __commonJS({
     var braces = require_braces();
     var picomatch = require_picomatch2();
     var utils = require_utils2();
-    var isEmptyString = (val) => val === "" || val === "./";
+    var isEmptyString2 = (val) => val === "" || val === "./";
     var micromatch = (list, patterns, options) => {
       patterns = [].concat(patterns);
       list = [].concat(list);
@@ -9581,7 +9581,7 @@ var require_micromatch = __commonJS({
         return pattern.some((p) => micromatch.contains(str, p, options));
       }
       if (typeof pattern === "string") {
-        if (isEmptyString(str) || isEmptyString(pattern)) {
+        if (isEmptyString2(str) || isEmptyString2(pattern)) {
           return false;
         }
         if (str.includes(pattern) || str.startsWith("./") && str.slice(2).includes(pattern)) {
@@ -9839,10 +9839,10 @@ var require_string = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.isEmpty = exports.isString = void 0;
-    function isString(input) {
+    function isString2(input) {
       return typeof input === "string";
     }
-    exports.isString = isString;
+    exports.isString = isString2;
     function isEmpty(input) {
       return input === "";
     }
@@ -10069,8 +10069,8 @@ var require_settings = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     var fs2 = require_fs3();
     var Settings = class {
-      constructor(_options = {}) {
-        this._options = _options;
+      constructor(_options2 = {}) {
+        this._options = _options2;
         this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
         this.fs = fs2.createFileSystemAdapter(this._options.fs);
         this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
@@ -10456,8 +10456,8 @@ var require_settings2 = __commonJS({
     var fsStat = require_out();
     var fs2 = require_fs5();
     var Settings = class {
-      constructor(_options = {}) {
-        this._options = _options;
+      constructor(_options2 = {}) {
+        this._options = _options2;
         this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
         this.fs = fs2.createFileSystemAdapter(this._options.fs);
         this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path2.sep);
@@ -10540,19 +10540,19 @@ var require_reusify = __commonJS({
   }
 });
 
-// node_modules/.pnpm/fastq@1.15.0/node_modules/fastq/queue.js
+// node_modules/.pnpm/fastq@1.17.1/node_modules/fastq/queue.js
 var require_queue = __commonJS({
-  "node_modules/.pnpm/fastq@1.15.0/node_modules/fastq/queue.js"(exports, module) {
+  "node_modules/.pnpm/fastq@1.17.1/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 cache = reusify(Task);
       var queueHead = null;
@@ -10561,18 +10561,32 @@ var require_queue = __commonJS({
       var errorHandler = null;
       var self = {
         push,
-        drain: noop3,
-        saturated: noop3,
+        drain: noop4,
+        saturated: noop4,
         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,
         length,
         getQueue,
         unshift,
-        empty: noop3,
+        empty: noop4,
         kill,
         killAndDrain,
         error: error2
@@ -10606,7 +10620,12 @@ var require_queue = __commonJS({
         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();
         }
@@ -10619,9 +10638,9 @@ var require_queue = __commonJS({
         current.context = context;
         current.release = release;
         current.value = value;
-        current.callback = done || noop3;
+        current.callback = done || noop4;
         current.errorHandler = errorHandler;
-        if (_running === self.concurrency || self.paused) {
+        if (_running >= _concurrency || self.paused) {
           if (queueTail) {
             queueTail.next = current;
             queueTail = current;
@@ -10640,8 +10659,9 @@ var require_queue = __commonJS({
         current.context = context;
         current.release = release;
         current.value = value;
-        current.callback = done || noop3;
-        if (_running === self.concurrency || self.paused) {
+        current.callback = done || noop4;
+        current.errorHandler = errorHandler;
+        if (_running >= _concurrency || self.paused) {
           if (queueHead) {
             current.next = queueHead;
             queueHead = current;
@@ -10660,7 +10680,7 @@ var require_queue = __commonJS({
           cache.release(holder);
         }
         var next = queueHead;
-        if (next) {
+        if (next && _running <= _concurrency) {
           if (!self.paused) {
             if (queueTail === queueHead) {
               queueTail = null;
@@ -10681,25 +10701,25 @@ var require_queue = __commonJS({
       function kill() {
         queueHead = null;
         queueTail = null;
-        self.drain = noop3;
+        self.drain = noop4;
       }
       function killAndDrain() {
         queueHead = null;
         queueTail = null;
         self.drain();
-        self.drain = noop3;
+        self.drain = noop4;
       }
       function error2(handler) {
         errorHandler = handler;
       }
     }
-    function noop3() {
+    function noop4() {
     }
     function Task() {
       this.value = null;
-      this.callback = noop3;
+      this.callback = noop4;
       this.next = null;
-      this.release = noop3;
+      this.release = noop4;
       this.context = null;
       this.errorHandler = null;
       var self = this;
@@ -10708,7 +10728,7 @@ var require_queue = __commonJS({
         var errorHandler = self.errorHandler;
         var val = self.value;
         self.value = null;
-        self.callback = noop3;
+        self.callback = noop4;
         if (self.errorHandler) {
           errorHandler(err, val);
         }
@@ -10716,9 +10736,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;
       }
@@ -10727,7 +10747,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 = push;
@@ -10744,7 +10764,7 @@ var require_queue = __commonJS({
             resolve(result);
           });
         });
-        p.catch(noop3);
+        p.catch(noop4);
         return p;
       }
       function unshift(value) {
@@ -10757,7 +10777,7 @@ var require_queue = __commonJS({
             resolve(result);
           });
         });
-        p.catch(noop3);
+        p.catch(noop4);
         return p;
       }
       function drained() {
@@ -11104,8 +11124,8 @@ var require_settings3 = __commonJS({
     var path2 = __require("path");
     var fsScandir = require_out2();
     var Settings = class {
-      constructor(_options = {}) {
-        this._options = _options;
+      constructor(_options2 = {}) {
+        this._options = _options2;
         this.basePath = this._getValue(this._options.basePath, void 0);
         this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
         this.deepFilter = this._getValue(this._options.deepFilter, null);
@@ -11787,8 +11807,8 @@ var require_settings4 = __commonJS({
       readdirSync: fs2.readdirSync
     };
     var Settings = class {
-      constructor(_options = {}) {
-        this._options = _options;
+      constructor(_options2 = {}) {
+        this._options = _options2;
         this.absolute = this._getValue(this._options.absolute, false);
         this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
         this.braceExpansion = this._getValue(this._options.braceExpansion, true);
@@ -12228,8 +12248,8 @@ var require_ignore = __commonJS({
       }
       return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
     };
-    var isString = (subject) => typeof subject === "string";
-    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var isString2 = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString2(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
     var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
     var IgnoreRule = class {
       constructor(origin, pattern, negative, regex) {
@@ -12259,7 +12279,7 @@ var require_ignore = __commonJS({
       throw new Ctor(message);
     };
     var checkPath = (path2, originalPath, doThrow) => {
-      if (!isString(path2)) {
+      if (!isString2(path2)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
@@ -12312,7 +12332,7 @@ var require_ignore = __commonJS({
       add(pattern) {
         this._added = false;
         makeArray(
-          isString(pattern) ? splitPattern(pattern) : pattern
+          isString2(pattern) ? splitPattern(pattern) : pattern
         ).forEach(this._addPattern, this);
         if (this._added) {
           this._initCache();
@@ -12795,7 +12815,7 @@ var require_common3 = __commonJS({
     function isNothing(subject) {
       return typeof subject === "undefined" || subject === null;
     }
-    function isObject(subject) {
+    function isObject2(subject) {
       return typeof subject === "object" && subject !== null;
     }
     function toArray(sequence) {
@@ -12827,7 +12847,7 @@ var require_common3 = __commonJS({
       return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
     }
     module.exports.isNothing = isNothing;
-    module.exports.isObject = isObject;
+    module.exports.isObject = isObject2;
     module.exports.toArray = toArray;
     module.exports.repeat = repeat;
     module.exports.isNegativeZero = isNegativeZero;
@@ -12853,7 +12873,7 @@ var require_exception = __commonJS({
     }
     YAMLException.prototype = Object.create(Error.prototype);
     YAMLException.prototype.constructor = YAMLException;
-    YAMLException.prototype.toString = function toString2(compact) {
+    YAMLException.prototype.toString = function toString(compact) {
       var result = this.name + ": ";
       result += this.reason || "(unknown reason)";
       if (!compact && this.mark) {
@@ -12906,7 +12926,7 @@ var require_mark = __commonJS({
       snippet = this.buffer.slice(start, end);
       return common.repeat(" ", indent) + head + snippet + tail + "\n" + common.repeat(" ", indent + this.position - start + head.length) + "^";
     };
-    Mark.prototype.toString = function toString2(compact) {
+    Mark.prototype.toString = function toString(compact) {
       var snippet, where = "";
       if (this.name) {
         where += 'in "' + this.name + '" ';
@@ -13142,14 +13162,14 @@ var require_null = __commonJS({
     function constructYamlNull() {
       return null;
     }
-    function isNull(object) {
+    function isNull2(object) {
       return object === null;
     }
     module.exports = new Type("tag:yaml.org,2002:null", {
       kind: "scalar",
       resolve: resolveYamlNull,
       construct: constructYamlNull,
-      predicate: isNull,
+      predicate: isNull2,
       represent: {
         canonical: function() {
           return "~";
@@ -13183,14 +13203,14 @@ var require_bool = __commonJS({
     function constructYamlBoolean(data) {
       return data === "true" || data === "True" || data === "TRUE";
     }
-    function isBoolean(object) {
+    function isBoolean2(object) {
       return Object.prototype.toString.call(object) === "[object Boolean]";
     }
     module.exports = new Type("tag:yaml.org,2002:bool", {
       kind: "scalar",
       resolve: resolveYamlBoolean,
       construct: constructYamlBoolean,
-      predicate: isBoolean,
+      predicate: isBoolean2,
       represent: {
         lowercase: function(object) {
           return object ? "true" : "false";
@@ -13324,14 +13344,14 @@ var require_int = __commonJS({
       }
       return sign * parseInt(value, 10);
     }
-    function isInteger(object) {
+    function isInteger2(object) {
       return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object));
     }
     module.exports = new Type("tag:yaml.org,2002:int", {
       kind: "scalar",
       resolve: resolveYamlInteger,
       construct: constructYamlInteger,
-      predicate: isInteger,
+      predicate: isInteger2,
       represent: {
         binary: function(obj) {
           return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
@@ -13817,14 +13837,14 @@ var require_undefined = __commonJS({
     function representJavascriptUndefined() {
       return "";
     }
-    function isUndefined(object) {
+    function isUndefined2(object) {
       return typeof object === "undefined";
     }
     module.exports = new Type("tag:yaml.org,2002:js/undefined", {
       kind: "scalar",
       resolve: resolveJavascriptUndefined,
       construct: constructJavascriptUndefined,
-      predicate: isUndefined,
+      predicate: isUndefined2,
       represent: representJavascriptUndefined
     });
   }
@@ -13870,14 +13890,14 @@ var require_regexp = __commonJS({
         result += "i";
       return result;
     }
-    function isRegExp(object) {
+    function isRegExp2(object) {
       return Object.prototype.toString.call(object) === "[object RegExp]";
     }
     module.exports = new Type("tag:yaml.org,2002:js/regexp", {
       kind: "scalar",
       resolve: resolveJavascriptRegExp,
       construct: constructJavascriptRegExp,
-      predicate: isRegExp,
+      predicate: isRegExp2,
       represent: representJavascriptRegExp
     });
   }
@@ -13927,14 +13947,14 @@ var require_function = __commonJS({
     function representJavascriptFunction(object) {
       return object.toString();
     }
-    function isFunction2(object) {
+    function isFunction3(object) {
       return Object.prototype.toString.call(object) === "[object Function]";
     }
     module.exports = new Type("tag:yaml.org,2002:js/function", {
       kind: "scalar",
       resolve: resolveJavascriptFunction,
       construct: constructJavascriptFunction,
-      predicate: isFunction2,
+      predicate: isFunction3,
       represent: representJavascriptFunction
     });
   }
@@ -16634,7 +16654,7 @@ var require_document = __commonJS({
     var tokenize = require_parse3().tokenize;
     var stringify = require_stringify2().stringify;
     var analyze = require_analyze().analyze;
-    function isObject(x) {
+    function isObject2(x) {
       return typeof x === "object" && x !== null;
     }
     function value_to_tokenlist(value, stack, options, is_key, indent) {
@@ -16783,7 +16803,7 @@ var require_document = __commonJS({
       function error2(add) {
         return Error("You can't " + (is_unset ? "unset" : "set") + " key '" + key + "'" + add);
       }
-      if (!isObject(object)) {
+      if (!isObject2(object)) {
         throw error2(" of an non-object");
       }
       if (Array.isArray(object)) {
@@ -16918,7 +16938,7 @@ var require_document = __commonJS({
       path2 = arg_to_path(path2);
       var data = this._data;
       for (var i = 0; i < path2.length; i++) {
-        if (!isObject(data))
+        if (!isObject2(data))
           return void 0;
         data = data[path2[i]];
       }
@@ -16928,7 +16948,7 @@ var require_document = __commonJS({
       path2 = arg_to_path(path2);
       var data = this._data;
       for (var i = 0; i < path2.length; i++) {
-        if (!isObject(data))
+        if (!isObject2(data))
           return false;
         data = data[path2[i]];
       }
@@ -16939,7 +16959,7 @@ var require_document = __commonJS({
       change([], self._data, value);
       return self;
       function change(path2, old_data, new_data) {
-        if (!isObject(new_data) || !isObject(old_data)) {
+        if (!isObject2(new_data) || !isObject2(old_data)) {
           if (new_data !== old_data)
             self.set(path2, new_data);
         } else if (Array.isArray(new_data) != Array.isArray(old_data)) {
@@ -20229,7 +20249,7 @@ var require_detect_indent = __commonJS({
   }
 });
 
-// node_modules/.pnpm/@sindresorhus+is@5.6.0/node_modules/@sindresorhus/is/dist/index.js
+// node_modules/.pnpm/@sindresorhus+is@6.3.0/node_modules/@sindresorhus/is/dist/index.js
 function isTypedArrayName(name) {
   return typedArrayTypeNames.includes(name);
 }
@@ -20239,10 +20259,7 @@ function isObjectTypeName(name) {
 function isPrimitiveTypeName(name) {
   return primitiveTypeNames.includes(name);
 }
-function isOfType(type) {
-  return (value) => typeof value === type;
-}
-function is(value) {
+function detect(value) {
   if (value === null) {
     return "null";
   }
@@ -20270,13 +20287,13 @@ function is(value) {
     }
     default:
   }
-  if (is.observable(value)) {
+  if (isObservable(value)) {
     return "Observable";
   }
-  if (is.array(value)) {
+  if (isArray(value)) {
     return "Array";
   }
-  if (is.buffer(value)) {
+  if (isBuffer(value)) {
     return "Buffer";
   }
   const tagType = getObjectType(value);
@@ -20288,9 +20305,807 @@ function is(value) {
   }
   return "Object";
 }
-var typedArrayTypeNames, objectTypeNames, primitiveTypeNames, toString, getObjectType, isObjectOfType, isNumberType, hasPromiseApi, isValidLength, NODE_TYPE_ELEMENT, DOM_PROPERTIES_TO_CHECK, isAbsoluteMod2, isWhiteSpaceString, predicateOnArray, assertType, assert, dist_default;
+function hasPromiseApi(value) {
+  return isFunction(value?.then) && isFunction(value?.catch);
+}
+function isAbsoluteMod2(remainder) {
+  return (value) => isInteger(value) && Math.abs(value % 2) === remainder;
+}
+function isAll(predicate, ...values) {
+  return predicateOnArray(Array.prototype.every, predicate, values);
+}
+function isAny(predicate, ...values) {
+  const predicates = isArray(predicate) ? predicate : [predicate];
+  return predicates.some((singlePredicate) => predicateOnArray(Array.prototype.some, singlePredicate, values));
+}
+function isArray(value, assertion) {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  if (!isFunction(assertion)) {
+    return true;
+  }
+  return value.every((element) => assertion(element));
+}
+function isArrayBuffer(value) {
+  return getObjectType(value) === "ArrayBuffer";
+}
+function isArrayLike(value) {
+  return !isNullOrUndefined(value) && !isFunction(value) && isValidLength(value.length);
+}
+function isAsyncFunction(value) {
+  return getObjectType(value) === "AsyncFunction";
+}
+function isAsyncGenerator(value) {
+  return isAsyncIterable(value) && isFunction(value.next) && isFunction(value.throw);
+}
+function isAsyncGeneratorFunction(value) {
+  return getObjectType(value) === "AsyncGeneratorFunction";
+}
+function isAsyncIterable(value) {
+  return isFunction(value?.[Symbol.asyncIterator]);
+}
+function isBigint(value) {
+  return typeof value === "bigint";
+}
+function isBigInt64Array(value) {
+  return getObjectType(value) === "BigInt64Array";
+}
+function isBigUint64Array(value) {
+  return getObjectType(value) === "BigUint64Array";
+}
+function isBlob(value) {
+  return getObjectType(value) === "Blob";
+}
+function isBoolean(value) {
+  return value === true || value === false;
+}
+function isBoundFunction(value) {
+  return isFunction(value) && !Object.prototype.hasOwnProperty.call(value, "prototype");
+}
+function isBuffer(value) {
+  return value?.constructor?.isBuffer?.(value) ?? false;
+}
+function isClass(value) {
+  return isFunction(value) && value.toString().startsWith("class ");
+}
+function isDataView(value) {
+  return getObjectType(value) === "DataView";
+}
+function isDate(value) {
+  return getObjectType(value) === "Date";
+}
+function isDirectInstanceOf(instance, class_) {
+  if (instance === void 0 || instance === null) {
+    return false;
+  }
+  return Object.getPrototypeOf(instance) === class_.prototype;
+}
+function isEmptyArray(value) {
+  return isArray(value) && value.length === 0;
+}
+function isEmptyMap(value) {
+  return isMap(value) && value.size === 0;
+}
+function isEmptyObject(value) {
+  return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length === 0;
+}
+function isEmptySet(value) {
+  return isSet(value) && value.size === 0;
+}
+function isEmptyString(value) {
+  return isString(value) && value.length === 0;
+}
+function isEmptyStringOrWhitespace(value) {
+  return isEmptyString(value) || isWhitespaceString(value);
+}
+function isEnumCase(value, targetEnum) {
+  return Object.values(targetEnum).includes(value);
+}
+function isError(value) {
+  return getObjectType(value) === "Error";
+}
+function isEvenInteger(value) {
+  return isAbsoluteMod2(0)(value);
+}
+function isFalsy(value) {
+  return !value;
+}
+function isFloat32Array(value) {
+  return getObjectType(value) === "Float32Array";
+}
+function isFloat64Array(value) {
+  return getObjectType(value) === "Float64Array";
+}
+function isFormData(value) {
+  return getObjectType(value) === "FormData";
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isGenerator(value) {
+  return isIterable(value) && isFunction(value?.next) && isFunction(value?.throw);
+}
+function isGeneratorFunction(value) {
+  return getObjectType(value) === "GeneratorFunction";
+}
+function isHtmlElement(value) {
+  return isObject(value) && value.nodeType === NODE_TYPE_ELEMENT && isString(value.nodeName) && !isPlainObject(value) && DOM_PROPERTIES_TO_CHECK.every((property) => property in value);
+}
+function isInfinite(value) {
+  return value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY;
+}
+function isInRange(value, range) {
+  if (isNumber(range)) {
+    return value >= Math.min(0, range) && value <= Math.max(range, 0);
+  }
+  if (isArray(range) && range.length === 2) {
+    return value >= Math.min(...range) && value <= Math.max(...range);
+  }
+  throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
+}
+function isInt16Array(value) {
+  return getObjectType(value) === "Int16Array";
+}
+function isInt32Array(value) {
+  return getObjectType(value) === "Int32Array";
+}
+function isInt8Array(value) {
+  return getObjectType(value) === "Int8Array";
+}
+function isInteger(value) {
+  return Number.isInteger(value);
+}
+function isIterable(value) {
+  return isFunction(value?.[Symbol.iterator]);
+}
+function isMap(value) {
+  return getObjectType(value) === "Map";
+}
+function isNan(value) {
+  return Number.isNaN(value);
+}
+function isNativePromise(value) {
+  return getObjectType(value) === "Promise";
+}
+function isNegativeNumber(value) {
+  return isNumber(value) && value < 0;
+}
+function isNodeStream(value) {
+  return isObject(value) && isFunction(value.pipe) && !isObservable(value);
+}
+function isNonEmptyArray(value) {
+  return isArray(value) && value.length > 0;
+}
+function isNonEmptyMap(value) {
+  return isMap(value) && value.size > 0;
+}
+function isNonEmptyObject(value) {
+  return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length > 0;
+}
+function isNonEmptySet(value) {
+  return isSet(value) && value.size > 0;
+}
+function isNonEmptyString(value) {
+  return isString(value) && value.length > 0;
+}
+function isNonEmptyStringAndNotWhitespace(value) {
+  return isString(value) && !isEmptyStringOrWhitespace(value);
+}
+function isNull(value) {
+  return value === null;
+}
+function isNullOrUndefined(value) {
+  return isNull(value) || isUndefined(value);
+}
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+function isNumericString(value) {
+  return isString(value) && !isEmptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
+}
+function isObject(value) {
+  return !isNull(value) && (typeof value === "object" || isFunction(value));
+}
+function isObservable(value) {
+  if (!value) {
+    return false;
+  }
+  if (value === value[Symbol.observable]?.()) {
+    return true;
+  }
+  if (value === value["@@observable"]?.()) {
+    return true;
+  }
+  return false;
+}
+function isOddInteger(value) {
+  return isAbsoluteMod2(1)(value);
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+function isPositiveNumber(value) {
+  return isNumber(value) && value > 0;
+}
+function isPrimitive(value) {
+  return isNull(value) || isPrimitiveTypeName(typeof value);
+}
+function isPromise(value) {
+  return isNativePromise(value) || hasPromiseApi(value);
+}
+function isPropertyKey(value) {
+  return isAny([isString, isNumber, isSymbol], value);
+}
+function isRegExp(value) {
+  return getObjectType(value) === "RegExp";
+}
+function isSafeInteger(value) {
+  return Number.isSafeInteger(value);
+}
+function isSet(value) {
+  return getObjectType(value) === "Set";
+}
+function isSharedArrayBuffer(value) {
+  return getObjectType(value) === "SharedArrayBuffer";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isTruthy(value) {
+  return Boolean(value);
+}
+function isTupleLike(value, guards) {
+  if (isArray(guards) && isArray(value) && guards.length === value.length) {
+    return guards.every((guard, index) => guard(value[index]));
+  }
+  return false;
+}
+function isTypedArray(value) {
+  return isTypedArrayName(getObjectType(value));
+}
+function isUint16Array(value) {
+  return getObjectType(value) === "Uint16Array";
+}
+function isUint32Array(value) {
+  return getObjectType(value) === "Uint32Array";
+}
+function isUint8Array(value) {
+  return getObjectType(value) === "Uint8Array";
+}
+function isUint8ClampedArray(value) {
+  return getObjectType(value) === "Uint8ClampedArray";
+}
+function isUndefined(value) {
+  return value === void 0;
+}
+function isUrlInstance(value) {
+  return getObjectType(value) === "URL";
+}
+function isUrlSearchParams(value) {
+  return getObjectType(value) === "URLSearchParams";
+}
+function isUrlString(value) {
+  if (!isString(value)) {
+    return false;
+  }
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidDate(value) {
+  return isDate(value) && !isNan(Number(value));
+}
+function isValidLength(value) {
+  return isSafeInteger(value) && value >= 0;
+}
+function isWeakMap(value) {
+  return getObjectType(value) === "WeakMap";
+}
+function isWeakRef(value) {
+  return getObjectType(value) === "WeakRef";
+}
+function isWeakSet(value) {
+  return getObjectType(value) === "WeakSet";
+}
+function isWhitespaceString(value) {
+  return isString(value) && /^\s+$/.test(value);
+}
+function predicateOnArray(method, predicate, values) {
+  if (!isFunction(predicate)) {
+    throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
+  }
+  if (values.length === 0) {
+    throw new TypeError("Invalid number of values");
+  }
+  return method.call(values, predicate);
+}
+function typeErrorMessage(description, value) {
+  return `Expected value which is \`${description}\`, received value of type \`${is(value)}\`.`;
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function typeErrorMessageMultipleValues(expectedType, values) {
+  const uniqueExpectedTypes = unique((isArray(expectedType) ? expectedType : [expectedType]).map((value) => `\`${value}\``));
+  const uniqueValueTypes = unique(values.map((value) => `\`${is(value)}\``));
+  return `Expected values which are ${orFormatter.format(uniqueExpectedTypes)}. Received values of type${uniqueValueTypes.length > 1 ? "s" : ""} ${andFormatter.format(uniqueValueTypes)}.`;
+}
+function keysOf(value) {
+  return Object.keys(value);
+}
+function isIsMethodName(value) {
+  return isMethodNames.includes(value);
+}
+function assertAll(predicate, ...values) {
+  if (!isAll(predicate, ...values)) {
+    const expectedType = isIsMethodName(predicate.name) ? methodTypeMap[predicate.name] : "predicate returns truthy for all values";
+    throw new TypeError(typeErrorMessageMultipleValues(expectedType, values));
+  }
+}
+function assertAny(predicate, ...values) {
+  if (!isAny(predicate, ...values)) {
+    const predicates = isArray(predicate) ? predicate : [predicate];
+    const expectedTypes = predicates.map((predicate2) => isIsMethodName(predicate2.name) ? methodTypeMap[predicate2.name] : "predicate returns truthy for any value");
+    throw new TypeError(typeErrorMessageMultipleValues(expectedTypes, values));
+  }
+}
+function assertArray(value, assertion, message) {
+  if (!isArray(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Array", value));
+  }
+  if (assertion) {
+    value.forEach(assertion);
+  }
+}
+function assertArrayBuffer(value, message) {
+  if (!isArrayBuffer(value)) {
+    throw new TypeError(message ?? typeErrorMessage("ArrayBuffer", value));
+  }
+}
+function assertArrayLike(value, message) {
+  if (!isArrayLike(value)) {
+    throw new TypeError(message ?? typeErrorMessage("array-like", value));
+  }
+}
+function assertAsyncFunction(value, message) {
+  if (!isAsyncFunction(value)) {
+    throw new TypeError(message ?? typeErrorMessage("AsyncFunction", value));
+  }
+}
+function assertAsyncGenerator(value, message) {
+  if (!isAsyncGenerator(value)) {
+    throw new TypeError(message ?? typeErrorMessage("AsyncGenerator", value));
+  }
+}
+function assertAsyncGeneratorFunction(value, message) {
+  if (!isAsyncGeneratorFunction(value)) {
+    throw new TypeError(message ?? typeErrorMessage("AsyncGeneratorFunction", value));
+  }
+}
+function assertAsyncIterable(value, message) {
+  if (!isAsyncIterable(value)) {
+    throw new TypeError(message ?? typeErrorMessage("AsyncIterable", value));
+  }
+}
+function assertBigint(value, message) {
+  if (!isBigint(value)) {
+    throw new TypeError(message ?? typeErrorMessage("bigint", value));
+  }
+}
+function assertBigInt64Array(value, message) {
+  if (!isBigInt64Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("BigInt64Array", value));
+  }
+}
+function assertBigUint64Array(value, message) {
+  if (!isBigUint64Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("BigUint64Array", value));
+  }
+}
+function assertBlob(value, message) {
+  if (!isBlob(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Blob", value));
+  }
+}
+function assertBoolean(value, message) {
+  if (!isBoolean(value)) {
+    throw new TypeError(message ?? typeErrorMessage("boolean", value));
+  }
+}
+function assertBoundFunction(value, message) {
+  if (!isBoundFunction(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Function", value));
+  }
+}
+function assertBuffer(value, message) {
+  if (!isBuffer(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Buffer", value));
+  }
+}
+function assertClass(value, message) {
+  if (!isClass(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Class", value));
+  }
+}
+function assertDataView(value, message) {
+  if (!isDataView(value)) {
+    throw new TypeError(message ?? typeErrorMessage("DataView", value));
+  }
+}
+function assertDate(value, message) {
+  if (!isDate(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Date", value));
+  }
+}
+function assertDirectInstanceOf(instance, class_, message) {
+  if (!isDirectInstanceOf(instance, class_)) {
+    throw new TypeError(message ?? typeErrorMessage("T", instance));
+  }
+}
+function assertEmptyArray(value, message) {
+  if (!isEmptyArray(value)) {
+    throw new TypeError(message ?? typeErrorMessage("empty array", value));
+  }
+}
+function assertEmptyMap(value, message) {
+  if (!isEmptyMap(value)) {
+    throw new TypeError(message ?? typeErrorMessage("empty map", value));
+  }
+}
+function assertEmptyObject(value, message) {
+  if (!isEmptyObject(value)) {
+    throw new TypeError(message ?? typeErrorMessage("empty object", value));
+  }
+}
+function assertEmptySet(value, message) {
+  if (!isEmptySet(value)) {
+    throw new TypeError(message ?? typeErrorMessage("empty set", value));
+  }
+}
+function assertEmptyString(value, message) {
+  if (!isEmptyString(value)) {
+    throw new TypeError(message ?? typeErrorMessage("empty string", value));
+  }
+}
+function assertEmptyStringOrWhitespace(value, message) {
+  if (!isEmptyStringOrWhitespace(value)) {
+    throw new TypeError(message ?? typeErrorMessage("empty string or whitespace", value));
+  }
+}
+function assertEnumCase(value, targetEnum, message) {
+  if (!isEnumCase(value, targetEnum)) {
+    throw new TypeError(message ?? typeErrorMessage("EnumCase", value));
+  }
+}
+function assertError(value, message) {
+  if (!isError(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Error", value));
+  }
+}
+function assertEvenInteger(value, message) {
+  if (!isEvenInteger(value)) {
+    throw new TypeError(message ?? typeErrorMessage("even integer", value));
+  }
+}
+function assertFalsy(value, message) {
+  if (!isFalsy(value)) {
+    throw new TypeError(message ?? typeErrorMessage("falsy", value));
+  }
+}
+function assertFloat32Array(value, message) {
+  if (!isFloat32Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Float32Array", value));
+  }
+}
+function assertFloat64Array(value, message) {
+  if (!isFloat64Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Float64Array", value));
+  }
+}
+function assertFormData(value, message) {
+  if (!isFormData(value)) {
+    throw new TypeError(message ?? typeErrorMessage("FormData", value));
+  }
+}
+function assertFunction(value, message) {
+  if (!isFunction(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Function", value));
+  }
+}
+function assertGenerator(value, message) {
+  if (!isGenerator(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Generator", value));
+  }
+}
+function assertGeneratorFunction(value, message) {
+  if (!isGeneratorFunction(value)) {
+    throw new TypeError(message ?? typeErrorMessage("GeneratorFunction", value));
+  }
+}
+function assertHtmlElement(value, message) {
+  if (!isHtmlElement(value)) {
+    throw new TypeError(message ?? typeErrorMessage("HTMLElement", value));
+  }
+}
+function assertInfinite(value, message) {
+  if (!isInfinite(value)) {
+    throw new TypeError(message ?? typeErrorMessage("infinite number", value));
+  }
+}
+function assertInRange(value, range, message) {
+  if (!isInRange(value, range)) {
+    throw new TypeError(message ?? typeErrorMessage("in range", value));
+  }
+}
+function assertInt16Array(value, message) {
+  if (!isInt16Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Int16Array", value));
+  }
+}
+function assertInt32Array(value, message) {
+  if (!isInt32Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Int32Array", value));
+  }
+}
+function assertInt8Array(value, message) {
+  if (!isInt8Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Int8Array", value));
+  }
+}
+function assertInteger(value, message) {
+  if (!isInteger(value)) {
+    throw new TypeError(message ?? typeErrorMessage("integer", value));
+  }
+}
+function assertIterable(value, message) {
+  if (!isIterable(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Iterable", value));
+  }
+}
+function assertMap(value, message) {
+  if (!isMap(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Map", value));
+  }
+}
+function assertNan(value, message) {
+  if (!isNan(value)) {
+    throw new TypeError(message ?? typeErrorMessage("NaN", value));
+  }
+}
+function assertNativePromise(value, message) {
+  if (!isNativePromise(value)) {
+    throw new TypeError(message ?? typeErrorMessage("native Promise", value));
+  }
+}
+function assertNegativeNumber(value, message) {
+  if (!isNegativeNumber(value)) {
+    throw new TypeError(message ?? typeErrorMessage("negative number", value));
+  }
+}
+function assertNodeStream(value, message) {
+  if (!isNodeStream(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Node.js Stream", value));
+  }
+}
+function assertNonEmptyArray(value, message) {
+  if (!isNonEmptyArray(value)) {
+    throw new TypeError(message ?? typeErrorMessage("non-empty array", value));
+  }
+}
+function assertNonEmptyMap(value, message) {
+  if (!isNonEmptyMap(value)) {
+    throw new TypeError(message ?? typeErrorMessage("non-empty map", value));
+  }
+}
+function assertNonEmptyObject(value, message) {
+  if (!isNonEmptyObject(value)) {
+    throw new TypeError(message ?? typeErrorMessage("non-empty object", value));
+  }
+}
+function assertNonEmptySet(value, message) {
+  if (!isNonEmptySet(value)) {
+    throw new TypeError(message ?? typeErrorMessage("non-empty set", value));
+  }
+}
+function assertNonEmptyString(value, message) {
+  if (!isNonEmptyString(value)) {
+    throw new TypeError(message ?? typeErrorMessage("non-empty string", value));
+  }
+}
+function assertNonEmptyStringAndNotWhitespace(value, message) {
+  if (!isNonEmptyStringAndNotWhitespace(value)) {
+    throw new TypeError(message ?? typeErrorMessage("non-empty string and not whitespace", value));
+  }
+}
+function assertNull(value, message) {
+  if (!isNull(value)) {
+    throw new TypeError(message ?? typeErrorMessage("null", value));
+  }
+}
+function assertNullOrUndefined(value, message) {
+  if (!isNullOrUndefined(value)) {
+    throw new TypeError(message ?? typeErrorMessage("null or undefined", value));
+  }
+}
+function assertNumber(value, message) {
+  if (!isNumber(value)) {
+    throw new TypeError(message ?? typeErrorMessage("number", value));
+  }
+}
+function assertNumericString(value, message) {
+  if (!isNumericString(value)) {
+    throw new TypeError(message ?? typeErrorMessage("string with a number", value));
+  }
+}
+function assertObject(value, message) {
+  if (!isObject(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Object", value));
+  }
+}
+function assertObservable(value, message) {
+  if (!isObservable(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Observable", value));
+  }
+}
+function assertOddInteger(value, message) {
+  if (!isOddInteger(value)) {
+    throw new TypeError(message ?? typeErrorMessage("odd integer", value));
+  }
+}
+function assertPlainObject(value, message) {
+  if (!isPlainObject(value)) {
+    throw new TypeError(message ?? typeErrorMessage("plain object", value));
+  }
+}
+function assertPositiveNumber(value, message) {
+  if (!isPositiveNumber(value)) {
+    throw new TypeError(message ?? typeErrorMessage("positive number", value));
+  }
+}
+function assertPrimitive(value, message) {
+  if (!isPrimitive(value)) {
+    throw new TypeError(message ?? typeErrorMessage("primitive", value));
+  }
+}
+function assertPromise(value, message) {
+  if (!isPromise(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Promise", value));
+  }
+}
+function assertPropertyKey(value, message) {
+  if (!isPropertyKey(value)) {
+    throw new TypeError(message ?? typeErrorMessage("PropertyKey", value));
+  }
+}
+function assertRegExp(value, message) {
+  if (!isRegExp(value)) {
+    throw new TypeError(message ?? typeErrorMessage("RegExp", value));
+  }
+}
+function assertSafeInteger(value, message) {
+  if (!isSafeInteger(value)) {
+    throw new TypeError(message ?? typeErrorMessage("integer", value));
+  }
+}
+function assertSet(value, message) {
+  if (!isSet(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Set", value));
+  }
+}
+function assertSharedArrayBuffer(value, message) {
+  if (!isSharedArrayBuffer(value)) {
+    throw new TypeError(message ?? typeErrorMessage("SharedArrayBuffer", value));
+  }
+}
+function assertString(value, message) {
+  if (!isString(value)) {
+    throw new TypeError(message ?? typeErrorMessage("string", value));
+  }
+}
+function assertSymbol(value, message) {
+  if (!isSymbol(value)) {
+    throw new TypeError(message ?? typeErrorMessage("symbol", value));
+  }
+}
+function assertTruthy(value, message) {
+  if (!isTruthy(value)) {
+    throw new TypeError(message ?? typeErrorMessage("truthy", value));
+  }
+}
+function assertTupleLike(value, guards, message) {
+  if (!isTupleLike(value, guards)) {
+    throw new TypeError(message ?? typeErrorMessage("tuple-like", value));
+  }
+}
+function assertTypedArray(value, message) {
+  if (!isTypedArray(value)) {
+    throw new TypeError(message ?? typeErrorMessage("TypedArray", value));
+  }
+}
+function assertUint16Array(value, message) {
+  if (!isUint16Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Uint16Array", value));
+  }
+}
+function assertUint32Array(value, message) {
+  if (!isUint32Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Uint32Array", value));
+  }
+}
+function assertUint8Array(value, message) {
+  if (!isUint8Array(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Uint8Array", value));
+  }
+}
+function assertUint8ClampedArray(value, message) {
+  if (!isUint8ClampedArray(value)) {
+    throw new TypeError(message ?? typeErrorMessage("Uint8ClampedArray", value));
+  }
+}
+function assertUndefined(value, message) {
+  if (!isUndefined(value)) {
+    throw new TypeError(message ?? typeErrorMessage("undefined", value));
+  }
+}
+function assertUrlInstance(value, message) {
+  if (!isUrlInstance(value)) {
+    throw new TypeError(message ?? typeErrorMessage("URL", value));
+  }
+}
+function assertUrlSearchParams(value, message) {
+  if (!isUrlSearchParams(value)) {
+    throw new TypeError(message ?? typeErrorMessage("URLSearchParams", value));
+  }
+}
+function assertUrlString(value, message) {
+  if (!isUrlString(value)) {
+    throw new TypeError(message ?? typeErrorMessage("string with a URL", value));
+  }
+}
+function assertValidDate(value, message) {
+  if (!isValidDate(value)) {
+    throw new TypeError(message ?? typeErrorMessage("valid Date", value));
+  }
+}
+function assertValidLength(value, message) {
+  if (!isValidLength(value)) {
+    throw new TypeError(message ?? typeErrorMessage("valid length", value));
+  }
+}
+function assertWeakMap(value, message) {
+  if (!isWeakMap(value)) {
+    throw new TypeError(message ?? typeErrorMessage("WeakMap", value));
+  }
+}
+function assertWeakRef(value, message) {
+  if (!isWeakRef(value)) {
+    throw new TypeError(message ?? typeErrorMessage("WeakRef", value));
+  }
+}
+function assertWeakSet(value, message) {
+  if (!isWeakSet(value)) {
+    throw new TypeError(message ?? typeErrorMessage("WeakSet", value));
+  }
+}
+function assertWhitespaceString(value, message) {
+  if (!isWhitespaceString(value)) {
+    throw new TypeError(message ?? typeErrorMessage("whitespace string", value));
+  }
+}
+var typedArrayTypeNames, objectTypeNames, primitiveTypeNames, assertionTypeDescriptions, getObjectType, is, NODE_TYPE_ELEMENT, DOM_PROPERTIES_TO_CHECK, andFormatter, orFormatter, assert, methodTypeMap, isMethodNames, dist_default;
 var init_dist = __esm({
-  "node_modules/.pnpm/@sindresorhus+is@5.6.0/node_modules/@sindresorhus/is/dist/index.js"() {
+  "node_modules/.pnpm/@sindresorhus+is@6.3.0/node_modules/@sindresorhus/is/dist/index.js"() {
     typedArrayTypeNames = [
       "Int8Array",
       "Uint8Array",
@@ -20344,10 +21159,55 @@ var init_dist = __esm({
       "boolean",
       "symbol"
     ];
-    ({ toString } = Object.prototype);
+    assertionTypeDescriptions = [
+      "positive number",
+      "negative number",
+      "Class",
+      "string with a number",
+      "null or undefined",
+      "Iterable",
+      "AsyncIterable",
+      "native Promise",
+      "EnumCase",
+      "string with a URL",
+      "truthy",
+      "falsy",
+      "primitive",
+      "integer",
+      "plain object",
+      "TypedArray",
+      "array-like",
+      "tuple-like",
+      "Node.js Stream",
+      "infinite number",
+      "empty array",
+      "non-empty array",
+      "empty string",
+      "empty string or whitespace",
+      "non-empty string",
+      "non-empty string and not whitespace",
+      "empty object",
+      "non-empty object",
+      "empty set",
+      "non-empty set",
+      "empty map",
+      "non-empty map",
+      "PropertyKey",
+      "even integer",
+      "odd integer",
+      "T",
+      "in range",
+      "predicate returns truthy for any value",
+      "predicate returns truthy for all values",
+      "valid Date",
+      "valid length",
+      "whitespace string",
+      ...objectTypeNames,
+      ...primitiveTypeNames
+    ];
     getObjectType = (value) => {
-      const objectTypeName = toString.call(value).slice(8, -1);
-      if (/HTML\w+Element/.test(objectTypeName) && is.domElement(value)) {
+      const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
+      if (/HTML\w+Element/.test(objectTypeName) && isHtmlElement(value)) {
         return "HTMLElement";
       }
       if (isObjectTypeName(objectTypeName)) {
@@ -20355,111 +21215,107 @@ var init_dist = __esm({
       }
       return void 0;
     };
-    isObjectOfType = (type) => (value) => getObjectType(value) === type;
-    is.undefined = isOfType("undefined");
-    is.string = isOfType("string");
-    isNumberType = isOfType("number");
-    is.number = (value) => isNumberType(value) && !is.nan(value);
-    is.positiveNumber = (value) => is.number(value) && value > 0;
-    is.negativeNumber = (value) => is.number(value) && value < 0;
-    is.bigint = isOfType("bigint");
-    is.function_ = isOfType("function");
-    is.null_ = (value) => value === null;
-    is.class_ = (value) => is.function_(value) && value.toString().startsWith("class ");
-    is.boolean = (value) => value === true || value === false;
-    is.symbol = isOfType("symbol");
-    is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
-    is.array = (value, assertion) => {
-      if (!Array.isArray(value)) {
-        return false;
-      }
-      if (!is.function_(assertion)) {
-        return true;
-      }
-      return value.every((element) => assertion(element));
-    };
-    is.buffer = (value) => value?.constructor?.isBuffer?.(value) ?? false;
-    is.blob = (value) => isObjectOfType("Blob")(value);
-    is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
-    is.object = (value) => !is.null_(value) && (typeof value === "object" || is.function_(value));
-    is.iterable = (value) => is.function_(value?.[Symbol.iterator]);
-    is.asyncIterable = (value) => is.function_(value?.[Symbol.asyncIterator]);
-    is.generator = (value) => is.iterable(value) && is.function_(value?.next) && is.function_(value?.throw);
-    is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
-    is.nativePromise = (value) => isObjectOfType("Promise")(value);
-    hasPromiseApi = (value) => is.function_(value?.then) && is.function_(value?.catch);
-    is.promise = (value) => is.nativePromise(value) || hasPromiseApi(value);
-    is.generatorFunction = isObjectOfType("GeneratorFunction");
-    is.asyncGeneratorFunction = (value) => getObjectType(value) === "AsyncGeneratorFunction";
-    is.asyncFunction = (value) => getObjectType(value) === "AsyncFunction";
-    is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty("prototype");
-    is.regExp = isObjectOfType("RegExp");
-    is.date = isObjectOfType("Date");
-    is.error = isObjectOfType("Error");
-    is.map = (value) => isObjectOfType("Map")(value);
-    is.set = (value) => isObjectOfType("Set")(value);
-    is.weakMap = (value) => isObjectOfType("WeakMap")(value);
-    is.weakSet = (value) => isObjectOfType("WeakSet")(value);
-    is.weakRef = (value) => isObjectOfType("WeakRef")(value);
-    is.int8Array = isObjectOfType("Int8Array");
-    is.uint8Array = isObjectOfType("Uint8Array");
-    is.uint8ClampedArray = isObjectOfType("Uint8ClampedArray");
-    is.int16Array = isObjectOfType("Int16Array");
-    is.uint16Array = isObjectOfType("Uint16Array");
-    is.int32Array = isObjectOfType("Int32Array");
-    is.uint32Array = isObjectOfType("Uint32Array");
-    is.float32Array = isObjectOfType("Float32Array");
-    is.float64Array = isObjectOfType("Float64Array");
-    is.bigInt64Array = isObjectOfType("BigInt64Array");
-    is.bigUint64Array = isObjectOfType("BigUint64Array");
-    is.arrayBuffer = isObjectOfType("ArrayBuffer");
-    is.sharedArrayBuffer = isObjectOfType("SharedArrayBuffer");
-    is.dataView = isObjectOfType("DataView");
-    is.enumCase = (value, targetEnum) => Object.values(targetEnum).includes(value);
-    is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype;
-    is.urlInstance = (value) => isObjectOfType("URL")(value);
-    is.urlString = (value) => {
-      if (!is.string(value)) {
-        return false;
-      }
-      try {
-        new URL(value);
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    is.truthy = (value) => Boolean(value);
-    is.falsy = (value) => !value;
-    is.nan = (value) => Number.isNaN(value);
-    is.primitive = (value) => is.null_(value) || isPrimitiveTypeName(typeof value);
-    is.integer = (value) => Number.isInteger(value);
-    is.safeInteger = (value) => Number.isSafeInteger(value);
-    is.plainObject = (value) => {
-      if (typeof value !== "object" || value === null) {
-        return false;
-      }
-      const prototype = Object.getPrototypeOf(value);
-      return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
-    };
-    is.typedArray = (value) => isTypedArrayName(getObjectType(value));
-    isValidLength = (value) => is.safeInteger(value) && value >= 0;
-    is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
-    is.tupleLike = (value, guards) => {
-      if (is.array(guards) && is.array(value) && guards.length === value.length) {
-        return guards.every((guard, index) => guard(value[index]));
-      }
-      return false;
-    };
-    is.inRange = (value, range) => {
-      if (is.number(range)) {
-        return value >= Math.min(0, range) && value <= Math.max(range, 0);
-      }
-      if (is.array(range) && range.length === 2) {
-        return value >= Math.min(...range) && value <= Math.max(...range);
-      }
-      throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
-    };
+    is = Object.assign(detect, {
+      all: isAll,
+      any: isAny,
+      array: isArray,
+      arrayBuffer: isArrayBuffer,
+      arrayLike: isArrayLike,
+      asyncFunction: isAsyncFunction,
+      asyncGenerator: isAsyncGenerator,
+      asyncGeneratorFunction: isAsyncGeneratorFunction,
+      asyncIterable: isAsyncIterable,
+      bigint: isBigint,
+      bigInt64Array: isBigInt64Array,
+      bigUint64Array: isBigUint64Array,
+      blob: isBlob,
+      boolean: isBoolean,
+      boundFunction: isBoundFunction,
+      buffer: isBuffer,
+      class: isClass,
+      /** @deprecated Renamed to `class`. */
+      class_: isClass,
+      dataView: isDataView,
+      date: isDate,
+      detect,
+      directInstanceOf: isDirectInstanceOf,
+      /** @deprecated Renamed to `htmlElement` */
+      domElement: isHtmlElement,
+      emptyArray: isEmptyArray,
+      emptyMap: isEmptyMap,
+      emptyObject: isEmptyObject,
+      emptySet: isEmptySet,
+      emptyString: isEmptyString,
+      emptyStringOrWhitespace: isEmptyStringOrWhitespace,
+      enumCase: isEnumCase,
+      error: isError,
+      evenInteger: isEvenInteger,
+      falsy: isFalsy,
+      float32Array: isFloat32Array,
+      float64Array: isFloat64Array,
+      formData: isFormData,
+      function: isFunction,
+      /** @deprecated Renamed to `function`. */
+      function_: isFunction,
+      generator: isGenerator,
+      generatorFunction: isGeneratorFunction,
+      htmlElement: isHtmlElement,
+      infinite: isInfinite,
+      inRange: isInRange,
+      int16Array: isInt16Array,
+      int32Array: isInt32Array,
+      int8Array: isInt8Array,
+      integer: isInteger,
+      iterable: isIterable,
+      map: isMap,
+      nan: isNan,
+      nativePromise: isNativePromise,
+      negativeNumber: isNegativeNumber,
+      nodeStream: isNodeStream,
+      nonEmptyArray: isNonEmptyArray,
+      nonEmptyMap: isNonEmptyMap,
+      nonEmptyObject: isNonEmptyObject,
+      nonEmptySet: isNonEmptySet,
+      nonEmptyString: isNonEmptyString,
+      nonEmptyStringAndNotWhitespace: isNonEmptyStringAndNotWhitespace,
+      null: isNull,
+      /** @deprecated Renamed to `null`. */
+      null_: isNull,
+      nullOrUndefined: isNullOrUndefined,
+      number: isNumber,
+      numericString: isNumericString,
+      object: isObject,
+      observable: isObservable,
+      oddInteger: isOddInteger,
+      plainObject: isPlainObject,
+      positiveNumber: isPositiveNumber,
+      primitive: isPrimitive,
+      promise: isPromise,
+      propertyKey: isPropertyKey,
+      regExp: isRegExp,
+      safeInteger: isSafeInteger,
+      set: isSet,
+      sharedArrayBuffer: isSharedArrayBuffer,
+      string: isString,
+      symbol: isSymbol,
+      truthy: isTruthy,
+      tupleLike: isTupleLike,
+      typedArray: isTypedArray,
+      uint16Array: isUint16Array,
+      uint32Array: isUint32Array,
+      uint8Array: isUint8Array,
+      uint8ClampedArray: isUint8ClampedArray,
+      undefined: isUndefined,
+      urlInstance: isUrlInstance,
+      urlSearchParams: isUrlSearchParams,
+      urlString: isUrlString,
+      validDate: isValidDate,
+      validLength: isValidLength,
+      weakMap: isWeakMap,
+      weakRef: isWeakRef,
+      weakSet: isWeakSet,
+      whitespaceString: isWhitespaceString
+    });
     NODE_TYPE_ELEMENT = 1;
     DOM_PROPERTIES_TO_CHECK = [
       "innerHTML",
@@ -20468,195 +21324,205 @@ var init_dist = __esm({
       "attributes",
       "nodeValue"
     ];
-    is.domElement = (value) => is.object(value) && value.nodeType === NODE_TYPE_ELEMENT && is.string(value.nodeName) && !is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every((property) => property in value);
-    is.observable = (value) => {
-      if (!value) {
-        return false;
-      }
-      if (value === value[Symbol.observable]?.()) {
-        return true;
-      }
-      if (value === value["@@observable"]?.()) {
-        return true;
-      }
-      return false;
-    };
-    is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value);
-    is.infinite = (value) => value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY;
-    isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder;
-    is.evenInteger = isAbsoluteMod2(0);
-    is.oddInteger = isAbsoluteMod2(1);
-    is.emptyArray = (value) => is.array(value) && value.length === 0;
-    is.nonEmptyArray = (value) => is.array(value) && value.length > 0;
-    is.emptyString = (value) => is.string(value) && value.length === 0;
-    isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value);
-    is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value);
-    is.nonEmptyString = (value) => is.string(value) && value.length > 0;
-    is.nonEmptyStringAndNotWhitespace = (value) => is.string(value) && !is.emptyStringOrWhitespace(value);
-    is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0;
-    is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0;
-    is.emptySet = (value) => is.set(value) && value.size === 0;
-    is.nonEmptySet = (value) => is.set(value) && value.size > 0;
-    is.emptyMap = (value) => is.map(value) && value.size === 0;
-    is.nonEmptyMap = (value) => is.map(value) && value.size > 0;
-    is.propertyKey = (value) => is.any([is.string, is.number, is.symbol], value);
-    is.formData = (value) => isObjectOfType("FormData")(value);
-    is.urlSearchParams = (value) => isObjectOfType("URLSearchParams")(value);
-    predicateOnArray = (method, predicate, values) => {
-      if (!is.function_(predicate)) {
-        throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
-      }
-      if (values.length === 0) {
-        throw new TypeError("Invalid number of values");
-      }
-      return method.call(values, predicate);
-    };
-    is.any = (predicate, ...values) => {
-      const predicates = is.array(predicate) ? predicate : [predicate];
-      return predicates.some((singlePredicate) => predicateOnArray(Array.prototype.some, singlePredicate, values));
-    };
-    is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values);
-    assertType = (condition, description, value, options = {}) => {
-      if (!condition) {
-        const { multipleValues } = options;
-        const valuesMessage = multipleValues ? `received values of types ${[
-          ...new Set(value.map((singleValue) => `\`${is(singleValue)}\``))
-        ].join(", ")}` : `received value of type \`${is(value)}\``;
-        throw new TypeError(`Expected value which is \`${description}\`, ${valuesMessage}.`);
-      }
-    };
+    andFormatter = new Intl.ListFormat("en", { style: "long", type: "conjunction" });
+    orFormatter = new Intl.ListFormat("en", { style: "long", type: "disjunction" });
     assert = {
-      // Unknowns.
-      undefined: (value) => assertType(is.undefined(value), "undefined", value),
-      string: (value) => assertType(is.string(value), "string", value),
-      number: (value) => assertType(is.number(value), "number", value),
-      positiveNumber: (value) => assertType(is.positiveNumber(value), "positive number", value),
-      negativeNumber: (value) => assertType(is.negativeNumber(value), "negative number", value),
-      bigint: (value) => assertType(is.bigint(value), "bigint", value),
-      // eslint-disable-next-line @typescript-eslint/ban-types
-      function_: (value) => assertType(is.function_(value), "Function", value),
-      null_: (value) => assertType(is.null_(value), "null", value),
-      class_: (value) => assertType(is.class_(value), "Class", value),
-      boolean: (value) => assertType(is.boolean(value), "boolean", value),
-      symbol: (value) => assertType(is.symbol(value), "symbol", value),
-      numericString: (value) => assertType(is.numericString(value), "string with a number", value),
-      array: (value, assertion) => {
-        const assert2 = assertType;
-        assert2(is.array(value), "Array", value);
-        if (assertion) {
-          value.forEach(assertion);
-        }
-      },
-      buffer: (value) => assertType(is.buffer(value), "Buffer", value),
-      blob: (value) => assertType(is.blob(value), "Blob", value),
-      nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), "null or undefined", value),
-      object: (value) => assertType(is.object(value), "Object", value),
-      iterable: (value) => assertType(is.iterable(value), "Iterable", value),
-      asyncIterable: (value) => assertType(is.asyncIterable(value), "AsyncIterable", value),
-      generator: (value) => assertType(is.generator(value), "Generator", value),
-      asyncGenerator: (value) => assertType(is.asyncGenerator(value), "AsyncGenerator", value),
-      nativePromise: (value) => assertType(is.nativePromise(value), "native Promise", value),
-      promise: (value) => assertType(is.promise(value), "Promise", value),
-      generatorFunction: (value) => assertType(is.generatorFunction(value), "GeneratorFunction", value),
-      asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), "AsyncGeneratorFunction", value),
-      // eslint-disable-next-line @typescript-eslint/ban-types
-      asyncFunction: (value) => assertType(is.asyncFunction(value), "AsyncFunction", value),
-      // eslint-disable-next-line @typescript-eslint/ban-types
-      boundFunction: (value) => assertType(is.boundFunction(value), "Function", value),
-      regExp: (value) => assertType(is.regExp(value), "RegExp", value),
-      date: (value) => assertType(is.date(value), "Date", value),
-      error: (value) => assertType(is.error(value), "Error", value),
-      map: (value) => assertType(is.map(value), "Map", value),
-      set: (value) => assertType(is.set(value), "Set", value),
-      weakMap: (value) => assertType(is.weakMap(value), "WeakMap", value),
-      weakSet: (value) => assertType(is.weakSet(value), "WeakSet", value),
-      weakRef: (value) => assertType(is.weakRef(value), "WeakRef", value),
-      int8Array: (value) => assertType(is.int8Array(value), "Int8Array", value),
-      uint8Array: (value) => assertType(is.uint8Array(value), "Uint8Array", value),
-      uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), "Uint8ClampedArray", value),
-      int16Array: (value) => assertType(is.int16Array(value), "Int16Array", value),
-      uint16Array: (value) => assertType(is.uint16Array(value), "Uint16Array", value),
-      int32Array: (value) => assertType(is.int32Array(value), "Int32Array", value),
-      uint32Array: (value) => assertType(is.uint32Array(value), "Uint32Array", value),
-      float32Array: (value) => assertType(is.float32Array(value), "Float32Array", value),
-      float64Array: (value) => assertType(is.float64Array(value), "Float64Array", value),
-      bigInt64Array: (value) => assertType(is.bigInt64Array(value), "BigInt64Array", value),
-      bigUint64Array: (value) => assertType(is.bigUint64Array(value), "BigUint64Array", value),
-      arrayBuffer: (value) => assertType(is.arrayBuffer(value), "ArrayBuffer", value),
-      sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), "SharedArrayBuffer", value),
-      dataView: (value) => assertType(is.dataView(value), "DataView", value),
-      enumCase: (value, targetEnum) => assertType(is.enumCase(value, targetEnum), "EnumCase", value),
-      urlInstance: (value) => assertType(is.urlInstance(value), "URL", value),
-      urlString: (value) => assertType(is.urlString(value), "string with a URL", value),
-      truthy: (value) => assertType(is.truthy(value), "truthy", value),
-      falsy: (value) => assertType(is.falsy(value), "falsy", value),
-      nan: (value) => assertType(is.nan(value), "NaN", value),
-      primitive: (value) => assertType(is.primitive(value), "primitive", value),
-      integer: (value) => assertType(is.integer(value), "integer", value),
-      safeInteger: (value) => assertType(is.safeInteger(value), "integer", value),
-      plainObject: (value) => assertType(is.plainObject(value), "plain object", value),
-      typedArray: (value) => assertType(is.typedArray(value), "TypedArray", value),
-      arrayLike: (value) => assertType(is.arrayLike(value), "array-like", value),
-      tupleLike: (value, guards) => assertType(is.tupleLike(value, guards), "tuple-like", value),
-      domElement: (value) => assertType(is.domElement(value), "HTMLElement", value),
-      observable: (value) => assertType(is.observable(value), "Observable", value),
-      nodeStream: (value) => assertType(is.nodeStream(value), "Node.js Stream", value),
-      infinite: (value) => assertType(is.infinite(value), "infinite number", value),
-      emptyArray: (value) => assertType(is.emptyArray(value), "empty array", value),
-      nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), "non-empty array", value),
-      emptyString: (value) => assertType(is.emptyString(value), "empty string", value),
-      emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), "empty string or whitespace", value),
-      nonEmptyString: (value) => assertType(is.nonEmptyString(value), "non-empty string", value),
-      nonEmptyStringAndNotWhitespace: (value) => assertType(is.nonEmptyStringAndNotWhitespace(value), "non-empty string and not whitespace", value),
-      emptyObject: (value) => assertType(is.emptyObject(value), "empty object", value),
-      nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), "non-empty object", value),
-      emptySet: (value) => assertType(is.emptySet(value), "empty set", value),
-      nonEmptySet: (value) => assertType(is.nonEmptySet(value), "non-empty set", value),
-      emptyMap: (value) => assertType(is.emptyMap(value), "empty map", value),
-      nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), "non-empty map", value),
-      propertyKey: (value) => assertType(is.propertyKey(value), "PropertyKey", value),
-      formData: (value) => assertType(is.formData(value), "FormData", value),
-      urlSearchParams: (value) => assertType(is.urlSearchParams(value), "URLSearchParams", value),
-      // Numbers.
-      evenInteger: (value) => assertType(is.evenInteger(value), "even integer", value),
-      oddInteger: (value) => assertType(is.oddInteger(value), "odd integer", value),
-      // Two arguments.
-      directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), "T", instance),
-      inRange: (value, range) => assertType(is.inRange(value, range), "in range", value),
-      // Variadic functions.
-      any: (predicate, ...values) => assertType(is.any(predicate, ...values), "predicate returns truthy for any value", values, { multipleValues: true }),
-      all: (predicate, ...values) => assertType(is.all(predicate, ...values), "predicate returns truthy for all values", values, { multipleValues: true })
-    };
-    Object.defineProperties(is, {
-      class: {
-        value: is.class_
-      },
-      function: {
-        value: is.function_
-      },
-      null: {
-        value: is.null_
-      }
-    });
-    Object.defineProperties(assert, {
-      class: {
-        value: assert.class_
-      },
-      function: {
-        value: assert.function_
-      },
-      null: {
-        value: assert.null_
-      }
-    });
+      all: assertAll,
+      any: assertAny,
+      array: assertArray,
+      arrayBuffer: assertArrayBuffer,
+      arrayLike: assertArrayLike,
+      asyncFunction: assertAsyncFunction,
+      asyncGenerator: assertAsyncGenerator,
+      asyncGeneratorFunction: assertAsyncGeneratorFunction,
+      asyncIterable: assertAsyncIterable,
+      bigint: assertBigint,
+      bigInt64Array: assertBigInt64Array,
+      bigUint64Array: assertBigUint64Array,
+      blob: assertBlob,
+      boolean: assertBoolean,
+      boundFunction: assertBoundFunction,
+      buffer: assertBuffer,
+      class: assertClass,
+      class_: assertClass,
+      dataView: assertDataView,
+      date: assertDate,
+      directInstanceOf: assertDirectInstanceOf,
+      domElement: assertHtmlElement,
+      emptyArray: assertEmptyArray,
+      emptyMap: assertEmptyMap,
+      emptyObject: assertEmptyObject,
+      emptySet: assertEmptySet,
+      emptyString: assertEmptyString,
+      emptyStringOrWhitespace: assertEmptyStringOrWhitespace,
+      enumCase: assertEnumCase,
+      error: assertError,
+      evenInteger: assertEvenInteger,
+      falsy: assertFalsy,
+      float32Array: assertFloat32Array,
+      float64Array: assertFloat64Array,
+      formData: assertFormData,
+      function: assertFunction,
+      function_: assertFunction,
+      generator: assertGenerator,
+      generatorFunction: assertGeneratorFunction,
+      htmlElement: assertHtmlElement,
+      infinite: assertInfinite,
+      inRange: assertInRange,
+      int16Array: assertInt16Array,
+      int32Array: assertInt32Array,
+      int8Array: assertInt8Array,
+      integer: assertInteger,
+      iterable: assertIterable,
+      map: assertMap,
+      nan: assertNan,
+      nativePromise: assertNativePromise,
+      negativeNumber: assertNegativeNumber,
+      nodeStream: assertNodeStream,
+      nonEmptyArray: assertNonEmptyArray,
+      nonEmptyMap: assertNonEmptyMap,
+      nonEmptyObject: assertNonEmptyObject,
+      nonEmptySet: assertNonEmptySet,
+      nonEmptyString: assertNonEmptyString,
+      nonEmptyStringAndNotWhitespace: assertNonEmptyStringAndNotWhitespace,
+      null: assertNull,
+      null_: assertNull,
+      nullOrUndefined: assertNullOrUndefined,
+      number: assertNumber,
+      numericString: assertNumericString,
+      object: assertObject,
+      observable: assertObservable,
+      oddInteger: assertOddInteger,
+      plainObject: assertPlainObject,
+      positiveNumber: assertPositiveNumber,
+      primitive: assertPrimitive,
+      promise: assertPromise,
+      propertyKey: assertPropertyKey,
+      regExp: assertRegExp,
+      safeInteger: assertSafeInteger,
+      set: assertSet,
+      sharedArrayBuffer: assertSharedArrayBuffer,
+      string: assertString,
+      symbol: assertSymbol,
+      truthy: assertTruthy,
+      tupleLike: assertTupleLike,
+      typedArray: assertTypedArray,
+      uint16Array: assertUint16Array,
+      uint32Array: assertUint32Array,
+      uint8Array: assertUint8Array,
+      uint8ClampedArray: assertUint8ClampedArray,
+      undefined: assertUndefined,
+      urlInstance: assertUrlInstance,
+      urlSearchParams: assertUrlSearchParams,
+      urlString: assertUrlString,
+      validDate: assertValidDate,
+      validLength: assertValidLength,
+      weakMap: assertWeakMap,
+      weakRef: assertWeakRef,
+      weakSet: assertWeakSet,
+      whitespaceString: assertWhitespaceString
+    };
+    methodTypeMap = {
+      isArray: "Array",
+      isArrayBuffer: "ArrayBuffer",
+      isArrayLike: "array-like",
+      isAsyncFunction: "AsyncFunction",
+      isAsyncGenerator: "AsyncGenerator",
+      isAsyncGeneratorFunction: "AsyncGeneratorFunction",
+      isAsyncIterable: "AsyncIterable",
+      isBigint: "bigint",
+      isBigInt64Array: "BigInt64Array",
+      isBigUint64Array: "BigUint64Array",
+      isBlob: "Blob",
+      isBoolean: "boolean",
+      isBoundFunction: "Function",
+      isBuffer: "Buffer",
+      isClass: "Class",
+      isDataView: "DataView",
+      isDate: "Date",
+      isDirectInstanceOf: "T",
+      /** @deprecated */
+      isDomElement: "HTMLElement",
+      isEmptyArray: "empty array",
+      isEmptyMap: "empty map",
+      isEmptyObject: "empty object",
+      isEmptySet: "empty set",
+      isEmptyString: "empty string",
+      isEmptyStringOrWhitespace: "empty string or whitespace",
+      isEnumCase: "EnumCase",
+      isError: "Error",
+      isEvenInteger: "even integer",
+      isFalsy: "falsy",
+      isFloat32Array: "Float32Array",
+      isFloat64Array: "Float64Array",
+      isFormData: "FormData",
+      isFunction: "Function",
+      isGenerator: "Generator",
+      isGeneratorFunction: "GeneratorFunction",
+      isHtmlElement: "HTMLElement",
+      isInfinite: "infinite number",
+      isInRange: "in range",
+      isInt16Array: "Int16Array",
+      isInt32Array: "Int32Array",
+      isInt8Array: "Int8Array",
+      isInteger: "integer",
+      isIterable: "Iterable",
+      isMap: "Map",
+      isNan: "NaN",
+      isNativePromise: "native Promise",
+      isNegativeNumber: "negative number",
+      isNodeStream: "Node.js Stream",
+      isNonEmptyArray: "non-empty array",
+      isNonEmptyMap: "non-empty map",
+      isNonEmptyObject: "non-empty object",
+      isNonEmptySet: "non-empty set",
+      isNonEmptyString: "non-empty string",
+      isNonEmptyStringAndNotWhitespace: "non-empty string and not whitespace",
+      isNull: "null",
+      isNullOrUndefined: "null or undefined",
+      isNumber: "number",
+      isNumericString: "string with a number",
+      isObject: "Object",
+      isObservable: "Observable",
+      isOddInteger: "odd integer",
+      isPlainObject: "plain object",
+      isPositiveNumber: "positive number",
+      isPrimitive: "primitive",
+      isPromise: "Promise",
+      isPropertyKey: "PropertyKey",
+      isRegExp: "RegExp",
+      isSafeInteger: "integer",
+      isSet: "Set",
+      isSharedArrayBuffer: "SharedArrayBuffer",
+      isString: "string",
+      isSymbol: "symbol",
+      isTruthy: "truthy",
+      isTupleLike: "tuple-like",
+      isTypedArray: "TypedArray",
+      isUint16Array: "Uint16Array",
+      isUint32Array: "Uint32Array",
+      isUint8Array: "Uint8Array",
+      isUint8ClampedArray: "Uint8ClampedArray",
+      isUndefined: "undefined",
+      isUrlInstance: "URL",
+      isUrlSearchParams: "URLSearchParams",
+      isUrlString: "string with a URL",
+      isValidDate: "valid Date",
+      isValidLength: "valid length",
+      isWeakMap: "WeakMap",
+      isWeakRef: "WeakRef",
+      isWeakSet: "WeakSet",
+      isWhitespaceString: "whitespace string"
+    };
+    isMethodNames = keysOf(methodTypeMap);
     dist_default = is;
   }
 });
 
-// node_modules/.pnpm/p-cancelable@3.0.0/node_modules/p-cancelable/index.js
-var CancelError, PCancelable;
+// node_modules/.pnpm/p-cancelable@4.0.1/node_modules/p-cancelable/index.js
+var CancelError, promiseState, PCancelable;
 var init_p_cancelable = __esm({
-  "node_modules/.pnpm/p-cancelable@3.0.0/node_modules/p-cancelable/index.js"() {
+  "node_modules/.pnpm/p-cancelable@4.0.1/node_modules/p-cancelable/index.js"() {
     CancelError = class extends Error {
       constructor(reason) {
         super(reason || "Promise was canceled");
@@ -20666,132 +21532,115 @@ var init_p_cancelable = __esm({
         return true;
       }
     };
+    promiseState = Object.freeze({
+      pending: Symbol("pending"),
+      canceled: Symbol("canceled"),
+      resolved: Symbol("resolved"),
+      rejected: Symbol("rejected")
+    });
     PCancelable = class _PCancelable {
       static fn(userFunction) {
-        return (...arguments_) => {
-          return new _PCancelable((resolve, reject, onCancel) => {
-            arguments_.push(onCancel);
-            userFunction(...arguments_).then(resolve, reject);
-          });
-        };
+        return (...arguments_) => new _PCancelable((resolve, reject, onCancel) => {
+          arguments_.push(onCancel);
+          userFunction(...arguments_).then(resolve, reject);
+        });
       }
+      #cancelHandlers = [];
+      #rejectOnCancel = true;
+      #state = promiseState.pending;
+      #promise;
+      #reject;
       constructor(executor) {
-        this._cancelHandlers = [];
-        this._isPending = true;
-        this._isCanceled = false;
-        this._rejectOnCancel = true;
-        this._promise = new Promise((resolve, reject) => {
-          this._reject = reject;
+        this.#promise = new Promise((resolve, reject) => {
+          this.#reject = reject;
           const onResolve = (value) => {
-            if (!this._isCanceled || !onCancel.shouldReject) {
-              this._isPending = false;
+            if (this.#state !== promiseState.canceled || !onCancel.shouldReject) {
               resolve(value);
+              this.#setState(promiseState.resolved);
             }
           };
           const onReject = (error2) => {
-            this._isPending = false;
-            reject(error2);
+            if (this.#state !== promiseState.canceled || !onCancel.shouldReject) {
+              reject(error2);
+              this.#setState(promiseState.rejected);
+            }
           };
           const onCancel = (handler) => {
-            if (!this._isPending) {
-              throw new Error("The `onCancel` handler was attached after the promise settled.");
+            if (this.#state !== promiseState.pending) {
+              throw new Error(`The \`onCancel\` handler was attached after the promise ${this.#state.description}.`);
             }
-            this._cancelHandlers.push(handler);
+            this.#cancelHandlers.push(handler);
           };
           Object.defineProperties(onCancel, {
             shouldReject: {
-              get: () => this._rejectOnCancel,
+              get: () => this.#rejectOnCancel,
               set: (boolean) => {
-                this._rejectOnCancel = boolean;
+                this.#rejectOnCancel = boolean;
               }
             }
           });
           executor(onResolve, onReject, onCancel);
         });
       }
+      // eslint-disable-next-line unicorn/no-thenable
       then(onFulfilled, onRejected) {
-        return this._promise.then(onFulfilled, onRejected);
+        return this.#promise.then(onFulfilled, onRejected);
       }
       catch(onRejected) {
-        return this._promise.catch(onRejected);
+        return this.#promise.catch(onRejected);
       }
       finally(onFinally) {
-        return this._promise.finally(onFinally);
+        return this.#promise.finally(onFinally);
       }
       cancel(reason) {
-        if (!this._isPending || this._isCanceled) {
+        if (this.#state !== promiseState.pending) {
           return;
         }
-        this._isCanceled = true;
-        if (this._cancelHandlers.length > 0) {
+        this.#setState(promiseState.canceled);
+        if (this.#cancelHandlers.length > 0) {
           try {
-            for (const handler of this._cancelHandlers) {
+            for (const handler of this.#cancelHandlers) {
               handler();
             }
           } catch (error2) {
-            this._reject(error2);
+            this.#reject(error2);
             return;
           }
         }
-        if (this._rejectOnCancel) {
-          this._reject(new CancelError(reason));
+        if (this.#rejectOnCancel) {
+          this.#reject(new CancelError(reason));
         }
       }
       get isCanceled() {
-        return this._isCanceled;
+        return this.#state === promiseState.canceled;
+      }
+      #setState(state) {
+        if (this.#state === promiseState.pending) {
+          this.#state = state;
+        }
       }
     };
     Object.setPrototypeOf(PCancelable.prototype, Promise.prototype);
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/errors.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/errors.js
 function isRequest(x) {
   return dist_default.object(x) && "_onResponse" in x;
 }
 var RequestError, MaxRedirectsError, HTTPError, CacheError, UploadError, TimeoutError, ReadError, RetryError, AbortError;
 var init_errors = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/errors.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/errors.js"() {
     init_dist();
     RequestError = class extends Error {
+      input;
+      code;
+      stack;
+      response;
+      request;
+      timings;
       constructor(message, error2, self) {
-        super(message);
-        Object.defineProperty(this, "input", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "code", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "stack", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "response", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "request", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "timings", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
+        super(message, { cause: error2 });
         Error.captureStackTrace(this, this.constructor);
         this.name = "RequestError";
         this.code = error2.code ?? "ERR_GOT_REQUEST_ERROR";
@@ -20850,20 +21699,10 @@ var init_errors = __esm({
       }
     };
     TimeoutError = class extends RequestError {
+      timings;
+      event;
       constructor(error2, timings, request) {
         super(error2.message, error2, request);
-        Object.defineProperty(this, "timings", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "event", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
         this.name = "TimeoutError";
         this.event = error2.event;
         this.timings = timings;
@@ -21051,7 +21890,7 @@ var init_source = __esm({
   }
 });
 
-// node_modules/.pnpm/normalize-url@8.0.0/node_modules/normalize-url/index.js
+// node_modules/.pnpm/normalize-url@8.0.1/node_modules/normalize-url/index.js
 function normalizeUrl(urlString, options) {
   options = {
     defaultProtocol: "http",
@@ -21195,7 +22034,7 @@ function normalizeUrl(urlString, options) {
 }
 var DATA_URL_DEFAULT_MIME_TYPE, DATA_URL_DEFAULT_CHARSET, testParameter, supportedProtocols, hasCustomProtocol, normalizeDataURL;
 var init_normalize_url = __esm({
-  "node_modules/.pnpm/normalize-url@8.0.0/node_modules/normalize-url/index.js"() {
+  "node_modules/.pnpm/normalize-url@8.0.1/node_modules/normalize-url/index.js"() {
     DATA_URL_DEFAULT_MIME_TYPE = "text/plain";
     DATA_URL_DEFAULT_CHARSET = "us-ascii";
     testParameter = (name, filters) => filters.some((filter) => filter instanceof RegExp ? filter.test(name) : filter === name);
@@ -21207,7 +22046,7 @@ var init_normalize_url = __esm({
     hasCustomProtocol = (urlString) => {
       try {
         const { protocol } = new URL(urlString);
-        return protocol.endsWith(":") && !supportedProtocols.has(protocol);
+        return protocol.endsWith(":") && !protocol.includes(".") && !supportedProtocols.has(protocol);
       } catch {
         return false;
       }
@@ -21259,14 +22098,14 @@ var require_buffer_stream = __commonJS({
       options = { ...options };
       const { array } = options;
       let { encoding } = options;
-      const isBuffer = encoding === "buffer";
+      const isBuffer2 = encoding === "buffer";
       let objectMode = false;
       if (array) {
-        objectMode = !(encoding || isBuffer);
+        objectMode = !(encoding || isBuffer2);
       } else {
         encoding = encoding || "utf8";
       }
-      if (isBuffer) {
+      if (isBuffer2) {
         encoding = null;
       }
       const stream2 = new PassThroughStream2({ objectMode });
@@ -21275,19 +22114,19 @@ var require_buffer_stream = __commonJS({
       }
       let length = 0;
       const chunks = [];
-      stream2.on("data", (chunk) => {
-        chunks.push(chunk);
+      stream2.on("data", (chunk2) => {
+        chunks.push(chunk2);
         if (objectMode) {
           length = chunks.length;
         } else {
-          length += chunk.length;
+          length += chunk2.length;
         }
       });
       stream2.getBufferedValue = () => {
         if (array) {
           return chunks;
         }
-        return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
+        return isBuffer2 ? Buffer.concat(chunks, length) : chunks.join("");
       };
       stream2.getBufferedLength = () => length;
       return stream2;
@@ -21304,13 +22143,13 @@ var require_get_stream = __commonJS({
     var { promisify: promisify4 } = __require("util");
     var bufferStream = require_buffer_stream();
     var streamPipelinePromisified = promisify4(stream2.pipeline);
-    var MaxBufferError = class extends Error {
+    var MaxBufferError2 = class extends Error {
       constructor() {
         super("maxBuffer exceeded");
         this.name = "MaxBufferError";
       }
     };
-    async function getStream3(inputStream, options) {
+    async function getStream2(inputStream, options) {
       if (!inputStream) {
         throw new Error("Expected a stream");
       }
@@ -21337,16 +22176,16 @@ var require_get_stream = __commonJS({
         })();
         stream3.on("data", () => {
           if (stream3.getBufferedLength() > maxBuffer) {
-            rejectPromise(new MaxBufferError());
+            rejectPromise(new MaxBufferError2());
           }
         });
       });
       return stream3.getBufferedValue();
     }
-    module.exports = getStream3;
-    module.exports.buffer = (stream3, options) => getStream3(stream3, { ...options, encoding: "buffer" });
-    module.exports.array = (stream3, options) => getStream3(stream3, { ...options, array: true });
-    module.exports.MaxBufferError = MaxBufferError;
+    module.exports = getStream2;
+    module.exports.buffer = (stream3, options) => getStream2(stream3, { ...options, encoding: "buffer" });
+    module.exports.array = (stream3, options) => getStream2(stream3, { ...options, array: true });
+    module.exports.MaxBufferError = MaxBufferError2;
   }
 });
 
@@ -22014,9 +22853,9 @@ var require_src = __commonJS({
       }
       get(key, options) {
         const { store } = this.opts;
-        const isArray = Array.isArray(key);
-        const keyPrefixed = isArray ? this._getKeyPrefixArray(key) : this._getKeyPrefix(key);
-        if (isArray && store.getMany === void 0) {
+        const isArray2 = Array.isArray(key);
+        const keyPrefixed = isArray2 ? this._getKeyPrefixArray(key) : this._getKeyPrefix(key);
+        if (isArray2 && store.getMany === void 0) {
           const promises = [];
           for (const key2 of keyPrefixed) {
             promises.push(
@@ -22039,11 +22878,11 @@ var require_src = __commonJS({
             return data;
           });
         }
-        return Promise.resolve().then(() => isArray ? store.getMany(keyPrefixed) : store.get(keyPrefixed)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => {
+        return Promise.resolve().then(() => isArray2 ? store.getMany(keyPrefixed) : store.get(keyPrefixed)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => {
           if (data === void 0 || data === null) {
             return void 0;
           }
-          if (isArray) {
+          if (isArray2) {
             return data.map((row, index) => {
               if (typeof row === "string") {
                 row = this.opts.deserialize(row);
@@ -22138,8 +22977,8 @@ function mimicResponse(fromStream, toStream) {
     properties[property] = {
       get() {
         const value = fromStream[property];
-        const isFunction2 = typeof value === "function";
-        return isFunction2 ? value.bind(fromStream) : value;
+        const isFunction3 = typeof value === "function";
+        return isFunction3 ? value.bind(fromStream) : value;
       },
       set(value) {
         fromStream[property] = value;
@@ -22503,8 +23342,8 @@ var require_mimic_response = __commonJS({
         properties[property] = {
           get() {
             const value = fromStream[property];
-            const isFunction2 = typeof value === "function";
-            return isFunction2 ? value.bind(fromStream) : value;
+            const isFunction3 = typeof value === "function";
+            return isFunction3 ? value.bind(fromStream) : value;
           },
           set(value) {
             fromStream[property] = value;
@@ -22585,15 +23424,221 @@ var require_decompress_response = __commonJS({
   }
 });
 
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/isFunction.js
-var isFunction;
-var init_isFunction = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/isFunction.js"() {
-    isFunction = (value) => typeof value === "function";
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/contents.js
+var getStreamContents, appendFinalChunk, appendChunk, addNewChunk, isAsyncIterable2, getChunkType, objectToString, MaxBufferError;
+var init_contents = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/contents.js"() {
+    getStreamContents = async (stream2, { init: init2, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
+      if (!isAsyncIterable2(stream2)) {
+        throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
+      }
+      const state = init2();
+      state.length = 0;
+      try {
+        for await (const chunk2 of stream2) {
+          const chunkType = getChunkType(chunk2);
+          const convertedChunk = convertChunk[chunkType](chunk2, state);
+          appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+        }
+        appendFinalChunk({ state, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer });
+        return finalize(state);
+      } catch (error2) {
+        error2.bufferedData = finalize(state);
+        throw error2;
+      }
+    };
+    appendFinalChunk = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
+      const convertedChunk = getFinalChunk(state);
+      if (convertedChunk !== void 0) {
+        appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+      }
+    };
+    appendChunk = ({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer }) => {
+      const chunkSize = getSize(convertedChunk);
+      const newLength = state.length + chunkSize;
+      if (newLength <= maxBuffer) {
+        addNewChunk(convertedChunk, state, addChunk, newLength);
+        return;
+      }
+      const truncatedChunk = truncateChunk(convertedChunk, maxBuffer - state.length);
+      if (truncatedChunk !== void 0) {
+        addNewChunk(truncatedChunk, state, addChunk, maxBuffer);
+      }
+      throw new MaxBufferError();
+    };
+    addNewChunk = (convertedChunk, state, addChunk, newLength) => {
+      state.contents = addChunk(convertedChunk, state, newLength);
+      state.length = newLength;
+    };
+    isAsyncIterable2 = (stream2) => typeof stream2 === "object" && stream2 !== null && typeof stream2[Symbol.asyncIterator] === "function";
+    getChunkType = (chunk2) => {
+      const typeOfChunk = typeof chunk2;
+      if (typeOfChunk === "string") {
+        return "string";
+      }
+      if (typeOfChunk !== "object" || chunk2 === null) {
+        return "others";
+      }
+      if (globalThis.Buffer?.isBuffer(chunk2)) {
+        return "buffer";
+      }
+      const prototypeName = objectToString.call(chunk2);
+      if (prototypeName === "[object ArrayBuffer]") {
+        return "arrayBuffer";
+      }
+      if (prototypeName === "[object DataView]") {
+        return "dataView";
+      }
+      if (Number.isInteger(chunk2.byteLength) && Number.isInteger(chunk2.byteOffset) && objectToString.call(chunk2.buffer) === "[object ArrayBuffer]") {
+        return "typedArray";
+      }
+      return "others";
+    };
+    ({ toString: objectToString } = Object.prototype);
+    MaxBufferError = class extends Error {
+      name = "MaxBufferError";
+      constructor() {
+        super("maxBuffer exceeded");
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/utils.js
+var noop, throwObjectStream, getLengthProp;
+var init_utils = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/utils.js"() {
+    noop = () => void 0;
+    throwObjectStream = (chunk2) => {
+      throw new Error(`Streams in object mode are not supported: ${String(chunk2)}`);
+    };
+    getLengthProp = (convertedChunk) => convertedChunk.length;
+  }
+});
+
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array.js
+var init_array = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array.js"() {
+    init_contents();
+    init_utils();
+  }
+});
+
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array-buffer.js
+async function getStreamAsArrayBuffer(stream2, options) {
+  return getStreamContents(stream2, arrayBufferMethods, options);
+}
+var initArrayBuffer, useTextEncoder, textEncoder, useUint8Array, useUint8ArrayWithOffset, truncateArrayBufferChunk, addArrayBufferChunk, resizeArrayBufferSlow, resizeArrayBuffer, getNewContentsLength, SCALE_FACTOR, finalizeArrayBuffer, hasArrayBufferResize, arrayBufferMethods;
+var init_array_buffer = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array-buffer.js"() {
+    init_contents();
+    init_utils();
+    initArrayBuffer = () => ({ contents: new ArrayBuffer(0) });
+    useTextEncoder = (chunk2) => textEncoder.encode(chunk2);
+    textEncoder = new TextEncoder();
+    useUint8Array = (chunk2) => new Uint8Array(chunk2);
+    useUint8ArrayWithOffset = (chunk2) => new Uint8Array(chunk2.buffer, chunk2.byteOffset, chunk2.byteLength);
+    truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+    addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
+      const newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
+      new Uint8Array(newContents).set(convertedChunk, previousLength);
+      return newContents;
+    };
+    resizeArrayBufferSlow = (contents, length) => {
+      if (length <= contents.byteLength) {
+        return contents;
+      }
+      const arrayBuffer = new ArrayBuffer(getNewContentsLength(length));
+      new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+      return arrayBuffer;
+    };
+    resizeArrayBuffer = (contents, length) => {
+      if (length <= contents.maxByteLength) {
+        contents.resize(length);
+        return contents;
+      }
+      const arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength(length) });
+      new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+      return arrayBuffer;
+    };
+    getNewContentsLength = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR));
+    SCALE_FACTOR = 2;
+    finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize() ? contents : contents.slice(0, length);
+    hasArrayBufferResize = () => "resize" in ArrayBuffer.prototype;
+    arrayBufferMethods = {
+      init: initArrayBuffer,
+      convertChunk: {
+        string: useTextEncoder,
+        buffer: useUint8Array,
+        arrayBuffer: useUint8Array,
+        dataView: useUint8ArrayWithOffset,
+        typedArray: useUint8ArrayWithOffset,
+        others: throwObjectStream
+      },
+      getSize: getLengthProp,
+      truncateChunk: truncateArrayBufferChunk,
+      addChunk: addArrayBufferChunk,
+      getFinalChunk: noop,
+      finalize: finalizeArrayBuffer
+    };
+  }
+});
+
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/buffer.js
+async function getStreamAsBuffer(stream2, options) {
+  if (!("Buffer" in globalThis)) {
+    throw new Error("getStreamAsBuffer() is only supported in Node.js");
+  }
+  try {
+    return arrayBufferToNodeBuffer(await getStreamAsArrayBuffer(stream2, options));
+  } catch (error2) {
+    if (error2.bufferedData !== void 0) {
+      error2.bufferedData = arrayBufferToNodeBuffer(error2.bufferedData);
+    }
+    throw error2;
+  }
+}
+var arrayBufferToNodeBuffer;
+var init_buffer = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/buffer.js"() {
+    init_array_buffer();
+    arrayBufferToNodeBuffer = (arrayBuffer) => globalThis.Buffer.from(arrayBuffer);
+  }
+});
+
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/string.js
+var init_string = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/string.js"() {
+    init_contents();
+    init_utils();
+  }
+});
+
+// node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/index.js
+var init_source2 = __esm({
+  "node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/index.js"() {
+    init_array();
+    init_array_buffer();
+    init_buffer();
+    init_string();
+    init_contents();
   }
 });
 
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/getStreamIterator.js
+// node_modules/.pnpm/form-data-encoder@4.0.2/node_modules/form-data-encoder/lib/index.js
+function* chunk(value) {
+  if (value.byteLength <= MAX_CHUNK_SIZE) {
+    yield value;
+    return;
+  }
+  let offset = 0;
+  while (offset < value.byteLength) {
+    const size = Math.min(value.byteLength - offset, MAX_CHUNK_SIZE);
+    const buffer = value.buffer.slice(offset, offset + size);
+    offset += buffer.byteLength;
+    yield new Uint8Array(buffer);
+  }
+}
 async function* readStream(readable) {
   const reader = readable.getReader();
   while (true) {
@@ -22604,24 +23649,11 @@ async function* readStream(readable) {
     yield value;
   }
 }
-var isAsyncIterable, getStreamIterator;
-var init_getStreamIterator = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/getStreamIterator.js"() {
-    init_isFunction();
-    isAsyncIterable = (value) => isFunction(value[Symbol.asyncIterator]);
-    getStreamIterator = (source) => {
-      if (isAsyncIterable(source)) {
-        return source;
-      }
-      if (isFunction(source.getReader)) {
-        return readStream(source);
-      }
-      throw new TypeError("Unsupported data source: Expected either ReadableStream or async iterable.");
-    };
+async function* chunkStream(stream2) {
+  for await (const value of stream2) {
+    yield* chunk(value);
   }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/createBoundary.js
+}
 function createBoundary() {
   let size = 16;
   let res = "";
@@ -22630,28 +23662,7 @@ function createBoundary() {
   }
   return res;
 }
-var alphabet;
-var init_createBoundary = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/createBoundary.js"() {
-    alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
-  }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/normalizeValue.js
-var normalizeValue;
-var init_normalizeValue = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/normalizeValue.js"() {
-    normalizeValue = (value) => String(value).replace(/\r|\n/g, (match, i, str) => {
-      if (match === "\r" && str[i + 1] !== "\n" || match === "\n" && str[i - 1] !== "\r") {
-        return "\r\n";
-      }
-      return match;
-    });
-  }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/isPlainObject.js
-function isPlainObject(value) {
+function isPlainObject2(value) {
   if (getType(value) !== "object") {
     return false;
   }
@@ -22662,14 +23673,6 @@ function isPlainObject(value) {
   const Ctor = pp.constructor && pp.constructor.toString();
   return Ctor === Object.toString();
 }
-var getType;
-var init_isPlainObject = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/isPlainObject.js"() {
-    getType = (value) => Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
-  }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/proxyHeaders.js
 function getProperty(target, prop) {
   if (typeof prop === "string") {
     for (const [name, value] of Object.entries(target)) {
@@ -22680,90 +23683,88 @@ function getProperty(target, prop) {
   }
   return void 0;
 }
-var proxyHeaders;
-var init_proxyHeaders = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/proxyHeaders.js"() {
-    proxyHeaders = (object) => new Proxy(object, {
-      get: (target, prop) => getProperty(target, prop),
-      has: (target, prop) => getProperty(target, prop) !== void 0
+var __accessCheck, __privateGet, __privateAdd, __privateSet, __privateMethod, isFunction2, isAsyncIterable3, MAX_CHUNK_SIZE, getStreamIterator, alphabet, normalizeValue, getType, proxyHeaders, isFormData2, escapeName, isFile, defaultOptions, readonlyProp, _CRLF, _CRLF_BYTES, _CRLF_BYTES_LENGTH, _DASHES, _encoder, _footer, _form, _options, _getFieldHeader, getFieldHeader_fn, _getContentLength, getContentLength_fn, FormDataEncoder;
+var init_lib = __esm({
+  "node_modules/.pnpm/form-data-encoder@4.0.2/node_modules/form-data-encoder/lib/index.js"() {
+    __accessCheck = (obj, member, msg) => {
+      if (!member.has(obj))
+        throw TypeError("Cannot " + msg);
+    };
+    __privateGet = (obj, member, getter) => {
+      __accessCheck(obj, member, "read from private field");
+      return getter ? getter.call(obj) : member.get(obj);
+    };
+    __privateAdd = (obj, member, value) => {
+      if (member.has(obj))
+        throw TypeError("Cannot add the same private member more than once");
+      member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+    };
+    __privateSet = (obj, member, value, setter) => {
+      __accessCheck(obj, member, "write to private field");
+      setter ? setter.call(obj, value) : member.set(obj, value);
+      return value;
+    };
+    __privateMethod = (obj, member, method) => {
+      __accessCheck(obj, member, "access private method");
+      return method;
+    };
+    isFunction2 = (value) => typeof value === "function";
+    isAsyncIterable3 = (value) => isFunction2(value[Symbol.asyncIterator]);
+    MAX_CHUNK_SIZE = 65536;
+    getStreamIterator = (source) => {
+      if (isAsyncIterable3(source)) {
+        return chunkStream(source);
+      }
+      if (isFunction2(source.getReader)) {
+        return chunkStream(readStream(source));
+      }
+      throw new TypeError(
+        "Unsupported data source: Expected either ReadableStream or async iterable."
+      );
+    };
+    alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+    normalizeValue = (value) => String(value).replace(/\r|\n/g, (match, i, str) => {
+      if (match === "\r" && str[i + 1] !== "\n" || match === "\n" && str[i - 1] !== "\r") {
+        return "\r\n";
+      }
+      return match;
     });
-  }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/isFormData.js
-var isFormData;
-var init_isFormData = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/isFormData.js"() {
-    init_isFunction();
-    isFormData = (value) => Boolean(value && isFunction(value.constructor) && value[Symbol.toStringTag] === "FormData" && isFunction(value.append) && isFunction(value.getAll) && isFunction(value.entries) && isFunction(value[Symbol.iterator]));
-  }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/escapeName.js
-var escapeName;
-var init_escapeName = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/escapeName.js"() {
+    getType = (value) => Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
+    proxyHeaders = (object) => new Proxy(
+      object,
+      {
+        get: (target, prop) => getProperty(target, prop),
+        has: (target, prop) => getProperty(target, prop) !== void 0
+      }
+    );
+    isFormData2 = (value) => Boolean(
+      value && isFunction2(value.constructor) && value[Symbol.toStringTag] === "FormData" && isFunction2(value.append) && isFunction2(value.getAll) && isFunction2(value.entries) && isFunction2(value[Symbol.iterator])
+    );
     escapeName = (name) => String(name).replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/"/g, "%22");
-  }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/isFile.js
-var isFile;
-var init_isFile = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/util/isFile.js"() {
-    init_isFunction();
-    isFile = (value) => Boolean(value && typeof value === "object" && isFunction(value.constructor) && value[Symbol.toStringTag] === "File" && isFunction(value.stream) && value.name != null);
-  }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/FormDataEncoder.js
-var __classPrivateFieldSet, __classPrivateFieldGet, _FormDataEncoder_instances, _FormDataEncoder_CRLF, _FormDataEncoder_CRLF_BYTES, _FormDataEncoder_CRLF_BYTES_LENGTH, _FormDataEncoder_DASHES, _FormDataEncoder_encoder, _FormDataEncoder_footer, _FormDataEncoder_form, _FormDataEncoder_options, _FormDataEncoder_getFieldHeader, _FormDataEncoder_getContentLength, defaultOptions, readonlyProp, FormDataEncoder;
-var init_FormDataEncoder = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/FormDataEncoder.js"() {
-    init_getStreamIterator();
-    init_createBoundary();
-    init_normalizeValue();
-    init_isPlainObject();
-    init_proxyHeaders();
-    init_isFormData();
-    init_escapeName();
-    init_isFile();
-    __classPrivateFieldSet = function(receiver, state, value, kind, f) {
-      if (kind === "m")
-        throw new TypeError("Private method is not writable");
-      if (kind === "a" && !f)
-        throw new TypeError("Private accessor was defined without a setter");
-      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-        throw new TypeError("Cannot write private member to an object whose class did not declare it");
-      return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
-    };
-    __classPrivateFieldGet = function(receiver, state, kind, f) {
-      if (kind === "a" && !f)
-        throw new TypeError("Private accessor was defined without a getter");
-      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-        throw new TypeError("Cannot read private member from an object whose class did not declare it");
-      return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-    };
+    isFile = (value) => Boolean(
+      value && typeof value === "object" && isFunction2(value.constructor) && value[Symbol.toStringTag] === "File" && isFunction2(value.stream) && value.name != null
+    );
     defaultOptions = {
       enableAdditionalHeaders: false
     };
     readonlyProp = { writable: false, configurable: false };
     FormDataEncoder = class {
       constructor(form, boundaryOrOptions, options) {
-        _FormDataEncoder_instances.add(this);
-        _FormDataEncoder_CRLF.set(this, "\r\n");
-        _FormDataEncoder_CRLF_BYTES.set(this, void 0);
-        _FormDataEncoder_CRLF_BYTES_LENGTH.set(this, void 0);
-        _FormDataEncoder_DASHES.set(this, "-".repeat(2));
-        _FormDataEncoder_encoder.set(this, new TextEncoder());
-        _FormDataEncoder_footer.set(this, void 0);
-        _FormDataEncoder_form.set(this, void 0);
-        _FormDataEncoder_options.set(this, void 0);
-        if (!isFormData(form)) {
+        __privateAdd(this, _getFieldHeader);
+        __privateAdd(this, _getContentLength);
+        __privateAdd(this, _CRLF, "\r\n");
+        __privateAdd(this, _CRLF_BYTES, void 0);
+        __privateAdd(this, _CRLF_BYTES_LENGTH, void 0);
+        __privateAdd(this, _DASHES, "-".repeat(2));
+        __privateAdd(this, _encoder, new TextEncoder());
+        __privateAdd(this, _footer, void 0);
+        __privateAdd(this, _form, void 0);
+        __privateAdd(this, _options, void 0);
+        if (!isFormData2(form)) {
           throw new TypeError("Expected first argument to be a FormData instance.");
         }
         let boundary;
-        if (isPlainObject(boundaryOrOptions)) {
+        if (isPlainObject2(boundaryOrOptions)) {
           options = boundaryOrOptions;
         } else {
           boundary = boundaryOrOptions;
@@ -22774,20 +23775,22 @@ var init_FormDataEncoder = __esm({
         if (typeof boundary !== "string") {
           throw new TypeError("Expected boundary argument to be a string.");
         }
-        if (options && !isPlainObject(options)) {
+        if (options && !isPlainObject2(options)) {
           throw new TypeError("Expected options argument to be an object.");
         }
-        __classPrivateFieldSet(this, _FormDataEncoder_form, Array.from(form.entries()), "f");
-        __classPrivateFieldSet(this, _FormDataEncoder_options, { ...defaultOptions, ...options }, "f");
-        __classPrivateFieldSet(this, _FormDataEncoder_CRLF_BYTES, __classPrivateFieldGet(this, _FormDataEncoder_encoder, "f").encode(__classPrivateFieldGet(this, _FormDataEncoder_CRLF, "f")), "f");
-        __classPrivateFieldSet(this, _FormDataEncoder_CRLF_BYTES_LENGTH, __classPrivateFieldGet(this, _FormDataEncoder_CRLF_BYTES, "f").byteLength, "f");
+        __privateSet(this, _form, Array.from(form.entries()));
+        __privateSet(this, _options, { ...defaultOptions, ...options });
+        __privateSet(this, _CRLF_BYTES, __privateGet(this, _encoder).encode(__privateGet(this, _CRLF)));
+        __privateSet(this, _CRLF_BYTES_LENGTH, __privateGet(this, _CRLF_BYTES).byteLength);
         this.boundary = `form-data-boundary-${boundary}`;
         this.contentType = `multipart/form-data; boundary=${this.boundary}`;
-        __classPrivateFieldSet(this, _FormDataEncoder_footer, __classPrivateFieldGet(this, _FormDataEncoder_encoder, "f").encode(`${__classPrivateFieldGet(this, _FormDataEncoder_DASHES, "f")}${this.boundary}${__classPrivateFieldGet(this, _FormDataEncoder_DASHES, "f")}${__classPrivateFieldGet(this, _FormDataEncoder_CRLF, "f").repeat(2)}`), "f");
+        __privateSet(this, _footer, __privateGet(this, _encoder).encode(
+          `${__privateGet(this, _DASHES)}${this.boundary}${__privateGet(this, _DASHES)}${__privateGet(this, _CRLF).repeat(2)}`
+        ));
         const headers = {
           "Content-Type": this.contentType
         };
-        const contentLength = __classPrivateFieldGet(this, _FormDataEncoder_instances, "m", _FormDataEncoder_getContentLength).call(this);
+        const contentLength = __privateMethod(this, _getContentLength, getContentLength_fn).call(this);
         if (contentLength) {
           this.contentLength = contentLength;
           headers["Content-Length"] = contentLength;
@@ -22800,97 +23803,166 @@ var init_FormDataEncoder = __esm({
           headers: readonlyProp
         });
       }
-      getContentLength() {
-        return this.contentLength == null ? void 0 : Number(this.contentLength);
-      }
+      /**
+       * Creates an iterator allowing to go through form-data parts (with metadata).
+       * This method **will not** read the files and **will not** split values big into smaller chunks.
+       *
+       * Using this method, you can convert form-data content into Blob:
+       *
+       * @example
+       *
+       * ```ts
+       * import {Readable} from "stream"
+       *
+       * import {FormDataEncoder} from "form-data-encoder"
+       *
+       * import {FormData} from "formdata-polyfill/esm-min.js"
+       * import {fileFrom} from "fetch-blob/form.js"
+       * import {File} from "fetch-blob/file.js"
+       * import {Blob} from "fetch-blob"
+       *
+       * import fetch from "node-fetch"
+       *
+       * const form = new FormData()
+       *
+       * form.set("field", "Just a random string")
+       * form.set("file", new File(["Using files is class amazing"]))
+       * form.set("fileFromPath", await fileFrom("path/to/a/file.txt"))
+       *
+       * const encoder = new FormDataEncoder(form)
+       *
+       * const options = {
+       *   method: "post",
+       *   body: new Blob(encoder, {type: encoder.contentType})
+       * }
+       *
+       * const response = await fetch("https://httpbin.org/post", options)
+       *
+       * console.log(await response.json())
+       * ```
+       */
       *values() {
-        for (const [name, raw] of __classPrivateFieldGet(this, _FormDataEncoder_form, "f")) {
-          const value = isFile(raw) ? raw : __classPrivateFieldGet(this, _FormDataEncoder_encoder, "f").encode(normalizeValue(raw));
-          yield __classPrivateFieldGet(this, _FormDataEncoder_instances, "m", _FormDataEncoder_getFieldHeader).call(this, name, value);
+        for (const [name, raw] of __privateGet(this, _form)) {
+          const value = isFile(raw) ? raw : __privateGet(this, _encoder).encode(
+            normalizeValue(raw)
+          );
+          yield __privateMethod(this, _getFieldHeader, getFieldHeader_fn).call(this, name, value);
           yield value;
-          yield __classPrivateFieldGet(this, _FormDataEncoder_CRLF_BYTES, "f");
+          yield __privateGet(this, _CRLF_BYTES);
         }
-        yield __classPrivateFieldGet(this, _FormDataEncoder_footer, "f");
+        yield __privateGet(this, _footer);
       }
+      /**
+       * Creates an async iterator allowing to perform the encoding by portions.
+       * This method reads through files and splits big values into smaller pieces (65536 bytes per each).
+       *
+       * @example
+       *
+       * ```ts
+       * import {Readable} from "stream"
+       *
+       * import {FormData, File, fileFromPath} from "formdata-node"
+       * import {FormDataEncoder} from "form-data-encoder"
+       *
+       * import fetch from "node-fetch"
+       *
+       * const form = new FormData()
+       *
+       * form.set("field", "Just a random string")
+       * form.set("file", new File(["Using files is class amazing"], "file.txt"))
+       * form.set("fileFromPath", await fileFromPath("path/to/a/file.txt"))
+       *
+       * const encoder = new FormDataEncoder(form)
+       *
+       * const options = {
+       *   method: "post",
+       *   headers: encoder.headers,
+       *   body: Readable.from(encoder.encode()) // or Readable.from(encoder)
+       * }
+       *
+       * const response = await fetch("https://httpbin.org/post", options)
+       *
+       * console.log(await response.json())
+       * ```
+       */
       async *encode() {
         for (const part of this.values()) {
           if (isFile(part)) {
             yield* getStreamIterator(part.stream());
           } else {
-            yield part;
+            yield* chunk(part);
           }
         }
       }
-      [(_FormDataEncoder_CRLF = /* @__PURE__ */ new WeakMap(), _FormDataEncoder_CRLF_BYTES = /* @__PURE__ */ new WeakMap(), _FormDataEncoder_CRLF_BYTES_LENGTH = /* @__PURE__ */ new WeakMap(), _FormDataEncoder_DASHES = /* @__PURE__ */ new WeakMap(), _FormDataEncoder_encoder = /* @__PURE__ */ new WeakMap(), _FormDataEncoder_footer = /* @__PURE__ */ new WeakMap(), _FormDataEncoder_form = /* @__PURE__ */ new WeakMap(), _FormDataEncoder_options = /* @__PURE__ */ new WeakMap(), _FormDataEncoder_instances = /* @__PURE__ */ new WeakSet(), _FormDataEncoder_getFieldHeader = function _FormDataEncoder_getFieldHeader2(name, value) {
-        let header = "";
-        header += `${__classPrivateFieldGet(this, _FormDataEncoder_DASHES, "f")}${this.boundary}${__classPrivateFieldGet(this, _FormDataEncoder_CRLF, "f")}`;
-        header += `Content-Disposition: form-data; name="${escapeName(name)}"`;
-        if (isFile(value)) {
-          header += `; filename="${escapeName(value.name)}"${__classPrivateFieldGet(this, _FormDataEncoder_CRLF, "f")}`;
-          header += `Content-Type: ${value.type || "application/octet-stream"}`;
-        }
-        const size = isFile(value) ? value.size : value.byteLength;
-        if (__classPrivateFieldGet(this, _FormDataEncoder_options, "f").enableAdditionalHeaders === true && size != null && !isNaN(size)) {
-          header += `${__classPrivateFieldGet(this, _FormDataEncoder_CRLF, "f")}Content-Length: ${isFile(value) ? value.size : value.byteLength}`;
-        }
-        return __classPrivateFieldGet(this, _FormDataEncoder_encoder, "f").encode(`${header}${__classPrivateFieldGet(this, _FormDataEncoder_CRLF, "f").repeat(2)}`);
-      }, _FormDataEncoder_getContentLength = function _FormDataEncoder_getContentLength2() {
-        let length = 0;
-        for (const [name, raw] of __classPrivateFieldGet(this, _FormDataEncoder_form, "f")) {
-          const value = isFile(raw) ? raw : __classPrivateFieldGet(this, _FormDataEncoder_encoder, "f").encode(normalizeValue(raw));
-          const size = isFile(value) ? value.size : value.byteLength;
-          if (size == null || isNaN(size)) {
-            return void 0;
-          }
-          length += __classPrivateFieldGet(this, _FormDataEncoder_instances, "m", _FormDataEncoder_getFieldHeader).call(this, name, value).byteLength;
-          length += size;
-          length += __classPrivateFieldGet(this, _FormDataEncoder_CRLF_BYTES_LENGTH, "f");
-        }
-        return String(length + __classPrivateFieldGet(this, _FormDataEncoder_footer, "f").byteLength);
-      }, Symbol.iterator)]() {
+      /**
+       * Creates an iterator allowing to read through the encoder data using for...of loops
+       */
+      [Symbol.iterator]() {
         return this.values();
       }
+      /**
+       * Creates an **async** iterator allowing to read through the encoder data using for-await...of loops
+       */
       [Symbol.asyncIterator]() {
         return this.encode();
       }
     };
+    _CRLF = /* @__PURE__ */ new WeakMap();
+    _CRLF_BYTES = /* @__PURE__ */ new WeakMap();
+    _CRLF_BYTES_LENGTH = /* @__PURE__ */ new WeakMap();
+    _DASHES = /* @__PURE__ */ new WeakMap();
+    _encoder = /* @__PURE__ */ new WeakMap();
+    _footer = /* @__PURE__ */ new WeakMap();
+    _form = /* @__PURE__ */ new WeakMap();
+    _options = /* @__PURE__ */ new WeakMap();
+    _getFieldHeader = /* @__PURE__ */ new WeakSet();
+    getFieldHeader_fn = function(name, value) {
+      let header = "";
+      header += `${__privateGet(this, _DASHES)}${this.boundary}${__privateGet(this, _CRLF)}`;
+      header += `Content-Disposition: form-data; name="${escapeName(name)}"`;
+      if (isFile(value)) {
+        header += `; filename="${escapeName(value.name)}"${__privateGet(this, _CRLF)}`;
+        header += `Content-Type: ${value.type || "application/octet-stream"}`;
+      }
+      if (__privateGet(this, _options).enableAdditionalHeaders === true) {
+        const size = isFile(value) ? value.size : value.byteLength;
+        if (size != null && !isNaN(size)) {
+          header += `${__privateGet(this, _CRLF)}Content-Length: ${size}`;
+        }
+      }
+      return __privateGet(this, _encoder).encode(`${header}${__privateGet(this, _CRLF).repeat(2)}`);
+    };
+    _getContentLength = /* @__PURE__ */ new WeakSet();
+    getContentLength_fn = function() {
+      let length = 0;
+      for (const [name, raw] of __privateGet(this, _form)) {
+        const value = isFile(raw) ? raw : __privateGet(this, _encoder).encode(
+          normalizeValue(raw)
+        );
+        const size = isFile(value) ? value.size : value.byteLength;
+        if (size == null || isNaN(size)) {
+          return void 0;
+        }
+        length += __privateMethod(this, _getFieldHeader, getFieldHeader_fn).call(this, name, value).byteLength;
+        length += size;
+        length += __privateGet(this, _CRLF_BYTES_LENGTH);
+      }
+      return String(length + __privateGet(this, _footer).byteLength);
+    };
   }
 });
 
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/FileLike.js
-var init_FileLike = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/FileLike.js"() {
-  }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/FormDataLike.js
-var init_FormDataLike = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/FormDataLike.js"() {
-  }
-});
-
-// node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/index.js
-var init_lib = __esm({
-  "node_modules/.pnpm/form-data-encoder@2.1.4/node_modules/form-data-encoder/lib/index.js"() {
-    init_FormDataEncoder();
-    init_FileLike();
-    init_FormDataLike();
-    init_isFile();
-    init_isFormData();
-  }
-});
-
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/is-form-data.js
-function isFormData2(body) {
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/is-form-data.js
+function isFormData3(body) {
   return dist_default.nodeStream(body) && dist_default.function_(body.getBoundary);
 }
 var init_is_form_data = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/is-form-data.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/is-form-data.js"() {
     init_dist();
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/get-body-size.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/get-body-size.js
 import { Buffer as Buffer2 } from "node:buffer";
 import { promisify } from "node:util";
 async function getBodySize(body, headers) {
@@ -22906,19 +23978,19 @@ async function getBodySize(body, headers) {
   if (dist_default.buffer(body)) {
     return body.length;
   }
-  if (isFormData2(body)) {
+  if (isFormData3(body)) {
     return promisify(body.getLength.bind(body))();
   }
   return void 0;
 }
 var init_get_body_size = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/get-body-size.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/get-body-size.js"() {
     init_dist();
     init_is_form_data();
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/proxy-events.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/proxy-events.js
 function proxyEvents(from, to, events) {
   const eventFunctions = {};
   for (const event of events) {
@@ -22935,11 +24007,11 @@ function proxyEvents(from, to, events) {
   };
 }
 var init_proxy_events = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/proxy-events.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/proxy-events.js"() {
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/unhandle.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/unhandle.js
 function unhandle() {
   const handlers = [];
   return {
@@ -22957,15 +24029,15 @@ function unhandle() {
   };
 }
 var init_unhandle = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/unhandle.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/unhandle.js"() {
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/timed-out.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/timed-out.js
 import net from "node:net";
 function timedOut(request, delays, options) {
   if (reentry in request) {
-    return noop;
+    return noop2;
   }
   request[reentry] = true;
   const cancelers = [];
@@ -22995,13 +24067,13 @@ function timedOut(request, delays, options) {
       throw error2;
     }
   });
-  if (typeof delays.request !== "undefined") {
+  if (delays.request !== void 0) {
     const cancelTimeout = addTimeout(delays.request, timeoutHandler, "request");
     once(request, "response", (response) => {
       once(response, "end", cancelTimeout);
     });
   }
-  if (typeof delays.socket !== "undefined") {
+  if (delays.socket !== void 0) {
     const { socket } = delays;
     const socketTimeoutHandler = () => {
       timeoutHandler(socket, "socket");
@@ -23011,16 +24083,16 @@ function timedOut(request, delays, options) {
       request.removeListener("timeout", socketTimeoutHandler);
     });
   }
-  const hasLookup = typeof delays.lookup !== "undefined";
-  const hasConnect = typeof delays.connect !== "undefined";
-  const hasSecureConnect = typeof delays.secureConnect !== "undefined";
-  const hasSend = typeof delays.send !== "undefined";
+  const hasLookup = delays.lookup !== void 0;
+  const hasConnect = delays.connect !== void 0;
+  const hasSecureConnect = delays.secureConnect !== void 0;
+  const hasSend = delays.send !== void 0;
   if (hasLookup || hasConnect || hasSecureConnect || hasSend) {
     once(request, "socket", (socket) => {
       const { socketPath } = request;
       if (socket.connecting) {
         const hasPath = Boolean(socketPath ?? net.isIP(hostname ?? host ?? "") !== 0);
-        if (hasLookup && !hasPath && typeof socket.address().address === "undefined") {
+        if (hasLookup && !hasPath && socket.address().address === void 0) {
           const cancelTimeout = addTimeout(delays.lookup, timeoutHandler, "lookup");
           once(socket, "lookup", cancelTimeout);
         }
@@ -23055,13 +24127,13 @@ function timedOut(request, delays, options) {
       }
     });
   }
-  if (typeof delays.response !== "undefined") {
+  if (delays.response !== void 0) {
     once(request, "upload-complete", () => {
       const cancelTimeout = addTimeout(delays.response, timeoutHandler, "response");
       once(request, "response", cancelTimeout);
     });
   }
-  if (typeof delays.read !== "undefined") {
+  if (delays.read !== void 0) {
     once(request, "response", (response) => {
       const cancelTimeout = addTimeout(delays.read, timeoutHandler, "read");
       once(response, "end", cancelTimeout);
@@ -23069,28 +24141,19 @@ function timedOut(request, delays, options) {
   }
   return cancelTimeouts;
 }
-var reentry, noop, TimeoutError2;
+var reentry, noop2, TimeoutError2;
 var init_timed_out = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/timed-out.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/timed-out.js"() {
     init_unhandle();
     reentry = Symbol("reentry");
-    noop = () => {
+    noop2 = () => {
     };
     TimeoutError2 = class extends Error {
+      event;
+      code;
       constructor(threshold, event) {
         super(`Timeout awaiting '${event}' for ${threshold}ms`);
-        Object.defineProperty(this, "event", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: event
-        });
-        Object.defineProperty(this, "code", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
+        this.event = event;
         this.name = "TimeoutError";
         this.code = "ETIMEDOUT";
       }
@@ -23098,7 +24161,7 @@ var init_timed_out = __esm({
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/url-to-options.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/url-to-options.js
 function urlToOptions(url) {
   url = url;
   const options = {
@@ -23120,29 +24183,19 @@ function urlToOptions(url) {
   return options;
 }
 var init_url_to_options = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/url-to-options.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/url-to-options.js"() {
     init_dist();
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/weakable-map.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/weakable-map.js
 var WeakableMap;
 var init_weakable_map = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/weakable-map.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/weakable-map.js"() {
     WeakableMap = class {
+      weakMap;
+      map;
       constructor() {
-        Object.defineProperty(this, "weakMap", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "map", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
         this.weakMap = /* @__PURE__ */ new WeakMap();
         this.map = /* @__PURE__ */ new Map();
       }
@@ -23169,10 +24222,10 @@ var init_weakable_map = __esm({
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/calculate-retry-delay.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/calculate-retry-delay.js
 var calculateRetryDelay, calculate_retry_delay_default;
 var init_calculate_retry_delay = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/calculate-retry-delay.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/calculate-retry-delay.js"() {
     calculateRetryDelay = ({ attemptCount, retryOptions, error: error2, retryAfter, computedValue }) => {
       if (error2.name === "RetryError") {
         return 1;
@@ -23214,8 +24267,8 @@ import {
 } from "node:dns";
 import { promisify as promisify2 } from "node:util";
 import os from "node:os";
-var AsyncResolver, kCacheableLookupCreateConnection, kCacheableLookupInstance, kExpires, supportsALL, verifyAgent, map4to6, getIfaceInfo, isIterable, ignoreNoResultErrors, ttl, all, all4, all6, CacheableLookup;
-var init_source2 = __esm({
+var AsyncResolver, kCacheableLookupCreateConnection, kCacheableLookupInstance, kExpires, supportsALL, verifyAgent, map4to6, getIfaceInfo, isIterable2, ignoreNoResultErrors, ttl, all, all4, all6, CacheableLookup;
+var init_source3 = __esm({
   "node_modules/.pnpm/cacheable-lookup@7.0.0/node_modules/cacheable-lookup/source/index.js"() {
     ({ Resolver: AsyncResolver } = dnsPromises);
     kCacheableLookupCreateConnection = Symbol("cacheableLookupCreateConnection");
@@ -23256,7 +24309,7 @@ var init_source2 = __esm({
       }
       return { has4, has6 };
     };
-    isIterable = (map) => {
+    isIterable2 = (map) => {
       return Symbol.iterator in map;
     };
     ignoreNoResultErrors = (dnsPromise) => {
@@ -23475,7 +24528,7 @@ var init_source2 = __esm({
               throw cacheError;
             };
           }
-          if (isIterable(this._cache)) {
+          if (isIterable2(this._cache)) {
             this._tick(cacheTtl);
           }
         }
@@ -23670,9 +24723,9 @@ var require_quick_lru = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/delay-async-destroy.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/delay-async-destroy.js
 var require_delay_async_destroy = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/delay-async-destroy.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/delay-async-destroy.js"(exports, module) {
     "use strict";
     module.exports = (stream2) => {
       if (stream2.listenerCount("error") !== 0) {
@@ -23700,11 +24753,11 @@ var require_delay_async_destroy = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/agent.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/agent.js
 var require_agent = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/agent.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/agent.js"(exports, module) {
     "use strict";
-    var { URL: URL4 } = __require("url");
+    var { URL: URL2 } = __require("url");
     var EventEmitter3 = __require("events");
     var tls = __require("tls");
     var http22 = __require("http2");
@@ -23874,8 +24927,8 @@ var require_agent = __commonJS({
           }
           try {
             if (typeof origin === "string") {
-              origin = new URL4(origin);
-            } else if (!(origin instanceof URL4)) {
+              origin = new URL2(origin);
+            } else if (!(origin instanceof URL2)) {
               throw new TypeError("The `origin` argument needs to be a string or an URL object");
             }
             if (options) {
@@ -24238,9 +25291,9 @@ var require_agent = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/incoming-message.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/incoming-message.js
 var require_incoming_message = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/incoming-message.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/incoming-message.js"(exports, module) {
     "use strict";
     var { Readable } = __require("stream");
     var IncomingMessage = class extends Readable {
@@ -24300,9 +25353,9 @@ var require_incoming_message = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/proxy-events.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/proxy-events.js
 var require_proxy_events = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/proxy-events.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/proxy-events.js"(exports, module) {
     "use strict";
     module.exports = (from, to, events) => {
       for (const event of events) {
@@ -24312,9 +25365,9 @@ var require_proxy_events = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/errors.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/errors.js
 var require_errors = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/errors.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/errors.js"(exports, module) {
     "use strict";
     var makeError = (Base, key, getMessage) => {
       module.exports[key] = class NodeError extends Base {
@@ -24367,9 +25420,9 @@ var require_errors = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/is-request-pseudo-header.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/is-request-pseudo-header.js
 var require_is_request_pseudo_header = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/is-request-pseudo-header.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/is-request-pseudo-header.js"(exports, module) {
     "use strict";
     module.exports = (header) => {
       switch (header) {
@@ -24385,9 +25438,9 @@ var require_is_request_pseudo_header = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/validate-header-name.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/validate-header-name.js
 var require_validate_header_name = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/validate-header-name.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/validate-header-name.js"(exports, module) {
     "use strict";
     var { ERR_INVALID_HTTP_TOKEN } = require_errors();
     var isRequestPseudoHeader = require_is_request_pseudo_header();
@@ -24400,9 +25453,9 @@ var require_validate_header_name = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/validate-header-value.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/validate-header-value.js
 var require_validate_header_value = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/validate-header-value.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/validate-header-value.js"(exports, module) {
     "use strict";
     var {
       ERR_HTTP_INVALID_HEADER_VALUE,
@@ -24420,9 +25473,9 @@ var require_validate_header_value = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/proxy-socket-handler.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/proxy-socket-handler.js
 var require_proxy_socket_handler = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/proxy-socket-handler.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/proxy-socket-handler.js"(exports, module) {
     "use strict";
     var { ERR_HTTP2_NO_SOCKET_MANIPULATION } = require_errors();
     var proxySocketHandler = {
@@ -24509,11 +25562,11 @@ var require_proxy_socket_handler = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/client-request.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/client-request.js
 var require_client_request = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/client-request.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/client-request.js"(exports, module) {
     "use strict";
-    var { URL: URL4, urlToHttpOptions } = __require("url");
+    var { URL: URL2, urlToHttpOptions } = __require("url");
     var http22 = __require("http2");
     var { Writable } = __require("stream");
     var { Agent, globalAgent } = require_agent();
@@ -24548,8 +25601,8 @@ var require_client_request = __commonJS({
           emitClose: false
         });
         if (typeof input === "string") {
-          input = urlToHttpOptions(new URL4(input));
-        } else if (input instanceof URL4) {
+          input = urlToHttpOptions(new URL2(input));
+        } else if (input instanceof URL2) {
           input = urlToHttpOptions(input);
         } else {
           input = { ...input };
@@ -24612,7 +25665,7 @@ var require_client_request = __commonJS({
         options.session = options.tlsSession;
         options.path = options.socketPath;
         this[kOptions] = options;
-        this[kOrigin] = new URL4(`${this.protocol}//${options.servername || options.host}:${options.port}`);
+        this[kOrigin] = new URL2(`${this.protocol}//${options.servername || options.host}:${options.port}`);
         const reuseSocket = options._reuseSocket;
         if (reuseSocket) {
           options.createConnection = (...args) => {
@@ -24658,13 +25711,13 @@ var require_client_request = __commonJS({
       get _mustNotHaveABody() {
         return this.method === "GET" || this.method === "HEAD" || this.method === "DELETE";
       }
-      _write(chunk, encoding, callback) {
+      _write(chunk2, encoding, callback) {
         if (this._mustNotHaveABody) {
           callback(new Error("The GET, HEAD and DELETE methods must NOT have a body"));
           return;
         }
         this.flushHeaders();
-        const callWrite = () => this._request.write(chunk, encoding, callback);
+        const callWrite = () => this._request.write(chunk2, encoding, callback);
         if (this._request) {
           callWrite();
         } else {
@@ -24765,8 +25818,8 @@ var require_client_request = __commonJS({
                 stream2.destroy();
               }
             } else {
-              stream2.on("data", (chunk) => {
-                if (!response._dumped && !response.push(chunk)) {
+              stream2.on("data", (chunk2) => {
+                if (!response._dumped && !response.push(chunk2)) {
                   stream2.pause();
                 }
               });
@@ -24966,9 +26019,9 @@ var require_resolve_alpn = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/calculate-server-name.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/calculate-server-name.js
 var require_calculate_server_name = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/calculate-server-name.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/calculate-server-name.js"(exports, module) {
     "use strict";
     var { isIP } = __require("net");
     var assert2 = __require("assert");
@@ -24994,11 +26047,11 @@ var require_calculate_server_name = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/auto.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/auto.js
 var require_auto = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/auto.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/auto.js"(exports, module) {
     "use strict";
-    var { URL: URL4, urlToHttpOptions } = __require("url");
+    var { URL: URL2, urlToHttpOptions } = __require("url");
     var http3 = __require("http");
     var https2 = __require("https");
     var resolveALPN = require_resolve_alpn();
@@ -25069,8 +26122,8 @@ var require_auto = __commonJS({
     var defaultResolveProtocol = createResolveProtocol(cache, queue);
     module.exports = async (input, options, callback) => {
       if (typeof input === "string") {
-        input = urlToHttpOptions(new URL4(input));
-      } else if (input instanceof URL4) {
+        input = urlToHttpOptions(new URL2(input));
+      } else if (input instanceof URL2) {
         input = urlToHttpOptions(input);
       } else {
         input = { ...input };
@@ -25144,6 +26197,18 @@ var require_auto = __commonJS({
       } else if (agent) {
         options.agent = agent.http;
       }
+      if (options.headers) {
+        options.headers = { ...options.headers };
+        if (options.headers[":authority"]) {
+          if (!options.headers.host) {
+            options.headers.host = options.headers[":authority"];
+          }
+          delete options.headers[":authority"];
+        }
+        delete options.headers[":method"];
+        delete options.headers[":scheme"];
+        delete options.headers[":path"];
+      }
       return delayAsyncDestroy(http3.request(options, callback));
     };
     module.exports.protocolCache = cache;
@@ -25152,9 +26217,9 @@ var require_auto = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/js-stream-socket.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/js-stream-socket.js
 var require_js_stream_socket = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/js-stream-socket.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/js-stream-socket.js"(exports, module) {
     "use strict";
     var stream2 = __require("stream");
     var tls = __require("tls");
@@ -25163,9 +26228,9 @@ var require_js_stream_socket = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/unexpected-status-code-error.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/unexpected-status-code-error.js
 var require_unexpected_status_code_error = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/unexpected-status-code-error.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/unexpected-status-code-error.js"(exports, module) {
     "use strict";
     var UnexpectedStatusCodeError = class extends Error {
       constructor(statusCode, statusMessage = "") {
@@ -25178,9 +26243,9 @@ var require_unexpected_status_code_error = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/check-type.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/check-type.js
 var require_check_type = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/utils/check-type.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/utils/check-type.js"(exports, module) {
     "use strict";
     var checkType = (name, value, types2) => {
       const valid = types2.some((type) => {
@@ -25199,18 +26264,18 @@ var require_check_type = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/initialize.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/initialize.js
 var require_initialize = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/initialize.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/initialize.js"(exports, module) {
     "use strict";
-    var { URL: URL4 } = __require("url");
+    var { URL: URL2 } = __require("url");
     var checkType = require_check_type();
     module.exports = (self, proxyOptions) => {
       checkType("proxyOptions", proxyOptions, ["object"]);
       checkType("proxyOptions.headers", proxyOptions.headers, ["object", "undefined"]);
       checkType("proxyOptions.raw", proxyOptions.raw, ["boolean", "undefined"]);
-      checkType("proxyOptions.url", proxyOptions.url, [URL4, "string"]);
-      const url = new URL4(proxyOptions.url);
+      checkType("proxyOptions.url", proxyOptions.url, [URL2, "string"]);
+      const url = new URL2(proxyOptions.url);
       self.proxyOptions = {
         raw: true,
         ...proxyOptions,
@@ -25221,9 +26286,9 @@ var require_initialize = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/get-auth-headers.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/get-auth-headers.js
 var require_get_auth_headers = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/get-auth-headers.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/get-auth-headers.js"(exports, module) {
     "use strict";
     module.exports = (self) => {
       const { username, password } = self.proxyOptions.url;
@@ -25240,9 +26305,9 @@ var require_get_auth_headers = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/h1-over-h2.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/h1-over-h2.js
 var require_h1_over_h2 = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/h1-over-h2.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/h1-over-h2.js"(exports, module) {
     "use strict";
     var tls = __require("tls");
     var http3 = __require("http");
@@ -25319,9 +26384,9 @@ var require_h1_over_h2 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/h2-over-hx.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/h2-over-hx.js
 var require_h2_over_hx = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/h2-over-hx.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/h2-over-hx.js"(exports, module) {
     "use strict";
     var { Agent } = require_agent();
     var JSStreamSocket = require_js_stream_socket();
@@ -25357,9 +26422,9 @@ var require_h2_over_hx = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/h2-over-h2.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/h2-over-h2.js
 var require_h2_over_h2 = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/h2-over-h2.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/h2-over-h2.js"(exports, module) {
     "use strict";
     var { globalAgent } = require_agent();
     var Http2OverHttpX = require_h2_over_hx();
@@ -25389,15 +26454,15 @@ var require_h2_over_h2 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/h2-over-h1.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/h2-over-h1.js
 var require_h2_over_h1 = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/proxies/h2-over-h1.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/proxies/h2-over-h1.js"(exports, module) {
     "use strict";
     var http3 = __require("http");
     var https2 = __require("https");
     var Http2OverHttpX = require_h2_over_hx();
     var getAuthorizationHeaders = require_get_auth_headers();
-    var getStream3 = (request) => new Promise((resolve, reject) => {
+    var getStream2 = (request) => new Promise((resolve, reject) => {
       const onConnect = (response, socket, head) => {
         socket.unshift(head);
         request.off("error", reject);
@@ -25423,7 +26488,7 @@ var require_h2_over_h1 = __commonJS({
           },
           method: "CONNECT"
         }).end();
-        return getStream3(request);
+        return getStream2(request);
       }
     };
     module.exports = {
@@ -25433,9 +26498,9 @@ var require_h2_over_h1 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/index.js
+// node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/index.js
 var require_source3 = __commonJS({
-  "node_modules/.pnpm/http2-wrapper@2.2.0/node_modules/http2-wrapper/source/index.js"(exports, module) {
+  "node_modules/.pnpm/http2-wrapper@2.2.1/node_modules/http2-wrapper/source/index.js"(exports, module) {
     "use strict";
     var http22 = __require("http2");
     var {
@@ -25484,14 +26549,14 @@ var require_source3 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/parse-link-header.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/parse-link-header.js
 function parseLinkHeader(link) {
   const parsed = [];
   const items = link.split(",");
   for (const item of items) {
     const [rawUriReference, ...rawLinkParameters] = item.split(";");
     const trimmedUriReference = rawUriReference.trim();
-    if (trimmedUriReference[0] !== "<" || trimmedUriReference[trimmedUriReference.length - 1] !== ">") {
+    if (trimmedUriReference[0] !== "<" || trimmedUriReference.at(-1) !== ">") {
       throw new Error(`Invalid format of the Link header reference: ${trimmedUriReference}`);
     }
     const reference = trimmedUriReference.slice(1, -1);
@@ -25517,17 +26582,16 @@ function parseLinkHeader(link) {
   return parsed;
 }
 var init_parse_link_header = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/parse-link-header.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/parse-link-header.js"() {
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/options.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/options.js
 import process2 from "node:process";
 import { promisify as promisify3, inspect } from "node:util";
-import { URL as URL2, URLSearchParams } from "node:url";
 import { checkServerIdentity } from "node:tls";
-import http from "node:http";
 import https from "node:https";
+import http from "node:http";
 function validateSearchParameters(searchParameters) {
   for (const key in searchParameters) {
     const value = searchParameters[key];
@@ -25536,10 +26600,10 @@ function validateSearchParameters(searchParameters) {
 }
 var import_http2_wrapper, major, minor, globalCache, globalDnsCache, getGlobalDnsCache, defaultInternals, cloneInternals, cloneRaw, getHttp2TimeoutOption, init, Options;
 var init_options = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/options.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/options.js"() {
     init_dist();
     init_lowercase_keys();
-    init_source2();
+    init_source3();
     import_http2_wrapper = __toESM(require_source3(), 1);
     init_lib();
     init_parse_link_header();
@@ -25690,7 +26754,7 @@ var init_options = __esm({
           const next = parsed.find((entry) => entry.parameters.rel === "next" || entry.parameters.rel === '"next"');
           if (next) {
             return {
-              url: new URL2(next.reference, response.url)
+              url: new URL(next.reference, response.url)
             };
           }
           return false;
@@ -25705,7 +26769,7 @@ var init_options = __esm({
       setHost: true,
       maxHeaderSize: void 0,
       signal: void 0,
-      enableUnixSockets: true
+      enableUnixSockets: false
     };
     cloneInternals = (internals) => {
       const { hooks, retry } = internals;
@@ -25819,31 +26883,11 @@ var init_options = __esm({
       }
     };
     Options = class _Options {
+      _unixOptions;
+      _internals;
+      _merging;
+      _init;
       constructor(input, options, defaults2) {
-        Object.defineProperty(this, "_unixOptions", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_internals", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_merging", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_init", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
         assert.any([dist_default.string, dist_default.urlInstance, dist_default.object, dist_default.undefined], input);
         assert.any([dist_default.object, dist_default.undefined], options);
         assert.any([dist_default.object, dist_default.undefined], defaults2);
@@ -25911,7 +26955,11 @@ var init_options = __esm({
             if (!(key in this)) {
               throw new Error(`Unexpected option: ${key}`);
             }
-            this[key] = options[key];
+            const value = options[key];
+            if (value === void 0) {
+              continue;
+            }
+            this[key] = value;
             push = true;
           }
           if (push) {
@@ -26103,7 +27151,7 @@ var init_options = __esm({
         return this._internals.body;
       }
       set body(value) {
-        assert.any([dist_default.string, dist_default.buffer, dist_default.nodeStream, dist_default.generator, dist_default.asyncGenerator, isFormData, dist_default.undefined], value);
+        assert.any([dist_default.string, dist_default.buffer, dist_default.nodeStream, dist_default.generator, dist_default.asyncGenerator, isFormData2, dist_default.undefined], value);
         if (dist_default.nodeStream(value)) {
           assert.truthy(value.readable);
         }
@@ -26181,7 +27229,7 @@ var init_options = __esm({
           throw new Error("`url` must not start with a slash");
         }
         const urlString = `${this.prefixUrl}${value.toString()}`;
-        const url = new URL2(urlString);
+        const url = new URL(urlString);
         this._internals.url = url;
         if (url.protocol === "unix:") {
           url.href = `http://unix${url.pathname}${url.search}`;
@@ -26253,8 +27301,6 @@ var init_options = __esm({
       /**
           You can abort the `request` using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
       
-          *Requires Node.js 16 or later.*
-      
           @example
           ```
           import got from 'got';
@@ -26270,11 +27316,9 @@ var init_options = __esm({
           }, 100);
           ```
           */
-      // TODO: Replace `any` with `AbortSignal` when targeting Node 16.
       get signal() {
         return this._internals.signal;
       }
-      // TODO: Replace `any` with `AbortSignal` when targeting Node 16.
       set signal(value) {
         assert.object(value);
         this._internals.signal = value;
@@ -26474,7 +27518,9 @@ var init_options = __esm({
         }
       }
       /**
-          Defines if redirect responses should be followed automatically.
+          Whether redirect responses should be followed automatically.
+      
+          Optionally, pass a function to dynamically decide based on the response object.
       
           Note that if a `303` is sent by the server in response to any request type (`POST`, `DELETE`, etc.), Got will automatically request the resource pointed to in the location header via `GET`.
           This is in accordance with [the spec](https://tools.ietf.org/html/rfc7231#section-6.4.4). You can optionally turn on this behavior also for other redirect codes - see `methodRewriting`.
@@ -26485,7 +27531,7 @@ var init_options = __esm({
         return this._internals.followRedirect;
       }
       set followRedirect(value) {
-        assert.boolean(value);
+        assert.any([dist_default.boolean, dist_default.function_], value);
         this._internals.followRedirect = value;
       }
       get followRedirects() {
@@ -27118,14 +28164,16 @@ var init_options = __esm({
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/response.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/response.js
 var isResponseOk, ParseError, parseBody;
 var init_response = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/response.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/response.js"() {
     init_errors();
     isResponseOk = (response) => {
       const { statusCode } = response;
-      const limitStatusCode = response.request.options.followRedirect ? 299 : 399;
+      const { followRedirect } = response.request.options;
+      const shouldFollow = typeof followRedirect === "function" ? followRedirect(response) : followRedirect;
+      const limitStatusCode = shouldFollow ? 299 : 399;
       return statusCode >= 200 && statusCode <= limitStatusCode || statusCode === 304;
     };
     ParseError = class extends RequestError {
@@ -27159,40 +28207,39 @@ var init_response = __esm({
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/is-client-request.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/is-client-request.js
 function isClientRequest(clientRequest) {
   return clientRequest.writable && !clientRequest.writableEnded;
 }
 var is_client_request_default;
 var init_is_client_request = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/is-client-request.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/is-client-request.js"() {
     is_client_request_default = isClientRequest;
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/is-unix-socket-url.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/is-unix-socket-url.js
 function isUnixSocketURL(url) {
   return url.protocol === "unix:" || url.hostname === "unix";
 }
 var init_is_unix_socket_url = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/utils/is-unix-socket-url.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/utils/is-unix-socket-url.js"() {
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/index.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/index.js
 import process3 from "node:process";
 import { Buffer as Buffer3 } from "node:buffer";
 import { Duplex } from "node:stream";
-import { URL as URL3, URLSearchParams as URLSearchParams2 } from "node:url";
 import http2, { ServerResponse } from "node:http";
-var import_decompress_response, import_get_stream2, getBuffer, supportsBrotli, methodsWithoutBody, cacheableStore, redirectCodes, proxiedRequestEvents, noop2, Request;
+var import_decompress_response, supportsBrotli, methodsWithoutBody, cacheableStore, redirectCodes, proxiedRequestEvents, noop3, Request;
 var init_core = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/core/index.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/core/index.js"() {
     init_source();
     init_dist2();
     import_decompress_response = __toESM(require_decompress_response(), 1);
     init_dist();
-    import_get_stream2 = __toESM(require_get_stream(), 1);
+    init_source2();
     init_lib();
     init_get_body_size();
     init_is_form_data();
@@ -27206,7 +28253,6 @@ var init_core = __esm({
     init_is_client_request();
     init_is_unix_socket_url();
     init_errors();
-    ({ buffer: getBuffer } = import_get_stream2.default);
     supportsBrotli = dist_default.string(process3.versions.brotli);
     methodsWithoutBody = /* @__PURE__ */ new Set(["GET", "HEAD"]);
     cacheableStore = new WeakableMap();
@@ -27218,9 +28264,37 @@ var init_core = __esm({
       "information",
       "upgrade"
     ];
-    noop2 = () => {
+    noop3 = () => {
     };
     Request = class _Request extends Duplex {
+      // @ts-expect-error - Ignoring for now.
+      ["constructor"];
+      _noPipe;
+      // @ts-expect-error https://github.com/microsoft/TypeScript/issues/9568
+      options;
+      response;
+      requestUrl;
+      redirectUrls;
+      retryCount;
+      _stopRetry;
+      _downloadedSize;
+      _uploadedSize;
+      _stopReading;
+      _pipedServerResponses;
+      _request;
+      _responseSize;
+      _bodySize;
+      _unproxyEvents;
+      _isFromCache;
+      _cannotHaveBody;
+      _triggerRead;
+      _cancelTimeouts;
+      _removeListeners;
+      _nativeResponse;
+      _flushed;
+      _aborted;
+      // We need this because `this._request` if `undefined` when using cache
+      _requestInitialized;
       constructor(url, options, defaults2) {
         super({
           // Don't destroy immediately, as the error may be emitted on unsuccessful retry
@@ -27228,172 +28302,22 @@ var init_core = __esm({
           // It needs to be zero because we're just proxying the data to another stream
           highWaterMark: 0
         });
-        Object.defineProperty(this, "constructor", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_noPipe", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "options", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "response", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "requestUrl", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "redirectUrls", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "retryCount", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_stopRetry", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_downloadedSize", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_uploadedSize", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_stopReading", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_pipedServerResponses", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_request", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_responseSize", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_bodySize", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_unproxyEvents", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_isFromCache", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_cannotHaveBody", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_triggerRead", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_cancelTimeouts", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_removeListeners", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_nativeResponse", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_flushed", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_aborted", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "_requestInitialized", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
         this._downloadedSize = 0;
         this._uploadedSize = 0;
         this._stopReading = false;
         this._pipedServerResponses = /* @__PURE__ */ new Set();
         this._cannotHaveBody = false;
-        this._unproxyEvents = noop2;
+        this._unproxyEvents = noop3;
         this._triggerRead = false;
-        this._cancelTimeouts = noop2;
-        this._removeListeners = noop2;
+        this._cancelTimeouts = noop3;
+        this._removeListeners = noop3;
         this._jobs = [];
         this._flushed = false;
         this._requestInitialized = false;
         this._aborted = false;
         this.redirectUrls = [];
         this.retryCount = 0;
-        this._stopRetry = noop2;
+        this._stopRetry = noop3;
         this.on("pipe", (source) => {
           if (source?.headers) {
             Object.assign(this.options.headers, source.headers);
@@ -27448,7 +28372,7 @@ var init_core = __esm({
           } else {
             this.options.signal.addEventListener("abort", abort);
             this._removeListeners = () => {
-              this.options.signal.removeEventListener("abort", abort);
+              this.options.signal?.removeEventListener("abort", abort);
             };
           }
         }
@@ -27584,9 +28508,9 @@ var init_core = __esm({
           }
         }
       }
-      _write(chunk, encoding, callback) {
+      _write(chunk2, encoding, callback) {
         const write = () => {
-          this._writeRequest(chunk, encoding, callback);
+          this._writeRequest(chunk2, encoding, callback);
         };
         if (this._requestInitialized) {
           write();
@@ -27666,7 +28590,7 @@ var init_core = __esm({
           }
           const noContentType = !dist_default.string(headers["content-type"]);
           if (isBody) {
-            if (isFormData(options.body)) {
+            if (isFormData2(options.body)) {
               const encoder = new FormDataEncoder(options.body);
               if (noContentType) {
                 headers["content-type"] = encoder.headers["Content-Type"];
@@ -27676,7 +28600,7 @@ var init_core = __esm({
               }
               options.body = encoder.encode();
             }
-            if (isFormData2(options.body) && noContentType) {
+            if (isFormData3(options.body) && noContentType) {
               headers["content-type"] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
             }
           } else if (isForm) {
@@ -27685,7 +28609,7 @@ var init_core = __esm({
             }
             const { form } = options;
             options.form = void 0;
-            options.body = new URLSearchParams2(form).toString();
+            options.body = new URLSearchParams(form).toString();
           } else {
             if (noContentType) {
               headers["content-type"] = "application/json";
@@ -27767,65 +28691,68 @@ var init_core = __esm({
         if (this.isAborted) {
           return;
         }
-        if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
-          response.resume();
-          this._cancelTimeouts();
-          this._unproxyEvents();
-          if (this.redirectUrls.length >= options.maxRedirects) {
-            this._beforeError(new MaxRedirectsError(this));
-            return;
-          }
-          this._request = void 0;
-          const updatedOptions = new Options(void 0, void 0, this.options);
-          const serverRequestedGet = statusCode === 303 && updatedOptions.method !== "GET" && updatedOptions.method !== "HEAD";
-          const canRewrite = statusCode !== 307 && statusCode !== 308;
-          const userRequestedGet = updatedOptions.methodRewriting && canRewrite;
-          if (serverRequestedGet || userRequestedGet) {
-            updatedOptions.method = "GET";
-            updatedOptions.body = void 0;
-            updatedOptions.json = void 0;
-            updatedOptions.form = void 0;
-            delete updatedOptions.headers["content-length"];
-          }
-          try {
-            const redirectBuffer = Buffer3.from(response.headers.location, "binary").toString();
-            const redirectUrl = new URL3(redirectBuffer, url);
-            if (!isUnixSocketURL(url) && isUnixSocketURL(redirectUrl)) {
-              this._beforeError(new RequestError("Cannot redirect to UNIX socket", {}, this));
+        if (response.headers.location && redirectCodes.has(statusCode)) {
+          const shouldFollow = typeof options.followRedirect === "function" ? options.followRedirect(typedResponse) : options.followRedirect;
+          if (shouldFollow) {
+            response.resume();
+            this._cancelTimeouts();
+            this._unproxyEvents();
+            if (this.redirectUrls.length >= options.maxRedirects) {
+              this._beforeError(new MaxRedirectsError(this));
               return;
             }
-            if (redirectUrl.hostname !== url.hostname || redirectUrl.port !== url.port) {
-              if ("host" in updatedOptions.headers) {
-                delete updatedOptions.headers.host;
-              }
-              if ("cookie" in updatedOptions.headers) {
-                delete updatedOptions.headers.cookie;
+            this._request = void 0;
+            const updatedOptions = new Options(void 0, void 0, this.options);
+            const serverRequestedGet = statusCode === 303 && updatedOptions.method !== "GET" && updatedOptions.method !== "HEAD";
+            const canRewrite = statusCode !== 307 && statusCode !== 308;
+            const userRequestedGet = updatedOptions.methodRewriting && canRewrite;
+            if (serverRequestedGet || userRequestedGet) {
+              updatedOptions.method = "GET";
+              updatedOptions.body = void 0;
+              updatedOptions.json = void 0;
+              updatedOptions.form = void 0;
+              delete updatedOptions.headers["content-length"];
+            }
+            try {
+              const redirectBuffer = Buffer3.from(response.headers.location, "binary").toString();
+              const redirectUrl = new URL(redirectBuffer, url);
+              if (!isUnixSocketURL(url) && isUnixSocketURL(redirectUrl)) {
+                this._beforeError(new RequestError("Cannot redirect to UNIX socket", {}, this));
+                return;
               }
-              if ("authorization" in updatedOptions.headers) {
-                delete updatedOptions.headers.authorization;
+              if (redirectUrl.hostname !== url.hostname || redirectUrl.port !== url.port) {
+                if ("host" in updatedOptions.headers) {
+                  delete updatedOptions.headers.host;
+                }
+                if ("cookie" in updatedOptions.headers) {
+                  delete updatedOptions.headers.cookie;
+                }
+                if ("authorization" in updatedOptions.headers) {
+                  delete updatedOptions.headers.authorization;
+                }
+                if (updatedOptions.username || updatedOptions.password) {
+                  updatedOptions.username = "";
+                  updatedOptions.password = "";
+                }
+              } else {
+                redirectUrl.username = updatedOptions.username;
+                redirectUrl.password = updatedOptions.password;
               }
-              if (updatedOptions.username || updatedOptions.password) {
-                updatedOptions.username = "";
-                updatedOptions.password = "";
+              this.redirectUrls.push(redirectUrl);
+              updatedOptions.prefixUrl = "";
+              updatedOptions.url = redirectUrl;
+              for (const hook of updatedOptions.hooks.beforeRedirect) {
+                await hook(updatedOptions, typedResponse);
               }
-            } else {
-              redirectUrl.username = updatedOptions.username;
-              redirectUrl.password = updatedOptions.password;
-            }
-            this.redirectUrls.push(redirectUrl);
-            updatedOptions.prefixUrl = "";
-            updatedOptions.url = redirectUrl;
-            for (const hook of updatedOptions.hooks.beforeRedirect) {
-              await hook(updatedOptions, typedResponse);
-            }
-            this.emit("redirect", updatedOptions, typedResponse);
-            this.options = updatedOptions;
-            await this._makeRequest();
-          } catch (error2) {
-            this._beforeError(error2);
+              this.emit("redirect", updatedOptions, typedResponse);
+              this.options = updatedOptions;
+              await this._makeRequest();
+            } catch (error2) {
+              this._beforeError(error2);
+              return;
+            }
             return;
           }
-          return;
         }
         if (options.isStream && options.throwHttpErrors && !isResponseOk(typedResponse)) {
           this._beforeError(new HTTPError(typedResponse));
@@ -27872,7 +28799,7 @@ var init_core = __esm({
           return false;
         }
         try {
-          const rawBody = await getBuffer(from);
+          const rawBody = await getStreamAsBuffer(from);
           if (!this.isAborted) {
             this.response.rawBody = rawBody;
             return true;
@@ -27912,9 +28839,9 @@ var init_core = __esm({
         this._sendBody();
         this.emit("request", request);
       }
-      async _asyncWrite(chunk) {
+      async _asyncWrite(chunk2) {
         return new Promise((resolve, reject) => {
-          super.write(chunk, (error2) => {
+          super.write(chunk2, (error2) => {
             if (error2) {
               reject(error2);
               return;
@@ -27931,8 +28858,8 @@ var init_core = __esm({
         } else if (dist_default.generator(body) || dist_default.asyncGenerator(body)) {
           (async () => {
             try {
-              for await (const chunk of body) {
-                await this._asyncWrite(chunk);
+              for await (const chunk2 of body) {
+                await this._asyncWrite(chunk2);
               }
               super.end();
             } catch (error2) {
@@ -28091,13 +29018,13 @@ var init_core = __esm({
         }
         this.destroy(error2);
       }
-      _writeRequest(chunk, encoding, callback) {
+      _writeRequest(chunk2, encoding, callback) {
         if (!this._request || this._request.destroyed) {
           return;
         }
-        this._request.write(chunk, encoding, (error2) => {
+        this._request.write(chunk2, encoding, (error2) => {
           if (!error2 && !this._request.destroyed) {
-            this._uploadedSize += Buffer3.byteLength(chunk, encoding);
+            this._uploadedSize += Buffer3.byteLength(chunk2, encoding);
             const progress = this.uploadProgress;
             if (progress.percent < 1) {
               this.emit("uploadProgress", progress);
@@ -28200,10 +29127,10 @@ var init_core = __esm({
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/as-promise/types.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/as-promise/types.js
 var CancelError2;
 var init_types2 = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/as-promise/types.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/as-promise/types.js"() {
     init_errors();
     CancelError2 = class extends RequestError {
       constructor(request) {
@@ -28221,7 +29148,7 @@ var init_types2 = __esm({
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/as-promise/index.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/as-promise/index.js
 import { EventEmitter as EventEmitter2 } from "node:events";
 function asPromise(firstRequest) {
   let globalRequest;
@@ -28253,7 +29180,12 @@ function asPromise(firstRequest) {
           try {
             response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
           } catch (error2) {
-            response.body = response.rawBody.toString();
+            try {
+              response.body = response.rawBody.toString();
+            } catch (error3) {
+              request._beforeError(new ParseError(error3, response));
+              return;
+            }
             if (isResponseOk(response)) {
               request._beforeError(error2);
               return;
@@ -28353,7 +29285,7 @@ function asPromise(firstRequest) {
 }
 var proxiedRequestEvents2;
 var init_as_promise = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/as-promise/index.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/as-promise/index.js"() {
     init_dist();
     init_p_cancelable();
     init_errors();
@@ -28371,10 +29303,10 @@ var init_as_promise = __esm({
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/create.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/create.js
 var delay, isGotInstance, aliases, create, create_default;
 var init_create = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/create.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/create.js"() {
     init_dist();
     init_as_promise();
     init_core();
@@ -28551,16 +29483,16 @@ var init_create = __esm({
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/types.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/types.js
 var init_types3 = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/types.js"() {
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/types.js"() {
   }
 });
 
-// node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/index.js
+// node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/index.js
 var defaults, got, source_default2;
-var init_source3 = __esm({
-  "node_modules/.pnpm/got@12.6.1/node_modules/got/dist/source/index.js"() {
+var init_source4 = __esm({
+  "node_modules/.pnpm/got@14.2.1/node_modules/got/dist/source/index.js"() {
     init_create();
     init_options();
     init_options();
@@ -29002,7 +29934,7 @@ var require_minimist = __commonJS({
       var key = keys[keys.length - 1];
       return key in o;
     }
-    function isNumber(x) {
+    function isNumber2(x) {
       if (typeof x === "number") {
         return true;
       }
@@ -29102,7 +30034,7 @@ var require_minimist = __commonJS({
             return;
           }
         }
-        var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
+        var value2 = !flags.strings[key2] && isNumber2(val) ? Number(val) : val;
         setKey(argv, key2.split("."), value2);
         (aliases2[key2] || []).forEach(function(x) {
           setKey(argv, x.split("."), value2);
@@ -29184,7 +30116,7 @@ var require_minimist = __commonJS({
           }
         } else {
           if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
-            argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
+            argv._.push(flags.strings._ || !isNumber2(arg) ? arg : Number(arg));
           }
           if (opts.stopEarly) {
             argv._.push.apply(argv._, args.slice(i + 1));
@@ -29734,7 +30666,7 @@ var require_graceful_fs2 = __commonJS({
       gracefulQueue = "___graceful-fs.queue";
       previousSymbol = "___graceful-fs.previous";
     }
-    function noop3() {
+    function noop4() {
     }
     function publishQueue(context, queue2) {
       Object.defineProperty(context, gracefulQueue, {
@@ -29743,7 +30675,7 @@ var require_graceful_fs2 = __commonJS({
         }
       });
     }
-    var debug = noop3;
+    var debug = noop4;
     if (util2.debuglog)
       debug = util2.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
@@ -30581,8 +31513,8 @@ var require_util2 = __commonJS({
       const typeList = [].concat(types2[key]);
       const isPath = typeList.indexOf(path2) !== -1;
       const isBool = typeList.indexOf(Boolean) !== -1;
-      const isString = typeList.indexOf(String) !== -1;
-      const isNumber = typeList.indexOf(Number) !== -1;
+      const isString2 = typeList.indexOf(String) !== -1;
+      const isNumber2 = typeList.indexOf(Number) !== -1;
       field = `${field}`.trim();
       if (/^".*"$/.test(field)) {
         try {
@@ -30591,7 +31523,7 @@ var require_util2 = __commonJS({
           throw new Error(`Failed parsing JSON config key ${key}: ${field}`);
         }
       }
-      if (isBool && !isString && field === "") {
+      if (isBool && !isString2 && field === "") {
         return true;
       }
       switch (field) {
@@ -30616,7 +31548,7 @@ var require_util2 = __commonJS({
         }
         field = path2.resolve(field);
       }
-      if (isNumber && !isNaN(field)) {
+      if (isNumber2 && !isNaN(field)) {
         field = Number(field);
       }
       return field;
@@ -32734,7 +33666,7 @@ var require_range = __commonJS({
             this.set = [first];
           } else if (this.set.length > 1) {
             for (const c of this.set) {
-              if (c.length === 1 && isAny(c[0])) {
+              if (c.length === 1 && isAny2(c[0])) {
                 this.set = [c];
                 break;
               }
@@ -32840,7 +33772,7 @@ var require_range = __commonJS({
     } = require_re();
     var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants4();
     var isNullSet = (c) => c.value === "<0.0.0-0";
-    var isAny = (c) => c.value === "";
+    var isAny2 = (c) => c.value === "";
     var isSatisfiable = (comparators, options) => {
       let result = true;
       const remainingComparators = comparators.slice();
@@ -33800,7 +34732,7 @@ async function packageJson(packageName, options) {
 var import_registry_auth_token, import_semver4, agentOptions, httpAgent, httpsAgent, PackageNotFoundError, VersionNotFoundError;
 var init_package_json = __esm({
   "node_modules/.pnpm/package-json@8.1.1/node_modules/package-json/index.js"() {
-    init_source3();
+    init_source4();
     init_registry_url();
     import_registry_auth_token = __toESM(require_registry_auth_token(), 1);
     import_semver4 = __toESM(require_semver3(), 1);
@@ -33825,7 +34757,7 @@ var init_package_json = __esm({
   }
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/utils.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/utils.ts
 var semver = __toESM(require_semver());
 var import_sembear = __toESM(require_sembear_cjs());
 var NORMAL_DEPENDENCY_TYPES = [
@@ -33923,7 +34855,7 @@ function makeCheck(check) {
   return check;
 }
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/EXTERNAL_MISMATCH.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/EXTERNAL_MISMATCH.ts
 var import_semver = __toESM(require_semver());
 var EXTERNAL_MISMATCH_default = makeCheck({
   validate: (workspace, allWorkspace) => {
@@ -33962,7 +34894,7 @@ var EXTERNAL_MISMATCH_default = makeCheck({
   type: "all"
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/INTERNAL_MISMATCH.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/INTERNAL_MISMATCH.ts
 var import_semver2 = __toESM(require_semver());
 var INTERNAL_MISMATCH_default = makeCheck({
   validate: (workspace, allWorkspaces) => {
@@ -34001,7 +34933,7 @@ var INTERNAL_MISMATCH_default = makeCheck({
   type: "all"
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP.ts
 var import_sembear2 = __toESM(require_sembear_cjs());
 var import_semver3 = __toESM(require_semver());
 var INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP_default = makeCheck({
@@ -34068,7 +35000,7 @@ var INVALID_DEV_AND_PEER_DEPENDENCY_RELATIONSHIP_default = makeCheck({
   }
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/INVALID_PACKAGE_NAME.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/INVALID_PACKAGE_NAME.ts
 var import_validate_npm_package_name = __toESM(require_validate_npm_package_name());
 var INVALID_PACKAGE_NAME_default = makeCheck({
   type: "all",
@@ -34111,7 +35043,7 @@ ${error2.errors.join(
   }
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/MULTIPLE_DEPENDENCY_TYPES.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/MULTIPLE_DEPENDENCY_TYPES.ts
 var MULTIPLE_DEPENDENCY_TYPES_default = makeCheck({
   validate: (workspace, allWorkspaces) => {
     let dependencies = /* @__PURE__ */ new Set();
@@ -34152,7 +35084,7 @@ var MULTIPLE_DEPENDENCY_TYPES_default = makeCheck({
   print: (error2) => `${error2.workspace.packageJson.name} has a dependency and a ${error2.dependencyType === "devDependencies" ? "devDependency" : "optionalDependency"} on ${error2.dependencyName}, this is unnecessary, it should be removed from ${error2.dependencyType}`
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/ROOT_HAS_DEV_DEPENDENCIES.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/ROOT_HAS_DEV_DEPENDENCIES.ts
 var import_chalk = __toESM(require_source());
 var ROOT_HAS_DEV_DEPENDENCIES_default = makeCheck({
   type: "root",
@@ -34180,7 +35112,7 @@ var ROOT_HAS_DEV_DEPENDENCIES_default = makeCheck({
   }
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/UNSORTED_DEPENDENCIES.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/UNSORTED_DEPENDENCIES.ts
 var UNSORTED_DEPENDENCIES_default = makeCheck({
   type: "all",
   validate: (workspace) => {
@@ -34203,7 +35135,7 @@ var UNSORTED_DEPENDENCIES_default = makeCheck({
   print: (error2) => `${error2.workspace.packageJson.name}'s dependencies are unsorted, this can cause large diffs when packages are added, resulting in dependencies being sorted`
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/INCORRECT_REPOSITORY_FIELD.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/INCORRECT_REPOSITORY_FIELD.ts
 var import_parse_github_url = __toESM(require_parse_github_url());
 var import_normalize_path = __toESM(require_normalize_path());
 var INCORRECT_REPOSITORY_FIELD_default = makeCheck({
@@ -34271,7 +35203,7 @@ var INCORRECT_REPOSITORY_FIELD_default = makeCheck({
   }
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/WORKSPACE_REQUIRED.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/WORKSPACE_REQUIRED.ts
 var WORKSPACE_REQUIRED_default = makeCheck({
   validate: (workspace, allWorkspaces, root, opts) => {
     if (opts.workspaceProtocol !== "require")
@@ -34305,7 +35237,7 @@ var WORKSPACE_REQUIRED_default = makeCheck({
   type: "all"
 });
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/checks/index.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/checks/index.ts
 var checks = {
   EXTERNAL_MISMATCH: EXTERNAL_MISMATCH_default,
   INTERNAL_MISMATCH: INTERNAL_MISMATCH_default,
@@ -34318,7 +35250,7 @@ var checks = {
   WORKSPACE_REQUIRED: WORKSPACE_REQUIRED_default
 };
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/errors.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/errors.ts
 var ExitError = class extends Error {
   code;
   constructor(code) {
@@ -34327,7 +35259,7 @@ var ExitError = class extends Error {
   }
 };
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/npm-tag.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/npm-tag.ts
 var import_get_packages = __toESM(require_manypkg_get_packages_cjs());
 var import_spawndamnit = __toESM(require_spawndamnit());
 var import_p_limit = __toESM(require_p_limit());
@@ -34368,11 +35300,11 @@ async function npmTagAll([tag, _, otp]) {
   );
 }
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/run.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/run.ts
 var import_get_packages2 = __toESM(require_manypkg_get_packages_cjs());
 var import_spawndamnit2 = __toESM(require_spawndamnit());
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/logger.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/logger.ts
 var import_chalk2 = __toESM(require_source());
 import util from "util";
 function format(args, messageType, scope) {
@@ -34388,7 +35320,7 @@ function error(message, scope) {
   console.error(format([message], "error", scope));
 }
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/run.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/run.ts
 async function runCmd(args, cwd) {
   let { packages, rootDir } = await (0, import_get_packages2.getPackages)(cwd);
   const exactMatchingPackage = packages.find((pkg) => {
@@ -34422,12 +35354,12 @@ ${matchingPackages.map((x) => x.packageJson.name).join("\n")}`
   }
 }
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/upgrade.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/upgrade.ts
 var import_get_packages3 = __toESM(require_manypkg_get_packages_cjs());
 var import_semver5 = __toESM(require_semver());
 var import_p_limit2 = __toESM(require_p_limit());
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/utils.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/utils.ts
 var fs = __toESM(require_lib());
 var import_spawndamnit3 = __toESM(require_spawndamnit());
 var import_detect_indent = __toESM(require_detect_indent());
@@ -34456,7 +35388,7 @@ async function install(toolType, cwd) {
   );
 }
 
-// node_modules/.pnpm/@manypkg+cli@0.21.3/node_modules/@manypkg/cli/src/upgrade.ts
+// node_modules/.pnpm/@manypkg+cli@0.21.4/node_modules/@manypkg/cli/src/upgrade.ts
 async function upgradeDependency([name, tag = "latest"]) {
   let { packages, tool, rootPackage, rootDir } = await (0, import_get_packages3.getPackages)(
     process.cwd()
@@ -34472,7 +35404,7 @@ async function upgradeDependency([name, tag = "latest"]) {
         return;
       let packageNames = Object.keys(deps);
       packageNames.forEach((pkgName) => {
-        if (isScope && pkgName.startsWith(name) || pkgName === name) {
+        if (isScope && pkgName.startsWith(`${name}/`) || pkgName === name) {
           requiresUpdate = true;
           packagesToUpdate.add(pkgName);
         }
@@ -34488,7 +35420,7 @@ async function upgradeDependency([name, tag = "latest"]) {
         return;
       let packageNames = Object.keys(deps);
       packageNames.forEach((pkgName) => {
-        if (isScope && pkgName.startsWith(name) || pkgName === name) {
+        if (isScope && pkgName.startsWith(`${name}/`) || pkgName === name) {
           rootRequiresUpdate = true;
           packagesToUpdate.add(pkgName);
         }