@gatwech/auth 1.0.0-beta.18

package/dist/types/index.d.mts

@@ -0,0 +1,6 @@
+import "../helper-tmxW3BHj.mjs";
+import { A as Where, B as InferPluginsFromClient, C as AdapterInstance, D as DBAdapterSchemaCreation, E as DBAdapterInstance, F as ClientStore, G as PayvoAuthClientPlugin, H as InferUserFromClient, I as InferActions, K as SessionQueryParams, L as InferAdditionalFromClient, M as AtomListener, N as ClientAtomListener, O as DBTransactionAdapter, P as ClientOptions, R as InferClientAPI, S as Adapter, T as DBAdapter, U as IsSignal, V as InferSessionFromClient, W as PayvoAuthClientOptions, _ as Verification, a as PayvoAuthRateLimitOptions, b as InferAPI, c as AdditionalSessionFieldsOutput, d as InferPluginTypes, f as InferSession, g as User, h as Session, i as PayvoAuthPlugin, j as init, k as TransactionAdapter, l as AdditionalUserFieldsInput, m as RateLimit, n as PayvoAuthCookies, o as Account, p as InferUser, q as Store, r as PayvoAuthOptions, s as AdditionalSessionFieldsInput, t as PayvoAuthAdvancedOptions, u as AdditionalUserFieldsOutput, v as FilterActions, w as AdapterSchemaCreation, x as InferSessionAPI, y as FilteredAPI, z as InferErrorCodes } from "../index-Cxi7TbLE.mjs";
+import "../types-B1OL7hyf.mjs";
+import "../index-65G5U5DB-DSdjzreF.mjs";
+import { n as InferPluginErrorCodes, t as InferOptionSchema } from "../plugins-hFZT3hmK.mjs";
+export { Account, Adapter, AdapterInstance, AdapterSchemaCreation, AdditionalSessionFieldsInput, AdditionalSessionFieldsOutput, AdditionalUserFieldsInput, AdditionalUserFieldsOutput, AtomListener, ClientAtomListener, ClientOptions, ClientStore, DBAdapter, DBAdapterInstance, DBAdapterSchemaCreation, DBTransactionAdapter, FilterActions, FilteredAPI, InferAPI, InferActions, InferAdditionalFromClient, InferClientAPI, InferErrorCodes, InferOptionSchema, InferPluginErrorCodes, InferPluginTypes, InferPluginsFromClient, InferSession, InferSessionAPI, InferSessionFromClient, InferUser, InferUserFromClient, IsSignal, PayvoAuthAdvancedOptions, PayvoAuthClientOptions, PayvoAuthClientPlugin, PayvoAuthCookies, PayvoAuthOptions, PayvoAuthPlugin, PayvoAuthRateLimitOptions, RateLimit, Session, SessionQueryParams, Store, TransactionAdapter, User, Verification, Where, init };

package/dist/types/index.mjs

@@ -0,0 +1,3 @@
+import "../types-Bjn15Uy6.mjs";
+
+export {  };

package/dist/types-B1OL7hyf.d.mts

@@ -0,0 +1,4 @@
+//#region src/adapters/kysely-adapter/types.d.ts
+type KyselyDatabaseType = "postgres" | "mysql" | "sqlite" | "mssql";
+//#endregion
+export { KyselyDatabaseType as t };

package/dist/types-Bjn15Uy6.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/url-VB2gAbTI.mjs

