limen-auth 0.0.0

package/dist/client-Er91De-z.mjs

@@ -0,0 +1,705 @@
+import { a as joinURL, c as stripTrailingSlash, i as ensureLeadingSlash, l as toCamelCaseKey, n as camelizeEach, o as kebabToCamel, s as normalizeBasePath, t as camelToSnake } from "./helpers-Cs3VtXdv.mjs";
+import { n as DEFAULT_ENVELOPE_FIELDS, t as DEFAULT_ENVELOPE_CONFIG } from "./constants-CsR2pQ_9.mjs";
+import { n as deriveErrorCode, t as LimenError } from "./errors-4YJYt6f0.mjs";
+import { n as defineRoutes, t as defineClientPlugin } from "./define-plugin-C7WOGU4b.mjs";
+import { t as route } from "./route-DGxvFqWl.mjs";
+import { atom, onMount, onNotify } from "nanostores";
+//#region src/path.ts
+/**
+* Derive the public client chain from a route path. Mirrors the type-level
+* `PathSegments` in `infer.ts` exactly, so runtime materialization and compile
+* time inference can never drift.
+*
+*   "/otp/send"            -> ["otp", "send"]
+*   "/revoke-sessions"     -> ["revokeSessions"]
+*   "/:provider/authorize" -> ["authorize"]   (param segments are dropped)
+*/
+function pathToChain(path) {
+	return path.split("/").filter((seg) => seg.length > 0 && !seg.startsWith(":")).map(kebabToCamel);
+}
+function chainFromDotted(chain) {
+	return chain.split(".").filter((seg) => seg.length > 0);
+}
+/**
+* Substitute declared path params from `input` into `path` and strip them from
+* the payload.
+*/
+function resolvePath(path, params, input) {
+	if (!params || params.length === 0) return {
+		path,
+		rest: input
+	};
+	const rest = { ...input ?? {} };
+	let resolved = path;
+	for (const param of params) {
+		const value = rest[param];
+		if (value === void 0) throw new Error(`Missing required path param "${param}" for route "${path}"`);
+		resolved = resolved.replace(`:${param}`, encodeURIComponent(value));
+		delete rest[param];
+	}
+	return {
+		path: resolved,
+		rest
+	};
+}
+//#endregion
+//#region src/serialize.ts
+/**
+* Default request serializer: shallow camelCase → snake_case, drops `undefined`,
+* leaves non-objects unchanged.
+*
+* `additionalFields` entries are merged into the top-level body verbatim.
+* Known route fields win on key collisions.
+*/
+function defaultSerialize(input) {
+	if (input === null || input === void 0) return input;
+	if (typeof input !== "object" || Array.isArray(input)) return input;
+	const { additionalFields, ...rest } = input;
+	const out = {};
+	if (additionalFields && typeof additionalFields === "object" && !Array.isArray(additionalFields)) Object.assign(out, additionalFields);
+	for (const [key, value] of Object.entries(rest)) {
+		if (value === void 0) continue;
+		out[camelToSnake(key)] = value;
+	}
+	return out;
+}
+//#endregion
+//#region src/pipeline.ts
+/**
+* Run the default HTTP steps for a route — merge defaults, resolve path params,
+* serialize, dispatch, parse — without applying session effects.
+*/
+async function runHttp(ctx, def, input) {
+	let merged = input;
+	if (def.defaults !== void 0) merged = {
+		...def.defaults,
+		...input ?? {}
+	};
+	const { path, rest } = resolvePath(def.path, def.params, merged);
+	const payload = def.serialize !== void 0 ? def.serialize(rest) : defaultSerialize(rest);
+	const init = {
+		method: def.method,
+		absolute: def.absolute ?? false
+	};
+	if (def.method === "GET" && payload !== void 0) init.query = payload;
+	else init.body = payload;
+	const raw = await ctx.fetch(path, init);
+	if (def.parseSession === true) return ctx.parseSession(raw);
+	if (def.parse !== void 0) return def.parse(raw);
+	return Array.isArray(raw) ? camelizeEach(raw) : raw;
+}
+async function applyEffects(ctx, def, result) {
+	if (def.clearSession === true) ctx.store.setData(null);
+	if (def.parseSession === true && def.skipStore !== true) {
+		if (result !== null && typeof result === "object" && "user" in result) ctx.store.setData(result);
+	}
+	if (def.refetchSession === true) await ctx.store.refetch();
+}
+function makeHttpRunner(ctx, def, boundInput) {
+	const run = (override) => runHttp(ctx, def, override === void 0 ? boundInput : override);
+	return run;
+}
+/**
+* Execute a route's behaviour: delegate to its `handler` when present (handler
+* owns all behaviour, including any effects), otherwise run the default
+* pipeline and apply declarative effects once at the top level.
+*/
+async function dispatchRoute(ctx, def, input) {
+	if (def.handler !== void 0) return def.handler(ctx, input, makeHttpRunner(ctx, def, input));
+	const result = await runHttp(ctx, def, input);
+	await applyEffects(ctx, def, result);
+	return result;
+}
+/**
+* Run a route as a public client call, firing the per-call `onSuccess` /
+* `onError` hooks around the resolved value or thrown error.
+*/
+async function runRoute(ctx, def, input, opts) {
+	try {
+		const result = await dispatchRoute(ctx, def, input);
+		opts?.onSuccess?.(result);
+		return result;
+	} catch (error) {
+		opts?.onError?.(error);
+		throw error;
+	}
+}
+//#endregion
+//#region src/build-tree.ts
+/** Scope a context's `fetch` to one plugin's base path (after client `overrides`). */
+function scopeContext(ctx, fetcher, plugin, overrides) {
+	const defaultBase = normalizeBasePath(plugin.basePath ?? "");
+	const overrideBase = overrides?.[kebabToCamel(plugin.id)]?.basePath;
+	const resolvedBase = normalizeBasePath(overrideBase ?? plugin.basePath ?? "");
+	return {
+		...ctx,
+		fetch: (path, init) => {
+			const absolute = init?.absolute === true;
+			const requestPath = (absolute ? "" : resolvedBase) + ensureLeadingSlash(path);
+			const routePath = (absolute ? "" : defaultBase) + ensureLeadingSlash(path);
+			return fetcher.fetch(requestPath, init, routePath);
+		}
+	};
+}
+function chainFor(plugin, def) {
+	if (typeof def.as === "string") return chainFromDotted(def.as);
+	return [...pathToChain(plugin.basePath ?? ""), ...pathToChain(def.path)];
+}
+function mountAtChain(target, pathSegments, callable) {
+	let current = target;
+	for (let i = 0; i < pathSegments.length - 1; i += 1) {
+		const segment = pathSegments[i];
+		const child = current[segment];
+		if (child === void 0) {
+			const namespace = {};
+			current[segment] = namespace;
+			current = namespace;
+		} else current = child;
+	}
+	const finalSegment = pathSegments[pathSegments.length - 1];
+	current[finalSegment] = callable;
+}
+function isNamespace(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value !== "function";
+}
+function mergeInto(target, source) {
+	for (const [key, value] of Object.entries(source)) {
+		const existing = target[key];
+		if (isNamespace(existing) && isNamespace(value)) {
+			mergeInto(existing, value);
+			continue;
+		}
+		target[key] = value;
+	}
+}
+/**
+* Build the public API object from plugin routes and actions.
+*/
+function buildClientTree({ plugins, ctx, fetcher, overrides }) {
+	const api = {};
+	for (const plugin of plugins) {
+		const scopedCtx = scopeContext(ctx, fetcher, plugin, overrides);
+		const contribution = {};
+		for (const def of plugin.routes) {
+			if (def.expose === false) continue;
+			const call = (input, opts) => runRoute(scopedCtx, def, input, opts);
+			mountAtChain(contribution, chainFor(plugin, def), call);
+		}
+		if (plugin.actions !== void 0) {
+			const run = (route, input) => runRoute(scopedCtx, route, input);
+			mergeInto(contribution, plugin.actions(scopedCtx, run));
+		}
+		mergeInto(api, contribution);
+	}
+	return api;
+}
+//#endregion
+//#region src/envelope.ts
+/**
+* Unwrap a parsed JSON success body according to envelope config.
+*
+* - `mode: "off"`: return as-is.
+* - `mode: "wrap-success" | "always"`: extract `body[fields.data]` if present;
+*   if the key is missing (server didn't wrap this particular response), fall
+*   back to the raw body so we don't lose data.
+*
+* Returning `unknown` is intentional: the caller knows the expected shape and
+* narrows / validates it. Trying to be clever here would invite false typing.
+*/
+function unwrapPayload(body, envelope) {
+	if (envelope.mode === "off") return body;
+	if (body === null || typeof body !== "object") return body;
+	const fields = envelope.fields ?? DEFAULT_ENVELOPE_FIELDS;
+	const record = body;
+	if (fields.data in record) return record[fields.data];
+	return body;
+}
+/**
+* Pull the human-readable error message out of a non-2xx body.
+*
+* - `mode: "off" | "wrap-success"`: error bodies look like `{ message }`
+* - `mode: "always"`: error bodies use the configured `fields.message` key.
+*
+* Returns `undefined` when no message can be located; the caller substitutes
+* a status-based fallback (e.g. HTTP status text).
+*/
+function unwrapErrorMessage(body, envelope) {
+	if (body === null || typeof body !== "object") return;
+	const record = body;
+	const fields = envelope.fields ?? DEFAULT_ENVELOPE_FIELDS;
+	const value = record[envelope.mode === "always" ? fields.message : "message"];
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+//#region src/fetcher.ts
+var Fetcher = class {
+	opts;
+	fetchImpl;
+	credentials;
+	constructor(opts) {
+		this.opts = opts;
+		this.fetchImpl = opts.fetchOptions.impl ?? globalThis.fetch.bind(globalThis);
+		this.credentials = opts.fetchOptions.credentials ?? "include";
+	}
+	async fetch(path, init, routePath = path) {
+		const method = init?.method ?? (init?.body !== void 0 ? "POST" : "GET");
+		return this.run({
+			method,
+			path,
+			routePath,
+			body: init?.body,
+			headers: init?.headers,
+			query: init?.query
+		});
+	}
+	/**
+	* Builds the request context, runs hooks, does
+	* the fetch, parses the response, runs hooks again, throws on non-2xx.
+	*/
+	async run(args) {
+		const fullPath = this.normalizeRelativePath(this.opts.basePath, args.path, args.query);
+		const url = joinURL(this.opts.baseURL, fullPath);
+		const headers = new Headers({
+			...args.headers,
+			...this.opts.fetchOptions.headers ?? {}
+		});
+		if (!headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+		if (!headers.has("Accept")) headers.set("Accept", "application/json");
+		let reqCtx = {
+			method: args.method,
+			fullPath,
+			path: args.path,
+			routePath: args.routePath,
+			url,
+			headers,
+			body: args.body
+		};
+		reqCtx = await this.opts.hooks.runBeforeRequest(reqCtx);
+		const payload = reqCtx.body !== void 0 && reqCtx.body !== null ? JSON.stringify(reqCtx.body) : void 0;
+		const requestInit = {
+			method: reqCtx.method,
+			headers: reqCtx.headers,
+			credentials: this.credentials
+		};
+		if (payload !== void 0) requestInit.body = payload;
+		let response;
+		try {
+			response = await this.fetchImpl(reqCtx.url, requestInit);
+		} catch (err) {
+			this.opts.fetchOptions.onError?.({
+				...reqCtx,
+				status: 0,
+				ok: false,
+				error: err
+			});
+			throw new LimenError(err instanceof Error ? err.message : "Network request failed", 0, "unknown");
+		}
+		const parsedBody = await this.parseResponseBody(response);
+		const unwrapped = response.ok && parsedBody !== void 0 ? unwrapPayload(parsedBody, this.opts.envelope) : parsedBody;
+		let resCtx = {
+			method: args.method,
+			fullPath,
+			path: args.path,
+			routePath: args.routePath,
+			status: response.status,
+			ok: response.ok,
+			headers: response.headers,
+			body: unwrapped
+		};
+		resCtx = await this.opts.hooks.runAfterResponse(resCtx);
+		if (resCtx.ok) {
+			this.opts.fetchOptions.onSuccess?.({
+				...resCtx,
+				response
+			});
+			return resCtx.body;
+		}
+		const error = new LimenError(unwrapErrorMessage(resCtx.body, this.opts.envelope) ?? response.statusText ?? `Request failed with status ${response.status}`, response.status, deriveErrorCode(response.status));
+		this.opts.fetchOptions.onError?.({
+			...reqCtx,
+			status: response.status,
+			ok: false,
+			error
+		});
+		throw error;
+	}
+	async parseResponseBody(response) {
+		if (response.status === 204) return;
+		const text = await response.text();
+		if (text.length === 0) return;
+		return JSON.parse(text);
+	}
+	normalizeRelativePath(basePath, relativePath, query) {
+		let path = (basePath === "" || basePath === "/" ? "" : ensureLeadingSlash(stripTrailingSlash(basePath))) + ensureLeadingSlash(relativePath);
+		if (query !== void 0) {
+			const qs = new URLSearchParams(query).toString();
+			if (qs.length > 0) path = `${path}?${qs}`;
+		}
+		return path;
+	}
+};
+//#endregion
+//#region src/hooks.ts
+function matchesRoute(matcher, routePath) {
+	if (matcher === void 0) return true;
+	if (typeof matcher === "string") return routePath === matcher;
+	if (typeof matcher === "function") return matcher({ path: routePath });
+	return routePath !== void 0 && matcher.includes(routePath);
+}
+var HookRunner = class {
+	before;
+	after;
+	constructor(plugins) {
+		this.before = plugins.flatMap((p) => p.hooks?.beforeRequest ?? []);
+		this.after = plugins.flatMap((p) => p.hooks?.afterResponse ?? []);
+	}
+	async runBeforeRequest(initial) {
+		let ctx = initial;
+		for (const hook of this.before) {
+			if (!matchesRoute(hook.match, ctx.routePath)) continue;
+			ctx = await hook.run(ctx);
+		}
+		return ctx;
+	}
+	async runAfterResponse(initial) {
+		let ctx = initial;
+		for (const hook of this.after) {
+			if (!matchesRoute(hook.match, ctx.routePath)) continue;
+			if (!hook.allowOnFailure && ctx.status >= 400) continue;
+			ctx = await hook.run(ctx);
+		}
+		return ctx;
+	}
+};
+//#endregion
+//#region src/normalize.ts
+/**
+* Convert snake_case User keys from server payloads to camelCase. Unknown
+* extension fields are converted with the same rule so consumers consistently
+* read camelCase in SDK responses.
+*/
+function normalizeUser(raw) {
+	const out = {};
+	for (const [key, value] of Object.entries(raw)) out[toCamelCaseKey(key)] = value;
+	return out;
+}
+function defaultSessionParse(raw) {
+	if (!raw || typeof raw !== "object") throw new TypeError(`Expected session response to be an object, got ${raw === null ? "null" : typeof raw}`);
+	const obj = raw;
+	return { user: normalizeUser(obj["user"] ?? obj) };
+}
+//#endregion
+//#region src/routes.ts
+/**
+* Core routes available on every client.
+*/
+function coreClientPlugin() {
+	return defineClientPlugin({
+		id: "core",
+		basePath: "/",
+		routes: defineRoutes(route()({
+			method: "GET",
+			path: "/sessions"
+		}), route()({
+			method: "POST",
+			path: "/signout",
+			clearSession: true
+		}), route()({
+			method: "POST",
+			path: "/revoke-sessions",
+			clearSession: true
+		}), route()({
+			method: "POST",
+			path: "/verify-email",
+			refetchSession: true
+		}), route()({
+			method: "POST",
+			path: "/email-verifications",
+			as: "requestEmailVerification"
+		})),
+		actions: (ctx) => ({ 
+		/**
+		* Revalidate session state with `GET /me`, update `$session`, and return the
+		* resolved value (`null` when signed out).
+		*
+		* Prefer subscribing to `$session` for reactive UI state (`data`, `isPending`,
+		* `error`). Use `getSession()` when you need an awaited server re-check, such
+		* as route guards or SSR revalidation after `initialSession`.
+		*/
+getSession: async () => {
+			await ctx.refetchSession();
+			const state = ctx.store.$session.get();
+			if (state.error) throw state.error;
+			return state.data;
+		} })
+	});
+}
+/**
+* Fetch and parse the current session for the reactive store.
+*/
+function createSessionHydrator(ctx) {
+	return async () => {
+		const raw = await ctx.fetch("/me", { method: "GET" });
+		return ctx.parseSession(raw);
+	};
+}
+//#endregion
+//#region src/broadcast-channel.ts
+const NOOP_PORT = {
+	post() {},
+	subscribe: () => () => {},
+	close() {}
+};
+function createBroadcastChannel(name) {
+	if (typeof window === "undefined") return NOOP_PORT;
+	const storageKey = `${name}-sync`;
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = (message) => {
+		for (const listener of listeners) listener(message);
+	};
+	const channel = typeof BroadcastChannel !== "undefined" ? new BroadcastChannel(name) : null;
+	if (channel) channel.onmessage = (event) => {
+		if (event.data != null) emit(event.data);
+	};
+	const onStorage = (event) => {
+		if (event.key !== storageKey || !event.newValue) return;
+		emit(JSON.parse(event.newValue));
+	};
+	if (!channel) window.addEventListener("storage", onStorage);
+	return {
+		post(message) {
+			if (channel) {
+				channel.postMessage(message);
+				return;
+			}
+			if (typeof globalThis.localStorage !== "undefined") {
+				globalThis.localStorage.setItem(storageKey, JSON.stringify(message));
+				globalThis.localStorage.removeItem(storageKey);
+			}
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		close() {
+			listeners.clear();
+			if (channel) {
+				channel.close();
+				return;
+			}
+			window.removeEventListener("storage", onStorage);
+		}
+	};
+}
+//#endregion
+//#region src/json-deep-equal.ts
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function equalArrays(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i += 1) if (!deepJsonEqual(a[i], b[i])) return false;
+	return true;
+}
+function equalObjects(a, b) {
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) if (!Object.hasOwn(b, key) || !deepJsonEqual(a[key], b[key])) return false;
+	return true;
+}
+/** Structural equality for JSON-shaped values. */
+function deepJsonEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return equalArrays(a, b);
+	if (!isPlainObject(a) || !isPlainObject(b)) return false;
+	return equalObjects(a, b);
+}
+//#endregion
+//#region src/session-sync.ts
+const CHANNEL_NAME = "limen.session";
+const FOCUS_REFETCH_THROTTLE_MS = 5e3;
+function createSessionSync(store, options) {
+	if (options.fetchOnMount) store.refetch();
+	const teardowns = [];
+	if (options.crossTabSync) teardowns.push(syncAcrossTabs(store));
+	if (options.refetchOnWindowFocus) teardowns.push(refetchOnFocus(store));
+	return () => {
+		for (const teardown of teardowns) teardown();
+	};
+}
+function syncAcrossTabs(store) {
+	const port = createBroadcastChannel(CHANNEL_NAME);
+	let lastData = store.$session.get().data;
+	const unsubscribe = port.subscribe((message) => {
+		lastData = message.data;
+		store.setData(message.data);
+	});
+	const unbindNotify = onNotify(store.$session, () => {
+		const data = store.$session.get().data;
+		if (deepJsonEqual(data, lastData)) return;
+		lastData = data;
+		port.post({ data });
+	});
+	return () => {
+		unbindNotify();
+		unsubscribe();
+		port.close();
+	};
+}
+function refetchOnFocus(store) {
+	if (typeof document === "undefined") return () => {};
+	const onVisibilityChange = () => {
+		if (document.visibilityState === "visible") store.refetch({
+			maxAgeMs: FOCUS_REFETCH_THROTTLE_MS,
+			skipSignedOut: true
+		});
+	};
+	document.addEventListener("visibilitychange", onVisibilityChange);
+	return () => document.removeEventListener("visibilitychange", onVisibilityChange);
+}
+//#endregion
+//#region src/session-store.ts
+function createSessionStore(options) {
+	const $session = atom({
+		data: options.initialSession ?? null,
+		isPending: false,
+		error: null
+	});
+	let inFlightHydration = null;
+	let writeVersion = 0;
+	let lastRefreshedAt = 0;
+	const isStale = (requestVersion) => requestVersion !== writeVersion;
+	const fetchSessionFromServer = async () => {
+		const requestVersion = ++writeVersion;
+		$session.set({
+			data: $session.get().data,
+			isPending: true,
+			error: null
+		});
+		try {
+			const session = await options.hydrator();
+			if (isStale(requestVersion)) return;
+			$session.set({
+				data: session,
+				isPending: false,
+				error: null
+			});
+		} catch (err) {
+			if (isStale(requestVersion)) return;
+			if (err instanceof LimenError && err.isUnauthorized) {
+				$session.set({
+					data: null,
+					isPending: false,
+					error: null
+				});
+				return;
+			}
+			const error = err instanceof LimenError ? err : new LimenError(err instanceof Error ? err.message : "Failed to load session", 0, "unknown");
+			$session.set({
+				data: $session.get().data,
+				isPending: false,
+				error
+			});
+		}
+	};
+	const refetch = (options) => {
+		const { skipSignedOut, maxAgeMs } = options ?? {};
+		if (skipSignedOut && $session.get().data === null) return Promise.resolve();
+		if (maxAgeMs !== void 0 && Date.now() - lastRefreshedAt < maxAgeMs) return Promise.resolve();
+		if (!inFlightHydration) inFlightHydration = fetchSessionFromServer().finally(() => {
+			inFlightHydration = null;
+			lastRefreshedAt = Date.now();
+		});
+		return inFlightHydration;
+	};
+	const setData = (session) => {
+		writeVersion++;
+		$session.set({
+			data: session,
+			isPending: false,
+			error: null
+		});
+	};
+	const store = {
+		$session,
+		setData,
+		refetch
+	};
+	onMount($session, () => createSessionSync(store, {
+		fetchOnMount: options.initialSession === void 0,
+		crossTabSync: options.crossTabSync ?? false,
+		refetchOnWindowFocus: options.refetchOnWindowFocus ?? false
+	}));
+	return store;
+}
+//#endregion
+//#region src/client.ts
+function createAuthClient(opts) {
+	const baseURL = stripTrailingSlash(opts.baseURL);
+	const basePath = normalizeBasePath(opts.basePath ?? "/auth");
+	const userPlugins = opts.plugins ?? [];
+	const plugins = [coreClientPlugin(), ...userPlugins];
+	const hooks = new HookRunner(plugins);
+	const fetcher = buildFetcher(baseURL, basePath, {
+		...DEFAULT_ENVELOPE_CONFIG,
+		...opts.envelope
+	}, hooks, opts.fetchOptions ?? {});
+	const parseSession = opts.parseSession ?? defaultSessionParse;
+	const redirect = resolveRedirect(opts.redirectFn);
+	const baseFetch = (path, init) => fetcher.fetch(path, init);
+	const store = createSessionStore({
+		hydrator: createSessionHydrator({
+			fetch: baseFetch,
+			parseSession
+		}),
+		crossTabSync: opts.crossTabSync !== false,
+		refetchOnWindowFocus: opts.refetchOnWindowFocus !== false,
+		...opts.initialSession !== void 0 ? { initialSession: opts.initialSession } : {}
+	});
+	return {
+		baseURL,
+		basePath,
+		...buildClientTree({
+			plugins,
+			ctx: {
+				fetch: baseFetch,
+				redirect,
+				parseSession,
+				setSession: (session) => store.setData(session),
+				refetchSession: () => store.refetch(),
+				store
+			},
+			fetcher,
+			overrides: opts.overrides
+		}),
+		$session: store.$session
+	};
+}
+function buildFetcher(baseURL, basePath, envelope, hooks, fetchOptions) {
+	return new Fetcher({
+		baseURL,
+		basePath,
+		envelope,
+		hooks,
+		fetchOptions
+	});
+}
+function resolveRedirect(redirect) {
+	return (url) => {
+		if (redirect !== void 0) return redirect(url);
+		if (typeof window !== "undefined" && typeof window.location !== "undefined") {
+			window.location.href = url;
+			return true;
+		}
+		return false;
+	};
+}
+//#endregion
+export { defaultSerialize as a, normalizeUser as i, coreClientPlugin as n, defaultSessionParse as r, createAuthClient as t };
+
+//# sourceMappingURL=client-Er91De-z.mjs.map