@gatwech/auth 1.0.0-beta.18

package/dist/auth-CBUoBX6o.mjs

@@ -0,0 +1,233 @@
+import { t as generateId } from "./utils-SOMB4Px5.mjs";
+import { r as getOrigin, t as getBaseURL } from "./url-VB2gAbTI.mjs";
+import { a as getEndpoints, n as checkEndpointConflicts, s as router } from "./api-0pR_I-Nx.mjs";
+import { a as verifyPassword, i as hashPassword } from "./crypto-Bb42eMrH.mjs";
+import { i as getCookies, t as createCookieGetter } from "./cookies-cJObLwn1.mjs";
+import { a as createInternalAdapter, r as getAdapter, s as getMigrations } from "./db-BrstmDhc.mjs";
+import { n as getKyselyDatabaseType } from "./dialect-CeddeGHf.mjs";
+import { t as getAuthTables } from "./get-tables-BQP7YW9c.mjs";
+import { t as checkPassword } from "./password-sVC4nePO.mjs";
+import { runWithAdapter } from "@gatwech/core/context";
+import { createLogger, env, isProduction, isTest } from "@gatwech/core/env";
+import { BASE_ERROR_CODES, PayvoAuthError } from "@gatwech/core/error";
+import { socialProviders } from "@gatwech/core/social-providers";
+import { defu } from "defu";
+import { createTelemetry } from "@gatwech/telemetry";
+
+//#region src/utils/constants.ts
+const DEFAULT_SECRET = "payvo-auth-secret-123456789";
+
+//#endregion
+//#region src/utils/is-promise.ts
+function isPromise(obj) {
+	return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+}
+
+//#endregion
+//#region src/init.ts
+const init = async (options) => {
+	const adapter = await getAdapter(options);
+	const plugins = options.plugins || [];
+	const internalPlugins = getInternalPlugins(options);
+	const logger$1 = createLogger(options.logger);
+	const baseURL = getBaseURL(options.baseURL, options.basePath);
+	const secret = options.secret || env.PAYVO_AUTH_SECRET || env.AUTH_SECRET || DEFAULT_SECRET;
+	if (secret === DEFAULT_SECRET) {
+		if (isProduction) logger$1.error("You are using the default secret. Please set `PAYVO_AUTH_SECRET` in your environment variables or pass `secret` in your auth config.");
+	}
+	options = {
+		...options,
+		secret,
+		baseURL: baseURL ? new URL(baseURL).origin : "",
+		basePath: options.basePath || "/api/auth",
+		plugins: plugins.concat(internalPlugins)
+	};
+	checkEndpointConflicts(options, logger$1);
+	const cookies = getCookies(options);
+	const tables = getAuthTables(options);
+	const providers = Object.entries(options.socialProviders || {}).map(([key, config]) => {
+		if (config == null) return null;
+		if (config.enabled === false) return null;
+		if (!config.clientId) logger$1.warn(`Social provider ${key} is missing clientId or clientSecret`);
+		const provider = socialProviders[key](config);
+		provider.disableImplicitSignUp = config.disableImplicitSignUp;
+		return provider;
+	}).filter((x) => x !== null);
+	const generateIdFunc = ({ model, size }) => {
+		if (typeof options.advanced?.generateId === "function") return options.advanced.generateId({
+			model,
+			size
+		});
+		if (typeof options?.advanced?.database?.generateId === "function") return options.advanced.database.generateId({
+			model,
+			size
+		});
+		return generateId(size);
+	};
+	const { publish } = await createTelemetry(options, {
+		adapter: adapter.id,
+		database: typeof options.database === "function" ? "adapter" : getKyselyDatabaseType(options.database) || "unknown"
+	});
+	const initOrPromise = runPluginInit({
+		appName: options.appName || "Payvo Auth",
+		socialProviders: providers,
+		options,
+		oauthConfig: {
+			storeStateStrategy: options.advanced?.oauthConfig?.storeStateStrategy || "database",
+			skipStateCookieCheck: !!options.advanced?.oauthConfig?.skipStateCookieCheck
+		},
+		tables,
+		trustedOrigins: getTrustedOrigins(options),
+		baseURL: baseURL || "",
+		sessionConfig: {
+			updateAge: options.session?.updateAge !== void 0 ? options.session.updateAge : 1440 * 60,
+			expiresIn: options.session?.expiresIn || 3600 * 24 * 7,
+			freshAge: options.session?.freshAge === void 0 ? 3600 * 24 : options.session.freshAge,
+			cookieRefreshCache: (() => {
+				const refreshCache = options.session?.cookieCache?.refreshCache;
+				const maxAge = options.session?.cookieCache?.maxAge || 300;
+				if (refreshCache === false || refreshCache === void 0) return false;
+				if (refreshCache === true) return {
+					enabled: true,
+					updateAge: Math.floor(maxAge * .2)
+				};
+				return {
+					enabled: true,
+					updateAge: refreshCache.updateAge !== void 0 ? refreshCache.updateAge : Math.floor(maxAge * .2)
+				};
+			})()
+		},
+		secret,
+		rateLimit: {
+			...options.rateLimit,
+			enabled: options.rateLimit?.enabled ?? isProduction,
+			window: options.rateLimit?.window || 10,
+			max: options.rateLimit?.max || 100,
+			storage: options.rateLimit?.storage || (options.secondaryStorage ? "secondary-storage" : "memory")
+		},
+		authCookies: cookies,
+		logger: logger$1,
+		generateId: generateIdFunc,
+		session: null,
+		secondaryStorage: options.secondaryStorage,
+		password: {
+			hash: options.emailAndPassword?.password?.hash || hashPassword,
+			verify: options.emailAndPassword?.password?.verify || verifyPassword,
+			config: {
+				minPasswordLength: options.emailAndPassword?.minPasswordLength || 8,
+				maxPasswordLength: options.emailAndPassword?.maxPasswordLength || 128
+			},
+			checkPassword
+		},
+		setNewSession(session) {
+			this.newSession = session;
+		},
+		newSession: null,
+		adapter,
+		internalAdapter: createInternalAdapter(adapter, {
+			options,
+			logger: logger$1,
+			hooks: options.databaseHooks ? [options.databaseHooks] : [],
+			generateId: generateIdFunc
+		}),
+		createAuthCookie: createCookieGetter(options),
+		async runMigrations() {
+			if (!options.database || "updateMany" in options.database) throw new PayvoAuthError("Database is not provided or it's an adapter. Migrations are only supported with a database instance.");
+			const { runMigrations } = await getMigrations(options);
+			await runMigrations();
+		},
+		publishTelemetry: publish,
+		skipCSRFCheck: !!options.advanced?.disableCSRFCheck,
+		skipOriginCheck: options.advanced?.disableOriginCheck !== void 0 ? options.advanced.disableOriginCheck : isTest() ? true : false
+	});
+	let context;
+	if (isPromise(initOrPromise)) ({context} = await initOrPromise);
+	else ({context} = initOrPromise);
+	return context;
+};
+async function runPluginInit(ctx) {
+	let options = ctx.options;
+	const plugins = options.plugins || [];
+	let context = ctx;
+	const dbHooks = [];
+	for (const plugin of plugins) if (plugin.init) {
+		let initPromise = plugin.init(context);
+		let result;
+		if (isPromise(initPromise)) result = await initPromise;
+		else result = initPromise;
+		if (typeof result === "object") {
+			if (result.options) {
+				const { databaseHooks,...restOpts } = result.options;
+				if (databaseHooks) dbHooks.push(databaseHooks);
+				options = defu(options, restOpts);
+			}
+			if (result.context) context = {
+				...context,
+				...result.context
+			};
+		}
+	}
+	dbHooks.push(options.databaseHooks);
+	context.internalAdapter = createInternalAdapter(ctx.adapter, {
+		options,
+		logger: ctx.logger,
+		hooks: dbHooks.filter((u) => u !== void 0),
+		generateId: ctx.generateId
+	});
+	context.options = options;
+	return { context };
+}
+function getInternalPlugins(options) {
+	const plugins = [];
+	if (options.advanced?.crossSubDomainCookies?.enabled) {}
+	return plugins;
+}
+function getTrustedOrigins(options) {
+	const baseURL = getBaseURL(options.baseURL, options.basePath);
+	if (!baseURL) return [];
+	const trustedOrigins = [new URL(baseURL).origin];
+	if (options.trustedOrigins && Array.isArray(options.trustedOrigins)) trustedOrigins.push(...options.trustedOrigins);
+	const envTrustedOrigins = env.PAYVO_AUTH_TRUSTED_ORIGINS;
+	if (envTrustedOrigins) trustedOrigins.push(...envTrustedOrigins.split(","));
+	if (trustedOrigins.filter((x) => !x).length) throw new PayvoAuthError("A provided trusted origin is invalid, make sure your trusted origins list is properly defined.");
+	return trustedOrigins;
+}
+
+//#endregion
+//#region src/auth.ts
+const payvoAuth = (options) => {
+	const authContext = init(options);
+	const { api } = getEndpoints(authContext, options);
+	return {
+		handler: async (request) => {
+			const ctx = await authContext;
+			const basePath = ctx.options.basePath || "/api/auth";
+			if (!ctx.options.baseURL) {
+				const baseURL = getBaseURL(void 0, basePath, request);
+				if (baseURL) {
+					ctx.baseURL = baseURL;
+					ctx.options.baseURL = getOrigin(ctx.baseURL) || void 0;
+				} else throw new PayvoAuthError("Could not get base URL from request. Please provide a valid base URL.");
+			}
+			ctx.trustedOrigins = [...options.trustedOrigins ? Array.isArray(options.trustedOrigins) ? options.trustedOrigins : await options.trustedOrigins(request) : [], ctx.options.baseURL];
+			const { handler } = router(ctx, options);
+			return runWithAdapter(ctx.adapter, () => handler(request));
+		},
+		api,
+		options,
+		$context: authContext,
+		$ERROR_CODES: {
+			...options.plugins?.reduce((acc, plugin) => {
+				if (plugin.$ERROR_CODES) return {
+					...acc,
+					...plugin.$ERROR_CODES
+				};
+				return acc;
+			}, {}),
+			...BASE_ERROR_CODES
+		}
+	};
+};
+
+//#endregion
+export { payvoAuth as t };