@@ -0,0 +1,59 @@
+import { env } from "@gatwech/core/env";
+import { PayvoAuthError } from "@gatwech/core/error";
+
+//#region src/utils/url.ts
+function checkHasPath(url) {
+	try {
+		return (new URL(url).pathname.replace(/\/+$/, "") || "/") !== "/";
+	} catch (error) {
+		throw new PayvoAuthError(`Invalid base URL: ${url}. Please provide a valid base URL.`);
+	}
+}
+function withPath(url, path = "/api/auth") {
+	if (checkHasPath(url)) return url;
+	const trimmedUrl = url.replace(/\/+$/, "");
+	if (!path || path === "/") return trimmedUrl;
+	path = path.startsWith("/") ? path : `/${path}`;
+	return `${trimmedUrl}${path}`;
+}
+function getBaseURL(url, path, request, loadEnv) {
+	if (url) return withPath(url, path);
+	if (loadEnv !== false) {
+		const fromEnv = env.PAYVO_AUTH_URL || env.NEXT_PUBLIC_PAYVO_AUTH_URL || env.PUBLIC_PAYVO_AUTH_URL || env.NUXT_PUBLIC_PAYVO_AUTH_URL || env.NUXT_PUBLIC_AUTH_URL || (env.BASE_URL !== "/" ? env.BASE_URL : void 0);
+		if (fromEnv) return withPath(fromEnv, path);
+	}
+	const fromRequest = request?.headers.get("x-forwarded-host");
+	const fromRequestProto = request?.headers.get("x-forwarded-proto");
+	if (fromRequest && fromRequestProto) return withPath(`${fromRequestProto}://${fromRequest}`, path);
+	if (request) {
+		const url$1 = getOrigin(request.url);
+		if (!url$1) throw new PayvoAuthError("Could not get origin from request. Please provide a valid base URL.");
+		return withPath(url$1, path);
+	}
+	if (typeof window !== "undefined" && window.location) return withPath(window.location.origin, path);
+}
+function getOrigin(url) {
+	try {
+		const parsedUrl = new URL(url);
+		return parsedUrl.origin === "null" ? null : parsedUrl.origin;
+	} catch (error) {
+		return null;
+	}
+}
+function getProtocol(url) {
+	try {
+		return new URL(url).protocol;
+	} catch (error) {
+		return null;
+	}
+}
+function getHost(url) {
+	try {
+		return new URL(url).host;
+	} catch (error) {
+		return null;
+	}
+}
+
+//#endregion
+export { getProtocol as i, getHost as n, getOrigin as r, getBaseURL as t };

package/dist/username-DiGklOGl.mjs

