@caspian2026/agent-sdk 0.0.18 → 0.0.20

package/dist/{chunk-55raexh7.js → chunk-tnpk0ne1.js}

@@ -1,16 +1,16 @@
 // @bun
 import {
   require_src
-} from "./chunk-b0kf00ff.js";
+} from "./chunk-6d05fvxz.js";
 import {
   __commonJS,
   __esm,
   __export,
   __require,
   __toESM
-} from "./chunk-qp2qdcda.js";
+} from "./chunk-eta5aekm.js";
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/bind.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/bind.js
 function bind(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
@@ -18,7 +18,7 @@ function bind(fn, thisArg) {
 }
 var init_bind = () => {};
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/utils.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/utils.js
 function isBuffer(val) {
   return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
 }
@@ -84,16 +84,17 @@ function findKey(obj, key) {
   }
   return null;
 }
-function merge() {
+function merge(...objs) {
   const { caseless, skipUndefined } = isContextDefined(this) && this || {};
   const result = {};
   const assignValue = (val, key) => {
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
       return;
     }
-    const targetKey = caseless && findKey(result, key) || key;
-    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
-      result[targetKey] = merge(result[targetKey], val);
+    const targetKey = caseless && typeof key === "string" && findKey(result, key) || key;
+    const existing = hasOwnProperty(result, targetKey) ? result[targetKey] : undefined;
+    if (isPlainObject(existing) && isPlainObject(val)) {
+      result[targetKey] = merge(existing, val);
     } else if (isPlainObject(val)) {
       result[targetKey] = merge({}, val);
     } else if (isArray(val)) {
@@ -102,23 +103,51 @@ function merge() {
       result[targetKey] = val;
     }
   };
-  for (let i = 0, l = arguments.length;i < l; i++) {
-    arguments[i] && forEach(arguments[i], assignValue);
+  for (let i = 0, l = objs.length;i < l; i++) {
+    const source = objs[i];
+    if (!source || isBuffer(source)) {
+      continue;
+    }
+    forEach(source, assignValue);
+    if (typeof source !== "object" || isArray(source)) {
+      continue;
+    }
+    const symbols = Object.getOwnPropertySymbols(source);
+    for (let j = 0;j < symbols.length; j++) {
+      const symbol = symbols[j];
+      if (propertyIsEnumerable.call(source, symbol)) {
+        assignValue(source[symbol], symbol);
+      }
+    }
   }
   return result;
 }
 function isSpecCompliantForm(thing) {
   return !!(thing && isFunction(thing.append) && thing[toStringTag] === "FormData" && thing[iterator]);
 }
-var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type) => {
+var toString, getPrototypeOf, iterator, toStringTag, hasOwnProperty, hasOwnInPrototypeChain = (thing, prop) => {
+  let obj = thing;
+  const seen = [];
+  while (obj != null && obj !== Object.prototype) {
+    if (seen.indexOf(obj) !== -1) {
+      return false;
+    }
+    seen.push(obj);
+    if (hasOwnProperty(obj, prop)) {
+      return true;
+    }
+    obj = getPrototypeOf(obj);
+  }
+  return false;
+}, getSafeProp = (obj, prop) => obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : undefined, kindOf, kindOfTest = (type) => {
   type = type.toLowerCase();
   return (thing) => kindOf(thing) === type;
 }, typeOfTest = (type) => (thing) => typeof thing === type, isArray, isUndefined, isArrayBuffer, isString, isFunction, isNumber, isObject = (thing) => thing !== null && typeof thing === "object", isBoolean = (thing) => thing === true || thing === false, isPlainObject = (val) => {
-  if (kindOf(val) !== "object") {
+  if (!isObject(val)) {
     return false;
   }
   const prototype = getPrototypeOf(val);
-  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(iterator in val);
+  return (prototype === null || prototype === Object.prototype || getPrototypeOf(prototype) === null) && !hasOwnInPrototypeChain(val, toStringTag) && !hasOwnInPrototypeChain(val, iterator);
 }, isEmptyObject = (val) => {
   if (!isObject(val) || isBuffer(val)) {
     return false;
@@ -131,14 +160,24 @@ var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type)
 }, isDate, isFile, isReactNativeBlob = (value) => {
   return !!(value && typeof value.uri !== "undefined");
 }, isReactNative = (formData) => formData && typeof formData.getParts !== "undefined", isBlob, isFileList, isStream = (val) => isObject(val) && isFunction(val.pipe), G, FormDataCtor, isFormData = (thing) => {
-  let kind;
-  return thing && (FormDataCtor && thing instanceof FormDataCtor || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]"));
+  if (!thing)
+    return false;
+  if (FormDataCtor && thing instanceof FormDataCtor)
+    return true;
+  const proto = getPrototypeOf(thing);
+  if (!proto || proto === Object.prototype)
+    return false;
+  if (!isFunction(thing.append))
+    return false;
+  const kind = kindOf(thing);
+  return kind === "formdata" || kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]";
 }, isURLSearchParams, isReadableStream, isRequest, isResponse, isHeaders, trim = (str) => {
   return str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
 }, _global, isContextDefined = (context) => !isUndefined(context) && context !== _global, extend = (a, b, thisArg, { allOwnKeys } = {}) => {
   forEach(b, (val, key) => {
     if (thisArg && isFunction(val)) {
       Object.defineProperty(a, key, {
+        __proto__: null,
         value: bind(val, thisArg),
         writable: true,
         enumerable: true,
@@ -146,6 +185,7 @@ var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type)
       });
     } else {
       Object.defineProperty(a, key, {
+        __proto__: null,
         value: val,
         writable: true,
         enumerable: true,
@@ -162,12 +202,14 @@ var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type)
 }, inherits = (constructor, superConstructor, props, descriptors) => {
   constructor.prototype = Object.create(superConstructor.prototype, descriptors);
   Object.defineProperty(constructor.prototype, "constructor", {
+    __proto__: null,
     value: constructor,
     writable: true,
     enumerable: false,
     configurable: true
   });
   Object.defineProperty(constructor, "super", {
+    __proto__: null,
     value: superConstructor.prototype
   });
   props && Object.assign(constructor.prototype, props);
@@ -232,7 +274,7 @@ var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type)
   return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
     return p1.toUpperCase() + p2;
   });
-}, hasOwnProperty, isRegExp, reduceDescriptors = (obj, reducer) => {
+}, propertyIsEnumerable, isRegExp, reduceDescriptors = (obj, reducer) => {
   const descriptors = Object.getOwnPropertyDescriptors(obj);
   const reducedDescriptors = {};
   forEach(descriptors, (descriptor, name) => {
@@ -244,7 +286,7 @@ var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type)
   Object.defineProperties(obj, reducedDescriptors);
 }, freezeMethods = (obj) => {
   reduceDescriptors(obj, (descriptor, name) => {
-    if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name) !== -1) {
+    if (isFunction(obj) && ["arguments", "caller", "callee"].includes(name)) {
       return false;
     }
     const value = obj[name];
@@ -273,35 +315,36 @@ var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type)
 }, noop = () => {}, toFiniteNumber = (value, defaultValue) => {
   return value != null && Number.isFinite(value = +value) ? value : defaultValue;
 }, toJSONObject = (obj) => {
-  const stack = new Array(10);
-  const visit = (source, i) => {
+  const visited = new WeakSet;
+  const visit = (source) => {
     if (isObject(source)) {
-      if (stack.indexOf(source) >= 0) {
+      if (visited.has(source)) {
         return;
       }
       if (isBuffer(source)) {
         return source;
       }
       if (!("toJSON" in source)) {
-        stack[i] = source;
+        visited.add(source);
         const target = isArray(source) ? [] : {};
         forEach(source, (value, key) => {
-          const reducedValue = visit(value, i + 1);
+          const reducedValue = visit(value);
           !isUndefined(reducedValue) && (target[key] = reducedValue);
         });
-        stack[i] = undefined;
+        visited.delete(source);
         return target;
       }
     }
     return source;
   };
-  return visit(obj, 0);
-}, isAsyncFn, isThenable = (thing) => thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch), _setImmediate, asap, isIterable = (thing) => thing != null && isFunction(thing[iterator]), utils_default;
+  return visit(obj);
+}, isAsyncFn, isThenable = (thing) => thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch), _setImmediate, asap, isIterable = (thing) => thing != null && isFunction(thing[iterator]), isSafeIterable = (thing) => thing != null && hasOwnInPrototypeChain(thing, iterator) && isIterable(thing), utils_default;
 var init_utils = __esm(() => {
   init_bind();
   ({ toString } = Object.prototype);
   ({ getPrototypeOf } = Object);
   ({ iterator, toStringTag } = Symbol);
+  hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
   kindOf = ((cache) => (thing) => {
     const str = toString.call(thing);
     return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
@@ -336,7 +379,7 @@ var init_utils = __esm(() => {
     };
   })(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array));
   isHTMLForm = kindOfTest("HTMLFormElement");
-  hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
+  ({ propertyIsEnumerable } = Object.prototype);
   isRegExp = kindOfTest("RegExp");
   isAsyncFn = kindOfTest("AsyncFunction");
   _setImmediate = ((setImmediateSupported, postMessageSupported) => {
@@ -400,6 +443,8 @@ var init_utils = __esm(() => {
     isHTMLForm,
     hasOwnProperty,
     hasOwnProp: hasOwnProperty,
+    hasOwnInPrototypeChain,
+    getSafeProp,
     reduceDescriptors,
     freezeMethods,
     toObjectSet,
@@ -415,203 +460,610 @@ var init_utils = __esm(() => {
     isThenable,
     setImmediate: _setImmediate,
     asap,
-    isIterable
+    isIterable,
+    isSafeIterable
   };
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/core/AxiosError.js
-var AxiosError, AxiosError_default;
-var init_AxiosError = __esm(() => {
-  init_utils();
-  AxiosError = class AxiosError extends Error {
-    static from(error, code, config, request, response, customProps) {
-      const axiosError = new AxiosError(error.message, code || error.code, config, request, response);
-      axiosError.cause = error;
-      axiosError.name = error.name;
-      if (error.status != null && axiosError.status == null) {
-        axiosError.status = error.status;
-      }
-      customProps && Object.assign(axiosError, customProps);
-      return axiosError;
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/parseHeaders.js
+var ignoreDuplicateOf, parseHeaders_default = (rawHeaders) => {
+  const parsed = {};
+  let key;
+  let val;
+  let i;
+  rawHeaders && rawHeaders.split(`
+`).forEach(function parser(line) {
+    i = line.indexOf(":");
+    key = line.substring(0, i).trim().toLowerCase();
+    val = line.substring(i + 1).trim();
+    if (!key || parsed[key] && ignoreDuplicateOf[key]) {
+      return;
     }
-    constructor(message, code, config, request, response) {
-      super(message);
-      Object.defineProperty(this, "message", {
-        value: message,
-        enumerable: true,
-        writable: true,
-        configurable: true
-      });
-      this.name = "AxiosError";
-      this.isAxiosError = true;
-      code && (this.code = code);
-      config && (this.config = config);
-      request && (this.request = request);
-      if (response) {
-        this.response = response;
-        this.status = response.status;
+    if (key === "set-cookie") {
+      if (parsed[key]) {
+        parsed[key].push(val);
+      } else {
+        parsed[key] = [val];
       }
+    } else {
+      parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
     }
-    toJSON() {
-      return {
-        message: this.message,
-        name: this.name,
-        description: this.description,
-        number: this.number,
-        fileName: this.fileName,
-        lineNumber: this.lineNumber,
-        columnNumber: this.columnNumber,
-        stack: this.stack,
-        config: utils_default.toJSONObject(this.config),
-        code: this.code,
-        status: this.status
-      };
-    }
-  };
-  AxiosError.ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
-  AxiosError.ERR_BAD_OPTION = "ERR_BAD_OPTION";
-  AxiosError.ECONNABORTED = "ECONNABORTED";
-  AxiosError.ETIMEDOUT = "ETIMEDOUT";
-  AxiosError.ERR_NETWORK = "ERR_NETWORK";
-  AxiosError.ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
-  AxiosError.ERR_DEPRECATED = "ERR_DEPRECATED";
-  AxiosError.ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
-  AxiosError.ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
-  AxiosError.ERR_CANCELED = "ERR_CANCELED";
-  AxiosError.ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
-  AxiosError.ERR_INVALID_URL = "ERR_INVALID_URL";
-  AxiosError_default = AxiosError;
+  });
+  return parsed;
+};
+var init_parseHeaders = __esm(() => {
+  init_utils();
+  ignoreDuplicateOf = utils_default.toObjectSet([
+    "age",
+    "authorization",
+    "content-length",
+    "content-type",
+    "etag",
+    "expires",
+    "from",
+    "host",
+    "if-modified-since",
+    "if-unmodified-since",
+    "last-modified",
+    "location",
+    "max-forwards",
+    "proxy-authorization",
+    "referer",
+    "retry-after",
+    "user-agent"
+  ]);
 });
 
-// node_modules/.bun/delayed-stream@1.0.0/node_modules/delayed-stream/lib/delayed_stream.js
-var require_delayed_stream = __commonJS((exports, module) => {
-  var Stream = __require("stream").Stream;
-  var util = __require("util");
-  module.exports = DelayedStream;
-  function DelayedStream() {
-    this.source = null;
-    this.dataSize = 0;
-    this.maxDataSize = 1024 * 1024;
-    this.pauseStream = true;
-    this._maxDataSizeExceeded = false;
-    this._released = false;
-    this._bufferedEvents = [];
-  }
-  util.inherits(DelayedStream, Stream);
-  DelayedStream.create = function(source, options) {
-    var delayedStream = new this;
-    options = options || {};
-    for (var option in options) {
-      delayedStream[option] = options[option];
-    }
-    delayedStream.source = source;
-    var realEmit = source.emit;
-    source.emit = function() {
-      delayedStream._handleEmit(arguments);
-      return realEmit.apply(source, arguments);
-    };
-    source.on("error", function() {});
-    if (delayedStream.pauseStream) {
-      source.pause();
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/sanitizeHeaderValue.js
+function trimSPorHTAB(str) {
+  let start = 0;
+  let end = str.length;
+  while (start < end) {
+    const code = str.charCodeAt(start);
+    if (code !== 9 && code !== 32) {
+      break;
     }
-    return delayedStream;
-  };
-  Object.defineProperty(DelayedStream.prototype, "readable", {
-    configurable: true,
-    enumerable: true,
-    get: function() {
-      return this.source.readable;
+    start += 1;
+  }
+  while (end > start) {
+    const code = str.charCodeAt(end - 1);
+    if (code !== 9 && code !== 32) {
+      break;
     }
+    end -= 1;
+  }
+  return start === 0 && end === str.length ? str : str.slice(start, end);
+}
+function sanitizeValue(value, invalidChars) {
+  if (utils_default.isArray(value)) {
+    return value.map((item) => sanitizeValue(item, invalidChars));
+  }
+  return trimSPorHTAB(String(value).replace(invalidChars, ""));
+}
+function toByteStringHeaderObject(headers) {
+  const byteStringHeaders = Object.create(null);
+  utils_default.forEach(headers.toJSON(), (value, header) => {
+    byteStringHeaders[header] = sanitizeByteStringHeaderValue(value);
   });
-  DelayedStream.prototype.setEncoding = function() {
-    return this.source.setEncoding.apply(this.source, arguments);
-  };
-  DelayedStream.prototype.resume = function() {
-    if (!this._released) {
-      this.release();
-    }
-    this.source.resume();
-  };
-  DelayedStream.prototype.pause = function() {
-    this.source.pause();
-  };
-  DelayedStream.prototype.release = function() {
-    this._released = true;
-    this._bufferedEvents.forEach(function(args) {
-      this.emit.apply(this, args);
-    }.bind(this));
-    this._bufferedEvents = [];
-  };
-  DelayedStream.prototype.pipe = function() {
-    var r = Stream.prototype.pipe.apply(this, arguments);
-    this.resume();
-    return r;
-  };
-  DelayedStream.prototype._handleEmit = function(args) {
-    if (this._released) {
-      this.emit.apply(this, args);
-      return;
-    }
-    if (args[0] === "data") {
-      this.dataSize += args[1].length;
-      this._checkIfMaxDataSizeExceeded();
-    }
-    this._bufferedEvents.push(args);
-  };
-  DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
-    if (this._maxDataSizeExceeded) {
-      return;
-    }
-    if (this.dataSize <= this.maxDataSize) {
-      return;
-    }
-    this._maxDataSizeExceeded = true;
-    var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
-    this.emit("error", new Error(message));
-  };
+  return byteStringHeaders;
+}
+var INVALID_UNICODE_HEADER_VALUE_CHARS, INVALID_BYTE_STRING_HEADER_VALUE_CHARS, sanitizeHeaderValue = (value) => sanitizeValue(value, INVALID_UNICODE_HEADER_VALUE_CHARS), sanitizeByteStringHeaderValue = (value) => sanitizeValue(value, INVALID_BYTE_STRING_HEADER_VALUE_CHARS);
+var init_sanitizeHeaderValue = __esm(() => {
+  init_utils();
+  INVALID_UNICODE_HEADER_VALUE_CHARS = new RegExp("[\\u0000-\\u0008\\u000a-\\u001f\\u007f]+", "g");
+  INVALID_BYTE_STRING_HEADER_VALUE_CHARS = new RegExp("[^\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+", "g");
 });
 
-// node_modules/.bun/combined-stream@1.0.8/node_modules/combined-stream/lib/combined_stream.js
-var require_combined_stream = __commonJS((exports, module) => {
-  var util = __require("util");
-  var Stream = __require("stream").Stream;
-  var DelayedStream = require_delayed_stream();
-  module.exports = CombinedStream;
-  function CombinedStream() {
-    this.writable = false;
-    this.readable = true;
-    this.dataSize = 0;
-    this.maxDataSize = 2 * 1024 * 1024;
-    this.pauseStreams = true;
-    this._released = false;
-    this._streams = [];
-    this._currentStream = null;
-    this._insideLoop = false;
-    this._pendingNext = false;
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/core/AxiosHeaders.js
+function normalizeHeader(header) {
+  return header && String(header).trim().toLowerCase();
+}
+function normalizeValue(value) {
+  if (value === false || value == null) {
+    return value;
   }
-  util.inherits(CombinedStream, Stream);
-  CombinedStream.create = function(options) {
-    var combinedStream = new this;
-    options = options || {};
-    for (var option in options) {
-      combinedStream[option] = options[option];
-    }
-    return combinedStream;
-  };
-  CombinedStream.isStreamLike = function(stream) {
-    return typeof stream !== "function" && typeof stream !== "string" && typeof stream !== "boolean" && typeof stream !== "number" && !Buffer.isBuffer(stream);
-  };
-  CombinedStream.prototype.append = function(stream) {
-    var isStreamLike = CombinedStream.isStreamLike(stream);
-    if (isStreamLike) {
-      if (!(stream instanceof DelayedStream)) {
-        var newStream = DelayedStream.create(stream, {
-          maxDataSize: Infinity,
-          pauseStream: this.pauseStreams
-        });
-        stream.on("data", this._checkDataSize.bind(this));
-        stream = newStream;
-      }
+  return utils_default.isArray(value) ? value.map(normalizeValue) : sanitizeHeaderValue(String(value));
+}
+function parseTokens(str) {
+  const tokens = Object.create(null);
+  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+  let match;
+  while (match = tokensRE.exec(str)) {
+    tokens[match[1]] = match[2];
+  }
+  return tokens;
+}
+function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
+  if (utils_default.isFunction(filter)) {
+    return filter.call(this, value, header);
+  }
+  if (isHeaderNameFilter) {
+    value = header;
+  }
+  if (!utils_default.isString(value))
+    return;
+  if (utils_default.isString(filter)) {
+    return value.indexOf(filter) !== -1;
+  }
+  if (utils_default.isRegExp(filter)) {
+    return filter.test(value);
+  }
+}
+function formatHeader(header) {
+  return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
+    return char.toUpperCase() + str;
+  });
+}
+function buildAccessors(obj, header) {
+  const accessorName = utils_default.toCamelCase(" " + header);
+  ["get", "set", "has"].forEach((methodName) => {
+    Object.defineProperty(obj, methodName + accessorName, {
+      __proto__: null,
+      value: function(arg1, arg2, arg3) {
+        return this[methodName].call(this, header, arg1, arg2, arg3);
+      },
+      configurable: true
+    });
+  });
+}
+var $internals, isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim()), AxiosHeaders, AxiosHeaders_default;
+var init_AxiosHeaders = __esm(() => {
+  init_utils();
+  init_parseHeaders();
+  init_sanitizeHeaderValue();
+  $internals = Symbol("internals");
+  AxiosHeaders = class AxiosHeaders {
+    constructor(headers) {
+      headers && this.set(headers);
+    }
+    set(header, valueOrRewrite, rewrite) {
+      const self2 = this;
+      function setHeader(_value, _header, _rewrite) {
+        const lHeader = normalizeHeader(_header);
+        if (!lHeader) {
+          return;
+        }
+        const key = utils_default.findKey(self2, lHeader);
+        if (!key || self2[key] === undefined || _rewrite === true || _rewrite === undefined && self2[key] !== false) {
+          self2[key || _header] = normalizeValue(_value);
+        }
+      }
+      const setHeaders = (headers, _rewrite) => utils_default.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
+      if (utils_default.isPlainObject(header) || header instanceof this.constructor) {
+        setHeaders(header, valueOrRewrite);
+      } else if (utils_default.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
+        setHeaders(parseHeaders_default(header), valueOrRewrite);
+      } else if (utils_default.isObject(header) && utils_default.isSafeIterable(header)) {
+        let obj = Object.create(null), dest, key;
+        for (const entry of header) {
+          if (!utils_default.isArray(entry)) {
+            throw new TypeError("Object iterator must return a key-value pair");
+          }
+          key = entry[0];
+          if (utils_default.hasOwnProp(obj, key)) {
+            dest = obj[key];
+            obj[key] = utils_default.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]];
+          } else {
+            obj[key] = entry[1];
+          }
+        }
+        setHeaders(obj, valueOrRewrite);
+      } else {
+        header != null && setHeader(valueOrRewrite, header, rewrite);
+      }
+      return this;
+    }
+    get(header, parser) {
+      header = normalizeHeader(header);
+      if (header) {
+        const key = utils_default.findKey(this, header);
+        if (key) {
+          const value = this[key];
+          if (!parser) {
+            return value;
+          }
+          if (parser === true) {
+            return parseTokens(value);
+          }
+          if (utils_default.isFunction(parser)) {
+            return parser.call(this, value, key);
+          }
+          if (utils_default.isRegExp(parser)) {
+            return parser.exec(value);
+          }
+          throw new TypeError("parser must be boolean|regexp|function");
+        }
+      }
+    }
+    has(header, matcher) {
+      header = normalizeHeader(header);
+      if (header) {
+        const key = utils_default.findKey(this, header);
+        return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+      }
+      return false;
+    }
+    delete(header, matcher) {
+      const self2 = this;
+      let deleted = false;
+      function deleteHeader(_header) {
+        _header = normalizeHeader(_header);
+        if (_header) {
+          const key = utils_default.findKey(self2, _header);
+          if (key && (!matcher || matchHeaderValue(self2, self2[key], key, matcher))) {
+            delete self2[key];
+            deleted = true;
+          }
+        }
+      }
+      if (utils_default.isArray(header)) {
+        header.forEach(deleteHeader);
+      } else {
+        deleteHeader(header);
+      }
+      return deleted;
+    }
+    clear(matcher) {
+      const keys = Object.keys(this);
+      let i = keys.length;
+      let deleted = false;
+      while (i--) {
+        const key = keys[i];
+        if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
+          delete this[key];
+          deleted = true;
+        }
+      }
+      return deleted;
+    }
+    normalize(format) {
+      const self2 = this;
+      const headers = {};
+      utils_default.forEach(this, (value, header) => {
+        const key = utils_default.findKey(headers, header);
+        if (key) {
+          self2[key] = normalizeValue(value);
+          delete self2[header];
+          return;
+        }
+        const normalized = format ? formatHeader(header) : String(header).trim();
+        if (normalized !== header) {
+          delete self2[header];
+        }
+        self2[normalized] = normalizeValue(value);
+        headers[normalized] = true;
+      });
+      return this;
+    }
+    concat(...targets) {
+      return this.constructor.concat(this, ...targets);
+    }
+    toJSON(asStrings) {
+      const obj = Object.create(null);
+      utils_default.forEach(this, (value, header) => {
+        value != null && value !== false && (obj[header] = asStrings && utils_default.isArray(value) ? value.join(", ") : value);
+      });
+      return obj;
+    }
+    [Symbol.iterator]() {
+      return Object.entries(this.toJSON())[Symbol.iterator]();
+    }
+    toString() {
+      return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join(`
+`);
+    }
+    getSetCookie() {
+      return this.get("set-cookie") || [];
+    }
+    get [Symbol.toStringTag]() {
+      return "AxiosHeaders";
+    }
+    static from(thing) {
+      return thing instanceof this ? thing : new this(thing);
+    }
+    static concat(first, ...targets) {
+      const computed = new this(first);
+      targets.forEach((target) => computed.set(target));
+      return computed;
+    }
+    static accessor(header) {
+      const internals = this[$internals] = this[$internals] = {
+        accessors: {}
+      };
+      const accessors = internals.accessors;
+      const prototype = this.prototype;
+      function defineAccessor(_header) {
+        const lHeader = normalizeHeader(_header);
+        if (!accessors[lHeader]) {
+          buildAccessors(prototype, _header);
+          accessors[lHeader] = true;
+        }
+      }
+      utils_default.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
+      return this;
+    }
+  };
+  AxiosHeaders.accessor([
+    "Content-Type",
+    "Content-Length",
+    "Accept",
+    "Accept-Encoding",
+    "User-Agent",
+    "Authorization"
+  ]);
+  utils_default.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
+    let mapped = key[0].toUpperCase() + key.slice(1);
+    return {
+      get: () => value,
+      set(headerValue) {
+        this[mapped] = headerValue;
+      }
+    };
+  });
+  utils_default.freezeMethods(AxiosHeaders);
+  AxiosHeaders_default = AxiosHeaders;
+});
+
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/core/AxiosError.js
+function hasOwnOrPrototypeToJSON(source) {
+  if (utils_default.hasOwnProp(source, "toJSON")) {
+    return true;
+  }
+  let prototype = Object.getPrototypeOf(source);
+  while (prototype && prototype !== Object.prototype) {
+    if (utils_default.hasOwnProp(prototype, "toJSON")) {
+      return true;
+    }
+    prototype = Object.getPrototypeOf(prototype);
+  }
+  return false;
+}
+function redactConfig(config, redactKeys) {
+  const lowerKeys = new Set(redactKeys.map((k) => String(k).toLowerCase()));
+  const seen = [];
+  const visit = (source) => {
+    if (source === null || typeof source !== "object")
+      return source;
+    if (utils_default.isBuffer(source))
+      return source;
+    if (seen.indexOf(source) !== -1)
+      return;
+    if (source instanceof AxiosHeaders_default) {
+      source = source.toJSON();
+    }
+    seen.push(source);
+    let result;
+    if (utils_default.isArray(source)) {
+      result = [];
+      source.forEach((v, i) => {
+        const reducedValue = visit(v);
+        if (!utils_default.isUndefined(reducedValue)) {
+          result[i] = reducedValue;
+        }
+      });
+    } else {
+      if (!utils_default.isPlainObject(source) && hasOwnOrPrototypeToJSON(source)) {
+        seen.pop();
+        return source;
+      }
+      result = Object.create(null);
+      for (const [key, value] of Object.entries(source)) {
+        const reducedValue = lowerKeys.has(key.toLowerCase()) ? REDACTED : visit(value);
+        if (!utils_default.isUndefined(reducedValue)) {
+          result[key] = reducedValue;
+        }
+      }
+    }
+    seen.pop();
+    return result;
+  };
+  return visit(config);
+}
+var REDACTED = "[REDACTED ****]", AxiosError, AxiosError_default;
+var init_AxiosError = __esm(() => {
+  init_utils();
+  init_AxiosHeaders();
+  AxiosError = class AxiosError extends Error {
+    static from(error, code, config, request, response, customProps) {
+      const axiosError = new AxiosError(error.message, code || error.code, config, request, response);
+      Object.defineProperty(axiosError, "cause", {
+        __proto__: null,
+        value: error,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+      axiosError.name = error.name;
+      if (error.status != null && axiosError.status == null) {
+        axiosError.status = error.status;
+      }
+      customProps && Object.assign(axiosError, customProps);
+      return axiosError;
+    }
+    constructor(message, code, config, request, response) {
+      super(message);
+      Object.defineProperty(this, "message", {
+        __proto__: null,
+        value: message,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+      this.name = "AxiosError";
+      this.isAxiosError = true;
+      code && (this.code = code);
+      config && (this.config = config);
+      request && (this.request = request);
+      if (response) {
+        this.response = response;
+        this.status = response.status;
+      }
+    }
+    toJSON() {
+      const config = this.config;
+      const redactKeys = config && utils_default.hasOwnProp(config, "redact") ? config.redact : undefined;
+      const serializedConfig = utils_default.isArray(redactKeys) && redactKeys.length > 0 ? redactConfig(config, redactKeys) : utils_default.toJSONObject(config);
+      return {
+        message: this.message,
+        name: this.name,
+        description: this.description,
+        number: this.number,
+        fileName: this.fileName,
+        lineNumber: this.lineNumber,
+        columnNumber: this.columnNumber,
+        stack: this.stack,
+        config: serializedConfig,
+        code: this.code,
+        status: this.status
+      };
+    }
+  };
+  AxiosError.ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
+  AxiosError.ERR_BAD_OPTION = "ERR_BAD_OPTION";
+  AxiosError.ECONNABORTED = "ECONNABORTED";
+  AxiosError.ETIMEDOUT = "ETIMEDOUT";
+  AxiosError.ECONNREFUSED = "ECONNREFUSED";
+  AxiosError.ERR_NETWORK = "ERR_NETWORK";
+  AxiosError.ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
+  AxiosError.ERR_DEPRECATED = "ERR_DEPRECATED";
+  AxiosError.ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
+  AxiosError.ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
+  AxiosError.ERR_CANCELED = "ERR_CANCELED";
+  AxiosError.ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
+  AxiosError.ERR_INVALID_URL = "ERR_INVALID_URL";
+  AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED = "ERR_FORM_DATA_DEPTH_EXCEEDED";
+  AxiosError_default = AxiosError;
+});
+
+// node_modules/.bun/delayed-stream@1.0.0/node_modules/delayed-stream/lib/delayed_stream.js
+var require_delayed_stream = __commonJS((exports, module) => {
+  var Stream = __require("stream").Stream;
+  var util = __require("util");
+  module.exports = DelayedStream;
+  function DelayedStream() {
+    this.source = null;
+    this.dataSize = 0;
+    this.maxDataSize = 1024 * 1024;
+    this.pauseStream = true;
+    this._maxDataSizeExceeded = false;
+    this._released = false;
+    this._bufferedEvents = [];
+  }
+  util.inherits(DelayedStream, Stream);
+  DelayedStream.create = function(source, options) {
+    var delayedStream = new this;
+    options = options || {};
+    for (var option in options) {
+      delayedStream[option] = options[option];
+    }
+    delayedStream.source = source;
+    var realEmit = source.emit;
+    source.emit = function() {
+      delayedStream._handleEmit(arguments);
+      return realEmit.apply(source, arguments);
+    };
+    source.on("error", function() {});
+    if (delayedStream.pauseStream) {
+      source.pause();
+    }
+    return delayedStream;
+  };
+  Object.defineProperty(DelayedStream.prototype, "readable", {
+    configurable: true,
+    enumerable: true,
+    get: function() {
+      return this.source.readable;
+    }
+  });
+  DelayedStream.prototype.setEncoding = function() {
+    return this.source.setEncoding.apply(this.source, arguments);
+  };
+  DelayedStream.prototype.resume = function() {
+    if (!this._released) {
+      this.release();
+    }
+    this.source.resume();
+  };
+  DelayedStream.prototype.pause = function() {
+    this.source.pause();
+  };
+  DelayedStream.prototype.release = function() {
+    this._released = true;
+    this._bufferedEvents.forEach(function(args) {
+      this.emit.apply(this, args);
+    }.bind(this));
+    this._bufferedEvents = [];
+  };
+  DelayedStream.prototype.pipe = function() {
+    var r = Stream.prototype.pipe.apply(this, arguments);
+    this.resume();
+    return r;
+  };
+  DelayedStream.prototype._handleEmit = function(args) {
+    if (this._released) {
+      this.emit.apply(this, args);
+      return;
+    }
+    if (args[0] === "data") {
+      this.dataSize += args[1].length;
+      this._checkIfMaxDataSizeExceeded();
+    }
+    this._bufferedEvents.push(args);
+  };
+  DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
+    if (this._maxDataSizeExceeded) {
+      return;
+    }
+    if (this.dataSize <= this.maxDataSize) {
+      return;
+    }
+    this._maxDataSizeExceeded = true;
+    var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
+    this.emit("error", new Error(message));
+  };
+});
+
+// node_modules/.bun/combined-stream@1.0.8/node_modules/combined-stream/lib/combined_stream.js
+var require_combined_stream = __commonJS((exports, module) => {
+  var util = __require("util");
+  var Stream = __require("stream").Stream;
+  var DelayedStream = require_delayed_stream();
+  module.exports = CombinedStream;
+  function CombinedStream() {
+    this.writable = false;
+    this.readable = true;
+    this.dataSize = 0;
+    this.maxDataSize = 2 * 1024 * 1024;
+    this.pauseStreams = true;
+    this._released = false;
+    this._streams = [];
+    this._currentStream = null;
+    this._insideLoop = false;
+    this._pendingNext = false;
+  }
+  util.inherits(CombinedStream, Stream);
+  CombinedStream.create = function(options) {
+    var combinedStream = new this;
+    options = options || {};
+    for (var option in options) {
+      combinedStream[option] = options[option];
+    }
+    return combinedStream;
+  };
+  CombinedStream.isStreamLike = function(stream) {
+    return typeof stream !== "function" && typeof stream !== "string" && typeof stream !== "boolean" && typeof stream !== "number" && !Buffer.isBuffer(stream);
+  };
+  CombinedStream.prototype.append = function(stream) {
+    var isStreamLike = CombinedStream.isStreamLike(stream);
+    if (isStreamLike) {
+      if (!(stream instanceof DelayedStream)) {
+        var newStream = DelayedStream.create(stream, {
+          maxDataSize: Infinity,
+          pauseStream: this.pauseStreams
+        });
+        stream.on("data", this._checkDataSize.bind(this));
+        stream = newStream;
+      }
       this._handleErrors(stream);
       if (this.pauseStreams) {
         stream.pause();
@@ -9546,7 +9998,7 @@ var require_asynckit = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/.bun/es-object-atoms@1.1.1/node_modules/es-object-atoms/index.js
+// node_modules/.bun/es-object-atoms@1.1.2/node_modules/es-object-atoms/index.js
 var require_es_object_atoms = __commonJS((exports, module) => {
   module.exports = Object;
 });
@@ -9893,7 +10345,7 @@ var require_get_proto = __commonJS((exports, module) => {
   } : null;
 });
 
-// node_modules/.bun/hasown@2.0.2/node_modules/hasown/index.js
+// node_modules/.bun/hasown@2.0.4/node_modules/hasown/index.js
 var require_hasown = __commonJS((exports, module) => {
   var call = Function.prototype.call;
   var $hasOwn = Object.prototype.hasOwnProperty;
@@ -10264,7 +10716,7 @@ var require_es_set_tostringtag = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/.bun/form-data@4.0.5/node_modules/form-data/lib/populate.js
+// node_modules/.bun/form-data@4.0.6/node_modules/form-data/lib/populate.js
 var require_populate = __commonJS((exports, module) => {
   module.exports = function(dst, src) {
     Object.keys(src).forEach(function(prop) {
@@ -10274,7 +10726,7 @@ var require_populate = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/.bun/form-data@4.0.5/node_modules/form-data/lib/form_data.js
+// node_modules/.bun/form-data@4.0.6/node_modules/form-data/lib/form_data.js
 var require_form_data = __commonJS((exports, module) => {
   var CombinedStream = require_combined_stream();
   var util = __require("util");
@@ -10290,6 +10742,9 @@ var require_form_data = __commonJS((exports, module) => {
   var setToStringTag = require_es_set_tostringtag();
   var hasOwn = require_hasown();
   var populate = require_populate();
+  function escapeHeaderParam(str) {
+    return String(str).replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/"/g, "%22");
+  }
   function FormData2(options) {
     if (!(this instanceof FormData2)) {
       return new FormData2(options);
@@ -10379,7 +10834,7 @@ var require_form_data = __commonJS((exports, module) => {
     var contentType = this._getContentType(value, options);
     var contents = "";
     var headers = {
-      "Content-Disposition": ["form-data", 'name="' + field + '"'].concat(contentDisposition || []),
+      "Content-Disposition": ["form-data", 'name="' + escapeHeaderParam(field) + '"'].concat(contentDisposition || []),
       "Content-Type": [].concat(contentType || [])
     };
     if (typeof options.header === "object") {
@@ -10412,7 +10867,7 @@ var require_form_data = __commonJS((exports, module) => {
       filename = path.basename(value.client._httpMessage.path || "");
     }
     if (filename) {
-      return 'filename="' + filename + '"';
+      return 'filename="' + escapeHeaderParam(filename) + '"';
     }
   };
   FormData2.prototype._getContentType = function(value, options) {
@@ -10589,14 +11044,14 @@ var require_form_data = __commonJS((exports, module) => {
   module.exports = FormData2;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/platform/node/classes/FormData.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/platform/node/classes/FormData.js
 var import_form_data, FormData_default;
 var init_FormData = __esm(() => {
   import_form_data = __toESM(require_form_data(), 1);
   FormData_default = import_form_data.default;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/toFormData.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/toFormData.js
 function isVisitable(thing) {
   return utils_default.isPlainObject(thing) || utils_default.isArray(thing);
 }
@@ -10631,7 +11086,9 @@ function toFormData(obj, formData, options) {
   const dots = options.dots;
   const indexes = options.indexes;
   const _Blob = options.Blob || typeof Blob !== "undefined" && Blob;
+  const maxDepth = options.maxDepth === undefined ? DEFAULT_FORM_DATA_MAX_DEPTH : options.maxDepth;
   const useBlob = _Blob && utils_default.isSpecCompliantForm(formData);
+  const stack = [];
   if (!utils_default.isFunction(visitor)) {
     throw new TypeError("visitor must be a function");
   }
@@ -10648,10 +11105,38 @@ function toFormData(obj, formData, options) {
       throw new AxiosError_default("Blob is not supported. Use a Buffer instead.");
     }
     if (utils_default.isArrayBuffer(value) || utils_default.isTypedArray(value)) {
-      return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
+      if (useBlob && typeof _Blob === "function") {
+        return new _Blob([value]);
+      }
+      if (typeof Buffer !== "undefined") {
+        return Buffer.from(value);
+      }
+      throw new AxiosError_default("Blob is not supported. Use a Buffer instead.", AxiosError_default.ERR_NOT_SUPPORT);
     }
     return value;
   }
+  function throwIfMaxDepthExceeded(depth) {
+    if (depth > maxDepth) {
+      throw new AxiosError_default("Object is too deeply nested (" + depth + " levels). Max depth: " + maxDepth, AxiosError_default.ERR_FORM_DATA_DEPTH_EXCEEDED);
+    }
+  }
+  function stringifyWithDepthLimit(value, depth) {
+    if (maxDepth === Infinity) {
+      return JSON.stringify(value);
+    }
+    const ancestors = [];
+    return JSON.stringify(value, function limitDepth(_key, currentValue) {
+      if (!utils_default.isObject(currentValue)) {
+        return currentValue;
+      }
+      while (ancestors.length && ancestors[ancestors.length - 1] !== this) {
+        ancestors.pop();
+      }
+      ancestors.push(currentValue);
+      throwIfMaxDepthExceeded(depth + ancestors.length - 1);
+      return currentValue;
+    });
+  }
   function defaultVisitor(value, key, path) {
     let arr = value;
     if (utils_default.isReactNative(formData) && utils_default.isReactNativeBlob(value)) {
@@ -10661,7 +11146,7 @@ function toFormData(obj, formData, options) {
     if (value && !path && typeof value === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
-        value = JSON.stringify(value);
+        value = stringifyWithDepthLimit(value, 1);
       } else if (utils_default.isArray(value) && isFlatArray(value) || (utils_default.isFileList(value) || utils_default.endsWith(key, "[]")) && (arr = utils_default.toArray(value))) {
         key = removeBrackets(key);
         arr.forEach(function each(el, index) {
@@ -10676,23 +11161,23 @@ function toFormData(obj, formData, options) {
     formData.append(renderKey(path, key, dots), convertValue(value));
     return false;
   }
-  const stack = [];
   const exposedHelpers = Object.assign(predicates, {
     defaultVisitor,
     convertValue,
     isVisitable
   });
-  function build(value, path) {
+  function build(value, path, depth = 0) {
     if (utils_default.isUndefined(value))
       return;
+    throwIfMaxDepthExceeded(depth);
     if (stack.indexOf(value) !== -1) {
-      throw Error("Circular reference detected in " + path.join("."));
+      throw new Error("Circular reference detected in " + path.join("."));
     }
     stack.push(value);
     utils_default.forEach(value, function each(el, key) {
       const result = !(utils_default.isUndefined(el) || el === null) && visitor.call(formData, el, utils_default.isString(key) ? key.trim() : key, path, exposedHelpers);
       if (result === true) {
-        build(el, path ? path.concat(key) : [key]);
+        build(el, path ? path.concat(key) : [key], depth + 1);
       }
     });
     stack.pop();
@@ -10703,7 +11188,7 @@ function toFormData(obj, formData, options) {
   build(obj);
   return formData;
 }
-var predicates, toFormData_default;
+var DEFAULT_FORM_DATA_MAX_DEPTH = 100, predicates, toFormData_default;
 var init_toFormData = __esm(() => {
   init_utils();
   init_AxiosError();
@@ -10714,7 +11199,7 @@ var init_toFormData = __esm(() => {
   toFormData_default = toFormData;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/AxiosURLSearchParams.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/AxiosURLSearchParams.js
 function encode(str) {
   const charMap = {
     "!": "%21",
@@ -10722,10 +11207,9 @@ function encode(str) {
     "(": "%28",
     ")": "%29",
     "~": "%7E",
-    "%20": "+",
-    "%00": "\x00"
+    "%20": "+"
   };
-  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
+  return encodeURIComponent(str).replace(/[!'()~]|%20/g, function replacer(match) {
     return charMap[match];
   });
 }
@@ -10741,9 +11225,7 @@ var init_AxiosURLSearchParams = __esm(() => {
     this._pairs.push([name, value]);
   };
   prototype.toString = function toString2(encoder) {
-    const _encode = encoder ? function(value) {
-      return encoder.call(this, value, encode);
-    } : encode;
+    const _encode = encoder ? (value) => encoder.call(this, value, encode) : encode;
     return this._pairs.map(function each(pair) {
       return _encode(pair[0]) + "=" + _encode(pair[1]);
     }, "").join("&");
@@ -10751,7 +11233,7 @@ var init_AxiosURLSearchParams = __esm(() => {
   AxiosURLSearchParams_default = AxiosURLSearchParams;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/buildURL.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/buildURL.js
 function encode2(val) {
   return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+");
 }
@@ -10759,11 +11241,12 @@ function buildURL(url, params, options) {
   if (!params) {
     return url;
   }
-  const _encode = options && options.encode || encode2;
+  url = url || "";
   const _options = utils_default.isFunction(options) ? {
     serialize: options
   } : options;
-  const serializeFn = _options && _options.serialize;
+  const _encode = utils_default.getSafeProp(_options, "encode") || encode2;
+  const serializeFn = utils_default.getSafeProp(_options, "serialize");
   let serializedParams;
   if (serializeFn) {
     serializedParams = serializeFn(params, _options);
@@ -10784,7 +11267,7 @@ var init_buildURL = __esm(() => {
   init_AxiosURLSearchParams();
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/core/InterceptorManager.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/core/InterceptorManager.js
 class InterceptorManager {
   constructor() {
     this.handlers = [];
@@ -10822,25 +11305,27 @@ var init_InterceptorManager = __esm(() => {
   InterceptorManager_default = InterceptorManager;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/defaults/transitional.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/defaults/transitional.js
 var transitional_default;
 var init_transitional = __esm(() => {
   transitional_default = {
     silentJSONParsing: true,
     forcedJSONParsing: true,
     clarifyTimeoutError: false,
-    legacyInterceptorReqResOrdering: true
+    legacyInterceptorReqResOrdering: true,
+    advertiseZstdAcceptEncoding: false,
+    validateStatusUndefinedResolves: true
   };
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/platform/node/classes/URLSearchParams.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/platform/node/classes/URLSearchParams.js
 import url from "url";
 var URLSearchParams_default;
 var init_URLSearchParams = __esm(() => {
   URLSearchParams_default = url.URLSearchParams;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/platform/node/index.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/platform/node/index.js
 import crypto from "crypto";
 var ALPHA = "abcdefghijklmnopqrstuvwxyz", DIGIT = "0123456789", ALPHABET, generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
   let str = "";
@@ -10873,7 +11358,7 @@ var init_node = __esm(() => {
   };
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/platform/common/utils.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/platform/common/utils.js
 var exports_utils = {};
 __export(exports_utils, {
   origin: () => origin,
@@ -10893,7 +11378,7 @@ var init_utils2 = __esm(() => {
   origin = hasBrowserEnv && window.location.href || "http://localhost";
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/platform/index.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/platform/index.js
 var platform_default;
 var init_platform = __esm(() => {
   init_node();
@@ -10904,7 +11389,7 @@ var init_platform = __esm(() => {
   };
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/toURLEncodedForm.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/toURLEncodedForm.js
 function toURLEncodedForm(data, options) {
   return toFormData_default(data, new platform_default.classes.URLSearchParams, {
     visitor: function(value, key, path, helpers) {
@@ -10923,11 +11408,21 @@ var init_toURLEncodedForm = __esm(() => {
   init_platform();
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/formDataToJSON.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/formDataToJSON.js
+function throwIfDepthExceeded(index) {
+  if (index > MAX_DEPTH) {
+    throw new AxiosError_default("FormData field is too deeply nested (" + index + " levels). Max depth: " + MAX_DEPTH, AxiosError_default.ERR_FORM_DATA_DEPTH_EXCEEDED);
+  }
+}
 function parsePropPath(name) {
-  return utils_default.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
-    return match[0] === "[]" ? "" : match[1] || match[0];
-  });
+  const path = [];
+  const pattern = /\w+|\[(\w*)]/g;
+  let match;
+  while ((match = pattern.exec(name)) !== null) {
+    throwIfDepthExceeded(path.length);
+    path.push(match[0] === "[]" ? "" : match[1] || match[0]);
+  }
+  return path;
 }
 function arrayToObject(arr) {
   const obj = {};
@@ -10943,6 +11438,7 @@ function arrayToObject(arr) {
 }
 function formDataToJSON(formData) {
   function buildPath(path, value, target, index) {
+    throwIfDepthExceeded(index);
     let name = path[index++];
     if (name === "__proto__")
       return true;
@@ -10951,13 +11447,13 @@ function formDataToJSON(formData) {
     name = !name && utils_default.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils_default.hasOwnProp(target, name)) {
-        target[name] = [target[name], value];
+        target[name] = utils_default.isArray(target[name]) ? target[name].concat(value) : [target[name], value];
       } else {
         target[name] = value;
       }
       return !isNumericKey;
     }
-    if (!target[name] || !utils_default.isObject(target[name])) {
+    if (!utils_default.hasOwnProp(target, name) || !utils_default.isObject(target[name])) {
       target[name] = [];
     }
     const result = buildPath(path, value, target[name], index);
@@ -10975,13 +11471,16 @@ function formDataToJSON(formData) {
   }
   return null;
 }
-var formDataToJSON_default;
+var MAX_DEPTH, formDataToJSON_default;
 var init_formDataToJSON = __esm(() => {
   init_utils();
+  init_AxiosError();
+  init_toFormData();
+  MAX_DEPTH = DEFAULT_FORM_DATA_MAX_DEPTH;
   formDataToJSON_default = formDataToJSON;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/defaults/index.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/defaults/index.js
 function stringifySafely(rawValue, parser, encoder) {
   if (utils_default.isString(rawValue)) {
     try {
@@ -10995,7 +11494,7 @@ function stringifySafely(rawValue, parser, encoder) {
   }
   return (encoder || JSON.stringify)(rawValue);
 }
-var defaults, defaults_default;
+var own = (obj, key) => obj != null && utils_default.hasOwnProp(obj, key) ? obj[key] : undefined, defaults, defaults_default;
 var init_defaults = __esm(() => {
   init_utils();
   init_AxiosError();
@@ -11031,363 +11530,75 @@ var init_defaults = __esm(() => {
         }
         let isFileList2;
         if (isObjectPayload) {
-          if (contentType.indexOf("application/x-www-form-urlencoded") > -1) {
-            return toURLEncodedForm(data, this.formSerializer).toString();
-          }
-          if ((isFileList2 = utils_default.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
-            const _FormData = this.env && this.env.FormData;
-            return toFormData_default(isFileList2 ? { "files[]": data } : data, _FormData && new _FormData, this.formSerializer);
-          }
-        }
-        if (isObjectPayload || hasJSONContentType) {
-          headers.setContentType("application/json", false);
-          return stringifySafely(data);
-        }
-        return data;
-      }
-    ],
-    transformResponse: [
-      function transformResponse(data) {
-        const transitional = this.transitional || defaults.transitional;
-        const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
-        const JSONRequested = this.responseType === "json";
-        if (utils_default.isResponse(data) || utils_default.isReadableStream(data)) {
-          return data;
-        }
-        if (data && utils_default.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
-          const silentJSONParsing = transitional && transitional.silentJSONParsing;
-          const strictJSONParsing = !silentJSONParsing && JSONRequested;
-          try {
-            return JSON.parse(data, this.parseReviver);
-          } catch (e) {
-            if (strictJSONParsing) {
-              if (e.name === "SyntaxError") {
-                throw AxiosError_default.from(e, AxiosError_default.ERR_BAD_RESPONSE, this, null, this.response);
-              }
-              throw e;
-            }
-          }
-        }
-        return data;
-      }
-    ],
-    timeout: 0,
-    xsrfCookieName: "XSRF-TOKEN",
-    xsrfHeaderName: "X-XSRF-TOKEN",
-    maxContentLength: -1,
-    maxBodyLength: -1,
-    env: {
-      FormData: platform_default.classes.FormData,
-      Blob: platform_default.classes.Blob
-    },
-    validateStatus: function validateStatus(status) {
-      return status >= 200 && status < 300;
-    },
-    headers: {
-      common: {
-        Accept: "application/json, text/plain, */*",
-        "Content-Type": undefined
-      }
-    }
-  };
-  utils_default.forEach(["delete", "get", "head", "post", "put", "patch"], (method) => {
-    defaults.headers[method] = {};
-  });
-  defaults_default = defaults;
-});
-
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/parseHeaders.js
-var ignoreDuplicateOf, parseHeaders_default = (rawHeaders) => {
-  const parsed = {};
-  let key;
-  let val;
-  let i;
-  rawHeaders && rawHeaders.split(`
-`).forEach(function parser(line) {
-    i = line.indexOf(":");
-    key = line.substring(0, i).trim().toLowerCase();
-    val = line.substring(i + 1).trim();
-    if (!key || parsed[key] && ignoreDuplicateOf[key]) {
-      return;
-    }
-    if (key === "set-cookie") {
-      if (parsed[key]) {
-        parsed[key].push(val);
-      } else {
-        parsed[key] = [val];
-      }
-    } else {
-      parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
-    }
-  });
-  return parsed;
-};
-var init_parseHeaders = __esm(() => {
-  init_utils();
-  ignoreDuplicateOf = utils_default.toObjectSet([
-    "age",
-    "authorization",
-    "content-length",
-    "content-type",
-    "etag",
-    "expires",
-    "from",
-    "host",
-    "if-modified-since",
-    "if-unmodified-since",
-    "last-modified",
-    "location",
-    "max-forwards",
-    "proxy-authorization",
-    "referer",
-    "retry-after",
-    "user-agent"
-  ]);
-});
-
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/core/AxiosHeaders.js
-function normalizeHeader(header) {
-  return header && String(header).trim().toLowerCase();
-}
-function normalizeValue(value) {
-  if (value === false || value == null) {
-    return value;
-  }
-  return utils_default.isArray(value) ? value.map(normalizeValue) : String(value).replace(/[\r\n]+$/, "");
-}
-function parseTokens(str) {
-  const tokens = Object.create(null);
-  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
-  let match;
-  while (match = tokensRE.exec(str)) {
-    tokens[match[1]] = match[2];
-  }
-  return tokens;
-}
-function matchHeaderValue(context, value, header, filter2, isHeaderNameFilter) {
-  if (utils_default.isFunction(filter2)) {
-    return filter2.call(this, value, header);
-  }
-  if (isHeaderNameFilter) {
-    value = header;
-  }
-  if (!utils_default.isString(value))
-    return;
-  if (utils_default.isString(filter2)) {
-    return value.indexOf(filter2) !== -1;
-  }
-  if (utils_default.isRegExp(filter2)) {
-    return filter2.test(value);
-  }
-}
-function formatHeader(header) {
-  return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
-    return char.toUpperCase() + str;
-  });
-}
-function buildAccessors(obj, header) {
-  const accessorName = utils_default.toCamelCase(" " + header);
-  ["get", "set", "has"].forEach((methodName) => {
-    Object.defineProperty(obj, methodName + accessorName, {
-      value: function(arg1, arg2, arg3) {
-        return this[methodName].call(this, header, arg1, arg2, arg3);
-      },
-      configurable: true
-    });
-  });
-}
-var $internals, isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim()), AxiosHeaders, AxiosHeaders_default;
-var init_AxiosHeaders = __esm(() => {
-  init_utils();
-  init_parseHeaders();
-  $internals = Symbol("internals");
-  AxiosHeaders = class AxiosHeaders {
-    constructor(headers) {
-      headers && this.set(headers);
-    }
-    set(header, valueOrRewrite, rewrite) {
-      const self2 = this;
-      function setHeader(_value, _header, _rewrite) {
-        const lHeader = normalizeHeader(_header);
-        if (!lHeader) {
-          throw new Error("header name must be a non-empty string");
-        }
-        const key = utils_default.findKey(self2, lHeader);
-        if (!key || self2[key] === undefined || _rewrite === true || _rewrite === undefined && self2[key] !== false) {
-          self2[key || _header] = normalizeValue(_value);
-        }
-      }
-      const setHeaders = (headers, _rewrite) => utils_default.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
-      if (utils_default.isPlainObject(header) || header instanceof this.constructor) {
-        setHeaders(header, valueOrRewrite);
-      } else if (utils_default.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
-        setHeaders(parseHeaders_default(header), valueOrRewrite);
-      } else if (utils_default.isObject(header) && utils_default.isIterable(header)) {
-        let obj = {}, dest, key;
-        for (const entry of header) {
-          if (!utils_default.isArray(entry)) {
-            throw TypeError("Object iterator must return a key-value pair");
-          }
-          obj[key = entry[0]] = (dest = obj[key]) ? utils_default.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
-        }
-        setHeaders(obj, valueOrRewrite);
-      } else {
-        header != null && setHeader(valueOrRewrite, header, rewrite);
-      }
-      return this;
-    }
-    get(header, parser) {
-      header = normalizeHeader(header);
-      if (header) {
-        const key = utils_default.findKey(this, header);
-        if (key) {
-          const value = this[key];
-          if (!parser) {
-            return value;
-          }
-          if (parser === true) {
-            return parseTokens(value);
-          }
-          if (utils_default.isFunction(parser)) {
-            return parser.call(this, value, key);
-          }
-          if (utils_default.isRegExp(parser)) {
-            return parser.exec(value);
-          }
-          throw new TypeError("parser must be boolean|regexp|function");
-        }
-      }
-    }
-    has(header, matcher) {
-      header = normalizeHeader(header);
-      if (header) {
-        const key = utils_default.findKey(this, header);
-        return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
-      }
-      return false;
-    }
-    delete(header, matcher) {
-      const self2 = this;
-      let deleted = false;
-      function deleteHeader(_header) {
-        _header = normalizeHeader(_header);
-        if (_header) {
-          const key = utils_default.findKey(self2, _header);
-          if (key && (!matcher || matchHeaderValue(self2, self2[key], key, matcher))) {
-            delete self2[key];
-            deleted = true;
-          }
-        }
-      }
-      if (utils_default.isArray(header)) {
-        header.forEach(deleteHeader);
-      } else {
-        deleteHeader(header);
-      }
-      return deleted;
-    }
-    clear(matcher) {
-      const keys = Object.keys(this);
-      let i = keys.length;
-      let deleted = false;
-      while (i--) {
-        const key = keys[i];
-        if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
-          delete this[key];
-          deleted = true;
-        }
-      }
-      return deleted;
-    }
-    normalize(format) {
-      const self2 = this;
-      const headers = {};
-      utils_default.forEach(this, (value, header) => {
-        const key = utils_default.findKey(headers, header);
-        if (key) {
-          self2[key] = normalizeValue(value);
-          delete self2[header];
-          return;
+          const formSerializer = own(this, "formSerializer");
+          if (contentType.indexOf("application/x-www-form-urlencoded") > -1) {
+            return toURLEncodedForm(data, formSerializer).toString();
+          }
+          if ((isFileList2 = utils_default.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
+            const env = own(this, "env");
+            const _FormData = env && env.FormData;
+            return toFormData_default(isFileList2 ? { "files[]": data } : data, _FormData && new _FormData, formSerializer);
+          }
         }
-        const normalized = format ? formatHeader(header) : String(header).trim();
-        if (normalized !== header) {
-          delete self2[header];
+        if (isObjectPayload || hasJSONContentType) {
+          headers.setContentType("application/json", false);
+          return stringifySafely(data);
         }
-        self2[normalized] = normalizeValue(value);
-        headers[normalized] = true;
-      });
-      return this;
-    }
-    concat(...targets) {
-      return this.constructor.concat(this, ...targets);
-    }
-    toJSON(asStrings) {
-      const obj = Object.create(null);
-      utils_default.forEach(this, (value, header) => {
-        value != null && value !== false && (obj[header] = asStrings && utils_default.isArray(value) ? value.join(", ") : value);
-      });
-      return obj;
-    }
-    [Symbol.iterator]() {
-      return Object.entries(this.toJSON())[Symbol.iterator]();
-    }
-    toString() {
-      return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join(`
-`);
-    }
-    getSetCookie() {
-      return this.get("set-cookie") || [];
-    }
-    get [Symbol.toStringTag]() {
-      return "AxiosHeaders";
-    }
-    static from(thing) {
-      return thing instanceof this ? thing : new this(thing);
-    }
-    static concat(first, ...targets) {
-      const computed = new this(first);
-      targets.forEach((target) => computed.set(target));
-      return computed;
-    }
-    static accessor(header) {
-      const internals = this[$internals] = this[$internals] = {
-        accessors: {}
-      };
-      const accessors = internals.accessors;
-      const prototype2 = this.prototype;
-      function defineAccessor(_header) {
-        const lHeader = normalizeHeader(_header);
-        if (!accessors[lHeader]) {
-          buildAccessors(prototype2, _header);
-          accessors[lHeader] = true;
+        return data;
+      }
+    ],
+    transformResponse: [
+      function transformResponse(data) {
+        const transitional = own(this, "transitional") || defaults.transitional;
+        const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+        const responseType = own(this, "responseType");
+        const JSONRequested = responseType === "json";
+        if (utils_default.isResponse(data) || utils_default.isReadableStream(data)) {
+          return data;
+        }
+        if (data && utils_default.isString(data) && (forcedJSONParsing && !responseType || JSONRequested)) {
+          const silentJSONParsing = transitional && transitional.silentJSONParsing;
+          const strictJSONParsing = !silentJSONParsing && JSONRequested;
+          try {
+            return JSON.parse(data, own(this, "parseReviver"));
+          } catch (e) {
+            if (strictJSONParsing) {
+              if (e.name === "SyntaxError") {
+                throw AxiosError_default.from(e, AxiosError_default.ERR_BAD_RESPONSE, this, null, own(this, "response"));
+              }
+              throw e;
+            }
+          }
         }
+        return data;
+      }
+    ],
+    timeout: 0,
+    xsrfCookieName: "XSRF-TOKEN",
+    xsrfHeaderName: "X-XSRF-TOKEN",
+    maxContentLength: -1,
+    maxBodyLength: -1,
+    env: {
+      FormData: platform_default.classes.FormData,
+      Blob: platform_default.classes.Blob
+    },
+    validateStatus: function validateStatus(status) {
+      return status >= 200 && status < 300;
+    },
+    headers: {
+      common: {
+        Accept: "application/json, text/plain, */*",
+        "Content-Type": undefined
       }
-      utils_default.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
-      return this;
     }
   };
-  AxiosHeaders.accessor([
-    "Content-Type",
-    "Content-Length",
-    "Accept",
-    "Accept-Encoding",
-    "User-Agent",
-    "Authorization"
-  ]);
-  utils_default.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
-    let mapped = key[0].toUpperCase() + key.slice(1);
-    return {
-      get: () => value,
-      set(headerValue) {
-        this[mapped] = headerValue;
-      }
-    };
+  utils_default.forEach(["delete", "get", "head", "post", "put", "patch", "query"], (method) => {
+    defaults.headers[method] = {};
   });
-  utils_default.freezeMethods(AxiosHeaders);
-  AxiosHeaders_default = AxiosHeaders;
+  defaults_default = defaults;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/core/transformData.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/core/transformData.js
 function transformData(fns, response) {
   const config = this || defaults_default;
   const context = response || config;
@@ -11405,13 +11616,13 @@ var init_transformData = __esm(() => {
   init_AxiosHeaders();
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/cancel/isCancel.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/cancel/isCancel.js
 function isCancel(value) {
   return !!(value && value.__CANCEL__);
 }
 var init_isCancel = () => {};
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/cancel/CanceledError.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/cancel/CanceledError.js
 var CanceledError, CanceledError_default;
 var init_CanceledError = __esm(() => {
   init_AxiosError();
@@ -11425,20 +11636,20 @@ var init_CanceledError = __esm(() => {
   CanceledError_default = CanceledError;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/core/settle.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/core/settle.js
 function settle(resolve, reject, response) {
   const validateStatus2 = response.config.validateStatus;
   if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
     resolve(response);
   } else {
-    reject(new AxiosError_default("Request failed with status code " + response.status, [AxiosError_default.ERR_BAD_REQUEST, AxiosError_default.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], response.config, response.request, response));
+    reject(new AxiosError_default("Request failed with status code " + response.status, response.status >= 400 && response.status < 500 ? AxiosError_default.ERR_BAD_REQUEST : AxiosError_default.ERR_BAD_RESPONSE, response.config, response.request, response));
   }
 }
 var init_settle = __esm(() => {
   init_AxiosError();
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/isAbsoluteURL.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/isAbsoluteURL.js
 function isAbsoluteURL(url2) {
   if (typeof url2 !== "string") {
     return false;
@@ -11447,23 +11658,44 @@ function isAbsoluteURL(url2) {
 }
 var init_isAbsoluteURL = () => {};
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/combineURLs.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/combineURLs.js
 function combineURLs(baseURL, relativeURL) {
   return relativeURL ? baseURL.replace(/\/?\/$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
 }
 var init_combineURLs = () => {};
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/core/buildFullPath.js
-function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/core/buildFullPath.js
+function stripLeadingC0ControlOrSpace(url2) {
+  let i = 0;
+  while (i < url2.length && url2.charCodeAt(i) <= 32) {
+    i++;
+  }
+  return url2.slice(i);
+}
+function normalizeURLForProtocolCheck(url2) {
+  return stripLeadingC0ControlOrSpace(url2).replace(httpProtocolControlCharacters, "");
+}
+function assertValidHttpProtocolURL(url2, config) {
+  if (typeof url2 === "string" && malformedHttpProtocol.test(normalizeURLForProtocolCheck(url2))) {
+    throw new AxiosError_default('Invalid URL: missing "//" after protocol', AxiosError_default.ERR_INVALID_URL, config);
+  }
+}
+function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls, config) {
+  assertValidHttpProtocolURL(requestedURL, config);
   let isRelativeUrl = !isAbsoluteURL(requestedURL);
-  if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
+  if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) {
+    assertValidHttpProtocolURL(baseURL, config);
     return combineURLs(baseURL, requestedURL);
   }
   return requestedURL;
 }
+var malformedHttpProtocol, httpProtocolControlCharacters;
 var init_buildFullPath = __esm(() => {
+  init_AxiosError();
   init_isAbsoluteURL();
   init_combineURLs();
+  malformedHttpProtocol = /^https?:(?!\/\/)/i;
+  httpProtocolControlCharacters = /[\t\n\r]/g;
 });
 
 // node_modules/.bun/proxy-from-env@2.1.0/node_modules/proxy-from-env/index.js
@@ -11488,55 +11720,484 @@ function getProxyForUrl(url2) {
   if (!shouldProxy(hostname, port)) {
     return "";
   }
-  var proxy = getEnv(proto + "_proxy") || getEnv("all_proxy");
-  if (proxy && proxy.indexOf("://") === -1) {
-    proxy = proto + "://" + proxy;
+  var proxy = getEnv(proto + "_proxy") || getEnv("all_proxy");
+  if (proxy && proxy.indexOf("://") === -1) {
+    proxy = proto + "://" + proxy;
+  }
+  return proxy;
+}
+function shouldProxy(hostname, port) {
+  var NO_PROXY = getEnv("no_proxy").toLowerCase();
+  if (!NO_PROXY) {
+    return true;
+  }
+  if (NO_PROXY === "*") {
+    return false;
+  }
+  return NO_PROXY.split(/[,\s]/).every(function(proxy) {
+    if (!proxy) {
+      return true;
+    }
+    var parsedProxy = proxy.match(/^(.+):(\d+)$/);
+    var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
+    var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
+    if (parsedProxyPort && parsedProxyPort !== port) {
+      return true;
+    }
+    if (!/^[.*]/.test(parsedProxyHostname)) {
+      return hostname !== parsedProxyHostname;
+    }
+    if (parsedProxyHostname.charAt(0) === "*") {
+      parsedProxyHostname = parsedProxyHostname.slice(1);
+    }
+    return !hostname.endsWith(parsedProxyHostname);
+  });
+}
+function getEnv(key) {
+  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || "";
+}
+var DEFAULT_PORTS;
+var init_proxy_from_env = __esm(() => {
+  DEFAULT_PORTS = {
+    ftp: 21,
+    gopher: 70,
+    http: 80,
+    https: 443,
+    ws: 80,
+    wss: 443
+  };
+});
+
+// node_modules/.bun/agent-base@6.0.2/node_modules/agent-base/dist/src/promisify.js
+var require_promisify = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  function promisify(fn) {
+    return function(req, opts) {
+      return new Promise((resolve, reject) => {
+        fn.call(this, req, opts, (err, rtn) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(rtn);
+          }
+        });
+      });
+    };
+  }
+  exports.default = promisify;
+});
+
+// node_modules/.bun/agent-base@6.0.2/node_modules/agent-base/dist/src/index.js
+var require_src2 = __commonJS((exports, module) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  var events_1 = __require("events");
+  var debug_1 = __importDefault(require_src());
+  var promisify_1 = __importDefault(require_promisify());
+  var debug = debug_1.default("agent-base");
+  function isAgent(v) {
+    return Boolean(v) && typeof v.addRequest === "function";
+  }
+  function isSecureEndpoint() {
+    const { stack } = new Error;
+    if (typeof stack !== "string")
+      return false;
+    return stack.split(`
+`).some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+  }
+  function createAgent(callback, opts) {
+    return new createAgent.Agent(callback, opts);
+  }
+  (function(createAgent2) {
+
+    class Agent extends events_1.EventEmitter {
+      constructor(callback, _opts) {
+        super();
+        let opts = _opts;
+        if (typeof callback === "function") {
+          this.callback = callback;
+        } else if (callback) {
+          opts = callback;
+        }
+        this.timeout = null;
+        if (opts && typeof opts.timeout === "number") {
+          this.timeout = opts.timeout;
+        }
+        this.maxFreeSockets = 1;
+        this.maxSockets = 1;
+        this.maxTotalSockets = Infinity;
+        this.sockets = {};
+        this.freeSockets = {};
+        this.requests = {};
+        this.options = {};
+      }
+      get defaultPort() {
+        if (typeof this.explicitDefaultPort === "number") {
+          return this.explicitDefaultPort;
+        }
+        return isSecureEndpoint() ? 443 : 80;
+      }
+      set defaultPort(v) {
+        this.explicitDefaultPort = v;
+      }
+      get protocol() {
+        if (typeof this.explicitProtocol === "string") {
+          return this.explicitProtocol;
+        }
+        return isSecureEndpoint() ? "https:" : "http:";
+      }
+      set protocol(v) {
+        this.explicitProtocol = v;
+      }
+      callback(req, opts, fn) {
+        throw new Error('"agent-base" has no default implementation, you must subclass and override `callback()`');
+      }
+      addRequest(req, _opts) {
+        const opts = Object.assign({}, _opts);
+        if (typeof opts.secureEndpoint !== "boolean") {
+          opts.secureEndpoint = isSecureEndpoint();
+        }
+        if (opts.host == null) {
+          opts.host = "localhost";
+        }
+        if (opts.port == null) {
+          opts.port = opts.secureEndpoint ? 443 : 80;
+        }
+        if (opts.protocol == null) {
+          opts.protocol = opts.secureEndpoint ? "https:" : "http:";
+        }
+        if (opts.host && opts.path) {
+          delete opts.path;
+        }
+        delete opts.agent;
+        delete opts.hostname;
+        delete opts._defaultAgent;
+        delete opts.defaultPort;
+        delete opts.createConnection;
+        req._last = true;
+        req.shouldKeepAlive = false;
+        let timedOut = false;
+        let timeoutId = null;
+        const timeoutMs = opts.timeout || this.timeout;
+        const onerror = (err) => {
+          if (req._hadError)
+            return;
+          req.emit("error", err);
+          req._hadError = true;
+        };
+        const ontimeout = () => {
+          timeoutId = null;
+          timedOut = true;
+          const err = new Error(`A "socket" was not created for HTTP request before ${timeoutMs}ms`);
+          err.code = "ETIMEOUT";
+          onerror(err);
+        };
+        const callbackError = (err) => {
+          if (timedOut)
+            return;
+          if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+          }
+          onerror(err);
+        };
+        const onsocket = (socket) => {
+          if (timedOut)
+            return;
+          if (timeoutId != null) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+          }
+          if (isAgent(socket)) {
+            debug("Callback returned another Agent instance %o", socket.constructor.name);
+            socket.addRequest(req, opts);
+            return;
+          }
+          if (socket) {
+            socket.once("free", () => {
+              this.freeSocket(socket, opts);
+            });
+            req.onSocket(socket);
+            return;
+          }
+          const err = new Error(`no Duplex stream was returned to agent-base for \`${req.method} ${req.path}\``);
+          onerror(err);
+        };
+        if (typeof this.callback !== "function") {
+          onerror(new Error("`callback` is not defined"));
+          return;
+        }
+        if (!this.promisifiedCallback) {
+          if (this.callback.length >= 3) {
+            debug("Converting legacy callback function to promise");
+            this.promisifiedCallback = promisify_1.default(this.callback);
+          } else {
+            this.promisifiedCallback = this.callback;
+          }
+        }
+        if (typeof timeoutMs === "number" && timeoutMs > 0) {
+          timeoutId = setTimeout(ontimeout, timeoutMs);
+        }
+        if ("port" in opts && typeof opts.port !== "number") {
+          opts.port = Number(opts.port);
+        }
+        try {
+          debug("Resolving socket for %o request: %o", opts.protocol, `${req.method} ${req.path}`);
+          Promise.resolve(this.promisifiedCallback(req, opts)).then(onsocket, callbackError);
+        } catch (err) {
+          Promise.reject(err).catch(callbackError);
+        }
+      }
+      freeSocket(socket, opts) {
+        debug("Freeing socket %o %o", socket.constructor.name, opts);
+        socket.destroy();
+      }
+      destroy() {
+        debug("Destroying agent %o", this.constructor.name);
+      }
+    }
+    createAgent2.Agent = Agent;
+    createAgent2.prototype = createAgent2.Agent.prototype;
+  })(createAgent || (createAgent = {}));
+  module.exports = createAgent;
+});
+
+// node_modules/.bun/https-proxy-agent@5.0.1/node_modules/https-proxy-agent/dist/parse-proxy-response.js
+var require_parse_proxy_response = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var debug_1 = __importDefault(require_src());
+  var debug = debug_1.default("https-proxy-agent:parse-proxy-response");
+  function parseProxyResponse(socket) {
+    return new Promise((resolve, reject) => {
+      let buffersLength = 0;
+      const buffers = [];
+      function read() {
+        const b = socket.read();
+        if (b)
+          ondata(b);
+        else
+          socket.once("readable", read);
+      }
+      function cleanup() {
+        socket.removeListener("end", onend);
+        socket.removeListener("error", onerror);
+        socket.removeListener("close", onclose);
+        socket.removeListener("readable", read);
+      }
+      function onclose(err) {
+        debug("onclose had error %o", err);
+      }
+      function onend() {
+        debug("onend");
+      }
+      function onerror(err) {
+        cleanup();
+        debug("onerror %o", err);
+        reject(err);
+      }
+      function ondata(b) {
+        buffers.push(b);
+        buffersLength += b.length;
+        const buffered = Buffer.concat(buffers, buffersLength);
+        const endOfHeaders = buffered.indexOf(`\r
+\r
+`);
+        if (endOfHeaders === -1) {
+          debug("have not received end of HTTP headers yet...");
+          read();
+          return;
+        }
+        const firstLine = buffered.toString("ascii", 0, buffered.indexOf(`\r
+`));
+        const statusCode = +firstLine.split(" ")[1];
+        debug("got proxy server response: %o", firstLine);
+        resolve({
+          statusCode,
+          buffered
+        });
+      }
+      socket.on("error", onerror);
+      socket.on("close", onclose);
+      socket.on("end", onend);
+      read();
+    });
+  }
+  exports.default = parseProxyResponse;
+});
+
+// node_modules/.bun/https-proxy-agent@5.0.1/node_modules/https-proxy-agent/dist/agent.js
+var require_agent = __commonJS((exports) => {
+  var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var net_1 = __importDefault(__require("net"));
+  var tls_1 = __importDefault(__require("tls"));
+  var url_1 = __importDefault(__require("url"));
+  var assert_1 = __importDefault(__require("assert"));
+  var debug_1 = __importDefault(require_src());
+  var agent_base_1 = require_src2();
+  var parse_proxy_response_1 = __importDefault(require_parse_proxy_response());
+  var debug = debug_1.default("https-proxy-agent:agent");
+
+  class HttpsProxyAgent extends agent_base_1.Agent {
+    constructor(_opts) {
+      let opts;
+      if (typeof _opts === "string") {
+        opts = url_1.default.parse(_opts);
+      } else {
+        opts = _opts;
+      }
+      if (!opts) {
+        throw new Error("an HTTP(S) proxy server `host` and `port` must be specified!");
+      }
+      debug("creating new HttpsProxyAgent instance: %o", opts);
+      super(opts);
+      const proxy = Object.assign({}, opts);
+      this.secureProxy = opts.secureProxy || isHTTPS(proxy.protocol);
+      proxy.host = proxy.hostname || proxy.host;
+      if (typeof proxy.port === "string") {
+        proxy.port = parseInt(proxy.port, 10);
+      }
+      if (!proxy.port && proxy.host) {
+        proxy.port = this.secureProxy ? 443 : 80;
+      }
+      if (this.secureProxy && !("ALPNProtocols" in proxy)) {
+        proxy.ALPNProtocols = ["http 1.1"];
+      }
+      if (proxy.host && proxy.path) {
+        delete proxy.path;
+        delete proxy.pathname;
+      }
+      this.proxy = proxy;
+    }
+    callback(req, opts) {
+      return __awaiter(this, undefined, undefined, function* () {
+        const { proxy, secureProxy } = this;
+        let socket;
+        if (secureProxy) {
+          debug("Creating `tls.Socket`: %o", proxy);
+          socket = tls_1.default.connect(proxy);
+        } else {
+          debug("Creating `net.Socket`: %o", proxy);
+          socket = net_1.default.connect(proxy);
+        }
+        const headers = Object.assign({}, proxy.headers);
+        const hostname = `${opts.host}:${opts.port}`;
+        let payload = `CONNECT ${hostname} HTTP/1.1\r
+`;
+        if (proxy.auth) {
+          headers["Proxy-Authorization"] = `Basic ${Buffer.from(proxy.auth).toString("base64")}`;
+        }
+        let { host, port, secureEndpoint } = opts;
+        if (!isDefaultPort(port, secureEndpoint)) {
+          host += `:${port}`;
+        }
+        headers.Host = host;
+        headers.Connection = "close";
+        for (const name of Object.keys(headers)) {
+          payload += `${name}: ${headers[name]}\r
+`;
+        }
+        const proxyResponsePromise = parse_proxy_response_1.default(socket);
+        socket.write(`${payload}\r
+`);
+        const { statusCode, buffered } = yield proxyResponsePromise;
+        if (statusCode === 200) {
+          req.once("socket", resume);
+          if (opts.secureEndpoint) {
+            debug("Upgrading socket connection to TLS");
+            const servername = opts.servername || opts.host;
+            return tls_1.default.connect(Object.assign(Object.assign({}, omit(opts, "host", "hostname", "path", "port")), {
+              socket,
+              servername
+            }));
+          }
+          return socket;
+        }
+        socket.destroy();
+        const fakeSocket = new net_1.default.Socket({ writable: false });
+        fakeSocket.readable = true;
+        req.once("socket", (s) => {
+          debug("replaying proxy buffer for failed request");
+          assert_1.default(s.listenerCount("data") > 0);
+          s.push(buffered);
+          s.push(null);
+        });
+        return fakeSocket;
+      });
+    }
+  }
+  exports.default = HttpsProxyAgent;
+  function resume(socket) {
+    socket.resume();
   }
-  return proxy;
-}
-function shouldProxy(hostname, port) {
-  var NO_PROXY = getEnv("no_proxy").toLowerCase();
-  if (!NO_PROXY) {
-    return true;
+  function isDefaultPort(port, secure) {
+    return Boolean(!secure && port === 80 || secure && port === 443);
   }
-  if (NO_PROXY === "*") {
-    return false;
+  function isHTTPS(protocol) {
+    return typeof protocol === "string" ? /^https:?$/i.test(protocol) : false;
   }
-  return NO_PROXY.split(/[,\s]/).every(function(proxy) {
-    if (!proxy) {
-      return true;
-    }
-    var parsedProxy = proxy.match(/^(.+):(\d+)$/);
-    var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
-    var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
-    if (parsedProxyPort && parsedProxyPort !== port) {
-      return true;
-    }
-    if (!/^[.*]/.test(parsedProxyHostname)) {
-      return hostname !== parsedProxyHostname;
-    }
-    if (parsedProxyHostname.charAt(0) === "*") {
-      parsedProxyHostname = parsedProxyHostname.slice(1);
+  function omit(obj, ...keys) {
+    const ret = {};
+    let key;
+    for (key in obj) {
+      if (!keys.includes(key)) {
+        ret[key] = obj[key];
+      }
     }
-    return !hostname.endsWith(parsedProxyHostname);
-  });
-}
-function getEnv(key) {
-  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || "";
-}
-var DEFAULT_PORTS;
-var init_proxy_from_env = __esm(() => {
-  DEFAULT_PORTS = {
-    ftp: 21,
-    gopher: 70,
-    http: 80,
-    https: 443,
-    ws: 80,
-    wss: 443
+    return ret;
+  }
+});
+
+// node_modules/.bun/https-proxy-agent@5.0.1/node_modules/https-proxy-agent/dist/index.js
+var require_dist = __commonJS((exports, module) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
   };
+  var agent_1 = __importDefault(require_agent());
+  function createHttpsProxyAgent(opts) {
+    return new agent_1.default(opts);
+  }
+  (function(createHttpsProxyAgent2) {
+    createHttpsProxyAgent2.HttpsProxyAgent = agent_1.default;
+    createHttpsProxyAgent2.prototype = agent_1.default.prototype;
+  })(createHttpsProxyAgent || (createHttpsProxyAgent = {}));
+  module.exports = createHttpsProxyAgent;
 });
 
-// node_modules/.bun/follow-redirects@1.15.11/node_modules/follow-redirects/debug.js
+// node_modules/.bun/follow-redirects@1.16.0/node_modules/follow-redirects/debug.js
 var require_debug = __commonJS((exports, module) => {
   var debug;
   module.exports = function() {
@@ -11552,7 +12213,7 @@ var require_debug = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/.bun/follow-redirects@1.15.11/node_modules/follow-redirects/index.js
+// node_modules/.bun/follow-redirects@1.16.0/node_modules/follow-redirects/index.js
 var require_follow_redirects = __commonJS((exports, module) => {
   var url2 = __require("url");
   var URL2 = url2.URL;
@@ -11575,6 +12236,11 @@ var require_follow_redirects = __commonJS((exports, module) => {
   } catch (error) {
     useNativeURL = error.code === "ERR_INVALID_URL";
   }
+  var sensitiveHeaders = [
+    "Authorization",
+    "Proxy-Authorization",
+    "Cookie"
+  ];
   var preservedUrlFields = [
     "auth",
     "host",
@@ -11622,6 +12288,7 @@ var require_follow_redirects = __commonJS((exports, module) => {
         self2.emit("error", cause instanceof RedirectionError ? cause : new RedirectionError({ cause }));
       }
     };
+    this._headerFilter = new RegExp("^(?:" + sensitiveHeaders.concat(options.sensitiveHeaders).map(escapeRegex).join("|") + ")$", "i");
     this._performRequest();
   }
   RedirectableRequest.prototype = Object.create(Writable.prototype);
@@ -11759,6 +12426,9 @@ var require_follow_redirects = __commonJS((exports, module) => {
     if (!options.headers) {
       options.headers = {};
     }
+    if (!isArray2(options.sensitiveHeaders)) {
+      options.sensitiveHeaders = [];
+    }
     if (options.host) {
       if (!options.hostname) {
         options.hostname = options.host;
@@ -11855,7 +12525,7 @@ var require_follow_redirects = __commonJS((exports, module) => {
     this._isRedirect = true;
     spreadUrlObject(redirectUrl, this._options);
     if (redirectUrl.protocol !== currentUrlParts.protocol && redirectUrl.protocol !== "https:" || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) {
-      removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
+      removeMatchingHeaders(this._headerFilter, this._options.headers);
     }
     if (isFunction2(beforeRedirect)) {
       var responseDetails = {
@@ -12003,6 +12673,9 @@ var require_follow_redirects = __commonJS((exports, module) => {
     var dot = subdomain.length - domain.length - 1;
     return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
   }
+  function isArray2(value) {
+    return value instanceof Array;
+  }
   function isString2(value) {
     return typeof value === "string" || value instanceof String;
   }
@@ -12015,22 +12688,25 @@ var require_follow_redirects = __commonJS((exports, module) => {
   function isURL(value) {
     return URL2 && value instanceof URL2;
   }
+  function escapeRegex(regex) {
+    return regex.replace(/[\]\\/()*+?.$]/g, "\\$&");
+  }
   module.exports = wrap({ http, https });
   module.exports.wrap = wrap;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/env/data.js
-var VERSION = "1.14.0";
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/env/data.js
+var VERSION = "1.18.1";
 var init_data = () => {};
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/parseProtocol.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/parseProtocol.js
 function parseProtocol(url2) {
-  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url2);
+  const match = /^([-+\w]{1,25}):(?:\/\/)?/.exec(url2);
   return match && match[1] || "";
 }
 var init_parseProtocol = () => {};
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/fromDataURI.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/fromDataURI.js
 function fromDataURI(uri, asBlob, options) {
   const _Blob = options && options.Blob || platform_default.classes.Blob;
   const protocol = parseProtocol(uri);
@@ -12043,10 +12719,17 @@ function fromDataURI(uri, asBlob, options) {
     if (!match) {
       throw new AxiosError_default("Invalid URL", AxiosError_default.ERR_INVALID_URL);
     }
-    const mime = match[1];
-    const isBase64 = match[2];
-    const body = match[3];
-    const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? "base64" : "utf8");
+    const type = match[1];
+    const params = match[2];
+    const encoding = match[3] ? "base64" : "utf8";
+    const body = match[4];
+    let mime = "";
+    if (type) {
+      mime = params ? type + params : type;
+    } else if (params) {
+      mime = "text/plain" + params;
+    }
+    const buffer = encoding === "base64" ? Buffer.from(body, "base64") : Buffer.from(decodeURIComponent(body), encoding);
     if (asBlob) {
       if (!_Blob) {
         throw new AxiosError_default("Blob is not supported", AxiosError_default.ERR_NOT_SUPPORT);
@@ -12062,10 +12745,10 @@ var init_fromDataURI = __esm(() => {
   init_AxiosError();
   init_parseProtocol();
   init_platform();
-  DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
+  DATA_URL_PATTERN = /^([^,;]+\/[^,;]+)?((?:;[^,;=]+=[^,;]+)*)(;base64)?,([\s\S]*)$/;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/AxiosTransformStream.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/AxiosTransformStream.js
 import stream from "stream";
 var kInternals, AxiosTransformStream, AxiosTransformStream_default;
 var init_AxiosTransformStream = __esm(() => {
@@ -12184,7 +12867,7 @@ var init_AxiosTransformStream = __esm(() => {
   AxiosTransformStream_default = AxiosTransformStream;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/readBlob.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/readBlob.js
 var asyncIterator, readBlob = async function* (blob) {
   if (blob.stream) {
     yield* blob.stream();
@@ -12201,7 +12884,7 @@ var init_readBlob = __esm(() => {
   readBlob_default = readBlob;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/formDataToStream.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/formDataToStream.js
 import util from "util";
 import { Readable } from "stream";
 
@@ -12213,7 +12896,8 @@ class FormDataPart {
     if (isStringValue) {
       value = textEncoder.encode(String(value).replace(/\r?\n|\r\n?/g, CRLF));
     } else {
-      headers += `Content-Type: ${value.type || "application/octet-stream"}${CRLF}`;
+      const safeType = String(value.type || "application/octet-stream").replace(/[\r\n]/g, "");
+      headers += `Content-Type: ${safeType}${CRLF}`;
     }
     this.headers = textEncoder.encode(headers + CRLF);
     this.contentLength = isStringValue ? value.byteLength : value.size;
@@ -12247,10 +12931,10 @@ var BOUNDARY_ALPHABET, textEncoder, CRLF = `\r
     boundary = tag + "-" + platform_default.generateString(size, BOUNDARY_ALPHABET)
   } = options || {};
   if (!utils_default.isFormData(form)) {
-    throw TypeError("FormData instance required");
+    throw new TypeError("FormData instance required");
   }
   if (boundary.length < 1 || boundary.length > 70) {
-    throw Error("boundary must be 10-70 characters long");
+    throw new Error("boundary must be 1-70 characters long");
   }
   const boundaryBytes = textEncoder.encode("--" + boundary + CRLF);
   const footerBytes = textEncoder.encode("--" + boundary + "--" + CRLF);
@@ -12287,7 +12971,7 @@ var init_formDataToStream = __esm(() => {
   formDataToStream_default = formDataToStream;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/ZlibHeaderTransformStream.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/ZlibHeaderTransformStream.js
 import stream2 from "stream";
 var ZlibHeaderTransformStream, ZlibHeaderTransformStream_default;
 var init_ZlibHeaderTransformStream = __esm(() => {
@@ -12312,7 +12996,89 @@ var init_ZlibHeaderTransformStream = __esm(() => {
   ZlibHeaderTransformStream_default = ZlibHeaderTransformStream;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/callbackify.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/Http2Sessions.js
+import http2 from "http2";
+import util2 from "util";
+
+class Http2Sessions {
+  constructor() {
+    this.sessions = Object.create(null);
+  }
+  getSession(authority, options) {
+    options = Object.assign({
+      sessionTimeout: 1000
+    }, options);
+    let authoritySessions = this.sessions[authority];
+    if (authoritySessions) {
+      let len = authoritySessions.length;
+      for (let i = 0;i < len; i++) {
+        const [sessionHandle, sessionOptions] = authoritySessions[i];
+        if (!sessionHandle.destroyed && !sessionHandle.closed && util2.isDeepStrictEqual(sessionOptions, options)) {
+          return sessionHandle;
+        }
+      }
+    }
+    const session = http2.connect(authority, options);
+    let removed;
+    let timer;
+    const removeSession = () => {
+      if (removed) {
+        return;
+      }
+      removed = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      let entries = authoritySessions, len = entries.length, i = len;
+      while (i--) {
+        if (entries[i][0] === session) {
+          if (len === 1) {
+            delete this.sessions[authority];
+          } else {
+            entries.splice(i, 1);
+          }
+          if (!session.closed) {
+            session.close();
+          }
+          return;
+        }
+      }
+    };
+    const originalRequestFn = session.request;
+    const { sessionTimeout } = options;
+    if (sessionTimeout != null) {
+      let streamsCount = 0;
+      session.request = function() {
+        const stream3 = originalRequestFn.apply(this, arguments);
+        streamsCount++;
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        stream3.once("close", () => {
+          if (!--streamsCount) {
+            timer = setTimeout(() => {
+              timer = null;
+              removeSession();
+            }, sessionTimeout);
+          }
+        });
+        return stream3;
+      };
+    }
+    session.once("close", removeSession);
+    let entry = [session, options];
+    authoritySessions ? authoritySessions.push(entry) : authoritySessions = this.sessions[authority] = [entry];
+    return session;
+  }
+}
+var Http2Sessions_default;
+var init_Http2Sessions = __esm(() => {
+  Http2Sessions_default = Http2Sessions;
+});
+
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/callbackify.js
 var callbackify = (fn, reducer) => {
   return utils_default.isAsyncFn(fn) ? function(...args) {
     const cb = args.pop();
@@ -12330,7 +13096,154 @@ var init_callbackify = __esm(() => {
   callbackify_default = callbackify;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/speedometer.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/shouldBypassProxy.js
+function shouldBypassProxy(location) {
+  let parsed;
+  try {
+    parsed = new URL(location);
+  } catch (_err) {
+    return false;
+  }
+  const noProxy = (process.env.no_proxy || process.env.NO_PROXY || "").toLowerCase();
+  if (!noProxy) {
+    return false;
+  }
+  if (noProxy === "*") {
+    return true;
+  }
+  const port = Number.parseInt(parsed.port, 10) || DEFAULT_PORTS2[parsed.protocol.split(":", 1)[0]] || 0;
+  const hostname = normalizeNoProxyHost(parsed.hostname.toLowerCase());
+  return noProxy.split(/[\s,]+/).some((entry) => {
+    if (!entry) {
+      return false;
+    }
+    let [entryHost, entryPort] = parseNoProxyEntry(entry);
+    entryHost = normalizeNoProxyHost(entryHost);
+    if (!entryHost) {
+      return false;
+    }
+    if (entryPort && entryPort !== port) {
+      return false;
+    }
+    if (entryHost.charAt(0) === "*") {
+      entryHost = entryHost.slice(1);
+    }
+    if (entryHost.charAt(0) === ".") {
+      return hostname.endsWith(entryHost);
+    }
+    return hostname === entryHost || isLoopback(hostname) && isLoopback(entryHost);
+  });
+}
+var LOOPBACK_HOSTNAMES, isIPv4Loopback = (host) => {
+  const parts = host.split(".");
+  if (parts.length !== 4)
+    return false;
+  if (parts[0] !== "127")
+    return false;
+  return parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255);
+}, isIPv6ZeroGroup = (group) => /^0{1,4}$/.test(group), isIPv6Unspecified = (host) => {
+  if (host === "::")
+    return true;
+  const compressionIndex = host.indexOf("::");
+  if (compressionIndex !== -1) {
+    if (compressionIndex !== host.lastIndexOf("::"))
+      return false;
+    const left = host.slice(0, compressionIndex);
+    const right = host.slice(compressionIndex + 2);
+    const leftGroups = left ? left.split(":") : [];
+    const rightGroups = right ? right.split(":") : [];
+    const explicitGroups = leftGroups.length + rightGroups.length;
+    return explicitGroups < 8 && leftGroups.every(isIPv6ZeroGroup) && rightGroups.every(isIPv6ZeroGroup);
+  }
+  const groups = host.split(":");
+  return groups.length === 8 && groups.every(isIPv6ZeroGroup);
+}, isIPv6Loopback = (host) => {
+  if (host === "::1")
+    return true;
+  const v4MappedDotted = host.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
+  if (v4MappedDotted)
+    return isIPv4Loopback(v4MappedDotted[1]);
+  const v4MappedHex = host.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
+  if (v4MappedHex) {
+    const high = parseInt(v4MappedHex[1], 16);
+    return high >= 32512 && high <= 32767;
+  }
+  const groups = host.split(":");
+  if (groups.length === 8) {
+    for (let i = 0;i < 7; i++) {
+      if (!/^0+$/.test(groups[i]))
+        return false;
+    }
+    return /^0*1$/.test(groups[7]);
+  }
+  return false;
+}, isLoopback = (host) => {
+  if (!host)
+    return false;
+  if (LOOPBACK_HOSTNAMES.has(host))
+    return true;
+  if (isIPv4Loopback(host))
+    return true;
+  if (isIPv6Unspecified(host))
+    return true;
+  return isIPv6Loopback(host);
+}, DEFAULT_PORTS2, parseNoProxyEntry = (entry) => {
+  let entryHost = entry;
+  let entryPort = 0;
+  if (entryHost.charAt(0) === "[") {
+    const bracketIndex = entryHost.indexOf("]");
+    if (bracketIndex !== -1) {
+      const host = entryHost.slice(1, bracketIndex);
+      const rest = entryHost.slice(bracketIndex + 1);
+      if (rest.charAt(0) === ":" && /^\d+$/.test(rest.slice(1))) {
+        entryPort = Number.parseInt(rest.slice(1), 10);
+      }
+      return [host, entryPort];
+    }
+  }
+  const firstColon = entryHost.indexOf(":");
+  const lastColon = entryHost.lastIndexOf(":");
+  if (firstColon !== -1 && firstColon === lastColon && /^\d+$/.test(entryHost.slice(lastColon + 1))) {
+    entryPort = Number.parseInt(entryHost.slice(lastColon + 1), 10);
+    entryHost = entryHost.slice(0, lastColon);
+  }
+  return [entryHost, entryPort];
+}, IPV4_MAPPED_DOTTED_RE, IPV4_MAPPED_HEX_RE, unmapIPv4MappedIPv6 = (host) => {
+  if (typeof host !== "string" || host.indexOf(":") === -1)
+    return host;
+  const dotted = host.match(IPV4_MAPPED_DOTTED_RE);
+  if (dotted)
+    return dotted[1];
+  const hex = host.match(IPV4_MAPPED_HEX_RE);
+  if (hex) {
+    const high = parseInt(hex[1], 16);
+    const low = parseInt(hex[2], 16);
+    return `${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`;
+  }
+  return host;
+}, normalizeNoProxyHost = (hostname) => {
+  if (!hostname) {
+    return hostname;
+  }
+  if (hostname.charAt(0) === "[" && hostname.charAt(hostname.length - 1) === "]") {
+    hostname = hostname.slice(1, -1);
+  }
+  return unmapIPv4MappedIPv6(hostname.replace(/\.+$/, ""));
+};
+var init_shouldBypassProxy = __esm(() => {
+  LOOPBACK_HOSTNAMES = new Set(["localhost", "0.0.0.0"]);
+  DEFAULT_PORTS2 = {
+    http: 80,
+    https: 443,
+    ws: 80,
+    wss: 443,
+    ftp: 21
+  };
+  IPV4_MAPPED_DOTTED_RE = /^(?:::|(?:0{1,4}:){1,4}:|(?:0{1,4}:){5})ffff:(\d+\.\d+\.\d+\.\d+)$/i;
+  IPV4_MAPPED_HEX_RE = /^(?:::|(?:0{1,4}:){1,4}:|(?:0{1,4}:){5})ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i;
+});
+
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/speedometer.js
 function speedometer(samplesCount, min) {
   samplesCount = samplesCount || 10;
   const bytes = new Array(samplesCount);
@@ -12369,7 +13282,7 @@ var init_speedometer = __esm(() => {
   speedometer_default = speedometer;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/throttle.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/throttle.js
 function throttle(fn, freq) {
   let timestamp = 0;
   let threshold = 1000 / freq;
@@ -12407,24 +13320,27 @@ var init_throttle = __esm(() => {
   throttle_default = throttle;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/progressEventReducer.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/progressEventReducer.js
 var progressEventReducer = (listener, isDownloadStream, freq = 3) => {
   let bytesNotified = 0;
   const _speedometer = speedometer_default(50, 250);
   return throttle_default((e) => {
-    const loaded = e.loaded;
+    if (!e || typeof e.loaded !== "number") {
+      return;
+    }
+    const rawLoaded = e.loaded;
     const total = e.lengthComputable ? e.total : undefined;
-    const progressBytes = loaded - bytesNotified;
+    const loaded = total != null ? Math.min(rawLoaded, total) : rawLoaded;
+    const progressBytes = Math.max(0, loaded - bytesNotified);
     const rate = _speedometer(progressBytes);
-    const inRange = loaded <= total;
-    bytesNotified = loaded;
+    bytesNotified = Math.max(bytesNotified, loaded);
     const data = {
       loaded,
       total,
       progress: total ? loaded / total : undefined,
       bytes: progressBytes,
       rate: rate ? rate : undefined,
-      estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
+      estimated: rate && total ? (total - loaded) / rate : undefined,
       event: e,
       lengthComputable: total != null,
       [isDownloadStream ? "download" : "upload"]: true
@@ -12448,7 +13364,7 @@ var init_progressEventReducer = __esm(() => {
   init_utils();
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/estimateDataURLDecodedBytes.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/estimateDataURLDecodedBytes.js
 function estimateDataURLDecodedBytes(url2) {
   if (!url2 || typeof url2 !== "string")
     return 0;
@@ -12467,163 +13383,264 @@ function estimateDataURLDecodedBytes(url2) {
       if (body.charCodeAt(i) === 37 && i + 2 < len) {
         const a = body.charCodeAt(i + 1);
         const b = body.charCodeAt(i + 2);
-        const isHex = (a >= 48 && a <= 57 || a >= 65 && a <= 70 || a >= 97 && a <= 102) && (b >= 48 && b <= 57 || b >= 65 && b <= 70 || b >= 97 && b <= 102);
+        const isHex = isHexDigit(a) && isHexDigit(b);
         if (isHex) {
           effectiveLen -= 2;
-          i += 2;
-        }
-      }
-    }
-    let pad = 0;
-    let idx = len - 1;
-    const tailIsPct3D = (j) => j >= 2 && body.charCodeAt(j - 2) === 37 && body.charCodeAt(j - 1) === 51 && (body.charCodeAt(j) === 68 || body.charCodeAt(j) === 100);
-    if (idx >= 0) {
-      if (body.charCodeAt(idx) === 61) {
-        pad++;
-        idx--;
-      } else if (tailIsPct3D(idx)) {
-        pad++;
-        idx -= 3;
-      }
-    }
-    if (pad === 1 && idx >= 0) {
-      if (body.charCodeAt(idx) === 61) {
-        pad++;
-      } else if (tailIsPct3D(idx)) {
-        pad++;
-      }
-    }
-    const groups = Math.floor(effectiveLen / 4);
-    const bytes = groups * 3 - (pad || 0);
-    return bytes > 0 ? bytes : 0;
-  }
-  return Buffer.byteLength(body, "utf8");
-}
-var init_estimateDataURLDecodedBytes = () => {};
-
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/adapters/http.js
-import http from "http";
-import https from "https";
-import http2 from "http2";
-import util2 from "util";
-import zlib from "zlib";
-import stream3 from "stream";
-import { EventEmitter } from "events";
-
-class Http2Sessions {
-  constructor() {
-    this.sessions = Object.create(null);
-  }
-  getSession(authority, options) {
-    options = Object.assign({
-      sessionTimeout: 1000
-    }, options);
-    let authoritySessions = this.sessions[authority];
-    if (authoritySessions) {
-      let len = authoritySessions.length;
-      for (let i = 0;i < len; i++) {
-        const [sessionHandle, sessionOptions] = authoritySessions[i];
-        if (!sessionHandle.destroyed && !sessionHandle.closed && util2.isDeepStrictEqual(sessionOptions, options)) {
-          return sessionHandle;
-        }
-      }
-    }
-    const session = http2.connect(authority, options);
-    let removed;
-    const removeSession = () => {
-      if (removed) {
-        return;
-      }
-      removed = true;
-      let entries = authoritySessions, len = entries.length, i = len;
-      while (i--) {
-        if (entries[i][0] === session) {
-          if (len === 1) {
-            delete this.sessions[authority];
-          } else {
-            entries.splice(i, 1);
-          }
-          if (!session.closed) {
-            session.close();
-          }
-          return;
-        }
-      }
-    };
-    const originalRequestFn = session.request;
-    const { sessionTimeout } = options;
-    if (sessionTimeout != null) {
-      let timer;
-      let streamsCount = 0;
-      session.request = function() {
-        const stream4 = originalRequestFn.apply(this, arguments);
-        streamsCount++;
-        if (timer) {
-          clearTimeout(timer);
-          timer = null;
+          i += 2;
         }
-        stream4.once("close", () => {
-          if (!--streamsCount) {
-            timer = setTimeout(() => {
-              timer = null;
-              removeSession();
-            }, sessionTimeout);
-          }
-        });
-        return stream4;
-      };
+      }
     }
-    session.once("close", removeSession);
-    let entry = [session, options];
-    authoritySessions ? authoritySessions.push(entry) : authoritySessions = this.sessions[authority] = [entry];
-    return session;
+    let pad = 0;
+    let idx = len - 1;
+    const tailIsPct3D = (j) => j >= 2 && body.charCodeAt(j - 2) === 37 && body.charCodeAt(j - 1) === 51 && (body.charCodeAt(j) === 68 || body.charCodeAt(j) === 100);
+    if (idx >= 0) {
+      if (body.charCodeAt(idx) === 61) {
+        pad++;
+        idx--;
+      } else if (tailIsPct3D(idx)) {
+        pad++;
+        idx -= 3;
+      }
+    }
+    if (pad === 1 && idx >= 0) {
+      if (body.charCodeAt(idx) === 61) {
+        pad++;
+      } else if (tailIsPct3D(idx)) {
+        pad++;
+      }
+    }
+    const groups = Math.floor(effectiveLen / 4);
+    const bytes2 = groups * 3 - (pad || 0);
+    return bytes2 > 0 ? bytes2 : 0;
+  }
+  let bytes = 0;
+  for (let i = 0, len = body.length;i < len; i++) {
+    const c = body.charCodeAt(i);
+    if (c === 37 && isPercentEncodedByte(body, i, len)) {
+      bytes += 1;
+      i += 2;
+    } else if (c < 128) {
+      bytes += 1;
+    } else if (c < 2048) {
+      bytes += 2;
+    } else if (c >= 55296 && c <= 56319 && i + 1 < len) {
+      const next = body.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i++;
+      } else {
+        bytes += 3;
+      }
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+var isHexDigit = (charCode) => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 70 || charCode >= 97 && charCode <= 102, isPercentEncodedByte = (str, i, len) => i + 2 < len && isHexDigit(str.charCodeAt(i + 1)) && isHexDigit(str.charCodeAt(i + 2));
+var init_estimateDataURLDecodedBytes = () => {};
+
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/adapters/http.js
+import http from "http";
+import https from "https";
+import http22 from "http2";
+import util3 from "util";
+import { resolve as resolvePath } from "path";
+import zlib from "zlib";
+import stream3 from "stream";
+import { EventEmitter } from "events";
+function setFormDataHeaders(headers, formHeaders, policy) {
+  if (policy !== "content-only") {
+    headers.set(formHeaders);
+    return;
+  }
+  Object.entries(formHeaders).forEach(([key, val]) => {
+    if (FORM_DATA_CONTENT_HEADERS.includes(key.toLowerCase())) {
+      headers.set(key, val);
+    }
+  });
+}
+function isNodeNativeEnvProxySupported(nodeVersion = process.versions && process.versions.node) {
+  if (!nodeVersion) {
+    return false;
+  }
+  const [major, minor] = nodeVersion.split(".").map((part) => Number(part));
+  if (!Number.isInteger(major) || !Number.isInteger(minor)) {
+    return false;
+  }
+  if (major > 24) {
+    return true;
+  }
+  return NODE_NATIVE_ENV_PROXY_SUPPORT[major] != null && minor >= NODE_NATIVE_ENV_PROXY_SUPPORT[major];
+}
+function isNodeEnvProxyEnabled(agent, nodeVersion = process.versions && process.versions.node) {
+  if (!isNodeNativeEnvProxySupported(nodeVersion)) {
+    return false;
+  }
+  const agentOptions = agent && agent.options;
+  return Boolean(agentOptions && utils_default.hasOwnProp(agentOptions, "proxyEnv") && agentOptions.proxyEnv != null);
+}
+function getProxyEnvAgent(options, configHttpAgent, configHttpsAgent) {
+  return isHttps.test(options.protocol) ? configHttpsAgent || https.globalAgent : configHttpAgent || http.globalAgent;
+}
+function getTunnelingAgent(agentOptions, userHttpsAgent) {
+  const key = agentOptions.protocol + "//" + agentOptions.hostname + ":" + (agentOptions.port || "") + "#" + (agentOptions.auth || "");
+  const cache = userHttpsAgent ? tunnelingAgentCacheUser.get(userHttpsAgent) || tunnelingAgentCacheUser.set(userHttpsAgent, new Map).get(userHttpsAgent) : tunnelingAgentCache;
+  let agent = cache.get(key);
+  if (agent)
+    return agent;
+  const merged = userHttpsAgent && userHttpsAgent.options ? { ...userHttpsAgent.options, ...agentOptions } : agentOptions;
+  agent = new import_https_proxy_agent.default(merged);
+  if (userHttpsAgent && userHttpsAgent.options) {
+    const originTLSOptions = { ...userHttpsAgent.options };
+    const callback = agent.callback;
+    agent.callback = function axiosTunnelingAgentCallback(req, opts) {
+      return callback.call(this, req, { ...originTLSOptions, ...opts });
+    };
   }
+  agent[kAxiosInstalledTunnel] = true;
+  cache.set(key, agent);
+  return agent;
 }
-function dispatchBeforeRedirect(options, responseDetails) {
+function dispatchBeforeRedirect(options, responseDetails, requestDetails) {
   if (options.beforeRedirects.proxy) {
     options.beforeRedirects.proxy(options);
   }
+  if (options.beforeRedirects.auth) {
+    options.beforeRedirects.auth(options);
+  }
+  if (options.beforeRedirects.sensitiveHeaders) {
+    options.beforeRedirects.sensitiveHeaders(options, requestDetails);
+  }
   if (options.beforeRedirects.config) {
-    options.beforeRedirects.config(options, responseDetails);
+    options.beforeRedirects.config(options, responseDetails, requestDetails);
+  }
+}
+function stripMatchingHeaders(headers, sensitiveSet) {
+  if (!headers) {
+    return;
+  }
+  Object.keys(headers).forEach((header) => {
+    if (sensitiveSet.has(header.toLowerCase())) {
+      delete headers[header];
+    }
+  });
+}
+function isSameOriginRedirect(redirectOptions, requestDetails) {
+  if (!requestDetails) {
+    return false;
+  }
+  try {
+    return new URL(requestDetails.url).origin === new URL(redirectOptions.href).origin;
+  } catch (e) {
+    return false;
   }
 }
-function setProxy(options, configProxy, location) {
+function setProxy(options, configProxy, location, isRedirect, configHttpsAgent, configHttpAgent) {
   let proxy = configProxy;
-  if (!proxy && proxy !== false) {
+  const proxyEnvAgent = getProxyEnvAgent(options, configHttpAgent, configHttpsAgent);
+  if (!proxy && proxy !== false && !isNodeEnvProxyEnabled(proxyEnvAgent)) {
     const proxyUrl = getProxyForUrl(location);
     if (proxyUrl) {
-      proxy = new URL(proxyUrl);
+      if (!shouldBypassProxy(location)) {
+        proxy = new URL(proxyUrl);
+      }
     }
   }
-  if (proxy) {
-    if (proxy.username) {
-      proxy.auth = (proxy.username || "") + ":" + (proxy.password || "");
+  if (isRedirect && options.headers) {
+    for (const name of Object.keys(options.headers)) {
+      if (name.toLowerCase() === "proxy-authorization") {
+        delete options.headers[name];
+      }
     }
-    if (proxy.auth) {
-      const validProxyAuth = Boolean(proxy.auth.username || proxy.auth.password);
+  }
+  if (isRedirect && options.agent && options.agent[kAxiosInstalledTunnel]) {
+    options.agent = undefined;
+  }
+  if (proxy) {
+    const isProxyURL = proxy instanceof URL;
+    const readProxyField = (key) => isProxyURL || utils_default.hasOwnProp(proxy, key) ? proxy[key] : undefined;
+    const proxyUsername = readProxyField("username");
+    const proxyPassword = readProxyField("password");
+    let proxyAuth = utils_default.hasOwnProp(proxy, "auth") ? proxy.auth : undefined;
+    if (proxyUsername) {
+      proxyAuth = (proxyUsername || "") + ":" + (proxyPassword || "");
+    }
+    if (proxyAuth) {
+      const authIsObject = typeof proxyAuth === "object";
+      const authUsername = authIsObject && utils_default.hasOwnProp(proxyAuth, "username") ? proxyAuth.username : undefined;
+      const authPassword = authIsObject && utils_default.hasOwnProp(proxyAuth, "password") ? proxyAuth.password : undefined;
+      const validProxyAuth = Boolean(authUsername || authPassword);
       if (validProxyAuth) {
-        proxy.auth = (proxy.auth.username || "") + ":" + (proxy.auth.password || "");
-      } else if (typeof proxy.auth === "object") {
+        proxyAuth = (authUsername || "") + ":" + (authPassword || "");
+      } else if (authIsObject) {
         throw new AxiosError_default("Invalid proxy authorization", AxiosError_default.ERR_BAD_OPTION, { proxy });
       }
-      const base64 = Buffer.from(proxy.auth, "utf8").toString("base64");
-      options.headers["Proxy-Authorization"] = "Basic " + base64;
     }
-    options.headers.host = options.hostname + (options.port ? ":" + options.port : "");
-    const proxyHost = proxy.hostname || proxy.host;
-    options.hostname = proxyHost;
-    options.host = proxyHost;
-    options.port = proxy.port;
-    options.path = location;
-    if (proxy.protocol) {
-      options.protocol = proxy.protocol.includes(":") ? proxy.protocol : `${proxy.protocol}:`;
+    const targetIsHttps = isHttps.test(options.protocol);
+    if (targetIsHttps) {
+      if (!(configHttpsAgent instanceof import_https_proxy_agent.default)) {
+        const proxyHost = readProxyField("hostname") || readProxyField("host");
+        const proxyPort = readProxyField("port");
+        const rawProxyProtocol = readProxyField("protocol");
+        const normalizedProtocol = rawProxyProtocol ? rawProxyProtocol.includes(":") ? rawProxyProtocol : `${rawProxyProtocol}:` : "http:";
+        const proxyHostForURL = proxyHost && proxyHost.includes(":") && !proxyHost.startsWith("[") ? `[${proxyHost}]` : proxyHost;
+        const proxyURL = new URL(`${normalizedProtocol}//${proxyHostForURL}${proxyPort ? ":" + proxyPort : ""}`);
+        const agentOptions = {
+          protocol: proxyURL.protocol,
+          hostname: proxyURL.hostname.replace(/^\[|\]$/g, ""),
+          port: proxyURL.port,
+          auth: proxyAuth && typeof proxyAuth === "string" ? proxyAuth : undefined
+        };
+        if (proxyURL.protocol === "https:") {
+          agentOptions.ALPNProtocols = ["http/1.1"];
+        }
+        const tunnelingAgent = getTunnelingAgent(agentOptions, configHttpsAgent);
+        options.agent = tunnelingAgent;
+        if (options.agents) {
+          options.agents.https = tunnelingAgent;
+        }
+      }
+    } else {
+      if (proxyAuth) {
+        const base64 = Buffer.from(proxyAuth, "utf8").toString("base64");
+        options.headers["Proxy-Authorization"] = "Basic " + base64;
+      }
+      let hasUserHostHeader = false;
+      for (const name of Object.keys(options.headers)) {
+        if (name.toLowerCase() === "host") {
+          hasUserHostHeader = true;
+          break;
+        }
+      }
+      if (!hasUserHostHeader) {
+        options.headers.host = options.hostname + (options.port ? ":" + options.port : "");
+      }
+      const proxyHost = readProxyField("hostname") || readProxyField("host");
+      options.hostname = proxyHost;
+      options.host = proxyHost;
+      options.port = readProxyField("port");
+      options.path = location;
+      const proxyProtocol = readProxyField("protocol");
+      if (proxyProtocol) {
+        options.protocol = proxyProtocol.includes(":") ? proxyProtocol : `${proxyProtocol}:`;
+      }
     }
   }
   options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) {
-    setProxy(redirectOptions, configProxy, redirectOptions.href);
+    setProxy(redirectOptions, configProxy, redirectOptions.href, true, configHttpsAgent, configHttpAgent);
   };
 }
-var import_follow_redirects, zlibOptions, brotliOptions, isBrotliSupported, httpFollow, httpsFollow, isHttps, supportedProtocols, flushOnFinish = (stream4, [throttled, flush]) => {
+var import_https_proxy_agent, import_follow_redirects, zlibOptions, brotliOptions, zstdOptions, isBrotliSupported, isZstdSupported, ACCEPT_ENCODING, ACCEPT_ENCODING_WITH_ZSTD, httpFollow, httpsFollow, isHttps, FORM_DATA_CONTENT_HEADERS, kAxiosSocketListener, kAxiosCurrentReq, kAxiosInstalledTunnel, tunnelingAgentCache, tunnelingAgentCacheUser, NODE_NATIVE_ENV_PROXY_SUPPORT, supportedProtocols, decodeURIComponentSafe = (value) => {
+  if (!utils_default.isString(value)) {
+    return value;
+  }
+  try {
+    return decodeURIComponent(value);
+  } catch (error) {
+    return value;
+  }
+}, flushOnFinish = (stream4, [throttled, flush]) => {
   stream4.on("end", flush).on("error", flush);
   return throttled;
 }, http2Sessions, isHttpAdapterSupported, wrapAsync = (asyncExecutor) => {
@@ -12672,9 +13689,13 @@ var init_http = __esm(() => {
   init_formDataToStream();
   init_readBlob();
   init_ZlibHeaderTransformStream();
+  init_Http2Sessions();
   init_callbackify();
+  init_shouldBypassProxy();
+  init_sanitizeHeaderValue();
   init_progressEventReducer();
   init_estimateDataURLDecodedBytes();
+  import_https_proxy_agent = __toESM(require_dist(), 1);
   import_follow_redirects = __toESM(require_follow_redirects(), 1);
   zlibOptions = {
     flush: zlib.constants.Z_SYNC_FLUSH,
@@ -12684,20 +13705,37 @@ var init_http = __esm(() => {
     flush: zlib.constants.BROTLI_OPERATION_FLUSH,
     finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
   };
+  zstdOptions = {
+    flush: zlib.constants.ZSTD_e_flush,
+    finishFlush: zlib.constants.ZSTD_e_flush
+  };
   isBrotliSupported = utils_default.isFunction(zlib.createBrotliDecompress);
+  isZstdSupported = utils_default.isFunction(zlib.createZstdDecompress);
+  ACCEPT_ENCODING = "gzip, compress, deflate" + (isBrotliSupported ? ", br" : "");
+  ACCEPT_ENCODING_WITH_ZSTD = ACCEPT_ENCODING + (isZstdSupported ? ", zstd" : "");
   ({ http: httpFollow, https: httpsFollow } = import_follow_redirects.default);
   isHttps = /https:?/;
+  FORM_DATA_CONTENT_HEADERS = ["content-type", "content-length"];
+  kAxiosSocketListener = Symbol("axios.http.socketListener");
+  kAxiosCurrentReq = Symbol("axios.http.currentReq");
+  kAxiosInstalledTunnel = Symbol("axios.http.installedTunnel");
+  tunnelingAgentCache = new Map;
+  tunnelingAgentCacheUser = new WeakMap;
+  NODE_NATIVE_ENV_PROXY_SUPPORT = {
+    22: 21,
+    24: 5
+  };
   supportedProtocols = platform_default.protocols.map((protocol) => {
     return protocol + ":";
   });
-  http2Sessions = new Http2Sessions;
+  http2Sessions = new Http2Sessions_default;
   isHttpAdapterSupported = typeof process !== "undefined" && utils_default.kindOf(process) === "process";
   http2Transport = {
     request(options, cb) {
       const authority = options.protocol + "//" + options.hostname + ":" + (options.port || (options.protocol === "https:" ? 443 : 80));
       const { http2Options, headers } = options;
       const session = http2Sessions.getSession(authority, http2Options);
-      const { HTTP2_HEADER_SCHEME, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_STATUS } = http2.constants;
+      const { HTTP2_HEADER_SCHEME, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_STATUS } = http22.constants;
       const http2Headers = {
         [HTTP2_HEADER_SCHEME]: options.protocol.replace(":", ""),
         [HTTP2_HEADER_METHOD]: options.method,
@@ -12721,12 +13759,30 @@ var init_http = __esm(() => {
   };
   http_default = isHttpAdapterSupported && function httpAdapter(config) {
     return wrapAsync(async function dispatchHttpRequest(resolve, reject, onDone) {
-      let { data, lookup, family, httpVersion = 1, http2Options } = config;
-      const { responseType, responseEncoding } = config;
-      const method = config.method.toUpperCase();
+      const own2 = (key) => utils_default.getSafeProp(config, key);
+      const transitional = own2("transitional") || transitional_default;
+      let data = own2("data");
+      let lookup = own2("lookup");
+      let family = own2("family");
+      let httpVersion = own2("httpVersion");
+      if (httpVersion === undefined)
+        httpVersion = 1;
+      let http2Options = own2("http2Options");
+      const httpAgent = own2("httpAgent");
+      const httpsAgent = own2("httpsAgent");
+      const configProxy = own2("proxy");
+      const responseType = own2("responseType");
+      const responseEncoding = own2("responseEncoding");
+      const socketPath = own2("socketPath");
+      const method = own2("method").toUpperCase();
+      const maxRedirects = own2("maxRedirects");
+      const maxBodyLength = own2("maxBodyLength");
+      const maxContentLength = own2("maxContentLength");
+      const decompress = own2("decompress");
       let isDone;
       let rejected = false;
       let req;
+      let connectPhaseTimer;
       httpVersion = +httpVersion;
       if (Number.isNaN(httpVersion)) {
         throw TypeError(`Invalid protocol version: '${config.httpVersion}' is not a number`);
@@ -12751,12 +13807,26 @@ var init_http = __esm(() => {
       function abort(reason) {
         try {
           abortEmitter.emit("abort", !reason || reason.type ? new CanceledError_default(null, config, req) : reason);
-        } catch (err) {
-          console.warn("emit error", err);
+        } catch (err) {}
+      }
+      function clearConnectPhaseTimer() {
+        if (connectPhaseTimer) {
+          clearTimeout(connectPhaseTimer);
+          connectPhaseTimer = null;
+        }
+      }
+      function createTimeoutError() {
+        const configTimeout = own2("timeout");
+        let timeoutErrorMessage = configTimeout ? "timeout of " + configTimeout + "ms exceeded" : "timeout exceeded";
+        const configTimeoutErrorMessage = own2("timeoutErrorMessage");
+        if (configTimeoutErrorMessage) {
+          timeoutErrorMessage = configTimeoutErrorMessage;
         }
+        return new AxiosError_default(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED, config, req);
       }
       abortEmitter.once("abort", reject);
       const onFinished = () => {
+        clearConnectPhaseTimer();
         if (config.cancelToken) {
           config.cancelToken.unsubscribe(abort);
         }
@@ -12773,6 +13843,7 @@ var init_http = __esm(() => {
       }
       onDone((response, isRejected) => {
         isDone = true;
+        clearConnectPhaseTimer();
         if (isRejected) {
           rejected = true;
           onFinished();
@@ -12788,15 +13859,16 @@ var init_http = __esm(() => {
           onFinished();
         }
       });
-      const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
-      const parsed = new URL(fullPath, platform_default.hasBrowserEnv ? platform_default.origin : undefined);
+      const fullPath = buildFullPath(own2("baseURL"), own2("url"), own2("allowAbsoluteUrls"), config);
+      const urlBase = socketPath ? "http://localhost" : platform_default.hasBrowserEnv ? platform_default.origin : undefined;
+      const parsed = new URL(fullPath, urlBase);
       const protocol = parsed.protocol || supportedProtocols[0];
       if (protocol === "data:") {
-        if (config.maxContentLength > -1) {
-          const dataUrl = String(config.url || fullPath || "");
+        if (maxContentLength > -1) {
+          const dataUrl = String(own2("url") || fullPath || "");
           const estimated = estimateDataURLDecodedBytes(dataUrl);
-          if (estimated > config.maxContentLength) {
-            return reject(new AxiosError_default("maxContentLength size of " + config.maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config));
+          if (estimated > maxContentLength) {
+            return reject(new AxiosError_default("maxContentLength size of " + maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config));
           }
         }
         let convertedData;
@@ -12809,7 +13881,7 @@ var init_http = __esm(() => {
           });
         }
         try {
-          convertedData = fromDataURI(config.url, responseType === "blob", {
+          convertedData = fromDataURI(own2("url"), responseType === "blob", {
             Blob: config.env && config.env.Blob
           });
         } catch (err) {
@@ -12848,11 +13920,11 @@ var init_http = __esm(() => {
           tag: `axios-${VERSION}-boundary`,
           boundary: userBoundary && userBoundary[1] || undefined
         });
-      } else if (utils_default.isFormData(data) && utils_default.isFunction(data.getHeaders)) {
-        headers.set(data.getHeaders());
+      } else if (utils_default.isFormData(data) && utils_default.isFunction(data.getHeaders) && data.getHeaders !== Object.prototype.getHeaders) {
+        setFormDataHeaders(headers, data.getHeaders(), own2("formDataHeaderPolicy"));
         if (!headers.hasContentLength()) {
           try {
-            const knownLength = await util2.promisify(data.getLength).call(data);
+            const knownLength = await util3.promisify(data.getLength).call(data);
             Number.isFinite(knownLength) && knownLength >= 0 && headers.setContentLength(knownLength);
           } catch (e) {}
         }
@@ -12869,7 +13941,7 @@ var init_http = __esm(() => {
           return reject(new AxiosError_default("Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream", AxiosError_default.ERR_BAD_REQUEST, config));
         }
         headers.setContentLength(data.length, false);
-        if (config.maxBodyLength > -1 && data.length > config.maxBodyLength) {
+        if (maxBodyLength > -1 && data.length > maxBodyLength) {
           return reject(new AxiosError_default("Request body larger than maxBodyLength limit", AxiosError_default.ERR_BAD_REQUEST, config));
         }
       }
@@ -12893,77 +13965,129 @@ var init_http = __esm(() => {
         onUploadProgress && data.on("progress", flushOnFinish(data, progressEventDecorator(contentLength, progressEventReducer(asyncDecorator(onUploadProgress), false, 3))));
       }
       let auth = undefined;
-      if (config.auth) {
-        const username = config.auth.username || "";
-        const password = config.auth.password || "";
+      const configAuth = own2("auth");
+      if (configAuth) {
+        const username = utils_default.getSafeProp(configAuth, "username") || "";
+        const password = utils_default.getSafeProp(configAuth, "password") || "";
         auth = username + ":" + password;
       }
-      if (!auth && parsed.username) {
-        const urlUsername = parsed.username;
-        const urlPassword = parsed.password;
+      if (!auth && (parsed.username || parsed.password)) {
+        const urlUsername = decodeURIComponentSafe(parsed.username);
+        const urlPassword = decodeURIComponentSafe(parsed.password);
         auth = urlUsername + ":" + urlPassword;
       }
       auth && headers.delete("authorization");
       let path;
       try {
-        path = buildURL(parsed.pathname + parsed.search, config.params, config.paramsSerializer).replace(/^\?/, "");
+        path = buildURL(parsed.pathname + parsed.search, own2("params"), own2("paramsSerializer")).replace(/^\?/, "");
       } catch (err) {
-        const customErr = new Error(err.message);
-        customErr.config = config;
-        customErr.url = config.url;
-        customErr.exists = true;
-        return reject(customErr);
-      }
-      headers.set("Accept-Encoding", "gzip, compress, deflate" + (isBrotliSupported ? ", br" : ""), false);
-      const options = {
+        return reject(AxiosError_default.from(err, AxiosError_default.ERR_BAD_REQUEST, config, null, null, {
+          url: own2("url"),
+          exists: true
+        }));
+      }
+      headers.set("Accept-Encoding", utils_default.hasOwnProp(transitional, "advertiseZstdAcceptEncoding") && transitional.advertiseZstdAcceptEncoding === true ? ACCEPT_ENCODING_WITH_ZSTD : ACCEPT_ENCODING, false);
+      const options = Object.assign(Object.create(null), {
         path,
         method,
-        headers: headers.toJSON(),
-        agents: { http: config.httpAgent, https: config.httpsAgent },
+        headers: toByteStringHeaderObject(headers),
+        agents: { http: httpAgent, https: httpsAgent },
         auth,
         protocol,
         family,
         beforeRedirect: dispatchBeforeRedirect,
-        beforeRedirects: {},
+        beforeRedirects: Object.create(null),
         http2Options
-      };
+      });
       !utils_default.isUndefined(lookup) && (options.lookup = lookup);
-      if (config.socketPath) {
-        options.socketPath = config.socketPath;
+      if (socketPath) {
+        if (typeof socketPath !== "string") {
+          return reject(new AxiosError_default("socketPath must be a string", AxiosError_default.ERR_BAD_OPTION_VALUE, config));
+        }
+        const allowedSocketPaths = own2("allowedSocketPaths");
+        if (allowedSocketPaths != null) {
+          const allowed = Array.isArray(allowedSocketPaths) ? allowedSocketPaths : [allowedSocketPaths];
+          const resolvedSocket = resolvePath(socketPath);
+          const isAllowed = allowed.some((entry) => typeof entry === "string" && resolvePath(entry) === resolvedSocket);
+          if (!isAllowed) {
+            return reject(new AxiosError_default(`socketPath "${socketPath}" is not permitted by allowedSocketPaths`, AxiosError_default.ERR_BAD_OPTION_VALUE, config));
+          }
+        }
+        options.socketPath = socketPath;
       } else {
         options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
         options.port = parsed.port;
-        setProxy(options, config.proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
+        setProxy(options, configProxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path, false, httpsAgent, httpAgent);
       }
       let transport;
+      let isNativeTransport = false;
+      let transportEnforcesMaxBodyLength = false;
       const isHttpsRequest = isHttps.test(options.protocol);
-      options.agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
+      if (options.agent == null) {
+        options.agent = isHttpsRequest ? httpsAgent : httpAgent;
+      }
       if (isHttp2) {
         transport = http2Transport;
       } else {
-        if (config.transport) {
-          transport = config.transport;
-        } else if (config.maxRedirects === 0) {
+        const configTransport = own2("transport");
+        if (configTransport) {
+          transport = configTransport;
+        } else if (maxRedirects === 0) {
           transport = isHttpsRequest ? https : http;
+          isNativeTransport = true;
         } else {
-          if (config.maxRedirects) {
-            options.maxRedirects = config.maxRedirects;
+          transportEnforcesMaxBodyLength = true;
+          options.sensitiveHeaders = [];
+          if (maxRedirects) {
+            options.maxRedirects = maxRedirects;
+          }
+          const configBeforeRedirect = own2("beforeRedirect");
+          if (configBeforeRedirect) {
+            options.beforeRedirects.config = configBeforeRedirect;
           }
-          if (config.beforeRedirect) {
-            options.beforeRedirects.config = config.beforeRedirect;
+          if (auth) {
+            const requestOrigin = parsed.origin;
+            const authToRestore = auth;
+            options.beforeRedirects.auth = function beforeRedirectAuth(redirectOptions) {
+              try {
+                if (new URL(redirectOptions.href).origin === requestOrigin) {
+                  redirectOptions.auth = authToRestore;
+                }
+              } catch (e) {}
+            };
+          }
+          const sensitiveHeaders = own2("sensitiveHeaders");
+          if (sensitiveHeaders != null) {
+            if (!utils_default.isArray(sensitiveHeaders)) {
+              return reject(new AxiosError_default("sensitiveHeaders must be an array of strings", AxiosError_default.ERR_BAD_OPTION_VALUE, config));
+            }
+            const sensitiveSet = new Set;
+            for (const header of sensitiveHeaders) {
+              if (!utils_default.isString(header)) {
+                return reject(new AxiosError_default("sensitiveHeaders must be an array of strings", AxiosError_default.ERR_BAD_OPTION_VALUE, config));
+              }
+              sensitiveSet.add(header.toLowerCase());
+            }
+            if (sensitiveSet.size) {
+              options.sensitiveHeaders = Array.from(sensitiveSet);
+              options.beforeRedirects.sensitiveHeaders = function beforeRedirectSensitiveHeaders(redirectOptions, requestDetails) {
+                if (!isSameOriginRedirect(redirectOptions, requestDetails)) {
+                  stripMatchingHeaders(redirectOptions.headers, sensitiveSet);
+                }
+              };
+            }
           }
           transport = isHttpsRequest ? httpsFollow : httpFollow;
         }
       }
-      if (config.maxBodyLength > -1) {
-        options.maxBodyLength = config.maxBodyLength;
+      if (maxBodyLength > -1) {
+        options.maxBodyLength = maxBodyLength;
       } else {
         options.maxBodyLength = Infinity;
       }
-      if (config.insecureHTTPParser) {
-        options.insecureHTTPParser = config.insecureHTTPParser;
-      }
+      options.insecureHTTPParser = Boolean(own2("insecureHTTPParser"));
       req = transport.request(options, function handleResponse(res) {
+        clearConnectPhaseTimer();
         if (req.destroyed)
           return;
         const streams = [res];
@@ -12977,7 +14101,7 @@ var init_http = __esm(() => {
         }
         let responseStream = res;
         const lastRequest = res.req || req;
-        if (config.decompress !== false && res.headers["content-encoding"]) {
+        if (decompress !== false && res.headers["content-encoding"]) {
           if (method === "HEAD" || res.statusCode === 204) {
             delete res.headers["content-encoding"];
           }
@@ -12999,6 +14123,13 @@ var init_http = __esm(() => {
                 streams.push(zlib.createBrotliDecompress(brotliOptions));
                 delete res.headers["content-encoding"];
               }
+              break;
+            case "zstd":
+              if (isZstdSupported) {
+                streams.push(zlib.createZstdDecompress(zstdOptions));
+                delete res.headers["content-encoding"];
+              }
+              break;
           }
         }
         responseStream = streams.length > 1 ? stream3.pipeline(streams, utils_default.noop) : streams[0];
@@ -13010,6 +14141,23 @@ var init_http = __esm(() => {
           request: lastRequest
         };
         if (responseType === "stream") {
+          if (maxContentLength > -1) {
+            const limit = maxContentLength;
+            const source = responseStream;
+            async function* enforceMaxContentLength() {
+              let totalResponseBytes = 0;
+              for await (const chunk of source) {
+                totalResponseBytes += chunk.length;
+                if (totalResponseBytes > limit) {
+                  throw new AxiosError_default("maxContentLength size of " + limit + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config, lastRequest);
+                }
+                yield chunk;
+              }
+            }
+            responseStream = stream3.Readable.from(enforceMaxContentLength(), {
+              objectMode: false
+            });
+          }
           response.data = responseStream;
           settle(resolve, reject, response);
         } else {
@@ -13018,24 +14166,24 @@ var init_http = __esm(() => {
           responseStream.on("data", function handleStreamData(chunk) {
             responseBuffer.push(chunk);
             totalResponseBytes += chunk.length;
-            if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
+            if (maxContentLength > -1 && totalResponseBytes > maxContentLength) {
               rejected = true;
               responseStream.destroy();
-              abort(new AxiosError_default("maxContentLength size of " + config.maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config, lastRequest));
+              abort(new AxiosError_default("maxContentLength size of " + maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config, lastRequest));
             }
           });
           responseStream.on("aborted", function handlerStreamAborted() {
             if (rejected) {
               return;
             }
-            const err = new AxiosError_default("stream has been aborted", AxiosError_default.ERR_BAD_RESPONSE, config, lastRequest);
+            const err = new AxiosError_default("stream has been aborted", AxiosError_default.ERR_BAD_RESPONSE, config, lastRequest, response);
             responseStream.destroy(err);
             reject(err);
           });
           responseStream.on("error", function handleStreamError(err) {
-            if (req.destroyed)
+            if (rejected)
               return;
-            reject(AxiosError_default.from(err, null, config, lastRequest));
+            reject(AxiosError_default.from(err, null, config, lastRequest, response));
           });
           responseStream.on("end", function handleStreamEnd() {
             try {
@@ -13070,25 +14218,47 @@ var init_http = __esm(() => {
       req.on("error", function handleRequestError(err) {
         reject(AxiosError_default.from(err, null, config, req));
       });
+      const boundSockets = new Set;
       req.on("socket", function handleRequestSocket(socket) {
-        socket.setKeepAlive(true, 1000 * 60);
+        if (typeof socket.setKeepAlive === "function") {
+          socket.setKeepAlive(true, 1000 * 60);
+        }
+        if (!socket[kAxiosSocketListener]) {
+          socket.on("error", function handleSocketError(err) {
+            const current = socket[kAxiosCurrentReq];
+            if (current && !current.destroyed) {
+              current.destroy(err);
+            }
+          });
+          socket[kAxiosSocketListener] = true;
+        }
+        socket[kAxiosCurrentReq] = req;
+        boundSockets.add(socket);
       });
-      if (config.timeout) {
-        const timeout = parseInt(config.timeout, 10);
+      req.once("close", function clearCurrentReq() {
+        clearConnectPhaseTimer();
+        for (const socket of boundSockets) {
+          if (socket[kAxiosCurrentReq] === req) {
+            socket[kAxiosCurrentReq] = null;
+          }
+        }
+        boundSockets.clear();
+      });
+      if (own2("timeout")) {
+        const timeout = parseInt(own2("timeout"), 10);
         if (Number.isNaN(timeout)) {
           abort(new AxiosError_default("error trying to parse `config.timeout` to int", AxiosError_default.ERR_BAD_OPTION_VALUE, config, req));
           return;
         }
-        req.setTimeout(timeout, function handleRequestTimeout() {
+        const handleTimeout = function handleTimeout2() {
           if (isDone)
             return;
-          let timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
-          const transitional = config.transitional || transitional_default;
-          if (config.timeoutErrorMessage) {
-            timeoutErrorMessage = config.timeoutErrorMessage;
-          }
-          abort(new AxiosError_default(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED, config, req));
-        });
+          abort(createTimeoutError());
+        };
+        if (isNativeTransport && timeout > 0) {
+          connectPhaseTimer = setTimeout(handleTimeout, timeout);
+        }
+        req.setTimeout(timeout, handleTimeout);
       } else {
         req.setTimeout(0);
       }
@@ -13107,7 +14277,28 @@ var init_http = __esm(() => {
             abort(new CanceledError_default("Request stream has been aborted", config, req));
           }
         });
-        data.pipe(req);
+        let uploadStream = data;
+        if (maxBodyLength > -1 && !transportEnforcesMaxBodyLength) {
+          const limit = maxBodyLength;
+          let bytesSent = 0;
+          uploadStream = stream3.pipeline([
+            data,
+            new stream3.Transform({
+              transform(chunk, _enc, cb) {
+                bytesSent += chunk.length;
+                if (bytesSent > limit) {
+                  return cb(new AxiosError_default("Request body larger than maxBodyLength limit", AxiosError_default.ERR_BAD_REQUEST, config, req));
+                }
+                cb(null, chunk);
+              }
+            })
+          ], utils_default.noop);
+          uploadStream.on("error", (err) => {
+            if (!req.destroyed)
+              req.destroy(err);
+          });
+        }
+        uploadStream.pipe(req);
       } else {
         data && req.write(data);
         req.end();
@@ -13116,7 +14307,7 @@ var init_http = __esm(() => {
   };
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/isURLSameOrigin.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/isURLSameOrigin.js
 var isURLSameOrigin_default;
 var init_isURLSameOrigin = __esm(() => {
   init_platform();
@@ -13126,7 +14317,7 @@ var init_isURLSameOrigin = __esm(() => {
   })(new URL(platform_default.origin), platform_default.navigator && /(msie|trident)/i.test(platform_default.navigator.userAgent)) : () => true;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/cookies.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/cookies.js
 var cookies_default;
 var init_cookies = __esm(() => {
   init_utils();
@@ -13156,8 +14347,19 @@ var init_cookies = __esm(() => {
     read(name) {
       if (typeof document === "undefined")
         return null;
-      const match = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
-      return match ? decodeURIComponent(match[1]) : null;
+      const cookies = document.cookie.split(";");
+      for (let i = 0;i < cookies.length; i++) {
+        const cookie = cookies[i].replace(/^\s+/, "");
+        const eq = cookie.indexOf("=");
+        if (eq !== -1 && cookie.slice(0, eq) === name) {
+          try {
+            return decodeURIComponent(cookie.slice(eq + 1));
+          } catch (e) {
+            return cookie.slice(eq + 1);
+          }
+        }
+      }
+      return null;
     },
     remove(name) {
       this.write(name, "", Date.now() - 86400000, "/");
@@ -13171,10 +14373,18 @@ var init_cookies = __esm(() => {
   };
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/core/mergeConfig.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/core/mergeConfig.js
 function mergeConfig(config1, config2) {
+  config1 = config1 || {};
   config2 = config2 || {};
-  const config = {};
+  const config = Object.create(null);
+  Object.defineProperty(config, "hasOwnProperty", {
+    __proto__: null,
+    value: Object.prototype.hasOwnProperty,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
   function getMergedValue(target, source, prop, caseless) {
     if (utils_default.isPlainObject(target) && utils_default.isPlainObject(source)) {
       return utils_default.merge.call({ caseless }, target, source);
@@ -13204,10 +14414,27 @@ function mergeConfig(config1, config2) {
       return getMergedValue(undefined, a);
     }
   }
+  function getMergedTransitionalOption(prop) {
+    const transitional2 = utils_default.hasOwnProp(config2, "transitional") ? config2.transitional : undefined;
+    if (!utils_default.isUndefined(transitional2)) {
+      if (utils_default.isPlainObject(transitional2)) {
+        if (utils_default.hasOwnProp(transitional2, prop)) {
+          return transitional2[prop];
+        }
+      } else {
+        return;
+      }
+    }
+    const transitional1 = utils_default.hasOwnProp(config1, "transitional") ? config1.transitional : undefined;
+    if (utils_default.isPlainObject(transitional1) && utils_default.hasOwnProp(transitional1, prop)) {
+      return transitional1[prop];
+    }
+    return;
+  }
   function mergeDirectKeys(a, b, prop) {
-    if (prop in config2) {
+    if (utils_default.hasOwnProp(config2, prop)) {
       return getMergedValue(a, b);
-    } else if (prop in config1) {
+    } else if (utils_default.hasOwnProp(config1, prop)) {
       return getMergedValue(undefined, a);
     }
   }
@@ -13238,6 +14465,7 @@ function mergeConfig(config1, config2) {
     httpsAgent: defaultToConfig2,
     cancelToken: defaultToConfig2,
     socketPath: defaultToConfig2,
+    allowedSocketPaths: defaultToConfig2,
     responseEncoding: defaultToConfig2,
     validateStatus: mergeDirectKeys,
     headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
@@ -13246,9 +14474,18 @@ function mergeConfig(config1, config2) {
     if (prop === "__proto__" || prop === "constructor" || prop === "prototype")
       return;
     const merge2 = utils_default.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
-    const configValue = merge2(config1[prop], config2[prop], prop);
+    const a = utils_default.hasOwnProp(config1, prop) ? config1[prop] : undefined;
+    const b = utils_default.hasOwnProp(config2, prop) ? config2[prop] : undefined;
+    const configValue = merge2(a, b, prop);
     utils_default.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
   });
+  if (utils_default.hasOwnProp(config2, "validateStatus") && utils_default.isUndefined(config2.validateStatus) && getMergedTransitionalOption("validateStatusUndefinedResolves") === false) {
+    if (utils_default.hasOwnProp(config1, "validateStatus")) {
+      config.validateStatus = getMergedValue(undefined, config1.validateStatus);
+    } else {
+      delete config.validateStatus;
+    }
+  }
   return config;
 }
 var headersToObject = (thing) => thing instanceof AxiosHeaders_default ? { ...thing } : thing;
@@ -13257,31 +14494,54 @@ var init_mergeConfig = __esm(() => {
   init_AxiosHeaders();
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/resolveConfig.js
-var resolveConfig_default = (config) => {
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/resolveConfig.js
+function setFormDataHeaders2(headers, formHeaders, policy) {
+  if (policy !== "content-only") {
+    headers.set(formHeaders);
+    return;
+  }
+  Object.entries(formHeaders || {}).forEach(([key, val]) => {
+    if (FORM_DATA_CONTENT_HEADERS2.includes(key.toLowerCase())) {
+      headers.set(key, val);
+    }
+  });
+}
+function resolveConfig(config) {
   const newConfig = mergeConfig({}, config);
-  let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
+  const own2 = (key) => utils_default.hasOwnProp(newConfig, key) ? newConfig[key] : undefined;
+  const data = own2("data");
+  let withXSRFToken = own2("withXSRFToken");
+  const xsrfHeaderName = own2("xsrfHeaderName");
+  const xsrfCookieName = own2("xsrfCookieName");
+  let headers = own2("headers");
+  const auth = own2("auth");
+  const baseURL = own2("baseURL");
+  const allowAbsoluteUrls = own2("allowAbsoluteUrls");
+  const url2 = own2("url");
   newConfig.headers = headers = AxiosHeaders_default.from(headers);
-  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
+  newConfig.url = buildURL(buildFullPath(baseURL, url2, allowAbsoluteUrls, newConfig), own2("params"), own2("paramsSerializer"));
   if (auth) {
-    headers.set("Authorization", "Basic " + btoa((auth.username || "") + ":" + (auth.password ? unescape(encodeURIComponent(auth.password)) : "")));
+    const username = utils_default.getSafeProp(auth, "username") || "";
+    const password = utils_default.getSafeProp(auth, "password") || "";
+    try {
+      headers.set("Authorization", "Basic " + btoa(username + ":" + (password ? encodeUTF8(password) : "")));
+    } catch (e) {
+      throw AxiosError_default.from(e, AxiosError_default.ERR_BAD_OPTION_VALUE, config);
+    }
   }
   if (utils_default.isFormData(data)) {
-    if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv) {
+    if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv || utils_default.isReactNative(data)) {
       headers.setContentType(undefined);
     } else if (utils_default.isFunction(data.getHeaders)) {
-      const formHeaders = data.getHeaders();
-      const allowedHeaders = ["content-type", "content-length"];
-      Object.entries(formHeaders).forEach(([key, val]) => {
-        if (allowedHeaders.includes(key.toLowerCase())) {
-          headers.set(key, val);
-        }
-      });
+      setFormDataHeaders2(headers, data.getHeaders(), own2("formDataHeaderPolicy"));
     }
   }
   if (platform_default.hasStandardBrowserEnv) {
-    withXSRFToken && utils_default.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));
-    if (withXSRFToken || withXSRFToken !== false && isURLSameOrigin_default(newConfig.url)) {
+    if (utils_default.isFunction(withXSRFToken)) {
+      withXSRFToken = withXSRFToken(newConfig);
+    }
+    const shouldSendXSRF = withXSRFToken === true || withXSRFToken == null && isURLSameOrigin_default(newConfig.url);
+    if (shouldSendXSRF) {
       const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies_default.read(xsrfCookieName);
       if (xsrfValue) {
         headers.set(xsrfHeaderName, xsrfValue);
@@ -13289,19 +14549,23 @@ var resolveConfig_default = (config) => {
     }
   }
   return newConfig;
-};
+}
+var FORM_DATA_CONTENT_HEADERS2, encodeUTF8 = (str) => encodeURIComponent(str).replace(/%([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))), resolveConfig_default;
 var init_resolveConfig = __esm(() => {
   init_platform();
   init_utils();
+  init_AxiosError();
   init_isURLSameOrigin();
   init_cookies();
   init_buildFullPath();
   init_mergeConfig();
   init_AxiosHeaders();
   init_buildURL();
+  FORM_DATA_CONTENT_HEADERS2 = ["content-type", "content-length"];
+  resolveConfig_default = resolveConfig;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/adapters/xhr.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/adapters/xhr.js
 var isXHRAdapterSupported, xhr_default;
 var init_xhr = __esm(() => {
   init_utils();
@@ -13314,6 +14578,7 @@ var init_xhr = __esm(() => {
   init_AxiosHeaders();
   init_progressEventReducer();
   init_resolveConfig();
+  init_sanitizeHeaderValue();
   isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
   xhr_default = isXHRAdapterSupported && function(config) {
     return new Promise(function dispatchXhrRequest(resolve, reject) {
@@ -13363,7 +14628,7 @@ var init_xhr = __esm(() => {
           if (!request || request.readyState !== 4) {
             return;
           }
-          if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
+          if (request.status === 0 && !(request.responseURL && request.responseURL.startsWith("file:"))) {
             return;
           }
           setTimeout(onloadend);
@@ -13374,6 +14639,7 @@ var init_xhr = __esm(() => {
           return;
         }
         reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config, request));
+        done();
         request = null;
       };
       request.onerror = function handleError(event) {
@@ -13381,6 +14647,7 @@ var init_xhr = __esm(() => {
         const err = new AxiosError_default(msg, AxiosError_default.ERR_NETWORK, config, request);
         err.event = event || null;
         reject(err);
+        done();
         request = null;
       };
       request.ontimeout = function handleTimeout() {
@@ -13390,11 +14657,12 @@ var init_xhr = __esm(() => {
           timeoutErrorMessage = _config.timeoutErrorMessage;
         }
         reject(new AxiosError_default(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED, config, request));
+        done();
         request = null;
       };
       requestData === undefined && requestHeaders.setContentType(null);
       if ("setRequestHeader" in request) {
-        utils_default.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+        utils_default.forEach(toByteStringHeaderObject(requestHeaders), function setRequestHeader(val, key) {
           request.setRequestHeader(key, val);
         });
       }
@@ -13420,6 +14688,7 @@ var init_xhr = __esm(() => {
           }
           reject(!cancel || cancel.type ? new CanceledError_default(null, config, request) : cancel);
           request.abort();
+          done();
           request = null;
         };
         _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
@@ -13428,8 +14697,9 @@ var init_xhr = __esm(() => {
         }
       }
       const protocol = parseProtocol(_config.url);
-      if (protocol && platform_default.protocols.indexOf(protocol) === -1) {
+      if (protocol && !platform_default.protocols.includes(protocol)) {
         reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config));
+        done();
         return;
       }
       request.send(requestData || null);
@@ -13437,39 +14707,41 @@ var init_xhr = __esm(() => {
   };
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/composeSignals.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/composeSignals.js
 var composeSignals = (signals, timeout) => {
-  const { length } = signals = signals ? signals.filter(Boolean) : [];
-  if (timeout || length) {
-    let controller = new AbortController;
-    let aborted;
-    const onabort = function(reason) {
-      if (!aborted) {
-        aborted = true;
-        unsubscribe();
-        const err = reason instanceof Error ? reason : this.reason;
-        controller.abort(err instanceof AxiosError_default ? err : new CanceledError_default(err instanceof Error ? err.message : err));
-      }
-    };
-    let timer = timeout && setTimeout(() => {
-      timer = null;
-      onabort(new AxiosError_default(`timeout of ${timeout}ms exceeded`, AxiosError_default.ETIMEDOUT));
-    }, timeout);
-    const unsubscribe = () => {
-      if (signals) {
-        timer && clearTimeout(timer);
-        timer = null;
-        signals.forEach((signal2) => {
-          signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
-        });
-        signals = null;
-      }
-    };
-    signals.forEach((signal2) => signal2.addEventListener("abort", onabort));
-    const { signal } = controller;
-    signal.unsubscribe = () => utils_default.asap(unsubscribe);
-    return signal;
+  signals = signals ? signals.filter(Boolean) : [];
+  if (!timeout && !signals.length) {
+    return;
   }
+  const controller = new AbortController;
+  let aborted = false;
+  const onabort = function(reason) {
+    if (!aborted) {
+      aborted = true;
+      unsubscribe();
+      const err = reason instanceof Error ? reason : this.reason;
+      controller.abort(err instanceof AxiosError_default ? err : new CanceledError_default(err instanceof Error ? err.message : err));
+    }
+  };
+  let timer = timeout && setTimeout(() => {
+    timer = null;
+    onabort(new AxiosError_default(`timeout of ${timeout}ms exceeded`, AxiosError_default.ETIMEDOUT));
+  }, timeout);
+  const unsubscribe = () => {
+    if (!signals) {
+      return;
+    }
+    timer && clearTimeout(timer);
+    timer = null;
+    signals.forEach((signal2) => {
+      signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
+    });
+    signals = null;
+  };
+  signals.forEach((signal2) => signal2.addEventListener("abort", onabort, { once: true }));
+  const { signal } = controller;
+  signal.unsubscribe = () => utils_default.asap(unsubscribe);
+  return signal;
 }, composeSignals_default;
 var init_composeSignals = __esm(() => {
   init_CanceledError();
@@ -13478,7 +14750,7 @@ var init_composeSignals = __esm(() => {
   composeSignals_default = composeSignals;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/trackStream.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/trackStream.js
 var streamChunk = function* (chunk, chunkSize) {
   let len = chunk.byteLength;
   if (!chunkSize || len < chunkSize) {
@@ -13553,17 +14825,38 @@ var streamChunk = function* (chunk, chunkSize) {
 };
 var init_trackStream = () => {};
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/adapters/fetch.js
-var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncoder2, test = (fn, ...args) => {
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/adapters/fetch.js
+var DEFAULT_CHUNK_SIZE, isFunction2, encodeUTF82 = (str) => encodeURIComponent(str).replace(/%([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))), decodeURIComponentSafe2 = (value) => {
+  if (!utils_default.isString(value)) {
+    return value;
+  }
+  try {
+    return decodeURIComponent(value);
+  } catch (error) {
+    return value;
+  }
+}, test = (fn, ...args) => {
   try {
     return !!fn(...args);
   } catch (e) {
     return false;
   }
+}, maybeWithAuthCredentials = (url2) => {
+  const protocolIndex = url2.indexOf("://");
+  let urlToCheck = url2;
+  if (protocolIndex !== -1) {
+    urlToCheck = urlToCheck.slice(protocolIndex + 3);
+  }
+  return urlToCheck.includes("@") || urlToCheck.includes(":");
 }, factory = (env) => {
+  const globalObject = utils_default.global !== undefined && utils_default.global !== null ? utils_default.global : globalThis;
+  const { ReadableStream: ReadableStream2, TextEncoder: TextEncoder2 } = globalObject;
   env = utils_default.merge.call({
     skipUndefined: true
-  }, globalFetchAPI, env);
+  }, {
+    Request: globalObject.Request,
+    Response: globalObject.Response
+  }, env);
   const { fetch: envFetch, Request, Response } = env;
   const isFetchSupported = envFetch ? isFunction2(envFetch) : typeof fetch === "function";
   const isRequestSupported = isFunction2(Request);
@@ -13575,16 +14868,18 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
   const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder2) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
   const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
     let duplexAccessed = false;
-    const body = new ReadableStream2;
-    const hasContentType = new Request(platform_default.origin, {
-      body,
+    const request = new Request(platform_default.origin, {
+      body: new ReadableStream2,
       method: "POST",
       get duplex() {
         duplexAccessed = true;
         return "half";
       }
-    }).headers.has("Content-Type");
-    body.cancel();
+    });
+    const hasContentType = request.headers.has("Content-Type");
+    if (request.body != null) {
+      request.body.cancel();
+    }
     return duplexAccessed && !hasContentType;
   });
   const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils_default.isReadableStream(new Response("").body));
@@ -13643,8 +14938,13 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
       responseType,
       headers,
       withCredentials = "same-origin",
-      fetchOptions
+      fetchOptions,
+      maxContentLength,
+      maxBodyLength
     } = resolveConfig_default(config);
+    const hasMaxContentLength = utils_default.isNumber(maxContentLength) && maxContentLength > -1;
+    const hasMaxBodyLength = utils_default.isNumber(maxBodyLength) && maxBodyLength > -1;
+    const own2 = (key) => utils_default.hasOwnProp(config, key) ? config[key] : undefined;
     let _fetch = envFetch || fetch;
     responseType = responseType ? (responseType + "").toLowerCase() : "text";
     let composedSignal = composeSignals_default([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
@@ -13653,52 +14953,152 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
       composedSignal.unsubscribe();
     });
     let requestContentLength;
+    let pendingBodyError = null;
+    const maxBodyLengthError = () => new AxiosError_default("Request body larger than maxBodyLength limit", AxiosError_default.ERR_BAD_REQUEST, config, request);
     try {
-      if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
-        let _request = new Request(url2, {
-          method: "POST",
-          body: data,
-          duplex: "half"
-        });
-        let contentTypeHeader;
-        if (utils_default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
-          headers.setContentType(contentTypeHeader);
+      let auth = undefined;
+      const configAuth = own2("auth");
+      if (configAuth) {
+        const username = utils_default.getSafeProp(configAuth, "username") || "";
+        const password = utils_default.getSafeProp(configAuth, "password") || "";
+        auth = {
+          username,
+          password
+        };
+      }
+      if (maybeWithAuthCredentials(url2)) {
+        const parsedURL = new URL(url2, platform_default.origin);
+        if (!auth && (parsedURL.username || parsedURL.password)) {
+          const urlUsername = decodeURIComponentSafe2(parsedURL.username);
+          const urlPassword = decodeURIComponentSafe2(parsedURL.password);
+          auth = {
+            username: urlUsername,
+            password: urlPassword
+          };
+        }
+        if (parsedURL.username || parsedURL.password) {
+          parsedURL.username = "";
+          parsedURL.password = "";
+          url2 = parsedURL.href;
+        }
+      }
+      if (auth) {
+        headers.delete("authorization");
+        headers.set("Authorization", "Basic " + btoa(encodeUTF82((auth.username || "") + ":" + (auth.password || ""))));
+      }
+      if (hasMaxContentLength && typeof url2 === "string" && url2.startsWith("data:")) {
+        const estimated = estimateDataURLDecodedBytes(url2);
+        if (estimated > maxContentLength) {
+          throw new AxiosError_default("maxContentLength size of " + maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config, request);
+        }
+      }
+      if (hasMaxBodyLength && method !== "get" && method !== "head") {
+        const outboundLength = await getBodyLength(data);
+        if (typeof outboundLength === "number" && isFinite(outboundLength)) {
+          requestContentLength = outboundLength;
+          if (outboundLength > maxBodyLength) {
+            throw maxBodyLengthError();
+          }
         }
-        if (_request.body) {
-          const [onProgress, flush] = progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress)));
-          data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+      }
+      const mustEnforceStreamBody = hasMaxBodyLength && (utils_default.isReadableStream(data) || utils_default.isStream(data));
+      const trackRequestStream = (stream4, onProgress, flush) => trackStream(stream4, DEFAULT_CHUNK_SIZE, (loadedBytes) => {
+        if (hasMaxBodyLength && loadedBytes > maxBodyLength) {
+          throw pendingBodyError = maxBodyLengthError();
+        }
+        onProgress && onProgress(loadedBytes);
+      }, flush);
+      if (supportsRequestStream && method !== "get" && method !== "head" && (onUploadProgress || mustEnforceStreamBody)) {
+        requestContentLength = requestContentLength == null ? await resolveBodyLength(headers, data) : requestContentLength;
+        if (requestContentLength !== 0 || mustEnforceStreamBody) {
+          let _request = new Request(url2, {
+            method: "POST",
+            body: data,
+            duplex: "half"
+          });
+          let contentTypeHeader;
+          if (utils_default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
+            headers.setContentType(contentTypeHeader);
+          }
+          if (_request.body) {
+            const [onProgress, flush] = onUploadProgress && progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress))) || [];
+            data = trackRequestStream(_request.body, onProgress, flush);
+          }
         }
+      } else if (mustEnforceStreamBody && !isRequestSupported && isReadableStreamSupported && method !== "get" && method !== "head") {
+        data = trackRequestStream(data);
+      } else if (mustEnforceStreamBody && isRequestSupported && !supportsRequestStream && method !== "get" && method !== "head") {
+        throw new AxiosError_default("Stream request bodies are not supported by the current fetch implementation", AxiosError_default.ERR_NOT_SUPPORT, config, request);
       }
       if (!utils_default.isString(withCredentials)) {
         withCredentials = withCredentials ? "include" : "omit";
       }
       const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
+      if (utils_default.isFormData(data)) {
+        const contentType = headers.getContentType();
+        if (contentType && /^multipart\/form-data/i.test(contentType) && !/boundary=/i.test(contentType)) {
+          headers.delete("content-type");
+        }
+      }
+      headers.set("User-Agent", "axios/" + VERSION, false);
       const resolvedOptions = {
         ...fetchOptions,
         signal: composedSignal,
         method: method.toUpperCase(),
-        headers: headers.normalize().toJSON(),
+        headers: toByteStringHeaderObject(headers.normalize()),
         body: data,
         duplex: "half",
         credentials: isCredentialsSupported ? withCredentials : undefined
       };
       request = isRequestSupported && new Request(url2, resolvedOptions);
       let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url2, resolvedOptions));
+      const responseHeaders = AxiosHeaders_default.from(response.headers);
+      if (hasMaxContentLength) {
+        const declaredLength = utils_default.toFiniteNumber(responseHeaders.getContentLength());
+        if (declaredLength != null && declaredLength > maxContentLength) {
+          throw new AxiosError_default("maxContentLength size of " + maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config, request);
+        }
+      }
       const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
-      if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
+      if (supportsResponseStream && response.body && (onDownloadProgress || hasMaxContentLength || isStreamResponse && unsubscribe)) {
         const options = {};
         ["status", "statusText", "headers"].forEach((prop) => {
           options[prop] = response[prop];
         });
-        const responseContentLength = utils_default.toFiniteNumber(response.headers.get("content-length"));
+        const responseContentLength = utils_default.toFiniteNumber(responseHeaders.getContentLength());
         const [onProgress, flush] = onDownloadProgress && progressEventDecorator(responseContentLength, progressEventReducer(asyncDecorator(onDownloadProgress), true)) || [];
-        response = new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+        let bytesRead = 0;
+        const onChunkProgress = (loadedBytes) => {
+          if (hasMaxContentLength) {
+            bytesRead = loadedBytes;
+            if (bytesRead > maxContentLength) {
+              throw new AxiosError_default("maxContentLength size of " + maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config, request);
+            }
+          }
+          onProgress && onProgress(loadedBytes);
+        };
+        response = new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onChunkProgress, () => {
           flush && flush();
           unsubscribe && unsubscribe();
         }), options);
       }
       responseType = responseType || "text";
       let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config);
+      if (hasMaxContentLength && !supportsResponseStream && !isStreamResponse) {
+        let materializedSize;
+        if (responseData != null) {
+          if (typeof responseData.byteLength === "number") {
+            materializedSize = responseData.byteLength;
+          } else if (typeof responseData.size === "number") {
+            materializedSize = responseData.size;
+          } else if (typeof responseData === "string") {
+            materializedSize = typeof TextEncoder2 === "function" ? new TextEncoder2().encode(responseData).byteLength : responseData.length;
+          }
+        }
+        if (typeof materializedSize === "number" && materializedSize > maxContentLength) {
+          throw new AxiosError_default("maxContentLength size of " + maxContentLength + " exceeded", AxiosError_default.ERR_BAD_RESPONSE, config, request);
+        }
+      }
       !isStreamResponse && unsubscribe && unsubscribe();
       return await new Promise((resolve, reject) => {
         settle(resolve, reject, {
@@ -13712,10 +15112,39 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
       });
     } catch (err) {
       unsubscribe && unsubscribe();
+      if (composedSignal && composedSignal.aborted && composedSignal.reason instanceof AxiosError_default) {
+        const canceledError = composedSignal.reason;
+        canceledError.config = config;
+        request && (canceledError.request = request);
+        if (err !== canceledError) {
+          Object.defineProperty(canceledError, "cause", {
+            __proto__: null,
+            value: err,
+            writable: true,
+            enumerable: false,
+            configurable: true
+          });
+        }
+        throw canceledError;
+      }
+      if (pendingBodyError) {
+        request && !pendingBodyError.request && (pendingBodyError.request = request);
+        throw pendingBodyError;
+      }
+      if (err instanceof AxiosError_default) {
+        request && !err.request && (err.request = request);
+        throw err;
+      }
       if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
-        throw Object.assign(new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request, err && err.response), {
-          cause: err.cause || err
+        const networkError = new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request, err && err.response);
+        Object.defineProperty(networkError, "cause", {
+          __proto__: null,
+          value: err.cause || err,
+          writable: true,
+          enumerable: false,
+          configurable: true
         });
+        throw networkError;
       }
       throw AxiosError_default.from(err, err && err.code, config, request, err && err.response);
     }
@@ -13743,18 +15172,16 @@ var init_fetch = __esm(() => {
   init_progressEventReducer();
   init_resolveConfig();
   init_settle();
+  init_estimateDataURLDecodedBytes();
+  init_data();
+  init_sanitizeHeaderValue();
   DEFAULT_CHUNK_SIZE = 64 * 1024;
   ({ isFunction: isFunction2 } = utils_default);
-  globalFetchAPI = (({ Request, Response }) => ({
-    Request,
-    Response
-  }))(utils_default.global);
-  ({ ReadableStream: ReadableStream2, TextEncoder: TextEncoder2 } = utils_default.global);
   seedCache = new Map;
   adapter = getFetch();
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/adapters/adapters.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/adapters/adapters.js
 function getAdapter(adapters, config) {
   adapters = utils_default.isArray(adapters) ? adapters : [adapters];
   const { length } = adapters;
@@ -13781,7 +15208,7 @@ function getAdapter(adapters, config) {
     let s = length ? reasons.length > 1 ? `since :
 ` + reasons.map(renderReason).join(`
 `) : " " + renderReason(reasons[0]) : "as no adapter specified";
-    throw new AxiosError_default(`There is no suitable adapter to dispatch the request ` + s, "ERR_NOT_SUPPORT");
+    throw new AxiosError_default(`There is no suitable adapter to dispatch the request ` + s, AxiosError_default.ERR_NOT_SUPPORT);
   }
   return adapter2;
 }
@@ -13802,9 +15229,9 @@ var init_adapters = __esm(() => {
   utils_default.forEach(knownAdapters, (fn, value) => {
     if (fn) {
       try {
-        Object.defineProperty(fn, "name", { value });
+        Object.defineProperty(fn, "name", { __proto__: null, value });
       } catch (e) {}
-      Object.defineProperty(fn, "adapterName", { value });
+      Object.defineProperty(fn, "adapterName", { __proto__: null, value });
     }
   });
   adapters_default = {
@@ -13813,7 +15240,7 @@ var init_adapters = __esm(() => {
   };
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/core/dispatchRequest.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/core/dispatchRequest.js
 function throwIfCancellationRequested(config) {
   if (config.cancelToken) {
     config.cancelToken.throwIfRequested();
@@ -13832,14 +15259,24 @@ function dispatchRequest(config) {
   const adapter2 = adapters_default.getAdapter(config.adapter || defaults_default.adapter, config);
   return adapter2(config).then(function onAdapterResolution(response) {
     throwIfCancellationRequested(config);
-    response.data = transformData.call(config, config.transformResponse, response);
+    config.response = response;
+    try {
+      response.data = transformData.call(config, config.transformResponse, response);
+    } finally {
+      delete config.response;
+    }
     response.headers = AxiosHeaders_default.from(response.headers);
     return response;
   }, function onAdapterRejection(reason) {
     if (!isCancel(reason)) {
       throwIfCancellationRequested(config);
       if (reason && reason.response) {
-        reason.response.data = transformData.call(config, config.transformResponse, reason.response);
+        config.response = reason.response;
+        try {
+          reason.response.data = transformData.call(config, config.transformResponse, reason.response);
+        } finally {
+          delete config.response;
+        }
         reason.response.headers = AxiosHeaders_default.from(reason.response.headers);
       }
     }
@@ -13855,16 +15292,16 @@ var init_dispatchRequest = __esm(() => {
   init_adapters();
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/validator.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/validator.js
 function assertOptions(options, schema, allowUnknown) {
-  if (typeof options !== "object") {
+  if (typeof options !== "object" || options === null) {
     throw new AxiosError_default("options must be an object", AxiosError_default.ERR_BAD_OPTION_VALUE);
   }
   const keys = Object.keys(options);
   let i = keys.length;
   while (i-- > 0) {
     const opt = keys[i];
-    const validator = schema[opt];
+    const validator = Object.prototype.hasOwnProperty.call(schema, opt) ? schema[opt] : undefined;
     if (validator) {
       const value = options[opt];
       const result = value === undefined || validator(value, opt, options);
@@ -13916,7 +15353,7 @@ var init_validator = __esm(() => {
   };
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/core/Axios.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/core/Axios.js
 class Axios {
   constructor(instanceConfig) {
     this.defaults = instanceConfig || {};
@@ -13932,13 +15369,27 @@ class Axios {
       if (err instanceof Error) {
         let dummy = {};
         Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = new Error;
-        const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, "") : "";
+        const stack = (() => {
+          if (!dummy.stack) {
+            return "";
+          }
+          const firstNewlineIndex = dummy.stack.indexOf(`
+`);
+          return firstNewlineIndex === -1 ? "" : dummy.stack.slice(firstNewlineIndex + 1);
+        })();
         try {
           if (!err.stack) {
             err.stack = stack;
-          } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ""))) {
-            err.stack += `
+          } else if (stack) {
+            const firstNewlineIndex = stack.indexOf(`
+`);
+            const secondNewlineIndex = firstNewlineIndex === -1 ? -1 : stack.indexOf(`
+`, firstNewlineIndex + 1);
+            const stackWithoutTwoTopLines = secondNewlineIndex === -1 ? "" : stack.slice(secondNewlineIndex + 1);
+            if (!String(err.stack).endsWith(stackWithoutTwoTopLines)) {
+              err.stack += `
 ` + stack;
+            }
           }
         } catch (e) {}
       }
@@ -13959,7 +15410,9 @@ class Axios {
         silentJSONParsing: validators2.transitional(validators2.boolean),
         forcedJSONParsing: validators2.transitional(validators2.boolean),
         clarifyTimeoutError: validators2.transitional(validators2.boolean),
-        legacyInterceptorReqResOrdering: validators2.transitional(validators2.boolean)
+        legacyInterceptorReqResOrdering: validators2.transitional(validators2.boolean),
+        advertiseZstdAcceptEncoding: validators2.transitional(validators2.boolean),
+        validateStatusUndefinedResolves: validators2.transitional(validators2.boolean)
       }, false);
     }
     if (paramsSerializer != null) {
@@ -13985,7 +15438,7 @@ class Axios {
     }, true);
     config.method = (config.method || this.defaults.method || "get").toLowerCase();
     let contextHeaders = headers && utils_default.merge(headers.common, headers[config.method]);
-    headers && utils_default.forEach(["delete", "get", "head", "post", "put", "patch", "common"], (method) => {
+    headers && utils_default.forEach(["delete", "get", "head", "post", "put", "patch", "query", "common"], (method) => {
       delete headers[method];
     });
     config.headers = AxiosHeaders_default.concat(contextHeaders, headers);
@@ -14048,7 +15501,7 @@ class Axios {
   }
   getUri(config) {
     config = mergeConfig(this.defaults, config);
-    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
+    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls, config);
     return buildURL(fullPath, config.params, config.paramsSerializer);
   }
 }
@@ -14069,11 +15522,11 @@ var init_Axios = __esm(() => {
       return this.request(mergeConfig(config || {}, {
         method,
         url: url2,
-        data: (config || {}).data
+        data: config && utils_default.hasOwnProp(config, "data") ? config.data : undefined
       }));
     };
   });
-  utils_default.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+  utils_default.forEach(["post", "put", "patch", "query"], function forEachMethodWithData(method) {
     function generateHTTPMethod(isForm) {
       return function httpMethod(url2, data, config) {
         return this.request(mergeConfig(config || {}, {
@@ -14087,12 +15540,14 @@ var init_Axios = __esm(() => {
       };
     }
     Axios.prototype[method] = generateHTTPMethod();
-    Axios.prototype[method + "Form"] = generateHTTPMethod(true);
+    if (method !== "query") {
+      Axios.prototype[method + "Form"] = generateHTTPMethod(true);
+    }
   });
   Axios_default = Axios;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/cancel/CancelToken.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/cancel/CancelToken.js
 class CancelToken {
   constructor(executor) {
     if (typeof executor !== "function") {
@@ -14182,7 +15637,7 @@ var init_CancelToken = __esm(() => {
   CancelToken_default = CancelToken;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/spread.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/spread.js
 function spread(callback) {
   return function wrap(arr) {
     return callback.apply(null, arr);
@@ -14190,7 +15645,7 @@ function spread(callback) {
 }
 var init_spread = () => {};
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/isAxiosError.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/isAxiosError.js
 function isAxiosError(payload) {
   return utils_default.isObject(payload) && payload.isAxiosError === true;
 }
@@ -14198,7 +15653,7 @@ var init_isAxiosError = __esm(() => {
   init_utils();
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/helpers/HttpStatusCode.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/helpers/HttpStatusCode.js
 var HttpStatusCode, HttpStatusCode_default;
 var init_HttpStatusCode = __esm(() => {
   HttpStatusCode = {
@@ -14278,7 +15733,7 @@ var init_HttpStatusCode = __esm(() => {
   HttpStatusCode_default = HttpStatusCode;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/lib/axios.js
+// node_modules/.bun/axios@1.18.1/node_modules/axios/lib/axios.js
 function createInstance(defaultConfig) {
   const context = new Axios_default(defaultConfig);
   const instance = bind(Axios_default.prototype.request, context);
@@ -14331,8 +15786,8 @@ var init_axios = __esm(() => {
   axios_default = axios;
 });
 
-// node_modules/.bun/axios@1.14.0/node_modules/axios/index.js
-var Axios2, AxiosError2, CanceledError2, isCancel2, CancelToken2, VERSION2, all2, Cancel, isAxiosError2, spread2, toFormData2, AxiosHeaders2, HttpStatusCode2, formToJSON, getAdapter2, mergeConfig2;
+// node_modules/.bun/axios@1.18.1/node_modules/axios/index.js
+var Axios2, AxiosError2, CanceledError2, isCancel2, CancelToken2, VERSION2, all2, Cancel, isAxiosError2, spread2, toFormData2, AxiosHeaders2, HttpStatusCode2, formToJSON, getAdapter2, mergeConfig2, create;
 var init_axios2 = __esm(() => {
   init_axios();
   ({
@@ -14351,8 +15806,9 @@ var init_axios2 = __esm(() => {
     HttpStatusCode: HttpStatusCode2,
     formToJSON,
     getAdapter: getAdapter2,
-    mergeConfig: mergeConfig2
+    mergeConfig: mergeConfig2,
+    create
   } = axios_default);
 });
 
-export { axios_default, Axios2 as Axios, AxiosError2 as AxiosError, CanceledError2 as CanceledError, isCancel2 as isCancel, CancelToken2 as CancelToken, VERSION2 as VERSION, all2 as all, Cancel, isAxiosError2 as isAxiosError, spread2 as spread, toFormData2 as toFormData, AxiosHeaders2 as AxiosHeaders, HttpStatusCode2 as HttpStatusCode, formToJSON, getAdapter2 as getAdapter, mergeConfig2 as mergeConfig, init_axios2 as init_axios };
+export { axios_default, Axios2 as Axios, AxiosError2 as AxiosError, CanceledError2 as CanceledError, isCancel2 as isCancel, CancelToken2 as CancelToken, VERSION2 as VERSION, all2 as all, Cancel, isAxiosError2 as isAxiosError, spread2 as spread, toFormData2 as toFormData, AxiosHeaders2 as AxiosHeaders, HttpStatusCode2 as HttpStatusCode, formToJSON, getAdapter2 as getAdapter, mergeConfig2 as mergeConfig, create, init_axios2 as init_axios };