clerk-solidjs/dist/chunk/7ARPN5DO.jsx

Clerk for SolidJS

// src/errors/error-thrower.ts
import { buildErrorThrower } from "@clerk/shared/error";
var errorThrower = buildErrorThrower({ packageName: "clerk-solidjs" });
function setErrorThrowerOptions(options) {
  errorThrower.setMessages(options).setPackageName(options);
}

// src/contexts/clerk.tsx
import { isPublishableKey } from "@clerk/shared/keys";
import { createEffect as createEffect3, splitProps } from "solid-js";

// src/errors/messages.ts
var multipleClerkProvidersError = "You've added multiple <ClerkProvider> components in your SolidJS component tree. Wrap your components in a single <ClerkProvider>.";
var multipleChildrenInButtonComponent = (name) => `You've passed multiple children components to <${name}/>. You can only pass a single child component or text.`;
var unsupportedNonBrowserDomainOrProxyUrlFunction = "Unsupported usage of isSatellite, domain or proxyUrl. The usage of isSatellite, domain or proxyUrl as function is not supported in non-browser environments.";
var userProfilePageRenderedError = "<UserProfile.Page /> component needs to be a direct child of `<UserProfile />` or `<UserButton />`.";
var userProfileLinkRenderedError = "<UserProfile.Link /> component needs to be a direct child of `<UserProfile />` or `<UserButton />`.";
var organizationProfilePageRenderedError = "<OrganizationProfile.Page /> component needs to be a direct child of `<OrganizationProfile />` or `<OrganizationSwitcher />`.";
var organizationProfileLinkRenderedError = "<OrganizationProfile.Link /> component needs to be a direct child of `<OrganizationProfile />` or `<OrganizationSwitcher />`.";
var useAuthHasRequiresRoleOrPermission = 'Missing parameters. `has` from `useAuth` requires a permission or role key to be passed. Example usage: `has({permission: "org:posts:edit"`';

// src/utils/children-utils.tsx
var assertSingleChild = (children) => (name) => {
  try {
    if (Array.isArray(children)) {
      throw new Error();
    } else if (children instanceof Node) {
      if (children.previousSibling || children.nextSibling) {
        throw new Error();
      }
    }
    return children;
  } catch {
    return errorThrower.throw(multipleChildrenInButtonComponent(name));
  }
};
var normalizeWithDefaultValue = (children, defaultText) => {
  if (!children) {
    children = defaultText;
  }
  return children;
};
var safeExecute = (cb) => (...args) => {
  if (cb && typeof cb === "function") {
    return cb(...args);
  }
};

// src/utils/create-context-provider-and-hook.ts
import {
  createContextProvider
} from "@solid-primitives/context";
function createContextProviderAndHook(name, factoryFn) {
  const [ContextProvider, useContextUnsafe] = createContextProvider(factoryFn);
  const useContext2 = () => {
    const ctx = useContextUnsafe();
    if (ctx === void 0) {
      throw new Error(`${name} not found`);
    }
    return ctx;
  };
  return [ContextProvider, useContext2, useContextUnsafe];
}

// src/utils/is-constructor.ts
function isConstructor(f) {
  return typeof f === "function";
}

// src/utils/is-dev-or-stage-url.ts
import { createDevOrStagingUrlCache } from "@clerk/shared/keys";
var { isDevOrStagingUrl } = createDevOrStagingUrlCache();

// src/utils/load-clerk-js-script.ts
import { parsePublishableKey } from "@clerk/shared/keys";
import { loadScript } from "@clerk/shared/loadScript";
import { isValidProxyUrl, proxyUrlToAbsoluteURL } from "@clerk/shared/proxy";
import { addClerkPrefix } from "@clerk/shared/url";