@@ -0,0 +1,278 @@
+import { C as createEmailVerificationToken } from "./api-0pR_I-Nx.mjs";
+import { c as setSessionCookie } from "./cookies-cJObLwn1.mjs";
+import { n as mergeSchema } from "./date-Cx2yCiC4.mjs";
+import { BASE_ERROR_CODES } from "@gatwech/core/error";
+import { defineErrorCodes } from "@gatwech/core/utils";
+import { APIError } from "better-call";
+import { createAuthEndpoint, createAuthMiddleware } from "@gatwech/core/api";
+import * as z$1 from "zod";
+
+//#region src/plugins/username/error-codes.ts
+const USERNAME_ERROR_CODES = defineErrorCodes({
+	INVALID_USERNAME_OR_PASSWORD: "Invalid username or password",
+	EMAIL_NOT_VERIFIED: "Email not verified",
+	UNEXPECTED_ERROR: "Unexpected error",
+	USERNAME_IS_ALREADY_TAKEN: "Username is already taken. Please try another.",
+	USERNAME_TOO_SHORT: "Username is too short",
+	USERNAME_TOO_LONG: "Username is too long",
+	INVALID_USERNAME: "Username is invalid",
+	INVALID_DISPLAY_USERNAME: "Display username is invalid"
+});
+
+//#endregion
+//#region src/plugins/username/schema.ts
+const getSchema = (normalizer) => {
+	return { user: { fields: {
+		username: {
+			type: "string",
+			required: false,
+			sortable: true,
+			unique: true,
+			returned: true,
+			transform: { input(value) {
+				return typeof value !== "string" ? value : normalizer.username(value);
+			} }
+		},
+		displayUsername: {
+			type: "string",
+			required: false,
+			transform: { input(value) {
+				return typeof value !== "string" ? value : normalizer.displayUsername(value);
+			} }
+		}
+	} } };
+};
+
+//#endregion
+//#region src/plugins/username/index.ts
+function defaultUsernameValidator(username$1) {
+	return /^[a-zA-Z0-9_.]+$/.test(username$1);
+}
+const username = (options) => {
+	const normalizer = (username$1) => {
+		if (options?.usernameNormalization === false) return username$1;
+		if (options?.usernameNormalization) return options.usernameNormalization(username$1);
+		return username$1.toLowerCase();
+	};
+	const displayUsernameNormalizer = (displayUsername) => {
+		return options?.displayUsernameNormalization ? options.displayUsernameNormalization(displayUsername) : displayUsername;
+	};
+	return {
+		id: "username",
+		init(ctx) {
+			return { options: { databaseHooks: { user: {
+				create: { async before(user, context) {
+					const username$1 = "username" in user ? user.username : null;
+					const displayUsername = "displayUsername" in user ? user.displayUsername : null;
+					return { data: {
+						...user,
+						...username$1 ? { username: normalizer(username$1) } : {},
+						...displayUsername ? { displayUsername: displayUsernameNormalizer(displayUsername) } : {}
+					} };
+				} },
+				update: { async before(user, context) {
+					const username$1 = "username" in user ? user.username : null;
+					const displayUsername = "displayUsername" in user ? user.displayUsername : null;
+					return { data: {
+						...user,
+						...username$1 ? { username: normalizer(username$1) } : {},
+						...displayUsername ? { displayUsername: displayUsernameNormalizer(displayUsername) } : {}
+					} };
+				} }
+			} } } };
+		},
+		endpoints: {
+			signInUsername: createAuthEndpoint("/sign-in/username", {
+				method: "POST",
+				body: z$1.object({
+					username: z$1.string().meta({ description: "The username of the user" }),
+					password: z$1.string().meta({ description: "The password of the user" }),
+					rememberMe: z$1.boolean().meta({ description: "Remember the user session" }).optional(),
+					callbackURL: z$1.string().meta({ description: "The URL to redirect to after email verification" }).optional()
+				}),
+				metadata: { openapi: {
+					summary: "Sign in with username",
+					description: "Sign in with username",
+					responses: {
+						200: {
+							description: "Success",
+							content: { "application/json": { schema: {
+								type: "object",
+								properties: {
+									token: {
+										type: "string",
+										description: "Session token for the authenticated session"
+									},
+									user: { $ref: "#/components/schemas/User" }
+								},
+								required: ["token", "user"]
+							} } }
+						},
+						422: {
+							description: "Unprocessable Entity. Validation error",
+							content: { "application/json": { schema: {
+								type: "object",
+								properties: { message: { type: "string" } }
+							} } }
+						}
+					}
+				} }
+			}, async (ctx) => {
+				if (!ctx.body.username || !ctx.body.password) {
+					ctx.context.logger.error("Username or password not found");
+					throw new APIError("UNAUTHORIZED", { message: USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD });
+				}
+				const username$1 = options?.validationOrder?.username === "pre-normalization" ? normalizer(ctx.body.username) : ctx.body.username;
+				const minUsernameLength = options?.minUsernameLength || 3;
+				const maxUsernameLength = options?.maxUsernameLength || 30;
+				if (username$1.length < minUsernameLength) {
+					ctx.context.logger.error("Username too short", { username: username$1 });
+					throw new APIError("UNPROCESSABLE_ENTITY", { message: USERNAME_ERROR_CODES.USERNAME_TOO_SHORT });
+				}
+				if (username$1.length > maxUsernameLength) {
+					ctx.context.logger.error("Username too long", { username: username$1 });
+					throw new APIError("UNPROCESSABLE_ENTITY", { message: USERNAME_ERROR_CODES.USERNAME_TOO_LONG });
+				}
+				if (!(options?.usernameValidator || defaultUsernameValidator)(username$1)) throw new APIError("UNPROCESSABLE_ENTITY", { message: USERNAME_ERROR_CODES.INVALID_USERNAME });
+				const user = await ctx.context.adapter.findOne({
+					model: "user",
+					where: [{
+						field: "username",
+						value: normalizer(username$1)
+					}]
+				});
+				if (!user) {
+					await ctx.context.password.hash(ctx.body.password);
+					ctx.context.logger.error("User not found", { username: username$1 });
+					throw new APIError("UNAUTHORIZED", { message: USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD });
+				}
+				const account = await ctx.context.adapter.findOne({
+					model: "account",
+					where: [{
+						field: "userId",
+						value: user.id
+					}, {
+						field: "providerId",
+						value: "credential"
+					}]
+				});
+				if (!account) throw new APIError("UNAUTHORIZED", { message: USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD });
+				const currentPassword = account?.password;
+				if (!currentPassword) {
+					ctx.context.logger.error("Password not found", { username: username$1 });
+					throw new APIError("UNAUTHORIZED", { message: USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD });
+				}
+				if (!await ctx.context.password.verify({
+					hash: currentPassword,
+					password: ctx.body.password
+				})) {
+					ctx.context.logger.error("Invalid password");
+					throw new APIError("UNAUTHORIZED", { message: USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD });
+				}
+				if (ctx.context.options?.emailAndPassword?.requireEmailVerification && !user.emailVerified) {
+					if (!ctx.context.options?.emailVerification?.sendVerificationEmail) throw new APIError("FORBIDDEN", { message: USERNAME_ERROR_CODES.EMAIL_NOT_VERIFIED });
+					if (ctx.context.options?.emailVerification?.sendOnSignIn) {
+						const token = await createEmailVerificationToken(ctx.context.secret, user.email, void 0, ctx.context.options.emailVerification?.expiresIn);
+						const url = `${ctx.context.baseURL}/verify-email?token=${token}&callbackURL=${ctx.body.callbackURL || "/"}`;
+						await ctx.context.options.emailVerification.sendVerificationEmail({
+							user,
+							url,
+							token
+						}, ctx.request);
+					}
+					throw new APIError("FORBIDDEN", { message: USERNAME_ERROR_CODES.EMAIL_NOT_VERIFIED });
+				}
+				const session = await ctx.context.internalAdapter.createSession(user.id, ctx.body.rememberMe === false);
+				if (!session) return ctx.json(null, {
+					status: 500,
+					body: { message: BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION }
+				});
+				await setSessionCookie(ctx, {
+					session,
+					user
+				}, ctx.body.rememberMe === false);
+				return ctx.json({
+					token: session.token,
+					user: {
+						id: user.id,
+						email: user.email,
+						emailVerified: user.emailVerified,
+						username: user.username,
+						displayUsername: user.displayUsername,
+						name: user.name,
+						image: user.image,
+						createdAt: user.createdAt,
+						updatedAt: user.updatedAt
+					}
+				});
+			}),
+			isUsernameAvailable: createAuthEndpoint("/is-username-available", {
+				method: "POST",
+				body: z$1.object({ username: z$1.string().meta({ description: "The username to check" }) })
+			}, async (ctx) => {
+				const username$1 = ctx.body.username;
+				if (!username$1) throw new APIError("UNPROCESSABLE_ENTITY", { message: USERNAME_ERROR_CODES.INVALID_USERNAME });
+				const minUsernameLength = options?.minUsernameLength || 3;
+				const maxUsernameLength = options?.maxUsernameLength || 30;
+				if (username$1.length < minUsernameLength) throw new APIError("UNPROCESSABLE_ENTITY", { message: USERNAME_ERROR_CODES.USERNAME_TOO_SHORT });
+				if (username$1.length > maxUsernameLength) throw new APIError("UNPROCESSABLE_ENTITY", { message: USERNAME_ERROR_CODES.USERNAME_TOO_LONG });
+				if (!await (options?.usernameValidator || defaultUsernameValidator)(username$1)) throw new APIError("UNPROCESSABLE_ENTITY", { message: USERNAME_ERROR_CODES.INVALID_USERNAME });
+				if (await ctx.context.adapter.findOne({
+					model: "user",
+					where: [{
+						field: "username",
+						value: normalizer(username$1)
+					}]
+				})) return ctx.json({ available: false });
+				return ctx.json({ available: true });
+			})
+		},
+		schema: mergeSchema(getSchema({
+			username: normalizer,
+			displayUsername: displayUsernameNormalizer
+		}), options?.schema),
+		hooks: { before: [{
+			matcher(context) {
+				return context.path === "/sign-up/email" || context.path === "/update-user";
+			},
+			handler: createAuthMiddleware(async (ctx) => {
+				const username$1 = typeof ctx.body.username === "string" && options?.validationOrder?.username === "post-normalization" ? normalizer(ctx.body.username) : ctx.body.username;
+				if (username$1 !== void 0 && typeof username$1 === "string") {
+					const minUsernameLength = options?.minUsernameLength || 3;
+					const maxUsernameLength = options?.maxUsernameLength || 30;
+					if (username$1.length < minUsernameLength) throw new APIError("BAD_REQUEST", { message: USERNAME_ERROR_CODES.USERNAME_TOO_SHORT });
+					if (username$1.length > maxUsernameLength) throw new APIError("BAD_REQUEST", { message: USERNAME_ERROR_CODES.USERNAME_TOO_LONG });
+					if (!await (options?.usernameValidator || defaultUsernameValidator)(username$1)) throw new APIError("BAD_REQUEST", { message: USERNAME_ERROR_CODES.INVALID_USERNAME });
+					const user = await ctx.context.adapter.findOne({
+						model: "user",
+						where: [{
+							field: "username",
+							value: username$1
+						}]
+					});
+					const blockChangeSignUp = ctx.path === "/sign-up/email" && user;
+					const blockChangeUpdateUser = ctx.path === "/update-user" && user && ctx.context.session && user.id !== ctx.context.session.session.userId;
+					if (blockChangeSignUp || blockChangeUpdateUser) throw new APIError("BAD_REQUEST", { message: USERNAME_ERROR_CODES.USERNAME_IS_ALREADY_TAKEN });
+				}
+				const displayUsername = typeof ctx.body.displayUsername === "string" && options?.validationOrder?.displayUsername === "post-normalization" ? displayUsernameNormalizer(ctx.body.displayUsername) : ctx.body.displayUsername;
+				if (displayUsername !== void 0 && typeof displayUsername === "string") {
+					if (options?.displayUsernameValidator) {
+						if (!await options.displayUsernameValidator(displayUsername)) throw new APIError("BAD_REQUEST", { message: USERNAME_ERROR_CODES.INVALID_DISPLAY_USERNAME });
+					}
+				}
+			})
+		}, {
+			matcher(context) {
+				return context.path === "/sign-up/email" || context.path === "/update-user";
+			},
+			handler: createAuthMiddleware(async (ctx) => {
+				if (ctx.body.username && !ctx.body.displayUsername) ctx.body.displayUsername = ctx.body.username;
+				if (ctx.body.displayUsername && !ctx.body.username) ctx.body.username = ctx.body.displayUsername;
+			})
+		}] },
+		$ERROR_CODES: USERNAME_ERROR_CODES
+	};
+};
+
+//#endregion
+export { USERNAME_ERROR_CODES as n, username as t };

