@foundatiofx/fetchclient 1.1.1 → 1.2.0

package/script/src/FetchClientError.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchClientError = void 0;
+/**
+ * Error wrapper for non-2xx responses.
+ * Exposes the underlying response for compatibility and debugging.
+ */
+class FetchClientError extends Error {
+    response;
+    constructor(response, message) {
+        super(message ??
+            response.problem?.title ??
+            `Unexpected status code: ${response.status}`);
+        this.name = "FetchClientError";
+        this.response = response;
+    }
+    get status() {
+        return this.response.status;
+    }
+    get statusText() {
+        return this.response.statusText;
+    }
+    get ok() {
+        return this.response.ok;
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get url() {
+        return this.response.url;
+    }
+    get redirected() {
+        return this.response.redirected;
+    }
+    get type() {
+        return this.response.type;
+    }
+    get body() {
+        return this.response.body;
+    }
+    get bodyUsed() {
+        return this.response.bodyUsed;
+    }
+    get data() {
+        return this.response.data;
+    }
+    get problem() {
+        return this.response.problem;
+    }
+    get meta() {
+        return this.response.meta;
+    }
+    json() {
+        return this.response.json();
+    }
+    text() {
+        return this.response.text();
+    }
+    arrayBuffer() {
+        return this.response.arrayBuffer();
+    }
+    blob() {
+        return this.response.blob();
+    }
+    formData() {
+        return this.response.formData();
+    }
+    // @ts-ignore: New in Deno 1.44
+    bytes() {
+        // @ts-ignore: New in Deno 1.44
+        return this.response.bytes();
+    }
+    clone() {
+        return this.response.clone();
+    }
+}
+exports.FetchClientError = FetchClientError;

package/script/src/FetchClientProvider.js

@@ -9,6 +9,7 @@ const RateLimitMiddleware_js_1 = require("./RateLimitMiddleware.js");
 const RateLimiter_js_1 = require("./RateLimiter.js");
 const CircuitBreakerMiddleware_js_1 = require("./CircuitBreakerMiddleware.js");
 const CircuitBreaker_js_1 = require("./CircuitBreaker.js");
+const RetryMiddleware_js_1 = require("./RetryMiddleware.js");
 /**
  * Represents a provider for creating instances of the FetchClient class with shared default options and cache.
  */
@@ -20,6 +21,8 @@ class FetchClientProvider {
     #rateLimitMiddlewareFunc;
     #circuitBreakerMiddleware;
     #circuitBreakerMiddlewareFunc;
+    #retryMiddleware;
+    #retryMiddlewareFunc;
     #counter = new Counter_js_1.Counter();
     #onLoading = new ObjectEvent_js_1.ObjectEvent();
     /**
@@ -253,6 +256,27 @@ class FetchClientProvider {
             this.#options.middleware = this.#options.middleware?.filter((m) => m !== middlewareFunc);
         }
     }
+    /**
+     * Enables automatic retry for failed requests.
+     * Retries are performed with exponential backoff and jitter.
+     * @param options - The retry configuration options.
+     */
+    useRetry(options) {
+        this.#retryMiddleware = new RetryMiddleware_js_1.RetryMiddleware(options);
+        this.#retryMiddlewareFunc = this.#retryMiddleware.middleware();
+        this.useMiddleware(this.#retryMiddlewareFunc);
+    }
+    /**
+     * Removes the retry middleware from all FetchClient instances created by this provider.
+     */
+    removeRetry() {
+        const middlewareFunc = this.#retryMiddlewareFunc;
+        this.#retryMiddleware = undefined;
+        this.#retryMiddlewareFunc = undefined;
+        if (middlewareFunc) {
+            this.#options.middleware = this.#options.middleware?.filter((m) => m !== middlewareFunc);
+        }
+    }
 }
 exports.FetchClientProvider = FetchClientProvider;
 const provider = new FetchClientProvider();

package/script/src/RateLimitMiddleware.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RateLimitMiddleware = exports.RateLimitError = void 0;
+exports.createRateLimitMiddleware = createRateLimitMiddleware;
+exports.createPerDomainRateLimitMiddleware = createPerDomainRateLimitMiddleware;
 const ProblemDetails_js_1 = require("./ProblemDetails.js");
 const RateLimiter_js_1 = require("./RateLimiter.js");
 /**
@@ -118,3 +120,37 @@ class RateLimitMiddleware {
     }
 }
 exports.RateLimitMiddleware = RateLimitMiddleware;
+/**
+ * Creates a rate limit middleware with the given options.
+ *
+ * @example
+ * ```typescript
+ * const client = new FetchClient();
+ * client.use(createRateLimitMiddleware({
+ *   maxRequests: 100,
+ *   windowSeconds: 60,
+ * }));
+ * ```
+ */
+function createRateLimitMiddleware(options) {
+    return new RateLimitMiddleware(options).middleware();
+}
+/**
+ * Creates a per-domain rate limit middleware where each domain is tracked separately.
+ *
+ * @example
+ * ```typescript
+ * const client = new FetchClient();
+ * client.use(createPerDomainRateLimitMiddleware({
+ *   maxRequests: 100,
+ *   windowSeconds: 60,
+ * }));
+ * // api.example.com and api.other.com will have separate rate limits
+ * ```
+ */
+function createPerDomainRateLimitMiddleware(options) {
+    return new RateLimitMiddleware({
+        ...options,
+        getGroupFunc: RateLimiter_js_1.groupByDomain,
+    }).middleware();
+}

package/script/src/ResponsePromise.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsePromise = void 0;
+/**
+ * A promise that resolves to a FetchClientResponse with additional helper methods
+ * for parsing the response body. This allows for a fluent API similar to ky:
+ *
+ * @example
+ * ```typescript
+ * // Await to get the full response
+ * const response = await client.get("/api/users");
+ *
+ * // Or use helper methods for direct access to parsed body
+ * const users = await client.get("/api/users").json<User[]>();
+ * const html = await client.get("/page").text();
+ * const file = await client.get("/file").blob();
+ * ```
+ */
+class ResponsePromise {
+    #responsePromise;
+    #options;
+    constructor(responsePromise, options) {
+        this.#responsePromise = responsePromise;
+        this.#options = options;
+    }
+    /**
+     * Implements PromiseLike interface so the ResponsePromise can be awaited.
+     */
+    then(onfulfilled, onrejected) {
+        return this.#responsePromise.then(onfulfilled, onrejected);
+    }
+    /**
+     * Catches any errors from the response promise.
+     */
+    catch(onrejected) {
+        return this.#responsePromise.catch(onrejected);
+    }
+    /**
+     * Executes a callback when the promise settles (fulfilled or rejected).
+     */
+    finally(onfinally) {
+        return this.#responsePromise.finally(onfinally);
+    }
+    /**
+     * Parses the response body as JSON.
+     *
+     * If the response was already parsed as JSON (via getJSON, postJSON, etc.),
+     * returns the parsed data directly. Otherwise, parses the response body.
+     *
+     * @template TJson - The expected type of the JSON response
+     * @returns A promise that resolves to the parsed JSON
+     *
+     * @example
+     * ```typescript
+     * const user = await client.get("/api/user/1").json<User>();
+     * ```
+     */
+    async json() {
+        const response = await this.#responsePromise;
+        // If the response already has parsed data (from getJSON, etc.), return it
+        if (response.data !== null && response.data !== undefined) {
+            return response.data;
+        }
+        // Otherwise, parse the response body as JSON
+        const data = await response.json();
+        // Apply reviver and date parsing if options are set
+        if (this.#options?.reviver || this.#options?.shouldParseDates) {
+            return this.#reviveJson(data);
+        }
+        return data;
+    }
+    /**
+     * Returns the response body as text.
+     *
+     * @returns A promise that resolves to the response text
+     *
+     * @example
+     * ```typescript
+     * const html = await client.get("/page").text();
+     * ```
+     */
+    async text() {
+        const response = await this.#responsePromise;
+        return response.text();
+    }
+    /**
+     * Returns the response body as a Blob.
+     *
+     * @returns A promise that resolves to the response as a Blob
+     *
+     * @example
+     * ```typescript
+     * const imageBlob = await client.get("/image.png").blob();
+     * ```
+     */
+    async blob() {
+        const response = await this.#responsePromise;
+        return response.blob();
+    }
+    /**
+     * Returns the response body as an ArrayBuffer.
+     *
+     * @returns A promise that resolves to the response as an ArrayBuffer
+     *
+     * @example
+     * ```typescript
+     * const buffer = await client.get("/file").arrayBuffer();
+     * ```
+     */
+    async arrayBuffer() {
+        const response = await this.#responsePromise;
+        return response.arrayBuffer();
+    }
+    /**
+     * Returns the response body as FormData.
+     *
+     * @returns A promise that resolves to the response as FormData
+     *
+     * @example
+     * ```typescript
+     * const formData = await client.get("/form").formData();
+     * ```
+     */
+    async formData() {
+        const response = await this.#responsePromise;
+        return response.formData();
+    }
+    #reviveJson(data) {
+        if (data === null || data === undefined) {
+            return data;
+        }
+        if (Array.isArray(data)) {
+            return data.map((item) => this.#reviveJson(item));
+        }
+        if (typeof data === "object") {
+            const result = {};
+            for (const [key, value] of Object.entries(data)) {
+                result[key] = this.#reviveValue(key, this.#reviveJson(value));
+            }
+            return result;
+        }
+        return this.#reviveValue("", data);
+    }
+    #reviveValue(key, value) {
+        let revivedValue = value;
+        if (this.#options?.reviver) {
+            revivedValue = this.#options.reviver.call(this, key, revivedValue);
+        }
+        if (this.#options?.shouldParseDates) {
+            revivedValue = this.#tryParseDate(revivedValue);
+        }
+        return revivedValue;
+    }
+    #tryParseDate(value) {
+        if (typeof value !== "string") {
+            return value;
+        }
+        if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
+            const date = new Date(value);
+            if (!isNaN(date.getTime())) {
+                return date;
+            }
+        }
+        return value;
+    }
+}
+exports.ResponsePromise = ResponsePromise;