// src/utils/use-max-allowed-instances-guard.tsx
import { createEffect, onCleanup } from "solid-js";
var counts = /* @__PURE__ */ new Map();
function useMaxAllowedInstancesGuard(props) {
  createEffect(() => {
    const count = counts.get(props().name) || 0;
    if (count == (props().maxCount ?? 1)) {
      return errorThrower.throw(props().error);
    }
    counts.set(props().name, count + 1);
    onCleanup(() => {
      counts.set(props().name, (counts.get(props().name) || 1) - 1);
    });
  });
}
function withMaxAllowedInstancesGuard(WrappedComponent, name, error) {
  const HOC = (props) => {
    useMaxAllowedInstancesGuard(() => ({ name, error }));
    return <WrappedComponent {...props} />;
  };
  return HOC;
}

// src/contexts/clerk-context.tsx
import { deriveState } from "@clerk/shared";
import {
  createEffect as createEffect2,
  createMemo,
  createSignal,
  on,
  onCleanup as onCleanup2,
  untrack
} from "solid-js";

// src/isomorphic-clerk.ts
import { inBrowser } from "@clerk/shared/browser";
import { loadClerkJsScript } from "@clerk/shared/loadClerkJsScript";
import { handleValueOrFn } from "@clerk/shared/utils";
if (typeof __BUILD_DISABLE_RHC__ === "undefined") {
  globalThis.__BUILD_DISABLE_RHC__ = false;
}
var SDK_METADATA = {
  name: "clerk-solidjs",
  version: "2.0.10",
  environment: "production"
};
var IsomorphicClerk = class _IsomorphicClerk {
  mode;
  options;
  Clerk;
  clerkjs = null;
  preopenOneTap = null;
  preopenUserVerification = null;
  preopenSignIn = null;
  preopenSignUp = null;
  preopenUserProfile = null;
  preopenOrganizationProfile = null;
  preopenCreateOrganization = null;
  preOpenWaitlist = null;
  premountSignInNodes = /* @__PURE__ */ new Map();
  premountSignUpNodes = /* @__PURE__ */ new Map();
  premountUserProfileNodes = /* @__PURE__ */ new Map();
  premountUserButtonNodes = /* @__PURE__ */ new Map();
  premountOrganizationProfileNodes = /* @__PURE__ */ new Map();
  premountCreateOrganizationNodes = /* @__PURE__ */ new Map();
  premountOrganizationSwitcherNodes = /* @__PURE__ */ new Map();
  premountOrganizationListNodes = /* @__PURE__ */ new Map();
  premountMethodCalls = /* @__PURE__ */ new Map();
  premountWaitlistNodes = /* @__PURE__ */ new Map();
  // A separate Map of `addListener` method calls to handle multiple listeners.
  premountAddListenerCalls = /* @__PURE__ */ new Map();
  loadedListeners = [];
  #loaded = false;
  #domain;
  #proxyUrl;
  #publishableKey;
  get publishableKey() {
    return this.#publishableKey;
  }
  get loaded() {
    return this.#loaded;
  }
  static #instance;
  static getOrCreateInstance(options) {
    if (!inBrowser() || !this.#instance || options.Clerk && this.#instance.Clerk !== options.Clerk || // Allow hot swapping PKs on the client
    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 handleValueOrFn(this.#domain, new URL(window.location.href), "");
    }
    if (typeof this.#domain === "function") {
      return errorThrower.throw(unsupportedNonBrowserDomainOrProxyUrlFunction);
    }
    return this.#domain || "";
  }
  get proxyUrl() {
    if (typeof window !== "undefined" && window.location) {
      return handleValueOrFn(this.#proxyUrl, new URL(window.location.href), "");
    }
    if (typeof this.#proxyUrl === "function") {
      return errorThrower.throw(unsupportedNonBrowserDomainOrProxyUrlFunction);
    }
    return this.#proxyUrl || "";
  }
  __internal_getOption(key) {
    return this.clerkjs?.__internal_getOption(key);
  }
  constructor(options) {
    const { Clerk = null, publishableKey } = options || {};
    this.#publishableKey = publishableKey;
    this.#proxyUrl = options?.proxyUrl;
    this.#domain = options?.domain;
    this.options = options;
    this.Clerk = Clerk;
    this.mode = inBrowser() ? "browser" : "server";
    if (!this.options.sdkMetadata) {
      this.options.sdkMetadata = SDK_METADATA;
    }
    if (this.#publishableKey) {
      void this.loadClerkJS();
    }
  }
  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 handleValueOrFn(
        this.options.isSatellite,
        new URL(window.location.href),
        false
      );
    }
    if (typeof this.options.isSatellite === "function") {
      return errorThrower.throw(unsupportedNonBrowserDomainOrProxyUrlFunction);
    }
    return false;
  }
  buildSignInUrl = (opts) => {
    const callback = () => this.clerkjs?.buildSignInUrl(opts) || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildSignInUrl", callback);
    }
  };
  buildSignUpUrl = (opts) => {
    const callback = () => this.clerkjs?.buildSignUpUrl(opts) || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildSignUpUrl", callback);
    }
  };
  buildAfterSignInUrl = () => {
    const callback = () => this.clerkjs?.buildAfterSignInUrl() || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildAfterSignInUrl", callback);
    }
  };
  buildAfterSignUpUrl = () => {
    const callback = () => this.clerkjs?.buildAfterSignUpUrl() || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildAfterSignUpUrl", callback);
    }
  };
  buildAfterSignOutUrl = () => {
    const callback = () => this.clerkjs?.buildAfterSignOutUrl() || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildAfterSignOutUrl", callback);
    }
  };
  buildAfterMultiSessionSingleSignOutUrl = () => {
    const callback = () => this.clerkjs?.buildAfterMultiSessionSingleSignOutUrl() || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set(
        "buildAfterMultiSessionSingleSignOutUrl",
        callback
      );
    }
  };
  buildUserProfileUrl = () => {
    const callback = () => this.clerkjs?.buildUserProfileUrl() || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildUserProfileUrl", callback);
    }
  };
  buildCreateOrganizationUrl = () => {
    const callback = () => this.clerkjs?.buildCreateOrganizationUrl() || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildCreateOrganizationUrl", callback);
    }
  };
  buildOrganizationProfileUrl = () => {
    const callback = () => this.clerkjs?.buildOrganizationProfileUrl() || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildOrganizationProfileUrl", callback);
    }
  };
  buildWaitlistUrl = () => {
    const callback = () => this.clerkjs?.buildWaitlistUrl() || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildWaitlistUrl", callback);
    }
  };
  buildUrlWithAuth = (to) => {
    const callback = () => this.clerkjs?.buildUrlWithAuth(to) || "";
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("buildUrlWithAuth", callback);
    }
  };
  handleUnauthenticated = () => {
    const callback = () => this.clerkjs?.handleUnauthenticated();
    if (this.clerkjs && this.#loaded) {
      void callback();
    } else {
      this.premountMethodCalls.set("handleUnauthenticated", callback);
    }
  };
  #waitForClerkJS() {
    return new Promise((resolve) => {
      this.addOnLoaded(() => resolve(this.clerkjs));
    });
  }
  async loadClerkJS() {
    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 {
      if (this.Clerk) {
        let c;
        if (isConstructor(this.Clerk)) {
          c = new this.Clerk(this.#publishableKey, {
            proxyUrl: this.proxyUrl,
            domain: this.domain
          });
          await c.load(this.options);
        } else {
          c = this.Clerk;
          if (!c.loaded) {
            await c.load(this.options);
          }
        }
        globalThis.Clerk = c;
      } else if (!__BUILD_DISABLE_RHC__) {
        if (!globalThis.Clerk) {
          await loadClerkJsScript({
            ...this.options,
            publishableKey: this.#publishableKey,
            proxyUrl: this.proxyUrl,
            domain: this.domain,
            nonce: this.options.nonce
          });
        }
        if (!globalThis.Clerk) {
          throw new Error(
            "Failed to download latest ClerkJS. Contact support@clerk.com."
          );
        }
        await globalThis.Clerk.load(this.options);
      }
      if (globalThis.Clerk?.loaded) {
        return this.hydrateClerkJS(globalThis.Clerk);
      }
      return;
    } catch (err) {
      const error = err;
      if (true) {
      } else {
        throw err;
      }
      return;
    }
  }
  addOnLoaded = (cb) => {
    this.loadedListeners.push(cb);
    if (this.loaded) {
      this.emitLoaded();
    }
  };
  emitLoaded = () => {
    this.loadedListeners.forEach((cb) => cb());
    this.loadedListeners = [];
  };
  hydrateClerkJS = (clerkjs) => {
    if (!clerkjs) {
      throw new Error("Failed to hydrate latest Clerk JS");
    }
    this.clerkjs = clerkjs;
    this.premountMethodCalls.forEach((cb) => cb());
    this.premountAddListenerCalls.forEach((listenerHandlers, listener) => {
      listenerHandlers.nativeUnsubscribe = clerkjs.addListener(listener);
    });
    if (this.preopenSignIn !== null) {
      clerkjs.openSignIn(this.preopenSignIn);
    }
    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);
    }
    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.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.#loaded = true;
    this.emitLoaded();
    return this.clerkjs;
  };
  get version() {
    return this.clerkjs?.version;
  }
  get client() {
    if (this.clerkjs) {
      return this.clerkjs.client;
    } else {
      return void 0;
    }
  }
  get session() {
    if (this.clerkjs) {
      return this.clerkjs.session;
    } else {
      return void 0;
    }
  }
  get user() {
    if (this.clerkjs) {
      return this.clerkjs.user;
    } else {
      return void 0;
    }
  }
  get organization() {
    if (this.clerkjs) {
      return this.clerkjs.organization;
    } else {
      return void 0;
    }
  }
  get telemetry() {
    if (this.clerkjs) {
      return this.clerkjs.telemetry;
    } else {
      return void 0;
    }
  }
  get __unstable__environment() {
    if (this.clerkjs) {
      return this.clerkjs.__unstable__environment;
    } else {
      return void 0;
    }
  }
  __unstable__setEnvironment(...args) {
    if (this.clerkjs && "__unstable__setEnvironment" in this.clerkjs) {
      this.clerkjs.__unstable__setEnvironment(args);
    } else {
      return void 0;
    }
  }
  __unstable__updateProps = async (props) => {
    const clerkjs = await this.#waitForClerkJS();
    if (clerkjs && "__unstable__updateProps" in clerkjs) {
      return clerkjs.__unstable__updateProps(props);
    }
  };
  /**
   * `setActive` can be used to set the active session and/or organization.
   */
  setActive = ({
    session,
    organization,
    beforeEmit,
    redirectUrl
  }) => {
    if (this.clerkjs) {
      return this.clerkjs.setActive({
        session,
        organization,
        beforeEmit,
        redirectUrl
      });
    } else {
      return Promise.reject();
    }
  };
  openSignIn = (props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.openSignIn(props);
    } else {
      this.preopenSignIn = props;
    }
  };
  closeSignIn = () => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.closeSignIn();
    } else {
      this.preopenSignIn = null;
    }
  };
  __internal_openReverification = (props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.__internal_openReverification(props);
    } else {
      this.preopenUserVerification = props;
    }
  };
  __internal_closeReverification = () => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.__internal_closeReverification();
    } else {
      this.preopenUserVerification = null;
    }
  };
  openGoogleOneTap = (props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.openGoogleOneTap(props);
    } else {
      this.preopenOneTap = props;
    }
  };
  closeGoogleOneTap = () => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.closeGoogleOneTap();
    } else {
      this.preopenOneTap = null;
    }
  };
  openUserProfile = (props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.openUserProfile(props);
    } else {
      this.preopenUserProfile = props;
    }
  };
  closeUserProfile = () => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.closeUserProfile();
    } else {
      this.preopenUserProfile = null;
    }
  };
  openOrganizationProfile = (props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.openOrganizationProfile(props);
    } else {
      this.preopenOrganizationProfile = props;
    }
  };
  closeOrganizationProfile = () => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.closeOrganizationProfile();
    } else {
      this.preopenOrganizationProfile = null;
    }
  };
  openCreateOrganization = (props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.openCreateOrganization(props);
    } else {
      this.preopenCreateOrganization = props;
    }
  };
  closeCreateOrganization = () => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.closeCreateOrganization();
    } else {
      this.preopenCreateOrganization = null;
    }
  };
  openWaitlist = (props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.openWaitlist(props);
    } else {
      this.preOpenWaitlist = props;
    }
  };
  closeWaitlist = () => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.closeWaitlist();
    } else {
      this.preOpenWaitlist = null;
    }
  };
  openSignUp = (props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.openSignUp(props);
    } else {
      this.preopenSignUp = props;
    }
  };
  closeSignUp = () => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.closeSignUp();
    } else {
      this.preopenSignUp = null;
    }
  };
  mountSignIn = (node, props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.mountSignIn(node, props);
    } else {
      this.premountSignInNodes.set(node, props);
    }
  };
  unmountSignIn = (node) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.unmountSignIn(node);
    } else {
      this.premountSignInNodes.delete(node);
    }
  };
  mountSignUp = (node, props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.mountSignUp(node, props);
    } else {
      this.premountSignUpNodes.set(node, props);
    }
  };
  unmountSignUp = (node) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.unmountSignUp(node);
    } else {
      this.premountSignUpNodes.delete(node);
    }
  };
  mountUserProfile = (node, props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.mountUserProfile(node, props);
    } else {
      this.premountUserProfileNodes.set(node, props);
    }
  };
  unmountUserProfile = (node) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.unmountUserProfile(node);
    } else {
      this.premountUserProfileNodes.delete(node);
    }
  };
  mountOrganizationProfile = (node, props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.mountOrganizationProfile(node, props);
    } else {
      this.premountOrganizationProfileNodes.set(node, props);
    }
  };
  unmountOrganizationProfile = (node) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.unmountOrganizationProfile(node);
    } else {
      this.premountOrganizationProfileNodes.delete(node);
    }
  };
  mountCreateOrganization = (node, props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.mountCreateOrganization(node, props);
    } else {
      this.premountCreateOrganizationNodes.set(node, props);
    }
  };
  unmountCreateOrganization = (node) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.unmountCreateOrganization(node);
    } else {
      this.premountCreateOrganizationNodes.delete(node);
    }
  };
  mountOrganizationSwitcher = (node, props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.mountOrganizationSwitcher(node, props);
    } else {
      this.premountOrganizationSwitcherNodes.set(node, props);
    }
  };
  unmountOrganizationSwitcher = (node) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.unmountOrganizationSwitcher(node);
    } else {
      this.premountOrganizationSwitcherNodes.delete(node);
    }
  };
  __experimental_prefetchOrganizationSwitcher = () => {
    const callback = () => this.clerkjs?.__experimental_prefetchOrganizationSwitcher();
    if (this.clerkjs && this.#loaded) {
      void callback();
    } else {
      this.premountMethodCalls.set(
        "__experimental_prefetchOrganizationSwitcher",
        callback
      );
    }
  };
  mountOrganizationList = (node, props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.mountOrganizationList(node, props);
    } else {
      this.premountOrganizationListNodes.set(node, props);
    }
  };
  unmountOrganizationList = (node) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.unmountOrganizationList(node);
    } else {
      this.premountOrganizationListNodes.delete(node);
    }
  };
  mountUserButton = (node, userButtonProps) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.mountUserButton(node, userButtonProps);
    } else {
      this.premountUserButtonNodes.set(node, userButtonProps);
    }
  };
  unmountUserButton = (node) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.unmountUserButton(node);
    } else {
      this.premountUserButtonNodes.delete(node);
    }
  };
  mountWaitlist = (node, props) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.mountWaitlist(node, props);
    } else {
      this.premountWaitlistNodes.set(node, props);
    }
  };
  unmountWaitlist = (node) => {
    if (this.clerkjs && this.#loaded) {
      this.clerkjs.unmountWaitlist(node);
    } else {
      this.premountWaitlistNodes.delete(node);
    }
  };
  addListener = (listener) => {
    if (this.clerkjs) {
      return this.clerkjs.addListener(listener);
    } else {
      const unsubscribe = () => {
        const listenerHandlers = this.premountAddListenerCalls.get(listener);
        if (listenerHandlers) {
          listenerHandlers.nativeUnsubscribe?.();
          this.premountAddListenerCalls.delete(listener);
        }
      };
      this.premountAddListenerCalls.set(listener, {
        unsubscribe,
        nativeUnsubscribe: void 0
      });
      return unsubscribe;
    }
  };
  navigate = (to) => {
    const callback = () => this.clerkjs?.navigate(to);
    if (this.clerkjs && this.#loaded) {
      void callback();
    } else {
      this.premountMethodCalls.set("navigate", callback);
    }
  };
  redirectWithAuth = async (...args) => {
    const callback = () => this.clerkjs?.redirectWithAuth(...args);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("redirectWithAuth", callback);
      return;
    }
  };
  redirectToSignIn = async (opts) => {
    const callback = () => this.clerkjs?.redirectToSignIn(opts);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("redirectToSignIn", callback);
      return;
    }
  };
  redirectToSignUp = async (opts) => {
    const callback = () => this.clerkjs?.redirectToSignUp(opts);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("redirectToSignUp", callback);
      return;
    }
  };
  redirectToUserProfile = async () => {
    const callback = () => this.clerkjs?.redirectToUserProfile();
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("redirectToUserProfile", callback);
      return;
    }
  };
  redirectToAfterSignUp = () => {
    const callback = () => this.clerkjs?.redirectToAfterSignUp();
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("redirectToAfterSignUp", callback);
    }
  };
  redirectToAfterSignIn = () => {
    const callback = () => this.clerkjs?.redirectToAfterSignIn();
    if (this.clerkjs && this.#loaded) {
      callback();
    } else {
      this.premountMethodCalls.set("redirectToAfterSignIn", callback);
    }
  };
  redirectToAfterSignOut = () => {
    const callback = () => this.clerkjs?.redirectToAfterSignOut();
    if (this.clerkjs && this.#loaded) {
      callback();
    } else {
      this.premountMethodCalls.set("redirectToAfterSignOut", callback);
    }
  };
  redirectToOrganizationProfile = async () => {
    const callback = () => this.clerkjs?.redirectToOrganizationProfile();
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("redirectToOrganizationProfile", callback);
      return;
    }
  };
  redirectToCreateOrganization = async () => {
    const callback = () => this.clerkjs?.redirectToCreateOrganization();
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("redirectToCreateOrganization", callback);
      return;
    }
  };
  redirectToWaitlist = async () => {
    const callback = () => this.clerkjs?.redirectToWaitlist();
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("redirectToWaitlist", callback);
      return;
    }
  };
  handleRedirectCallback = (params) => {
    const callback = () => this.clerkjs?.handleRedirectCallback(params);
    if (this.clerkjs && this.#loaded) {
      void callback()?.catch(() => {
      });
    } else {
      this.premountMethodCalls.set("handleRedirectCallback", callback);
    }
  };
  handleGoogleOneTapCallback = (signInOrUp, params) => {
    const callback = () => this.clerkjs?.handleGoogleOneTapCallback(signInOrUp, params);
    if (this.clerkjs && this.#loaded) {
      void callback()?.catch(() => {
      });
    } else {
      this.premountMethodCalls.set("handleGoogleOneTapCallback", callback);
    }
  };
  handleEmailLinkVerification = async (params) => {
    const callback = () => this.clerkjs?.handleEmailLinkVerification(params);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("handleEmailLinkVerification", callback);
    }
  };
  authenticateWithMetamask = async (params) => {
    const callback = () => this.clerkjs?.authenticateWithMetamask(params);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("authenticateWithMetamask", callback);
    }
  };
  authenticateWithCoinbaseWallet = async (params) => {
    const callback = () => this.clerkjs?.authenticateWithCoinbaseWallet(params);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("authenticateWithCoinbaseWallet", callback);
    }
  };
  authenticateWithOKXWallet = async (params) => {
    const callback = () => this.clerkjs?.authenticateWithOKXWallet(params);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("authenticateWithOKXWallet", callback);
    }
  };
  authenticateWithWeb3 = async (params) => {
    const callback = () => this.clerkjs?.authenticateWithWeb3(params);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("authenticateWithWeb3", callback);
    }
  };
  authenticateWithGoogleOneTap = async (params) => {
    const clerkjs = await this.#waitForClerkJS();
    return clerkjs.authenticateWithGoogleOneTap(params);
  };
  createOrganization = async (params) => {
    const callback = () => this.clerkjs?.createOrganization(params);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("createOrganization", callback);
    }
  };
  getOrganization = async (organizationId) => {
    const callback = () => this.clerkjs?.getOrganization(organizationId);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("getOrganization", callback);
    }
  };
  joinWaitlist = async (params) => {
    const callback = () => this.clerkjs?.joinWaitlist(params);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("joinWaitlist", callback);
    }
  };
  signOut = async (signOutCallbackOrOptions, options) => {
    const callback = () => this.clerkjs?.signOut(signOutCallbackOrOptions, options);
    if (this.clerkjs && this.#loaded) {
      return callback();
    } else {
      this.premountMethodCalls.set("signOut", callback);
    }
  };
};

