@langchain/langgraph-sdk 0.1.9 → 1.0.0

package/dist/utils/async_caller.d.ts

@@ -1,25 +1,26 @@
+//#region src/utils/async_caller.d.ts
 type ResponseCallback = (response?: Response) => Promise<boolean>;
-export interface AsyncCallerParams {
-    /**
-     * The maximum number of concurrent calls that can be made.
-     * Defaults to `Infinity`, which means no limit.
-     */
-    maxConcurrency?: number;
-    /**
-     * The maximum number of retries that can be made for a single call,
-     * with an exponential backoff between each attempt. Defaults to 6.
-     */
-    maxRetries?: number;
-    onFailedResponseHook?: ResponseCallback;
-    /**
-     * Specify a custom fetch implementation.
-     *
-     * By default we expect the `fetch` is available in the global scope.
-     */
-    fetch?: typeof fetch | ((...args: any[]) => any);
+interface AsyncCallerParams {
+  /**
+   * The maximum number of concurrent calls that can be made.
+   * Defaults to `Infinity`, which means no limit.
+   */
+  maxConcurrency?: number;
+  /**
+   * The maximum number of retries that can be made for a single call,
+   * with an exponential backoff between each attempt. Defaults to 6.
+   */
+  maxRetries?: number;
+  onFailedResponseHook?: ResponseCallback;
+  /**
+   * Specify a custom fetch implementation.
+   *
+   * By default we expect the `fetch` is available in the global scope.
+   */
+  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any
 }
-export interface AsyncCallerCallOptions {
-    signal?: AbortSignal;
+interface AsyncCallerCallOptions {
+  signal?: AbortSignal;
 }
 /**
  * A class that can be used to make async calls with concurrency and retry logic.
@@ -34,15 +35,19 @@ export interface AsyncCallerCallOptions {
  * means that by default, each call will be retried up to 5 times, with an
  * exponential backoff between each attempt.
  */
-export declare class AsyncCaller {
-    protected maxConcurrency: AsyncCallerParams["maxConcurrency"];
-    protected maxRetries: AsyncCallerParams["maxRetries"];
-    private queue;
-    private onFailedResponseHook?;
-    private customFetch?;
-    constructor(params: AsyncCallerParams);
-    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
-    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
-    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;
+declare class AsyncCaller {
+  protected maxConcurrency: AsyncCallerParams["maxConcurrency"];
+  protected maxRetries: AsyncCallerParams["maxRetries"];
+  private queue;
+  private onFailedResponseHook?;
+  private customFetch?;
+  constructor(params: AsyncCallerParams);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
+  fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;
 }
-export {};
+//#endregion
+export { AsyncCaller, AsyncCallerParams };
+//# sourceMappingURL=async_caller.d.ts.map

package/dist/utils/async_caller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async_caller.d.ts","names":["ResponseCallback","Response","Promise","AsyncCallerParams","fetch","AsyncCallerCallOptions","AbortSignal","AsyncCaller","A","T","Parameters","ReturnType","Awaited"],"sources":["../../src/utils/async_caller.d.ts"],"sourcesContent":["type ResponseCallback = (response?: Response) => Promise<boolean>;\nexport interface AsyncCallerParams {\n    /**\n     * The maximum number of concurrent calls that can be made.\n     * Defaults to `Infinity`, which means no limit.\n     */\n    maxConcurrency?: number;\n    /**\n     * The maximum number of retries that can be made for a single call,\n     * with an exponential backoff between each attempt. Defaults to 6.\n     */\n    maxRetries?: number;\n    onFailedResponseHook?: ResponseCallback;\n    /**\n     * Specify a custom fetch implementation.\n     *\n     * By default we expect the `fetch` is available in the global scope.\n     */\n    fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n}\nexport interface AsyncCallerCallOptions {\n    signal?: AbortSignal;\n}\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 5. This\n * means that by default, each call will be retried up to 5 times, with an\n * exponential backoff between each attempt.\n */\nexport declare class AsyncCaller {\n    protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n    protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n    private queue;\n    private onFailedResponseHook?;\n    private customFetch?;\n    constructor(params: AsyncCallerParams);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;\n}\nexport {};\n"],"mappings":";KAAKA,gBAAAA,eAA+BC,aAAaC;AAA5CF,UACYG,iBAAAA,CADI;EAAA;;;;EACJA,cAAAA,CAAAA,EAAAA,MAAiB;EAAA;;;;EAmBjBE,UAAAA,CAAAA,EAAAA,MAAAA;EAgBIE,oBAAW,CAAA,EAxBLP,gBAwBK;EAAA;;;;;OAQoBE,CAAAA,EAAAA,OA1BjCE,KA0BiCF,GAAAA,CAAAA,CAAAA,GAAAA,IAAAA,EAAAA,GAAAA,EAAAA,EAAAA,GAAAA,GAAAA,CAAAA,CAAAA,CAAAA;;AAA+CO,UAxBlFJ,sBAAAA,CAwBkFI;QAAXC,CAAAA,EAvB3EJ,WAuB2EI;;;;;;;;;;;;;;;AAGnDN,cAXhBG,WAAAA,CAWgBH;YAAlBM,cAAAA,EAVWP,iBAUXO,CAAAA,gBAAAA,CAAAA;YAA6CN,UAAAA,EATtCD,iBASsCC,CAAAA,YAAAA,CAAAA;UAAlBO,KAAAA;;;sBALtBR;;4CAEsBK,MAAMN,wBAAwBO,YAAYC,WAAWD,KAAKP,QAAQU,QAAQD,WAAWF;;uDAE1ED,MAAMN,uBAAuBG,kCAAkCI,YAAYC,WAAWD,KAAKP,QAAQU,QAAQD,WAAWF;iBAC5JC,kBAAkBN,SAASO,kBAAkBP"}

package/dist/utils/async_caller.js

@@ -1,186 +1,110 @@
+import { _getFetchImplementation } from "../singletons/fetch.js";
 import pRetry from "p-retry";
 import PQueueMod from "p-queue";
-import { _getFetchImplementation } from "../singletons/fetch.js";
+
+//#region src/utils/async_caller.ts
 const STATUS_NO_RETRY = [
-    400, // Bad Request
-    401, // Unauthorized
-    402, // Payment required
-    403, // Forbidden
-    404, // Not Found
-    405, // Method Not Allowed
-    406, // Not Acceptable
-    407, // Proxy Authentication Required
-    408, // Request Timeout
-    409, // Conflict
-    422, // Unprocessable Entity
+	400,
+	401,
+	402,
+	403,
+	404,
+	405,
+	406,
+	407,
+	408,
+	409,
+	422
 ];
 /**
- * Do not rely on globalThis.Response, rather just
- * do duck typing
- */
+* Do not rely on globalThis.Response, rather just
+* do duck typing
+*/
 function isResponse(x) {
-    if (x == null || typeof x !== "object")
-        return false;
-    return "status" in x && "statusText" in x && "text" in x;
+	if (x == null || typeof x !== "object") return false;
+	return "status" in x && "statusText" in x && "text" in x;
 }
 /**
- * Utility error to properly handle failed requests
- */
-class HTTPError extends Error {
-    constructor(status, message, response) {
-        super(`HTTP ${status}: ${message}`);
-        Object.defineProperty(this, "status", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "text", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "response", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.status = status;
-        this.text = message;
-        this.response = response;
-    }
-    static async fromResponse(response, options) {
-        try {
-            return new HTTPError(response.status, await response.text(), options?.includeResponse ? response : undefined);
-        }
-        catch {
-            return new HTTPError(response.status, response.statusText, options?.includeResponse ? response : undefined);
-        }
-    }
-}
+* Utility error to properly handle failed requests
+*/
+var HTTPError = class HTTPError extends Error {
+	status;
+	text;
+	response;
+	constructor(status, message, response) {
+		super(`HTTP ${status}: ${message}`);
+		this.status = status;
+		this.text = message;
+		this.response = response;
+	}
+	static async fromResponse(response, options) {
+		try {
+			return new HTTPError(response.status, await response.text(), options?.includeResponse ? response : void 0);
+		} catch {
+			return new HTTPError(response.status, response.statusText, options?.includeResponse ? response : void 0);
+		}
+	}
+};
 /**
- * A class that can be used to make async calls with concurrency and retry logic.
- *
- * This is useful for making calls to any kind of "expensive" external resource,
- * be it because it's rate-limited, subject to network issues, etc.
- *
- * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
- * to `Infinity`. This means that by default, all calls will be made in parallel.
- *
- * Retries are limited by the `maxRetries` parameter, which defaults to 5. This
- * means that by default, each call will be retried up to 5 times, with an
- * exponential backoff between each attempt.
- */
-export class AsyncCaller {
-    constructor(params) {
-        Object.defineProperty(this, "maxConcurrency", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "maxRetries", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "queue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "onFailedResponseHook", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "customFetch", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.maxConcurrency = params.maxConcurrency ?? Infinity;
-        this.maxRetries = params.maxRetries ?? 4;
-        if ("default" in PQueueMod) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.queue = new PQueueMod.default({
-                concurrency: this.maxConcurrency,
-            });
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.queue = new PQueueMod({ concurrency: this.maxConcurrency });
-        }
-        this.onFailedResponseHook = params?.onFailedResponseHook;
-        this.customFetch = params.fetch;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    call(callable, ...args) {
-        const { onFailedResponseHook } = this;
-        return this.queue.add(() => pRetry(() => callable(...args).catch(async (error) => {
-            // eslint-disable-next-line no-instanceof/no-instanceof
-            if (error instanceof Error) {
-                throw error;
-            }
-            else if (isResponse(error)) {
-                throw await HTTPError.fromResponse(error, {
-                    includeResponse: !!onFailedResponseHook,
-                });
-            }
-            else {
-                throw new Error(error);
-            }
-        }), {
-            async onFailedAttempt(error) {
-                if (error.message.startsWith("Cancel") ||
-                    error.message.startsWith("TimeoutError") ||
-                    error.message.startsWith("AbortError")) {
-                    throw error;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                if (error?.code === "ECONNABORTED") {
-                    throw error;
-                }
-                // eslint-disable-next-line no-instanceof/no-instanceof
-                if (error instanceof HTTPError) {
-                    if (STATUS_NO_RETRY.includes(error.status)) {
-                        throw error;
-                    }
-                    if (onFailedResponseHook && error.response) {
-                        await onFailedResponseHook(error.response);
-                    }
-                }
-            },
-            // If needed we can change some of the defaults here,
-            // but they're quite sensible.
-            retries: this.maxRetries,
-            randomize: true,
-        }), { throwOnTimeout: true });
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    callWithOptions(options, callable, ...args) {
-        // Note this doesn't cancel the underlying request,
-        // when available prefer to use the signal option of the underlying call
-        if (options.signal) {
-            return Promise.race([
-                this.call(callable, ...args),
-                new Promise((_, reject) => {
-                    options.signal?.addEventListener("abort", () => {
-                        reject(new Error("AbortError"));
-                    });
-                }),
-            ]);
-        }
-        return this.call(callable, ...args);
-    }
-    fetch(...args) {
-        const fetchFn = this.customFetch ?? _getFetchImplementation();
-        return this.call(() => fetchFn(...args).then((res) => (res.ok ? res : Promise.reject(res))));
-    }
-}
+* A class that can be used to make async calls with concurrency and retry logic.
+*
+* This is useful for making calls to any kind of "expensive" external resource,
+* be it because it's rate-limited, subject to network issues, etc.
+*
+* Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
+* to `Infinity`. This means that by default, all calls will be made in parallel.
+*
+* Retries are limited by the `maxRetries` parameter, which defaults to 5. This
+* means that by default, each call will be retried up to 5 times, with an
+* exponential backoff between each attempt.
+*/
+var AsyncCaller = class {
+	maxConcurrency;
+	maxRetries;
+	queue;
+	onFailedResponseHook;
+	customFetch;
+	constructor(params) {
+		this.maxConcurrency = params.maxConcurrency ?? Infinity;
+		this.maxRetries = params.maxRetries ?? 4;
+		if ("default" in PQueueMod) this.queue = new PQueueMod.default({ concurrency: this.maxConcurrency });
+		else this.queue = new PQueueMod({ concurrency: this.maxConcurrency });
+		this.onFailedResponseHook = params?.onFailedResponseHook;
+		this.customFetch = params.fetch;
+	}
+	call(callable, ...args) {
+		const { onFailedResponseHook } = this;
+		return this.queue.add(() => pRetry(() => callable(...args).catch(async (error) => {
+			if (error instanceof Error) throw error;
+			else if (isResponse(error)) throw await HTTPError.fromResponse(error, { includeResponse: !!onFailedResponseHook });
+			else throw new Error(error);
+		}), {
+			async onFailedAttempt(error) {
+				if (error.message.startsWith("Cancel") || error.message.startsWith("TimeoutError") || error.message.startsWith("AbortError")) throw error;
+				if (error?.code === "ECONNABORTED") throw error;
+				if (error instanceof HTTPError) {
+					if (STATUS_NO_RETRY.includes(error.status)) throw error;
+					if (onFailedResponseHook && error.response) await onFailedResponseHook(error.response);
+				}
+			},
+			retries: this.maxRetries,
+			randomize: true
+		}), { throwOnTimeout: true });
+	}
+	callWithOptions(options, callable, ...args) {
+		if (options.signal) return Promise.race([this.call(callable, ...args), new Promise((_, reject) => {
+			options.signal?.addEventListener("abort", () => {
+				reject(/* @__PURE__ */ new Error("AbortError"));
+			});
+		})]);
+		return this.call(callable, ...args);
+	}
+	fetch(...args) {
+		const fetchFn = this.customFetch ?? _getFetchImplementation();
+		return this.call(() => fetchFn(...args).then((res) => res.ok ? res : Promise.reject(res)));
+	}
+};
+
+//#endregion
+export { AsyncCaller };
+//# sourceMappingURL=async_caller.js.map

package/dist/utils/async_caller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async_caller.js","names":[],"sources":["../../src/utils/async_caller.ts"],"sourcesContent":["import pRetry from \"p-retry\";\nimport PQueueMod from \"p-queue\";\nimport { _getFetchImplementation } from \"../singletons/fetch.js\";\n\nconst STATUS_NO_RETRY = [\n  400, // Bad Request\n  401, // Unauthorized\n  402, // Payment required\n  403, // Forbidden\n  404, // Not Found\n  405, // Method Not Allowed\n  406, // Not Acceptable\n  407, // Proxy Authentication Required\n  408, // Request Timeout\n  409, // Conflict\n  422, // Unprocessable Entity\n];\n\ntype ResponseCallback = (response?: Response) => Promise<boolean>;\n\nexport interface AsyncCallerParams {\n  /**\n   * The maximum number of concurrent calls that can be made.\n   * Defaults to `Infinity`, which means no limit.\n   */\n  maxConcurrency?: number;\n  /**\n   * The maximum number of retries that can be made for a single call,\n   * with an exponential backoff between each attempt. Defaults to 6.\n   */\n  maxRetries?: number;\n\n  onFailedResponseHook?: ResponseCallback;\n\n  /**\n   * Specify a custom fetch implementation.\n   *\n   * By default we expect the `fetch` is available in the global scope.\n   */\n  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n}\n\nexport interface AsyncCallerCallOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Do not rely on globalThis.Response, rather just\n * do duck typing\n */\nfunction isResponse(x: unknown): x is Response {\n  if (x == null || typeof x !== \"object\") return false;\n  return \"status\" in x && \"statusText\" in x && \"text\" in x;\n}\n\n/**\n * Utility error to properly handle failed requests\n */\nclass HTTPError extends Error {\n  status: number;\n\n  text: string;\n\n  response?: Response;\n\n  constructor(status: number, message: string, response?: Response) {\n    super(`HTTP ${status}: ${message}`);\n    this.status = status;\n    this.text = message;\n    this.response = response;\n  }\n\n  static async fromResponse(\n    response: Response,\n    options?: { includeResponse?: boolean }\n  ): Promise<HTTPError> {\n    try {\n      return new HTTPError(\n        response.status,\n        await response.text(),\n        options?.includeResponse ? response : undefined\n      );\n    } catch {\n      return new HTTPError(\n        response.status,\n        response.statusText,\n        options?.includeResponse ? response : undefined\n      );\n    }\n  }\n}\n\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 5. This\n * means that by default, each call will be retried up to 5 times, with an\n * exponential backoff between each attempt.\n */\nexport class AsyncCaller {\n  protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n\n  protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n\n  private queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n  private onFailedResponseHook?: ResponseCallback;\n\n  private customFetch?: typeof fetch;\n\n  constructor(params: AsyncCallerParams) {\n    this.maxConcurrency = params.maxConcurrency ?? Infinity;\n    this.maxRetries = params.maxRetries ?? 4;\n\n    if (\"default\" in PQueueMod) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this.queue = new (PQueueMod.default as any)({\n        concurrency: this.maxConcurrency,\n      });\n    } else {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this.queue = new (PQueueMod as any)({ concurrency: this.maxConcurrency });\n    }\n    this.onFailedResponseHook = params?.onFailedResponseHook;\n    this.customFetch = params.fetch;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  call<A extends any[], T extends (...args: A) => Promise<any>>(\n    callable: T,\n    ...args: Parameters<T>\n  ): Promise<Awaited<ReturnType<T>>> {\n    const { onFailedResponseHook } = this;\n    return this.queue.add(\n      () =>\n        pRetry(\n          () =>\n            callable(...(args as Parameters<T>)).catch(async (error) => {\n              // eslint-disable-next-line no-instanceof/no-instanceof\n              if (error instanceof Error) {\n                throw error;\n              } else if (isResponse(error)) {\n                throw await HTTPError.fromResponse(error, {\n                  includeResponse: !!onFailedResponseHook,\n                });\n              } else {\n                throw new Error(error);\n              }\n            }),\n          {\n            async onFailedAttempt(error) {\n              if (\n                error.message.startsWith(\"Cancel\") ||\n                error.message.startsWith(\"TimeoutError\") ||\n                error.message.startsWith(\"AbortError\")\n              ) {\n                throw error;\n              }\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              if ((error as any)?.code === \"ECONNABORTED\") {\n                throw error;\n              }\n\n              // eslint-disable-next-line no-instanceof/no-instanceof\n              if (error instanceof HTTPError) {\n                if (STATUS_NO_RETRY.includes(error.status)) {\n                  throw error;\n                }\n                if (onFailedResponseHook && error.response) {\n                  await onFailedResponseHook(error.response);\n                }\n              }\n            },\n            // If needed we can change some of the defaults here,\n            // but they're quite sensible.\n            retries: this.maxRetries,\n            randomize: true,\n          }\n        ),\n      { throwOnTimeout: true }\n    );\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(\n    options: AsyncCallerCallOptions,\n    callable: T,\n    ...args: Parameters<T>\n  ): Promise<Awaited<ReturnType<T>>> {\n    // Note this doesn't cancel the underlying request,\n    // when available prefer to use the signal option of the underlying call\n    if (options.signal) {\n      return Promise.race([\n        this.call<A, T>(callable, ...args),\n        new Promise<never>((_, reject) => {\n          options.signal?.addEventListener(\"abort\", () => {\n            reject(new Error(\"AbortError\"));\n          });\n        }),\n      ]);\n    }\n    return this.call<A, T>(callable, ...args);\n  }\n\n  fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch> {\n    const fetchFn =\n      this.customFetch ?? (_getFetchImplementation() as typeof fetch);\n    return this.call(() =>\n      fetchFn(...args).then((res) => (res.ok ? res : Promise.reject(res)))\n    );\n  }\n}\n"],"mappings":";;;;;AAIA,MAAM,kBAAkB;CACtB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;;;;;;AAmCF,SAAS,WAAW,GAA2B;AAC7C,KAAI,KAAK,QAAQ,OAAO,MAAM,SAAU,QAAO;AAC/C,QAAO,YAAY,KAAK,gBAAgB,KAAK,UAAU;;;;;AAMzD,IAAM,YAAN,MAAM,kBAAkB,MAAM;CAC5B;CAEA;CAEA;CAEA,YAAY,QAAgB,SAAiB,UAAqB;AAChE,QAAM,QAAQ,OAAO,IAAI;AACzB,OAAK,SAAS;AACd,OAAK,OAAO;AACZ,OAAK,WAAW;;CAGlB,aAAa,aACX,UACA,SACoB;AACpB,MAAI;AACF,UAAO,IAAI,UACT,SAAS,QACT,MAAM,SAAS,QACf,SAAS,kBAAkB,WAAW;UAElC;AACN,UAAO,IAAI,UACT,SAAS,QACT,SAAS,YACT,SAAS,kBAAkB,WAAW;;;;;;;;;;;;;;;;;AAmB9C,IAAa,cAAb,MAAyB;CACvB,AAAU;CAEV,AAAU;CAEV,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,YAAY,QAA2B;AACrC,OAAK,iBAAiB,OAAO,kBAAkB;AAC/C,OAAK,aAAa,OAAO,cAAc;AAEvC,MAAI,aAAa,UAEf,MAAK,QAAQ,IAAK,UAAU,QAAgB,EAC1C,aAAa,KAAK;MAIpB,MAAK,QAAQ,IAAK,UAAkB,EAAE,aAAa,KAAK;AAE1D,OAAK,uBAAuB,QAAQ;AACpC,OAAK,cAAc,OAAO;;CAI5B,KACE,UACA,GAAG,MAC8B;EACjC,MAAM,EAAE,yBAAyB;AACjC,SAAO,KAAK,MAAM,UAEd,aAEI,SAAS,GAAI,MAAwB,MAAM,OAAO,UAAU;AAE1D,OAAI,iBAAiB,MACnB,OAAM;YACG,WAAW,OACpB,OAAM,MAAM,UAAU,aAAa,OAAO,EACxC,iBAAiB,CAAC,CAAC;OAGrB,OAAM,IAAI,MAAM;MAGtB;GACE,MAAM,gBAAgB,OAAO;AAC3B,QACE,MAAM,QAAQ,WAAW,aACzB,MAAM,QAAQ,WAAW,mBACzB,MAAM,QAAQ,WAAW,cAEzB,OAAM;AAGR,QAAK,OAAe,SAAS,eAC3B,OAAM;AAIR,QAAI,iBAAiB,WAAW;AAC9B,SAAI,gBAAgB,SAAS,MAAM,QACjC,OAAM;AAER,SAAI,wBAAwB,MAAM,SAChC,OAAM,qBAAqB,MAAM;;;GAMvC,SAAS,KAAK;GACd,WAAW;MAGjB,EAAE,gBAAgB;;CAKtB,gBACE,SACA,UACA,GAAG,MAC8B;AAGjC,MAAI,QAAQ,OACV,QAAO,QAAQ,KAAK,CAClB,KAAK,KAAW,UAAU,GAAG,OAC7B,IAAI,SAAgB,GAAG,WAAW;AAChC,WAAQ,QAAQ,iBAAiB,eAAe;AAC9C,2BAAO,IAAI,MAAM;;;AAKzB,SAAO,KAAK,KAAW,UAAU,GAAG;;CAGtC,MAAM,GAAG,MAA0D;EACjE,MAAM,UACJ,KAAK,eAAgB;AACvB,SAAO,KAAK,WACV,QAAQ,GAAG,MAAM,MAAM,QAAS,IAAI,KAAK,MAAM,QAAQ,OAAO"}

package/dist/utils/env.cjs

@@ -1,15 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnvironmentVariable = getEnvironmentVariable;
+
+//#region src/utils/env.ts
 function getEnvironmentVariable(name) {
-    // Certain setups (Deno, frontend) will throw an error if you try to access environment variables
-    try {
-        return typeof process !== "undefined"
-            ? // eslint-disable-next-line no-process-env
-                process.env?.[name]
-            : undefined;
-    }
-    catch (e) {
-        return undefined;
-    }
+	try {
+		return typeof process !== "undefined" ? process.env?.[name] : void 0;
+	} catch (e) {
+		return void 0;
+	}
 }
+
+//#endregion
+exports.getEnvironmentVariable = getEnvironmentVariable;
+//# sourceMappingURL=env.cjs.map

package/dist/utils/env.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.cjs","names":[],"sources":["../../src/utils/env.ts"],"sourcesContent":["export function getEnvironmentVariable(name: string): string | undefined {\n  // Certain setups (Deno, frontend) will throw an error if you try to access environment variables\n  try {\n    return typeof process !== \"undefined\"\n      ? // eslint-disable-next-line no-process-env\n        process.env?.[name]\n      : undefined;\n  } catch (e) {\n    return undefined;\n  }\n}\n"],"mappings":";;AAAA,SAAgB,uBAAuB,MAAkC;AAEvE,KAAI;AACF,SAAO,OAAO,YAAY,cAEtB,QAAQ,MAAM,QACd;UACG,GAAG;AACV,SAAO"}

package/dist/utils/env.js

@@ -1,12 +1,12 @@
-export function getEnvironmentVariable(name) {
-    // Certain setups (Deno, frontend) will throw an error if you try to access environment variables
-    try {
-        return typeof process !== "undefined"
-            ? // eslint-disable-next-line no-process-env
-                process.env?.[name]
-            : undefined;
-    }
-    catch (e) {
-        return undefined;
-    }
+//#region src/utils/env.ts
+function getEnvironmentVariable(name) {
+	try {
+		return typeof process !== "undefined" ? process.env?.[name] : void 0;
+	} catch (e) {
+		return void 0;
+	}
 }
+
+//#endregion
+export { getEnvironmentVariable };
+//# sourceMappingURL=env.js.map

package/dist/utils/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","names":[],"sources":["../../src/utils/env.ts"],"sourcesContent":["export function getEnvironmentVariable(name: string): string | undefined {\n  // Certain setups (Deno, frontend) will throw an error if you try to access environment variables\n  try {\n    return typeof process !== \"undefined\"\n      ? // eslint-disable-next-line no-process-env\n        process.env?.[name]\n      : undefined;\n  } catch (e) {\n    return undefined;\n  }\n}\n"],"mappings":";AAAA,SAAgB,uBAAuB,MAAkC;AAEvE,KAAI;AACF,SAAO,OAAO,YAAY,cAEtB,QAAQ,MAAM,QACd;UACG,GAAG;AACV,SAAO"}

package/dist/utils/signals.cjs

@@ -1,21 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeSignals = mergeSignals;
+
+//#region src/utils/signals.ts
 function mergeSignals(...signals) {
-    const nonZeroSignals = signals.filter((signal) => signal != null);
-    if (nonZeroSignals.length === 0)
-        return undefined;
-    if (nonZeroSignals.length === 1)
-        return nonZeroSignals[0];
-    const controller = new AbortController();
-    for (const signal of signals) {
-        if (signal?.aborted) {
-            controller.abort(signal.reason);
-            return controller.signal;
-        }
-        signal?.addEventListener("abort", () => controller.abort(signal.reason), {
-            once: true,
-        });
-    }
-    return controller.signal;
+	const nonZeroSignals = signals.filter((signal) => signal != null);
+	if (nonZeroSignals.length === 0) return void 0;
+	if (nonZeroSignals.length === 1) return nonZeroSignals[0];
+	const controller = new AbortController();
+	for (const signal of signals) {
+		if (signal?.aborted) {
+			controller.abort(signal.reason);
+			return controller.signal;
+		}
+		signal?.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+	}
+	return controller.signal;
 }
+
+//#endregion
+exports.mergeSignals = mergeSignals;
+//# sourceMappingURL=signals.cjs.map

package/dist/utils/signals.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.cjs","names":[],"sources":["../../src/utils/signals.ts"],"sourcesContent":["export function mergeSignals(...signals: (AbortSignal | null | undefined)[]) {\n  const nonZeroSignals = signals.filter(\n    (signal): signal is AbortSignal => signal != null\n  );\n\n  if (nonZeroSignals.length === 0) return undefined;\n  if (nonZeroSignals.length === 1) return nonZeroSignals[0];\n\n  const controller = new AbortController();\n  for (const signal of signals) {\n    if (signal?.aborted) {\n      controller.abort(signal.reason);\n      return controller.signal;\n    }\n\n    signal?.addEventListener(\"abort\", () => controller.abort(signal.reason), {\n      once: true,\n    });\n  }\n\n  return controller.signal;\n}\n"],"mappings":";;AAAA,SAAgB,aAAa,GAAG,SAA6C;CAC3E,MAAM,iBAAiB,QAAQ,QAC5B,WAAkC,UAAU;AAG/C,KAAI,eAAe,WAAW,EAAG,QAAO;AACxC,KAAI,eAAe,WAAW,EAAG,QAAO,eAAe;CAEvD,MAAM,aAAa,IAAI;AACvB,MAAK,MAAM,UAAU,SAAS;AAC5B,MAAI,QAAQ,SAAS;AACnB,cAAW,MAAM,OAAO;AACxB,UAAO,WAAW;;AAGpB,UAAQ,iBAAiB,eAAe,WAAW,MAAM,OAAO,SAAS,EACvE,MAAM;;AAIV,QAAO,WAAW"}

package/dist/utils/signals.js

@@ -1,18 +1,19 @@
-export function mergeSignals(...signals) {
-    const nonZeroSignals = signals.filter((signal) => signal != null);
-    if (nonZeroSignals.length === 0)
-        return undefined;
-    if (nonZeroSignals.length === 1)
-        return nonZeroSignals[0];
-    const controller = new AbortController();
-    for (const signal of signals) {
-        if (signal?.aborted) {
-            controller.abort(signal.reason);
-            return controller.signal;
-        }
-        signal?.addEventListener("abort", () => controller.abort(signal.reason), {
-            once: true,
-        });
-    }
-    return controller.signal;
+//#region src/utils/signals.ts
+function mergeSignals(...signals) {
+	const nonZeroSignals = signals.filter((signal) => signal != null);
+	if (nonZeroSignals.length === 0) return void 0;
+	if (nonZeroSignals.length === 1) return nonZeroSignals[0];
+	const controller = new AbortController();
+	for (const signal of signals) {
+		if (signal?.aborted) {
+			controller.abort(signal.reason);
+			return controller.signal;
+		}
+		signal?.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+	}
+	return controller.signal;
 }
+
+//#endregion
+export { mergeSignals };
+//# sourceMappingURL=signals.js.map

package/dist/utils/signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.js","names":[],"sources":["../../src/utils/signals.ts"],"sourcesContent":["export function mergeSignals(...signals: (AbortSignal | null | undefined)[]) {\n  const nonZeroSignals = signals.filter(\n    (signal): signal is AbortSignal => signal != null\n  );\n\n  if (nonZeroSignals.length === 0) return undefined;\n  if (nonZeroSignals.length === 1) return nonZeroSignals[0];\n\n  const controller = new AbortController();\n  for (const signal of signals) {\n    if (signal?.aborted) {\n      controller.abort(signal.reason);\n      return controller.signal;\n    }\n\n    signal?.addEventListener(\"abort\", () => controller.abort(signal.reason), {\n      once: true,\n    });\n  }\n\n  return controller.signal;\n}\n"],"mappings":";AAAA,SAAgB,aAAa,GAAG,SAA6C;CAC3E,MAAM,iBAAiB,QAAQ,QAC5B,WAAkC,UAAU;AAG/C,KAAI,eAAe,WAAW,EAAG,QAAO;AACxC,KAAI,eAAe,WAAW,EAAG,QAAO,eAAe;CAEvD,MAAM,aAAa,IAAI;AACvB,MAAK,MAAM,UAAU,SAAS;AAC5B,MAAI,QAAQ,SAAS;AACnB,cAAW,MAAM,OAAO;AACxB,UAAO,WAAW;;AAGpB,UAAQ,iBAAiB,eAAe,WAAW,MAAM,OAAO,SAAS,EACvE,MAAM;;AAIV,QAAO,WAAW"}