package/script/src/RetryMiddleware.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryMiddleware = void 0;
+exports.createRetryMiddleware = createRetryMiddleware;
+/**
+ * Default HTTP methods that are eligible for retry.
+ * These are idempotent methods that can be safely retried without side effects.
+ */
+const DEFAULT_RETRY_METHODS = [
+    "GET",
+    "HEAD",
+    "PUT",
+    "DELETE",
+    "OPTIONS",
+    "TRACE",
+];
+/**
+ * Default HTTP status codes that trigger a retry.
+ */
+const DEFAULT_RETRY_STATUS_CODES = [
+    408, // Request Timeout
+    413, // Payload Too Large (rate limiting)
+    429, // Too Many Requests
+    500, // Internal Server Error
+    502, // Bad Gateway
+    503, // Service Unavailable
+    504, // Gateway Timeout
+];
+/**
+ * Retry middleware that automatically retries failed requests with exponential backoff.
+ *
+ * @example
+ * ```typescript
+ * const provider = new FetchClientProvider();
+ * provider.useRetry({
+ *   limit: 3,
+ *   statusCodes: [500, 502, 503, 504],
+ *   jitter: 0.1,
+ * });
+ *
+ * const client = provider.getFetchClient();
+ * const response = await client.getJSON('/api/data');
+ * ```
+ */
+class RetryMiddleware {
+    #options;
+    constructor(options) {
+        this.#options = {
+            limit: options?.limit ?? 2,
+            methods: (options?.methods ?? DEFAULT_RETRY_METHODS).map((m) => m.toUpperCase()),
+            statusCodes: options?.statusCodes ?? DEFAULT_RETRY_STATUS_CODES,
+            maxRetryAfter: options?.maxRetryAfter ?? Infinity,
+            backoffLimit: options?.backoffLimit ?? 30000,
+            jitter: options?.jitter ?? 0.1,
+            delay: options?.delay,
+            shouldRetry: options?.shouldRetry,
+            onRetry: options?.onRetry,
+        };
+    }
+    /**
+     * Creates the middleware function.
+     * @returns The middleware function
+     */
+    middleware() {
+        return async (context, next) => {
+            const method = context.request.method.toUpperCase();
+            // Check if method is eligible for retry
+            if (!this.#options.methods.includes(method)) {
+                await next();
+                return;
+            }
+            let attemptNumber = 0;
+            while (true) {
+                // Store retry metadata in context for observability
+                if (attemptNumber > 0) {
+                    context.retryAttempt = attemptNumber;
+                }
+                await next();
+                // If no response or we've exhausted retries, stop
+                if (!context.response || attemptNumber >= this.#options.limit) {
+                    break;
+                }
+                const response = context.response;
+                // Check if status code is retryable
+                if (!this.#options.statusCodes.includes(response.status)) {
+                    break;
+                }
+                // Check custom shouldRetry predicate
+                if (this.#options.shouldRetry) {
+                    const shouldRetry = await this.#options.shouldRetry(response, attemptNumber);
+                    if (!shouldRetry) {
+                        break;
+                    }
+                }
+                // Calculate base delay
+                let delay = this.#calculateDelay(attemptNumber, response);
+                // Check Retry-After header
+                const retryAfterDelay = this.#parseRetryAfter(response);
+                if (retryAfterDelay !== null) {
+                    // If Retry-After exceeds maxRetryAfter, don't retry
+                    if (retryAfterDelay > this.#options.maxRetryAfter) {
+                        break;
+                    }
+                    // Use the larger of computed delay or Retry-After
+                    delay = Math.max(delay, retryAfterDelay);
+                }
+                // Invoke onRetry callback
+                this.#options.onRetry?.(attemptNumber, response, delay);
+                // Wait before retry
+                await this.#sleep(delay);
+                // Reset response for next attempt
+                context.response = null;
+                attemptNumber++;
+            }
+        };
+    }
+    /**
+     * Calculates the delay for a given attempt with exponential backoff and jitter.
+     */
+    #calculateDelay(attemptNumber, response) {
+        let baseDelay;
+        if (this.#options.delay) {
+            baseDelay = this.#options.delay(attemptNumber, response);
+        }
+        else {
+            // Default exponential backoff: 1s, 2s, 4s, 8s, ...
+            baseDelay = Math.min(1000 * Math.pow(2, attemptNumber), this.#options.backoffLimit);
+        }
+        // Apply jitter
+        return this.#applyJitter(baseDelay);
+    }
+    /**
+     * Applies jitter to a delay value.
+     */
+    #applyJitter(delay) {
+        if (this.#options.jitter <= 0) {
+            return delay;
+        }
+        const jitterRange = delay * this.#options.jitter;
+        // Random value between -jitterRange and +jitterRange
+        const jitter = (Math.random() * 2 - 1) * jitterRange;
+        return Math.max(0, Math.round(delay + jitter));
+    }
+    /**
+     * Parses the Retry-After header and returns the delay in milliseconds.
+     * Supports both delta-seconds and HTTP-date formats.
+     */
+    #parseRetryAfter(response) {
+        const retryAfter = response.headers.get("Retry-After");
+        if (!retryAfter) {
+            return null;
+        }
+        // Try parsing as seconds (integer)
+        const seconds = parseInt(retryAfter, 10);
+        if (!isNaN(seconds)) {
+            return seconds * 1000;
+        }
+        // Try parsing as HTTP-date
+        const date = Date.parse(retryAfter);
+        if (!isNaN(date)) {
+            return Math.max(0, date - Date.now());
+        }
+        return null;
+    }
+    /**
+     * Sleep for the specified number of milliseconds.
+     */
+    #sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.RetryMiddleware = RetryMiddleware;
+/**
+ * Creates a retry middleware with the given options.
+ *
+ * @example
+ * ```typescript
+ * const client = new FetchClient();
+ * client.use(createRetryMiddleware({ limit: 3 }));
+ * ```
+ */
+function createRetryMiddleware(options) {
+    return new RetryMiddleware(options).middleware();
+}

