@ahoo-wang/fetcher 0.9.1 → 0.9.5

package/dist/index.umd.js

@@ -1 +1 @@
-(function(n,a){typeof exports=="object"&&typeof module<"u"?a(exports):typeof define=="function"&&define.amd?define(["exports"],a):(n=typeof globalThis<"u"?globalThis:n||self,a(n.Fetcher={}))})(this,(function(n){"use strict";function a(r){return/^([a-z][a-z\d+\-.]*:)?\/\//i.test(r)}function g(r,e){return a(e)?e:e?r.replace(/\/?\/$/,"")+"/"+e.replace(/^\/+/,""):r}class I{constructor(e){this.baseURL=e}build(e,t){const s=t?.path,o=t?.query,u=g(this.baseURL,e);let i=this.interpolateUrl(u,s);if(o){const h=new URLSearchParams(o).toString();h&&(i+="?"+h)}return i}resolveRequestUrl(e){return this.build(e.url,e.urlParams)}interpolateUrl(e,t){return t?e.replace(/{([^}]+)}/g,(s,o)=>{const u=t[o];if(u===void 0)throw new Error(`Missing required path parameter: ${o}`);return String(u)}):e}}function b(r,e){return typeof r<"u"?r:e}class d extends Error{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,d.prototype)}}async function F(r){const e=r.url,t=r.timeout,s=r;if(!t)return fetch(e,s);const o=new AbortController,u={...s,signal:o.signal};let i=null;const h=new Promise((B,D)=>{i=setTimeout(()=>{i&&clearTimeout(i);const _=new d(r);o.abort(_),D(_)},t)});try{return await Promise.race([fetch(e,u),h])}finally{i&&clearTimeout(i)}}function l(r,e){return e?r.filter(e).sort((t,s)=>t.order-s.order):[...r].sort((t,s)=>t.order-s.order)}var c=(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 L="Content-Type";var m=(r=>(r.APPLICATION_JSON="application/json",r.TEXT_EVENT_STREAM="text/event-stream",r))(m||{});class R{constructor(){this.name="RequestBodyInterceptor",this.order=Number.MIN_SAFE_INTEGER+200}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)||t.body instanceof Blob||t.body instanceof File||t.body instanceof URLSearchParams||t.body instanceof FormData||t.body instanceof ReadableStream)return;const s={...t};s.body=JSON.stringify(t.body),s.headers||(s.headers={});const o=s.headers;o["Content-Type"]||(o["Content-Type"]=m.APPLICATION_JSON),e.request=s}}class w{constructor(){this.name="FetchInterceptor",this.order=Number.MAX_SAFE_INTEGER-100}async intercept(e){e.response=await F(e.request)}}class P{constructor(){this.name="UrlResolveInterceptor",this.order=Number.MIN_SAFE_INTEGER+100}intercept(e){const t=e.request;t.url=e.fetcher.urlBuilder.resolveRequestUrl(t)}}class f{constructor(e=[]){this.sortedInterceptors=[],this.sortedInterceptors=l(e)}get name(){return this.constructor.name}get order(){return Number.MIN_SAFE_INTEGER}use(e){return this.sortedInterceptors.some(t=>t.name===e.name)?!1:(this.sortedInterceptors=l([...this.sortedInterceptors,e]),!0)}eject(e){const t=this.sortedInterceptors;return this.sortedInterceptors=l(t,s=>s.name!==e),t.length!==this.sortedInterceptors.length}clear(){this.sortedInterceptors=[]}async intercept(e){for(const t of this.sortedInterceptors)await t.intercept(e)}}class A{constructor(){this.request=new f([new P,new R,new w]),this.response=new f,this.error=new f}}class N{constructor(e,t,s,o){this.attributes={},this.fetcher=e,this.request=t,this.response=s,this.error=o}hasError(){return!!this.error}hasResponse(){return!!this.response}}function y(r,e){if(!(r===void 0&&e===void 0))return e===void 0?r:r===void 0?e:{...r,...e}}const p={"Content-Type":m.APPLICATION_JSON},E={baseURL:"",headers:p};class S{constructor(e=E){this.headers=p,this.urlBuilder=new I(e.baseURL),this.headers=e.headers??p,this.timeout=e.timeout,this.interceptors=e.interceptors??new A}async fetch(e,t={}){const s=t;s.url=e;const o=await this.request(s);if(!o.response)throw new Error(`Request to ${s.url} failed with no response`);return o.response}async request(e){const t=y(e.headers,this.headers),s={...e,headers:t,timeout:b(e.timeout,this.timeout)},o=new N(this,s);return this.exchange(o)}async exchange(e){try{return await this.interceptors.request.intercept(e),await this.interceptors.response.intercept(e),e}catch(t){if(e.error=t,await this.interceptors.error.intercept(e),e.hasResponse())return e;throw e.error}}async methodFetch(e,t,s={}){return this.fetch(t,{...s,method:e})}async get(e,t={}){return this.methodFetch(c.GET,e,t)}async post(e,t={}){return this.methodFetch(c.POST,e,t)}async put(e,t={}){return this.methodFetch(c.PUT,e,t)}async delete(e,t={}){return this.methodFetch(c.DELETE,e,t)}async patch(e,t={}){return this.methodFetch(c.PATCH,e,t)}async head(e,t={}){return this.methodFetch(c.HEAD,e,t)}async options(e,t={}){return this.methodFetch(c.OPTIONS,e,t)}}const T="default";class q{constructor(){this.registrar=new Map}register(e,t){this.registrar.set(e,t)}unregister(e){return this.registrar.delete(e)}get(e){return this.registrar.get(e)}requiredGet(e){const t=this.get(e);if(!t)throw new Error(`Fetcher ${e} not found`);return t}get default(){return this.requiredGet(T)}set default(e){this.register(T,e)}get fetchers(){return new Map(this.registrar)}}const O=new q;function v(r,e){if(Object.keys(r).length===0)return e;if(Object.keys(e).length===0)return r;const t={path:y(r.urlParams?.path,e.urlParams?.path),query:y(r.urlParams?.query,e.urlParams?.query)},s={...r.headers,...e.headers},o=e.method??r.method,u=e.body??r.body,i=e.timeout??r.timeout,h=e.signal??r.signal;return{...r,...e,method:o,urlParams:t,headers:s,body:u,timeout:i,signal:h}}class U extends S{constructor(e,t=E){super(t),this.name=e,O.register(e,this)}}const C=new U(T);n.ContentTypeHeader=L,n.ContentTypeValues=m,n.DEFAULT_FETCHER_NAME=T,n.DEFAULT_OPTIONS=E,n.FetchExchange=N,n.FetchInterceptor=w,n.FetchTimeoutError=d,n.Fetcher=S,n.FetcherInterceptors=A,n.FetcherRegistrar=q,n.HttpMethod=c,n.InterceptorManager=f,n.NamedFetcher=U,n.RequestBodyInterceptor=R,n.UrlBuilder=I,n.UrlResolveInterceptor=P,n.combineURLs=g,n.fetcher=C,n.fetcherRegistrar=O,n.isAbsoluteURL=a,n.mergeRecords=y,n.mergeRequest=v,n.resolveTimeout=b,n.timeoutFetch=F,n.toSorted=l,Object.defineProperty(n,Symbol.toStringTag,{value:"Module"})}));
+(function(s,h){typeof exports=="object"&&typeof module<"u"?h(exports):typeof define=="function"&&define.amd?define(["exports"],h):(s=typeof globalThis<"u"?globalThis:s||self,h(s.Fetcher={}))})(this,(function(s){"use strict";function h(r){return/^([a-z][a-z\d+\-.]*:)?\/\//i.test(r)}function P(r,e){return h(e)?e:e?r.replace(/\/?\/$/,"")+"/"+e.replace(/^\/+/,""):r}class S{constructor(e){this.baseURL=e}build(e,t){const n=t?.path,o=t?.query,u=P(this.baseURL,e);let i=this.interpolateUrl(u,n);if(o){const E=new URLSearchParams(o).toString();E&&(i+="?"+E)}return i}resolveRequestUrl(e){return this.build(e.url,e.urlParams)}interpolateUrl(e,t){return t?e.replace(/{([^}]+)}/g,(n,o)=>{const u=t[o];if(u===void 0)throw new Error(`Missing required path parameter: ${o}`);return String(u)}):e}}class a extends Error{constructor(e,t){const n=e||t?.message||"An error occurred in the fetcher";super(n),this.cause=t,this.name="FetcherError",t?.stack&&(this.stack=t.stack),Object.setPrototypeOf(this,a.prototype)}}class d extends a{constructor(e,t){const n=t||e.error?.message||`Request to ${e.request.url} failed with no response`;super(n,e.error),this.exchange=e,this.name="FetchError",Object.setPrototypeOf(this,d.prototype)}}class l extends a{constructor(e){const t=e.method||"GET",n=`Request timeout of ${e.timeout}ms exceeded for ${t} ${e.url}`;super(n),this.name="FetchTimeoutError",this.request=e,Object.setPrototypeOf(this,l.prototype)}}function N(r,e){return typeof r<"u"?r:e}async function g(r){const e=r.url,t=r.timeout,n=r;if(!t)return fetch(e,n);const o=new AbortController,u={...n,signal:o.signal};let i=null;const E=new Promise((W,K)=>{i=setTimeout(()=>{i&&clearTimeout(i);const J=new l(r);o.abort(J),K(J)},t)});try{return await Promise.race([fetch(e,u),E])}finally{i&&clearTimeout(i)}}class F{constructor(e,t,n,o){this.attributes={},this.fetcher=e,this.request=t,this.response=n,this.error=o}hasError(){return!!this.error}hasResponse(){return!!this.response}}var c=(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 Q="Content-Type";var T=(r=>(r.APPLICATION_JSON="application/json",r.TEXT_EVENT_STREAM="text/event-stream",r))(T||{});function R(r,e){if(!(r===void 0&&e===void 0))return e===void 0?r:r===void 0?e:{...r,...e}}const b="UrlResolveInterceptor",O=Number.MIN_SAFE_INTEGER+1e3;class w{constructor(){this.name=b,this.order=O}intercept(e){const t=e.request;t.url=e.fetcher.urlBuilder.resolveRequestUrl(t)}}const U="RequestBodyInterceptor",C=O+1e3;class L{constructor(){this.name=U,this.order=C}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)||t.body instanceof Blob||t.body instanceof File||t.body instanceof URLSearchParams||t.body instanceof FormData||t.body instanceof ReadableStream)return;const n={...t};n.body=JSON.stringify(t.body),n.headers||(n.headers={});const o=n.headers;o["Content-Type"]||(o["Content-Type"]=T.APPLICATION_JSON),e.request=n}}const q="FetchInterceptor",D=Number.MAX_SAFE_INTEGER-1e3;class M{constructor(){this.name=q,this.order=D}async intercept(e){e.response=await g(e.request)}}function m(r,e){return e?r.filter(e).sort((t,n)=>t.order-n.order):[...r].sort((t,n)=>t.order-n.order)}class f{constructor(e=[]){this.sortedInterceptors=[],this.sortedInterceptors=m(e)}get name(){return this.constructor.name}get order(){return Number.MIN_SAFE_INTEGER}get interceptors(){return[...this.sortedInterceptors]}use(e){return this.sortedInterceptors.some(t=>t.name===e.name)?!1:(this.sortedInterceptors=m([...this.sortedInterceptors,e]),!0)}eject(e){const t=this.sortedInterceptors;return this.sortedInterceptors=m(t,n=>n.name!==e),t.length!==this.sortedInterceptors.length}clear(){this.sortedInterceptors=[]}async intercept(e){for(const t of this.sortedInterceptors)await t.intercept(e)}}class y extends a{constructor(e){super(`Request failed with status code ${e.response?.status} for ${e.request.url}`),this.exchange=e,this.name="HttpStatusValidationError",Object.setPrototypeOf(this,y.prototype)}}const Y=r=>r>=200&&r<300,v="ValidateStatusInterceptor",V=Number.MAX_SAFE_INTEGER-1e3;class B{constructor(e=Y){this.validateStatus=e}get name(){return v}get order(){return V}intercept(e){if(!e.response)return;const t=e.response.status;if(!this.validateStatus(t))throw new y(e)}}class I extends a{constructor(e){const t=e.error?.message||e.response?.statusText||`Request to ${e.request.url} failed during exchange`;super(t,e.error),this.exchange=e,this.name="ExchangeError",Object.setPrototypeOf(this,I.prototype)}}class H{constructor(){this.request=new f([new w,new L,new M]),this.response=new f([new B]),this.error=new f}async exchange(e){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 I(e)}}}const _={"Content-Type":T.APPLICATION_JSON},A={baseURL:"",headers:_};class j{constructor(e=A){this.headers=_,this.urlBuilder=new S(e.baseURL),this.headers=e.headers??_,this.timeout=e.timeout,this.interceptors=e.interceptors??new H}async fetch(e,t={}){const n=t;n.url=e;const o=await this.request(n);if(!o.response)throw new d(o,`Request to ${n.url} failed with no response`);return o.response}async request(e){const t=R(e.headers,this.headers),n={...e,headers:t,timeout:N(e.timeout,this.timeout)},o=new F(this,n);return this.interceptors.exchange(o)}async methodFetch(e,t,n={}){return this.fetch(t,{...n,method:e})}async get(e,t={}){return this.methodFetch(c.GET,e,t)}async post(e,t={}){return this.methodFetch(c.POST,e,t)}async put(e,t={}){return this.methodFetch(c.PUT,e,t)}async delete(e,t={}){return this.methodFetch(c.DELETE,e,t)}async patch(e,t={}){return this.methodFetch(c.PATCH,e,t)}async head(e,t={}){return this.methodFetch(c.HEAD,e,t)}async options(e,t={}){return this.methodFetch(c.OPTIONS,e,t)}}const p="default";class ${constructor(){this.registrar=new Map}register(e,t){this.registrar.set(e,t)}unregister(e){return this.registrar.delete(e)}get(e){return this.registrar.get(e)}requiredGet(e){const t=this.get(e);if(!t)throw new Error(`Fetcher ${e} not found`);return t}get default(){return this.requiredGet(p)}set default(e){this.register(p,e)}get fetchers(){return new Map(this.registrar)}}const G=new $;function X(r,e){if(Object.keys(r).length===0)return e;if(Object.keys(e).length===0)return r;const t={path:R(r.urlParams?.path,e.urlParams?.path),query:R(r.urlParams?.query,e.urlParams?.query)},n={...r.headers,...e.headers},o=e.method??r.method,u=e.body??r.body,i=e.timeout??r.timeout,E=e.signal??r.signal;return{...r,...e,method:o,urlParams:t,headers:n,body:u,timeout:i,signal:E}}class k extends j{constructor(e,t=A){super(t),this.name=e,G.register(e,this)}}const z=new k(p);s.ContentTypeHeader=Q,s.ContentTypeValues=T,s.DEFAULT_FETCHER_NAME=p,s.DEFAULT_OPTIONS=A,s.ExchangeError=I,s.FETCH_INTERCEPTOR_NAME=q,s.FETCH_INTERCEPTOR_ORDER=D,s.FetchError=d,s.FetchExchange=F,s.FetchInterceptor=M,s.FetchTimeoutError=l,s.Fetcher=j,s.FetcherError=a,s.FetcherRegistrar=$,s.HttpMethod=c,s.HttpStatusValidationError=y,s.InterceptorManager=H,s.InterceptorRegistry=f,s.NamedFetcher=k,s.REQUEST_BODY_INTERCEPTOR_NAME=U,s.REQUEST_BODY_INTERCEPTOR_ORDER=C,s.RequestBodyInterceptor=L,s.URL_RESOLVE_INTERCEPTOR_NAME=b,s.URL_RESOLVE_INTERCEPTOR_ORDER=O,s.UrlBuilder=S,s.UrlResolveInterceptor=w,s.VALIDATE_STATUS_INTERCEPTOR_NAME=v,s.VALIDATE_STATUS_INTERCEPTOR_ORDER=V,s.ValidateStatusInterceptor=B,s.combineURLs=P,s.fetcher=z,s.fetcherRegistrar=G,s.isAbsoluteURL=h,s.mergeRecords=R,s.mergeRequest=X,s.resolveTimeout=N,s.timeoutFetch=g,s.toSorted=m,Object.defineProperty(s,Symbol.toStringTag,{value:"Module"})}));

package/dist/interceptor.d.ts

@@ -26,14 +26,21 @@ export interface Interceptor extends NamedCapable, OrderedCapable {
     /**
      * Unique identifier for the interceptor.
      *
-     * Used by InterceptorManager to manage interceptors, including adding, removing,
+     * Used by InterceptorRegistry to manage interceptors, including adding, removing,
      * and preventing duplicates. Each interceptor must have a unique name.
      */
-    name: string;
+    readonly name: string;
+    /**
+     * Interceptor method that modifies the request or response.
+     *
+     * @param exchange - The current exchange object, which contains the request and response.
+     * @returns A promise that resolves to the modified exchange object.
+     */
+    readonly order: number;
     /**
      * Process the exchange object in the interceptor pipeline.
      *
-     * This method is called by InterceptorManager to process the exchange object.
+     * This method is called by InterceptorRegistry to process the exchange object.
      * Interceptors can modify request, response, or error properties directly.
      *
      * @param exchange - The exchange object containing request, response, and error information
@@ -45,47 +52,123 @@ export interface Interceptor extends NamedCapable, OrderedCapable {
     intercept(exchange: FetchExchange): void | Promise<void>;
 }
 /**
- * Manager for a collection of interceptors of the same type.
+ * Interface for request interceptors.
+ *
+ * Request interceptors are executed before the HTTP request is sent.
+ * They can modify the request configuration, add headers, or perform
+ * other preprocessing tasks.
+ *
+ * @example
+ * // Example of a request interceptor that adds an authorization header
+ * const authInterceptor: RequestInterceptor = {
+ *   name: 'AuthorizationInterceptor',
+ *   order: 100,
+ *   async intercept(exchange: FetchExchange): Promise<void> {
+ *     const token = getAuthToken();
+ *     if (token) {
+ *       exchange.request.headers = {
+ *         ...exchange.request.headers,
+ *         'Authorization': `Bearer ${token}`
+ *       };
+ *     }
+ *   }
+ * };
+ */
+export interface RequestInterceptor extends Interceptor {
+}
+/**
+ * Interface for response interceptors.
+ *
+ * Response interceptors are executed after the HTTP response is received
+ * but before it's processed by the application. They can modify the response,
+ * transform data, or handle response-specific logic.
+ *
+ * @example
+ * // Example of a response interceptor that parses JSON data
+ * const jsonInterceptor: ResponseInterceptor = {
+ *   name: 'JsonResponseInterceptor',
+ *   order: 100,
+ *   async intercept(exchange: FetchExchange): Promise<void> {
+ *     if (exchange.response && exchange.response.headers.get('content-type')?.includes('application/json')) {
+ *       const data = await exchange.response.json();
+ *       // Attach parsed data to a custom property
+ *       (exchange.response as any).jsonData = data;
+ *     }
+ *   }
+ * };
+ */
+export interface ResponseInterceptor extends Interceptor {
+}
+/**
+ * Interface for error interceptors.
+ *
+ * Error interceptors are executed when an HTTP request fails.
+ * They can handle errors, transform them, or implement retry logic.
+ *
+ * @example
+ * // Example of an error interceptor that retries failed requests
+ * const retryInterceptor: ErrorInterceptor = {
+ *   name: 'RetryInterceptor',
+ *   order: 100,
+ *   async intercept(exchange: FetchExchange): Promise<void> {
+ *     if (exchange.error && isRetryableError(exchange.error)) {
+ *       // Implement retry logic
+ *       const retryCount = (exchange.request as any).retryCount || 0;
+ *       if (retryCount < 3) {
+ *         (exchange.request as any).retryCount = retryCount + 1;
+ *         // Retry the request
+ *         exchange.response = await fetch(exchange.request);
+ *         // Clear the error since we've recovered
+ *         exchange.error = undefined;
+ *       }
+ *     }
+ *   }
+ * };
+ */
+export interface ErrorInterceptor extends Interceptor {
+}
+/**
+ * Registry for a collection of interceptors of the same type.
  *
  * Handles adding, removing, and executing interceptors in the correct order.
- * Each InterceptorManager instance manages one type of interceptor (request, response, or error).
+ * Each InterceptorRegistry instance manages one type of interceptor (request, response, or error).
  *
  * @remarks
  * Interceptors are executed in ascending order of their `order` property.
  * Interceptors with the same order value are executed in the order they were added.
  *
  * @example
- * // Create an interceptor manager with initial interceptors
- * const requestManager = new InterceptorManager([interceptor1, interceptor2]);
+ * // Create an interceptor registry with initial interceptors
+ * const requestRegistry = new InterceptorRegistry([interceptor1, interceptor2]);
  *
  * // Add a new interceptor
- * requestManager.use(newInterceptor);
+ * requestRegistry.use(newInterceptor);
  *
  * // Remove an interceptor by name
- * requestManager.eject('InterceptorName');
+ * requestRegistry.eject('InterceptorName');
  *
  * // Process an exchange through all interceptors
- * const result = await requestManager.intercept(exchange);
+ * const result = await requestRegistry.intercept(exchange);
  */
-export declare class InterceptorManager implements Interceptor {
+export declare class InterceptorRegistry implements Interceptor {
     /**
-     * Gets the name of this interceptor manager.
+     * Gets the name of this interceptor registry.
      *
      * @returns The constructor name of this class
      */
     get name(): string;
     /**
-     * Gets the order of this interceptor manager.
+     * Gets the order of this interceptor registry.
      *
-     * @returns Number.MIN_SAFE_INTEGER, indicating this manager should execute early
+     * @returns Number.MIN_SAFE_INTEGER, indicating this registry should execute early
      */
     get order(): number;
     /**
-     * Array of interceptors managed by this manager, sorted by their order property.
+     * Array of interceptors managed by this registry, sorted by their order property.
      */
     private sortedInterceptors;
     /**
-     * Initializes a new InterceptorManager instance.
+     * Initializes a new InterceptorRegistry instance.
      *
      * @param interceptors - Initial array of interceptors to manage
      *
@@ -95,7 +178,11 @@ export declare class InterceptorManager implements Interceptor {
      */
     constructor(interceptors?: Interceptor[]);
     /**
-     * Adds an interceptor to this manager.
+     * Returns an array of all interceptors in the registry.
+     */
+    get interceptors(): Interceptor[];
+    /**
+     * Adds an interceptor to this registry.
      *
      * @param interceptor - The interceptor to add
      * @returns True if the interceptor was added, false if an interceptor with the
@@ -103,7 +190,7 @@ export declare class InterceptorManager implements Interceptor {
      *
      * @remarks
      * Interceptors are uniquely identified by their name property. Attempting to add
-     * an interceptor with a name that already exists in the manager will fail.
+     * an interceptor with a name that already exists in the registry will fail.
      *
      * After adding, interceptors are automatically sorted by their order property.
      */
@@ -117,7 +204,7 @@ export declare class InterceptorManager implements Interceptor {
      */
     eject(name: string): boolean;
     /**
-     * Removes all interceptors from this manager.
+     * Removes all interceptors from this registry.
      */
     clear(): void;
     /**
@@ -136,79 +223,4 @@ export declare class InterceptorManager implements Interceptor {
      */
     intercept(exchange: FetchExchange): Promise<void>;
 }
-/**
- * Collection of interceptor managers for the Fetcher client.
- *
- * Manages three types of interceptors:
- * 1. Request interceptors - Process requests before sending HTTP requests
- * 2. Response interceptors - Process responses after receiving HTTP responses
- * 3. Error interceptors - Handle errors when they occur during the request process
- *
- * Each type of interceptor is managed by an InterceptorManager instance, supporting
- * adding, removing, and executing interceptors.
- *
- * @example
- * // Create a custom interceptor
- * const customRequestInterceptor: Interceptor = {
- *   name: 'CustomRequestInterceptor',
- *   order: 100,
- *   async intercept(exchange: FetchExchange): Promise<FetchExchange> {
- *     // Modify request headers
- *     exchange.request.headers = {
- *       ...exchange.request.headers,
- *       'X-Custom-Header': 'custom-value'
- *     };
- *     return exchange;
- *   }
- * };
- *
- * // Add interceptor to Fetcher
- * const fetcher = new Fetcher();
- * fetcher.interceptors.request.use(customRequestInterceptor);
- *
- * @remarks
- * By default, the request interceptor manager has three built-in interceptors registered:
- * 1. UrlResolveInterceptor - Resolves the final URL with parameters
- * 2. RequestBodyInterceptor - Automatically converts object-type request bodies to JSON strings
- * 3. FetchInterceptor - Executes actual HTTP requests and handles timeouts
- */
-export declare class FetcherInterceptors {
-    /**
-     * Manager for request-phase interceptors.
-     *
-     * Executed before HTTP requests are sent. Contains three built-in interceptors by default:
-     * UrlResolveInterceptor, RequestBodyInterceptor, and FetchInterceptor.
-     *
-     * @remarks
-     * Request interceptors are executed in ascending order of their order values, with smaller
-     * values having higher priority. The default interceptors are:
-     * 1. UrlResolveInterceptor (order: Number.MIN_SAFE_INTEGER) - Resolves the final URL
-     * 2. RequestBodyInterceptor (order: 0) - Converts object bodies to JSON
-     * 3. FetchInterceptor (order: Number.MAX_SAFE_INTEGER) - Executes the actual HTTP request
-     */
-    request: InterceptorManager;
-    /**
-     * Manager for response-phase interceptors.
-     *
-     * Executed after HTTP responses are received. Empty by default, custom response processing
-     * logic can be added as needed.
-     *
-     * @remarks
-     * Response interceptors are executed in ascending order of their order values, with smaller
-     * values having higher priority.
-     */
-    response: InterceptorManager;
-    /**
-     * Manager for error-handling phase interceptors.
-     *
-     * Executed when errors occur during HTTP requests. Empty by default, custom error handling
-     * logic can be added as needed.
-     *
-     * @remarks
-     * Error interceptors are executed in ascending order of their order values, with smaller
-     * values having higher priority. Error interceptors can transform errors into normal responses,
-     * avoiding thrown exceptions.
-     */
-    error: InterceptorManager;
-}
 //# sourceMappingURL=interceptor.d.ts.map

package/dist/interceptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interceptor.d.ts","sourceRoot":"","sources":["../src/interceptor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,cAAc,EAAY,MAAM,kBAAkB,CAAC;AAG5D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,WAAY,SAAQ,YAAY,EAAE,cAAc;IAC/D;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,kBAAmB,YAAW,WAAW;IACpD;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;OAIG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;OAEG;IACH,OAAO,CAAC,kBAAkB,CAAqB;IAE/C;;;;;;;;OAQG;gBACS,YAAY,GAAE,WAAW,EAAO;IAI5C;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO;IAWtC;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS5B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;;;;;;OAaG;IACG,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAMxD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,mBAAmB;IAC9B;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,kBAAkB,CAIxB;IAEH;;;;;;;;;OASG;IACH,QAAQ,EAAE,kBAAkB,CAA4B;IAExD;;;;;;;;;;OAUG;IACH,KAAK,EAAE,kBAAkB,CAA4B;CACtD"}
+{"version":3,"file":"interceptor.d.ts","sourceRoot":"","sources":["../src/interceptor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,cAAc,EAAY,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,WAAY,SAAQ,YAAY,EAAE,cAAc;IAC/D;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,kBAAmB,SAAQ,WAAW;CACtD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,mBAAoB,SAAQ,WAAW;CACvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,WAAW,gBAAiB,SAAQ,WAAW;CACpD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACrD;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;OAIG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;OAEG;IACH,OAAO,CAAC,kBAAkB,CAAqB;IAE/C;;;;;;;;OAQG;gBACS,YAAY,GAAE,WAAW,EAAO;IAI5C;;OAEG;IACH,IAAI,YAAY,IAAI,WAAW,EAAE,CAEhC;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO;IAWtC;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS5B;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;;;;;;;;;;;;OAaG;IACG,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAMxD"}

package/dist/interceptorManager.d.ts

@@ -0,0 +1,200 @@
+import { FetchExchange } from './fetchExchange';
+import { FetcherError } from './fetcherError';
+import { InterceptorRegistry } from './interceptor';
+/**
+ * Custom error class for FetchExchange related errors.
+ *
+ * This error is thrown when there are issues with the HTTP exchange process,
+ * such as when a request fails and no response is generated. It provides
+ * comprehensive information about the failed request through the exchange object.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await fetcher.get('/api/users');
+ * } catch (error) {
+ *   if (error instanceof ExchangeError) {
+ *     console.log('Request URL:', error.exchange.request.url);
+ *     console.log('Request method:', error.exchange.request.method);
+ *     if (error.exchange.error) {
+ *       console.log('Underlying error:', error.exchange.error);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class ExchangeError extends FetcherError {
+    readonly exchange: FetchExchange;
+    /**
+     * Creates a new ExchangeError instance.
+     *
+     * @param exchange - The FetchExchange object containing request/response/error information.
+     */
+    constructor(exchange: FetchExchange);
+}
+/**
+ * Collection of interceptor managers for the Fetcher client.
+ *
+ * Manages three types of interceptors:
+ * 1. Request interceptors - Process requests before sending HTTP requests
+ * 2. Response interceptors - Process responses after receiving HTTP responses
+ * 3. Error interceptors - Handle errors when they occur during the request process
+ *
+ * Each type of interceptor is managed by an InterceptorRegistry instance, supporting
+ * adding, removing, and executing interceptors.
+ *
+ * @example
+ * // Create a custom interceptor
+ * const customRequestInterceptor: Interceptor = {
+ *   name: 'CustomRequestInterceptor',
+ *   order: 100,
+ *   async intercept(exchange: FetchExchange): Promise<FetchExchange> {
+ *     // Modify request headers
+ *     exchange.request.headers = {
+ *       ...exchange.request.headers,
+ *       'X-Custom-Header': 'custom-value'
+ *     };
+ *     return exchange;
+ *   }
+ * };
+ *
+ * // Add interceptor to Fetcher
+ * const fetcher = new Fetcher();
+ * fetcher.interceptors.request.use(customRequestInterceptor);
+ *
+ * @remarks
+ * By default, the request interceptor registry has three built-in interceptors registered:
+ * 1. UrlResolveInterceptor - Resolves the final URL with parameters
+ * 2. RequestBodyInterceptor - Automatically converts object-type request bodies to JSON strings
+ * 3. FetchInterceptor - Executes actual HTTP requests and handles timeouts
+ */
+export declare class InterceptorManager {
+    /**
+     * Registry for request-phase interceptors.
+     *
+     * Executed before HTTP requests are sent. Contains three built-in interceptors by default:
+     * UrlResolveInterceptor, RequestBodyInterceptor, and FetchInterceptor.
+     *
+     * @remarks
+     * Request interceptors are executed in ascending order of their order values, with smaller
+     * values having higher priority. The default interceptors are:
+     * 1. UrlResolveInterceptor (order: Number.MIN_SAFE_INTEGER) - Resolves the final URL
+     * 2. RequestBodyInterceptor (order: 0) - Converts object bodies to JSON
+     * 3. FetchInterceptor (order: Number.MAX_SAFE_INTEGER) - Executes the actual HTTP request
+     */
+    readonly request: InterceptorRegistry;
+    /**
+     * Manager for response-phase interceptors.
+     *
+     * Executed after HTTP responses are received. Contains ValidateStatusInterceptor by default
+     * which validates HTTP status codes and throws errors for invalid statuses.
+     *
+     * @remarks
+     * Response interceptors are executed in ascending order of their order values, with smaller
+     * values having higher priority.
+     *
+     * By default, the response interceptor registry has one built-in interceptor registered:
+     * 1. ValidateStatusInterceptor - Validates HTTP status codes and throws HttpStatusValidationError for invalid statuses
+     */
+    readonly response: InterceptorRegistry;
+    /**
+     * Manager for error-handling phase interceptors.
+     *
+     * Executed when errors occur during HTTP requests. Empty by default, custom error handling
+     * logic can be added as needed.
+     *
+     * @remarks
+     * Error interceptors are executed in ascending order of their order values, with smaller
+     * values having higher priority. Error interceptors can transform errors into normal responses,
+     * avoiding thrown exceptions.
+     */
+    readonly error: InterceptorRegistry;
+    /**
+     * Processes a FetchExchange through the interceptor pipeline.
+     *
+     * This method is the core of the Fetcher's interceptor system. It executes the three
+     * phases of interceptors in sequence:
+     * 1. Request interceptors - Process the request before sending
+     * 2. Response interceptors - Process the response after receiving
+     * 3. Error interceptors - Handle any errors that occurred during the process
+     *
+     * The interceptor pipeline follows the Chain of Responsibility pattern, where each
+     * interceptor can modify the exchange object and decide whether to continue or
+     * terminate the chain.
+     *
+     * @param fetchExchange - The exchange object containing request, response, and error information
+     * @returns Promise that resolves to the processed FetchExchange
+     * @throws ExchangeError if an unhandled error occurs during processing
+     *
+     * @remarks
+     * The method handles three distinct phases:
+     *
+     * 1. Request Phase: Executes request interceptors which can modify headers, URL, body, etc.
+     *    Built-in interceptors handle URL resolution, body serialization, and actual HTTP execution.
+     *
+     * 2. Response Phase: Executes response interceptors which can transform or validate responses.
+     *    These interceptors only run if the request phase completed without throwing.
+     *
+     * 3. Error Phase: Executes error interceptors when any phase throws an error. Error interceptors
+     *    can handle errors by clearing the error property. If error interceptors clear the error,
+     *    the exchange is returned successfully.
+     *
+     * Error Handling:
+     * - If any interceptor throws an error, the error phase is triggered
+     * - Error interceptors can "fix" errors by clearing the error property on the exchange
+     * - If errors remain after error interceptors run, they are wrapped in ExchangeError
+     *
+     * Order of Execution:
+     * 1. Request interceptors (sorted by order property, ascending)
+     * 2. Response interceptors (sorted by order property, ascending) - only if no error in request phase
+     * 3. Error interceptors (sorted by order property, ascending) - only if an error occurred
+     *
+     * @example
+     * ```typescript
+     * // Create a fetcher with custom interceptors
+     * const fetcher = new Fetcher();
+     *
+     * // Add a request interceptor
+     * fetcher.interceptors.request.use({
+     *   name: 'AuthInterceptor',
+     *   order: 100,
+     *   async intercept(exchange: FetchExchange) {
+     *     exchange.request.headers = {
+     *       ...exchange.request.headers,
+     *       'Authorization': 'Bearer ' + getToken()
+     *     };
+     *   }
+     * });
+     *
+     * // Add a response interceptor
+     * fetcher.interceptors.response.use({
+     *   name: 'ResponseLogger',
+     *   order: 100,
+     *   async intercept(exchange: FetchExchange) {
+     *     console.log(`Response status: ${exchange.response?.status}`);
+     *   }
+     * });
+     *
+     * // Add an error interceptor
+     * fetcher.interceptors.error.use({
+     *   name: 'ErrorLogger',
+     *   order: 100,
+     *   async intercept(exchange: FetchExchange) {
+     *     console.error(`Request to ${exchange.request.url} failed:`, exchange.error);
+     *     // Clear the error to indicate it's been handled
+     *     exchange.error = undefined;
+     *   }
+     * });
+     *
+     * // Create and process an exchange
+     * const request: FetchRequest = {
+     *   url: '/api/users',
+     *   method: HttpMethod.GET
+     * };
+     * const exchange = new FetchExchange(fetcher, request);
+     * const result = await fetcher.exchange(exchange);
+     * ```
+     */
+    exchange(fetchExchange: FetchExchange): Promise<FetchExchange>;
+}
+//# sourceMappingURL=interceptorManager.d.ts.map

package/dist/interceptorManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptorManager.d.ts","sourceRoot":"","sources":["../src/interceptorManager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,aAAc,SAAQ,YAAY;aAMjB,QAAQ,EAAE,aAAa;IALnD;;;;OAIG;gBACyB,QAAQ,EAAE,aAAa;CASpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,kBAAkB;IAC7B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAIlC;IAEH;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAEnC;IAEH;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAA6B;IAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqFG;IACG,QAAQ,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;CAqBrE"}

package/dist/requestBodyInterceptor.d.ts

@@ -1,27 +1,45 @@
-import { Interceptor } from './interceptor';
+import { RequestInterceptor } from './interceptor';
 import { FetchExchange } from './fetchExchange';
+/**
+ * The name of the RequestBodyInterceptor.
+ */
+export declare const REQUEST_BODY_INTERCEPTOR_NAME = "RequestBodyInterceptor";
+/**
+ * The order of the RequestBodyInterceptor.
+ * Set to URL_RESOLVE_INTERCEPTOR_ORDER + 1000 to ensure it runs early among request interceptors.
+ */
+export declare const REQUEST_BODY_INTERCEPTOR_ORDER: number;
 /**
  * Interceptor responsible for converting plain objects to JSON strings for HTTP request bodies.
  *
  * This interceptor ensures that object request bodies are properly serialized and that
  * the appropriate Content-Type header is set. It runs early in the request processing chain
  * to ensure request bodies are properly formatted before other interceptors process them.
+ *
+ * @remarks
+ * This interceptor runs after URL resolution (UrlResolveInterceptor) but before
+ * the actual HTTP request is made (FetchInterceptor). The order is set to
+ * REQUEST_BODY_INTERCEPTOR_ORDER to ensure it executes in the correct position
+ * in the interceptor chain, allowing for other interceptors to run between URL resolution
+ * and request body processing. This positioning ensures that URL parameters are resolved
+ * first, then request bodies are properly formatted, and finally the HTTP request is executed.
  */
-export declare class RequestBodyInterceptor implements Interceptor {
+export declare class RequestBodyInterceptor implements RequestInterceptor {
     /**
      * Interceptor name, used for identification and management.
      */
-    name: string;
+    readonly name = "RequestBodyInterceptor";
     /**
      * Interceptor execution order, set to run after UrlResolveInterceptor but before FetchInterceptor.
      *
      * This interceptor should run after URL resolution (UrlResolveInterceptor) but before
      * the actual HTTP request is made (FetchInterceptor). The order is set to
-     * Number.MIN_SAFE_INTEGER + 200 to ensure it executes in the correct position
+     * REQUEST_BODY_INTERCEPTOR_ORDER to ensure it executes in the correct position
      * in the interceptor chain, allowing for other interceptors to run between URL resolution
-     * and request body processing.
+     * and request body processing. This positioning ensures that URL parameters are resolved
+     * first, then request bodies are properly formatted, and finally the HTTP request is executed.
      */
-    order: number;
+    readonly order: number;
     /**
      * Attempts to convert request body to a valid fetch API body type.
      *

package/dist/requestBodyInterceptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requestBodyInterceptor.d.ts","sourceRoot":"","sources":["../src/requestBodyInterceptor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,WAAW;IACxD;;OAEG;IACH,IAAI,SAA4B;IAEhC;;;;;;;;OAQG;IACH,KAAK,SAAiC;IAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa;CA0ClC"}
+{"version":3,"file":"requestBodyInterceptor.d.ts","sourceRoot":"","sources":["../src/requestBodyInterceptor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIhD;;GAEG;AACH,eAAO,MAAM,6BAA6B,2BAA2B,CAAC;AAEtE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QACL,CAAC;AAEvC;;;;;;;;;;;;;;GAcG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IAC/D;;OAEG;IACH,QAAQ,CAAC,IAAI,4BAAiC;IAE9C;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,SAAkC;IAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa;CA0ClC"}

package/dist/timeout.d.ts

@@ -1,30 +1,5 @@
 import { FetchRequest } from './fetchRequest';
-/**
- * Interface that defines timeout capability for HTTP requests.
- *
- * Objects implementing this interface can specify timeout values for HTTP requests.
- */
-export interface TimeoutCapable {
-    /**
-     * Request timeout in milliseconds.
-     *
-     * When the value is 0, it indicates no timeout should be set.
-     * The default value is undefined.
-     */
-    timeout?: number;
-}
-/**
- * Resolves request timeout settings, prioritizing request-level timeout settings.
- *
- * @param requestTimeout - Request-level timeout setting
- * @param optionsTimeout - Configuration-level timeout setting
- * @returns Resolved timeout setting
- *
- * @remarks
- * If requestTimeout is defined, it takes precedence over optionsTimeout.
- * Otherwise, optionsTimeout is returned. If both are undefined, undefined is returned.
- */
-export declare function resolveTimeout(requestTimeout?: number, optionsTimeout?: number): number | undefined;
+import { FetcherError } from './fetcherError';
 /**
  * Exception class thrown when an HTTP request times out.
  *
@@ -41,7 +16,7 @@ export declare function resolveTimeout(requestTimeout?: number, optionsTimeout?:
  * }
  * ```
  */
-export declare class FetchTimeoutError extends Error {
+export declare class FetchTimeoutError extends FetcherError {
     /**
      * The request options that timed out.
      */
@@ -53,6 +28,32 @@ export declare class FetchTimeoutError extends Error {
      */
     constructor(request: FetchRequest);
 }
+/**
+ * Interface that defines timeout capability for HTTP requests.
+ *
+ * Objects implementing this interface can specify timeout values for HTTP requests.
+ */
+export interface TimeoutCapable {
+    /**
+     * Request timeout in milliseconds.
+     *
+     * When the value is 0, it indicates no timeout should be set.
+     * The default value is undefined.
+     */
+    timeout?: number;
+}
+/**
+ * Resolves request timeout settings, prioritizing request-level timeout settings.
+ *
+ * @param requestTimeout - Request-level timeout setting
+ * @param optionsTimeout - Configuration-level timeout setting
+ * @returns Resolved timeout setting
+ *
+ * @remarks
+ * If requestTimeout is defined, it takes precedence over optionsTimeout.
+ * Otherwise, optionsTimeout is returned. If both are undefined, undefined is returned.
+ */
+export declare function resolveTimeout(requestTimeout?: number, optionsTimeout?: number): number | undefined;
 /**
  * HTTP request method with timeout control.
  *

package/dist/timeout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../src/timeout.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,cAAc,CAAC,EAAE,MAAM,EACvB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,GAAG,SAAS,CAKpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;;;OAIG;gBACS,OAAO,EAAE,YAAY;CASlC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAyC3E"}
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../src/timeout.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IACjD;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;;;OAIG;gBACS,OAAO,EAAE,YAAY;CASlC;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,cAAc,CAAC,EAAE,MAAM,EACvB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,GAAG,SAAS,CAKpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAyC3E"}