@codemation/core-nodes-ocr 0.2.5 → 0.2.7

package/dist/dist-Zdvm5pqX.cjs

@@ -0,0 +1,2464 @@
+const require_chunk = require('./chunk-BaqVhFee.cjs');
+let zod_v4 = require("zod/v4");
+zod_v4 = require_chunk.__toESM(zod_v4);
+let zod_v3 = require("zod/v3");
+zod_v3 = require_chunk.__toESM(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) !== zod_v3.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) === zod_v3.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) === zod_v3.ZodFirstPartyTypeKind.ZodEnum) return {
+		...schema,
+		propertyNames: { enum: def.keyType._def.values }
+	};
+	else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === zod_v3.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === zod_v3.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 zod_v3.ZodFirstPartyTypeKind.ZodString: return parseStringDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodNumber: return parseNumberDef(def);
+		case zod_v3.ZodFirstPartyTypeKind.ZodObject: return parseObjectDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodBigInt: return parseBigintDef(def);
+		case zod_v3.ZodFirstPartyTypeKind.ZodBoolean: return parseBooleanDef();
+		case zod_v3.ZodFirstPartyTypeKind.ZodDate: return parseDateDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodUndefined: return parseUndefinedDef();
+		case zod_v3.ZodFirstPartyTypeKind.ZodNull: return parseNullDef();
+		case zod_v3.ZodFirstPartyTypeKind.ZodArray: return parseArrayDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodUnion:
+		case zod_v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: return parseUnionDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodIntersection: return parseIntersectionDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodTuple: return parseTupleDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodRecord: return parseRecordDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodLiteral: return parseLiteralDef(def);
+		case zod_v3.ZodFirstPartyTypeKind.ZodEnum: return parseEnumDef(def);
+		case zod_v3.ZodFirstPartyTypeKind.ZodNativeEnum: return parseNativeEnumDef(def);
+		case zod_v3.ZodFirstPartyTypeKind.ZodNullable: return parseNullableDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodOptional: return parseOptionalDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodMap: return parseMapDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodSet: return parseSetDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodLazy: return () => def.getter()._def;
+		case zod_v3.ZodFirstPartyTypeKind.ZodPromise: return parsePromiseDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodNaN:
+		case zod_v3.ZodFirstPartyTypeKind.ZodNever: return parseNeverDef();
+		case zod_v3.ZodFirstPartyTypeKind.ZodEffects: return parseEffectsDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodAny: return parseAnyDef();
+		case zod_v3.ZodFirstPartyTypeKind.ZodUnknown: return parseUnknownDef();
+		case zod_v3.ZodFirstPartyTypeKind.ZodDefault: return parseDefaultDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodBranded: return parseBrandedDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodReadonly: return parseReadonlyDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodCatch: return parseCatchDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodPipeline: return parsePipelineDef(def, refs);
+		case zod_v3.ZodFirstPartyTypeKind.ZodFunction:
+		case zod_v3.ZodFirstPartyTypeKind.ZodVoid:
+		case zod_v3.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(zod_v4.toJSONSchema(zodSchema2, {
+		target: "draft-7",
+		io: "input",
+		reused: useReferences ? "ref" : "inline"
+	})), { validate: async (value) => {
+		const result = await zod_v4.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
+Object.defineProperty(exports, 'APICallError', {
+  enumerable: true,
+  get: function () {
+    return APICallError;
+  }
+});
+Object.defineProperty(exports, 'InvalidArgumentError', {
+  enumerable: true,
+  get: function () {
+    return InvalidArgumentError;
+  }
+});
+Object.defineProperty(exports, 'InvalidPromptError', {
+  enumerable: true,
+  get: function () {
+    return InvalidPromptError;
+  }
+});
+Object.defineProperty(exports, 'InvalidResponseDataError', {
+  enumerable: true,
+  get: function () {
+    return InvalidResponseDataError;
+  }
+});
+Object.defineProperty(exports, 'NoSuchModelError', {
+  enumerable: true,
+  get: function () {
+    return NoSuchModelError;
+  }
+});
+Object.defineProperty(exports, 'TooManyEmbeddingValuesForCallError', {
+  enumerable: true,
+  get: function () {
+    return TooManyEmbeddingValuesForCallError;
+  }
+});
+Object.defineProperty(exports, 'UnsupportedFunctionalityError', {
+  enumerable: true,
+  get: function () {
+    return UnsupportedFunctionalityError;
+  }
+});
+Object.defineProperty(exports, 'combineHeaders', {
+  enumerable: true,
+  get: function () {
+    return combineHeaders;
+  }
+});
+Object.defineProperty(exports, 'convertBase64ToUint8Array', {
+  enumerable: true,
+  get: function () {
+    return convertBase64ToUint8Array;
+  }
+});
+Object.defineProperty(exports, 'convertToBase64', {
+  enumerable: true,
+  get: function () {
+    return convertToBase64;
+  }
+});
+Object.defineProperty(exports, 'convertToFormData', {
+  enumerable: true,
+  get: function () {
+    return convertToFormData;
+  }
+});
+Object.defineProperty(exports, 'createBinaryResponseHandler', {
+  enumerable: true,
+  get: function () {
+    return createBinaryResponseHandler;
+  }
+});
+Object.defineProperty(exports, 'createEventSourceResponseHandler', {
+  enumerable: true,
+  get: function () {
+    return createEventSourceResponseHandler;
+  }
+});
+Object.defineProperty(exports, 'createJsonErrorResponseHandler', {
+  enumerable: true,
+  get: function () {
+    return createJsonErrorResponseHandler;
+  }
+});
+Object.defineProperty(exports, 'createJsonResponseHandler', {
+  enumerable: true,
+  get: function () {
+    return createJsonResponseHandler;
+  }
+});
+Object.defineProperty(exports, 'createProviderToolFactory', {
+  enumerable: true,
+  get: function () {
+    return createProviderToolFactory;
+  }
+});
+Object.defineProperty(exports, 'createProviderToolFactoryWithOutputSchema', {
+  enumerable: true,
+  get: function () {
+    return createProviderToolFactoryWithOutputSchema;
+  }
+});
+Object.defineProperty(exports, 'createToolNameMapping', {
+  enumerable: true,
+  get: function () {
+    return createToolNameMapping;
+  }
+});
+Object.defineProperty(exports, 'downloadBlob', {
+  enumerable: true,
+  get: function () {
+    return downloadBlob;
+  }
+});
+Object.defineProperty(exports, 'generateId', {
+  enumerable: true,
+  get: function () {
+    return generateId;
+  }
+});
+Object.defineProperty(exports, 'isNonNullable', {
+  enumerable: true,
+  get: function () {
+    return isNonNullable;
+  }
+});
+Object.defineProperty(exports, 'isParsableJson', {
+  enumerable: true,
+  get: function () {
+    return isParsableJson;
+  }
+});
+Object.defineProperty(exports, 'lazySchema', {
+  enumerable: true,
+  get: function () {
+    return lazySchema;
+  }
+});
+Object.defineProperty(exports, 'loadApiKey', {
+  enumerable: true,
+  get: function () {
+    return loadApiKey;
+  }
+});
+Object.defineProperty(exports, 'loadOptionalSetting', {
+  enumerable: true,
+  get: function () {
+    return loadOptionalSetting;
+  }
+});
+Object.defineProperty(exports, 'mediaTypeToExtension', {
+  enumerable: true,
+  get: function () {
+    return mediaTypeToExtension;
+  }
+});
+Object.defineProperty(exports, 'parseJSON', {
+  enumerable: true,
+  get: function () {
+    return parseJSON;
+  }
+});
+Object.defineProperty(exports, 'parseProviderOptions', {
+  enumerable: true,
+  get: function () {
+    return parseProviderOptions;
+  }
+});
+Object.defineProperty(exports, 'postFormDataToApi', {
+  enumerable: true,
+  get: function () {
+    return postFormDataToApi;
+  }
+});
+Object.defineProperty(exports, 'postJsonToApi', {
+  enumerable: true,
+  get: function () {
+    return postJsonToApi;
+  }
+});
+Object.defineProperty(exports, 'resolve', {
+  enumerable: true,
+  get: function () {
+    return resolve;
+  }
+});
+Object.defineProperty(exports, 'safeParseJSON', {
+  enumerable: true,
+  get: function () {
+    return safeParseJSON;
+  }
+});
+Object.defineProperty(exports, 'validateTypes', {
+  enumerable: true,
+  get: function () {
+    return validateTypes;
+  }
+});
+Object.defineProperty(exports, 'withUserAgentSuffix', {
+  enumerable: true,
+  get: function () {
+    return withUserAgentSuffix;
+  }
+});
+Object.defineProperty(exports, 'withoutTrailingSlash', {
+  enumerable: true,
+  get: function () {
+    return withoutTrailingSlash;
+  }
+});
+Object.defineProperty(exports, 'zodSchema', {
+  enumerable: true,
+  get: function () {
+    return zodSchema;
+  }
+});
+//# sourceMappingURL=dist-Zdvm5pqX.cjs.map