@zayne-labs/callapi 1.11.12 → 1.11.15

package/dist/esm/index.js

@@ -1,270 +1,7 @@
 import { n as requestOptionDefaults, r as defineEnum, t as extraOptionDefaults } from "./defaults-BD3B1uIH.js";
-import { _ as isReadableStream, b as isValidJsonString, c as HTTPError, d as isBoolean, f as isFunction, g as isQueryString, h as isPromise, i as isHTTPErrorInstance, l as ValidationError, m as isPlainObject, n as toQueryString, p as isObject, s as isValidationErrorInstance, u as isArray, v as isSerializable, y as isString } from "./body-B9WKokQt.js";
+import { _ as isReadableStream, a as isValidationErrorInstance, b as isValidJsonString, d as isBoolean, f as isFunction, g as isQueryString, h as isPromise, l as toQueryString, m as isPlainObject, n as isHTTPErrorInstance, o as HTTPError, p as isObject, s as ValidationError, u as isArray, v as isSerializable, y as isString } from "./guards-ClpaRdJN.js";
 import { n as fetchSpecificKeys, t as fallBackRouteSchemaKey } from "./validation-MjkoG9bG.js";
 
-//#region src/result.ts
-const getResponseType = (response, parser) => ({
-	arrayBuffer: () => response.arrayBuffer(),
-	blob: () => response.blob(),
-	formData: () => response.formData(),
-	json: async () => {
-		return parser(await response.text());
-	},
-	stream: () => response.body,
-	text: () => response.text()
-});
-const textTypes = new Set([
-	"image/svg",
-	"application/xml",
-	"application/xhtml",
-	"application/html"
-]);
-const JSON_REGEX = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
-const detectResponseType = (response) => {
-	const initContentType = response.headers.get("content-type");
-	if (!initContentType) return extraOptionDefaults.responseType;
-	const contentType = initContentType.split(";")[0] ?? "";
-	if (JSON_REGEX.test(contentType)) return "json";
-	if (textTypes.has(contentType) || contentType.startsWith("text/")) return "text";
-	return "blob";
-};
-const resolveResponseData = (response, responseType, parser) => {
-	const selectedParser = parser ?? extraOptionDefaults.responseParser;
-	const selectedResponseType = responseType ?? detectResponseType(response);
-	const RESPONSE_TYPE_LOOKUP = getResponseType(response, selectedParser);
-	if (!Object.hasOwn(RESPONSE_TYPE_LOOKUP, selectedResponseType)) throw new Error(`Invalid response type: ${responseType}`);
-	return RESPONSE_TYPE_LOOKUP[selectedResponseType]();
-};
-const getResultModeMap = (details) => {
-	return {
-		all: () => details,
-		onlyData: () => details.data,
-		onlyResponse: () => details.response
-	};
-};
-const resolveSuccessResult = (data, info) => {
-	const { response, resultMode } = info;
-	return getResultModeMap({
-		data,
-		error: null,
-		response
-	})[resultMode ?? "all"]();
-};
-const resolveErrorResult = (error, info) => {
-	const { cloneResponse, message: customErrorMessage, resultMode } = info;
-	let errorDetails = {
-		data: null,
-		error: {
-			errorData: false,
-			message: customErrorMessage ?? error.message,
-			name: error.name,
-			originalError: error
-		},
-		response: null
-	};
-	if (isValidationErrorInstance(error)) {
-		const { errorData, message, response } = error;
-		errorDetails = {
-			data: null,
-			error: {
-				errorData,
-				issueCause: error.issueCause,
-				message,
-				name: "ValidationError",
-				originalError: error
-			},
-			response
-		};
-	}
-	if (isHTTPErrorInstance(error)) {
-		const { errorData, message, name, response } = error;
-		errorDetails = {
-			data: null,
-			error: {
-				errorData,
-				message,
-				name,
-				originalError: error
-			},
-			response: cloneResponse ? response.clone() : response
-		};
-	}
-	const errorResult = getResultModeMap(errorDetails)[resultMode ?? "all"]();
-	return {
-		errorDetails,
-		errorResult
-	};
-};
-const getCustomizedErrorResult = (errorResult, customErrorInfo) => {
-	if (!errorResult) return null;
-	const { message = errorResult.error.message } = customErrorInfo;
-	return {
-		...errorResult,
-		error: {
-			...errorResult.error,
-			message
-		}
-	};
-};
-
-//#endregion
-//#region src/hooks.ts
-const getHookRegistriesAndKeys = () => {
-	const hookRegistries = {
-		onError: /* @__PURE__ */ new Set(),
-		onRequest: /* @__PURE__ */ new Set(),
-		onRequestError: /* @__PURE__ */ new Set(),
-		onRequestReady: /* @__PURE__ */ new Set(),
-		onRequestStream: /* @__PURE__ */ new Set(),
-		onResponse: /* @__PURE__ */ new Set(),
-		onResponseError: /* @__PURE__ */ new Set(),
-		onResponseStream: /* @__PURE__ */ new Set(),
-		onRetry: /* @__PURE__ */ new Set(),
-		onSuccess: /* @__PURE__ */ new Set(),
-		onValidationError: /* @__PURE__ */ new Set()
-	};
-	return {
-		hookRegistries,
-		hookRegistryKeys: Object.keys(hookRegistries)
-	};
-};
-const composeHooksFromArray = (hooksArray, hooksExecutionMode) => {
-	const composedHook = async (ctx) => {
-		switch (hooksExecutionMode) {
-			case "parallel":
-				await Promise.all(hooksArray.map((uniqueHook) => uniqueHook?.(ctx)));
-				break;
-			case "sequential":
-				for (const hook of hooksArray) await hook?.(ctx);
-				break;
-			default:
-		}
-	};
-	return composedHook;
-};
-const executeHooks = async (...hookResultsOrPromise) => {
-	await Promise.all(hookResultsOrPromise);
-};
-const executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
-	const { errorInfo, shouldThrowOnError } = hookInfo;
-	try {
-		await Promise.all(hookResultsOrPromise);
-		return null;
-	} catch (hookError) {
-		if (shouldThrowOnError) throw hookError;
-		const { errorResult } = resolveErrorResult(hookError, errorInfo);
-		return errorResult;
-	}
-};
-
-//#endregion
-//#region src/stream.ts
-const createProgressEvent = (options) => {
-	const { chunk, totalBytes, transferredBytes } = options;
-	return {
-		chunk,
-		progress: Math.round(transferredBytes / totalBytes * 100) || 0,
-		totalBytes,
-		transferredBytes
-	};
-};
-const calculateTotalBytesFromBody = async (requestBody, existingTotalBytes) => {
-	let totalBytes = existingTotalBytes;
-	if (!requestBody) return totalBytes;
-	for await (const chunk of requestBody) totalBytes += chunk.byteLength;
-	return totalBytes;
-};
-const toStreamableRequest = async (context) => {
-	const { baseConfig, config, options, request } = context;
-	if (!options.onRequestStream || !isReadableStream(request.body)) return request;
-	const requestInstance = new Request(options.fullURL, {
-		...request,
-		duplex: "half"
-	});
-	const contentLength = requestInstance.headers.get("content-length");
-	let totalBytes = Number(contentLength ?? 0);
-	const shouldForcefullyCalcStreamSize = isObject(options.forcefullyCalculateStreamSize) ? options.forcefullyCalculateStreamSize.request : options.forcefullyCalculateStreamSize;
-	if (!contentLength && shouldForcefullyCalcStreamSize) totalBytes = await calculateTotalBytesFromBody(requestInstance.clone().body, totalBytes);
-	let transferredBytes = 0;
-	const stream = new ReadableStream({ start: async (controller) => {
-		const body = requestInstance.body;
-		if (!body) return;
-		const requestStreamContext = {
-			baseConfig,
-			config,
-			event: createProgressEvent({
-				chunk: new Uint8Array(),
-				totalBytes,
-				transferredBytes
-			}),
-			options,
-			request,
-			requestInstance
-		};
-		await executeHooks(options.onRequestStream?.(requestStreamContext));
-		for await (const chunk of body) {
-			transferredBytes += chunk.byteLength;
-			totalBytes = Math.max(totalBytes, transferredBytes);
-			await executeHooks(options.onRequestStream?.({
-				...requestStreamContext,
-				event: createProgressEvent({
-					chunk,
-					totalBytes,
-					transferredBytes
-				})
-			}));
-			controller.enqueue(chunk);
-		}
-		controller.close();
-	} });
-	return new Request(requestInstance, {
-		body: stream,
-		duplex: "half"
-	});
-};
-const toStreamableResponse = async (context) => {
-	const { baseConfig, config, options, request, response } = context;
-	if (!options.onResponseStream || !response.body) return response;
-	const contentLength = response.headers.get("content-length");
-	let totalBytes = Number(contentLength ?? 0);
-	const shouldForceContentLengthCalc = isObject(options.forcefullyCalculateStreamSize) ? options.forcefullyCalculateStreamSize.response : options.forcefullyCalculateStreamSize;
-	if (!contentLength && shouldForceContentLengthCalc) totalBytes = await calculateTotalBytesFromBody(response.clone().body, totalBytes);
-	let transferredBytes = 0;
-	const stream = new ReadableStream({ start: async (controller) => {
-		const body = response.body;
-		if (!body) return;
-		const responseStreamContext = {
-			baseConfig,
-			config,
-			event: createProgressEvent({
-				chunk: new Uint8Array(),
-				totalBytes,
-				transferredBytes
-			}),
-			options,
-			request,
-			response
-		};
-		await executeHooks(options.onResponseStream?.(responseStreamContext));
-		for await (const chunk of body) {
-			transferredBytes += chunk.byteLength;
-			totalBytes = Math.max(totalBytes, transferredBytes);
-			await executeHooks(options.onResponseStream?.({
-				...responseStreamContext,
-				event: createProgressEvent({
-					chunk,
-					totalBytes,
-					transferredBytes
-				})
-			}));
-			controller.enqueue(chunk);
-		}
-		controller.close();
-	} });
-	return new Response(stream, response);
-};
-
-//#endregion
 //#region src/auth.ts
 const resolveAuthValue = (value) => isFunction(value) ? value() : value;
 const getAuthHeader = async (auth) => {
@@ -533,122 +270,386 @@ const getFullAndNormalizedURL = (options) => {
 	const normalizedInitURL = normalizeURL(initURL);
 	const urlWithMergedQueryAndParams = mergeUrlWithQuery(mergeUrlWithParams(normalizedInitURL, params), query);
 	return {
-		fullURL: !urlWithMergedQueryAndParams.startsWith("http") && baseURL ? `${baseURL}${urlWithMergedQueryAndParams}` : urlWithMergedQueryAndParams,
-		normalizedInitURL
+		fullURL: !urlWithMergedQueryAndParams.startsWith("http") && baseURL ? `${baseURL}${urlWithMergedQueryAndParams}` : urlWithMergedQueryAndParams,
+		normalizedInitURL
+	};
+};
+
+//#endregion
+//#region src/utils/polyfills/combinedSignal.ts
+const createCombinedSignalPolyfill = (signals) => {
+	const controller = new AbortController();
+	const handleAbort = (actualSignal) => {
+		if (controller.signal.aborted) return;
+		controller.abort(actualSignal.reason);
+	};
+	for (const actualSignal of signals) {
+		if (actualSignal.aborted) {
+			handleAbort(actualSignal);
+			break;
+		}
+		actualSignal.addEventListener("abort", () => handleAbort(actualSignal), { signal: controller.signal });
+	}
+	return controller.signal;
+};
+
+//#endregion
+//#region src/utils/polyfills/timeoutSignal.ts
+const createTimeoutSignalPolyfill = (milliseconds) => {
+	const controller = new AbortController();
+	const reason = new DOMException("Request timed out", "TimeoutError");
+	const timeout = setTimeout(() => controller.abort(reason), milliseconds);
+	controller.signal.addEventListener("abort", () => clearTimeout(timeout));
+	return controller.signal;
+};
+
+//#endregion
+//#region src/utils/common.ts
+const omitKeys = (initialObject, keysToOmit) => {
+	const updatedObject = {};
+	const keysToOmitSet = new Set(keysToOmit);
+	for (const [key, value] of Object.entries(initialObject)) if (!keysToOmitSet.has(key)) updatedObject[key] = value;
+	return updatedObject;
+};
+const pickKeys = (initialObject, keysToPick) => {
+	const updatedObject = {};
+	const keysToPickSet = new Set(keysToPick);
+	for (const [key, value] of Object.entries(initialObject)) if (keysToPickSet.has(key)) updatedObject[key] = value;
+	return updatedObject;
+};
+const splitBaseConfig = (baseConfig) => [pickKeys(baseConfig, fetchSpecificKeys), omitKeys(baseConfig, fetchSpecificKeys)];
+const splitConfig = (config) => [pickKeys(config, fetchSpecificKeys), omitKeys(config, fetchSpecificKeys)];
+const objectifyHeaders = (headers) => {
+	if (!headers || isPlainObject(headers)) return headers;
+	return Object.fromEntries(headers);
+};
+const getHeaders = async (options) => {
+	const { auth, body, headers } = options;
+	if (!(Boolean(headers) || Boolean(body) || Boolean(auth))) return;
+	const headersObject = {
+		...await getAuthHeader(auth),
+		...objectifyHeaders(headers)
+	};
+	if (isQueryString(body)) {
+		headersObject["Content-Type"] = "application/x-www-form-urlencoded";
+		return headersObject;
+	}
+	if (isSerializable(body) || isValidJsonString(body)) {
+		headersObject["Content-Type"] = "application/json";
+		headersObject.Accept = "application/json";
+	}
+	return headersObject;
+};
+const getMethod = (ctx) => {
+	const { initURL, method } = ctx;
+	return method?.toUpperCase() ?? extractMethodFromURL(initURL)?.toUpperCase() ?? requestOptionDefaults.method;
+};
+const getBody = (options) => {
+	const { body, bodySerializer } = options;
+	if (isSerializable(body)) return (bodySerializer ?? extraOptionDefaults.bodySerializer)(body);
+	return body;
+};
+const getInitFetchImpl = (customFetchImpl) => {
+	if (customFetchImpl) return customFetchImpl;
+	if (typeof globalThis !== "undefined" && isFunction(globalThis.fetch)) return globalThis.fetch;
+	throw new Error("No fetch implementation found");
+};
+const getFetchImpl = (context) => {
+	const { customFetchImpl, fetchMiddleware, requestContext } = context;
+	const initFetchImpl = getInitFetchImpl(customFetchImpl);
+	return fetchMiddleware ? fetchMiddleware({
+		...requestContext,
+		fetchImpl: initFetchImpl
+	}) : initFetchImpl;
+};
+const waitFor = (delay) => {
+	if (delay === 0) return;
+	return new Promise((resolve) => setTimeout(resolve, delay));
+};
+const createCombinedSignal = (...signals) => {
+	const cleanedSignals = signals.filter((signal) => signal != null);
+	if (!("any" in AbortSignal)) return createCombinedSignalPolyfill(cleanedSignals);
+	return AbortSignal.any(cleanedSignals);
+};
+const createTimeoutSignal = (milliseconds) => {
+	if (milliseconds == null) return null;
+	if (!("timeout" in AbortSignal)) return createTimeoutSignalPolyfill(milliseconds);
+	return AbortSignal.timeout(milliseconds);
+};
+const deterministicHashFn = (value) => {
+	return JSON.stringify(value, (_, val) => {
+		if (!isPlainObject(val)) return val;
+		const sortedKeys = Object.keys(val).toSorted();
+		const result = {};
+		for (const key of sortedKeys) result[key] = val[key];
+		return result;
+	});
+};
+const toArray = (value) => isArray(value) ? value : [value];
+
+//#endregion
+//#region src/result.ts
+const getResponseType = (response, parser) => ({
+	arrayBuffer: () => response.arrayBuffer(),
+	blob: () => response.blob(),
+	formData: () => response.formData(),
+	json: async () => {
+		return parser(await response.text());
+	},
+	stream: () => response.body,
+	text: () => response.text()
+});
+const textTypes = new Set([
+	"image/svg",
+	"application/xml",
+	"application/xhtml",
+	"application/html"
+]);
+const JSON_REGEX = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
+const detectResponseType = (response) => {
+	const initContentType = response.headers.get("content-type");
+	if (!initContentType) return extraOptionDefaults.responseType;
+	const contentType = initContentType.split(";")[0] ?? "";
+	if (JSON_REGEX.test(contentType)) return "json";
+	if (textTypes.has(contentType) || contentType.startsWith("text/")) return "text";
+	return "blob";
+};
+const resolveResponseData = (response, responseType, parser) => {
+	const selectedParser = parser ?? extraOptionDefaults.responseParser;
+	const selectedResponseType = responseType ?? detectResponseType(response);
+	const RESPONSE_TYPE_LOOKUP = getResponseType(response, selectedParser);
+	if (!Object.hasOwn(RESPONSE_TYPE_LOOKUP, selectedResponseType)) throw new Error(`Invalid response type: ${responseType}`);
+	return RESPONSE_TYPE_LOOKUP[selectedResponseType]();
+};
+const getResultModeMap = (details) => {
+	return {
+		all: () => details,
+		onlyData: () => details.data,
+		onlyResponse: () => details.response,
+		withoutResponse: () => omitKeys(details, ["response"])
+	};
+};
+const resolveSuccessResult = (data, info) => {
+	const { response, resultMode } = info;
+	return getResultModeMap({
+		data,
+		error: null,
+		response
+	})[resultMode ?? "all"]();
+};
+const resolveErrorResult = (error, info) => {
+	const { cloneResponse, message: customErrorMessage, resultMode } = info;
+	let errorDetails = {
+		data: null,
+		error: {
+			errorData: false,
+			message: customErrorMessage ?? error.message,
+			name: error.name,
+			originalError: error
+		},
+		response: null
+	};
+	if (isValidationErrorInstance(error)) {
+		const { errorData, message, response } = error;
+		errorDetails = {
+			data: null,
+			error: {
+				errorData,
+				issueCause: error.issueCause,
+				message,
+				name: "ValidationError",
+				originalError: error
+			},
+			response
+		};
+	}
+	if (isHTTPErrorInstance(error)) {
+		const { errorData, message, name, response } = error;
+		errorDetails = {
+			data: null,
+			error: {
+				errorData,
+				message,
+				name,
+				originalError: error
+			},
+			response: cloneResponse ? response.clone() : response
+		};
+	}
+	const errorResult = getResultModeMap(errorDetails)[resultMode ?? "all"]();
+	return {
+		errorDetails,
+		errorResult
+	};
+};
+const getCustomizedErrorResult = (errorResult, customErrorInfo) => {
+	if (!errorResult) return null;
+	const { message = errorResult.error.message } = customErrorInfo;
+	return {
+		...errorResult,
+		error: {
+			...errorResult.error,
+			message
+		}
 	};
 };
 
 //#endregion
-//#region src/utils/polyfills/combinedSignal.ts
-const createCombinedSignalPolyfill = (signals) => {
-	const controller = new AbortController();
-	const handleAbort = (actualSignal) => {
-		if (controller.signal.aborted) return;
-		controller.abort(actualSignal.reason);
+//#region src/hooks.ts
+const getHookRegistriesAndKeys = () => {
+	const hookRegistries = {
+		onError: /* @__PURE__ */ new Set(),
+		onRequest: /* @__PURE__ */ new Set(),
+		onRequestError: /* @__PURE__ */ new Set(),
+		onRequestReady: /* @__PURE__ */ new Set(),
+		onRequestStream: /* @__PURE__ */ new Set(),
+		onResponse: /* @__PURE__ */ new Set(),
+		onResponseError: /* @__PURE__ */ new Set(),
+		onResponseStream: /* @__PURE__ */ new Set(),
+		onRetry: /* @__PURE__ */ new Set(),
+		onSuccess: /* @__PURE__ */ new Set(),
+		onValidationError: /* @__PURE__ */ new Set()
 	};
-	for (const actualSignal of signals) {
-		if (actualSignal.aborted) {
-			handleAbort(actualSignal);
-			break;
+	return {
+		hookRegistries,
+		hookRegistryKeys: Object.keys(hookRegistries)
+	};
+};
+const composeHooksFromArray = (hooksArray, hooksExecutionMode) => {
+	const composedHook = async (ctx) => {
+		switch (hooksExecutionMode) {
+			case "parallel":
+				await Promise.all(hooksArray.map((uniqueHook) => uniqueHook?.(ctx)));
+				break;
+			case "sequential":
+				for (const hook of hooksArray) await hook?.(ctx);
+				break;
+			default:
 		}
-		actualSignal.addEventListener("abort", () => handleAbort(actualSignal), { signal: controller.signal });
-	}
-	return controller.signal;
+	};
+	return composedHook;
 };
-
-//#endregion
-//#region src/utils/polyfills/timeoutSignal.ts
-const createTimeoutSignalPolyfill = (milliseconds) => {
-	const controller = new AbortController();
-	const reason = new DOMException("Request timed out", "TimeoutError");
-	const timeout = setTimeout(() => controller.abort(reason), milliseconds);
-	controller.signal.addEventListener("abort", () => clearTimeout(timeout));
-	return controller.signal;
+const executeHooks = async (...hookResultsOrPromise) => {
+	await Promise.all(hookResultsOrPromise);
+};
+const executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
+	const { errorInfo, shouldThrowOnError } = hookInfo;
+	try {
+		await Promise.all(hookResultsOrPromise);
+		return null;
+	} catch (hookError) {
+		if (shouldThrowOnError) throw hookError;
+		const { errorResult } = resolveErrorResult(hookError, errorInfo);
+		return errorResult;
+	}
 };
 
 //#endregion
-//#region src/utils/common.ts
-const omitKeys = (initialObject, keysToOmit) => {
-	const updatedObject = {};
-	const keysToOmitSet = new Set(keysToOmit);
-	for (const [key, value] of Object.entries(initialObject)) if (!keysToOmitSet.has(key)) updatedObject[key] = value;
-	return updatedObject;
-};
-const pickKeys = (initialObject, keysToPick) => {
-	const updatedObject = {};
-	const keysToPickSet = new Set(keysToPick);
-	for (const [key, value] of Object.entries(initialObject)) if (keysToPickSet.has(key)) updatedObject[key] = value;
-	return updatedObject;
-};
-const splitBaseConfig = (baseConfig) => [pickKeys(baseConfig, fetchSpecificKeys), omitKeys(baseConfig, fetchSpecificKeys)];
-const splitConfig = (config) => [pickKeys(config, fetchSpecificKeys), omitKeys(config, fetchSpecificKeys)];
-const objectifyHeaders = (headers) => {
-	if (!headers || isPlainObject(headers)) return headers;
-	return Object.fromEntries(headers);
-};
-const getHeaders = async (options) => {
-	const { auth, body, headers } = options;
-	if (!(Boolean(headers) || Boolean(body) || Boolean(auth))) return;
-	const headersObject = {
-		...await getAuthHeader(auth),
-		...objectifyHeaders(headers)
+//#region src/stream.ts
+const createProgressEvent = (options) => {
+	const { chunk, totalBytes, transferredBytes } = options;
+	return {
+		chunk,
+		progress: Math.round(transferredBytes / totalBytes * 100) || 0,
+		totalBytes,
+		transferredBytes
 	};
-	if (isQueryString(body)) {
-		headersObject["Content-Type"] = "application/x-www-form-urlencoded";
-		return headersObject;
-	}
-	if (isSerializable(body) || isValidJsonString(body)) {
-		headersObject["Content-Type"] = "application/json";
-		headersObject.Accept = "application/json";
-	}
-	return headersObject;
-};
-const getMethod = (ctx) => {
-	const { initURL, method } = ctx;
-	return method?.toUpperCase() ?? extractMethodFromURL(initURL)?.toUpperCase() ?? requestOptionDefaults.method;
-};
-const getBody = (options) => {
-	const { body, bodySerializer } = options;
-	if (isSerializable(body)) return (bodySerializer ?? extraOptionDefaults.bodySerializer)(body);
-	return body;
-};
-const getInitFetchImpl = (customFetchImpl) => {
-	if (customFetchImpl) return customFetchImpl;
-	if (typeof globalThis !== "undefined" && isFunction(globalThis.fetch)) return globalThis.fetch;
-	throw new Error("No fetch implementation found");
-};
-const getFetchImpl = (context) => {
-	const { customFetchImpl, fetchMiddleware, requestContext } = context;
-	const initFetchImpl = getInitFetchImpl(customFetchImpl);
-	return fetchMiddleware ? fetchMiddleware({
-		...requestContext,
-		fetchImpl: initFetchImpl
-	}) : initFetchImpl;
-};
-const waitFor = (delay) => {
-	if (delay === 0) return;
-	return new Promise((resolve) => setTimeout(resolve, delay));
-};
-const createCombinedSignal = (...signals) => {
-	const cleanedSignals = signals.filter((signal) => signal != null);
-	if (!("any" in AbortSignal)) return createCombinedSignalPolyfill(cleanedSignals);
-	return AbortSignal.any(cleanedSignals);
 };
-const createTimeoutSignal = (milliseconds) => {
-	if (milliseconds == null) return null;
-	if (!("timeout" in AbortSignal)) return createTimeoutSignalPolyfill(milliseconds);
-	return AbortSignal.timeout(milliseconds);
+const calculateTotalBytesFromBody = async (requestBody, existingTotalBytes) => {
+	let totalBytes = existingTotalBytes;
+	if (!requestBody) return totalBytes;
+	for await (const chunk of requestBody) totalBytes += chunk.byteLength;
+	return totalBytes;
 };
-const deterministicHashFn = (value) => {
-	return JSON.stringify(value, (_, val) => {
-		if (!isPlainObject(val)) return val;
-		const sortedKeys = Object.keys(val).toSorted();
-		const result = {};
-		for (const key of sortedKeys) result[key] = val[key];
-		return result;
+const toStreamableRequest = async (context) => {
+	const { baseConfig, config, options, request } = context;
+	if (!options.onRequestStream || !isReadableStream(request.body)) return request;
+	const requestInstance = new Request(options.fullURL, {
+		...request,
+		duplex: "half"
+	});
+	const contentLength = requestInstance.headers.get("content-length");
+	let totalBytes = Number(contentLength ?? 0);
+	const shouldForcefullyCalcStreamSize = isObject(options.forcefullyCalculateStreamSize) ? options.forcefullyCalculateStreamSize.request : options.forcefullyCalculateStreamSize;
+	if (!contentLength && shouldForcefullyCalcStreamSize) totalBytes = await calculateTotalBytesFromBody(requestInstance.clone().body, totalBytes);
+	let transferredBytes = 0;
+	const stream = new ReadableStream({ start: async (controller) => {
+		const body = requestInstance.body;
+		if (!body) return;
+		const requestStreamContext = {
+			baseConfig,
+			config,
+			event: createProgressEvent({
+				chunk: new Uint8Array(),
+				totalBytes,
+				transferredBytes
+			}),
+			options,
+			request,
+			requestInstance
+		};
+		await executeHooks(options.onRequestStream?.(requestStreamContext));
+		for await (const chunk of body) {
+			transferredBytes += chunk.byteLength;
+			totalBytes = Math.max(totalBytes, transferredBytes);
+			await executeHooks(options.onRequestStream?.({
+				...requestStreamContext,
+				event: createProgressEvent({
+					chunk,
+					totalBytes,
+					transferredBytes
+				})
+			}));
+			controller.enqueue(chunk);
+		}
+		controller.close();
+	} });
+	return new Request(requestInstance, {
+		body: stream,
+		duplex: "half"
 	});
 };
-const toArray = (value) => isArray(value) ? value : [value];
+const toStreamableResponse = async (context) => {
+	const { baseConfig, config, options, request, response } = context;
+	if (!options.onResponseStream || !response.body) return response;
+	const contentLength = response.headers.get("content-length");
+	let totalBytes = Number(contentLength ?? 0);
+	const shouldForceContentLengthCalc = isObject(options.forcefullyCalculateStreamSize) ? options.forcefullyCalculateStreamSize.response : options.forcefullyCalculateStreamSize;
+	if (!contentLength && shouldForceContentLengthCalc) totalBytes = await calculateTotalBytesFromBody(response.clone().body, totalBytes);
+	let transferredBytes = 0;
+	const stream = new ReadableStream({ start: async (controller) => {
+		const body = response.body;
+		if (!body) return;
+		const responseStreamContext = {
+			baseConfig,
+			config,
+			event: createProgressEvent({
+				chunk: new Uint8Array(),
+				totalBytes,
+				transferredBytes
+			}),
+			options,
+			request,
+			response
+		};
+		await executeHooks(options.onResponseStream?.(responseStreamContext));
+		for await (const chunk of body) {
+			transferredBytes += chunk.byteLength;
+			totalBytes = Math.max(totalBytes, transferredBytes);
+			await executeHooks(options.onResponseStream?.({
+				...responseStreamContext,
+				event: createProgressEvent({
+					chunk,
+					totalBytes,
+					transferredBytes
+				})
+			}));
+			controller.enqueue(chunk);
+		}
+		controller.close();
+	} });
+	return new Response(stream, response);
+};
 
 //#endregion
 //#region src/dedupe.ts