kassza 0.1.0

package/dist/storage/index.cjs

@@ -0,0 +1,643 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("../errors-B0QJhUW1.cjs");
+const require_binary = require("../binary-B89HM03_.cjs");
+const require_dates = require("../dates-PPxH0n5H.cjs");
+const require_shared = require("../shared-CrxlxI8n.cjs");
+//#region src/storage/keys.ts
+const DEFAULT_INVOICE_KEY_PREFIX = "szamlak";
+const DEFAULT_RECEIPT_KEY_PREFIX = "nyugtak";
+const KIND_FOLDERS = {
+	invoice: void 0,
+	proforma: "dijbekero",
+	advance: "elolegszamla",
+	final: "vegszamla",
+	corrective: "helyesbito",
+	storno: "sztorno",
+	deliveryNote: "szallitolevel"
+};
+const COMBINING_MARKS = /\p{M}/gu;
+function sanitizeKeySegment(value) {
+	return value.normalize("NFKD").replace(COMBINING_MARKS, "").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+}
+function datedPdfKey(prefix, folder, number, date) {
+	const fileName = sanitizeKeySegment(number);
+	if (fileName === "") throw new require_shared.StorageError(`A bizonylatszámból nem képezhető fájlnév: ${JSON.stringify(number)}`, { operation: "key" });
+	const [year = "", month = ""] = (date === void 0 ? require_dates.todayInBudapest() : require_dates.toAgentDate(date)).split("-");
+	return [
+		...prefix.split("/"),
+		folder ?? "",
+		year,
+		month
+	].map(sanitizeKeySegment).filter((segment) => segment !== "").concat(`${fileName}.pdf`).join("/");
+}
+function invoicePdfKey(input) {
+	return datedPdfKey(input.prefix ?? "szamlak", KIND_FOLDERS[input.type ?? "invoice"], input.number, input.date);
+}
+function receiptPdfKey(input) {
+	return datedPdfKey(input.prefix ?? "nyugtak", void 0, input.number, input.date);
+}
+//#endregion
+//#region src/storage/memory.ts
+const MEMORY_BASE_URL = "memory://storage";
+function memoryStorage(options = {}) {
+	const prefix = require_shared.normalizePrefix(options.prefix);
+	const files = /* @__PURE__ */ new Map();
+	const urlFor = (fullKey) => require_shared.joinPublicUrl(options.publicBaseUrl ?? MEMORY_BASE_URL, fullKey);
+	return {
+		files,
+		async put(key, body, putOptions) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			files.set(fullKey, {
+				body: body.slice(),
+				contentType: putOptions.contentType
+			});
+			return {
+				key,
+				url: urlFor(fullKey),
+				size: body.byteLength,
+				contentType: putOptions.contentType
+			};
+		},
+		async get(key) {
+			return files.get(require_shared.resolveKey(prefix, key))?.body.slice();
+		},
+		async delete(key) {
+			files.delete(require_shared.resolveKey(prefix, key));
+		},
+		async getUrl(key) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			if (!files.has(fullKey)) throw new require_shared.StorageError(`Nincs ilyen fájl: ${key}`, {
+				operation: "getUrl",
+				key,
+				status: 404
+			});
+			return urlFor(fullKey);
+		},
+		clear() {
+			files.clear();
+		}
+	};
+}
+//#endregion
+//#region src/storage/r2-binding.ts
+function r2BindingStorage(bucket, options = {}) {
+	const prefix = require_shared.normalizePrefix(options.prefix);
+	return {
+		async put(key, body, putOptions) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			const object = await require_shared.guardStorageCall("R2", "put", key, () => bucket.put(fullKey, body, { httpMetadata: { contentType: putOptions.contentType } }));
+			if (!object) throw new require_shared.StorageError("Az R2 nem mentette el a fájlt (a put null-t adott vissza).", {
+				operation: "put",
+				key
+			});
+			return {
+				key,
+				url: options.publicBaseUrl ? require_shared.joinPublicUrl(options.publicBaseUrl, fullKey) : void 0,
+				size: object.size,
+				contentType: putOptions.contentType
+			};
+		},
+		async get(key) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			const object = await require_shared.guardStorageCall("R2", "get", key, () => bucket.get(fullKey));
+			if (!object) return void 0;
+			return new Uint8Array(await require_shared.guardStorageCall("R2", "get", key, () => object.arrayBuffer()));
+		},
+		async delete(key) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			await require_shared.guardStorageCall("R2", "delete", key, () => bucket.delete(fullKey));
+		},
+		async getUrl(key, urlOptions = {}) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			if (urlOptions.expiresInSeconds !== void 0) throw require_shared.unsupportedSignedUrl("r2BindingStorage", key);
+			if (!options.publicBaseUrl) throw require_shared.missingPublicBaseUrl("r2BindingStorage", key);
+			return require_shared.joinPublicUrl(options.publicBaseUrl, fullKey);
+		}
+	};
+}
+//#endregion
+//#region src/storage/s3.ts
+function statusOf(error) {
+	const status = error?.$metadata?.httpStatusCode;
+	return typeof status === "number" ? status : void 0;
+}
+function isNotFound$1(error) {
+	const name = error?.name;
+	return name === "NoSuchKey" || name === "NotFound" || statusOf(error) === 404;
+}
+function wrap(operation, key, error) {
+	return new require_shared.StorageError(`S3 hiba (${operation}): ${require_shared.describeError(error)}`, {
+		operation,
+		key,
+		status: statusOf(error),
+		cause: error
+	});
+}
+function missingCommand(name, key, operation) {
+	return new require_shared.StorageError(`Ehhez a művelethez add meg a commands.${name} osztályt.`, {
+		operation,
+		key
+	});
+}
+async function readBody(output) {
+	const body = output?.Body;
+	if (!body || typeof body.transformToByteArray !== "function") throw new Error("A GetObject válasza nem tartalmaz olvasható Body-t.");
+	return await body.transformToByteArray();
+}
+function s3Storage(options) {
+	const prefix = require_shared.normalizePrefix(options.prefix);
+	const { client, bucket, commands } = options;
+	return {
+		async put(key, body, putOptions) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			try {
+				await client.send(new commands.PutObjectCommand({
+					Bucket: bucket,
+					Key: fullKey,
+					Body: body,
+					ContentType: putOptions.contentType,
+					ContentLength: body.byteLength
+				}));
+			} catch (error) {
+				throw wrap("put", key, error);
+			}
+			return {
+				key,
+				url: options.publicBaseUrl ? require_shared.joinPublicUrl(options.publicBaseUrl, fullKey) : void 0,
+				size: body.byteLength,
+				contentType: putOptions.contentType
+			};
+		},
+		async get(key) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			if (!commands.GetObjectCommand) throw missingCommand("GetObjectCommand", key, "get");
+			try {
+				return await readBody(await client.send(new commands.GetObjectCommand({
+					Bucket: bucket,
+					Key: fullKey
+				})));
+			} catch (error) {
+				if (isNotFound$1(error)) return void 0;
+				throw wrap("get", key, error);
+			}
+		},
+		async delete(key) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			if (!commands.DeleteObjectCommand) throw missingCommand("DeleteObjectCommand", key, "delete");
+			try {
+				await client.send(new commands.DeleteObjectCommand({
+					Bucket: bucket,
+					Key: fullKey
+				}));
+			} catch (error) {
+				throw wrap("delete", key, error);
+			}
+		},
+		async getUrl(key, urlOptions = {}) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			if (urlOptions.expiresInSeconds === void 0 && options.publicBaseUrl) return require_shared.joinPublicUrl(options.publicBaseUrl, fullKey);
+			if (!options.getSignedUrl || !commands.GetObjectCommand) throw new require_shared.StorageError("URL készítéséhez add meg a publicBaseUrl opciót, vagy aláírt URL-hez a getSignedUrl függvényt (@aws-sdk/s3-request-presigner) és a commands.GetObjectCommand osztályt.", {
+				operation: "getUrl",
+				key
+			});
+			const expiresIn = require_shared.assertExpires(urlOptions.expiresInSeconds ?? 3600, require_shared.S3_MAX_PRESIGN_SECONDS, key);
+			try {
+				return await options.getSignedUrl(client, new commands.GetObjectCommand({
+					Bucket: bucket,
+					Key: fullKey
+				}), { expiresIn });
+			} catch (error) {
+				throw wrap("getUrl", key, error);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/storage/sigv4.ts
+const AWS_SIGV4_ALGORITHM = "AWS4-HMAC-SHA256";
+const UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
+const encoder = new TextEncoder();
+function toHex(buffer) {
+	return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function toBuffer(data) {
+	return typeof data === "string" ? require_shared.toArrayBuffer(encoder.encode(data)) : require_shared.toArrayBuffer(data);
+}
+async function sha256Hex(data) {
+	return toHex(await crypto.subtle.digest("SHA-256", toBuffer(data)));
+}
+async function hmac(key, data) {
+	const cryptoKey = await crypto.subtle.importKey("raw", key, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	return crypto.subtle.sign("HMAC", cryptoKey, toBuffer(data));
+}
+function toAmzDate(date) {
+	return date.toISOString().replace(/[:-]|\.\d{3}/g, "");
+}
+function canonicalPath(url) {
+	return url.pathname.split("/").map((segment) => require_shared.encodeRfc3986(decodeURIComponent(segment))).join("/");
+}
+function canonicalQuery(params) {
+	return [...params].map(([name, value]) => [require_shared.encodeRfc3986(name), require_shared.encodeRfc3986(value)]).sort(([nameA, valueA], [nameB, valueB]) => nameA === nameB ? valueA < valueB ? -1 : 1 : nameA < nameB ? -1 : 1).map(([name, value]) => `${name}=${value}`).join("&");
+}
+function normalizeHeaders(headers) {
+	const normalized = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(headers)) normalized.set(name.toLowerCase(), value.trim().replace(/\s+/g, " "));
+	return new Map([...normalized].sort(([a], [b]) => a < b ? -1 : 1));
+}
+function canonicalRequest(input) {
+	const signedHeaders = [...input.headers.keys()].join(";");
+	const headerLines = [...input.headers].map(([name, value]) => `${name}:${value}\n`).join("");
+	return {
+		request: [
+			input.method.toUpperCase(),
+			canonicalPath(input.url),
+			canonicalQuery(input.url.searchParams),
+			headerLines,
+			signedHeaders,
+			input.payloadHash
+		].join("\n"),
+		signedHeaders
+	};
+}
+async function signCanonical(scope, amzDate, request) {
+	const day = amzDate.slice(0, 8);
+	const credentialScope = `${day}/${scope.region}/${scope.service}/aws4_request`;
+	const stringToSign = [
+		AWS_SIGV4_ALGORITHM,
+		amzDate,
+		credentialScope,
+		await sha256Hex(request)
+	].join("\n");
+	return {
+		signature: toHex(await hmac(await hmac(await hmac(await hmac(await hmac(toBuffer(`AWS4${scope.credentials.secretAccessKey}`), day), scope.region), scope.service), "aws4_request"), stringToSign)),
+		credentialScope
+	};
+}
+async function signAwsRequest(input) {
+	const url = new URL(input.url);
+	const amzDate = toAmzDate(input.date ?? /* @__PURE__ */ new Date());
+	const payloadHash = input.payloadHash ?? await sha256Hex(input.body ?? "");
+	const extra = {
+		host: url.host,
+		"x-amz-date": amzDate
+	};
+	if (input.service === "s3") extra["x-amz-content-sha256"] = payloadHash;
+	if (input.credentials.sessionToken) extra["x-amz-security-token"] = input.credentials.sessionToken;
+	const headers = normalizeHeaders({
+		...input.headers,
+		...extra
+	});
+	const { request, signedHeaders } = canonicalRequest({
+		method: input.method,
+		url,
+		headers,
+		payloadHash
+	});
+	const { signature, credentialScope } = await signCanonical(input, amzDate, request);
+	const result = {};
+	for (const [name, value] of headers) if (name !== "host") result[name] = value;
+	result.authorization = `${AWS_SIGV4_ALGORITHM} Credential=${input.credentials.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+	return result;
+}
+async function presignAwsUrl(input) {
+	const url = new URL(input.url);
+	const amzDate = toAmzDate(input.date ?? /* @__PURE__ */ new Date());
+	const credentialScope = `${amzDate.slice(0, 8)}/${input.region}/${input.service}/aws4_request`;
+	url.searchParams.set("X-Amz-Algorithm", AWS_SIGV4_ALGORITHM);
+	url.searchParams.set("X-Amz-Credential", `${input.credentials.accessKeyId}/${credentialScope}`);
+	url.searchParams.set("X-Amz-Date", amzDate);
+	url.searchParams.set("X-Amz-Expires", String(input.expiresInSeconds));
+	if (input.credentials.sessionToken) url.searchParams.set("X-Amz-Security-Token", input.credentials.sessionToken);
+	url.searchParams.set("X-Amz-SignedHeaders", "host");
+	const { request } = canonicalRequest({
+		method: input.method,
+		url,
+		headers: /* @__PURE__ */ new Map([["host", url.host]]),
+		payloadHash: UNSIGNED_PAYLOAD
+	});
+	const { signature } = await signCanonical(input, amzDate, request);
+	const query = `${canonicalQuery(url.searchParams)}&X-Amz-Signature=${signature}`;
+	return `${url.origin}${canonicalPath(url)}?${query}`;
+}
+//#endregion
+//#region src/storage/s3-fetch.ts
+function requireOption(value, name) {
+	if (typeof value !== "string" || value.trim() === "") throw new require_errors.SzamlazzError(`Az s3FetchStorage ${name} opciója kötelező.`, { category: "configuration" });
+	return value;
+}
+function bucketBaseUrl(options) {
+	const bucket = options.bucket;
+	if (options.endpoint === void 0) return options.forcePathStyle ?? bucket.includes(".") ? `https://s3.${options.region}.amazonaws.com/${bucket}` : `https://${bucket}.s3.${options.region}.amazonaws.com`;
+	let endpoint;
+	try {
+		endpoint = new URL(options.endpoint);
+	} catch (error) {
+		throw new require_errors.SzamlazzError(`Érvénytelen S3 endpoint: ${options.endpoint}`, {
+			category: "configuration",
+			cause: error
+		});
+	}
+	const basePath = endpoint.pathname.replace(/\/+$/, "");
+	if (options.forcePathStyle ?? true) return `${endpoint.origin}${basePath}/${bucket}`;
+	return `${endpoint.protocol}//${bucket}.${endpoint.host}${basePath}`;
+}
+function readS3ErrorCode(body) {
+	const code = /<Code>([^<]*)<\/Code>/.exec(body)?.[1];
+	const message = /<Message>([^<]*)<\/Message>/.exec(body)?.[1];
+	if (!code) return void 0;
+	return message ? `${code}: ${message}` : code;
+}
+function s3FetchStorage(options) {
+	requireOption(options.bucket, "bucket");
+	requireOption(options.region, "region");
+	const credentials = {
+		accessKeyId: requireOption(options.accessKeyId, "accessKeyId"),
+		secretAccessKey: requireOption(options.secretAccessKey, "secretAccessKey"),
+		sessionToken: options.sessionToken
+	};
+	const baseUrl = bucketBaseUrl(options);
+	const prefix = require_shared.normalizePrefix(options.prefix);
+	const scope = {
+		credentials,
+		region: options.region,
+		service: "s3"
+	};
+	const objectUrl = (fullKey) => `${baseUrl}/${require_shared.encodeKeyPath(fullKey)}`;
+	async function send(operation, key, init) {
+		const doFetch = options.fetch ?? globalThis.fetch;
+		try {
+			return await doFetch(init.url, {
+				method: init.method,
+				headers: init.headers,
+				...init.body === void 0 ? {} : { body: init.body }
+			});
+		} catch (error) {
+			throw new require_shared.StorageError(`S3 hálózati hiba (${operation}): ${require_shared.describeError(error)}`, {
+				operation,
+				key,
+				cause: error
+			});
+		}
+	}
+	async function failure(operation, key, response) {
+		const detail = readS3ErrorCode(await response.text().catch(() => "")) ?? response.statusText;
+		return new require_shared.StorageError(`S3 hiba (${operation}, HTTP ${response.status})${detail ? `: ${detail}` : ""}`, {
+			operation,
+			key,
+			status: response.status
+		});
+	}
+	return {
+		async put(key, body, putOptions) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			const url = objectUrl(fullKey);
+			const response = await send("put", key, {
+				method: "PUT",
+				url,
+				headers: await signAwsRequest({
+					...scope,
+					method: "PUT",
+					url,
+					headers: { "content-type": putOptions.contentType },
+					payloadHash: await sha256Hex(body)
+				}),
+				body: require_shared.toArrayBuffer(body)
+			});
+			if (!response.ok) throw await failure("put", key, response);
+			return {
+				key,
+				url: options.publicBaseUrl ? require_shared.joinPublicUrl(options.publicBaseUrl, fullKey) : void 0,
+				size: body.byteLength,
+				contentType: putOptions.contentType
+			};
+		},
+		async get(key) {
+			const url = objectUrl(require_shared.resolveKey(prefix, key));
+			const response = await send("get", key, {
+				method: "GET",
+				url,
+				headers: await signAwsRequest({
+					...scope,
+					method: "GET",
+					url
+				})
+			});
+			if (response.status === 404) return void 0;
+			if (!response.ok) throw await failure("get", key, response);
+			return new Uint8Array(await response.arrayBuffer());
+		},
+		async delete(key) {
+			const url = objectUrl(require_shared.resolveKey(prefix, key));
+			const response = await send("delete", key, {
+				method: "DELETE",
+				url,
+				headers: await signAwsRequest({
+					...scope,
+					method: "DELETE",
+					url
+				})
+			});
+			if (!response.ok && response.status !== 404) throw await failure("delete", key, response);
+		},
+		async getUrl(key, urlOptions = {}) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			if (urlOptions.expiresInSeconds === void 0 && options.publicBaseUrl) return require_shared.joinPublicUrl(options.publicBaseUrl, fullKey);
+			return presignAwsUrl({
+				...scope,
+				method: "GET",
+				url: objectUrl(fullKey),
+				expiresInSeconds: require_shared.assertExpires(urlOptions.expiresInSeconds ?? 3600, require_shared.S3_MAX_PRESIGN_SECONDS, key)
+			});
+		}
+	};
+}
+//#endregion
+//#region src/storage/store-pdf.ts
+async function storePdf(storage, key, pdf) {
+	if (!require_binary.isPdf(pdf)) throw new require_shared.StorageError("A tárolandó tartalom nem PDF (hiányzik a %PDF fejléc).", {
+		operation: "put",
+		key
+	});
+	return storage.put(key, pdf, { contentType: require_shared.PDF_CONTENT_TYPE });
+}
+//#endregion
+//#region src/storage/supabase.ts
+const SUPABASE_MAX_SIGNED_URL_SECONDS = 31536e3;
+function isNotFound(error) {
+	return error.status === 404 || error.statusCode === "404" || /not[\s_-]?found/i.test(error.message);
+}
+const run = (operation, key, call) => require_shared.guardStorageCall("Supabase Storage", operation, key, call);
+function failure(operation, key, error) {
+	return new require_shared.StorageError(`Supabase Storage hiba (${operation}): ${error?.message ?? "üres válasz"}`, {
+		operation,
+		key,
+		status: error?.status,
+		cause: error ?? void 0
+	});
+}
+function supabaseStorage(options) {
+	const prefix = require_shared.normalizePrefix(options.prefix);
+	const bucket = () => options.client.storage.from(options.bucket);
+	return {
+		async put(key, body, putOptions) {
+			const path = require_shared.resolveKey(prefix, key);
+			const uploadOptions = {
+				contentType: putOptions.contentType,
+				upsert: options.upsert ?? true,
+				...options.cacheControl === void 0 ? {} : { cacheControl: options.cacheControl }
+			};
+			const result = await run("put", key, () => bucket().upload(path, body, uploadOptions));
+			if (!result.data) throw failure("put", key, result.error);
+			return {
+				key,
+				url: options.public ? bucket().getPublicUrl(path).data.publicUrl : void 0,
+				size: body.byteLength,
+				contentType: putOptions.contentType
+			};
+		},
+		async get(key) {
+			const path = require_shared.resolveKey(prefix, key);
+			const result = await run("get", key, () => bucket().download(path));
+			if (!result.data) {
+				if (result.error && isNotFound(result.error)) return void 0;
+				throw failure("get", key, result.error);
+			}
+			const blob = result.data;
+			return new Uint8Array(await blob.arrayBuffer());
+		},
+		async delete(key) {
+			const path = require_shared.resolveKey(prefix, key);
+			const result = await run("delete", key, () => bucket().remove([path]));
+			if (result.error) throw failure("delete", key, result.error);
+		},
+		async getUrl(key, urlOptions = {}) {
+			const path = require_shared.resolveKey(prefix, key);
+			if (options.public && urlOptions.expiresInSeconds === void 0) return bucket().getPublicUrl(path).data.publicUrl;
+			const expiresIn = require_shared.assertExpires(urlOptions.expiresInSeconds ?? 3600, SUPABASE_MAX_SIGNED_URL_SECONDS, key);
+			const result = await run("getUrl", key, () => bucket().createSignedUrl(path, expiresIn));
+			if (!result.data) throw failure("getUrl", key, result.error);
+			return result.data.signedUrl;
+		}
+	};
+}
+//#endregion
+//#region src/storage/uploadthing.ts
+const UPLOADTHING_MAX_CUSTOM_ID_LENGTH = 128;
+const UPLOADTHING_MAX_SIGNED_URL_SECONDS = 604800;
+function uploadthingStorage(options) {
+	const { utapi } = options;
+	const prefix = require_shared.normalizePrefix(options.prefix);
+	const uploadOptions = {
+		...options.acl === void 0 ? {} : { acl: options.acl },
+		...options.contentDisposition === void 0 ? {} : { contentDisposition: options.contentDisposition }
+	};
+	return {
+		async put(key, body, putOptions) {
+			const customId = require_shared.resolveKey(prefix, key);
+			if (customId.length > 128) throw new require_shared.StorageError(`Az UploadThing customId legfeljebb 128 karakter lehet, a kulcs ${customId.length} karakteres.`, {
+				operation: "key",
+				key
+			});
+			const file = Object.assign(new File([require_shared.toArrayBuffer(body)], require_shared.basename(customId), { type: putOptions.contentType }), { customId });
+			const result = await require_shared.guardStorageCall("UploadThing", "put", key, () => utapi.uploadFiles(file, uploadOptions));
+			if (!result.data) throw new require_shared.StorageError(`UploadThing hiba (put): ${result.error?.message ?? "ismeretlen hiba"}`, {
+				operation: "put",
+				key,
+				cause: result.error
+			});
+			return {
+				key,
+				url: result.data.ufsUrl ?? result.data.url,
+				size: result.data.size,
+				contentType: putOptions.contentType
+			};
+		},
+		async delete(key) {
+			const customId = require_shared.resolveKey(prefix, key);
+			await require_shared.guardStorageCall("UploadThing", "delete", key, () => utapi.deleteFiles(customId, { keyType: "customId" }));
+		},
+		async getUrl(key, urlOptions = {}) {
+			const customId = require_shared.resolveKey(prefix, key);
+			const generate = utapi.generateSignedURL;
+			if (!generate) throw new require_shared.StorageError("Ez az UploadThing verzió nem támogatja a generateSignedURL-t, frissíts uploadthing v7-re.", {
+				operation: "getUrl",
+				key
+			});
+			const expiresIn = require_shared.assertExpires(urlOptions.expiresInSeconds ?? 3600, UPLOADTHING_MAX_SIGNED_URL_SECONDS, key);
+			return (await require_shared.guardStorageCall("UploadThing", "getUrl", key, () => generate.call(utapi, customId, { expiresIn }))).ufsUrl;
+		}
+	};
+}
+//#endregion
+//#region src/storage/vercel-blob.ts
+function missingFunction(name, key, operation) {
+	return new require_shared.StorageError(`Ehhez a művelethez add át a @vercel/blob ${name} függvényét a vercelBlobStorage-nak.`, {
+		operation,
+		key
+	});
+}
+function vercelBlobStorage(options) {
+	const prefix = require_shared.normalizePrefix(options.prefix);
+	const commandOptions = options.token ? { token: options.token } : {};
+	return {
+		async put(key, body, putOptions) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			const blobOptions = {
+				access: options.access,
+				contentType: putOptions.contentType,
+				addRandomSuffix: false,
+				allowOverwrite: options.allowOverwrite ?? true,
+				...commandOptions,
+				...options.cacheControlMaxAge === void 0 ? {} : { cacheControlMaxAge: options.cacheControlMaxAge }
+			};
+			const blob = new Blob([require_shared.toArrayBuffer(body)], { type: putOptions.contentType });
+			return {
+				key,
+				url: (await require_shared.guardStorageCall("Vercel Blob", "put", key, () => options.put(fullKey, blob, blobOptions))).url,
+				size: body.byteLength,
+				contentType: putOptions.contentType
+			};
+		},
+		async delete(key) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			const del = options.del;
+			if (!del) throw missingFunction("del", key, "delete");
+			await require_shared.guardStorageCall("Vercel Blob", "delete", key, () => del(fullKey, commandOptions));
+		},
+		async getUrl(key, urlOptions = {}) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			if (urlOptions.expiresInSeconds !== void 0) throw require_shared.unsupportedSignedUrl("vercelBlobStorage", key);
+			const head = options.head;
+			if (!head) throw missingFunction("head", key, "getUrl");
+			return (await require_shared.guardStorageCall("Vercel Blob", "getUrl", key, () => head(fullKey, commandOptions))).url;
+		}
+	};
+}
+//#endregion
+exports.DEFAULT_INVOICE_KEY_PREFIX = DEFAULT_INVOICE_KEY_PREFIX;
+exports.DEFAULT_RECEIPT_KEY_PREFIX = DEFAULT_RECEIPT_KEY_PREFIX;
+exports.PDF_CONTENT_TYPE = require_shared.PDF_CONTENT_TYPE;
+exports.S3_MAX_PRESIGN_SECONDS = require_shared.S3_MAX_PRESIGN_SECONDS;
+exports.SUPABASE_MAX_SIGNED_URL_SECONDS = SUPABASE_MAX_SIGNED_URL_SECONDS;
+exports.StorageError = require_shared.StorageError;
+exports.UPLOADTHING_MAX_CUSTOM_ID_LENGTH = UPLOADTHING_MAX_CUSTOM_ID_LENGTH;
+exports.UPLOADTHING_MAX_SIGNED_URL_SECONDS = UPLOADTHING_MAX_SIGNED_URL_SECONDS;
+exports.assertStorageKey = require_shared.assertStorageKey;
+exports.guardStorageCall = require_shared.guardStorageCall;
+exports.invoicePdfKey = invoicePdfKey;
+exports.isStorageError = require_shared.isStorageError;
+exports.memoryStorage = memoryStorage;
+exports.presignAwsUrl = presignAwsUrl;
+exports.r2BindingStorage = r2BindingStorage;
+exports.receiptPdfKey = receiptPdfKey;
+exports.s3FetchStorage = s3FetchStorage;
+exports.s3Storage = s3Storage;
+exports.sanitizeKeySegment = sanitizeKeySegment;
+exports.signAwsRequest = signAwsRequest;
+exports.storePdf = storePdf;
+exports.supabaseStorage = supabaseStorage;
+exports.uploadthingStorage = uploadthingStorage;
+exports.vercelBlobStorage = vercelBlobStorage;