// src/contexts/auth.tsx
var [AuthContextProvider, useAuthContext] = createContextProviderAndHook(
  "AuthContext",
  (props) => {
    return {
      userId: props.userId,
      sessionId: props.sessionId,
      actor: props.actor,
      orgId: props.orgId,
      orgRole: props.orgRole,
      orgSlug: props.orgSlug,
      orgPermissions: props.orgPermissions
    };
  }
);

// src/contexts/client.tsx
var [ClientContextProvider, useClientContext] = createContextProviderAndHook(
  "ClientProvider",
  (props) => {
    return props.client;
  }
);

// src/contexts/clerk-instance.tsx
import { createContext, useContext } from "solid-js";
var ClerkInstanceContext = createContext();
var ClerkInstanceContextProvider = (props) => {
  return <ClerkInstanceContext.Provider value={props.clerk}>
      {props.children}
    </ClerkInstanceContext.Provider>;
};
function useClerkInstanceContext() {
  const ctx = useContext(ClerkInstanceContext);
  if (!ctx) {
    throw new Error(
      `ClerkInstanceProvider can only be used within the <ClerkProvider /> component. Learn more: https://clerk.com/docs/components/clerk-provider`
    );
  }
  return ctx;
}

// src/contexts/isomorphic-clerk.tsx
var IsomorphicClerkContextProvider = ClerkInstanceContextProvider;
var useIsomorphicClerkContext = useClerkInstanceContext;

