@ahoo-wang/fetcher 1.0.6 → 1.1.0

package/dist/index.es.js

@@ -1,10 +1,10 @@
 function g(r) {
   return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(r);
 }
-function P(r, e) {
-  return g(e) ? e : e ? r.replace(/\/?\/$/, "") + "/" + e.replace(/^\/+/, "") : r;
+function b(r, t) {
+  return g(t) ? t : t ? r.replace(/\/?\/$/, "") + "/" + t.replace(/^\/+/, "") : r;
 }
-class b {
+class S {
   /**
    * Initializes a new UrlBuilder instance.
    *
@@ -15,8 +15,8 @@ class b {
    * const urlBuilder = new UrlBuilder('https://api.example.com');
    * ```
    */
-  constructor(e) {
-    this.baseURL = e;
+  constructor(t) {
+    this.baseURL = t;
   }
   /**
    * Builds a complete URL, including path parameter replacement and query parameter addition.
@@ -36,8 +36,8 @@ class b {
    * // Result: https://api.example.com/users/123/posts/456?filter=active&limit=10
    * ```
    */
-  build(e, t) {
-    const s = t?.path, o = t?.query, i = P(this.baseURL, e);
+  build(t, e) {
+    const s = e?.path, o = e?.query, i = b(this.baseURL, t);
     let n = this.interpolateUrl(i, s);
     if (o) {
       const u = new URLSearchParams(o).toString();
@@ -54,8 +54,8 @@ class b {
    * @param request - The FetchRequest containing URL and URL parameters
    * @returns Complete resolved URL string
    */
-  resolveRequestUrl(e) {
-    return this.build(e.url, e.urlParams);
+  resolveRequestUrl(t) {
+    return this.build(t.url, t.urlParams);
   }
   /**
    * Replaces placeholders in the URL with path parameters.
@@ -84,13 +84,13 @@ class b {
    * }
    * ```
    */
-  interpolateUrl(e, t) {
-    return t ? e.replace(/{([^}]+)}/g, (s, o) => {
-      const i = t[o];
+  interpolateUrl(t, e) {
+    return e ? t.replace(/{([^}]+)}/g, (s, o) => {
+      const i = e[o];
       if (i === void 0)
         throw new Error(`Missing required path parameter: ${o}`);
       return String(i);
-    }) : e;
+    }) : t;
   }
 }
 class a extends Error {
@@ -100,69 +100,71 @@ class a extends Error {
    * @param errorMsg - Optional error message. If not provided, will use the cause's message or a default message.
    * @param cause - Optional underlying error that caused this error.
    */
-  constructor(e, t) {
-    const s = e || t?.message || "An error occurred in the fetcher";
-    super(s), this.cause = t, this.name = "FetcherError", t?.stack && (this.stack = t.stack), Object.setPrototypeOf(this, a.prototype);
+  constructor(t, e) {
+    const s = t || e?.message || "An error occurred in the fetcher";
+    super(s), this.cause = e, this.name = "FetcherError", e?.stack && (this.stack = e.stack), Object.setPrototypeOf(this, a.prototype);
   }
 }
-class m extends a {
+class R extends a {
   /**
    * Creates a new FetchTimeoutError instance.
    *
    * @param request - The request options that timed out
    */
-  constructor(e) {
-    const t = e.method || "GET", s = `Request timeout of ${e.timeout}ms exceeded for ${t} ${e.url}`;
-    super(s), this.name = "FetchTimeoutError", this.request = e, Object.setPrototypeOf(this, m.prototype);
+  constructor(t) {
+    const e = t.method || "GET", s = `Request timeout of ${t.timeout}ms exceeded for ${e} ${t.url}`;
+    super(s), this.name = "FetchTimeoutError", this.request = t, Object.setPrototypeOf(this, R.prototype);
   }
 }
-function S(r, e) {
-  return typeof r < "u" ? r : e;
+function _(r, t) {
+  return typeof r < "u" ? r : t;
 }
-async function _(r) {
-  const e = r.url, t = r.timeout, s = r;
-  if (!t)
-    return fetch(e, s);
+async function w(r) {
+  const t = r.url, e = r.timeout, s = r;
+  if (!e)
+    return fetch(t, s);
   const o = new AbortController(), i = {
     ...s,
     signal: o.signal
   };
   let n = null;
-  const u = new Promise((X, A) => {
+  const u = new Promise((Y, P) => {
     n = setTimeout(() => {
       n && clearTimeout(n);
-      const f = new m(r);
-      o.abort(f), A(f);
-    }, t);
+      const y = new R(r);
+      o.abort(y), P(y);
+    }, e);
   });
   try {
-    return await Promise.race([fetch(e, i), u]);
+    return await Promise.race([fetch(t, i), u]);
   } finally {
     n && clearTimeout(n);
   }
 }
-const w = "UrlResolveInterceptor", I = Number.MIN_SAFE_INTEGER + 1e3;
-class N {
+const N = "UrlResolveInterceptor", O = Number.MIN_SAFE_INTEGER + 1e3;
+class F {
   constructor() {
-    this.name = w, this.order = I;
+    this.name = N, this.order = O;
   }
   /**
    * Resolves the final URL by combining the base URL, path parameters, and query parameters.
    *
    * @param exchange - The fetch exchange containing the request information
    */
-  intercept(e) {
-    const t = e.request;
-    t.url = e.fetcher.urlBuilder.resolveRequestUrl(t);
+  intercept(t) {
+    const e = t.request;
+    e.url = t.fetcher.urlBuilder.resolveRequestUrl(e);
   }
 }
 var c = /* @__PURE__ */ ((r) => (r.GET = "GET", r.POST = "POST", r.PUT = "PUT", r.DELETE = "DELETE", r.PATCH = "PATCH", r.HEAD = "HEAD", r.OPTIONS = "OPTIONS", r))(c || {});
-const z = "Content-Type";
-var T = /* @__PURE__ */ ((r) => (r.APPLICATION_JSON = "application/json", r.TEXT_EVENT_STREAM = "text/event-stream", r))(T || {});
-const F = "RequestBodyInterceptor", q = I + 1e3;
-class U {
+const z = "Content-Type", d = class d {
+};
+d.APPLICATION_JSON = "application/json", d.TEXT_EVENT_STREAM = "text/event-stream";
+let h = d;
+const q = "RequestBodyInterceptor", U = O + 1e3;
+class D {
   constructor() {
-    this.name = F, this.order = q;
+    this.name = q, this.order = U;
   }
   /**
    * Attempts to convert request body to a valid fetch API body type.
@@ -201,21 +203,21 @@ class U {
    * // exchange.request.body will be '{"name":"John","age":30}'
    * // exchange.request.headers will include 'Content-Type: application/json'
    */
-  intercept(e) {
-    const t = e.request;
-    if (t.body === void 0 || t.body === null || typeof t.body != "object" || t.body instanceof ArrayBuffer || ArrayBuffer.isView(t.body) || // Includes TypedArray and DataView
-    t.body instanceof Blob || t.body instanceof File || t.body instanceof URLSearchParams || t.body instanceof FormData || t.body instanceof ReadableStream)
+  intercept(t) {
+    const e = t.request;
+    if (e.body === void 0 || e.body === null || typeof e.body != "object" || e.body instanceof ArrayBuffer || ArrayBuffer.isView(e.body) || // Includes TypedArray and DataView
+    e.body instanceof Blob || e.body instanceof File || e.body instanceof URLSearchParams || e.body instanceof FormData || e.body instanceof ReadableStream)
       return;
-    const s = { ...t };
-    s.body = JSON.stringify(t.body), s.headers || (s.headers = {});
+    const s = { ...e };
+    s.body = JSON.stringify(e.body), s.headers || (s.headers = {});
     const o = s.headers;
-    o["Content-Type"] || (o["Content-Type"] = T.APPLICATION_JSON), e.request = s;
+    o["Content-Type"] || (o["Content-Type"] = h.APPLICATION_JSON), t.request = s;
   }
 }
-const C = "FetchInterceptor", L = Number.MAX_SAFE_INTEGER - 1e3;
-class D {
+const L = "FetchInterceptor", C = Number.MAX_SAFE_INTEGER - 1e3;
+class v {
   constructor() {
-    this.name = C, this.order = L;
+    this.name = L, this.order = C;
   }
   /**
    * Intercept and process HTTP requests.
@@ -242,14 +244,14 @@ class D {
    * await fetchInterceptor.intercept(exchange);
    * console.log(exchange.response); // HTTP response object
    */
-  async intercept(e) {
-    e.response = await _(e.request);
+  async intercept(t) {
+    t.response = await w(t.request);
   }
 }
-function d(r, e) {
-  return e ? r.filter(e).sort((t, s) => t.order - s.order) : [...r].sort((t, s) => t.order - s.order);
+function E(r, t) {
+  return t ? r.filter(t).sort((e, s) => e.order - s.order) : [...r].sort((e, s) => e.order - s.order);
 }
-class l {
+class p {
   /**
    * Initializes a new InterceptorRegistry instance.
    *
@@ -259,8 +261,8 @@ class l {
    * The provided interceptors will be sorted by their order property immediately
    * upon construction.
    */
-  constructor(e = []) {
-    this.sortedInterceptors = [], this.sortedInterceptors = d(e);
+  constructor(t = []) {
+    this.sortedInterceptors = [], this.sortedInterceptors = E(t);
   }
   /**
    * Gets the name of this interceptor registry.
@@ -297,10 +299,10 @@ class l {
    *
    * After adding, interceptors are automatically sorted by their order property.
    */
-  use(e) {
-    return this.sortedInterceptors.some((t) => t.name === e.name) ? !1 : (this.sortedInterceptors = d([
+  use(t) {
+    return this.sortedInterceptors.some((e) => e.name === t.name) ? !1 : (this.sortedInterceptors = E([
       ...this.sortedInterceptors,
-      e
+      t
     ]), !0);
   }
   /**
@@ -310,12 +312,12 @@ class l {
    * @returns True if an interceptor was removed, false if no interceptor with the
    *          given name was found
    */
-  eject(e) {
-    const t = this.sortedInterceptors;
-    return this.sortedInterceptors = d(
-      t,
-      (s) => s.name !== e
-    ), t.length !== this.sortedInterceptors.length;
+  eject(t) {
+    const e = this.sortedInterceptors;
+    return this.sortedInterceptors = E(
+      e,
+      (s) => s.name !== t
+    ), e.length !== this.sortedInterceptors.length;
   }
   /**
    * Removes all interceptors from this registry.
@@ -337,27 +339,27 @@ class l {
    * If any interceptor throws an error, the execution chain is broken and the error
    * is propagated to the caller.
    */
-  async intercept(e) {
-    for (const t of this.sortedInterceptors)
-      await t.intercept(e);
+  async intercept(t) {
+    for (const e of this.sortedInterceptors)
+      await e.intercept(t);
   }
 }
-class R extends a {
-  constructor(e) {
+class f extends a {
+  constructor(t) {
     super(
-      `Request failed with status code ${e.response?.status} for ${e.request.url}`
-    ), this.exchange = e, this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, R.prototype);
+      `Request failed with status code ${t.response?.status} for ${t.request.url}`
+    ), this.exchange = t, this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, f.prototype);
   }
 }
-const v = (r) => r >= 200 && r < 300, B = "ValidateStatusInterceptor", G = Number.MAX_SAFE_INTEGER - 1e3;
-class M {
+const B = (r) => r >= 200 && r < 300, G = "ValidateStatusInterceptor", M = Number.MAX_SAFE_INTEGER - 1e3;
+class $ {
   /**
    * Creates a new ValidateStatusInterceptor instance.
    *
    * @param validateStatus - Function that determines if a status code is valid
    */
-  constructor(e = v) {
-    this.validateStatus = e;
+  constructor(t = B) {
+    this.validateStatus = t;
   }
   /**
    * Gets the name of this interceptor.
@@ -365,7 +367,7 @@ class M {
    * @returns The name of this interceptor
    */
   get name() {
-    return B;
+    return G;
   }
   /**
    * Gets the order of this interceptor.
@@ -373,7 +375,7 @@ class M {
    * @returns VALIDATE_STATUS_INTERCEPTOR_ORDER, indicating this interceptor should execute early
    */
   get order() {
-    return G;
+    return M;
   }
   /**
    * Validates the response status code.
@@ -388,35 +390,35 @@ class M {
    * preventing other response handlers from attempting to process them. Valid responses
    * proceed through the rest of the response interceptor chain normally.
    */
-  intercept(e) {
-    if (!e.response)
+  intercept(t) {
+    if (!t.response)
       return;
-    const t = e.response.status;
-    if (!this.validateStatus(t))
-      throw new R(e);
+    const e = t.response.status;
+    if (!this.validateStatus(e))
+      throw new f(t);
   }
 }
-class h extends a {
+class l extends a {
   /**
    * Creates a new ExchangeError instance.
    *
    * @param exchange - The FetchExchange object containing request/response/error information.
    * @param errorMsg - An optional error message.
    */
-  constructor(e, t) {
-    const s = t || e.error?.message || e.response?.statusText || `Request to ${e.request.url} failed during exchange`;
-    super(s, e.error), this.exchange = e, this.name = "ExchangeError", Object.setPrototypeOf(this, h.prototype);
+  constructor(t, e) {
+    const s = e || t.error?.message || t.response?.statusText || `Request to ${t.request.url} failed during exchange`;
+    super(s, t.error), this.exchange = t, this.name = "ExchangeError", Object.setPrototypeOf(this, l.prototype);
   }
 }
-class $ {
+class j {
   constructor() {
-    this.request = new l([
-      new N(),
-      new U(),
-      new D()
-    ]), this.response = new l([
-      new M()
-    ]), this.error = new l();
+    this.request = new p([
+      new F(),
+      new D(),
+      new v()
+    ]), this.response = new p([
+      new $()
+    ]), this.error = new p();
   }
   /**
    * Processes a FetchExchange through the interceptor pipeline.
@@ -504,19 +506,19 @@ class $ {
    * const result = await fetcher.exchange(exchange);
    * ```
    */
-  async exchange(e) {
+  async exchange(t) {
     try {
-      return await this.request.intercept(e), await this.response.intercept(e), e;
-    } catch (t) {
-      if (e.error = t, await this.error.intercept(e), !e.hasError())
-        return e;
-      throw new h(e);
+      return await this.request.intercept(t), await this.response.intercept(t), t;
+    } catch (e) {
+      if (t.error = e, await this.error.intercept(t), !t.hasError())
+        return t;
+      throw new l(t);
     }
   }
 }
-class j {
-  constructor(e, t, s, o) {
-    this.attributes = {}, this.fetcher = e, this.request = t, this.response = s, this.error = o;
+class H {
+  constructor(t, e, s, o) {
+    this.attributes = {}, this.fetcher = t, this.request = e, this.response = s, this.error = o;
   }
   /**
    * Checks if the exchange has an error.
@@ -546,18 +548,18 @@ class j {
    */
   get requiredResponse() {
     if (!this.response)
-      throw new h(
+      throw new l(
         this,
         `Request to ${this.request.url} failed with no response`
       );
     return this.response;
   }
 }
-const p = {
-  "Content-Type": T.APPLICATION_JSON
-}, O = {
+const m = {
+  "Content-Type": h.APPLICATION_JSON
+}, A = {
   baseURL: "",
-  headers: p
+  headers: m
 };
 class V {
   /**
@@ -568,8 +570,8 @@ class V {
    *
    * @param options - Configuration options for the Fetcher instance
    */
-  constructor(e = O) {
-    this.headers = p, this.urlBuilder = new b(e.baseURL), this.headers = e.headers ?? p, this.timeout = e.timeout, this.interceptors = e.interceptors ?? new $();
+  constructor(t = A) {
+    this.headers = m, this.urlBuilder = new S(t.baseURL), this.headers = t.headers ?? m, this.timeout = t.timeout, this.interceptors = t.interceptors ?? new j();
   }
   /**
    * Executes an HTTP request with the specified URL and options.
@@ -582,9 +584,9 @@ class V {
    * @returns Promise that resolves to the HTTP response
    * @throws FetchError if the request fails and no response is generated
    */
-  async fetch(e, t = {}) {
-    const s = t;
-    return s.url = e, (await this.request(s)).requiredResponse;
+  async fetch(t, e = {}) {
+    const s = e;
+    return s.url = t, (await this.request(s)).requiredResponse;
   }
   /**
    * Processes an HTTP request through the Fetcher's internal workflow.
@@ -597,15 +599,15 @@ class V {
    * @returns Promise that resolves to a FetchExchange containing request/response data
    * @throws Error if an unhandled error occurs during request processing
    */
-  async request(e) {
-    const t = {
+  async request(t) {
+    const e = {
       ...this.headers,
-      ...e.headers
+      ...t.headers
     }, s = {
-      ...e,
-      headers: t,
-      timeout: S(e.timeout, this.timeout)
-    }, o = new j(this, s);
+      ...t,
+      headers: e,
+      timeout: _(t.timeout, this.timeout)
+    }, o = new H(this, s);
     return this.interceptors.exchange(o);
   }
   /**
@@ -619,10 +621,10 @@ class V {
    * @param request - Additional request options
    * @returns Promise that resolves to the HTTP response
    */
-  async methodFetch(e, t, s = {}) {
-    return this.fetch(t, {
+  async methodFetch(t, e, s = {}) {
+    return this.fetch(e, {
       ...s,
-      method: e
+      method: t
     });
   }
   /**
@@ -635,8 +637,8 @@ class V {
    * @param request - Request options excluding method and body
    * @returns Promise that resolves to the HTTP response
    */
-  async get(e, t = {}) {
-    return this.methodFetch(c.GET, e, t);
+  async get(t, e = {}) {
+    return this.methodFetch(c.GET, t, e);
   }
   /**
    * Makes a POST HTTP request.
@@ -647,8 +649,8 @@ class V {
    * @param request - Request options including body and other parameters
    * @returns Promise that resolves to the HTTP response
    */
-  async post(e, t = {}) {
-    return this.methodFetch(c.POST, e, t);
+  async post(t, e = {}) {
+    return this.methodFetch(c.POST, t, e);
   }
   /**
    * Makes a PUT HTTP request.
@@ -659,8 +661,8 @@ class V {
    * @param request - Request options including body and other parameters
    * @returns Promise that resolves to the HTTP response
    */
-  async put(e, t = {}) {
-    return this.methodFetch(c.PUT, e, t);
+  async put(t, e = {}) {
+    return this.methodFetch(c.PUT, t, e);
   }
   /**
    * Makes a DELETE HTTP request.
@@ -671,8 +673,8 @@ class V {
    * @param request - Request options excluding method and body
    * @returns Promise that resolves to the HTTP response
    */
-  async delete(e, t = {}) {
-    return this.methodFetch(c.DELETE, e, t);
+  async delete(t, e = {}) {
+    return this.methodFetch(c.DELETE, t, e);
   }
   /**
    * Makes a PATCH HTTP request.
@@ -683,8 +685,8 @@ class V {
    * @param request - Request options including body and other parameters
    * @returns Promise that resolves to the HTTP response
    */
-  async patch(e, t = {}) {
-    return this.methodFetch(c.PATCH, e, t);
+  async patch(t, e = {}) {
+    return this.methodFetch(c.PATCH, t, e);
   }
   /**
    * Makes a HEAD HTTP request.
@@ -696,8 +698,8 @@ class V {
    * @param request - Request options excluding method and body
    * @returns Promise that resolves to the HTTP response
    */
-  async head(e, t = {}) {
-    return this.methodFetch(c.HEAD, e, t);
+  async head(t, e = {}) {
+    return this.methodFetch(c.HEAD, t, e);
   }
   /**
    * Makes an OPTIONS HTTP request.
@@ -709,12 +711,12 @@ class V {
    * @param request - Request options excluding method and body
    * @returns Promise that resolves to the HTTP response
    */
-  async options(e, t = {}) {
-    return this.methodFetch(c.OPTIONS, e, t);
+  async options(t, e = {}) {
+    return this.methodFetch(c.OPTIONS, t, e);
   }
 }
-const E = "default";
-class H {
+const T = "default";
+class k {
   constructor() {
     this.registrar = /* @__PURE__ */ new Map();
   }
@@ -727,8 +729,8 @@ class H {
    * const fetcher = new Fetcher({ baseURL: 'https://api.example.com' });
    * fetcherRegistrar.register('api', fetcher);
    */
-  register(e, t) {
-    this.registrar.set(e, t);
+  register(t, e) {
+    this.registrar.set(t, e);
   }
   /**
    * Unregister a Fetcher instance by name
@@ -741,8 +743,8 @@ class H {
    *   console.log('Fetcher unregistered successfully');
    * }
    */
-  unregister(e) {
-    return this.registrar.delete(e);
+  unregister(t) {
+    return this.registrar.delete(t);
   }
   /**
    * Get a Fetcher instance by name
@@ -755,8 +757,8 @@ class H {
    *   // Use the fetcher
    * }
    */
-  get(e) {
-    return this.registrar.get(e);
+  get(t) {
+    return this.registrar.get(t);
   }
   /**
    * Get a Fetcher instance by name, throwing an error if not found
@@ -772,11 +774,11 @@ class H {
    *   console.error('Fetcher not found:', error.message);
    * }
    */
-  requiredGet(e) {
-    const t = this.get(e);
-    if (!t)
-      throw new Error(`Fetcher ${e} not found`);
-    return t;
+  requiredGet(t) {
+    const e = this.get(t);
+    if (!e)
+      throw new Error(`Fetcher ${t} not found`);
+    return e;
   }
   /**
    * Get the default Fetcher instance
@@ -787,7 +789,7 @@ class H {
    * const defaultFetcher = fetcherRegistrar.default;
    */
   get default() {
-    return this.requiredGet(E);
+    return this.requiredGet(T);
   }
   /**
    * Set the default Fetcher instance
@@ -797,8 +799,8 @@ class H {
    * const fetcher = new Fetcher({ baseURL: 'https://api.example.com' });
    * fetcherRegistrar.default = fetcher;
    */
-  set default(e) {
-    this.register(E, e);
+  set default(t) {
+    this.register(T, t);
   }
   /**
    * Get a copy of all registered fetchers
@@ -814,35 +816,35 @@ class H {
     return new Map(this.registrar);
   }
 }
-const k = new H();
-function y(r, e) {
-  if (!(r === void 0 && e === void 0))
-    return e === void 0 ? r : r === void 0 ? e : { ...r, ...e };
+const J = new k();
+function I(r, t) {
+  if (!(r === void 0 && t === void 0))
+    return t === void 0 ? r : r === void 0 ? t : { ...r, ...t };
 }
-function Q(r, e) {
+function Q(r, t) {
   if (Object.keys(r).length === 0)
-    return e;
-  if (Object.keys(e).length === 0)
+    return t;
+  if (Object.keys(t).length === 0)
     return r;
-  const t = {
-    path: y(r.urlParams?.path, e.urlParams?.path),
-    query: y(r.urlParams?.query, e.urlParams?.query)
+  const e = {
+    path: I(r.urlParams?.path, t.urlParams?.path),
+    query: I(r.urlParams?.query, t.urlParams?.query)
   }, s = {
     ...r.headers,
-    ...e.headers
-  }, o = e.method ?? r.method, i = e.body ?? r.body, n = e.timeout ?? r.timeout, u = e.signal ?? r.signal;
+    ...t.headers
+  }, o = t.method ?? r.method, i = t.body ?? r.body, n = t.timeout ?? r.timeout, u = t.signal ?? r.signal;
   return {
     ...r,
-    ...e,
+    ...t,
     method: o,
-    urlParams: t,
+    urlParams: e,
     headers: s,
     body: i,
     timeout: n,
     signal: u
   };
 }
-class J extends V {
+class X extends V {
   /**
    * Create a NamedFetcher instance and automatically register it with the global fetcherRegistrar
    *
@@ -860,48 +862,48 @@ class J extends V {
    *   headers: { 'Authorization': 'Bearer token' }
    * });
    */
-  constructor(e, t = O) {
-    super(t), this.name = e, k.register(e, this);
+  constructor(t, e = A) {
+    super(e), this.name = t, J.register(t, this);
   }
 }
-const Y = new J(E);
+const x = new X(T);
 export {
-  z as ContentTypeHeader,
-  T as ContentTypeValues,
-  E as DEFAULT_FETCHER_NAME,
-  O as DEFAULT_OPTIONS,
-  h as ExchangeError,
-  C as FETCH_INTERCEPTOR_NAME,
-  L as FETCH_INTERCEPTOR_ORDER,
-  j as FetchExchange,
-  D as FetchInterceptor,
-  m as FetchTimeoutError,
+  z as CONTENT_TYPE_HEADER,
+  h as ContentTypeValues,
+  T as DEFAULT_FETCHER_NAME,
+  A as DEFAULT_OPTIONS,
+  l as ExchangeError,
+  L as FETCH_INTERCEPTOR_NAME,
+  C as FETCH_INTERCEPTOR_ORDER,
+  H as FetchExchange,
+  v as FetchInterceptor,
+  R as FetchTimeoutError,
   V as Fetcher,
   a as FetcherError,
-  H as FetcherRegistrar,
+  k as FetcherRegistrar,
   c as HttpMethod,
-  R as HttpStatusValidationError,
-  $ as InterceptorManager,
-  l as InterceptorRegistry,
-  J as NamedFetcher,
-  F as REQUEST_BODY_INTERCEPTOR_NAME,
-  q as REQUEST_BODY_INTERCEPTOR_ORDER,
-  U as RequestBodyInterceptor,
-  w as URL_RESOLVE_INTERCEPTOR_NAME,
-  I as URL_RESOLVE_INTERCEPTOR_ORDER,
-  b as UrlBuilder,
-  N as UrlResolveInterceptor,
-  B as VALIDATE_STATUS_INTERCEPTOR_NAME,
-  G as VALIDATE_STATUS_INTERCEPTOR_ORDER,
-  M as ValidateStatusInterceptor,
-  P as combineURLs,
-  Y as fetcher,
-  k as fetcherRegistrar,
+  f as HttpStatusValidationError,
+  j as InterceptorManager,
+  p as InterceptorRegistry,
+  X as NamedFetcher,
+  q as REQUEST_BODY_INTERCEPTOR_NAME,
+  U as REQUEST_BODY_INTERCEPTOR_ORDER,
+  D as RequestBodyInterceptor,
+  N as URL_RESOLVE_INTERCEPTOR_NAME,
+  O as URL_RESOLVE_INTERCEPTOR_ORDER,
+  S as UrlBuilder,
+  F as UrlResolveInterceptor,
+  G as VALIDATE_STATUS_INTERCEPTOR_NAME,
+  M as VALIDATE_STATUS_INTERCEPTOR_ORDER,
+  $ as ValidateStatusInterceptor,
+  b as combineURLs,
+  x as fetcher,
+  J as fetcherRegistrar,
   g as isAbsoluteURL,
-  y as mergeRecords,
+  I as mergeRecords,
   Q as mergeRequest,
-  S as resolveTimeout,
-  _ as timeoutFetch,
-  d as toSorted
+  _ as resolveTimeout,
+  w as timeoutFetch,
+  E as toSorted
 };
 //# sourceMappingURL=index.es.js.map