limen-auth 0.0.0 → 0.0.1

package/dist/client-Er91De-z.mjs

@@ -1,705 +0,0 @@
-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