// src/contexts/organization.tsx
var [OrganizationContextProvider, useOrganizationContext] = createContextProviderAndHook(
  "OrganizationProvider",
  (props) => {
    return props.organization;
  }
);

// src/contexts/session.tsx
var [SessionContextProvider, useSessionContext] = createContextProviderAndHook(
  "SessionProvider",
  (props) => {
    return props.session;
  }
);

// src/contexts/user.tsx
var [UserContextProvider, useUserContext] = createContextProviderAndHook(
  "UserProvider",
  (props) => {
    return props.user;
  }
);

// src/contexts/clerk-context.tsx
function ClerkContextProvider(props) {
  const { isomorphicClerk: clerk, loaded: clerkLoaded } = useLoadedIsomorphicClerk(() => props.isomorphicClerkOptions);
  const [state, setState] = createSignal({
    client: clerk().client,
    session: clerk().session,
    user: clerk().user,
    organization: clerk().organization
  });
  createEffect2(() => {
    const fn = clerk().addListener((e) => setState({ ...e }));
    onCleanup2(fn);
  });
  const derivedState = createMemo(
    () => deriveState(clerkLoaded(), state(), props.initialState)
  );
  const clerkCtx = () => clerkLoaded() ? clerk() : clerk();
  return <IsomorphicClerkContextProvider
    clerk={clerkCtx}
  >
      <ClientContextProvider client={() => state().client}>
        <SessionContextProvider session={() => derivedState().session}>
          <OrganizationContextProvider
    organization={() => derivedState().organization}
  >
            <AuthContextProvider
    userId={() => derivedState().userId}
    sessionId={() => derivedState().sessionId}
    actor={() => derivedState().actor}
    orgId={() => derivedState().orgId}
    orgRole={() => derivedState().orgRole}
    orgSlug={() => derivedState().orgSlug}
    orgPermissions={() => derivedState().orgPermissions}
  >
              <UserContextProvider user={() => derivedState().user}>
                {props.children}
              </UserContextProvider>
            </AuthContextProvider>
          </OrganizationContextProvider>
        </SessionContextProvider>
      </ClientContextProvider>
    </IsomorphicClerkContextProvider>;
}
var useLoadedIsomorphicClerk = (options) => {
  const [loaded, setLoaded] = createSignal(false);
  const isomorphicClerk = createMemo(
    () => IsomorphicClerk.getOrCreateInstance(untrack(options))
  );
  createEffect2(
    on(
      () => options().appearance,
      (appearance) => {
        void isomorphicClerk().__unstable__updateProps({
          appearance
        });
      }
    )
  );
  createEffect2(
    on(
      () => options().localization,
      (localization) => {
        void isomorphicClerk().__unstable__updateProps({
          options: {
            localization
          }
        });
      }
    )
  );
  createEffect2(() => {
    isomorphicClerk().addOnLoaded(() => {
      setLoaded(true);
    });
  });
  onCleanup2(() => {
    IsomorphicClerk.clearInstance();
  });
  return { isomorphicClerk, loaded };
};