package/script/src/mocks/MockHistory.js

@@ -6,6 +6,7 @@ exports.MockHistoryImpl = void 0;
  */
 class MockHistoryImpl {
     #get = [];
+    #head = [];
     #post = [];
     #put = [];
     #patch = [];
@@ -14,6 +15,9 @@ class MockHistoryImpl {
     get get() {
         return [...this.#get];
     }
+    get head() {
+        return [...this.#head];
+    }
     get post() {
         return [...this.#post];
     }
@@ -38,6 +42,9 @@ class MockHistoryImpl {
             case "GET":
                 this.#get.push(request);
                 break;
+            case "HEAD":
+                this.#head.push(request);
+                break;
             case "POST":
                 this.#post.push(request);
                 break;
@@ -57,6 +64,7 @@ class MockHistoryImpl {
      */
     clear() {
         this.#get = [];
+        this.#head = [];
         this.#post = [];
         this.#put = [];
         this.#patch = [];

package/script/src/mocks/MockRegistry.js

@@ -43,6 +43,13 @@ class MockRegistry {
     onGet(url) {
         return this.#addMock("GET", url);
     }
+    /**
+     * Creates a mock for HEAD requests matching the given URL.
+     * @param url - URL string or RegExp to match
+     */
+    onHead(url) {
+        return this.#addMock("HEAD", url);
+    }
     /**
      * Creates a mock for POST requests matching the given URL.
      * @param url - URL string or RegExp to match

package/types/mod.d.ts

@@ -1,6 +1,8 @@
 export { FetchClient } from "./src/FetchClient.js";
 export type { FetchClientOptions } from "./src/FetchClientOptions.js";
 export type { FetchClientResponse } from "./src/FetchClientResponse.js";
+export { FetchClientError } from "./src/FetchClientError.js";
+export { ResponsePromise } from "./src/ResponsePromise.js";
 export { ProblemDetails } from "./src/ProblemDetails.js";
 export { type CacheKey, type CacheTag, FetchClientCache, } from "./src/FetchClientCache.js";
 export type { RequestOptions } from "./src/RequestOptions.js";
@@ -10,4 +12,98 @@ export { defaultInstance as defaultProviderInstance, FetchClientProvider, } from
 export * from "./src/DefaultHelpers.js";
 export { CircuitBreaker, type CircuitBreakerOptions, type CircuitState, groupByDomain as circuitBreakerGroupByDomain, type GroupCircuitBreakerOptions, } from "./src/CircuitBreaker.js";
 export { CircuitBreakerMiddleware, type CircuitBreakerMiddlewareOptions, CircuitOpenError, createCircuitBreakerMiddleware, createPerDomainCircuitBreakerMiddleware, } from "./src/CircuitBreakerMiddleware.js";
+export { createRetryMiddleware, RetryMiddleware, type RetryMiddlewareOptions, } from "./src/RetryMiddleware.js";
+export { createPerDomainRateLimitMiddleware, createRateLimitMiddleware, RateLimitError, RateLimitMiddleware, type RateLimitMiddlewareOptions, } from "./src/RateLimitMiddleware.js";
+export { groupByDomain as rateLimiterGroupByDomain, RateLimiter, type RateLimiterOptions, } from "./src/RateLimiter.js";
+import { createRetryMiddleware } from "./src/RetryMiddleware.js";
+import { createPerDomainRateLimitMiddleware, createRateLimitMiddleware } from "./src/RateLimitMiddleware.js";
+import { createCircuitBreakerMiddleware, createPerDomainCircuitBreakerMiddleware } from "./src/CircuitBreakerMiddleware.js";
+import { deleteJSON, getJSON, patchJSON, postJSON, putJSON, useMiddleware } from "./src/DefaultHelpers.js";
+import type { GetRequestOptions, RequestOptions } from "./src/RequestOptions.js";
+import type { ResponsePromise } from "./src/ResponsePromise.js";
+/**
+ * Convenience middleware factory functions for use with FetchClient.use()
+ *
+ * @example
+ * ```typescript
+ * import { FetchClient, middleware } from "@foundatiofx/fetchclient";
+ *
+ * const client = new FetchClient();
+ * client.use(
+ *   middleware.retry({ limit: 3 }),
+ *   middleware.rateLimit({ maxRequests: 100, windowSeconds: 60 }),
+ *   middleware.circuitBreaker({ failureThreshold: 5 })
+ * );
+ * ```
+ */
+export declare const middleware: {
+    /** Retry failed requests with exponential backoff and jitter */
+    retry: typeof createRetryMiddleware;
+    /** Rate limit requests to prevent overwhelming servers */
+    rateLimit: typeof createRateLimitMiddleware;
+    /** Per-domain rate limit (each domain tracked separately) */
+    perDomainRateLimit: typeof createPerDomainRateLimitMiddleware;
+    /** Circuit breaker for fault tolerance */
+    circuitBreaker: typeof createCircuitBreakerMiddleware;
+    /** Per-domain circuit breaker (each domain tracked separately) */
+    perDomainCircuitBreaker: typeof createPerDomainCircuitBreakerMiddleware;
+};
+/**
+ * Default export for convenient access to all HTTP methods.
+ *
+ * @example
+ * ```typescript
+ * import fc from "@foundatiofx/fetchclient";
+ *
+ * // Configure middleware
+ * fc.use(fc.middleware.retry({ limit: 3 }));
+ *
+ * // Use JSON methods (recommended)
+ * const { data: user } = await fc.getJSON<User>("/api/user/1");
+ * const { data: created } = await fc.postJSON<User>("/api/users", { name: "Alice" });
+ *
+ * // Or use fluent API for other response types
+ * const html = await fc.get("/page").text();
+ * ```
+ */
+declare const fetchClient: {
+    /** Sends a GET request. Use `.json<T>()` for typed JSON response. */
+    get: (url: string, options?: GetRequestOptions) => ResponsePromise<unknown>;
+    /** Sends a POST request. Use `.json<T>()` for typed JSON response. */
+    post: (url: string, body?: object | string | FormData, options?: RequestOptions) => ResponsePromise<unknown>;
+    /** Sends a PUT request. Use `.json<T>()` for typed JSON response. */
+    put: (url: string, body?: object | string | FormData, options?: RequestOptions) => ResponsePromise<unknown>;
+    /** Sends a PATCH request. Use `.json<T>()` for typed JSON response. */
+    patch: (url: string, body?: object | string | FormData, options?: RequestOptions) => ResponsePromise<unknown>;
+    /** Sends a DELETE request. Use `.json<T>()` for typed JSON response. */
+    delete: (url: string, options?: RequestOptions) => ResponsePromise<unknown>;
+    /** Sends a HEAD request. */
+    head: (url: string, options?: GetRequestOptions) => ResponsePromise<void>;
+    /** Sends a GET request and returns parsed JSON in response.data */
+    getJSON: typeof getJSON;
+    /** Sends a POST request and returns parsed JSON in response.data */
+    postJSON: typeof postJSON;
+    /** Sends a PUT request and returns parsed JSON in response.data */
+    putJSON: typeof putJSON;
+    /** Sends a PATCH request and returns parsed JSON in response.data */
+    patchJSON: typeof patchJSON;
+    /** Sends a DELETE request and returns parsed JSON in response.data */
+    deleteJSON: typeof deleteJSON;
+    /** Adds middleware to the default provider */
+    use: typeof useMiddleware;
+    /** Middleware factory functions */
+    middleware: {
+        /** Retry failed requests with exponential backoff and jitter */
+        retry: typeof createRetryMiddleware;
+        /** Rate limit requests to prevent overwhelming servers */
+        rateLimit: typeof createRateLimitMiddleware;
+        /** Per-domain rate limit (each domain tracked separately) */
+        perDomainRateLimit: typeof createPerDomainRateLimitMiddleware;
+        /** Circuit breaker for fault tolerance */
+        circuitBreaker: typeof createCircuitBreakerMiddleware;
+        /** Per-domain circuit breaker (each domain tracked separately) */
+        perDomainCircuitBreaker: typeof createPerDomainCircuitBreakerMiddleware;
+    };
+};
+export default fetchClient;
 //# sourceMappingURL=mod.d.ts.map

package/types/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,YAAY,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,gBAAgB,GACjB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,YAAY,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAC5E,YAAY,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,eAAe,IAAI,uBAAuB,EAC1C,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EACjB,aAAa,IAAI,2BAA2B,EAC5C,KAAK,0BAA0B,GAChC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,wBAAwB,EACxB,KAAK,+BAA+B,EACpC,gBAAgB,EAChB,8BAA8B,EAC9B,uCAAuC,GACxC,MAAM,mCAAmC,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"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"}