@superutils/fetch 1.4.2 → 1.5.0

package/dist/browser/index.min.js

@@ -0,0 +1,1124 @@
+this.superutils = this.superutils || {};
+this.superutils.fetch = (function () {
+  'use strict';
+
+  var __defProp = Object.defineProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    ContentType: () => ContentType,
+    FetchAs: () => FetchAs,
+    FetchError: () => FetchError,
+    ResolveError: () => ResolveError,
+    ResolveIgnored: () => ResolveIgnored,
+    TIMEOUT_FALLBACK: () => TIMEOUT_FALLBACK,
+    TIMEOUT_MAX: () => TIMEOUT_MAX,
+    TimeoutPromise: () => TimeoutPromise,
+    createClient: () => createClient,
+    createPostClient: () => createPostClient,
+    default: () => index_default,
+    executeInterceptors: () => executeInterceptors,
+    fetch: () => fetch2,
+    mergeOptions: () => mergeOptions
+  });
+
+  // ../core/dist/index.js
+  var isObj = (x, strict = true) => !!x && typeof x === "object" && (!strict || [
+    Object.prototype,
+    null
+    // when an object is created using `Object.create(null)`
+  ].includes(Object.getPrototypeOf(x)));
+  var isArr = (x) => Array.isArray(x);
+  var isInteger = (x) => Number.isInteger(x);
+  var isNumber = (x) => typeof x === "number" && !Number.isNaN(x) && Number.isFinite(x);
+  var isPositiveInteger = (x) => isInteger(x) && x > 0;
+  var isPositiveNumber = (x) => isNumber(x) && x > 0;
+  var isEmpty = (x, nonNumerable = false, fallback = false) => {
+    if (x === null || x === void 0) return true;
+    switch (typeof x) {
+      case "number":
+        return !isNumber(x);
+      case "string":
+        return !x.replaceAll("	", "").trim().length;
+      case "boolean":
+      case "bigint":
+      case "symbol":
+      case "function":
+        return false;
+    }
+    if (x instanceof Date) return Number.isNaN(x.getTime());
+    if (x instanceof Map || x instanceof Set) return !x.size;
+    if (Array.isArray(x) || x instanceof Uint8Array) return !x.length;
+    if (x instanceof Error) return !x.message.length;
+    const proto = typeof x === "object" && Object.getPrototypeOf(x);
+    if (proto === Object.prototype || proto === null) {
+      return nonNumerable ? !Object.getOwnPropertyNames(x).length : !Object.keys(x).length;
+    }
+    return fallback;
+  };
+  var isFn = (x) => typeof x === "function";
+  var isUrl = (x) => x instanceof URL;
+  var isUrlValid = (x, strict = true, tldExceptions = ["localhost"]) => {
+    if (!x) return false;
+    try {
+      if (typeof x !== "string" && !isUrl(x)) return false;
+      const url = isUrl(x) ? x : new URL(x);
+      if (!strict) return true;
+      const gotTld = tldExceptions.includes(url.hostname) || url.host.split(".").length > 1;
+      if (!gotTld) return false;
+      let y = `${x}`;
+      if (y.endsWith(url.hostname)) y += "/";
+      return url.href === y;
+    } catch (_) {
+      return false;
+    }
+  };
+  var isError = (x) => x instanceof Error;
+  var isPromise = (x) => x instanceof Promise;
+  var isSymbol = (x) => typeof x === "symbol";
+  var fallbackIfFails = (target, args, fallback) => {
+    try {
+      const result = !isFn(target) ? target : target(...isFn(args) ? args() : args);
+      if (!isPromise(result)) return result;
+      return result.catch(
+        (err) => isFn(fallback) ? fallback(err) : fallback
+      );
+    } catch (err) {
+      return isFn(fallback) ? fallback(err) : fallback;
+    }
+  };
+  var fallbackIfFails_default = fallbackIfFails;
+  (/* @__PURE__ */ new Date()).getTime();
+  var objKeys = (obj, sorted = true, includeSymbols = true) => (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    fallbackIfFails_default(
+      () => [
+        ...includeSymbols && Object.getOwnPropertySymbols(obj) || [],
+        ...sorted ? Object.keys(obj).sort() : Object.keys(obj)
+      ],
+      [],
+      []
+    )
+  );
+  var objKeys_default = objKeys;
+  var clone = (value, fallback = "null") => JSON.parse(fallbackIfFails_default(JSON.stringify, [value], fallback));
+  var objCopy = (input, output, ignoreKeys, override = false, recursive = true) => {
+    const _output = isObj(output, false) || isFn(output) ? output : {};
+    if (!isObj(input, false) && !isFn(output)) return _output;
+    const _ignoreKeys = new Set(ignoreKeys != null ? ignoreKeys : []);
+    const inKeys = objKeys_default(input, true, true).filter(
+      (x) => !_ignoreKeys.has(x)
+    );
+    for (const _key of inKeys) {
+      const key = _key;
+      const value = input[key];
+      const skip = _output.hasOwnProperty(key) && (override === "empty" ? !isEmpty(_output[key]) : isFn(override) ? !override(key, _output[key], value) : true);
+      if (skip) continue;
+      const isPrimitive = [void 0, null, Infinity, NaN].includes(value) || !isObj(value, false);
+      if (isPrimitive) {
+        _output[key] = value;
+        continue;
+      }
+      _output[key] = (() => {
+        switch (Object.getPrototypeOf(value)) {
+          case Array.prototype:
+            return clone(value, "[]");
+          case ArrayBuffer.prototype:
+            return value.slice(0);
+          case Date.prototype:
+            return new Date(value.getTime());
+          case Map.prototype:
+            return new Map(
+              clone(
+                Array.from(
+                  value
+                ),
+                "[]"
+              )
+            );
+          case RegExp.prototype:
+            return new RegExp(value);
+          case Set.prototype:
+            return new Set(
+              clone(Array.from(value))
+            );
+          case Uint8Array.prototype:
+            return new Uint8Array([...value]);
+          case URL.prototype:
+            return new URL(value);
+        }
+        if (isSymbol(key) || !recursive) return clone(value);
+        const ignoreChildKeys = [..._ignoreKeys].map(
+          (x) => String(x).startsWith(String(key).concat(".")) && String(x).split(String(key).concat("."))[1]
+        ).filter(Boolean);
+        if (!ignoreChildKeys.length) return clone(value);
+        return objCopy(
+          value,
+          _output[key],
+          ignoreChildKeys,
+          override,
+          recursive
+        );
+      })();
+    }
+    return _output;
+  };
+  var arrUnique = (arr, flatDepth = 0) => !isArr(arr) ? [] : Array.from(new Set(arr.flat(flatDepth)));
+  var debounce = (callback, delay2 = 50, config = {}) => {
+    const {
+      leading = debounce.defaults.leading,
+      onError = debounce.defaults.onError,
+      thisArg
+    } = config;
+    let { tid } = config;
+    if (thisArg !== void 0) callback = callback.bind(thisArg);
+    const _callback = (...args) => fallbackIfFails_default(callback, args, onError);
+    let firstArgs = null;
+    const leadingGlobal = leading === "global";
+    return (...args) => {
+      clearTimeout(tid);
+      tid = setTimeout(() => {
+        firstArgs !== args && _callback(...args);
+        firstArgs = leadingGlobal ? true : null;
+      }, delay2);
+      if (!leading || firstArgs) return;
+      firstArgs = args;
+      _callback(...args);
+    };
+  };
+  debounce.defaults = {
+    /**
+     * Set the default value of argument `leading` for the `deferred` function.
+     * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+     */
+    leading: false,
+    /**
+     * Set the default value of argument `onError` for the `deferred` function.
+     * This change is applicable application-wide and only applies to any new invocation of `deferred()`.
+     */
+    onError: void 0
+  };
+  var debounce_default = debounce;
+  var throttle = (callback, delay2 = 50, config = {}) => {
+    const { defaults: d } = throttle;
+    const { onError = d.onError, trailing = d.trailing, thisArg } = config;
+    let { tid } = config;
+    const handleCallback = (...args) => fallbackIfFails_default(
+      thisArg !== void 0 ? callback.bind(thisArg) : callback,
+      args,
+      !isFn(onError) ? void 0 : (err) => fallbackIfFails_default(onError, [err], void 0)
+    );
+    let trailArgs = null;
+    return (...args) => {
+      if (tid) {
+        trailArgs = args;
+        return;
+      }
+      tid = setTimeout(() => {
+        tid = void 0;
+        if (!trailing) return;
+        const cbArgs = trailArgs;
+        trailArgs = null;
+        cbArgs && cbArgs !== args && handleCallback(...cbArgs);
+      }, delay2);
+      handleCallback(...args);
+    };
+  };
+  throttle.defaults = {
+    onError: void 0,
+    trailing: false
+  };
+  var throttle_default = throttle;
+  var deferred = (callback, delay2 = 50, config = {}) => config.throttle ? throttle_default(callback, delay2, config) : debounce_default(callback, delay2, config);
+
+  // ../promise/dist/index.js
+  var _PromisEBase = class _PromisEBase2 extends Promise {
+    constructor(input) {
+      let _resolve;
+      let _reject;
+      super((resolve, reject) => {
+        _reject = (reason) => {
+          reject(reason);
+          this._state = 2;
+          this.onFinalize.forEach(
+            (fn) => fallbackIfFails(fn, [void 0, reason], void 0)
+          );
+        };
+        _resolve = (value) => {
+          resolve(value);
+          this._state = 1;
+          this.onFinalize.forEach(
+            (fn) => fallbackIfFails(fn, [value, void 0], void 0)
+          );
+        };
+        if (isFn(input)) {
+          fallbackIfFails(input, [_resolve, _reject], _reject);
+        } else if (isPromise(input)) {
+          input.then(_resolve, _reject);
+        } else if (input !== void 0) {
+          _resolve(input);
+        }
+      });
+      this._state = 0;
+      this.onEarlyFinalize = [];
+      this.onFinalize = [];
+      this.resolve = (value) => {
+        var _a, _b;
+        if (!this.pending) return;
+        (_a = this._resolve) == null ? void 0 : _a.call(this, value);
+        (_b = this.onEarlyFinalize) == null ? void 0 : _b.forEach((fn) => {
+          fallbackIfFails(fn, [true, value], void 0);
+        });
+      };
+      this.reject = (reason) => {
+        var _a, _b;
+        if (!this.pending) return;
+        (_a = this._reject) == null ? void 0 : _a.call(this, reason);
+        (_b = this.onEarlyFinalize) == null ? void 0 : _b.forEach((fn) => {
+          fallbackIfFails(fn, [false, reason], void 0);
+        });
+      };
+      this._resolve = _resolve;
+      this._reject = _reject;
+    }
+    //
+    //
+    //-------------------- Status related read-only attributes --------------------
+    //
+    //
+    /** Indicates if the promise is still pending/unfinalized */
+    get pending() {
+      return this.state === 0;
+    }
+    /** Indicates if the promise has been rejected */
+    get rejected() {
+      return this.state === 2;
+    }
+    /** Indicates if the promise has been resolved */
+    get resolved() {
+      return this.state === 1;
+    }
+    /**
+     * Get promise status code:
+     *
+     * - `0` = pending
+     * - `1` = resolved
+     * - `2` = rejected
+     */
+    get state() {
+      return this._state;
+    }
+  };
+  _PromisEBase.all = (values) => new _PromisEBase(globalThis.Promise.all(values));
+  _PromisEBase.allSettled = (values) => new _PromisEBase(globalThis.Promise.allSettled(values));
+  _PromisEBase.any = (values) => new _PromisEBase(globalThis.Promise.any(values));
+  _PromisEBase.race = (values) => new _PromisEBase(globalThis.Promise.race(values));
+  _PromisEBase.reject = (reason) => {
+    const promise = new _PromisEBase();
+    queueMicrotask(() => promise.reject(reason));
+    return promise;
+  };
+  _PromisEBase.resolve = (value) => new _PromisEBase(
+    globalThis.Promise.resolve(value)
+  );
+  _PromisEBase.try = (callbackFn, ...args) => new _PromisEBase(
+    (resolve) => resolve(
+      // Promise.try is not supported in Node < 23.
+      fallbackIfFails(
+        callbackFn,
+        args,
+        // rethrow error to ensure the returned promise is rejected
+        (err) => globalThis.Promise.reject(err)
+      )
+    )
+  );
+  _PromisEBase.withResolvers = () => {
+    const promise = new _PromisEBase();
+    return { promise, reject: promise.reject, resolve: promise.resolve };
+  };
+  var PromisEBase = _PromisEBase;
+  var PromisEBase_default = PromisEBase;
+  var ResolveError = /* @__PURE__ */ ((ResolveError2) => {
+    ResolveError2["NEVER"] = "NEVER";
+    ResolveError2["REJECT"] = "REJECT";
+    ResolveError2["WITH_ERROR"] = "RESOLVE_ERROR";
+    ResolveError2["WITH_UNDEFINED"] = "RESOLVE_UNDEFINED";
+    return ResolveError2;
+  })(ResolveError || {});
+  var ResolveIgnored = /* @__PURE__ */ ((ResolveIgnored2) => {
+    ResolveIgnored2["NEVER"] = "NEVER";
+    ResolveIgnored2["WITH_LAST"] = "WITH_LAST";
+    ResolveIgnored2["WITH_UNDEFINED"] = "WITH_UNDEFINED";
+    return ResolveIgnored2;
+  })(ResolveIgnored || {});
+  function deferred2(options = {}) {
+    let sequence = 0;
+    options = objCopy(
+      deferred2.defaults,
+      options,
+      [],
+      "empty"
+    );
+    let { onError, onIgnore, onResult } = options;
+    const {
+      delay: delay2 = 0,
+      ignoreStale,
+      resolveError,
+      resolveIgnored,
+      thisArg,
+      throttle: throttle2
+    } = options;
+    let lastInSeries = null;
+    let lastExecuted;
+    const queue = /* @__PURE__ */ new Map();
+    const isSequential = !isPositiveNumber(delay2);
+    if (thisArg !== void 0) {
+      onError = onError == null ? void 0 : onError.bind(thisArg);
+      onIgnore = onIgnore == null ? void 0 : onIgnore.bind(thisArg);
+      onResult = onResult == null ? void 0 : onResult.bind(thisArg);
+    }
+    const handleIgnore = (items) => {
+      for (const [iId, iItem] of items) {
+        queue.delete(iId);
+        const isStale = ignoreStale && iItem.sequence < lastExecuted.sequence;
+        if (iItem.resolved || iItem.started && !isStale) continue;
+        if (iItem.started) {
+          iItem.getPromise = (() => iItem.result);
+        }
+        fallbackIfFails(onIgnore, [iItem.getPromise], 0);
+        switch (resolveIgnored) {
+          case "WITH_UNDEFINED":
+            iItem.resolve(void 0);
+            break;
+          case "WITH_LAST":
+            lastExecuted == null ? void 0 : lastExecuted.then(iItem.resolve, iItem.reject);
+            break;
+        }
+      }
+      if (!queue.size) sequence = 0;
+    };
+    const handleRemaining = (currentId) => {
+      lastInSeries = null;
+      if (isSequential) {
+        queue.delete(currentId);
+        const [nextId, nextItem] = [...queue.entries()][0] || [];
+        return nextId && nextItem && handleItem(nextId, nextItem);
+      }
+      let items = [...queue.entries()];
+      if (throttle2 === true && options.trailing) {
+        const currentIndex = items.findIndex(([id]) => id === currentId);
+        items = items.slice(0, currentIndex);
+      } else if (!throttle2) {
+        items = items.slice(0, -1);
+      }
+      handleIgnore(items);
+      queue.delete(currentId);
+    };
+    const executeItem = async (id, qItem) => {
+      var _a;
+      try {
+        qItem.started = true;
+        lastExecuted = qItem;
+        lastInSeries = qItem;
+        (_a = qItem.result) != null ? _a : qItem.result = PromisEBase_default.try(qItem.getPromise);
+        const result = await qItem.result;
+        const isStale = !!ignoreStale && qItem.sequence < lastExecuted.sequence;
+        if (isStale) return handleIgnore([[id, qItem]]);
+        qItem.resolve(result);
+        onResult && fallbackIfFails(onResult, [result], void 0);
+      } catch (err) {
+        onError && fallbackIfFails(onError, [err], void 0);
+        switch (resolveError) {
+          case "REJECT":
+            qItem.reject(err);
+          // eslint-disable-next-line no-fallthrough
+          case "NEVER":
+            break;
+          case "RESOLVE_UNDEFINED":
+            qItem.resolve(void 0);
+            break;
+          case "RESOLVE_ERROR":
+            qItem.resolve(err);
+            break;
+        }
+      }
+      handleRemaining(id);
+    };
+    const handleItem = isSequential ? executeItem : deferred(
+      executeItem,
+      delay2,
+      options
+    );
+    return (promise) => {
+      const id = /* @__PURE__ */ Symbol("deferred-queue-item-id");
+      const qItem = new PromisEBase_default();
+      qItem.getPromise = isFn(promise) ? promise : () => promise;
+      qItem.started = false;
+      qItem.sequence = ++sequence;
+      queue.set(id, qItem);
+      if (!lastInSeries || !isSequential) handleItem(id, qItem);
+      return qItem;
+    };
+  }
+  deferred2.defaults = {
+    /**
+     * Default delay in milliseconds, used in `debounce` and `throttle` modes.
+     *
+     * Use `0` (or negative number) to disable debounce/throttle and execute all operations sequentially.
+     */
+    delay: 100,
+    /** Set the default error resolution behavior. {@link ResolveError} for all options. */
+    resolveError: "REJECT",
+    /** Set the default ignored resolution behavior. See {@link ResolveIgnored} for all options. */
+    resolveIgnored: "WITH_LAST"
+    /* WITH_LAST */
+  };
+  var deferred_default = deferred2;
+  function deferredCallback(callback, options = {}) {
+    const { thisArg } = options;
+    if (thisArg !== void 0) callback = callback.bind(thisArg);
+    const deferPromise = deferred_default(options);
+    return (...args) => deferPromise(() => callback(...args));
+  }
+  var deferredCallback_default = deferredCallback;
+  function delay(duration = delay.defaults.duration, result, asRejected = false) {
+    const promise = new PromisEBase_default();
+    const finalize = (result2) => {
+      const _result = fallbackIfFails(
+        async () => {
+          const _result2 = await (isFn(result2) ? result2() : result2);
+          return !asRejected ? _result2 != null ? _result2 : duration : _result2 != null ? _result2 : new Error(
+            `${delay.defaults.delayTimeoutMsg} ${duration}ms`
+          );
+        },
+        [],
+        // when result is a function and it fails/rejects,
+        // promise will reject even if `asRejected = false`
+        (err) => Promise.reject(err)
+      );
+      !asRejected ? promise.resolve(_result) : _result.then(promise.reject, promise.reject);
+    };
+    promise.timeoutId = setTimeout(() => finalize(result), duration);
+    promise.pause = () => clearTimeout(promise.timeoutId);
+    promise.catch(() => {
+    }).finally(() => promise.pause());
+    promise.onEarlyFinalize.push(() => promise.pause());
+    return promise;
+  }
+  delay.defaults = {
+    /** Default delay duration in milliseconds */
+    duration: 100,
+    /** Default timed out message (if `result` is not provided) */
+    delayTimeoutMsg: "Timed out after"
+  };
+  var delay_default = delay;
+  function delayReject(duration, reason) {
+    return delay_default(duration, reason, true);
+  }
+  var delayReject_default = delayReject;
+  var retry = async (func, options) => {
+    var _a, _b;
+    options = objCopy(retry.defaults, options != null ? options : {}, [], (key, value) => {
+      switch (key) {
+        // case 'retryDelayJitter':
+        // 	return true
+        case "retry":
+        // eslint-disable-next-line no-fallthrough
+        case "retryDelay":
+        case "retryDelayJitterMax":
+          return value !== 0 && !isPositiveInteger(value);
+      }
+      return !!isEmpty(value);
+    });
+    const {
+      retry: maxRetries,
+      retryBackOff,
+      retryDelay,
+      retryDelayJitter,
+      retryDelayJitterMax
+    } = options;
+    let _retryDelay = retryDelay;
+    let retryCount = -1;
+    let result;
+    let error;
+    let shouldRetry = false;
+    do {
+      retryCount++;
+      if (retryBackOff === "exponential" && retryCount > 1) _retryDelay *= 2;
+      if (retryDelayJitter)
+        _retryDelay += Math.floor(Math.random() * retryDelayJitterMax);
+      if (retryCount > 0) await delay_default(_retryDelay);
+      try {
+        error = void 0;
+        result = await func();
+      } catch (err) {
+        error = err;
+      }
+      if (maxRetries === 0 || retryCount >= maxRetries) break;
+      shouldRetry = !!((_b = await fallbackIfFails(
+        (_a = options.retryIf) != null ? _a : error,
+        // if `retryIf` not provided, retry on error
+        [result, retryCount, error],
+        error
+        // if `retryIf` throws error, default to retry on error
+      )) != null ? _b : error);
+    } while (shouldRetry);
+    if (error !== void 0) return Promise.reject(error);
+    return result;
+  };
+  retry.defaults = {
+    retry: 1,
+    retryBackOff: "exponential",
+    retryDelay: 300,
+    retryDelayJitter: true,
+    retryDelayJitterMax: 100
+  };
+  var retry_default = retry;
+  var TIMEOUT_FALLBACK = 1e4;
+  var TIMEOUT_MAX = 2147483647;
+  var TimeoutPromise = class extends PromisEBase_default {
+    constructor(data, timeout2, options, _signals) {
+      super(data);
+      this.started = /* @__PURE__ */ new Date();
+      this._setup = () => {
+        var _a, _b, _c, _d;
+        this._signals = arrUnique(
+          [(_b = (_a = this.options) == null ? void 0 : _a.abortCtrl) == null ? void 0 : _b.signal, (_c = this.options) == null ? void 0 : _c.signal].filter(
+            Boolean
+          )
+        );
+        !this.onEarlyFinalize.includes(this._handleEarlyFinalize) && this.onEarlyFinalize.push(this._handleEarlyFinalize);
+        !this.onFinalize.includes(this._handleFinalize) && this.onFinalize.push(this._handleFinalize);
+        (_d = this._signals) == null ? void 0 : _d.forEach(
+          (signal) => signal == null ? void 0 : signal.addEventListener(
+            "abort",
+            this._handleAbort
+          )
+        );
+      };
+      this._handleAbort = async () => {
+        var _a, _b, _c;
+        if (!((_a = this._signals) == null ? void 0 : _a.length) || !this.pending) return;
+        let err = await fallbackIfFails((_b = this.options) == null ? void 0 : _b.onAbort, [], void 0);
+        err != null ? err : err = new Error(
+          `Aborted after ${(/* @__PURE__ */ new Date()).getTime() - this.started.getTime()}ms`
+        );
+        (_c = err.name) != null ? _c : err.name = "AbortError";
+        this.reject(err);
+      };
+      this._handleEarlyFinalize = () => {
+        var _a, _b, _c, _d;
+        ((_a = this.options) == null ? void 0 : _a.abortOnEarlyFinalize) && ((_d = (_c = (_b = this.options) == null ? void 0 : _b.abortCtrl) == null ? void 0 : _c.abort) == null ? void 0 : _d.call(_c));
+      };
+      this._handleFinalize = ((_, err) => {
+        var _a, _b, _c, _d, _e;
+        this.cancelAbort();
+        this.clearTimeout();
+        if (!this.timeout.rejected && !((_a = this._signals) == null ? void 0 : _a.find((x) => x == null ? void 0 : x.aborted)))
+          return;
+        ((_d = (_c = (_b = this.options) == null ? void 0 : _b.abortCtrl) == null ? void 0 : _c.signal) == null ? void 0 : _d.aborted) === false && ((_e = this.options) == null ? void 0 : _e.abortCtrl.abort(err));
+      });
+      this.data = data;
+      this.options = isObj(options) ? options : {};
+      this.timeout = timeout2;
+      this._signals = _signals;
+      this._setup();
+    }
+    get abortCtrl() {
+      return this.options.abortCtrl;
+    }
+    get aborted() {
+      var _a;
+      return this.rejected && !this.timeout.rejected && !!((_a = this._signals) == null ? void 0 : _a.find((s) => s == null ? void 0 : s.aborted));
+    }
+    cancelAbort() {
+      var _a;
+      (_a = this._signals) == null ? void 0 : _a.forEach(
+        (signal) => signal == null ? void 0 : signal.removeEventListener(
+          "abort",
+          this._handleAbort
+        )
+      );
+    }
+    clearTimeout() {
+      clearTimeout(this.timeout.timeoutId);
+    }
+    get timedout() {
+      return this.rejected && this.timeout.rejected;
+    }
+  };
+  var TimeoutPromise_default = TimeoutPromise;
+  function timeout(options, ...values) {
+    var _a;
+    const opts = objCopy(
+      timeout.defaults,
+      isNumber(options) ? { timeout: options } : isObj(options) ? options : {},
+      [],
+      "empty"
+    );
+    opts.timeout = Math.min(
+      isPositiveNumber(opts.timeout) ? opts.timeout : TIMEOUT_FALLBACK,
+      TIMEOUT_MAX
+    );
+    const promises = values.map(
+      (v) => isFn(v) ? PromisEBase_default.try(v) : v
+    );
+    const dataPromise = promises.length <= 1 ? (
+      // single promise resolves to a single result
+      promises[0] instanceof PromisEBase_default ? promises[0] : new PromisEBase_default(promises[0])
+    ) : (
+      // multiple promises resolve to an array of results
+      (isFn(PromisEBase_default[opts.batchFunc]) ? PromisEBase_default[opts.batchFunc] : PromisEBase_default.all)(promises)
+    );
+    const timeoutPromise = delayReject_default(opts.timeout, opts.onTimeout);
+    return new TimeoutPromise_default(
+      PromisEBase_default.race([dataPromise, timeoutPromise]),
+      timeoutPromise,
+      opts,
+      arrUnique(
+        [(_a = opts.abortCtrl) == null ? void 0 : _a.signal, opts.signal].filter(Boolean)
+      )
+    );
+  }
+  timeout.defaults = {
+    abortOnEarlyFinalize: true,
+    batchFunc: "all",
+    timeout: TIMEOUT_FALLBACK
+  };
+  var timeout_default = timeout;
+  var PromisE = class extends PromisEBase_default {
+  };
+  PromisE.deferred = deferred_default;
+  PromisE.deferredCallback = deferredCallback_default;
+  PromisE.delay = delay_default;
+  PromisE.delayReject = delayReject_default;
+  PromisE.retry = retry_default;
+  PromisE.timeout = timeout_default;
+
+  // src/executeInterceptors.ts
+  var executeInterceptors = async (value, signal, interceptors, ...args) => {
+    var _a;
+    for (const interceptor of [...interceptors != null ? interceptors : []].filter(isFn)) {
+      if (signal == null ? void 0 : signal.aborted) break;
+      value = (_a = await fallbackIfFails(
+        interceptor,
+        [value, ...args],
+        void 0
+      )) != null ? _a : value;
+    }
+    return value;
+  };
+  var executeInterceptors_default = executeInterceptors;
+
+  // src/getResponse.ts
+  var getResponse = (url, options = {}) => {
+    const fetchFunc = isFn(options.fetchFunc) ? options.fetchFunc : globalThis.fetch;
+    if (!isPositiveInteger(options.retry)) return fetchFunc(url, options);
+    let attemptCount = 0;
+    const response = retry(
+      () => {
+        attemptCount++;
+        return fetchFunc(url, options);
+      },
+      {
+        ...options,
+        retryIf: async (res, count, error) => {
+          var _a;
+          const { abortCtrl, retryIf, signal } = options;
+          if ((abortCtrl == null ? void 0 : abortCtrl.signal.aborted) || (signal == null ? void 0 : signal.aborted)) return false;
+          return !!((_a = await fallbackIfFails(
+            retryIf,
+            [res, count, error],
+            void 0
+          )) != null ? _a : !!error || !(res == null ? void 0 : res.ok));
+        }
+      }
+    ).catch(
+      (err) => Promise.reject(
+        new Error(`Request failed after attempt #${attemptCount}`, {
+          cause: err
+        })
+      )
+    );
+    return response;
+  };
+  var getResponse_default = getResponse;
+
+  // src/mergeOptions.ts
+  var mergeOptions = (...allOptions) => allOptions.reduce(
+    (merged, options) => {
+      var _a;
+      options = isObj(options) ? options : {};
+      const { headers, interceptors: ints1 = {} } = merged;
+      const { interceptors: ints2 = {} } = options;
+      options.headers && new Headers(options.headers).forEach(
+        (value, key) => headers.set(key, value)
+      );
+      return {
+        ...merged,
+        ...options,
+        errMsgs: objCopy(
+          options.errMsgs,
+          merged.errMsgs,
+          [],
+          "empty"
+        ),
+        headers,
+        interceptors: {
+          error: [...toArr(ints1 == null ? void 0 : ints1.error), ...toArr(ints2 == null ? void 0 : ints2.error)],
+          request: [
+            ...toArr(ints1 == null ? void 0 : ints1.request),
+            ...toArr(ints2 == null ? void 0 : ints2.request)
+          ],
+          response: [
+            ...toArr(ints1 == null ? void 0 : ints1.response),
+            ...toArr(ints2 == null ? void 0 : ints2.response)
+          ],
+          result: [...toArr(ints1 == null ? void 0 : ints1.result), ...toArr(ints2 == null ? void 0 : ints2.result)]
+        },
+        timeout: (_a = options.timeout) != null ? _a : merged.timeout
+      };
+    },
+    { headers: new Headers() }
+  );
+  var mergeOptions_default = mergeOptions;
+  var toArr = (x) => isArr(x) ? x : isFn(x) ? [x] : [];
+
+  // src/types/constants.ts
+  var ContentType = {
+    APPLICATION_JAVASCRIPT: "application/javascript",
+    APPLICATION_JSON: "application/json",
+    APPLICATION_OCTET_STREAM: "application/octet-stream",
+    APPLICATION_PDF: "application/pdf",
+    APPLICATION_X_WWW_FORM_URLENCODED: "application/x-www-form-urlencoded",
+    APPLICATION_XML: "application/xml",
+    APPLICATION_ZIP: "application/zip",
+    AUDIO_MPEG: "audio/mpeg",
+    MULTIPART_FORM_DATA: "multipart/form-data",
+    TEXT_CSS: "text/css",
+    TEXT_HTML: "text/html",
+    TEXT_PLAIN: "text/plain",
+    VIDEO_MP4: "video/mp4"
+  };
+  var FetchAs = /* @__PURE__ */ ((FetchAs2) => {
+    FetchAs2["arrayBuffer"] = "arrayBuffer";
+    FetchAs2["blob"] = "blob";
+    FetchAs2["bytes"] = "bytes";
+    FetchAs2["formData"] = "formData";
+    FetchAs2["json"] = "json";
+    FetchAs2["response"] = "response";
+    FetchAs2["text"] = "text";
+    return FetchAs2;
+  })(FetchAs || {});
+
+  // src/types/FetchError.ts
+  var FetchError = class _FetchError extends Error {
+    constructor(message, options) {
+      super(message, { cause: options.cause });
+      this.name = "FetchError";
+      Object.defineProperties(this, {
+        clone: {
+          get() {
+            return (newMessage) => new _FetchError(newMessage, {
+              cause: options.cause,
+              options: options.options,
+              response: options.response,
+              url: options.url
+            });
+          }
+        },
+        options: {
+          get() {
+            return options.options;
+          }
+        },
+        response: {
+          get() {
+            return options.response;
+          }
+        },
+        url: {
+          get() {
+            return options.url;
+          }
+        }
+      });
+    }
+  };
+
+  // src/fetch.ts
+  var fetch = (url, options = {}) => {
+    var _a, _b, _c;
+    let response;
+    const opts = mergeOptions_default(fetch.defaults, options);
+    opts.abortCtrl = opts.abortCtrl instanceof AbortController ? opts.abortCtrl : new AbortController();
+    (_a = opts.as) != null ? _a : opts.as = "response" /* response */;
+    (_b = opts.method) != null ? _b : opts.method = "get";
+    (_c = opts.signal) != null ? _c : opts.signal = opts.abortCtrl.signal;
+    const { abortCtrl, as: parseAs, headers, onAbort, onTimeout } = opts;
+    opts.onAbort = async () => {
+      var _a2, _b2, _c2, _d, _e, _f;
+      const err = (_f = (_e = (_c2 = await fallbackIfFails(onAbort, [], void 0)) != null ? _c2 : (_b2 = (_a2 = opts.abortCtrl) == null ? void 0 : _a2.signal) == null ? void 0 : _b2.reason) != null ? _e : (_d = opts.signal) == null ? void 0 : _d.reason) != null ? _f : opts.errMsgs.aborted;
+      if (isError(err) && err.name === "AbortError") {
+        err.message = ["This operation was aborted"].includes(err.message) ? opts.errMsgs.aborted : err.message;
+      }
+      return await interceptErr(
+        isError(err) ? err : new Error(err),
+        url,
+        opts,
+        response
+      );
+    };
+    opts.onTimeout = async () => {
+      const err = await fallbackIfFails(onTimeout, [], void 0);
+      return await interceptErr(
+        err != null ? err : new Error(opts.errMsgs.timedout),
+        url,
+        opts,
+        response
+      );
+    };
+    return timeout(opts, async () => {
+      var _a2, _b2, _c2, _d, _e;
+      try {
+        let contentType = headers.get("content-type");
+        if (!contentType) {
+          headers.set("content-type", ContentType.APPLICATION_JSON);
+          contentType = ContentType.APPLICATION_JSON;
+        }
+        url = await executeInterceptors_default(
+          url,
+          abortCtrl.signal,
+          (_a2 = opts.interceptors) == null ? void 0 : _a2.request,
+          opts
+        );
+        const { body, errMsgs, validateUrl = true } = opts;
+        (_b2 = opts.signal) != null ? _b2 : opts.signal = abortCtrl.signal;
+        if (validateUrl && !isUrlValid(url, false))
+          throw new Error(errMsgs.invalidUrl);
+        const shouldStringifyBody = [
+          ContentType.APPLICATION_JSON,
+          ContentType.APPLICATION_X_WWW_FORM_URLENCODED
+        ].find((x) => contentType.includes(x)) && !["undefined", "string"].includes(typeof body);
+        if (shouldStringifyBody)
+          opts.body = JSON.stringify(
+            isFn(body) ? fallbackIfFails(body, [], void 0) : body
+          );
+        response = await getResponse_default(url, opts);
+        response = await executeInterceptors_default(
+          response,
+          abortCtrl.signal,
+          (_c2 = opts.interceptors) == null ? void 0 : _c2.response,
+          url,
+          opts
+        );
+        const status = (_d = response == null ? void 0 : response.status) != null ? _d : 0;
+        const isSuccess = status >= 200 && status < 300;
+        if (!isSuccess) {
+          const jsonError = await fallbackIfFails(
+            // try to parse error response as json first
+            () => response.json(),
+            [],
+            void 0
+          );
+          throw new Error(
+            (jsonError == null ? void 0 : jsonError.message) || `${errMsgs.requestFailed} ${status}`,
+            { cause: jsonError }
+          );
+        }
+        const parseFunc = response[parseAs];
+        let result = !isFn(parseFunc) ? response : parseFunc.bind(response)();
+        if (isPromise(result))
+          result = await result.catch(
+            (err) => Promise.reject(
+              new Error(
+                `${errMsgs.parseFailed} ${parseAs}. ${err == null ? void 0 : err.message}`,
+                { cause: err }
+              )
+            )
+          );
+        result = await executeInterceptors_default(
+          result,
+          abortCtrl.signal,
+          (_e = opts.interceptors) == null ? void 0 : _e.result,
+          url,
+          opts
+        );
+        return result;
+      } catch (_err) {
+        let err = _err;
+        err = await interceptErr(_err, url, opts, response);
+        return Promise.reject(err);
+      }
+    });
+  };
+  fetch.defaults = {
+    abortOnEarlyFinalize: true,
+    errMsgs: {
+      aborted: "Request aborted",
+      invalidUrl: "Invalid URL",
+      parseFailed: "Failed to parse response as",
+      timedout: "Request timed out",
+      requestFailed: "Request failed with status code:"
+    },
+    // all error messages must be defined here
+    headers: new Headers(),
+    interceptors: {
+      error: [],
+      request: [],
+      response: [],
+      result: []
+    },
+    timeout: 3e4,
+    validateUrl: true
+  };
+  var interceptErr = async (err, url, options, response) => {
+    var _a, _b, _c;
+    const fErr = await executeInterceptors_default(
+      new FetchError((_a = err == null ? void 0 : err.message) != null ? _a : err, {
+        cause: (_b = err == null ? void 0 : err.cause) != null ? _b : err,
+        response,
+        options,
+        url
+      }),
+      void 0,
+      // should execute regardless of abort status
+      (_c = options.interceptors) == null ? void 0 : _c.error,
+      url,
+      options
+    );
+    return fErr;
+  };
+  var fetch_default = fetch;
+
+  // src/createClient.ts
+  var createClient = (fixedOptions, commonOptions, commonDeferOptions) => {
+    function client(url, options) {
+      var _a;
+      const mergedOptions = mergeOptions_default(
+        commonOptions,
+        options,
+        fixedOptions
+        // fixed options will always override other options
+      );
+      (_a = mergedOptions.as) != null ? _a : mergedOptions.as = "json" /* json */;
+      return fetch_default(url, mergedOptions);
+    }
+    client.deferred = (deferOptions, defaultUrl, defaultOptions) => {
+      let _abortCtrl;
+      const fetchCb = (...args) => {
+        var _a, _b, _c;
+        const mergedOptions = (_a = mergeOptions_default(
+          commonOptions,
+          defaultOptions,
+          defaultUrl === void 0 ? args[1] : args[0],
+          fixedOptions
+          // fixed options will always override other options
+        )) != null ? _a : {};
+        (_b = mergedOptions.as) != null ? _b : mergedOptions.as = "json" /* json */;
+        (_c = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _c.call(_abortCtrl);
+        _abortCtrl = new AbortController();
+        return fetch_default(
+          defaultUrl != null ? defaultUrl : args[0],
+          mergedOptions
+        );
+      };
+      return deferredCallback(fetchCb, {
+        ...commonDeferOptions,
+        ...deferOptions
+      });
+    };
+    return client;
+  };
+  var createClient_default = createClient;
+
+  // src/createPostClient.ts
+  var createPostClient = (fixedOptions, commonOptions, commonDeferOptions) => {
+    function client(url, data, options) {
+      var _a, _b;
+      const mergedOptions = mergeOptions_default(
+        commonOptions,
+        options,
+        fixedOptions
+        // fixed options will always override other options
+      );
+      (_a = mergedOptions.as) != null ? _a : mergedOptions.as = "json" /* json */;
+      mergedOptions.body = data;
+      (_b = mergedOptions.method) != null ? _b : mergedOptions.method = "post";
+      return fetch_default(url, mergedOptions);
+    }
+    client.deferred = (deferOptions, defaultUrl, defaultData, defaultOptions) => {
+      let _abortCtrl;
+      const postCb = (...args) => {
+        var _a, _b, _c, _d, _e;
+        if (defaultUrl !== void 0) args.splice(0, 0, defaultUrl);
+        if (defaultData !== void 0) args.splice(1, 0, defaultData);
+        const mergedOptions = (_a = mergeOptions_default(
+          commonOptions,
+          defaultOptions,
+          args[2],
+          fixedOptions
+          // fixed options will always override other options
+        )) != null ? _a : {};
+        (_b = mergedOptions.as) != null ? _b : mergedOptions.as = "json" /* json */;
+        (_c = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _c.call(_abortCtrl);
+        _abortCtrl = new AbortController();
+        mergedOptions.body = (_d = args[1]) != null ? _d : mergedOptions.body;
+        (_e = mergedOptions.method) != null ? _e : mergedOptions.method = "post";
+        return fetch_default(args[0], mergedOptions);
+      };
+      return deferredCallback(postCb, {
+        ...commonDeferOptions,
+        ...deferOptions
+      });
+    };
+    return client;
+  };
+  var createPostClient_default = createPostClient;
+
+  // src/index.ts
+  var methods = {
+    /** Make HTTP requests with method GET */
+    get: createClient_default({ method: "get" }),
+    /** Make HTTP requests with method HEAD */
+    head: createClient_default({ method: "head" }),
+    /** Make HTTP requests with method OPTIONS */
+    options: createClient_default({ method: "options" }),
+    /** Make HTTP requests with method DELETE */
+    delete: createPostClient_default({ method: "delete" }),
+    /** Make HTTP requests with method PATCH */
+    patch: createPostClient_default({ method: "patch" }),
+    /** Make HTTP requests with method POST */
+    post: createPostClient_default({ method: "post" }),
+    /** Make HTTP requests with method PUT */
+    put: createPostClient_default({ method: "put" })
+  };
+  var fetch2 = fetch_default;
+  fetch2.delete = methods.delete;
+  fetch2.get = methods.get;
+  fetch2.head = methods.head;
+  fetch2.options = methods.options;
+  fetch2.patch = methods.patch;
+  fetch2.post = methods.post;
+  fetch2.put = methods.put;
+  var index_default = fetch2;
+
+  // src/browser.ts
+  var { default: fetch3 } = index_exports;
+  Object.keys(index_exports).forEach((key) => {
+    var _a;
+    if (["default", "fetch"].includes(key)) return;
+    (_a = fetch3[key]) != null ? _a : fetch3[key] = index_exports[key];
+  });
+  var browser_default = fetch3;
+
+  return browser_default;
+
+})();
+//# sourceMappingURL=index.min.js.map
+//# sourceMappingURL=index.min.js.map