@clerk/react 6.9.0 → 6.9.1-canary.v20260610190754

package/dist/ClerkProvider-9lxHp9j5.cjs

@@ -0,0 +1,1623 @@
+const require_hooks = require('./hooks-CBghYU21.cjs');
+const require_useAssertWrappedByClerkProvider = require('./useAssertWrappedByClerkProvider-Cm0djUcB.cjs');
+let react = require("react");
+react = require_hooks.__toESM(react);
+let _clerk_shared_loadClerkJsScript = require("@clerk/shared/loadClerkJsScript");
+let _clerk_shared_utils = require("@clerk/shared/utils");
+let _clerk_shared_react = require("@clerk/shared/react");
+let _clerk_shared_deprecated = require("@clerk/shared/deprecated");
+let _clerk_shared_browser = require("@clerk/shared/browser");
+let _clerk_shared_clerkEventBus = require("@clerk/shared/clerkEventBus");
+let _clerk_shared_versionCheck = require("@clerk/shared/versionCheck");
+
+//#region src/components/controlComponents.tsx
+const ClerkLoaded = ({ children }) => {
+	require_useAssertWrappedByClerkProvider.useAssertWrappedByClerkProvider("ClerkLoaded");
+	if (!require_useAssertWrappedByClerkProvider.useIsomorphicClerkContext().loaded) return null;
+	return children;
+};
+const ClerkLoading = ({ children }) => {
+	require_useAssertWrappedByClerkProvider.useAssertWrappedByClerkProvider("ClerkLoading");
+	if (require_useAssertWrappedByClerkProvider.useIsomorphicClerkContext().status !== "loading") return null;
+	return children;
+};
+const ClerkFailed = ({ children }) => {
+	require_useAssertWrappedByClerkProvider.useAssertWrappedByClerkProvider("ClerkFailed");
+	if (require_useAssertWrappedByClerkProvider.useIsomorphicClerkContext().status !== "error") return null;
+	return children;
+};
+const ClerkDegraded = ({ children }) => {
+	require_useAssertWrappedByClerkProvider.useAssertWrappedByClerkProvider("ClerkDegraded");
+	if (require_useAssertWrappedByClerkProvider.useIsomorphicClerkContext().status !== "degraded") return null;
+	return children;
+};
+/**
+* Use `<Show/>` to conditionally render content based on user authorization or sign-in state.
+* Returns `null` while auth is loading. Set `treatPendingAsSignedOut` to treat
+* pending sessions as signed out during that period.
+*
+* The `when` prop supports:
+* - `"signed-in"` or `"signed-out"` shorthands
+* - Authorization descriptors (e.g., `{ permission: "org:billing:manage" }`, `{ role: "admin" }`)
+* - A predicate function `(has) => boolean` that receives the `has` helper
+*
+* @example
+* ```tsx
+* <Show when={{ permission: "org:billing:manage" }} fallback={<p>Unauthorized</p>}>
+*   <BillingSettings />
+* </Show>
+*
+* <Show when={{ role: "admin" }}>
+*   <AdminPanel />
+* </Show>
+*
+* <Show when={(has) => has({ permission: "org:read" }) && isFeatureEnabled}>
+*   <ProtectedFeature />
+* </Show>
+* ```
+*
+*/
+const Show = ({ children, fallback, treatPendingAsSignedOut, when }) => {
+	require_useAssertWrappedByClerkProvider.useAssertWrappedByClerkProvider("Show");
+	const { has, isLoaded, userId } = require_hooks.useAuth({ treatPendingAsSignedOut });
+	if (!isLoaded) return null;
+	const resolvedWhen = when;
+	const authorized = children;
+	const unauthorized = fallback ?? null;
+	if (resolvedWhen === "signed-out") return userId ? unauthorized : authorized;
+	if (!userId) return unauthorized;
+	if (resolvedWhen === "signed-in") return authorized;
+	if (checkAuthorization(resolvedWhen, has)) return authorized;
+	return unauthorized;
+};
+function checkAuthorization(when, has) {
+	if (typeof when === "function") return when(has);
+	return has(when);
+}
+const RedirectToSignIn = require_hooks.withClerk(({ clerk, ...props }) => {
+	const { client, session } = clerk;
+	const hasSignedInSessions = (client.signedInSessions?.length ?? 0) > 0;
+	react.default.useEffect(() => {
+		if (session === null && hasSignedInSessions) clerk.redirectToAfterSignOut();
+		else clerk.redirectToSignIn(props);
+	}, []);
+	return null;
+}, "RedirectToSignIn");
+const RedirectToSignUp = require_hooks.withClerk(({ clerk, ...props }) => {
+	react.default.useEffect(() => {
+		clerk.redirectToSignUp(props);
+	}, []);
+	return null;
+}, "RedirectToSignUp");
+const RedirectToTasks = require_hooks.withClerk(({ clerk, ...props }) => {
+	react.default.useEffect(() => {
+		clerk.redirectToTasks(props);
+	}, []);
+	return null;
+}, "RedirectToTasks");
+/**
+* @function
+* @deprecated Use [`redirectToUserProfile()`](https://clerk.com/docs/reference/objects/clerk#redirect-to-user-profile) instead.
+*/
+const RedirectToUserProfile = require_hooks.withClerk(({ clerk }) => {
+	react.default.useEffect(() => {
+		(0, _clerk_shared_deprecated.deprecated)("RedirectToUserProfile", "Use the `redirectToUserProfile()` method instead.");
+		clerk.redirectToUserProfile();
+	}, []);
+	return null;
+}, "RedirectToUserProfile");
+/**
+* @function
+* @deprecated Use [`redirectToOrganizationProfile()`](https://clerk.com/docs/reference/objects/clerk#redirect-to-organization-profile) instead.
+*/
+const RedirectToOrganizationProfile = require_hooks.withClerk(({ clerk }) => {
+	react.default.useEffect(() => {
+		(0, _clerk_shared_deprecated.deprecated)("RedirectToOrganizationProfile", "Use the `redirectToOrganizationProfile()` method instead.");
+		clerk.redirectToOrganizationProfile();
+	}, []);
+	return null;
+}, "RedirectToOrganizationProfile");
+/**
+* @function
+* @deprecated Use [`redirectToCreateOrganization()`](https://clerk.com/docs/reference/objects/clerk#redirect-to-create-organization) instead.
+*/
+const RedirectToCreateOrganization = require_hooks.withClerk(({ clerk }) => {
+	react.default.useEffect(() => {
+		(0, _clerk_shared_deprecated.deprecated)("RedirectToCreateOrganization", "Use the `redirectToCreateOrganization()` method instead.");
+		clerk.redirectToCreateOrganization();
+	}, []);
+	return null;
+}, "RedirectToCreateOrganization");
+const AuthenticateWithRedirectCallback = require_hooks.withClerk(({ clerk, ...handleRedirectCallbackParams }) => {
+	react.default.useEffect(() => {
+		clerk.handleRedirectCallback(handleRedirectCallbackParams);
+	}, []);
+	return null;
+}, "AuthenticateWithRedirectCallback");
+const MultisessionAppSupport = ({ children }) => {
+	require_useAssertWrappedByClerkProvider.useAssertWrappedByClerkProvider("MultisessionAppSupport");
+	const session = (0, _clerk_shared_react.__internal_useSessionBase)();
+	return /* @__PURE__ */ react.default.createElement(react.default.Fragment, { key: session ? session.id : "no-users" }, children);
+};
+
+//#endregion
+//#region src/stateProxy.ts
+const defaultSignInErrors = () => ({
+	fields: {
+		identifier: null,
+		password: null,
+		code: null
+	},
+	raw: null,
+	global: null
+});
+const defaultSignUpErrors = () => ({
+	fields: {
+		firstName: null,
+		lastName: null,
+		emailAddress: null,
+		phoneNumber: null,
+		password: null,
+		username: null,
+		code: null,
+		captcha: null,
+		legalAccepted: null
+	},
+	raw: null,
+	global: null
+});
+const defaultWaitlistErrors = () => ({
+	fields: { emailAddress: null },
+	raw: null,
+	global: null
+});
+const defaultVerificationResource = () => ({
+	pathRoot: "",
+	attempts: null,
+	error: null,
+	expireAt: null,
+	externalVerificationRedirectURL: null,
+	nonce: null,
+	message: null,
+	status: null,
+	strategy: null,
+	verifiedAtClient: null,
+	verifiedFromTheSameClient() {
+		return false;
+	},
+	reload() {
+		throw new Error("reload() called before Clerk is loaded");
+	},
+	__internal_toSnapshot() {
+		return {
+			object: "verification",
+			id: "",
+			attempts: null,
+			error: {
+				code: "",
+				message: ""
+			},
+			expire_at: null,
+			externalVerificationRedirectURL: null,
+			nonce: null,
+			message: null,
+			status: null,
+			strategy: null,
+			verified_at_client: null
+		};
+	}
+});
+const defaultSignUpVerificationResource = () => ({
+	...defaultVerificationResource(),
+	supportedStrategies: [],
+	nextAction: "",
+	reload() {
+		throw new Error("reload() called before Clerk is loaded");
+	},
+	__internal_toSnapshot() {
+		return {
+			...defaultVerificationResource().__internal_toSnapshot(),
+			next_action: this.nextAction,
+			supported_strategies: this.supportedStrategies
+		};
+	}
+});
+var StateProxy = class {
+	constructor(isomorphicClerk) {
+		this.isomorphicClerk = isomorphicClerk;
+		this.signInSignalProxy = this.buildSignInProxy();
+		this.signUpSignalProxy = this.buildSignUpProxy();
+		this.waitlistSignalProxy = this.buildWaitlistProxy();
+	}
+	signInSignal() {
+		return this.signInSignalProxy;
+	}
+	signUpSignal() {
+		return this.signUpSignalProxy;
+	}
+	waitlistSignal() {
+		return this.waitlistSignalProxy;
+	}
+	get __internal_waitlist() {
+		return this.state.__internal_waitlist;
+	}
+	checkoutSignal(params) {
+		return this.buildCheckoutProxy(params);
+	}
+	buildSignInProxy() {
+		const gateProperty = this.gateProperty.bind(this);
+		const target = () => this.client.signIn.__internal_future;
+		return {
+			errors: defaultSignInErrors(),
+			fetchStatus: "idle",
+			signIn: {
+				status: "needs_identifier",
+				availableStrategies: [],
+				get isTransferable() {
+					return gateProperty(target, "isTransferable", false);
+				},
+				get id() {
+					return gateProperty(target, "id", void 0);
+				},
+				get supportedFirstFactors() {
+					return gateProperty(target, "supportedFirstFactors", []);
+				},
+				get supportedSecondFactors() {
+					return gateProperty(target, "supportedSecondFactors", []);
+				},
+				get secondFactorVerification() {
+					return gateProperty(target, "secondFactorVerification", {
+						status: null,
+						error: null,
+						expireAt: null,
+						externalVerificationRedirectURL: null,
+						nonce: null,
+						attempts: null,
+						message: null,
+						strategy: null,
+						verifiedAtClient: null,
+						verifiedFromTheSameClient: () => false,
+						__internal_toSnapshot: () => {
+							throw new Error("__internal_toSnapshot called before Clerk is loaded");
+						},
+						pathRoot: "",
+						reload: () => {
+							throw new Error("__internal_toSnapshot called before Clerk is loaded");
+						}
+					});
+				},
+				get identifier() {
+					return gateProperty(target, "identifier", null);
+				},
+				get createdSessionId() {
+					return gateProperty(target, "createdSessionId", null);
+				},
+				get userData() {
+					return gateProperty(target, "userData", {});
+				},
+				get firstFactorVerification() {
+					return gateProperty(target, "firstFactorVerification", {
+						status: null,
+						error: null,
+						expireAt: null,
+						externalVerificationRedirectURL: null,
+						nonce: null,
+						attempts: null,
+						message: null,
+						strategy: null,
+						verifiedAtClient: null,
+						verifiedFromTheSameClient: () => false,
+						__internal_toSnapshot: () => {
+							throw new Error("__internal_toSnapshot called before Clerk is loaded");
+						},
+						pathRoot: "",
+						reload: () => {
+							throw new Error("__internal_toSnapshot called before Clerk is loaded");
+						}
+					});
+				},
+				get canBeDiscarded() {
+					return gateProperty(target, "canBeDiscarded", false);
+				},
+				create: this.gateMethod(target, "create"),
+				password: this.gateMethod(target, "password"),
+				sso: this.gateMethod(target, "sso"),
+				finalize: this.gateMethod(target, "finalize"),
+				reset: this.gateMethod(target, "reset"),
+				emailCode: this.wrapMethods(() => target().emailCode, ["sendCode", "verifyCode"]),
+				emailLink: this.wrapStruct(() => target().emailLink, ["sendLink", "waitForVerification"], ["verification"], { verification: null }),
+				resetPasswordEmailCode: this.wrapMethods(() => target().resetPasswordEmailCode, [
+					"sendCode",
+					"verifyCode",
+					"submitPassword"
+				]),
+				resetPasswordPhoneCode: this.wrapMethods(() => target().resetPasswordPhoneCode, [
+					"sendCode",
+					"verifyCode",
+					"submitPassword"
+				]),
+				phoneCode: this.wrapMethods(() => target().phoneCode, ["sendCode", "verifyCode"]),
+				mfa: this.wrapMethods(() => target().mfa, [
+					"sendPhoneCode",
+					"verifyPhoneCode",
+					"sendEmailCode",
+					"verifyEmailCode",
+					"verifyTOTP",
+					"verifyBackupCode"
+				]),
+				ticket: this.gateMethod(target, "ticket"),
+				passkey: this.gateMethod(target, "passkey"),
+				web3: this.gateMethod(target, "web3")
+			}
+		};
+	}
+	buildSignUpProxy() {
+		const gateProperty = this.gateProperty.bind(this);
+		const gateMethod = this.gateMethod.bind(this);
+		const target = () => this.client.signUp.__internal_future;
+		return {
+			errors: defaultSignUpErrors(),
+			fetchStatus: "idle",
+			signUp: {
+				get id() {
+					return gateProperty(target, "id", void 0);
+				},
+				get requiredFields() {
+					return gateProperty(target, "requiredFields", []);
+				},
+				get optionalFields() {
+					return gateProperty(target, "optionalFields", []);
+				},
+				get missingFields() {
+					return gateProperty(target, "missingFields", []);
+				},
+				get username() {
+					return gateProperty(target, "username", null);
+				},
+				get firstName() {
+					return gateProperty(target, "firstName", null);
+				},
+				get lastName() {
+					return gateProperty(target, "lastName", null);
+				},
+				get emailAddress() {
+					return gateProperty(target, "emailAddress", null);
+				},
+				get phoneNumber() {
+					return gateProperty(target, "phoneNumber", null);
+				},
+				get web3Wallet() {
+					return gateProperty(target, "web3Wallet", null);
+				},
+				get hasPassword() {
+					return gateProperty(target, "hasPassword", false);
+				},
+				get unsafeMetadata() {
+					return gateProperty(target, "unsafeMetadata", {});
+				},
+				get createdSessionId() {
+					return gateProperty(target, "createdSessionId", null);
+				},
+				get createdUserId() {
+					return gateProperty(target, "createdUserId", null);
+				},
+				get abandonAt() {
+					return gateProperty(target, "abandonAt", null);
+				},
+				get legalAcceptedAt() {
+					return gateProperty(target, "legalAcceptedAt", null);
+				},
+				get locale() {
+					return gateProperty(target, "locale", null);
+				},
+				get status() {
+					return gateProperty(target, "status", "missing_requirements");
+				},
+				get unverifiedFields() {
+					return gateProperty(target, "unverifiedFields", []);
+				},
+				get isTransferable() {
+					return gateProperty(target, "isTransferable", false);
+				},
+				get canBeDiscarded() {
+					return gateProperty(target, "canBeDiscarded", false);
+				},
+				create: gateMethod(target, "create"),
+				update: gateMethod(target, "update"),
+				sso: gateMethod(target, "sso"),
+				password: gateMethod(target, "password"),
+				ticket: gateMethod(target, "ticket"),
+				web3: gateMethod(target, "web3"),
+				finalize: gateMethod(target, "finalize"),
+				reset: gateMethod(target, "reset"),
+				verifications: this.wrapStruct(() => target().verifications, [
+					"sendEmailCode",
+					"verifyEmailCode",
+					"sendEmailLink",
+					"waitForEmailLinkVerification",
+					"sendPhoneCode",
+					"verifyPhoneCode"
+				], [
+					"emailAddress",
+					"phoneNumber",
+					"web3Wallet",
+					"externalAccount",
+					"emailLinkVerification"
+				], {
+					emailAddress: defaultSignUpVerificationResource(),
+					phoneNumber: defaultSignUpVerificationResource(),
+					web3Wallet: defaultSignUpVerificationResource(),
+					externalAccount: defaultSignUpVerificationResource(),
+					emailLinkVerification: null
+				})
+			}
+		};
+	}
+	buildWaitlistProxy() {
+		const gateProperty = this.gateProperty.bind(this);
+		const gateMethod = this.gateMethod.bind(this);
+		const target = () => {
+			return this.state.__internal_waitlist;
+		};
+		return {
+			errors: defaultWaitlistErrors(),
+			fetchStatus: "idle",
+			waitlist: {
+				pathRoot: "/waitlist",
+				get id() {
+					return gateProperty(target, "id", "");
+				},
+				get createdAt() {
+					return gateProperty(target, "createdAt", null);
+				},
+				get updatedAt() {
+					return gateProperty(target, "updatedAt", null);
+				},
+				join: gateMethod(target, "join"),
+				reload: gateMethod(target, "reload")
+			}
+		};
+	}
+	buildCheckoutProxy(params) {
+		const gateProperty = this.gateProperty.bind(this);
+		const targetCheckout = () => this.checkout(params);
+		const target = () => targetCheckout().checkout;
+		return {
+			errors: {
+				raw: null,
+				global: null
+			},
+			fetchStatus: "idle",
+			checkout: {
+				get status() {
+					return gateProperty(target, "status", "needs_initialization");
+				},
+				get externalClientSecret() {
+					return gateProperty(target, "externalClientSecret", null);
+				},
+				get externalGatewayId() {
+					return gateProperty(target, "externalGatewayId", null);
+				},
+				get paymentMethod() {
+					return gateProperty(target, "paymentMethod", null);
+				},
+				get plan() {
+					return gateProperty(target, "plan", null);
+				},
+				get planPeriod() {
+					return gateProperty(target, "planPeriod", null);
+				},
+				get totals() {
+					return gateProperty(target, "totals", null);
+				},
+				get isImmediatePlanChange() {
+					return gateProperty(target, "isImmediatePlanChange", false);
+				},
+				get freeTrialEndsAt() {
+					return gateProperty(target, "freeTrialEndsAt", null);
+				},
+				get payer() {
+					return gateProperty(target, "payer", null);
+				},
+				get planPeriodStart() {
+					return gateProperty(target, "planPeriodStart", null);
+				},
+				get needsPaymentMethod() {
+					return gateProperty(target, "needsPaymentMethod", null);
+				},
+				start: this.gateMethod(target, "start"),
+				confirm: this.gateMethod(target, "confirm"),
+				finalize: this.gateMethod(target, "finalize")
+			}
+		};
+	}
+	__internal_effect(_) {
+		throw new Error("__internal_effect called before Clerk is loaded");
+	}
+	__internal_computed(_) {
+		throw new Error("__internal_computed called before Clerk is loaded");
+	}
+	get state() {
+		const s = this.isomorphicClerk.__internal_state;
+		if (!s) throw new Error("Clerk state not ready");
+		return s;
+	}
+	get client() {
+		const c = this.isomorphicClerk.client;
+		if (!c) throw new Error("Clerk client not ready");
+		return c;
+	}
+	get checkout() {
+		const c = this.isomorphicClerk.__experimental_checkout;
+		if (!c) throw new Error("Clerk checkout not ready");
+		return c;
+	}
+	gateProperty(getTarget, key, defaultValue) {
+		return (() => {
+			if (!(0, _clerk_shared_browser.inBrowser)() || !this.isomorphicClerk.loaded) return defaultValue;
+			return getTarget()[key];
+		})();
+	}
+	gateMethod(getTarget, key) {
+		return (async (...args) => {
+			if (!(0, _clerk_shared_browser.inBrowser)()) return require_useAssertWrappedByClerkProvider.errorThrower.throw(`Attempted to call a method (${key}) that is not supported on the server.`);
+			if (!this.isomorphicClerk.loaded) await new Promise((resolve) => this.isomorphicClerk.addOnLoaded(resolve));
+			const t = getTarget();
+			return t[key].apply(t, args);
+		});
+	}
+	wrapMethods(getTarget, keys) {
+		return Object.fromEntries(keys.map((k) => [k, this.gateMethod(getTarget, k)]));
+	}
+	wrapStruct(getTarget, methods, getters, fallbacks) {
+		const out = {};
+		for (const m of methods) out[m] = this.gateMethod(getTarget, m);
+		for (const g of getters) Object.defineProperty(out, g, {
+			get: () => this.gateProperty(getTarget, g, fallbacks[g]),
+			enumerable: true
+		});
+		return out;
+	}
+};
+
+//#endregion
+//#region src/isomorphicClerk.ts
+if (typeof globalThis.__BUILD_DISABLE_RHC__ === "undefined") globalThis.__BUILD_DISABLE_RHC__ = false;
+const SDK_METADATA = {
+	name: "@clerk/react",
+	version: "6.9.1-canary.v20260610190754",
+	environment: process.env.NODE_ENV
+};
+var IsomorphicClerk = class IsomorphicClerk {
+	#status;
+	#domain;
+	#proxyUrl;
+	#publishableKey;
+	#eventBus;
+	#stateProxy;
+	get publishableKey() {
+		return this.#publishableKey;
+	}
+	get loaded() {
+		return this.clerkjs?.loaded || false;
+	}
+	get status() {
+		/**
+		* If clerk-js is not available the returned value can either be "loading" or "error".
+		*/
+		if (!this.clerkjs) return this.#status;
+		return this.clerkjs?.status || (this.clerkjs.loaded ? "ready" : "loading");
+	}
+	static #instance;
+	static getOrCreateInstance(options) {
+		if (!(0, _clerk_shared_browser.inBrowser)() || !this.#instance || options.Clerk && this.#instance.Clerk !== options.Clerk || this.#instance.publishableKey !== options.publishableKey) this.#instance = new IsomorphicClerk(options);
+		return this.#instance;
+	}
+	static clearInstance() {
+		this.#instance = null;
+	}
+	get domain() {
+		if (typeof window !== "undefined" && window.location) return (0, _clerk_shared_utils.handleValueOrFn)(this.#domain, new URL(window.location.href), "");
+		if (typeof this.#domain === "function") return require_useAssertWrappedByClerkProvider.errorThrower.throw(require_hooks.unsupportedNonBrowserDomainOrProxyUrlFunction);
+		return this.#domain || "";
+	}
+	get proxyUrl() {
+		if (typeof window !== "undefined" && window.location) return (0, _clerk_shared_utils.handleValueOrFn)(this.#proxyUrl, new URL(window.location.href), "");
+		if (typeof this.#proxyUrl === "function") return require_useAssertWrappedByClerkProvider.errorThrower.throw(require_hooks.unsupportedNonBrowserDomainOrProxyUrlFunction);
+		return this.#proxyUrl || "";
+	}
+	/**
+	* Accesses private options from the `Clerk` instance and defaults to
+	* `IsomorphicClerk` options when in SSR context.
+	*  @internal
+	*/
+	__internal_getOption(key) {
+		return this.clerkjs?.__internal_getOption ? this.clerkjs?.__internal_getOption(key) : this.options[key];
+	}
+	constructor(options) {
+		this.clerkjs = null;
+		this.preopenOneTap = null;
+		this.preopenUserVerification = null;
+		this.preopenEnableOrganizationsPrompt = null;
+		this.preopenSignIn = null;
+		this.preopenCheckout = null;
+		this.preopenPlanDetails = null;
+		this.preopenSubscriptionDetails = null;
+		this.preopenSignUp = null;
+		this.preopenUserProfile = null;
+		this.preopenOrganizationProfile = null;
+		this.preopenCreateOrganization = null;
+		this.preOpenWaitlist = null;
+		this.premountSignInNodes = /* @__PURE__ */ new Map();
+		this.premountSignUpNodes = /* @__PURE__ */ new Map();
+		this.premountUserAvatarNodes = /* @__PURE__ */ new Map();
+		this.premountUserProfileNodes = /* @__PURE__ */ new Map();
+		this.premountUserButtonNodes = /* @__PURE__ */ new Map();
+		this.premountOrganizationProfileNodes = /* @__PURE__ */ new Map();
+		this.premountCreateOrganizationNodes = /* @__PURE__ */ new Map();
+		this.premountOrganizationSwitcherNodes = /* @__PURE__ */ new Map();
+		this.premountOrganizationListNodes = /* @__PURE__ */ new Map();
+		this.premountMethodCalls = /* @__PURE__ */ new Map();
+		this.premountWaitlistNodes = /* @__PURE__ */ new Map();
+		this.premountPricingTableNodes = /* @__PURE__ */ new Map();
+		this.premountAPIKeysNodes = /* @__PURE__ */ new Map();
+		this.premountConfigureSSONodes = /* @__PURE__ */ new Map();
+		this.premountOAuthConsentNodes = /* @__PURE__ */ new Map();
+		this.premountTaskChooseOrganizationNodes = /* @__PURE__ */ new Map();
+		this.premountTaskResetPasswordNodes = /* @__PURE__ */ new Map();
+		this.premountTaskSetupMFANodes = /* @__PURE__ */ new Map();
+		this.premountAddListenerCalls = /* @__PURE__ */ new Map();
+		this.loadedListeners = [];
+		this.#status = "loading";
+		this.#eventBus = (0, _clerk_shared_clerkEventBus.createClerkEventBus)();
+		this.buildSignInUrl = (opts) => {
+			const callback = () => this.clerkjs?.buildSignInUrl(opts) || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildSignInUrl", callback);
+		};
+		this.buildSignUpUrl = (opts) => {
+			const callback = () => this.clerkjs?.buildSignUpUrl(opts) || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildSignUpUrl", callback);
+		};
+		this.buildAfterSignInUrl = (...args) => {
+			const callback = () => this.clerkjs?.buildAfterSignInUrl(...args) || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildAfterSignInUrl", callback);
+		};
+		this.buildAfterSignUpUrl = (...args) => {
+			const callback = () => this.clerkjs?.buildAfterSignUpUrl(...args) || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildAfterSignUpUrl", callback);
+		};
+		this.buildAfterSignOutUrl = () => {
+			const callback = () => this.clerkjs?.buildAfterSignOutUrl() || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildAfterSignOutUrl", callback);
+		};
+		this.buildNewSubscriptionRedirectUrl = () => {
+			const callback = () => this.clerkjs?.buildNewSubscriptionRedirectUrl() || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildNewSubscriptionRedirectUrl", callback);
+		};
+		this.buildAfterMultiSessionSingleSignOutUrl = () => {
+			const callback = () => this.clerkjs?.buildAfterMultiSessionSingleSignOutUrl() || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildAfterMultiSessionSingleSignOutUrl", callback);
+		};
+		this.buildUserProfileUrl = () => {
+			const callback = () => this.clerkjs?.buildUserProfileUrl() || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildUserProfileUrl", callback);
+		};
+		this.buildCreateOrganizationUrl = () => {
+			const callback = () => this.clerkjs?.buildCreateOrganizationUrl() || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildCreateOrganizationUrl", callback);
+		};
+		this.buildOrganizationProfileUrl = () => {
+			const callback = () => this.clerkjs?.buildOrganizationProfileUrl() || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildOrganizationProfileUrl", callback);
+		};
+		this.buildWaitlistUrl = () => {
+			const callback = () => this.clerkjs?.buildWaitlistUrl() || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildWaitlistUrl", callback);
+		};
+		this.buildTasksUrl = () => {
+			const callback = () => this.clerkjs?.buildTasksUrl() || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildTasksUrl", callback);
+		};
+		this.buildUrlWithAuth = (to) => {
+			const callback = () => this.clerkjs?.buildUrlWithAuth(to) || "";
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("buildUrlWithAuth", callback);
+		};
+		this.handleUnauthenticated = async () => {
+			const callback = () => this.clerkjs?.handleUnauthenticated();
+			if (this.clerkjs && this.loaded) callback();
+			else this.premountMethodCalls.set("handleUnauthenticated", callback);
+		};
+		this.on = (...args) => {
+			if (this.clerkjs?.on) return this.clerkjs.on(...args);
+			else this.#eventBus.on(...args);
+		};
+		this.off = (...args) => {
+			if (this.clerkjs?.off) return this.clerkjs.off(...args);
+			else this.#eventBus.off(...args);
+		};
+		this.addOnLoaded = (cb) => {
+			this.loadedListeners.push(cb);
+			/**
+			* When IsomorphicClerk is loaded execute the callback directly
+			*/
+			if (this.loaded) this.emitLoaded();
+		};
+		this.emitLoaded = () => {
+			this.loadedListeners.forEach((cb) => cb());
+			this.loadedListeners = [];
+		};
+		this.beforeLoad = (clerkjs) => {
+			if (!clerkjs) throw new Error("Failed to hydrate latest Clerk JS");
+		};
+		this.replayInterceptedInvocations = (clerkjs) => {
+			if (!clerkjs) throw new Error("Failed to hydrate latest Clerk JS");
+			this.clerkjs = clerkjs;
+			this.premountMethodCalls.forEach((cb) => cb());
+			this.premountAddListenerCalls.forEach((listenerExtras, listener) => {
+				listenerExtras.handlers.nativeUnsubscribe = clerkjs.addListener(listener, listenerExtras.options);
+			});
+			this.#eventBus.internal.retrieveListeners("status")?.forEach((listener) => {
+				this.on("status", listener, { notify: true });
+			});
+			if (this.preopenSignIn !== null) clerkjs.openSignIn(this.preopenSignIn);
+			if (this.preopenCheckout !== null) clerkjs.__internal_openCheckout(this.preopenCheckout);
+			if (this.preopenPlanDetails !== null) clerkjs.__internal_openPlanDetails(this.preopenPlanDetails);
+			if (this.preopenSubscriptionDetails !== null) clerkjs.__internal_openSubscriptionDetails(this.preopenSubscriptionDetails);
+			if (this.preopenSignUp !== null) clerkjs.openSignUp(this.preopenSignUp);
+			if (this.preopenUserProfile !== null) clerkjs.openUserProfile(this.preopenUserProfile);
+			if (this.preopenUserVerification !== null) clerkjs.__internal_openReverification(this.preopenUserVerification);
+			if (this.preopenOneTap !== null) clerkjs.openGoogleOneTap(this.preopenOneTap);
+			if (this.preopenOrganizationProfile !== null) clerkjs.openOrganizationProfile(this.preopenOrganizationProfile);
+			if (this.preopenCreateOrganization !== null) clerkjs.openCreateOrganization(this.preopenCreateOrganization);
+			if (this.preOpenWaitlist !== null) clerkjs.openWaitlist(this.preOpenWaitlist);
+			if (this.preopenEnableOrganizationsPrompt) clerkjs.__internal_openEnableOrganizationsPrompt(this.preopenEnableOrganizationsPrompt);
+			this.premountSignInNodes.forEach((props, node) => {
+				clerkjs.mountSignIn(node, props);
+			});
+			this.premountSignUpNodes.forEach((props, node) => {
+				clerkjs.mountSignUp(node, props);
+			});
+			this.premountUserProfileNodes.forEach((props, node) => {
+				clerkjs.mountUserProfile(node, props);
+			});
+			this.premountUserAvatarNodes.forEach((props, node) => {
+				clerkjs.mountUserAvatar(node, props);
+			});
+			this.premountUserButtonNodes.forEach((props, node) => {
+				clerkjs.mountUserButton(node, props);
+			});
+			this.premountOrganizationListNodes.forEach((props, node) => {
+				clerkjs.mountOrganizationList(node, props);
+			});
+			this.premountWaitlistNodes.forEach((props, node) => {
+				clerkjs.mountWaitlist(node, props);
+			});
+			this.premountPricingTableNodes.forEach((props, node) => {
+				clerkjs.mountPricingTable(node, props);
+			});
+			this.premountAPIKeysNodes.forEach((props, node) => {
+				clerkjs.mountAPIKeys(node, props);
+			});
+			this.premountConfigureSSONodes.forEach((props, node) => {
+				clerkjs.__internal_mountConfigureSSO(node, props);
+			});
+			this.premountOAuthConsentNodes.forEach((props, node) => {
+				clerkjs.__internal_mountOAuthConsent(node, props);
+			});
+			this.premountTaskChooseOrganizationNodes.forEach((props, node) => {
+				clerkjs.mountTaskChooseOrganization(node, props);
+			});
+			this.premountTaskResetPasswordNodes.forEach((props, node) => {
+				clerkjs.mountTaskResetPassword(node, props);
+			});
+			this.premountTaskSetupMFANodes.forEach((props, node) => {
+				clerkjs.mountTaskSetupMFA(node, props);
+			});
+			/**
+			* Only update status in case `clerk.status` is missing. In any other case, `clerk-js` should be the orchestrator.
+			*/
+			if (typeof this.clerkjs.status === "undefined") this.#eventBus.emit(_clerk_shared_clerkEventBus.clerkEvents.Status, "ready");
+			this.emitLoaded();
+			return this.clerkjs;
+		};
+		this.__experimental_checkout = (...args) => {
+			return this.loaded && this.clerkjs ? this.clerkjs.__experimental_checkout(...args) : this.#stateProxy.checkoutSignal(...args);
+		};
+		this.__internal_updateProps = async (props) => {
+			const clerkjs = await this.#waitForClerkJS();
+			if (clerkjs && "__internal_updateProps" in clerkjs) return clerkjs.__internal_updateProps(props);
+		};
+		this.setActive = (params) => {
+			if (this.clerkjs) return this.clerkjs.setActive(params);
+			else return Promise.reject();
+		};
+		this.openSignIn = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.openSignIn(props);
+			else this.preopenSignIn = props;
+		};
+		this.closeSignIn = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.closeSignIn();
+			else this.preopenSignIn = null;
+		};
+		this.__internal_openCheckout = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_openCheckout(props);
+			else this.preopenCheckout = props;
+		};
+		this.__internal_closeCheckout = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_closeCheckout();
+			else this.preopenCheckout = null;
+		};
+		this.__internal_openPlanDetails = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_openPlanDetails(props);
+			else this.preopenPlanDetails = props;
+		};
+		this.__internal_closePlanDetails = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_closePlanDetails();
+			else this.preopenPlanDetails = null;
+		};
+		this.__internal_openSubscriptionDetails = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_openSubscriptionDetails(props);
+			else this.preopenSubscriptionDetails = props ?? null;
+		};
+		this.__internal_closeSubscriptionDetails = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_closeSubscriptionDetails();
+			else this.preopenSubscriptionDetails = null;
+		};
+		this.__internal_openReverification = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_openReverification(props);
+			else this.preopenUserVerification = props;
+		};
+		this.__internal_closeReverification = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_closeReverification();
+			else this.preopenUserVerification = null;
+		};
+		this.__internal_openEnableOrganizationsPrompt = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_openEnableOrganizationsPrompt(props);
+			else this.preopenEnableOrganizationsPrompt = props;
+		};
+		this.__internal_closeEnableOrganizationsPrompt = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_closeEnableOrganizationsPrompt();
+			else this.preopenEnableOrganizationsPrompt = null;
+		};
+		this.openGoogleOneTap = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.openGoogleOneTap(props);
+			else this.preopenOneTap = props;
+		};
+		this.closeGoogleOneTap = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.closeGoogleOneTap();
+			else this.preopenOneTap = null;
+		};
+		this.openUserProfile = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.openUserProfile(props);
+			else this.preopenUserProfile = props;
+		};
+		this.closeUserProfile = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.closeUserProfile();
+			else this.preopenUserProfile = null;
+		};
+		this.openOrganizationProfile = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.openOrganizationProfile(props);
+			else this.preopenOrganizationProfile = props;
+		};
+		this.closeOrganizationProfile = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.closeOrganizationProfile();
+			else this.preopenOrganizationProfile = null;
+		};
+		this.openCreateOrganization = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.openCreateOrganization(props);
+			else this.preopenCreateOrganization = props;
+		};
+		this.closeCreateOrganization = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.closeCreateOrganization();
+			else this.preopenCreateOrganization = null;
+		};
+		this.openWaitlist = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.openWaitlist(props);
+			else this.preOpenWaitlist = props;
+		};
+		this.closeWaitlist = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.closeWaitlist();
+			else this.preOpenWaitlist = null;
+		};
+		this.openSignUp = (props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.openSignUp(props);
+			else this.preopenSignUp = props;
+		};
+		this.closeSignUp = () => {
+			if (this.clerkjs && this.loaded) this.clerkjs.closeSignUp();
+			else this.preopenSignUp = null;
+		};
+		this.mountSignIn = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountSignIn(node, props);
+			else this.premountSignInNodes.set(node, props);
+		};
+		this.unmountSignIn = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountSignIn(node);
+			else this.premountSignInNodes.delete(node);
+		};
+		this.mountSignUp = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountSignUp(node, props);
+			else this.premountSignUpNodes.set(node, props);
+		};
+		this.unmountSignUp = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountSignUp(node);
+			else this.premountSignUpNodes.delete(node);
+		};
+		this.mountUserAvatar = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountUserAvatar(node, props);
+			else this.premountUserAvatarNodes.set(node, props);
+		};
+		this.unmountUserAvatar = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountUserAvatar(node);
+			else this.premountUserAvatarNodes.delete(node);
+		};
+		this.mountUserProfile = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountUserProfile(node, props);
+			else this.premountUserProfileNodes.set(node, props);
+		};
+		this.unmountUserProfile = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountUserProfile(node);
+			else this.premountUserProfileNodes.delete(node);
+		};
+		this.mountOrganizationProfile = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountOrganizationProfile(node, props);
+			else this.premountOrganizationProfileNodes.set(node, props);
+		};
+		this.unmountOrganizationProfile = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountOrganizationProfile(node);
+			else this.premountOrganizationProfileNodes.delete(node);
+		};
+		this.mountCreateOrganization = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountCreateOrganization(node, props);
+			else this.premountCreateOrganizationNodes.set(node, props);
+		};
+		this.unmountCreateOrganization = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountCreateOrganization(node);
+			else this.premountCreateOrganizationNodes.delete(node);
+		};
+		this.mountOrganizationSwitcher = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountOrganizationSwitcher(node, props);
+			else this.premountOrganizationSwitcherNodes.set(node, props);
+		};
+		this.unmountOrganizationSwitcher = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountOrganizationSwitcher(node);
+			else this.premountOrganizationSwitcherNodes.delete(node);
+		};
+		this.__experimental_prefetchOrganizationSwitcher = () => {
+			const callback = () => this.clerkjs?.__experimental_prefetchOrganizationSwitcher();
+			if (this.clerkjs && this.loaded) callback();
+			else this.premountMethodCalls.set("__experimental_prefetchOrganizationSwitcher", callback);
+		};
+		this.mountOrganizationList = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountOrganizationList(node, props);
+			else this.premountOrganizationListNodes.set(node, props);
+		};
+		this.unmountOrganizationList = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountOrganizationList(node);
+			else this.premountOrganizationListNodes.delete(node);
+		};
+		this.mountUserButton = (node, userButtonProps) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountUserButton(node, userButtonProps);
+			else this.premountUserButtonNodes.set(node, userButtonProps);
+		};
+		this.unmountUserButton = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountUserButton(node);
+			else this.premountUserButtonNodes.delete(node);
+		};
+		this.mountWaitlist = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountWaitlist(node, props);
+			else this.premountWaitlistNodes.set(node, props);
+		};
+		this.unmountWaitlist = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountWaitlist(node);
+			else this.premountWaitlistNodes.delete(node);
+		};
+		this.mountPricingTable = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountPricingTable(node, props);
+			else this.premountPricingTableNodes.set(node, props);
+		};
+		this.unmountPricingTable = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountPricingTable(node);
+			else this.premountPricingTableNodes.delete(node);
+		};
+		this.mountAPIKeys = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountAPIKeys(node, props);
+			else this.premountAPIKeysNodes.set(node, props);
+		};
+		this.unmountAPIKeys = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountAPIKeys(node);
+			else this.premountAPIKeysNodes.delete(node);
+		};
+		this.__internal_mountConfigureSSO = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_mountConfigureSSO(node, props);
+			else this.premountConfigureSSONodes.set(node, props);
+		};
+		this.__internal_unmountConfigureSSO = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_unmountConfigureSSO(node);
+			else this.premountConfigureSSONodes.delete(node);
+		};
+		this.__internal_mountOAuthConsent = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_mountOAuthConsent(node, props);
+			else this.premountOAuthConsentNodes.set(node, props);
+		};
+		this.__internal_unmountOAuthConsent = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.__internal_unmountOAuthConsent(node);
+			else this.premountOAuthConsentNodes.delete(node);
+		};
+		this.mountOAuthConsent = (node, props) => {
+			this.__internal_mountOAuthConsent(node, props);
+		};
+		this.unmountOAuthConsent = (node) => {
+			this.__internal_unmountOAuthConsent(node);
+		};
+		this.mountTaskChooseOrganization = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountTaskChooseOrganization(node, props);
+			else this.premountTaskChooseOrganizationNodes.set(node, props);
+		};
+		this.unmountTaskChooseOrganization = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountTaskChooseOrganization(node);
+			else this.premountTaskChooseOrganizationNodes.delete(node);
+		};
+		this.mountTaskResetPassword = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountTaskResetPassword(node, props);
+			else this.premountTaskResetPasswordNodes.set(node, props);
+		};
+		this.unmountTaskResetPassword = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountTaskResetPassword(node);
+			else this.premountTaskResetPasswordNodes.delete(node);
+		};
+		this.mountTaskSetupMFA = (node, props) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.mountTaskSetupMFA(node, props);
+			else this.premountTaskSetupMFANodes.set(node, props);
+		};
+		this.unmountTaskSetupMFA = (node) => {
+			if (this.clerkjs && this.loaded) this.clerkjs.unmountTaskSetupMFA(node);
+			else this.premountTaskSetupMFANodes.delete(node);
+		};
+		this.addListener = (listener, options) => {
+			if (this.clerkjs) return this.clerkjs.addListener(listener, options);
+			else {
+				const unsubscribe = () => {
+					const listenerExtras = this.premountAddListenerCalls.get(listener);
+					if (listenerExtras?.handlers) {
+						listenerExtras?.handlers.nativeUnsubscribe?.();
+						this.premountAddListenerCalls.delete(listener);
+					}
+				};
+				this.premountAddListenerCalls.set(listener, {
+					options,
+					handlers: {
+						unsubscribe,
+						nativeUnsubscribe: void 0
+					}
+				});
+				return unsubscribe;
+			}
+		};
+		this.navigate = (to) => {
+			const callback = () => this.clerkjs?.navigate(to);
+			if (this.clerkjs && this.loaded) callback();
+			else this.premountMethodCalls.set("navigate", callback);
+		};
+		this.redirectWithAuth = async (...args) => {
+			const callback = () => this.clerkjs?.redirectWithAuth(...args);
+			if (this.clerkjs && this.loaded) return callback();
+			else {
+				this.premountMethodCalls.set("redirectWithAuth", callback);
+				return;
+			}
+		};
+		this.redirectToSignIn = async (opts) => {
+			const callback = () => this.clerkjs?.redirectToSignIn(opts);
+			if (this.clerkjs && this.loaded) return callback();
+			else {
+				this.premountMethodCalls.set("redirectToSignIn", callback);
+				return;
+			}
+		};
+		this.redirectToSignUp = async (opts) => {
+			const callback = () => this.clerkjs?.redirectToSignUp(opts);
+			if (this.clerkjs && this.loaded) return callback();
+			else {
+				this.premountMethodCalls.set("redirectToSignUp", callback);
+				return;
+			}
+		};
+		this.redirectToUserProfile = async () => {
+			const callback = () => this.clerkjs?.redirectToUserProfile();
+			if (this.clerkjs && this.loaded) return callback();
+			else {
+				this.premountMethodCalls.set("redirectToUserProfile", callback);
+				return;
+			}
+		};
+		this.redirectToAfterSignUp = () => {
+			const callback = () => this.clerkjs?.redirectToAfterSignUp();
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("redirectToAfterSignUp", callback);
+		};
+		this.redirectToAfterSignIn = () => {
+			const callback = () => this.clerkjs?.redirectToAfterSignIn();
+			if (this.clerkjs && this.loaded) callback();
+			else this.premountMethodCalls.set("redirectToAfterSignIn", callback);
+		};
+		this.redirectToAfterSignOut = () => {
+			const callback = () => this.clerkjs?.redirectToAfterSignOut();
+			if (this.clerkjs && this.loaded) callback();
+			else this.premountMethodCalls.set("redirectToAfterSignOut", callback);
+		};
+		this.redirectToOrganizationProfile = async () => {
+			const callback = () => this.clerkjs?.redirectToOrganizationProfile();
+			if (this.clerkjs && this.loaded) return callback();
+			else {
+				this.premountMethodCalls.set("redirectToOrganizationProfile", callback);
+				return;
+			}
+		};
+		this.redirectToCreateOrganization = async () => {
+			const callback = () => this.clerkjs?.redirectToCreateOrganization();
+			if (this.clerkjs && this.loaded) return callback();
+			else {
+				this.premountMethodCalls.set("redirectToCreateOrganization", callback);
+				return;
+			}
+		};
+		this.redirectToWaitlist = async () => {
+			const callback = () => this.clerkjs?.redirectToWaitlist();
+			if (this.clerkjs && this.loaded) return callback();
+			else {
+				this.premountMethodCalls.set("redirectToWaitlist", callback);
+				return;
+			}
+		};
+		this.redirectToTasks = async (opts) => {
+			const callback = () => this.clerkjs?.redirectToTasks(opts);
+			if (this.clerkjs && this.loaded) return callback();
+			else {
+				this.premountMethodCalls.set("redirectToTasks", callback);
+				return;
+			}
+		};
+		this.handleRedirectCallback = async (params) => {
+			const callback = () => this.clerkjs?.handleRedirectCallback(params);
+			if (this.clerkjs && this.loaded) callback()?.catch(() => {});
+			else this.premountMethodCalls.set("handleRedirectCallback", callback);
+		};
+		this.handleGoogleOneTapCallback = async (signInOrUp, params) => {
+			const callback = () => this.clerkjs?.handleGoogleOneTapCallback(signInOrUp, params);
+			if (this.clerkjs && this.loaded) callback()?.catch(() => {});
+			else this.premountMethodCalls.set("handleGoogleOneTapCallback", callback);
+		};
+		this.handleEmailLinkVerification = async (params) => {
+			const callback = () => this.clerkjs?.handleEmailLinkVerification(params);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("handleEmailLinkVerification", callback);
+		};
+		this.authenticateWithMetamask = async (params) => {
+			const callback = () => this.clerkjs?.authenticateWithMetamask(params);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("authenticateWithMetamask", callback);
+		};
+		this.authenticateWithCoinbaseWallet = async (params) => {
+			const callback = () => this.clerkjs?.authenticateWithCoinbaseWallet(params);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("authenticateWithCoinbaseWallet", callback);
+		};
+		this.authenticateWithBase = async (params) => {
+			const callback = () => this.clerkjs?.authenticateWithBase(params);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("authenticateWithBase", callback);
+		};
+		this.authenticateWithOKXWallet = async (params) => {
+			const callback = () => this.clerkjs?.authenticateWithOKXWallet(params);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("authenticateWithOKXWallet", callback);
+		};
+		this.authenticateWithSolana = async (params) => {
+			const callback = () => this.clerkjs?.authenticateWithSolana(params);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("authenticateWithSolana", callback);
+		};
+		this.authenticateWithWeb3 = async (params) => {
+			const callback = () => this.clerkjs?.authenticateWithWeb3(params);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("authenticateWithWeb3", callback);
+		};
+		this.authenticateWithGoogleOneTap = async (params) => {
+			return (await this.#waitForClerkJS()).authenticateWithGoogleOneTap(params);
+		};
+		this.__internal_loadStripeJs = async () => {
+			return (await this.#waitForClerkJS()).__internal_loadStripeJs();
+		};
+		this.createOrganization = async (params) => {
+			const callback = () => this.clerkjs?.createOrganization(params);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("createOrganization", callback);
+		};
+		this.getOrganization = async (organizationId) => {
+			const callback = () => this.clerkjs?.getOrganization(organizationId);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("getOrganization", callback);
+		};
+		this.joinWaitlist = async (params) => {
+			const callback = () => this.clerkjs?.joinWaitlist(params);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("joinWaitlist", callback);
+		};
+		this.signOut = async (...args) => {
+			const callback = () => this.clerkjs?.signOut(...args);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("signOut", callback);
+		};
+		this.__internal_attemptToEnableEnvironmentSetting = (options) => {
+			const callback = () => this.clerkjs?.__internal_attemptToEnableEnvironmentSetting(options);
+			if (this.clerkjs && this.loaded) return callback();
+			else this.premountMethodCalls.set("__internal_attemptToEnableEnvironmentSetting", callback);
+		};
+		this.#publishableKey = options?.publishableKey;
+		this.#proxyUrl = options?.proxyUrl;
+		this.#domain = options?.domain;
+		this.options = options;
+		this.Clerk = options?.Clerk || null;
+		this.mode = (0, _clerk_shared_browser.inBrowser)() ? "browser" : "server";
+		this.#stateProxy = new StateProxy(this);
+		if (!this.options.sdkMetadata) this.options.sdkMetadata = SDK_METADATA;
+		this.#eventBus.emit(_clerk_shared_clerkEventBus.clerkEvents.Status, "loading");
+		this.#eventBus.prioritizedOn(_clerk_shared_clerkEventBus.clerkEvents.Status, (status) => this.#status = status);
+		if (this.#publishableKey && this.options.experimental?.runtimeEnvironment === "headless" && this.options.Clerk) this.loadHeadlessClerk();
+		else if (this.#publishableKey) this.getEntryChunks();
+	}
+	/**
+	* Initialize Clerk for headless/React Native environments where a Clerk instance is provided directly.
+	* Only handles Clerk construction and loading — post-load wiring is shared via replayInterceptedInvocations.
+	*/
+	loadHeadlessClerk() {
+		const clerk = require_hooks.isConstructor(this.options.Clerk) ? new this.options.Clerk(this.#publishableKey, {
+			proxyUrl: this.proxyUrl,
+			domain: this.domain
+		}) : this.options.Clerk;
+		if (!clerk) {
+			this.#eventBus.emit(_clerk_shared_clerkEventBus.clerkEvents.Status, "error");
+			return;
+		}
+		const onLoaded = () => {
+			this.replayInterceptedInvocations(clerk);
+		};
+		if (!clerk.loaded) clerk.load(this.options).then(() => onLoaded()).catch((err) => {
+			this.#eventBus.emit(_clerk_shared_clerkEventBus.clerkEvents.Status, "error");
+			this.emitLoaded();
+		});
+		else onLoaded();
+	}
+	get sdkMetadata() {
+		return this.clerkjs?.sdkMetadata || this.options.sdkMetadata || void 0;
+	}
+	get instanceType() {
+		return this.clerkjs?.instanceType;
+	}
+	get frontendApi() {
+		return this.clerkjs?.frontendApi || "";
+	}
+	get isStandardBrowser() {
+		return this.clerkjs?.isStandardBrowser || this.options.standardBrowser || false;
+	}
+	get isSatellite() {
+		if (typeof window !== "undefined" && window.location) return (0, _clerk_shared_utils.handleValueOrFn)(this.options.isSatellite, new URL(window.location.href), false);
+		if (typeof this.options.isSatellite === "function") return require_useAssertWrappedByClerkProvider.errorThrower.throw(require_hooks.unsupportedNonBrowserDomainOrProxyUrlFunction);
+		return false;
+	}
+	#waitForClerkJS() {
+		return new Promise((resolve) => {
+			this.addOnLoaded(() => resolve(this.clerkjs));
+		});
+	}
+	async getEntryChunks() {
+		if (this.mode !== "browser" || this.loaded) return;
+		if (typeof window !== "undefined") {
+			window.__clerk_publishable_key = this.#publishableKey;
+			window.__clerk_proxy_url = this.proxyUrl;
+			window.__clerk_domain = this.domain;
+		}
+		try {
+			const clerk = await this.getClerkJsEntryChunk();
+			if (!clerk.loaded) {
+				this.beforeLoad(clerk);
+				const ClerkUI = this.options.standardBrowser !== false && !this.options.Clerk || !!this.options.ui?.ClerkUI ? await this.getClerkUIEntryChunk() : void 0;
+				await clerk.load({
+					...this.options,
+					ui: {
+						...this.options.ui,
+						ClerkUI
+					}
+				});
+			}
+			if (clerk.loaded) this.replayInterceptedInvocations(clerk);
+		} catch (err) {
+			const error = err;
+			this.#eventBus.emit(_clerk_shared_clerkEventBus.clerkEvents.Status, "error");
+			console.error(error.stack || error.message || error);
+			return;
+		}
+	}
+	async getClerkJsEntryChunk() {
+		if ((!this.options.Clerk || this.options.__internal_clerkJSUrl) && !__BUILD_DISABLE_RHC__) await (0, _clerk_shared_loadClerkJsScript.loadClerkJSScript)({
+			...this.options,
+			publishableKey: this.#publishableKey,
+			proxyUrl: this.proxyUrl,
+			domain: this.domain,
+			nonce: this.options.nonce
+		});
+		if (this.options.Clerk && !this.options.__internal_clerkJSUrl) global.Clerk = require_hooks.isConstructor(this.options.Clerk) ? new this.options.Clerk(this.#publishableKey, {
+			proxyUrl: this.proxyUrl,
+			domain: this.domain
+		}) : this.options.Clerk;
+		if (!global.Clerk) throw new Error("Failed to download latest ClerkJS. Contact support@clerk.com.");
+		return global.Clerk;
+	}
+	async getClerkUIEntryChunk() {
+		const uiProp = this.options.ui;
+		const hasInternalUrl = !!this.options.__internal_clerkUIUrl;
+		if (uiProp?.ClerkUI && !hasInternalUrl) return uiProp.ClerkUI;
+		if ((uiProp || this.options.prefetchUI === false) && !hasInternalUrl) return;
+		if (!__BUILD_DISABLE_RHC__) {
+			await (0, _clerk_shared_loadClerkJsScript.loadClerkUIScript)({
+				...this.options,
+				publishableKey: this.#publishableKey,
+				proxyUrl: this.proxyUrl,
+				domain: this.domain,
+				nonce: this.options.nonce
+			});
+			if (!global.__internal_ClerkUICtor) throw new Error("Failed to download latest Clerk UI. Contact support@clerk.com.");
+			return global.__internal_ClerkUICtor;
+		}
+	}
+	get version() {
+		return this.clerkjs?.version;
+	}
+	get client() {
+		if (this.clerkjs) return this.clerkjs.client;
+		else return;
+	}
+	get session() {
+		if (this.clerkjs) return this.clerkjs.session;
+		else return;
+	}
+	get user() {
+		if (this.clerkjs) return this.clerkjs.user;
+		else return;
+	}
+	get organization() {
+		if (this.clerkjs) return this.clerkjs.organization;
+		else return;
+	}
+	get telemetry() {
+		if (this.clerkjs) return this.clerkjs.telemetry;
+		else return;
+	}
+	get __internal_environment() {
+		if (this.clerkjs) return this.clerkjs.__internal_environment;
+		else return;
+	}
+	get isSignedIn() {
+		if (this.clerkjs) return this.clerkjs.isSignedIn;
+		else return false;
+	}
+	get billing() {
+		return this.clerkjs?.billing;
+	}
+	get __internal_state() {
+		return this.loaded && this.clerkjs ? this.clerkjs.__internal_state : this.#stateProxy;
+	}
+	get apiKeys() {
+		return this.clerkjs?.apiKeys;
+	}
+	get oauthApplication() {
+		return this.clerkjs?.oauthApplication;
+	}
+	__internal_setEnvironment(...args) {
+		if (this.clerkjs && "__internal_setEnvironment" in this.clerkjs) this.clerkjs.__internal_setEnvironment(args);
+		else return;
+	}
+	get __internal_lastEmittedResources() {
+		return this.clerkjs?.__internal_lastEmittedResources;
+	}
+};
+
+//#endregion
+//#region src/utils/versionCheck.ts
+/**
+* Checks if the host application's React version is compatible with @clerk/ui's shared variant.
+* The shared variant expects React to be provided via globalThis.__clerkSharedModules,
+* so we need to ensure the host's React version matches what @clerk/ui was built against.
+*
+* This function is evaluated once at module load time.
+*/
+function computeReactVersionCompatibility() {
+	try {
+		return (0, _clerk_shared_versionCheck.isVersionCompatible)(react.default.version, [
+			[
+				18,
+				0,
+				-1,
+				0
+			],
+			[
+				19,
+				0,
+				0,
+				3
+			],
+			[
+				19,
+				1,
+				1,
+				4
+			],
+			[
+				19,
+				2,
+				2,
+				3
+			],
+			[
+				19,
+				3,
+				3,
+				0
+			]
+		]);
+	} catch {
+		return false;
+	}
+}
+/**
+* Whether the host React version is compatible with the shared @clerk/ui variant.
+* This is computed once at module load time for optimal performance.
+*/
+const IS_REACT_SHARED_VARIANT_COMPATIBLE = computeReactVersionCompatibility();
+
+//#endregion
+//#region src/contexts/ClerkProvider.tsx
+function ClerkProviderBase(props) {
+	const { initialState, children, ...restIsomorphicClerkOptions } = props;
+	const { isomorphicClerk, clerkStatus } = useLoadedIsomorphicClerk(require_hooks.mergeWithEnv(restIsomorphicClerkOptions));
+	return /* @__PURE__ */ react.default.createElement(_clerk_shared_react.ClerkContextProvider, {
+		initialState,
+		clerk: isomorphicClerk,
+		clerkStatus
+	}, children);
+}
+const ClerkProvider = require_hooks.withMaxAllowedInstancesGuard(ClerkProviderBase, "ClerkProvider", require_hooks.multipleClerkProvidersError);
+ClerkProvider.displayName = "ClerkProvider";
+const DEFAULT_CLERK_UI_VARIANT = IS_REACT_SHARED_VARIANT_COMPATIBLE ? "shared" : "";
+const useLoadedIsomorphicClerk = (mergedOptions) => {
+	const optionsWithDefaults = react.default.useMemo(() => ({
+		clerkUIVariant: DEFAULT_CLERK_UI_VARIANT,
+		...mergedOptions
+	}), [mergedOptions]);
+	const isomorphicClerkRef = react.default.useRef(IsomorphicClerk.getOrCreateInstance(optionsWithDefaults));
+	const [clerkStatus, setClerkStatus] = react.default.useState(isomorphicClerkRef.current.status);
+	react.default.useEffect(() => {
+		isomorphicClerkRef.current.__internal_updateProps({ appearance: mergedOptions.appearance });
+	}, [mergedOptions.appearance]);
+	react.default.useEffect(() => {
+		isomorphicClerkRef.current.__internal_updateProps({ options: mergedOptions });
+	}, [mergedOptions.localization]);
+	react.default.useEffect(() => {
+		isomorphicClerkRef.current.on("status", setClerkStatus);
+		return () => {
+			if (isomorphicClerkRef.current) isomorphicClerkRef.current.off("status", setClerkStatus);
+			IsomorphicClerk.clearInstance();
+		};
+	}, []);
+	return {
+		isomorphicClerk: isomorphicClerkRef.current,
+		clerkStatus
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'AuthenticateWithRedirectCallback', {
+  enumerable: true,
+  get: function () {
+    return AuthenticateWithRedirectCallback;
+  }
+});
+Object.defineProperty(exports, 'ClerkDegraded', {
+  enumerable: true,
+  get: function () {
+    return ClerkDegraded;
+  }
+});
+Object.defineProperty(exports, 'ClerkFailed', {
+  enumerable: true,
+  get: function () {
+    return ClerkFailed;
+  }
+});
+Object.defineProperty(exports, 'ClerkLoaded', {
+  enumerable: true,
+  get: function () {
+    return ClerkLoaded;
+  }
+});
+Object.defineProperty(exports, 'ClerkLoading', {
+  enumerable: true,
+  get: function () {
+    return ClerkLoading;
+  }
+});
+Object.defineProperty(exports, 'ClerkProvider', {
+  enumerable: true,
+  get: function () {
+    return ClerkProvider;
+  }
+});
+Object.defineProperty(exports, 'IS_REACT_SHARED_VARIANT_COMPATIBLE', {
+  enumerable: true,
+  get: function () {
+    return IS_REACT_SHARED_VARIANT_COMPATIBLE;
+  }
+});
+Object.defineProperty(exports, 'MultisessionAppSupport', {
+  enumerable: true,
+  get: function () {
+    return MultisessionAppSupport;
+  }
+});
+Object.defineProperty(exports, 'RedirectToCreateOrganization', {
+  enumerable: true,
+  get: function () {
+    return RedirectToCreateOrganization;
+  }
+});
+Object.defineProperty(exports, 'RedirectToOrganizationProfile', {
+  enumerable: true,
+  get: function () {
+    return RedirectToOrganizationProfile;
+  }
+});
+Object.defineProperty(exports, 'RedirectToSignIn', {
+  enumerable: true,
+  get: function () {
+    return RedirectToSignIn;
+  }
+});
+Object.defineProperty(exports, 'RedirectToSignUp', {
+  enumerable: true,
+  get: function () {
+    return RedirectToSignUp;
+  }
+});
+Object.defineProperty(exports, 'RedirectToTasks', {
+  enumerable: true,
+  get: function () {
+    return RedirectToTasks;
+  }
+});
+Object.defineProperty(exports, 'RedirectToUserProfile', {
+  enumerable: true,
+  get: function () {
+    return RedirectToUserProfile;
+  }
+});
+Object.defineProperty(exports, 'Show', {
+  enumerable: true,
+  get: function () {
+    return Show;
+  }
+});
+//# sourceMappingURL=ClerkProvider-9lxHp9j5.cjs.map