package/dist/utils-SOMB4Px5.mjs

@@ -0,0 +1,132 @@
+import { n as symmetricEncrypt, r as generateRandomString, t as symmetricDecrypt } from "./crypto-Bb42eMrH.mjs";
+import { defineRequestState } from "@gatwech/core/context";
+import { APIError } from "better-call";
+import * as z$1 from "zod";
+import { createRandomStringGenerator } from "@gatwech/utils/random";
+
+//#region src/api/middlewares/oauth.ts
+const { get: getOAuthState, set: setOAuthState } = defineRequestState();
+
+//#endregion
+//#region src/oauth2/state.ts
+async function generateState(c, link, additionalData) {
+	const callbackURL = c.body?.callbackURL || c.context.options.baseURL;
+	if (!callbackURL) throw new APIError("BAD_REQUEST", { message: "callbackURL is required" });
+	const codeVerifier = generateRandomString(128);
+	const state = generateRandomString(32);
+	const storeStateStrategy = c.context.oauthConfig?.storeStateStrategy || "cookie";
+	const stateData = {
+		...additionalData ? additionalData : {},
+		callbackURL,
+		codeVerifier,
+		errorURL: c.body?.errorCallbackURL,
+		newUserURL: c.body?.newUserCallbackURL,
+		link,
+		expiresAt: Date.now() + 600 * 1e3,
+		requestSignUp: c.body?.requestSignUp
+	};
+	await setOAuthState(stateData);
+	if (storeStateStrategy === "cookie") {
+		const encryptedData = await symmetricEncrypt({
+			key: c.context.secret,
+			data: JSON.stringify(stateData)
+		});
+		const stateCookie$1 = c.context.createAuthCookie("oauth_state", { maxAge: 600 * 1e3 });
+		c.setCookie(stateCookie$1.name, encryptedData, stateCookie$1.attributes);
+		return {
+			state,
+			codeVerifier
+		};
+	}
+	const stateCookie = c.context.createAuthCookie("state", { maxAge: 300 * 1e3 });
+	await c.setSignedCookie(stateCookie.name, state, c.context.secret, stateCookie.attributes);
+	const expiresAt = /* @__PURE__ */ new Date();
+	expiresAt.setMinutes(expiresAt.getMinutes() + 10);
+	const verification = await c.context.internalAdapter.createVerificationValue({
+		value: JSON.stringify(stateData),
+		identifier: state,
+		expiresAt
+	});
+	if (!verification) {
+		c.context.logger.error("Unable to create verification. Make sure the database adapter is properly working and there is a verification table in the database");
+		throw new APIError("INTERNAL_SERVER_ERROR", { message: "Unable to create verification" });
+	}
+	return {
+		state: verification.identifier,
+		codeVerifier
+	};
+}
+async function parseState(c) {
+	const state = c.query.state || c.body.state;
+	const storeStateStrategy = c.context.oauthConfig.storeStateStrategy || "cookie";
+	const stateDataSchema = z$1.object({
+		callbackURL: z$1.string(),
+		codeVerifier: z$1.string(),
+		errorURL: z$1.string().optional(),
+		newUserURL: z$1.string().optional(),
+		expiresAt: z$1.number(),
+		link: z$1.object({
+			email: z$1.string(),
+			userId: z$1.coerce.string()
+		}).optional(),
+		requestSignUp: z$1.boolean().optional()
+	}).passthrough();
+	let parsedData;
+	if (storeStateStrategy === "cookie") {
+		const stateCookie = c.context.createAuthCookie("oauth_state");
+		const encryptedData = c.getCookie(stateCookie.name);
+		if (!encryptedData) {
+			c.context.logger.error("State Mismatch. OAuth state cookie not found", { state });
+			const errorURL = c.context.options.onAPIError?.errorURL || `${c.context.baseURL}/error`;
+			throw c.redirect(`${errorURL}?error=please_restart_the_process`);
+		}
+		try {
+			const decryptedData = await symmetricDecrypt({
+				key: c.context.secret,
+				data: encryptedData
+			});
+			parsedData = stateDataSchema.parse(JSON.parse(decryptedData));
+		} catch (error) {
+			c.context.logger.error("Failed to decrypt or parse OAuth state cookie", { error });
+			const errorURL = c.context.options.onAPIError?.errorURL || `${c.context.baseURL}/error`;
+			throw c.redirect(`${errorURL}?error=please_restart_the_process`);
+		}
+		c.setCookie(stateCookie.name, "", { maxAge: 0 });
+	} else {
+		const data = await c.context.internalAdapter.findVerificationValue(state);
+		if (!data) {
+			c.context.logger.error("State Mismatch. Verification not found", { state });
+			const errorURL = c.context.options.onAPIError?.errorURL || `${c.context.baseURL}/error`;
+			throw c.redirect(`${errorURL}?error=please_restart_the_process`);
+		}
+		parsedData = stateDataSchema.parse(JSON.parse(data.value));
+		const stateCookie = c.context.createAuthCookie("state");
+		const stateCookieValue = await c.getSignedCookie(stateCookie.name, c.context.secret);
+		if (!c.context.oauthConfig?.skipStateCookieCheck && (!stateCookieValue || stateCookieValue !== state)) {
+			const errorURL = c.context.options.onAPIError?.errorURL || `${c.context.baseURL}/error`;
+			throw c.redirect(`${errorURL}?error=state_mismatch`);
+		}
+		c.setCookie(stateCookie.name, "", { maxAge: 0 });
+		await c.context.internalAdapter.deleteVerificationValue(data.id);
+	}
+	if (!parsedData.errorURL) parsedData.errorURL = c.context.options.onAPIError?.errorURL || `${c.context.baseURL}/error`;
+	if (parsedData.expiresAt < Date.now()) {
+		const errorURL = c.context.options.onAPIError?.errorURL || `${c.context.baseURL}/error`;
+		throw c.redirect(`${errorURL}?error=please_restart_the_process`);
+	}
+	if (parsedData) await setOAuthState(parsedData);
+	return parsedData;
+}
+
+//#endregion
+//#region src/utils/hide-metadata.ts
+const HIDE_METADATA = { isAction: false };
+
+//#endregion
+//#region src/utils/id.ts
+const generateId = (size) => {
+	return createRandomStringGenerator("a-z", "A-Z", "0-9")(size || 32);
+};
+
+//#endregion
+export { getOAuthState as a, parseState as i, HIDE_METADATA as n, generateState as r, generateId as t };