@ahoo-wang/fetcher 0.9.0 → 0.9.1

package/dist/index.es.js

@@ -6,7 +6,7 @@ function b(r, e) {
 }
 class g {
   /**
-   * Creates a UrlBuilder instance
+   * Initializes a new UrlBuilder instance.
    *
    * @param baseURL - Base URL that all constructed URLs will be based on
    *
@@ -19,7 +19,7 @@ class g {
     this.baseURL = e;
   }
   /**
-   * Builds a complete URL, including path parameter replacement and query parameter addition
+   * Builds a complete URL, including path parameter replacement and query parameter addition.
    *
    * @param url - URL path to build (e.g., '/users/{id}/posts')
    * @param params - URL parameters including path and query parameters
@@ -46,9 +46,9 @@ class g {
     return o;
   }
   /**
-   * Resolves a complete URL from a FetchRequest
+   * Resolves a complete URL from a FetchRequest.
    *
-   * This method is used internally by the Fetcher to build the final URL for a request
+   * Used internally by the Fetcher to build the final URL for a request
    * by combining the request URL with its URL parameters using this UrlBuilder.
    *
    * @param request - The FetchRequest containing URL and URL parameters
@@ -58,7 +58,7 @@ class g {
     return this.build(e.url, e.urlParams);
   }
   /**
-   * Replaces placeholders in the URL with path parameters
+   * Replaces placeholders in the URL with path parameters.
    *
    * @param url - Path string containing placeholders, e.g., "http://localhost/users/{id}/posts/{postId}"
    * @param path - Path parameter object used to replace placeholders in the URL
@@ -98,7 +98,7 @@ function w(r, e) {
 }
 class p extends Error {
   /**
-   * Creates a new FetchTimeoutError instance
+   * Creates a new FetchTimeoutError instance.
    *
    * @param request - The request options that timed out
    */
@@ -140,7 +140,7 @@ class R {
     this.name = "RequestBodyInterceptor", this.order = Number.MIN_SAFE_INTEGER + 200;
   }
   /**
-   * Attempts to convert request body to a valid fetch API body type
+   * Attempts to convert request body to a valid fetch API body type.
    *
    * According to the Fetch API specification, body can be multiple types, but for
    * plain objects, they need to be converted to JSON strings.
@@ -162,18 +162,19 @@ class R {
    * converted to JSON strings.
    *
    * @param exchange - The exchange object containing the request to process
-   * @returns The processed exchange object with potentially modified request body
    *
    * @example
    * // Plain object body will be converted to JSON
-   * const exchange = {
-   *   request: {
+   * const fetcher = new Fetcher();
+   * const exchange = new FetchExchange(
+   *   fetcher,
+   *   {
    *     body: { name: 'John', age: 30 }
    *   }
-   * };
-   * const result = interceptor.intercept(exchange);
-   * // result.request.body will be '{"name":"John","age":30}'
-   * // result.request.headers will include 'Content-Type: application/json'
+   * );
+   * interceptor.intercept(exchange);
+   * // exchange.request.body will be '{"name":"John","age":30}'
+   * // exchange.request.headers will include 'Content-Type: application/json'
    */
   intercept(e) {
     const t = e.request;
@@ -191,7 +192,7 @@ class F {
     this.name = "FetchInterceptor", this.order = Number.MAX_SAFE_INTEGER - 100;
   }
   /**
-   * Intercept and process HTTP requests
+   * Intercept and process HTTP requests.
    *
    * Executes the actual HTTP request and applies timeout control. This is the final
    * step in the request processing chain, responsible for calling the timeoutFetch
@@ -203,15 +204,17 @@ class F {
    *
    * @example
    * // Usually called internally by Fetcher
-   * const exchange = {
-   *   url: 'https://api.example.com/users',
-   *   request: {
+   * const fetcher = new Fetcher();
+   * const exchange = new FetchExchange(
+   *   fetcher,
+   *   {
+   *     url: 'https://api.example.com/users',
    *     method: 'GET',
    *     timeout: 5000
    *   }
-   * };
-   * const result = await fetchInterceptor.intercept(exchange);
-   * console.log(result.response); // HTTP response object
+   * );
+   * await fetchInterceptor.intercept(exchange);
+   * console.log(exchange.response); // HTTP response object
    */
   async intercept(e) {
     e.response = await P(e.request);
@@ -222,10 +225,9 @@ class A {
     this.name = "UrlResolveInterceptor", this.order = Number.MIN_SAFE_INTEGER + 100;
   }
   /**
-   * Resolves the final URL by combining the base URL, path parameters, and query parameters
+   * Resolves the final URL by combining the base URL, path parameters, and query parameters.
    *
    * @param exchange - The fetch exchange containing the request information
-   * @returns The modified exchange with the resolved URL
    */
   intercept(e) {
     const t = e.request;
@@ -234,7 +236,7 @@ class A {
 }
 class h {
   /**
-   * Creates a new InterceptorManager instance
+   * Initializes a new InterceptorManager instance.
    *
    * @param interceptors - Initial array of interceptors to manage
    *
@@ -246,7 +248,7 @@ class h {
     this.sortedInterceptors = [], this.sortedInterceptors = a(e);
   }
   /**
-   * Gets the name of this interceptor manager
+   * Gets the name of this interceptor manager.
    *
    * @returns The constructor name of this class
    */
@@ -254,7 +256,7 @@ class h {
     return this.constructor.name;
   }
   /**
-   * Gets the order of this interceptor manager
+   * Gets the order of this interceptor manager.
    *
    * @returns Number.MIN_SAFE_INTEGER, indicating this manager should execute early
    */
@@ -262,7 +264,7 @@ class h {
     return Number.MIN_SAFE_INTEGER;
   }
   /**
-   * Adds an interceptor to this manager
+   * Adds an interceptor to this manager.
    *
    * @param interceptor - The interceptor to add
    * @returns True if the interceptor was added, false if an interceptor with the
@@ -281,7 +283,7 @@ class h {
     ]), !0);
   }
   /**
-   * Removes an interceptor by name
+   * Removes an interceptor by name.
    *
    * @param name - The name of the interceptor to remove
    * @returns True if an interceptor was removed, false if no interceptor with the
@@ -295,16 +297,16 @@ class h {
     ), t.length !== this.sortedInterceptors.length;
   }
   /**
-   * Removes all interceptors from this manager
+   * Removes all interceptors from this manager.
    */
   clear() {
     this.sortedInterceptors = [];
   }
   /**
-   * Executes all managed interceptors on the given exchange object
+   * Executes all managed interceptors on the given exchange object.
    *
    * @param exchange - The exchange object to process
-   * @returns A promise that resolves to the processed exchange object
+   * @returns A promise that resolves when all interceptors have been executed
    *
    * @remarks
    * Interceptors are executed in order, with each interceptor receiving the result
@@ -333,7 +335,7 @@ class S {
     this.attributes = {}, this.fetcher = e, this.request = t, this.response = s, this.error = n;
   }
   /**
-   * Checks if the exchange has an error
+   * Checks if the exchange has an error.
    *
    * @returns true if an error is present, false otherwise
    */
@@ -341,7 +343,7 @@ class S {
     return !!this.error;
   }
   /**
-   * Checks if the exchange has a response
+   * Checks if the exchange has a response.
    *
    * @returns true if a response is present, false otherwise
    */
@@ -361,19 +363,26 @@ const l = {
 };
 class q {
   /**
-   * Create a Fetcher instance
+   * Initializes a new Fetcher instance with optional configuration.
    *
-   * @param options - Fetcher configuration options
+   * Creates a Fetcher with default settings that can be overridden through the options parameter.
+   * If no interceptors are provided, a default set of interceptors will be used.
+   *
+   * @param options - Configuration options for the Fetcher instance
    */
   constructor(e = T) {
     this.headers = l, this.urlBuilder = new g(e.baseURL), this.headers = e.headers ?? l, this.timeout = e.timeout, this.interceptors = e.interceptors ?? new N();
   }
   /**
-   * Make an HTTP request
+   * Executes an HTTP request with the specified URL and options.
+   *
+   * This is the primary method for making HTTP requests. It processes the request
+   * through the interceptor chain and returns the resulting Response.
    *
-   * @param url - Request URL path
-   * @param request - Request options, including path parameters, query parameters, etc.
-   * @returns Promise<Response> HTTP response
+   * @param url - The URL path for the request (relative to baseURL if set)
+   * @param request - Request configuration including headers, body, parameters, etc.
+   * @returns Promise that resolves to the HTTP response
+   * @throws Error if the request fails and no response is generated
    */
   async fetch(e, t = {}) {
     const s = t;
@@ -384,12 +393,15 @@ class q {
     return n.response;
   }
   /**
-   * Send an HTTP request
+   * Processes an HTTP request through the Fetcher's internal workflow.
    *
-   * @param request - Request configuration object, including url, method, headers, body, etc.
-   * @returns Promise that resolves to a FetchExchange object containing request and response information
+   * This method prepares the request by merging headers and timeout settings,
+   * creates a FetchExchange object, and passes it through the exchange method
+   * for interceptor processing.
    *
-   * @throws Throws an exception when an error occurs during the request and is not handled by error interceptors
+   * @param request - Complete request configuration object
+   * @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 = d(e.headers, this.headers), s = {
@@ -400,20 +412,20 @@ class q {
     return this.exchange(n);
   }
   /**
-   * Process a fetch exchange through the interceptor chain
+   * Processes a FetchExchange through the interceptor chain.
    *
-   * This method orchestrates the complete request lifecycle by applying interceptors
-   * in the following order:
-   * 1. Request interceptors - to modify the outgoing request
-   * 2. Response interceptors - to process the incoming response
+   * Orchestrates the complete request lifecycle by applying interceptors in sequence:
+   * 1. Request interceptors - Modify the outgoing request
+   * 2. Response interceptors - Process the incoming response
    *
-   * If any error occurs during the process, error interceptors are applied to handle it.
-   * If an error interceptor produces a response, that response is returned. Otherwise,
-   * the original error is re-thrown.
+   * Error handling follows this flow:
+   * - If an error occurs, error interceptors are invoked
+   * - If an error interceptor produces a response, it's returned
+   * - Otherwise, the original error is re-thrown
    *
-   * @param fetchExchange - The exchange object containing request, response, and metadata
-   * @returns Promise<FetchExchange> The processed exchange with final response or error
-   * @throws Error if an error occurs and is not handled by error interceptors
+   * @param fetchExchange - The exchange object containing request and response data
+   * @returns Promise resolving to the processed exchange
+   * @throws Error if an unhandled error occurs during processing
    */
   async exchange(e) {
     try {
@@ -425,12 +437,15 @@ class q {
     }
   }
   /**
-   * Make an HTTP request with the specified method
+   * Internal helper method for making HTTP requests with a specific method.
+   *
+   * This private method is used by the public HTTP method methods (get, post, etc.)
+   * to execute requests with the appropriate HTTP verb.
    *
-   * @param method - HTTP method to use
-   * @param url - Request URL path
-   * @param request - Request options
-   * @returns Promise<Response> HTTP response
+   * @param method - The HTTP method to use for the request
+   * @param url - The URL path for the request
+   * @param request - Additional request options
+   * @returns Promise that resolves to the HTTP response
    */
   async methodFetch(e, t, s = {}) {
     return this.fetch(t, {
@@ -439,71 +454,88 @@ class q {
     });
   }
   /**
-   * Make a GET request
+   * Makes a GET HTTP request.
    *
-   * @param url - Request URL path
-   * @param request - Request options, including path parameters, query parameters, etc.
-   * @returns Promise<Response> HTTP response
+   * Convenience method for making GET requests. The request body is omitted
+   * as GET requests should not contain a body according to HTTP specification.
+   *
+   * @param url - The URL path for the request
+   * @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);
   }
   /**
-   * Make a POST request
+   * Makes a POST HTTP request.
+   *
+   * Convenience method for making POST requests, commonly used for creating resources.
    *
-   * @param url - Request URL path
-   * @param request - Request options, including path parameters, query parameters, request body, etc.
-   * @returns Promise<Response> HTTP response
+   * @param url - The URL path for the request
+   * @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);
   }
   /**
-   * Make a PUT request
+   * Makes a PUT HTTP request.
    *
-   * @param url - Request URL path
-   * @param request - Request options, including path parameters, query parameters, request body, etc.
-   * @returns Promise<Response> HTTP response
+   * Convenience method for making PUT requests, commonly used for updating resources.
+   *
+   * @param url - The URL path for the request
+   * @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);
   }
   /**
-   * Make a DELETE request
+   * Makes a DELETE HTTP request.
+   *
+   * Convenience method for making DELETE requests, commonly used for deleting resources.
    *
-   * @param url - Request URL path
-   * @param request - Request options, including path parameters, query parameters, etc.
-   * @returns Promise<Response> HTTP response
+   * @param url - The URL path for the request
+   * @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);
   }
   /**
-   * Make a PATCH request
+   * Makes a PATCH HTTP request.
+   *
+   * Convenience method for making PATCH requests, commonly used for partial updates.
    *
-   * @param url - Request URL path
-   * @param request - Request options, including path parameters, query parameters, request body, etc.
-   * @returns Promise<Response> HTTP response
+   * @param url - The URL path for the request
+   * @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);
   }
   /**
-   * Make a HEAD request
+   * Makes a HEAD HTTP request.
    *
-   * @param url - Request URL path
-   * @param request - Request options, including path parameters, query parameters, etc.
-   * @returns Promise<Response> HTTP response
+   * Convenience method for making HEAD requests, which retrieve headers only.
+   * The request body is omitted as HEAD requests should not contain a body.
+   *
+   * @param url - The URL path for the request
+   * @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);
   }
   /**
-   * Make an OPTIONS request
+   * Makes an OPTIONS HTTP request.
+   *
+   * Convenience method for making OPTIONS requests, commonly used for CORS preflight.
+   * The request body is omitted as OPTIONS requests typically don't contain a body.
    *
-   * @param url - Request URL path
-   * @param request - Request options, including path parameters, query parameters, etc.
-   * @returns Promise<Response> HTTP response
+   * @param url - The URL path for the request
+   * @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);

package/dist/interceptor.d.ts

@@ -2,14 +2,11 @@ import { NamedCapable } from './types';
 import { OrderedCapable } from './orderedCapable';
 import { FetchExchange } from './fetchExchange';
 /**
- * Interceptor Interface
+ * Interface for HTTP interceptors in the fetcher pipeline.
  *
- * Defines the basic structure of an interceptor. Interceptors are used to process
- * requests, responses, or errors at different stages of the HTTP request lifecycle.
- *
- * @remarks
- * Interceptors follow the Chain of Responsibility pattern, where each interceptor
- * can modify the exchange object and pass it to the next interceptor in the chain.
+ * Interceptors are middleware components that can modify requests, responses, or handle errors
+ * at different stages of the HTTP request lifecycle. They follow the Chain of Responsibility
+ * pattern, where each interceptor can process the exchange object and pass it to the next.
  *
  * @example
  * // Example of a custom request interceptor
@@ -27,21 +24,19 @@ import { FetchExchange } from './fetchExchange';
  */
 export interface Interceptor extends NamedCapable, OrderedCapable {
     /**
-     * Interceptor name, used to identify the interceptor and must be unique
+     * Unique identifier for the interceptor.
      *
-     * @remarks
-     * The name is used by the InterceptorManager to manage interceptors,
-     * including adding, removing, and preventing duplicates.
+     * Used by InterceptorManager to manage interceptors, including adding, removing,
+     * and preventing duplicates. Each interceptor must have a unique name.
      */
     name: string;
     /**
-     * Intercept and process data
+     * Process the exchange object in the interceptor pipeline.
      *
-     * This method is called by the InterceptorManager to process the exchange object.
-     * The interceptor can modify the request, response, or error properties of the
-     * exchange object directly.
+     * This method is called by InterceptorManager to process the exchange object.
+     * Interceptors can modify request, response, or error properties directly.
      *
-     * @param exchange - The data to be processed, containing request, response, and error information
+     * @param exchange - The exchange object containing request, response, and error information
      *
      * @remarks
      * Interceptors should modify the exchange object directly rather than returning it.
@@ -50,11 +45,10 @@ export interface Interceptor extends NamedCapable, OrderedCapable {
     intercept(exchange: FetchExchange): void | Promise<void>;
 }
 /**
- * InterceptorManager Class
+ * Manager for a collection of interceptors of the same type.
  *
- * Manages multiple interceptors of the same type. Responsible for adding, removing,
- * and executing interceptors in the correct order. Each InterceptorManager instance
- * handles one type of interceptor (request, response, or error).
+ * Handles adding, removing, and executing interceptors in the correct order.
+ * Each InterceptorManager instance manages one type of interceptor (request, response, or error).
  *
  * @remarks
  * Interceptors are executed in ascending order of their `order` property.
@@ -75,23 +69,23 @@ export interface Interceptor extends NamedCapable, OrderedCapable {
  */
 export declare class InterceptorManager implements Interceptor {
     /**
-     * Gets the name of this interceptor manager
+     * Gets the name of this interceptor manager.
      *
      * @returns The constructor name of this class
      */
     get name(): string;
     /**
-     * Gets the order of this interceptor manager
+     * Gets the order of this interceptor manager.
      *
      * @returns Number.MIN_SAFE_INTEGER, indicating this manager should execute early
      */
     get order(): number;
     /**
-     * Array of interceptors managed by this manager, sorted by their order property
+     * Array of interceptors managed by this manager, sorted by their order property.
      */
     private sortedInterceptors;
     /**
-     * Creates a new InterceptorManager instance
+     * Initializes a new InterceptorManager instance.
      *
      * @param interceptors - Initial array of interceptors to manage
      *
@@ -101,7 +95,7 @@ export declare class InterceptorManager implements Interceptor {
      */
     constructor(interceptors?: Interceptor[]);
     /**
-     * Adds an interceptor to this manager
+     * Adds an interceptor to this manager.
      *
      * @param interceptor - The interceptor to add
      * @returns True if the interceptor was added, false if an interceptor with the
@@ -115,7 +109,7 @@ export declare class InterceptorManager implements Interceptor {
      */
     use(interceptor: Interceptor): boolean;
     /**
-     * Removes an interceptor by name
+     * Removes an interceptor by name.
      *
      * @param name - The name of the interceptor to remove
      * @returns True if an interceptor was removed, false if no interceptor with the
@@ -123,14 +117,14 @@ export declare class InterceptorManager implements Interceptor {
      */
     eject(name: string): boolean;
     /**
-     * Removes all interceptors from this manager
+     * Removes all interceptors from this manager.
      */
     clear(): void;
     /**
-     * Executes all managed interceptors on the given exchange object
+     * Executes all managed interceptors on the given exchange object.
      *
      * @param exchange - The exchange object to process
-     * @returns A promise that resolves to the processed exchange object
+     * @returns A promise that resolves when all interceptors have been executed
      *
      * @remarks
      * Interceptors are executed in order, with each interceptor receiving the result
@@ -143,14 +137,15 @@ export declare class InterceptorManager implements Interceptor {
     intercept(exchange: FetchExchange): Promise<void>;
 }
 /**
- * FetcherInterceptors Class
+ * Collection of interceptor managers for the Fetcher client.
  *
- * The interceptor collection management class for Fetcher, responsible for managing three types of interceptors:
+ * 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.
+ * Each type of interceptor is managed by an InterceptorManager instance, supporting
+ * adding, removing, and executing interceptors.
  *
  * @example
  * // Create a custom interceptor
@@ -172,44 +167,47 @@ export declare class InterceptorManager implements Interceptor {
  * fetcher.interceptors.request.use(customRequestInterceptor);
  *
  * @remarks
- * By default, the request interceptor manager has two built-in interceptors registered:
- * 1. RequestBodyInterceptor - Automatically converts object-type request bodies to JSON strings
- * 2. FetchInterceptor - Executes actual HTTP requests and handles timeouts
+ * 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 {
     /**
-     * Request Interceptor Manager
+     * Manager for request-phase interceptors.
      *
-     * Responsible for managing all request-phase interceptors, executed before HTTP requests are sent.
-     * Contains three built-in interceptors by default: UrlResolveInterceptor, RequestBodyInterceptor, and FetchInterceptor.
+     * 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:
+     * 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;
     /**
-     * Response Interceptor Manager
+     * Manager for response-phase interceptors.
      *
-     * Responsible for managing all response-phase interceptors, executed after HTTP responses are received.
-     * Empty by default, custom response processing logic can be added as needed.
+     * 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 interceptors are executed in ascending order of their order values, with smaller
+     * values having higher priority.
      */
     response: InterceptorManager;
     /**
-     * Error Interceptor Manager
+     * Manager for error-handling phase interceptors.
      *
-     * Responsible for managing all error-handling phase interceptors, executed when errors occur during HTTP requests.
-     * Empty by default, custom error handling logic can be added as needed.
+     * 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 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;
 }

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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,WAAY,SAAQ,YAAY,EAAE,cAAc;IAC/D;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,mBAAmB;IAC9B;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,kBAAkB,CAIxB;IAEH;;;;;;;;OAQG;IACH,QAAQ,EAAE,kBAAkB,CAA4B;IAExD;;;;;;;;;OASG;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;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"}