@codemation/core-nodes-ocr 0.2.6 → 0.2.8

package/dist/dist-BYInIjS8.js

@@ -0,0 +1,2246 @@
+import * as z4 from "zod/v4";
+import { ZodFirstPartyTypeKind } from "zod/v3";
+
+//#region ../../node_modules/.pnpm/@ai-sdk+provider@3.0.10/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker$1 = "vercel.ai.error";
+var symbol$1 = Symbol.for(marker$1);
+var _a$1, _b$1;
+var AISDKError = class _AISDKError extends (_b$1 = Error, _a$1 = symbol$1, _b$1) {
+	/**
+	* Creates an AI SDK Error.
+	*
+	* @param {Object} params - The parameters for creating the error.
+	* @param {string} params.name - The name of the error.
+	* @param {string} params.message - The error message.
+	* @param {unknown} [params.cause] - The underlying cause of the error.
+	*/
+	constructor({ name: name14, message, cause }) {
+		super(message);
+		this[_a$1] = true;
+		this.name = name14;
+		this.cause = cause;
+	}
+	/**
+	* Checks if the given error is an AI SDK Error.
+	* @param {unknown} error - The error to check.
+	* @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+	*/
+	static isInstance(error) {
+		return _AISDKError.hasMarker(error, marker$1);
+	}
+	static hasMarker(error, marker15) {
+		const markerSymbol = Symbol.for(marker15);
+		return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+	}
+};
+var name$1 = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name$1}`;
+var symbol2 = Symbol.for(marker2);
+var _a2, _b2;
+var APICallError = class extends (_b2 = AISDKError, _a2 = symbol2, _b2) {
+	constructor({ message, url, requestBodyValues, statusCode, responseHeaders, responseBody, cause, isRetryable = statusCode != null && (statusCode === 408 || statusCode === 409 || statusCode === 429 || statusCode >= 500), data }) {
+		super({
+			name: name$1,
+			message,
+			cause
+		});
+		this[_a2] = true;
+		this.url = url;
+		this.requestBodyValues = requestBodyValues;
+		this.statusCode = statusCode;
+		this.responseHeaders = responseHeaders;
+		this.responseBody = responseBody;
+		this.isRetryable = isRetryable;
+		this.data = data;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker2);
+	}
+};
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3, _b3;
+var EmptyResponseBodyError = class extends (_b3 = AISDKError, _a3 = symbol3, _b3) {
+	constructor({ message = "Empty response body" } = {}) {
+		super({
+			name: name2,
+			message
+		});
+		this[_a3] = true;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker3);
+	}
+};
+function getErrorMessage(error) {
+	if (error == null) return "unknown error";
+	if (typeof error === "string") return error;
+	if (error instanceof Error) return error.message;
+	return JSON.stringify(error);
+}
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4, _b4;
+var InvalidArgumentError = class extends (_b4 = AISDKError, _a4 = symbol4, _b4) {
+	constructor({ message, cause, argument }) {
+		super({
+			name: name3,
+			message,
+			cause
+		});
+		this[_a4] = true;
+		this.argument = argument;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker4);
+	}
+};
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5, _b5;
+var InvalidPromptError = class extends (_b5 = AISDKError, _a5 = symbol5, _b5) {
+	constructor({ prompt, message, cause }) {
+		super({
+			name: name4,
+			message: `Invalid prompt: ${message}`,
+			cause
+		});
+		this[_a5] = true;
+		this.prompt = prompt;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker5);
+	}
+};
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6, _b6;
+var InvalidResponseDataError = class extends (_b6 = AISDKError, _a6 = symbol6, _b6) {
+	constructor({ data, message = `Invalid response data: ${JSON.stringify(data)}.` }) {
+		super({
+			name: name5,
+			message
+		});
+		this[_a6] = true;
+		this.data = data;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker6);
+	}
+};
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7, _b7;
+var JSONParseError = class extends (_b7 = AISDKError, _a7 = symbol7, _b7) {
+	constructor({ text, cause }) {
+		super({
+			name: name6,
+			message: `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`,
+			cause
+		});
+		this[_a7] = true;
+		this.text = text;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker7);
+	}
+};
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8, _b8;
+var LoadAPIKeyError = class extends (_b8 = AISDKError, _a8 = symbol8, _b8) {
+	constructor({ message }) {
+		super({
+			name: name7,
+			message
+		});
+		this[_a8] = true;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker8);
+	}
+};
+var name8 = "AI_LoadSettingError";
+var marker9 = `vercel.ai.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var name9 = "AI_NoContentGeneratedError";
+var marker10 = `vercel.ai.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var name10 = "AI_NoSuchModelError";
+var marker11 = `vercel.ai.error.${name10}`;
+var symbol11 = Symbol.for(marker11);
+var _a11, _b11;
+var NoSuchModelError = class extends (_b11 = AISDKError, _a11 = symbol11, _b11) {
+	constructor({ errorName = name10, modelId, modelType, message = `No such ${modelType}: ${modelId}` }) {
+		super({
+			name: errorName,
+			message
+		});
+		this[_a11] = true;
+		this.modelId = modelId;
+		this.modelType = modelType;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker11);
+	}
+};
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12, _b12;
+var TooManyEmbeddingValuesForCallError = class extends (_b12 = AISDKError, _a12 = symbol12, _b12) {
+	constructor(options) {
+		super({
+			name: name11,
+			message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
+		});
+		this[_a12] = true;
+		this.provider = options.provider;
+		this.modelId = options.modelId;
+		this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
+		this.values = options.values;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker12);
+	}
+};
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13, _b13;
+var TypeValidationError = class _TypeValidationError extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
+	constructor({ value, cause, context }) {
+		let contextPrefix = "Type validation failed";
+		if (context == null ? void 0 : context.field) contextPrefix += ` for ${context.field}`;
+		if ((context == null ? void 0 : context.entityName) || (context == null ? void 0 : context.entityId)) {
+			contextPrefix += " (";
+			const parts = [];
+			if (context.entityName) parts.push(context.entityName);
+			if (context.entityId) parts.push(`id: "${context.entityId}"`);
+			contextPrefix += parts.join(", ");
+			contextPrefix += ")";
+		}
+		super({
+			name: name12,
+			message: `${contextPrefix}: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+			cause
+		});
+		this[_a13] = true;
+		this.value = value;
+		this.context = context;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker13);
+	}
+	/**
+	* Wraps an error into a TypeValidationError.
+	* If the cause is already a TypeValidationError with the same value and context, it returns the cause.
+	* Otherwise, it creates a new TypeValidationError.
+	*
+	* @param {Object} params - The parameters for wrapping the error.
+	* @param {unknown} params.value - The value that failed validation.
+	* @param {unknown} params.cause - The original error or cause of the validation failure.
+	* @param {TypeValidationContext} params.context - Optional context about what is being validated.
+	* @returns {TypeValidationError} A TypeValidationError instance.
+	*/
+	static wrap({ value, cause, context }) {
+		var _a15, _b15, _c;
+		if (_TypeValidationError.isInstance(cause) && cause.value === value && ((_a15 = cause.context) == null ? void 0 : _a15.field) === (context == null ? void 0 : context.field) && ((_b15 = cause.context) == null ? void 0 : _b15.entityName) === (context == null ? void 0 : context.entityName) && ((_c = cause.context) == null ? void 0 : _c.entityId) === (context == null ? void 0 : context.entityId)) return cause;
+		return new _TypeValidationError({
+			value,
+			cause,
+			context
+		});
+	}
+};
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14, _b14;
+var UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = symbol14, _b14) {
+	constructor({ functionality, message = `'${functionality}' functionality not supported.` }) {
+		super({
+			name: name13,
+			message
+		});
+		this[_a14] = true;
+		this.functionality = functionality;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker14);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eventsource-parser@3.0.8/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+	constructor(message, options) {
+		super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+	}
+};
+const LF = 10, CR = 13, SPACE = 32;
+function noop(_arg) {}
+function createParser(callbacks) {
+	if (typeof callbacks == "function") throw new TypeError("`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?");
+	const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks, pendingFragments = [];
+	let isFirstChunk = !0, id, data = "", dataLines = 0, eventType;
+	function feed(chunk) {
+		if (isFirstChunk && (isFirstChunk = !1, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+			const trailing2 = processLines(chunk);
+			trailing2 !== "" && pendingFragments.push(trailing2);
+			return;
+		}
+		if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+			pendingFragments.push(chunk);
+			return;
+		}
+		pendingFragments.push(chunk);
+		const input = pendingFragments.join("");
+		pendingFragments.length = 0;
+		const trailing = processLines(input);
+		trailing !== "" && pendingFragments.push(trailing);
+	}
+	function processLines(chunk) {
+		let searchIndex = 0;
+		if (chunk.indexOf("\r") === -1) {
+			let lfIndex = chunk.indexOf(`
+`, searchIndex);
+			for (; lfIndex !== -1;) {
+				if (searchIndex === lfIndex) {
+					dataLines > 0 && onEvent({
+						id,
+						event: eventType,
+						data
+					}), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+					continue;
+				}
+				const firstCharCode = chunk.charCodeAt(searchIndex);
+				if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+					const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+					if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+						onEvent({
+							id,
+							event: eventType,
+							data: value
+						}), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+						continue;
+					}
+					data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+				} else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6, lfIndex) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+				searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+			}
+			return chunk.slice(searchIndex);
+		}
+		for (; searchIndex < chunk.length;) {
+			const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+			let lineEnd = -1;
+			if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) break;
+			parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+		}
+		return chunk.slice(searchIndex);
+	}
+	function parseLine(chunk, start, end) {
+		if (start === end) {
+			dispatchEvent();
+			return;
+		}
+		const firstCharCode = chunk.charCodeAt(start);
+		if (isDataPrefix(chunk, start, firstCharCode)) {
+			const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+			data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+			return;
+		}
+		if (isEventPrefix(chunk, start, firstCharCode)) {
+			eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+			return;
+		}
+		if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+			const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+			id = value2.includes("\0") ? void 0 : value2;
+			return;
+		}
+		if (firstCharCode === 58) {
+			if (onComment) onComment(chunk.slice(start, end).slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+			return;
+		}
+		const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+		if (fieldSeparatorIndex === -1) {
+			processField(line, "", line);
+			return;
+		}
+		const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1;
+		processField(field, line.slice(fieldSeparatorIndex + offset), line);
+	}
+	function processField(field, value, line) {
+		switch (field) {
+			case "event":
+				eventType = value || void 0;
+				break;
+			case "data":
+				data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+				break;
+			case "id":
+				id = value.includes("\0") ? void 0 : value;
+				break;
+			case "retry":
+				/^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(new ParseError(`Invalid \`retry\` value: "${value}"`, {
+					type: "invalid-retry",
+					value,
+					line
+				}));
+				break;
+			default:
+				onError(new ParseError(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, {
+					type: "unknown-field",
+					field,
+					value,
+					line
+				}));
+				break;
+		}
+	}
+	function dispatchEvent() {
+		dataLines > 0 && onEvent({
+			id,
+			event: eventType,
+			data
+		}), id = void 0, data = "", dataLines = 0, eventType = void 0;
+	}
+	function reset(options = {}) {
+		if (options.consume && pendingFragments.length > 0) {
+			const incompleteLine = pendingFragments.join("");
+			parseLine(incompleteLine, 0, incompleteLine.length);
+		}
+		isFirstChunk = !0, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0;
+	}
+	return {
+		feed,
+		reset
+	};
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+	return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+	return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/eventsource-parser@3.0.8/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+	constructor({ onError, onRetry, onComment } = {}) {
+		let parser;
+		super({
+			start(controller) {
+				parser = createParser({
+					onEvent: (event) => {
+						controller.enqueue(event);
+					},
+					onError(error) {
+						onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+					},
+					onRetry,
+					onComment
+				});
+			},
+			transform(chunk) {
+				parser.feed(chunk);
+			}
+		});
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ai-sdk+provider-utils@4.0.30_zod@4.3.6/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+function combineHeaders(...headers) {
+	return headers.reduce((combinedHeaders, currentHeaders) => ({
+		...combinedHeaders,
+		...currentHeaders != null ? currentHeaders : {}
+	}), {});
+}
+function createToolNameMapping({ tools = [], providerToolNames, resolveProviderToolName }) {
+	var _a2$1;
+	const customToolNameToProviderToolName = {};
+	const providerToolNameToCustomToolName = {};
+	for (const tool2 of tools) if (tool2.type === "provider") {
+		const providerToolName = (_a2$1 = resolveProviderToolName == null ? void 0 : resolveProviderToolName(tool2)) != null ? _a2$1 : tool2.id in providerToolNames ? providerToolNames[tool2.id] : void 0;
+		if (providerToolName == null) continue;
+		customToolNameToProviderToolName[tool2.name] = providerToolName;
+		providerToolNameToCustomToolName[providerToolName] = tool2.name;
+	}
+	return {
+		toProviderToolName: (customToolName) => {
+			var _a3$1;
+			return (_a3$1 = customToolNameToProviderToolName[customToolName]) != null ? _a3$1 : customToolName;
+		},
+		toCustomToolName: (providerToolName) => {
+			var _a3$1;
+			return (_a3$1 = providerToolNameToCustomToolName[providerToolName]) != null ? _a3$1 : providerToolName;
+		}
+	};
+}
+function extractResponseHeaders(response) {
+	return Object.fromEntries([...response.headers]);
+}
+var { btoa, atob } = globalThis;
+function convertBase64ToUint8Array(base64String) {
+	const latin1string = atob(base64String.replace(/-/g, "+").replace(/_/g, "/"));
+	return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
+}
+function convertUint8ArrayToBase64(array) {
+	let latin1string = "";
+	for (let i = 0; i < array.length; i++) latin1string += String.fromCodePoint(array[i]);
+	return btoa(latin1string);
+}
+function convertToBase64(value) {
+	return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+}
+function convertToFormData(input, options = {}) {
+	const { useArrayBrackets = true } = options;
+	const formData = new FormData();
+	for (const [key, value] of Object.entries(input)) {
+		if (value == null) continue;
+		if (Array.isArray(value)) {
+			if (value.length === 1) {
+				formData.append(key, value[0]);
+				continue;
+			}
+			const arrayKey = useArrayBrackets ? `${key}[]` : key;
+			for (const item of value) formData.append(arrayKey, item);
+			continue;
+		}
+		formData.append(key, value);
+	}
+	return formData;
+}
+async function cancelResponseBody(response) {
+	var _a2$1;
+	try {
+		await ((_a2$1 = response.body) == null ? void 0 : _a2$1.cancel());
+	} catch (e) {}
+}
+var name = "AI_DownloadError";
+var marker = `vercel.ai.error.${name}`;
+var symbol = Symbol.for(marker);
+var _a, _b;
+var DownloadError = class extends (_b = AISDKError, _a = symbol, _b) {
+	constructor({ url, statusCode, statusText, cause, message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}` }) {
+		super({
+			name,
+			message,
+			cause
+		});
+		this[_a] = true;
+		this.url = url;
+		this.statusCode = statusCode;
+		this.statusText = statusText;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker);
+	}
+};
+function isBrowserRuntime(globalThisAny = globalThis) {
+	return globalThisAny.window != null;
+}
+function validateDownloadUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch (e) {
+		throw new DownloadError({
+			url,
+			message: `Invalid URL: ${url}`
+		});
+	}
+	if (parsed.protocol === "data:") return;
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new DownloadError({
+		url,
+		message: `URL scheme must be http, https, or data, got ${parsed.protocol}`
+	});
+	const hostname = parsed.hostname.toLowerCase().replace(/\.+$/, "");
+	if (!hostname) throw new DownloadError({
+		url,
+		message: `URL must have a hostname`
+	});
+	if (hostname === "localhost" || hostname.endsWith(".local") || hostname.endsWith(".localhost")) throw new DownloadError({
+		url,
+		message: `URL with hostname ${hostname} is not allowed`
+	});
+	if (hostname.startsWith("[") && hostname.endsWith("]")) {
+		if (isPrivateIPv6(hostname.slice(1, -1))) throw new DownloadError({
+			url,
+			message: `URL with IPv6 address ${hostname} is not allowed`
+		});
+		return;
+	}
+	if (isIPv4(hostname)) {
+		if (isPrivateIPv4(hostname)) throw new DownloadError({
+			url,
+			message: `URL with IP address ${hostname} is not allowed`
+		});
+		return;
+	}
+}
+function isIPv4(hostname) {
+	const parts = hostname.split(".");
+	if (parts.length !== 4) return false;
+	return parts.every((part) => {
+		const num = Number(part);
+		return Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part;
+	});
+}
+function isPrivateIPv4(ip) {
+	const [a, b, c] = ip.split(".").map(Number);
+	if (a === 0) return true;
+	if (a === 10) return true;
+	if (a === 100 && b >= 64 && b <= 127) return true;
+	if (a === 127) return true;
+	if (a === 169 && b === 254) return true;
+	if (a === 172 && b >= 16 && b <= 31) return true;
+	if (a === 192 && b === 0 && c === 0) return true;
+	if (a === 192 && b === 168) return true;
+	if (a === 198 && (b === 18 || b === 19)) return true;
+	if (a >= 240) return true;
+	return false;
+}
+function parseIPv6(ip) {
+	let address = ip.toLowerCase();
+	const zoneIndex = address.indexOf("%");
+	if (zoneIndex !== -1) address = address.slice(0, zoneIndex);
+	const halves = address.split("::");
+	if (halves.length > 2) return null;
+	const toGroups = (segment) => {
+		if (segment === "") return [];
+		const groups = [];
+		const parts = segment.split(":");
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (part.includes(".")) {
+				if (i !== parts.length - 1 || !isIPv4(part)) return null;
+				const [a, b, c, d] = part.split(".").map(Number);
+				groups.push(a << 8 | b, c << 8 | d);
+				continue;
+			}
+			if (!/^[0-9a-f]{1,4}$/.test(part)) return null;
+			groups.push(parseInt(part, 16));
+		}
+		return groups;
+	};
+	const head = toGroups(halves[0]);
+	if (head === null) return null;
+	if (halves.length === 2) {
+		const tail = toGroups(halves[1]);
+		if (tail === null) return null;
+		const fill = 8 - head.length - tail.length;
+		if (fill < 0) return null;
+		return [
+			...head,
+			...new Array(fill).fill(0),
+			...tail
+		];
+	}
+	return head.length === 8 ? head : null;
+}
+function isPrivateIPv6(ip) {
+	const groups = parseIPv6(ip);
+	if (groups === null) return true;
+	const topZero = (count) => groups.slice(0, count).every((group) => group === 0);
+	if (topZero(7) && (groups[7] === 0 || groups[7] === 1)) return true;
+	if ((groups[0] & 65024) === 64512) return true;
+	if ((groups[0] & 65472) === 65152) return true;
+	if ((groups[0] & 65472) === 65216) return true;
+	if ((groups[0] & 65280) === 65280) return true;
+	if (topZero(6) || topZero(5) && groups[5] === 65535 || topZero(4) && groups[4] === 65535 && groups[5] === 0 || groups[0] === 100 && groups[1] === 65435 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 0 || groups[0] === 100 && groups[1] === 65435 && groups[2] === 1) return isPrivateIPv4(`${groups[6] >> 8 & 255}.${groups[6] & 255}.${groups[7] >> 8 & 255}.${groups[7] & 255}`);
+	return false;
+}
+var MAX_DOWNLOAD_REDIRECTS = 10;
+async function fetchWithValidatedRedirects({ url, headers, abortSignal, maxRedirects = MAX_DOWNLOAD_REDIRECTS }) {
+	const baseInit = { signal: abortSignal };
+	if (headers !== void 0) baseInit.headers = headers;
+	let currentUrl = url;
+	for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount++) {
+		validateDownloadUrl(currentUrl);
+		const response = await fetch(currentUrl, {
+			...baseInit,
+			redirect: "manual"
+		});
+		if (response.type === "opaqueredirect") {
+			if (!isBrowserRuntime()) throw new DownloadError({
+				url,
+				message: `Redirect from ${currentUrl} could not be validated and was blocked`
+			});
+			return await fetch(currentUrl, {
+				...baseInit,
+				redirect: "follow"
+			});
+		}
+		const location = response.headers.get("location");
+		if (response.status >= 300 && response.status < 400 && location) {
+			await cancelResponseBody(response);
+			currentUrl = new URL(location, currentUrl).toString();
+			continue;
+		}
+		return response;
+	}
+	throw new DownloadError({
+		url,
+		message: `Too many redirects (max ${maxRedirects})`
+	});
+}
+var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
+async function readResponseWithSizeLimit({ response, url, maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE }) {
+	const contentLength = response.headers.get("content-length");
+	if (contentLength != null) {
+		const length = parseInt(contentLength, 10);
+		if (!isNaN(length) && length > maxBytes) {
+			await cancelResponseBody(response);
+			throw new DownloadError({
+				url,
+				message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
+			});
+		}
+	}
+	const body = response.body;
+	if (body == null) return new Uint8Array(0);
+	const reader = body.getReader();
+	const chunks = [];
+	let totalBytes = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			totalBytes += value.length;
+			if (totalBytes > maxBytes) throw new DownloadError({
+				url,
+				message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes.`
+			});
+			chunks.push(value);
+		}
+	} finally {
+		try {
+			await reader.cancel();
+		} finally {
+			reader.releaseLock();
+		}
+	}
+	const result = new Uint8Array(totalBytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
+async function downloadBlob(url, options) {
+	var _a2$1, _b2$1;
+	try {
+		const response = await fetchWithValidatedRedirects({
+			url,
+			abortSignal: options == null ? void 0 : options.abortSignal
+		});
+		if (!response.ok) {
+			await cancelResponseBody(response);
+			throw new DownloadError({
+				url,
+				statusCode: response.status,
+				statusText: response.statusText
+			});
+		}
+		const data = await readResponseWithSizeLimit({
+			response,
+			url,
+			maxBytes: (_a2$1 = options == null ? void 0 : options.maxBytes) != null ? _a2$1 : DEFAULT_MAX_DOWNLOAD_SIZE
+		});
+		const contentType = (_b2$1 = response.headers.get("content-type")) != null ? _b2$1 : void 0;
+		return new Blob([data], contentType ? { type: contentType } : void 0);
+	} catch (error) {
+		if (DownloadError.isInstance(error)) throw error;
+		throw new DownloadError({
+			url,
+			cause: error
+		});
+	}
+}
+var createIdGenerator = ({ prefix, size = 16, alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", separator = "-" } = {}) => {
+	const generator = () => {
+		const alphabetLength = alphabet.length;
+		const chars = new Array(size);
+		for (let i = 0; i < size; i++) chars[i] = alphabet[Math.random() * alphabetLength | 0];
+		return chars.join("");
+	};
+	if (prefix == null) return generator;
+	if (alphabet.includes(separator)) throw new InvalidArgumentError({
+		argument: "separator",
+		message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+	});
+	return () => `${prefix}${separator}${generator()}`;
+};
+var generateId = createIdGenerator();
+function isAbortError(error) {
+	return (error instanceof Error || error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || error.name === "TimeoutError");
+}
+var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+var BUN_ERROR_CODES = [
+	"ConnectionRefused",
+	"ConnectionClosed",
+	"FailedToOpenSocket",
+	"ECONNRESET",
+	"ECONNREFUSED",
+	"ETIMEDOUT",
+	"EPIPE"
+];
+function isBunNetworkError(error) {
+	if (!(error instanceof Error)) return false;
+	const code = error.code;
+	if (typeof code === "string" && BUN_ERROR_CODES.includes(code)) return true;
+	return false;
+}
+function handleFetchError({ error, url, requestBodyValues }) {
+	if (isAbortError(error)) return error;
+	if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
+		const cause = error.cause;
+		if (cause != null) return new APICallError({
+			message: `Cannot connect to API: ${cause.message}`,
+			cause,
+			url,
+			requestBodyValues,
+			isRetryable: true
+		});
+	}
+	if (isBunNetworkError(error)) return new APICallError({
+		message: `Cannot connect to API: ${error.message}`,
+		cause: error,
+		url,
+		requestBodyValues,
+		isRetryable: true
+	});
+	return error;
+}
+function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
+	var _a2$1, _b2$1, _c;
+	if (globalThisAny.window) return `runtime/browser`;
+	if ((_a2$1 = globalThisAny.navigator) == null ? void 0 : _a2$1.userAgent) return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
+	if ((_c = (_b2$1 = globalThisAny.process) == null ? void 0 : _b2$1.versions) == null ? void 0 : _c.node) return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
+	if (globalThisAny.EdgeRuntime) return `runtime/vercel-edge`;
+	return "runtime/unknown";
+}
+function normalizeHeaders(headers) {
+	if (headers == null) return {};
+	const normalized = {};
+	if (headers instanceof Headers) headers.forEach((value, key) => {
+		normalized[key.toLowerCase()] = value;
+	});
+	else {
+		if (!Array.isArray(headers)) headers = Object.entries(headers);
+		for (const [key, value] of headers) if (value != null) normalized[key.toLowerCase()] = value;
+	}
+	return normalized;
+}
+function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
+	const normalizedHeaders = new Headers(normalizeHeaders(headers));
+	const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
+	normalizedHeaders.set("user-agent", [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" "));
+	return Object.fromEntries(normalizedHeaders.entries());
+}
+var VERSION = "4.0.30";
+function isNonNullable(value) {
+	return value != null;
+}
+function loadApiKey({ apiKey, environmentVariableName, apiKeyParameterName = "apiKey", description }) {
+	if (typeof apiKey === "string") return apiKey;
+	if (apiKey != null) throw new LoadAPIKeyError({ message: `${description} API key must be a string.` });
+	if (typeof process === "undefined") throw new LoadAPIKeyError({ message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables are not supported in this environment.` });
+	apiKey = process.env[environmentVariableName];
+	if (apiKey == null) throw new LoadAPIKeyError({ message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.` });
+	if (typeof apiKey !== "string") throw new LoadAPIKeyError({ message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.` });
+	return apiKey;
+}
+function loadOptionalSetting({ settingValue, environmentVariableName }) {
+	if (typeof settingValue === "string") return settingValue;
+	if (settingValue != null || typeof process === "undefined") return;
+	settingValue = process.env[environmentVariableName];
+	if (settingValue == null || typeof settingValue !== "string") return;
+	return settingValue;
+}
+function mediaTypeToExtension(mediaType) {
+	var _a2$1;
+	const [_type, subtype = ""] = mediaType.toLowerCase().split("/");
+	return (_a2$1 = {
+		mpeg: "mp3",
+		"x-wav": "wav",
+		opus: "ogg",
+		mp4: "m4a",
+		"x-m4a": "m4a"
+	}[subtype]) != null ? _a2$1 : subtype;
+}
+var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+function _parse(text) {
+	const obj = JSON.parse(text);
+	if (obj === null || typeof obj !== "object") return obj;
+	if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) return obj;
+	return filter(obj);
+}
+function filter(obj) {
+	let next = [obj];
+	while (next.length) {
+		const nodes = next;
+		next = [];
+		for (const node of nodes) {
+			if (Object.prototype.hasOwnProperty.call(node, "__proto__")) throw new SyntaxError("Object contains forbidden prototype property");
+			if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) throw new SyntaxError("Object contains forbidden prototype property");
+			for (const key in node) {
+				const value = node[key];
+				if (value && typeof value === "object") next.push(value);
+			}
+		}
+	}
+	return obj;
+}
+function secureJsonParse(text) {
+	const { stackTraceLimit } = Error;
+	try {
+		Error.stackTraceLimit = 0;
+	} catch (e) {
+		return _parse(text);
+	}
+	try {
+		return _parse(text);
+	} finally {
+		Error.stackTraceLimit = stackTraceLimit;
+	}
+}
+function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
+	if (jsonSchema2.type === "object" || Array.isArray(jsonSchema2.type) && jsonSchema2.type.includes("object")) {
+		jsonSchema2.additionalProperties = false;
+		const { properties } = jsonSchema2;
+		if (properties != null) for (const key of Object.keys(properties)) properties[key] = visit(properties[key]);
+	}
+	if (jsonSchema2.items != null) jsonSchema2.items = Array.isArray(jsonSchema2.items) ? jsonSchema2.items.map(visit) : visit(jsonSchema2.items);
+	if (jsonSchema2.anyOf != null) jsonSchema2.anyOf = jsonSchema2.anyOf.map(visit);
+	if (jsonSchema2.allOf != null) jsonSchema2.allOf = jsonSchema2.allOf.map(visit);
+	if (jsonSchema2.oneOf != null) jsonSchema2.oneOf = jsonSchema2.oneOf.map(visit);
+	const { definitions } = jsonSchema2;
+	if (definitions != null) for (const key of Object.keys(definitions)) definitions[key] = visit(definitions[key]);
+	return jsonSchema2;
+}
+function visit(def) {
+	if (typeof def === "boolean") return def;
+	return addAdditionalPropertiesToJsonSchema(def);
+}
+var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions = {
+	name: void 0,
+	$refStrategy: "root",
+	basePath: ["#"],
+	effectStrategy: "input",
+	pipeStrategy: "all",
+	dateStrategy: "format:date-time",
+	mapStrategy: "entries",
+	removeAdditionalStrategy: "passthrough",
+	allowedAdditionalProperties: true,
+	rejectedAdditionalProperties: false,
+	definitionPath: "definitions",
+	strictUnions: false,
+	definitions: {},
+	errorMessages: false,
+	patternStrategy: "escape",
+	applyRegexFlags: false,
+	emailStrategy: "format:email",
+	base64Strategy: "contentEncoding:base64",
+	nameStrategy: "ref"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+	...defaultOptions,
+	name: options
+} : {
+	...defaultOptions,
+	...options
+};
+function parseAnyDef() {
+	return {};
+}
+function parseArrayDef(def, refs) {
+	var _a2$1, _b2$1, _c;
+	const res = { type: "array" };
+	if (((_a2$1 = def.type) == null ? void 0 : _a2$1._def) && ((_c = (_b2$1 = def.type) == null ? void 0 : _b2$1._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind.ZodAny) res.items = parseDef(def.type._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "items"]
+	});
+	if (def.minLength) res.minItems = def.minLength.value;
+	if (def.maxLength) res.maxItems = def.maxLength.value;
+	if (def.exactLength) {
+		res.minItems = def.exactLength.value;
+		res.maxItems = def.exactLength.value;
+	}
+	return res;
+}
+function parseBigintDef(def) {
+	const res = {
+		type: "integer",
+		format: "int64"
+	};
+	if (!def.checks) return res;
+	for (const check of def.checks) switch (check.kind) {
+		case "min":
+			if (check.inclusive) res.minimum = check.value;
+			else res.exclusiveMinimum = check.value;
+			break;
+		case "max":
+			if (check.inclusive) res.maximum = check.value;
+			else res.exclusiveMaximum = check.value;
+			break;
+		case "multipleOf":
+			res.multipleOf = check.value;
+			break;
+	}
+	return res;
+}
+function parseBooleanDef() {
+	return { type: "boolean" };
+}
+function parseBrandedDef(_def, refs) {
+	return parseDef(_def.type._def, refs);
+}
+var parseCatchDef = (def, refs) => {
+	return parseDef(def.innerType._def, refs);
+};
+function parseDateDef(def, refs, overrideDateStrategy) {
+	const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
+	if (Array.isArray(strategy)) return { anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)) };
+	switch (strategy) {
+		case "string":
+		case "format:date-time": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "format:date": return {
+			type: "string",
+			format: "date"
+		};
+		case "integer": return integerDateParser(def);
+	}
+}
+var integerDateParser = (def) => {
+	const res = {
+		type: "integer",
+		format: "unix-time"
+	};
+	for (const check of def.checks) switch (check.kind) {
+		case "min":
+			res.minimum = check.value;
+			break;
+		case "max":
+			res.maximum = check.value;
+			break;
+	}
+	return res;
+};
+function parseDefaultDef(_def, refs) {
+	return {
+		...parseDef(_def.innerType._def, refs),
+		default: _def.defaultValue()
+	};
+}
+function parseEffectsDef(_def, refs) {
+	return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
+}
+function parseEnumDef(def) {
+	return {
+		type: "string",
+		enum: Array.from(def.values)
+	};
+}
+var isJsonSchema7AllOfType = (type) => {
+	if ("type" in type && type.type === "string") return false;
+	return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+	const allOf = [parseDef(def.left._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"allOf",
+			"0"
+		]
+	}), parseDef(def.right._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"allOf",
+			"1"
+		]
+	})].filter((x) => !!x);
+	const mergedAllOf = [];
+	allOf.forEach((schema) => {
+		if (isJsonSchema7AllOfType(schema)) mergedAllOf.push(...schema.allOf);
+		else {
+			let nestedSchema = schema;
+			if ("additionalProperties" in schema && schema.additionalProperties === false) {
+				const { additionalProperties,...rest } = schema;
+				nestedSchema = rest;
+			}
+			mergedAllOf.push(nestedSchema);
+		}
+	});
+	return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
+}
+function parseLiteralDef(def) {
+	const parsedType = typeof def.value;
+	if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") return { type: Array.isArray(def.value) ? "array" : "object" };
+	return {
+		type: parsedType === "bigint" ? "integer" : parsedType,
+		const: def.value
+	};
+}
+var emojiRegex = void 0;
+var zodPatterns = {
+	cuid: /^[cC][^\s-]{8,}$/,
+	cuid2: /^[0-9a-z]+$/,
+	ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+	email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+	emoji: () => {
+		if (emojiRegex === void 0) emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+		return emojiRegex;
+	},
+	uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+	ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+	ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+	ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+	ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+	base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+	base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+	nanoid: /^[a-zA-Z0-9_-]{21}$/,
+	jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+	const res = { type: "string" };
+	if (def.checks) for (const check of def.checks) switch (check.kind) {
+		case "min":
+			res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
+			break;
+		case "max":
+			res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
+			break;
+		case "email":
+			switch (refs.emailStrategy) {
+				case "format:email":
+					addFormat(res, "email", check.message, refs);
+					break;
+				case "format:idn-email":
+					addFormat(res, "idn-email", check.message, refs);
+					break;
+				case "pattern:zod":
+					addPattern(res, zodPatterns.email, check.message, refs);
+					break;
+			}
+			break;
+		case "url":
+			addFormat(res, "uri", check.message, refs);
+			break;
+		case "uuid":
+			addFormat(res, "uuid", check.message, refs);
+			break;
+		case "regex":
+			addPattern(res, check.regex, check.message, refs);
+			break;
+		case "cuid":
+			addPattern(res, zodPatterns.cuid, check.message, refs);
+			break;
+		case "cuid2":
+			addPattern(res, zodPatterns.cuid2, check.message, refs);
+			break;
+		case "startsWith":
+			addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
+			break;
+		case "endsWith":
+			addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
+			break;
+		case "datetime":
+			addFormat(res, "date-time", check.message, refs);
+			break;
+		case "date":
+			addFormat(res, "date", check.message, refs);
+			break;
+		case "time":
+			addFormat(res, "time", check.message, refs);
+			break;
+		case "duration":
+			addFormat(res, "duration", check.message, refs);
+			break;
+		case "length":
+			res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
+			res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
+			break;
+		case "includes":
+			addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+			break;
+		case "ip":
+			if (check.version !== "v6") addFormat(res, "ipv4", check.message, refs);
+			if (check.version !== "v4") addFormat(res, "ipv6", check.message, refs);
+			break;
+		case "base64url":
+			addPattern(res, zodPatterns.base64url, check.message, refs);
+			break;
+		case "jwt":
+			addPattern(res, zodPatterns.jwt, check.message, refs);
+			break;
+		case "cidr":
+			if (check.version !== "v6") addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+			if (check.version !== "v4") addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+			break;
+		case "emoji":
+			addPattern(res, zodPatterns.emoji(), check.message, refs);
+			break;
+		case "ulid":
+			addPattern(res, zodPatterns.ulid, check.message, refs);
+			break;
+		case "base64":
+			switch (refs.base64Strategy) {
+				case "format:binary":
+					addFormat(res, "binary", check.message, refs);
+					break;
+				case "contentEncoding:base64":
+					res.contentEncoding = "base64";
+					break;
+				case "pattern:zod":
+					addPattern(res, zodPatterns.base64, check.message, refs);
+					break;
+			}
+			break;
+		case "nanoid": addPattern(res, zodPatterns.nanoid, check.message, refs);
+		case "toLowerCase":
+		case "toUpperCase":
+		case "trim": break;
+		default:
+	}
+	return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+	return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+var ALPHA_NUMERIC = /* @__PURE__ */ new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+	let result = "";
+	for (let i = 0; i < source.length; i++) {
+		if (!ALPHA_NUMERIC.has(source[i])) result += "\\";
+		result += source[i];
+	}
+	return result;
+}
+function addFormat(schema, value, message, refs) {
+	var _a2$1;
+	if (schema.format || ((_a2$1 = schema.anyOf) == null ? void 0 : _a2$1.some((x) => x.format))) {
+		if (!schema.anyOf) schema.anyOf = [];
+		if (schema.format) {
+			schema.anyOf.push({ format: schema.format });
+			delete schema.format;
+		}
+		schema.anyOf.push({
+			format: value,
+			...message && refs.errorMessages && { errorMessage: { format: message } }
+		});
+	} else schema.format = value;
+}
+function addPattern(schema, regex, message, refs) {
+	var _a2$1;
+	if (schema.pattern || ((_a2$1 = schema.allOf) == null ? void 0 : _a2$1.some((x) => x.pattern))) {
+		if (!schema.allOf) schema.allOf = [];
+		if (schema.pattern) {
+			schema.allOf.push({ pattern: schema.pattern });
+			delete schema.pattern;
+		}
+		schema.allOf.push({
+			pattern: stringifyRegExpWithFlags(regex, refs),
+			...message && refs.errorMessages && { errorMessage: { pattern: message } }
+		});
+	} else schema.pattern = stringifyRegExpWithFlags(regex, refs);
+}
+function stringifyRegExpWithFlags(regex, refs) {
+	var _a2$1;
+	if (!refs.applyRegexFlags || !regex.flags) return regex.source;
+	const flags = {
+		i: regex.flags.includes("i"),
+		m: regex.flags.includes("m"),
+		s: regex.flags.includes("s")
+	};
+	const source = flags.i ? regex.source.toLowerCase() : regex.source;
+	let pattern = "";
+	let isEscaped = false;
+	let inCharGroup = false;
+	let inCharRange = false;
+	for (let i = 0; i < source.length; i++) {
+		if (isEscaped) {
+			pattern += source[i];
+			isEscaped = false;
+			continue;
+		}
+		if (flags.i) {
+			if (inCharGroup) {
+				if (source[i].match(/[a-z]/)) {
+					if (inCharRange) {
+						pattern += source[i];
+						pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+						inCharRange = false;
+					} else if (source[i + 1] === "-" && ((_a2$1 = source[i + 2]) == null ? void 0 : _a2$1.match(/[a-z]/))) {
+						pattern += source[i];
+						inCharRange = true;
+					} else pattern += `${source[i]}${source[i].toUpperCase()}`;
+					continue;
+				}
+			} else if (source[i].match(/[a-z]/)) {
+				pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+				continue;
+			}
+		}
+		if (flags.m) {
+			if (source[i] === "^") {
+				pattern += `(^|(?<=[\r
+]))`;
+				continue;
+			} else if (source[i] === "$") {
+				pattern += `($|(?=[\r
+]))`;
+				continue;
+			}
+		}
+		if (flags.s && source[i] === ".") {
+			pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+			continue;
+		}
+		pattern += source[i];
+		if (source[i] === "\\") isEscaped = true;
+		else if (inCharGroup && source[i] === "]") inCharGroup = false;
+		else if (!inCharGroup && source[i] === "[") inCharGroup = true;
+	}
+	try {
+		new RegExp(pattern);
+	} catch (e) {
+		console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
+		return regex.source;
+	}
+	return pattern;
+}
+function parseRecordDef(def, refs) {
+	var _a2$1, _b2$1, _c, _d, _e, _f;
+	const schema = {
+		type: "object",
+		additionalProperties: (_a2$1 = parseDef(def.valueType._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "additionalProperties"]
+		})) != null ? _a2$1 : refs.allowedAdditionalProperties
+	};
+	if (((_b2$1 = def.keyType) == null ? void 0 : _b2$1._def.typeName) === ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+		const { type,...keyType } = parseStringDef(def.keyType._def, refs);
+		return {
+			...schema,
+			propertyNames: keyType
+		};
+	} else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind.ZodEnum) return {
+		...schema,
+		propertyNames: { enum: def.keyType._def.values }
+	};
+	else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+		const { type,...keyType } = parseBrandedDef(def.keyType._def, refs);
+		return {
+			...schema,
+			propertyNames: keyType
+		};
+	}
+	return schema;
+}
+function parseMapDef(def, refs) {
+	if (refs.mapStrategy === "record") return parseRecordDef(def, refs);
+	return {
+		type: "array",
+		maxItems: 125,
+		items: {
+			type: "array",
+			items: [parseDef(def.keyType._def, {
+				...refs,
+				currentPath: [
+					...refs.currentPath,
+					"items",
+					"items",
+					"0"
+				]
+			}) || parseAnyDef(), parseDef(def.valueType._def, {
+				...refs,
+				currentPath: [
+					...refs.currentPath,
+					"items",
+					"items",
+					"1"
+				]
+			}) || parseAnyDef()],
+			minItems: 2,
+			maxItems: 2
+		}
+	};
+}
+function parseNativeEnumDef(def) {
+	const object = def.values;
+	const actualValues = Object.keys(def.values).filter((key) => {
+		return typeof object[object[key]] !== "number";
+	}).map((key) => object[key]);
+	const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+	return {
+		type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+		enum: actualValues
+	};
+}
+function parseNeverDef() {
+	return { not: parseAnyDef() };
+}
+function parseNullDef() {
+	return { type: "null" };
+}
+var primitiveMappings = {
+	ZodString: "string",
+	ZodNumber: "number",
+	ZodBigInt: "integer",
+	ZodBoolean: "boolean",
+	ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+	const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+	if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+		const types = options.reduce((types2, x) => {
+			const type = primitiveMappings[x._def.typeName];
+			return type && !types2.includes(type) ? [...types2, type] : types2;
+		}, []);
+		return { type: types.length > 1 ? types : types[0] };
+	} else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+		const types = options.reduce((acc, x) => {
+			const type = typeof x._def.value;
+			switch (type) {
+				case "string":
+				case "number":
+				case "boolean": return [...acc, type];
+				case "bigint": return [...acc, "integer"];
+				case "object": if (x._def.value === null) return [...acc, "null"];
+				case "symbol":
+				case "undefined":
+				case "function":
+				default: return acc;
+			}
+		}, []);
+		if (types.length === options.length) {
+			const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+			return {
+				type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+				enum: options.reduce((acc, x) => {
+					return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+				}, [])
+			};
+		}
+	} else if (options.every((x) => x._def.typeName === "ZodEnum")) return {
+		type: "string",
+		enum: options.reduce((acc, x) => [...acc, ...x._def.values.filter((x2) => !acc.includes(x2))], [])
+	};
+	return asAnyOf(def, refs);
+}
+var asAnyOf = (def, refs) => {
+	const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"anyOf",
+			`${i}`
+		]
+	})).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+	return anyOf.length ? { anyOf } : void 0;
+};
+function parseNullableDef(def, refs) {
+	if ([
+		"ZodString",
+		"ZodNumber",
+		"ZodBigInt",
+		"ZodBoolean",
+		"ZodNull"
+	].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) return { type: [primitiveMappings[def.innerType._def.typeName], "null"] };
+	const base = parseDef(def.innerType._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"anyOf",
+			"0"
+		]
+	});
+	return base && { anyOf: [base, { type: "null" }] };
+}
+function parseNumberDef(def) {
+	const res = { type: "number" };
+	if (!def.checks) return res;
+	for (const check of def.checks) switch (check.kind) {
+		case "int":
+			res.type = "integer";
+			break;
+		case "min":
+			if (check.inclusive) res.minimum = check.value;
+			else res.exclusiveMinimum = check.value;
+			break;
+		case "max":
+			if (check.inclusive) res.maximum = check.value;
+			else res.exclusiveMaximum = check.value;
+			break;
+		case "multipleOf":
+			res.multipleOf = check.value;
+			break;
+	}
+	return res;
+}
+function parseObjectDef(def, refs) {
+	const result = {
+		type: "object",
+		properties: {}
+	};
+	const required = [];
+	const shape = def.shape();
+	for (const propName in shape) {
+		let propDef = shape[propName];
+		if (propDef === void 0 || propDef._def === void 0) continue;
+		const propOptional = safeIsOptional(propDef);
+		const parsedDef = parseDef(propDef._def, {
+			...refs,
+			currentPath: [
+				...refs.currentPath,
+				"properties",
+				propName
+			],
+			propertyPath: [
+				...refs.currentPath,
+				"properties",
+				propName
+			]
+		});
+		if (parsedDef === void 0) continue;
+		result.properties[propName] = parsedDef;
+		if (!propOptional) required.push(propName);
+	}
+	if (required.length) result.required = required;
+	const additionalProperties = decideAdditionalProperties(def, refs);
+	if (additionalProperties !== void 0) result.additionalProperties = additionalProperties;
+	return result;
+}
+function decideAdditionalProperties(def, refs) {
+	if (def.catchall._def.typeName !== "ZodNever") return parseDef(def.catchall._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "additionalProperties"]
+	});
+	switch (def.unknownKeys) {
+		case "passthrough": return refs.allowedAdditionalProperties;
+		case "strict": return refs.rejectedAdditionalProperties;
+		case "strip": return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+	}
+}
+function safeIsOptional(schema) {
+	try {
+		return schema.isOptional();
+	} catch (e) {
+		return true;
+	}
+}
+var parseOptionalDef = (def, refs) => {
+	var _a2$1;
+	if (refs.currentPath.toString() === ((_a2$1 = refs.propertyPath) == null ? void 0 : _a2$1.toString())) return parseDef(def.innerType._def, refs);
+	const innerSchema = parseDef(def.innerType._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"anyOf",
+			"1"
+		]
+	});
+	return innerSchema ? { anyOf: [{ not: parseAnyDef() }, innerSchema] } : parseAnyDef();
+};
+var parsePipelineDef = (def, refs) => {
+	if (refs.pipeStrategy === "input") return parseDef(def.in._def, refs);
+	else if (refs.pipeStrategy === "output") return parseDef(def.out._def, refs);
+	const a = parseDef(def.in._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"allOf",
+			"0"
+		]
+	});
+	return { allOf: [a, parseDef(def.out._def, {
+		...refs,
+		currentPath: [
+			...refs.currentPath,
+			"allOf",
+			a ? "1" : "0"
+		]
+	})].filter((x) => x !== void 0) };
+};
+function parsePromiseDef(def, refs) {
+	return parseDef(def.type._def, refs);
+}
+function parseSetDef(def, refs) {
+	const schema = {
+		type: "array",
+		uniqueItems: true,
+		items: parseDef(def.valueType._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "items"]
+		})
+	};
+	if (def.minSize) schema.minItems = def.minSize.value;
+	if (def.maxSize) schema.maxItems = def.maxSize.value;
+	return schema;
+}
+function parseTupleDef(def, refs) {
+	if (def.rest) return {
+		type: "array",
+		minItems: def.items.length,
+		items: def.items.map((x, i) => parseDef(x._def, {
+			...refs,
+			currentPath: [
+				...refs.currentPath,
+				"items",
+				`${i}`
+			]
+		})).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
+		additionalItems: parseDef(def.rest._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "additionalItems"]
+		})
+	};
+	else return {
+		type: "array",
+		minItems: def.items.length,
+		maxItems: def.items.length,
+		items: def.items.map((x, i) => parseDef(x._def, {
+			...refs,
+			currentPath: [
+				...refs.currentPath,
+				"items",
+				`${i}`
+			]
+		})).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+	};
+}
+function parseUndefinedDef() {
+	return { not: parseAnyDef() };
+}
+function parseUnknownDef() {
+	return parseAnyDef();
+}
+var parseReadonlyDef = (def, refs) => {
+	return parseDef(def.innerType._def, refs);
+};
+var selectParser = (def, typeName, refs) => {
+	switch (typeName) {
+		case ZodFirstPartyTypeKind.ZodString: return parseStringDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodNumber: return parseNumberDef(def);
+		case ZodFirstPartyTypeKind.ZodObject: return parseObjectDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBigInt: return parseBigintDef(def);
+		case ZodFirstPartyTypeKind.ZodBoolean: return parseBooleanDef();
+		case ZodFirstPartyTypeKind.ZodDate: return parseDateDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodUndefined: return parseUndefinedDef();
+		case ZodFirstPartyTypeKind.ZodNull: return parseNullDef();
+		case ZodFirstPartyTypeKind.ZodArray: return parseArrayDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodUnion:
+		case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: return parseUnionDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodIntersection: return parseIntersectionDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodTuple: return parseTupleDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodRecord: return parseRecordDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodLiteral: return parseLiteralDef(def);
+		case ZodFirstPartyTypeKind.ZodEnum: return parseEnumDef(def);
+		case ZodFirstPartyTypeKind.ZodNativeEnum: return parseNativeEnumDef(def);
+		case ZodFirstPartyTypeKind.ZodNullable: return parseNullableDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodOptional: return parseOptionalDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodMap: return parseMapDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodSet: return parseSetDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodLazy: return () => def.getter()._def;
+		case ZodFirstPartyTypeKind.ZodPromise: return parsePromiseDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodNaN:
+		case ZodFirstPartyTypeKind.ZodNever: return parseNeverDef();
+		case ZodFirstPartyTypeKind.ZodEffects: return parseEffectsDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodAny: return parseAnyDef();
+		case ZodFirstPartyTypeKind.ZodUnknown: return parseUnknownDef();
+		case ZodFirstPartyTypeKind.ZodDefault: return parseDefaultDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBranded: return parseBrandedDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodReadonly: return parseReadonlyDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodCatch: return parseCatchDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodPipeline: return parsePipelineDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodFunction:
+		case ZodFirstPartyTypeKind.ZodVoid:
+		case ZodFirstPartyTypeKind.ZodSymbol: return;
+		default: return /* @__PURE__ */ ((_) => void 0)(typeName);
+	}
+};
+var getRelativePath = (pathA, pathB) => {
+	let i = 0;
+	for (; i < pathA.length && i < pathB.length; i++) if (pathA[i] !== pathB[i]) break;
+	return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+function parseDef(def, refs, forceResolution = false) {
+	var _a2$1;
+	const seenItem = refs.seen.get(def);
+	if (refs.override) {
+		const overrideResult = (_a2$1 = refs.override) == null ? void 0 : _a2$1.call(refs, def, refs, seenItem, forceResolution);
+		if (overrideResult !== ignoreOverride) return overrideResult;
+	}
+	if (seenItem && !forceResolution) {
+		const seenSchema = get$ref(seenItem, refs);
+		if (seenSchema !== void 0) return seenSchema;
+	}
+	const newItem = {
+		def,
+		path: refs.currentPath,
+		jsonSchema: void 0
+	};
+	refs.seen.set(def, newItem);
+	const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+	const jsonSchema2 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+	if (jsonSchema2) addMeta(def, refs, jsonSchema2);
+	if (refs.postProcess) {
+		const postProcessResult = refs.postProcess(jsonSchema2, def, refs);
+		newItem.jsonSchema = jsonSchema2;
+		return postProcessResult;
+	}
+	newItem.jsonSchema = jsonSchema2;
+	return jsonSchema2;
+}
+var get$ref = (item, refs) => {
+	switch (refs.$refStrategy) {
+		case "root": return { $ref: item.path.join("/") };
+		case "relative": return { $ref: getRelativePath(refs.currentPath, item.path) };
+		case "none":
+		case "seen":
+			if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+				console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+				return parseAnyDef();
+			}
+			return refs.$refStrategy === "seen" ? parseAnyDef() : void 0;
+	}
+};
+var addMeta = (def, refs, jsonSchema2) => {
+	if (def.description) jsonSchema2.description = def.description;
+	return jsonSchema2;
+};
+var getRefs = (options) => {
+	const _options = getDefaultOptions(options);
+	const currentPath = _options.name !== void 0 ? [
+		..._options.basePath,
+		_options.definitionPath,
+		_options.name
+	] : _options.basePath;
+	return {
+		..._options,
+		currentPath,
+		propertyPath: void 0,
+		seen: new Map(Object.entries(_options.definitions).map(([name2$1, def]) => [def._def, {
+			def: def._def,
+			path: [
+				..._options.basePath,
+				_options.definitionPath,
+				name2$1
+			],
+			jsonSchema: void 0
+		}]))
+	};
+};
+var zod3ToJsonSchema = (schema, options) => {
+	var _a2$1;
+	const refs = getRefs(options);
+	let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name3$1, schema2]) => {
+		var _a3$1;
+		return {
+			...acc,
+			[name3$1]: (_a3$1 = parseDef(schema2._def, {
+				...refs,
+				currentPath: [
+					...refs.basePath,
+					refs.definitionPath,
+					name3$1
+				]
+			}, true)) != null ? _a3$1 : parseAnyDef()
+		};
+	}, {}) : void 0;
+	const name2$1 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
+	const main = (_a2$1 = parseDef(schema._def, name2$1 === void 0 ? refs : {
+		...refs,
+		currentPath: [
+			...refs.basePath,
+			refs.definitionPath,
+			name2$1
+		]
+	}, false)) != null ? _a2$1 : parseAnyDef();
+	const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+	if (title !== void 0) main.title = title;
+	const combined = name2$1 === void 0 ? definitions ? {
+		...main,
+		[refs.definitionPath]: definitions
+	} : main : {
+		$ref: [
+			...refs.$refStrategy === "relative" ? [] : refs.basePath,
+			refs.definitionPath,
+			name2$1
+		].join("/"),
+		[refs.definitionPath]: {
+			...definitions,
+			[name2$1]: main
+		}
+	};
+	combined.$schema = "http://json-schema.org/draft-07/schema#";
+	return combined;
+};
+var schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
+function lazySchema(createSchema) {
+	let schema;
+	return () => {
+		if (schema == null) schema = createSchema();
+		return schema;
+	};
+}
+function jsonSchema(jsonSchema2, { validate } = {}) {
+	return {
+		[schemaSymbol]: true,
+		_type: void 0,
+		get jsonSchema() {
+			if (typeof jsonSchema2 === "function") jsonSchema2 = jsonSchema2();
+			return jsonSchema2;
+		},
+		validate
+	};
+}
+function isSchema(value) {
+	return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+	return schema == null ? jsonSchema({
+		properties: {},
+		additionalProperties: false
+	}) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
+}
+function standardSchema(standardSchema2) {
+	return jsonSchema(() => addAdditionalPropertiesToJsonSchema(standardSchema2["~standard"].jsonSchema.input({ target: "draft-07" })), { validate: async (value) => {
+		const result = await standardSchema2["~standard"].validate(value);
+		return "value" in result ? {
+			success: true,
+			value: result.value
+		} : {
+			success: false,
+			error: new TypeValidationError({
+				value,
+				cause: result.issues
+			})
+		};
+	} });
+}
+function zod3Schema(zodSchema2, options) {
+	var _a2$1;
+	const useReferences = (_a2$1 = options == null ? void 0 : options.useReferences) != null ? _a2$1 : false;
+	return jsonSchema(() => zod3ToJsonSchema(zodSchema2, { $refStrategy: useReferences ? "root" : "none" }), { validate: async (value) => {
+		const result = await zodSchema2.safeParseAsync(value);
+		return result.success ? {
+			success: true,
+			value: result.data
+		} : {
+			success: false,
+			error: result.error
+		};
+	} });
+}
+function zod4Schema(zodSchema2, options) {
+	var _a2$1;
+	const useReferences = (_a2$1 = options == null ? void 0 : options.useReferences) != null ? _a2$1 : false;
+	return jsonSchema(() => addAdditionalPropertiesToJsonSchema(z4.toJSONSchema(zodSchema2, {
+		target: "draft-7",
+		io: "input",
+		reused: useReferences ? "ref" : "inline"
+	})), { validate: async (value) => {
+		const result = await z4.safeParseAsync(zodSchema2, value);
+		return result.success ? {
+			success: true,
+			value: result.data
+		} : {
+			success: false,
+			error: result.error
+		};
+	} });
+}
+function isZod4Schema(zodSchema2) {
+	return "_zod" in zodSchema2;
+}
+function zodSchema(zodSchema2, options) {
+	if (isZod4Schema(zodSchema2)) return zod4Schema(zodSchema2, options);
+	else return zod3Schema(zodSchema2, options);
+}
+async function validateTypes({ value, schema, context }) {
+	const result = await safeValidateTypes({
+		value,
+		schema,
+		context
+	});
+	if (!result.success) throw TypeValidationError.wrap({
+		value,
+		cause: result.error,
+		context
+	});
+	return result.value;
+}
+async function safeValidateTypes({ value, schema, context }) {
+	const actualSchema = asSchema(schema);
+	try {
+		if (actualSchema.validate == null) return {
+			success: true,
+			value,
+			rawValue: value
+		};
+		const result = await actualSchema.validate(value);
+		if (result.success) return {
+			success: true,
+			value: result.value,
+			rawValue: value
+		};
+		return {
+			success: false,
+			error: TypeValidationError.wrap({
+				value,
+				cause: result.error,
+				context
+			}),
+			rawValue: value
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: TypeValidationError.wrap({
+				value,
+				cause: error,
+				context
+			}),
+			rawValue: value
+		};
+	}
+}
+async function parseJSON({ text, schema }) {
+	try {
+		const value = secureJsonParse(text);
+		if (schema == null) return value;
+		return validateTypes({
+			value,
+			schema
+		});
+	} catch (error) {
+		if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) throw error;
+		throw new JSONParseError({
+			text,
+			cause: error
+		});
+	}
+}
+async function safeParseJSON({ text, schema }) {
+	try {
+		const value = secureJsonParse(text);
+		if (schema == null) return {
+			success: true,
+			value,
+			rawValue: value
+		};
+		return await safeValidateTypes({
+			value,
+			schema
+		});
+	} catch (error) {
+		return {
+			success: false,
+			error: JSONParseError.isInstance(error) ? error : new JSONParseError({
+				text,
+				cause: error
+			}),
+			rawValue: void 0
+		};
+	}
+}
+function isParsableJson(input) {
+	try {
+		secureJsonParse(input);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+function parseJsonEventStream({ stream, schema }) {
+	return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(new TransformStream({ async transform({ data }, controller) {
+		if (data === "[DONE]") return;
+		controller.enqueue(await safeParseJSON({
+			text: data,
+			schema
+		}));
+	} }));
+}
+async function parseProviderOptions({ provider, providerOptions, schema }) {
+	if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) return;
+	const parsedProviderOptions = await safeValidateTypes({
+		value: providerOptions[provider],
+		schema
+	});
+	if (!parsedProviderOptions.success) throw new InvalidArgumentError({
+		argument: "providerOptions",
+		message: `invalid ${provider} provider options`,
+		cause: parsedProviderOptions.error
+	});
+	return parsedProviderOptions.value;
+}
+var getOriginalFetch2 = () => globalThis.fetch;
+var postJsonToApi = async ({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch: fetch2 }) => postToApi({
+	url,
+	headers: {
+		"Content-Type": "application/json",
+		...headers
+	},
+	body: {
+		content: JSON.stringify(body),
+		values: body
+	},
+	failedResponseHandler,
+	successfulResponseHandler,
+	abortSignal,
+	fetch: fetch2
+});
+var postFormDataToApi = async ({ url, headers, formData, failedResponseHandler, successfulResponseHandler, abortSignal, fetch: fetch2 }) => postToApi({
+	url,
+	headers,
+	body: {
+		content: formData,
+		values: Object.fromEntries(formData.entries())
+	},
+	failedResponseHandler,
+	successfulResponseHandler,
+	abortSignal,
+	fetch: fetch2
+});
+var postToApi = async ({ url, headers = {}, body, successfulResponseHandler, failedResponseHandler, abortSignal, fetch: fetch2 = getOriginalFetch2() }) => {
+	try {
+		const response = await fetch2(url, {
+			method: "POST",
+			headers: withUserAgentSuffix(headers, `ai-sdk/provider-utils/${VERSION}`, getRuntimeEnvironmentUserAgent()),
+			body: body.content,
+			signal: abortSignal
+		});
+		const responseHeaders = extractResponseHeaders(response);
+		if (!response.ok) {
+			let errorInformation;
+			try {
+				errorInformation = await failedResponseHandler({
+					response,
+					url,
+					requestBodyValues: body.values
+				});
+			} catch (error) {
+				if (isAbortError(error) || APICallError.isInstance(error)) throw error;
+				throw new APICallError({
+					message: "Failed to process error response",
+					cause: error,
+					statusCode: response.status,
+					url,
+					responseHeaders,
+					requestBodyValues: body.values
+				});
+			}
+			throw errorInformation.value;
+		}
+		try {
+			return await successfulResponseHandler({
+				response,
+				url,
+				requestBodyValues: body.values
+			});
+		} catch (error) {
+			if (error instanceof Error) {
+				if (isAbortError(error) || APICallError.isInstance(error)) throw error;
+			}
+			throw new APICallError({
+				message: "Failed to process successful response",
+				cause: error,
+				statusCode: response.status,
+				url,
+				responseHeaders,
+				requestBodyValues: body.values
+			});
+		}
+	} catch (error) {
+		throw handleFetchError({
+			error,
+			url,
+			requestBodyValues: body.values
+		});
+	}
+};
+function tool(tool2) {
+	return tool2;
+}
+function createProviderToolFactory({ id, inputSchema }) {
+	return ({ execute, outputSchema, needsApproval, toModelOutput, onInputStart, onInputDelta, onInputAvailable,...args }) => tool({
+		type: "provider",
+		id,
+		args,
+		inputSchema,
+		outputSchema,
+		execute,
+		needsApproval,
+		toModelOutput,
+		onInputStart,
+		onInputDelta,
+		onInputAvailable
+	});
+}
+function createProviderToolFactoryWithOutputSchema({ id, inputSchema, outputSchema, supportsDeferredResults }) {
+	return ({ execute, needsApproval, toModelOutput, onInputStart, onInputDelta, onInputAvailable,...args }) => tool({
+		type: "provider",
+		id,
+		args,
+		inputSchema,
+		outputSchema,
+		execute,
+		needsApproval,
+		toModelOutput,
+		onInputStart,
+		onInputDelta,
+		onInputAvailable,
+		supportsDeferredResults
+	});
+}
+async function resolve(value) {
+	if (typeof value === "function") value = value();
+	return Promise.resolve(value);
+}
+var createJsonErrorResponseHandler = ({ errorSchema, errorToMessage, isRetryable }) => async ({ response, url, requestBodyValues }) => {
+	const responseBody = await response.text();
+	const responseHeaders = extractResponseHeaders(response);
+	if (responseBody.trim() === "") return {
+		responseHeaders,
+		value: new APICallError({
+			message: response.statusText,
+			url,
+			requestBodyValues,
+			statusCode: response.status,
+			responseHeaders,
+			responseBody,
+			isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+		})
+	};
+	try {
+		const parsedError = await parseJSON({
+			text: responseBody,
+			schema: errorSchema
+		});
+		return {
+			responseHeaders,
+			value: new APICallError({
+				message: errorToMessage(parsedError),
+				url,
+				requestBodyValues,
+				statusCode: response.status,
+				responseHeaders,
+				responseBody,
+				data: parsedError,
+				isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
+			})
+		};
+	} catch (parseError) {
+		return {
+			responseHeaders,
+			value: new APICallError({
+				message: response.statusText,
+				url,
+				requestBodyValues,
+				statusCode: response.status,
+				responseHeaders,
+				responseBody,
+				isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+			})
+		};
+	}
+};
+var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
+	const responseHeaders = extractResponseHeaders(response);
+	if (response.body == null) throw new EmptyResponseBodyError({});
+	return {
+		responseHeaders,
+		value: parseJsonEventStream({
+			stream: response.body,
+			schema: chunkSchema
+		})
+	};
+};
+var createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
+	const responseBody = await response.text();
+	const parsedResult = await safeParseJSON({
+		text: responseBody,
+		schema: responseSchema
+	});
+	const responseHeaders = extractResponseHeaders(response);
+	if (!parsedResult.success) throw new APICallError({
+		message: "Invalid JSON response",
+		cause: parsedResult.error,
+		statusCode: response.status,
+		responseHeaders,
+		responseBody,
+		url,
+		requestBodyValues
+	});
+	return {
+		responseHeaders,
+		value: parsedResult.value,
+		rawValue: parsedResult.rawValue
+	};
+};
+var createBinaryResponseHandler = () => async ({ response, url, requestBodyValues }) => {
+	const responseHeaders = extractResponseHeaders(response);
+	if (!response.body) throw new APICallError({
+		message: "Response body is empty",
+		url,
+		requestBodyValues,
+		statusCode: response.status,
+		responseHeaders,
+		responseBody: void 0
+	});
+	try {
+		const buffer = await response.arrayBuffer();
+		return {
+			responseHeaders,
+			value: new Uint8Array(buffer)
+		};
+	} catch (error) {
+		throw new APICallError({
+			message: "Failed to read response as array buffer",
+			url,
+			requestBodyValues,
+			statusCode: response.status,
+			responseHeaders,
+			responseBody: void 0,
+			cause: error
+		});
+	}
+};
+function withoutTrailingSlash(url) {
+	return url == null ? void 0 : url.replace(/\/$/, "");
+}
+
+//#endregion
+export { APICallError as A, postJsonToApi as C, withUserAgentSuffix as D, validateTypes as E, TooManyEmbeddingValuesForCallError as F, UnsupportedFunctionalityError as I, InvalidPromptError as M, InvalidResponseDataError as N, withoutTrailingSlash as O, NoSuchModelError as P, postFormDataToApi as S, safeParseJSON as T, loadApiKey as _, createBinaryResponseHandler as a, parseJSON as b, createJsonResponseHandler as c, createToolNameMapping as d, downloadBlob as f, lazySchema as g, isParsableJson as h, convertToFormData as i, InvalidArgumentError as j, zodSchema as k, createProviderToolFactory as l, isNonNullable as m, convertBase64ToUint8Array as n, createEventSourceResponseHandler as o, generateId as p, convertToBase64 as r, createJsonErrorResponseHandler as s, combineHeaders as t, createProviderToolFactoryWithOutputSchema as u, loadOptionalSetting as v, resolve as w, parseProviderOptions as x, mediaTypeToExtension as y };
+//# sourceMappingURL=dist-BYInIjS8.js.map