// src/contexts/clerk.tsx
function ClerkProviderBase(props) {
  const [local, restIsomorphicClerkOptions] = splitProps(props, [
    "initialState",
    "children"
  ]);
  createEffect3(() => {
    if (!restIsomorphicClerkOptions.Clerk) {
      if (!restIsomorphicClerkOptions.publishableKey) {
        errorThrower.throwMissingPublishableKeyError();
      } else if (restIsomorphicClerkOptions.publishableKey && !isPublishableKey(restIsomorphicClerkOptions.publishableKey)) {
        errorThrower.throwInvalidPublishableKeyError({
          key: restIsomorphicClerkOptions.publishableKey
        });
      }
    }
  });
  return <ClerkContextProvider
    initialState={local.initialState}
    isomorphicClerkOptions={restIsomorphicClerkOptions}
  >
      {local.children}
    </ClerkContextProvider>;
}
var ClerkProvider = withMaxAllowedInstancesGuard(
  ClerkProviderBase,
  "ClerkProvider",
  multipleClerkProvidersError
);

export {
  errorThrower,
  setErrorThrowerOptions,
  useAuthContext,
  ClerkInstanceContext,
  useClerkInstanceContext,
  useIsomorphicClerkContext,
  userProfilePageRenderedError,
  userProfileLinkRenderedError,
  organizationProfilePageRenderedError,
  organizationProfileLinkRenderedError,
  useAuthHasRequiresRoleOrPermission,
  assertSingleChild,
  normalizeWithDefaultValue,
  safeExecute,
  useClientContext,
  useOrganizationContext,
  useSessionContext,
  useUserContext,
  ClerkProvider
};