package/dist/bearer-Djf_awfo.mjs

@@ -0,0 +1,63 @@
+import { l as parseSetCookieHeader } from "./cookies-cJObLwn1.mjs";
+import { serializeSignedCookie } from "better-call";
+import { createAuthMiddleware } from "@gatwech/core/api";
+import { createHMAC } from "@gatwech/utils/hmac";
+
+//#region src/plugins/bearer/index.ts
+/**
+* Converts bearer token to session cookie
+*/
+const bearer = (options) => {
+	return {
+		id: "bearer",
+		hooks: {
+			before: [{
+				matcher(context) {
+					return Boolean(context.request?.headers.get("authorization") || context.headers?.get("authorization"));
+				},
+				handler: createAuthMiddleware(async (c) => {
+					const token = c.request?.headers.get("authorization")?.replace("Bearer ", "") || c.headers?.get("Authorization")?.replace("Bearer ", "");
+					if (!token) return;
+					let signedToken = "";
+					if (token.includes(".")) signedToken = token.replace("=", "");
+					else {
+						if (options?.requireSignature) return;
+						signedToken = (await serializeSignedCookie("", token, c.context.secret)).replace("=", "");
+					}
+					try {
+						const decodedToken = decodeURIComponent(signedToken);
+						if (!await createHMAC("SHA-256", "base64urlnopad").verify(c.context.secret, decodedToken.split(".")[0], decodedToken.split(".")[1])) return;
+					} catch (e) {
+						return;
+					}
+					const existingHeaders = c.request?.headers || c.headers;
+					const headers = new Headers({ ...Object.fromEntries(existingHeaders?.entries()) });
+					headers.append("cookie", `${c.context.authCookies.sessionToken.name}=${signedToken}`);
+					return { context: { headers } };
+				})
+			}],
+			after: [{
+				matcher(context) {
+					return true;
+				},
+				handler: createAuthMiddleware(async (ctx) => {
+					const setCookie = ctx.context.responseHeaders?.get("set-cookie");
+					if (!setCookie) return;
+					const parsedCookies = parseSetCookieHeader(setCookie);
+					const cookieName = ctx.context.authCookies.sessionToken.name;
+					const sessionCookie = parsedCookies.get(cookieName);
+					if (!sessionCookie || !sessionCookie.value || sessionCookie["max-age"] === 0) return;
+					const token = sessionCookie.value;
+					const exposedHeaders = ctx.context.responseHeaders?.get("access-control-expose-headers") || "";
+					const headersSet = new Set(exposedHeaders.split(",").map((header) => header.trim()).filter(Boolean));
+					headersSet.add("set-auth-token");
+					ctx.setHeader("set-auth-token", token);
+					ctx.setHeader("Access-Control-Expose-Headers", Array.from(headersSet).join(", "));
+				})
+			}]
+		}
+	};
+};
+
+//#endregion
+export { bearer as t };

package/dist/bun-sqlite-dialect-CeNvMaZz.mjs

@@ -0,0 +1,155 @@
+import { CompiledQuery, DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, DefaultQueryCompiler, Kysely, sql } from "kysely";
+
+//#region src/adapters/kysely-adapter/bun-sqlite-dialect.ts
+var BunSqliteAdapter = class {
+	get supportsCreateIfNotExists() {
+		return true;
+	}
+	get supportsTransactionalDdl() {
+		return false;
+	}
+	get supportsReturning() {
+		return true;
+	}
+	async acquireMigrationLock() {}
+	async releaseMigrationLock() {}
+	get supportsOutput() {
+		return true;
+	}
+};
+var BunSqliteDriver = class {
+	#config;
+	#connectionMutex = new ConnectionMutex();
+	#db;
+	#connection;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	async init() {
+		this.#db = this.#config.database;
+		this.#connection = new BunSqliteConnection(this.#db);
+		if (this.#config.onCreateConnection) await this.#config.onCreateConnection(this.#connection);
+	}
+	async acquireConnection() {
+		await this.#connectionMutex.lock();
+		return this.#connection;
+	}
+	async beginTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("begin"));
+	}
+	async commitTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("commit"));
+	}
+	async rollbackTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("rollback"));
+	}
+	async releaseConnection() {
+		this.#connectionMutex.unlock();
+	}
+	async destroy() {
+		this.#db?.close();
+	}
+};
+var BunSqliteConnection = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	executeQuery(compiledQuery) {
+		const { sql: sql$1, parameters } = compiledQuery;
+		const stmt = this.#db.prepare(sql$1);
+		return Promise.resolve({ rows: stmt.all(parameters) });
+	}
+	async *streamQuery() {
+		throw new Error("Streaming query is not supported by SQLite driver.");
+	}
+};
+var ConnectionMutex = class {
+	#promise;
+	#resolve;
+	async lock() {
+		while (this.#promise) await this.#promise;
+		this.#promise = new Promise((resolve) => {
+			this.#resolve = resolve;
+		});
+	}
+	unlock() {
+		const resolve = this.#resolve;
+		this.#promise = void 0;
+		this.#resolve = void 0;
+		resolve?.();
+	}
+};
+var BunSqliteIntrospector = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	async getSchemas() {
+		return [];
+	}
+	async getTables(options = { withInternalKyselyTables: false }) {
+		let query = this.#db.selectFrom("sqlite_schema").where("type", "=", "table").where("name", "not like", "sqlite_%").select("name").$castTo();
+		if (!options.withInternalKyselyTables) query = query.where("name", "!=", DEFAULT_MIGRATION_TABLE).where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
+		const tables = await query.execute();
+		return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+	}
+	async getMetadata(options) {
+		return { tables: await this.getTables(options) };
+	}
+	async #getTableMetadata(table) {
+		const db = this.#db;
+		const autoIncrementCol = (await db.selectFrom("sqlite_master").where("name", "=", table).select("sql").$castTo().execute())[0]?.sql?.split(/[\(\),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+		return {
+			name: table,
+			columns: (await db.selectFrom(sql`pragma_table_info(${table})`.as("table_info")).select([
+				"name",
+				"type",
+				"notnull",
+				"dflt_value"
+			]).execute()).map((col) => ({
+				name: col.name,
+				dataType: col.type,
+				isNullable: !col.notnull,
+				isAutoIncrementing: col.name === autoIncrementCol,
+				hasDefaultValue: col.dflt_value != null
+			})),
+			isView: true
+		};
+	}
+};
+var BunSqliteQueryCompiler = class extends DefaultQueryCompiler {
+	getCurrentParameterPlaceholder() {
+		return "?";
+	}
+	getLeftIdentifierWrapper() {
+		return "\"";
+	}
+	getRightIdentifierWrapper() {
+		return "\"";
+	}
+	getAutoIncrement() {
+		return "autoincrement";
+	}
+};
+var BunSqliteDialect = class {
+	#config;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	createDriver() {
+		return new BunSqliteDriver(this.#config);
+	}
+	createQueryCompiler() {
+		return new BunSqliteQueryCompiler();
+	}
+	createAdapter() {
+		return new BunSqliteAdapter();
+	}
+	createIntrospector(db) {
+		return new BunSqliteIntrospector(db);
+	}
+};
+
+//#endregion
+export { BunSqliteAdapter, BunSqliteDialect, BunSqliteDriver, BunSqliteIntrospector, BunSqliteQueryCompiler };

package/dist/captcha-BqaMxlKC.mjs

@@ -0,0 +1,178 @@
+import { t as getIp } from "./get-request-ip-DSjrEpGo.mjs";
+import { defineErrorCodes } from "@gatwech/core/utils";
+import { betterFetch } from "@better-fetch/fetch";
+
+//#region src/utils/middleware-response.ts
+const middlewareResponse = ({ message, status }) => ({ response: new Response(JSON.stringify({ message }), { status }) });
+
+//#endregion
+//#region src/plugins/captcha/constants.ts
+const defaultEndpoints = [
+	"/sign-up/email",
+	"/sign-in/email",
+	"/request-password-reset"
+];
+const Providers = {
+	CLOUDFLARE_TURNSTILE: "cloudflare-turnstile",
+	GOOGLE_RECAPTCHA: "google-recaptcha",
+	HCAPTCHA: "hcaptcha",
+	CAPTCHAFOX: "captchafox"
+};
+const siteVerifyMap = {
+	[Providers.CLOUDFLARE_TURNSTILE]: "https://challenges.cloudflare.com/turnstile/v0/siteverify",
+	[Providers.GOOGLE_RECAPTCHA]: "https://www.google.com/recaptcha/api/siteverify",
+	[Providers.HCAPTCHA]: "https://api.hcaptcha.com/siteverify",
+	[Providers.CAPTCHAFOX]: "https://api.captchafox.com/siteverify"
+};
+
+//#endregion
+//#region src/plugins/captcha/error-codes.ts
+const EXTERNAL_ERROR_CODES = defineErrorCodes({
+	VERIFICATION_FAILED: "Captcha verification failed",
+	MISSING_RESPONSE: "Missing CAPTCHA response",
+	UNKNOWN_ERROR: "Something went wrong"
+});
+const INTERNAL_ERROR_CODES = defineErrorCodes({
+	MISSING_SECRET_KEY: "Missing secret key",
+	SERVICE_UNAVAILABLE: "CAPTCHA service unavailable"
+});
+
+//#endregion
+//#region src/plugins/captcha/utils.ts
+const encodeToURLParams = (obj) => {
+	if (typeof obj !== "object" || obj === null || Array.isArray(obj)) throw new Error("Input must be a non-null object.");
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0 && value !== null) params.append(key, String(value));
+	return params.toString();
+};
+
+//#endregion
+//#region src/plugins/captcha/verify-handlers/captchafox.ts
+const captchaFox = async ({ siteVerifyURL, captchaResponse, secretKey, siteKey, remoteIP }) => {
+	const response = await betterFetch(siteVerifyURL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: encodeToURLParams({
+			secret: secretKey,
+			response: captchaResponse,
+			...siteKey && { sitekey: siteKey },
+			...remoteIP && { remoteIp: remoteIP }
+		})
+	});
+	if (!response.data || response.error) throw new Error(INTERNAL_ERROR_CODES.SERVICE_UNAVAILABLE);
+	if (!response.data.success) return middlewareResponse({
+		message: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED,
+		status: 403
+	});
+};
+
+//#endregion
+//#region src/plugins/captcha/verify-handlers/cloudflare-turnstile.ts
+const cloudflareTurnstile = async ({ siteVerifyURL, captchaResponse, secretKey, remoteIP }) => {
+	const response = await betterFetch(siteVerifyURL, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			secret: secretKey,
+			response: captchaResponse,
+			...remoteIP && { remoteip: remoteIP }
+		})
+	});
+	if (!response.data || response.error) throw new Error(INTERNAL_ERROR_CODES.SERVICE_UNAVAILABLE);
+	if (!response.data.success) return middlewareResponse({
+		message: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED,
+		status: 403
+	});
+};
+
+//#endregion
+//#region src/plugins/captcha/verify-handlers/google-recaptcha.ts
+const isV3 = (response) => {
+	return "score" in response && typeof response.score === "number";
+};
+const googleRecaptcha = async ({ siteVerifyURL, captchaResponse, secretKey, minScore = .5, remoteIP }) => {
+	const response = await betterFetch(siteVerifyURL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: encodeToURLParams({
+			secret: secretKey,
+			response: captchaResponse,
+			...remoteIP && { remoteip: remoteIP }
+		})
+	});
+	if (!response.data || response.error) throw new Error(INTERNAL_ERROR_CODES.SERVICE_UNAVAILABLE);
+	if (!response.data.success || isV3(response.data) && response.data.score < minScore) return middlewareResponse({
+		message: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED,
+		status: 403
+	});
+};
+
+//#endregion
+//#region src/plugins/captcha/verify-handlers/h-captcha.ts
+const hCaptcha = async ({ siteVerifyURL, captchaResponse, secretKey, siteKey, remoteIP }) => {
+	const response = await betterFetch(siteVerifyURL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: encodeToURLParams({
+			secret: secretKey,
+			response: captchaResponse,
+			...siteKey && { sitekey: siteKey },
+			...remoteIP && { remoteip: remoteIP }
+		})
+	});
+	if (!response.data || response.error) throw new Error(INTERNAL_ERROR_CODES.SERVICE_UNAVAILABLE);
+	if (!response.data.success) return middlewareResponse({
+		message: EXTERNAL_ERROR_CODES.VERIFICATION_FAILED,
+		status: 403
+	});
+};
+
+//#endregion
+//#region src/plugins/captcha/index.ts
+const captcha = (options) => ({
+	id: "captcha",
+	onRequest: async (request, ctx) => {
+		try {
+			if (!(options.endpoints?.length ? options.endpoints : defaultEndpoints).some((endpoint) => request.url.includes(endpoint))) return void 0;
+			if (!options.secretKey) throw new Error(INTERNAL_ERROR_CODES.MISSING_SECRET_KEY);
+			const captchaResponse = request.headers.get("x-captcha-response");
+			const remoteUserIP = getIp(request, ctx.options) ?? void 0;
+			if (!captchaResponse) return middlewareResponse({
+				message: EXTERNAL_ERROR_CODES.MISSING_RESPONSE,
+				status: 400
+			});
+			const handlerParams = {
+				siteVerifyURL: options.siteVerifyURLOverride || siteVerifyMap[options.provider],
+				captchaResponse,
+				secretKey: options.secretKey,
+				remoteIP: remoteUserIP
+			};
+			if (options.provider === Providers.CLOUDFLARE_TURNSTILE) return await cloudflareTurnstile(handlerParams);
+			if (options.provider === Providers.GOOGLE_RECAPTCHA) return await googleRecaptcha({
+				...handlerParams,
+				minScore: options.minScore
+			});
+			if (options.provider === Providers.HCAPTCHA) return await hCaptcha({
+				...handlerParams,
+				siteKey: options.siteKey
+			});
+			if (options.provider === Providers.CAPTCHAFOX) return await captchaFox({
+				...handlerParams,
+				siteKey: options.siteKey
+			});
+		} catch (_error) {
+			const errorMessage = _error instanceof Error ? _error.message : void 0;
+			ctx.logger.error(errorMessage ?? "Unknown error", {
+				endpoint: request.url,
+				message: _error
+			});
+			return middlewareResponse({
+				message: EXTERNAL_ERROR_CODES.UNKNOWN_ERROR,
+				status: 500
+			});
+		}
+	}
+});
+
+//#endregion
+export { captcha as t };

package/dist/chunk-BK_LfMhE.mjs

@@ -0,0 +1,40 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toDynamicImportESM = (isNodeMode) => (mod) => __toESM(mod.default, isNodeMode);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __toDynamicImportESM as a, __require as i, __export as n, __toESM as o, __reExport as r, __commonJS as t };