@rebasepro/client-firebase 0.0.1-canary.4d4fb3e

package/dist/index.umd.js

@@ -0,0 +1,2743 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("react"), require("fast-equals"), require("@firebase/auth"), require("@firebase/storage"), require("@firebase/app"), require("@firebase/app-check"), require("@rebasepro/types"), require("@firebase/firestore"), require("@rebasepro/common"), require("fuse.js"), require("@firebase/functions"), require("react-compiler-runtime"), require("@firebase/database"), require("react/jsx-runtime"), require("@rebasepro/core"), require("@rebasepro/cms"), require("@rebasepro/ui"), require("react-router-dom")) : typeof define === "function" && define.amd ? define(["exports", "react", "fast-equals", "@firebase/auth", "@firebase/storage", "@firebase/app", "@firebase/app-check", "@rebasepro/types", "@firebase/firestore", "@rebasepro/common", "fuse.js", "@firebase/functions", "react-compiler-runtime", "@firebase/database", "react/jsx-runtime", "@rebasepro/core", "@rebasepro/cms", "@rebasepro/ui", "react-router-dom"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase Firebase"] = {}, global.React, global.fastEquals, global.auth, global.storage, global.app, global.appCheck, global.types, global.firestore, global.common, global.Fuse, global.functions, global.reactCompilerRuntime, global.database, global.jsxRuntime, global.core, global.cms, global.ui, global.reactRouterDom));
+})(this, (function(exports2, React, fastEquals, auth, storage, app, appCheck, types, firestore, common, Fuse, functions, reactCompilerRuntime, database, jsxRuntime, core, cms, ui, reactRouterDom) {
+  "use strict";
+  const useFirebaseAuthController = ({
+    loading,
+    firebaseApp,
+    signInOptions,
+    onSignOut: onSignOutProp,
+    defineRolesFor
+  }) => {
+    const [loggedUser, setLoggedUser] = React.useState(void 0);
+    const [authError, setAuthError] = React.useState();
+    const [authProviderError, setAuthProviderError] = React.useState();
+    const [initialLoading, setInitialLoading] = React.useState(true);
+    const [authLoading, setAuthLoading] = React.useState(true);
+    const [loginSkipped, setLoginSkipped] = React.useState(false);
+    const [confirmationResult, setConfirmationResult] = React.useState();
+    const [userRoles, _setUserRoles] = React.useState();
+    const [extra, setExtra] = React.useState();
+    const setUserRoles = React.useCallback((roles) => {
+      const currentRoleIds = userRoles?.map((r) => r.id);
+      const newRoleIds = roles?.map((r_0) => r_0.id);
+      if (!fastEquals.deepEqual(currentRoleIds, newRoleIds)) {
+        _setUserRoles(roles);
+      }
+    }, [userRoles]);
+    const authRef = React.useRef(null);
+    const updateUser = React.useCallback(async (user, initialize) => {
+      if (loading) return;
+      if (defineRolesFor && user) {
+        setUserRoles(await defineRolesFor(user));
+      }
+      setLoggedUser(user);
+      setAuthLoading(false);
+      if (initialize) {
+        setInitialLoading(false);
+      }
+    }, [loading]);
+    const updateRoles = React.useCallback(async (user_0) => {
+      if (defineRolesFor && user_0) {
+        const userRoles_0 = await defineRolesFor(user_0);
+        if (!fastEquals.deepEqual(userRoles_0, userRoles_0)) {
+          setUserRoles(userRoles_0);
+        }
+      }
+    }, [defineRolesFor, userRoles]);
+    React.useEffect(() => {
+      if (updateRoles && loggedUser) {
+        updateRoles(loggedUser);
+      }
+    }, [updateRoles, loggedUser]);
+    React.useEffect(() => {
+      if (!firebaseApp) return;
+      try {
+        const auth$1 = auth.getAuth(firebaseApp);
+        authRef.current = auth$1;
+        setAuthError(void 0);
+        updateUser(auth$1.currentUser, false);
+        return auth.onAuthStateChanged(auth$1, async (user_1) => {
+          console.debug("User state changed", user_1);
+          await updateUser(user_1, true);
+        }, (error) => setAuthProviderError(error));
+      } catch (e) {
+        setAuthError(e);
+        setInitialLoading(false);
+        return () => {
+        };
+      }
+    }, [firebaseApp, updateUser]);
+    React.useEffect(() => {
+      if (!loading && authRef.current) {
+        updateUser(authRef.current.currentUser, false);
+      }
+    }, [loading, updateUser]);
+    const getProviderOptions = React.useCallback((providerId) => {
+      return signInOptions?.find((option) => {
+        if (option === null) throw Error("useFirebaseAuthController");
+        if (typeof option === "object" && option.provider === providerId) return option;
+        return void 0;
+      });
+    }, []);
+    const googleLogin = React.useCallback(() => {
+      const provider = new auth.GoogleAuthProvider();
+      const options = getProviderOptions("google.com");
+      if (options?.scopes) options.scopes.forEach((scope) => provider.addScope(scope));
+      if (options?.customParameters) {
+        provider.setCustomParameters(options.customParameters);
+      } else {
+        provider.setCustomParameters({
+          prompt: "select_account"
+        });
+      }
+      const auth_0 = authRef.current;
+      if (!auth_0) throw Error("No auth");
+      auth.signInWithPopup(auth_0, provider).catch(setAuthProviderError);
+    }, [getProviderOptions]);
+    const getAuthToken = React.useCallback(async () => {
+      if (!loggedUser) throw Error("No client user is logged in");
+      if (!loggedUser.getIdToken) {
+        throw Error("No getIdToken method available");
+      }
+      return loggedUser.getIdToken?.();
+    }, [loggedUser]);
+    const emailPasswordLogin = React.useCallback((email, password) => {
+      const auth_1 = authRef.current;
+      if (!auth_1) throw Error("No auth");
+      setAuthLoading(true);
+      auth.signInWithEmailAndPassword(auth_1, email, password).catch(setAuthProviderError).then(() => setAuthLoading(false));
+    }, []);
+    const createUserWithEmailAndPassword = React.useCallback((email_0, password_0) => {
+      const auth_2 = authRef.current;
+      if (!auth_2) throw Error("No auth");
+      setAuthLoading(true);
+      auth.createUserWithEmailAndPassword(auth_2, email_0, password_0).catch(setAuthProviderError).then(() => setAuthLoading(false));
+    }, []);
+    const sendPasswordResetEmail = React.useCallback((email_1) => {
+      const auth_3 = authRef.current;
+      if (!auth_3) throw Error("No auth");
+      return auth.sendPasswordResetEmail(auth_3, email_1);
+    }, []);
+    const fetchSignInMethodsForEmail = React.useCallback((email_2) => {
+      const auth_4 = authRef.current;
+      if (!auth_4) throw Error("No auth");
+      setAuthLoading(true);
+      return auth.fetchSignInMethodsForEmail(auth_4, email_2).then((res) => {
+        setAuthLoading(false);
+        return res;
+      });
+    }, []);
+    const onSignOut = React.useCallback(async () => {
+      const auth_5 = authRef.current;
+      if (!auth_5) throw Error("No auth");
+      await auth.signOut(auth_5).then((_) => {
+        setLoggedUser(null);
+        setUserRoles(void 0);
+        setAuthProviderError(null);
+        onSignOutProp?.();
+      });
+      setLoginSkipped(false);
+    }, [onSignOutProp]);
+    const doOauthLogin = React.useCallback((auth_6, provider_0) => {
+      setAuthLoading(true);
+      auth.signInWithPopup(auth_6, provider_0).catch(setAuthProviderError).then(() => setAuthLoading(false));
+    }, []);
+    const anonymousLogin = React.useCallback(() => {
+      const auth_7 = authRef.current;
+      if (!auth_7) throw Error("No auth");
+      setAuthLoading(true);
+      auth.signInAnonymously(auth_7).catch(setAuthProviderError).then(() => setAuthLoading(false));
+    }, []);
+    const phoneLogin = React.useCallback((phone, applicationVerifier) => {
+      const auth_8 = authRef.current;
+      if (!auth_8) throw Error("No auth");
+      setAuthLoading(true);
+      return auth.signInWithPhoneNumber(auth_8, phone, applicationVerifier).catch(setAuthProviderError).then((res_0) => {
+        setAuthLoading(false);
+        setConfirmationResult(res_0 ?? void 0);
+      });
+    }, []);
+    const appleLogin = React.useCallback(() => {
+      const provider_1 = new auth.OAuthProvider("apple.com");
+      const options_0 = getProviderOptions("apple.com");
+      if (options_0?.scopes) options_0.scopes.forEach((scope_0) => provider_1.addScope(scope_0));
+      if (options_0?.customParameters) provider_1.setCustomParameters(options_0.customParameters);
+      const auth_9 = authRef.current;
+      if (!auth_9) throw Error("No auth");
+      doOauthLogin(auth_9, provider_1);
+    }, [doOauthLogin, getProviderOptions]);
+    const facebookLogin = React.useCallback(() => {
+      const provider_2 = new auth.FacebookAuthProvider();
+      const options_1 = getProviderOptions("facebook.com");
+      if (options_1?.scopes) options_1.scopes.forEach((scope_1) => provider_2.addScope(scope_1));
+      if (options_1?.customParameters) provider_2.setCustomParameters(options_1.customParameters);
+      const auth_10 = authRef.current;
+      if (!auth_10) throw Error("No auth");
+      doOauthLogin(auth_10, provider_2);
+    }, [doOauthLogin, getProviderOptions]);
+    const githubLogin = React.useCallback(() => {
+      const provider_3 = new auth.GithubAuthProvider();
+      const options_2 = getProviderOptions("github.com");
+      if (options_2?.scopes) options_2.scopes.forEach((scope_2) => provider_3.addScope(scope_2));
+      if (options_2?.customParameters) provider_3.setCustomParameters(options_2.customParameters);
+      const auth_11 = authRef.current;
+      if (!auth_11) throw Error("No auth");
+      doOauthLogin(auth_11, provider_3);
+    }, [doOauthLogin, getProviderOptions]);
+    const microsoftLogin = React.useCallback(() => {
+      const provider_4 = new auth.OAuthProvider("microsoft.com");
+      const options_3 = getProviderOptions("microsoft.com");
+      if (options_3?.scopes) options_3.scopes.forEach((scope_3) => provider_4.addScope(scope_3));
+      if (options_3?.customParameters) provider_4.setCustomParameters(options_3.customParameters);
+      const auth_12 = authRef.current;
+      if (!auth_12) throw Error("No auth");
+      doOauthLogin(auth_12, provider_4);
+    }, [doOauthLogin, getProviderOptions]);
+    const twitterLogin = React.useCallback(() => {
+      const provider_5 = new auth.TwitterAuthProvider();
+      const options_4 = getProviderOptions("twitter.com");
+      if (options_4?.customParameters) provider_5.setCustomParameters(options_4.customParameters);
+      const auth_13 = authRef.current;
+      if (!auth_13) throw Error("No auth");
+      doOauthLogin(auth_13, provider_5);
+    }, [doOauthLogin, getProviderOptions]);
+    const skipLogin = React.useCallback(() => {
+      setLoginSkipped(true);
+      setLoggedUser(null);
+      setUserRoles(void 0);
+    }, []);
+    const firebaseUserWrapper = loggedUser ? {
+      ...loggedUser,
+      roles: userRoles?.map((r_1) => r_1.id),
+      // User.roles is string[], keep Role[] internally only
+      firebaseUser: loggedUser
+    } : null;
+    return {
+      user: firebaseUserWrapper,
+      setUser: updateUser,
+      setUserRoles,
+      authProviderError,
+      authLoading,
+      initialLoading: loading || initialLoading,
+      signOut: onSignOut,
+      getAuthToken,
+      googleLogin,
+      skipLogin,
+      loginSkipped,
+      emailPasswordLogin,
+      createUserWithEmailAndPassword,
+      sendPasswordResetEmail,
+      fetchSignInMethodsForEmail,
+      anonymousLogin,
+      phoneLogin,
+      appleLogin,
+      facebookLogin,
+      githubLogin,
+      microsoftLogin,
+      twitterLogin,
+      confirmationResult,
+      extra,
+      setExtra
+    };
+  };
+  function useFirebaseStorageSource({
+    firebaseApp,
+    bucketUrl
+  }) {
+    const projectId = firebaseApp?.options?.projectId;
+    const urlsCache = {};
+    return {
+      uploadFile({
+        file,
+        fileName,
+        path,
+        metadata,
+        bucket
+      }) {
+        try {
+          if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
+          const storageBucketUrl = bucket ?? bucketUrl;
+          const storage$1 = storage.getStorage(firebaseApp, storageBucketUrl);
+          if (!storage$1) throw Error("useFirebaseStorageSource Firebase not initialised");
+          const usedFilename = fileName ?? file.name;
+          const storageRef = storage.ref(storage$1, `${path}/${usedFilename}`);
+          const uploadTask = storage.uploadBytesResumable(storageRef, file, metadata);
+          return new Promise((resolve, reject) => {
+            let lastProgress = 0;
+            let timeoutId = null;
+            const clearTimeoutIfExists = () => {
+              if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+              }
+            };
+            const setProgressTimeout = () => {
+              clearTimeoutIfExists();
+              timeoutId = setTimeout(() => {
+                uploadTask.cancel();
+                reject(new Error(`Upload failed - This is likely a CORS configuration issue. Make sure Firebase Storage is enabled in your project: https://console.firebase.google.com/u/0/project/${projectId}/storage. If it is, check Firebase Storage CORS settings.`));
+              }, 5e3);
+            };
+            setProgressTimeout();
+            uploadTask.on("state_changed", (snapshot) => {
+              const progress = snapshot.bytesTransferred / snapshot.totalBytes * 100;
+              if (progress > lastProgress) {
+                lastProgress = progress;
+                setProgressTimeout();
+              }
+            }, (error) => {
+              clearTimeoutIfExists();
+              console.error("Firebase Storage upload error:", error);
+              let errorMessage = "Unknown upload error";
+              if (error?.message) {
+                errorMessage = error.message;
+              } else if (typeof error === "string") {
+                errorMessage = error;
+              } else if (error?.code) {
+                errorMessage = error.code;
+              }
+              if (error?.code === "storage/unauthorized") {
+                reject(new Error("Unauthorized: Check Firebase Storage security rules"));
+              } else if (error?.code === "storage/canceled") {
+                reject(new Error("Upload canceled"));
+              } else if (error?.code === "storage/unknown" || !error?.code) {
+                reject(new Error("Upload failed - Check Firebase Storage CORS configuration or network connection"));
+              } else if (errorMessage.toLowerCase().includes("network")) {
+                reject(new Error("Network error: Check your internet connection"));
+              } else {
+                const newError = Object.assign(new Error(errorMessage), {
+                  code: error?.code
+                });
+                reject(newError);
+              }
+            }, () => {
+              clearTimeoutIfExists();
+              const fullPath = uploadTask.snapshot.ref.fullPath;
+              const bucketName = uploadTask.snapshot.ref.bucket;
+              resolve({
+                path: fullPath,
+                bucket: bucketName,
+                storageUrl: `gs://${bucketName}/${fullPath}`
+              });
+            });
+          });
+        } catch (error) {
+          return Promise.reject(error);
+        }
+      },
+      async getFile(path, bucket) {
+        try {
+          if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
+          const storageBucketUrl = bucket ?? bucketUrl;
+          const storage$1 = storage.getStorage(firebaseApp, storageBucketUrl);
+          if (!storage$1) throw Error("useFirebaseStorageSource Firebase not initialised");
+          const fileRef = storage.ref(storage$1, path);
+          const url = await storage.getDownloadURL(fileRef);
+          const response = await fetch(url);
+          const blob = await response.blob();
+          return new File([blob], path);
+        } catch (e) {
+          if (e?.code === "storage/object-not-found") return null;
+          throw e;
+        }
+      },
+      async getDownloadURL(storagePathOrUrl, bucket) {
+        if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
+        let resolvedPathOrUrl = storagePathOrUrl;
+        let resolvedBucket = bucket;
+        if (storagePathOrUrl.startsWith("gs://")) {
+          const withoutProtocol = storagePathOrUrl.substring("gs://".length);
+          const firstSlash = withoutProtocol.indexOf("/");
+          if (firstSlash > 0) {
+            resolvedBucket = withoutProtocol.substring(0, firstSlash);
+            resolvedPathOrUrl = withoutProtocol.substring(firstSlash + 1);
+          }
+        }
+        const storageBucketUrl = resolvedBucket ?? bucketUrl;
+        const storage$1 = storage.getStorage(firebaseApp, storageBucketUrl);
+        if (!storage$1) throw Error("useFirebaseStorageSource Firebase not initialised");
+        if (urlsCache[storagePathOrUrl]) return urlsCache[storagePathOrUrl];
+        try {
+          const fileRef = storage.ref(storage$1, resolvedPathOrUrl);
+          const [url, metadata] = await Promise.all([storage.getDownloadURL(fileRef), storage.getMetadata(fileRef)]);
+          const result = {
+            url,
+            metadata
+          };
+          urlsCache[storagePathOrUrl] = result;
+          return result;
+        } catch (e) {
+          if (e?.code === "storage/object-not-found") return {
+            url: null,
+            fileNotFound: true
+          };
+          throw e;
+        }
+      },
+      async list(path, options) {
+        if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
+        const storageBucketUrl = options?.bucket ?? bucketUrl;
+        const storage$1 = storage.getStorage(firebaseApp, storageBucketUrl);
+        if (!storage$1) throw Error("useFirebaseStorageSource Firebase not initialised");
+        const folderRef = storage.ref(storage$1, path);
+        return await storage.list(folderRef, {
+          maxResults: options?.maxResults,
+          pageToken: options?.pageToken
+        });
+      },
+      async deleteFile(path, bucket) {
+        if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
+        const storageBucketUrl = bucket ?? bucketUrl;
+        const storage$1 = storage.getStorage(firebaseApp, storageBucketUrl);
+        if (!storage$1) throw Error("useFirebaseStorageSource Firebase not initialised");
+        const fileRef = storage.ref(storage$1, path);
+        return storage.deleteObject(fileRef);
+      }
+    };
+  }
+  const hostingError = "It seems like the provided Firebase config is not correct. If you \nare using the credentials provided automatically by Firebase \nHosting, make sure you link your Firebase app to Firebase Hosting. \n";
+  function useInitialiseFirebase({
+    firebaseConfig,
+    fromUrl,
+    onFirebaseInit,
+    name,
+    authDomain
+  }) {
+    const [firebaseApp, setFirebaseApp] = React.useState();
+    const [firebaseConfigLoading, setFirebaseConfigLoading] = React.useState(false);
+    const [configError, setConfigError] = React.useState();
+    const initFirebase = React.useCallback((config) => {
+      if (config.projectId === firebaseApp?.options.projectId) {
+        console.debug("Firebase app already initialised with the same project ID. This should happen only in development mode.");
+        setConfigError(void 0);
+        setFirebaseConfigLoading(false);
+        return;
+      }
+      try {
+        const targetName = name ?? "[DEFAULT]";
+        const currentApps = app.getApps();
+        const existingApp = currentApps.find((app2) => app2.name === targetName);
+        if (existingApp) {
+          app.deleteApp(existingApp);
+        }
+        const initialisedFirebaseApp = app.initializeApp(config, targetName);
+        setConfigError(void 0);
+        setFirebaseConfigLoading(false);
+        setFirebaseApp(initialisedFirebaseApp);
+      } catch (e) {
+        console.error("Error initialising Firebase", e);
+        setConfigError(hostingError + "\n" + (e.message ?? JSON.stringify(e)));
+      }
+    }, [name]);
+    React.useEffect(() => {
+      if (onFirebaseInit && firebaseConfig && firebaseApp) {
+        onFirebaseInit(firebaseConfig, firebaseApp);
+      }
+    }, [firebaseApp]);
+    React.useEffect(() => {
+      setFirebaseConfigLoading(true);
+      function fetchFromUrl(url) {
+        fetch(url).then(async (response) => {
+          console.debug("Firebase init response", response.status);
+          if (response && response.status < 300) {
+            const config_0 = await response.json();
+            if (authDomain) config_0.authDomain = authDomain;
+            initFirebase(config_0);
+          }
+        }).catch((e_0) => {
+          setFirebaseConfigLoading(false);
+          setConfigError("Could not load Firebase configuration from Firebase hosting. If the app is not deployed in Firebase hosting, you need to specify the configuration manually" + e_0.toString());
+        });
+      }
+      if (firebaseConfig) {
+        initFirebase(firebaseConfig);
+      } else {
+        if (fromUrl) {
+          fetchFromUrl(fromUrl);
+        } else if (process.env.NODE_ENV === "production") {
+          fetchFromUrl("/__/firebase/init.json");
+        } else {
+          setFirebaseConfigLoading(false);
+          setConfigError("You need to deploy the app to Firebase hosting or specify a Firebase configuration object");
+        }
+      }
+    }, []);
+    return {
+      firebaseApp,
+      firebaseConfigLoading,
+      configError
+    };
+  }
+  function useAppCheck({
+    firebaseApp,
+    options
+  }) {
+    if (options?.debugToken) {
+      Object.assign(window, {
+        FIREBASE_APPCHECK_DEBUG_TOKEN: options?.debugToken
+      });
+    }
+    const [appCheckLoading, setAppCheckLoading] = React.useState(false);
+    const [appCheckVerified, setAppCheckVerified] = React.useState(void 0);
+    const [error, setError] = React.useState();
+    const initialCheck = React.useRef(false);
+    const verifyToken = React.useCallback(async (appCheck$1) => {
+      console.debug("Verifying App Check token...", appCheck$1);
+      try {
+        const token = await appCheck.getToken(appCheck$1, options?.forceRefresh);
+        console.debug("App Check token:", token);
+        if (!token) {
+          setError("App Check failed.");
+          setAppCheckVerified(false);
+        } else {
+          setAppCheckVerified(true);
+          console.debug("App Check success.");
+        }
+      } catch (e) {
+        console.error("App Check error:", e);
+        setError(e.message);
+      }
+    }, [options?.forceRefresh]);
+    React.useEffect(() => {
+      if (!options) return;
+      if (!firebaseApp) return;
+      if (appCheckVerified !== void 0) return;
+      if (initialCheck.current) return;
+      setAppCheckLoading(true);
+      const {
+        provider,
+        isTokenAutoRefreshEnabled
+      } = options;
+      removeCurrentAppCheckDiv();
+      const appCheck_0 = appCheck.initializeAppCheck(firebaseApp, {
+        provider,
+        isTokenAutoRefreshEnabled
+      });
+      verifyToken(appCheck_0).then(() => {
+        setAppCheckLoading(false);
+      });
+      initialCheck.current = true;
+    }, [appCheckVerified, firebaseApp, options, verifyToken]);
+    return {
+      loading: appCheckLoading,
+      appCheckVerified,
+      error
+    };
+  }
+  function removeCurrentAppCheckDiv() {
+    const div = document.getElementById("fire_app_check_[DEFAULT]");
+    if (div) {
+      div.remove();
+    }
+  }
+  function buildCollectionId(idOrPath, parentCollectionIds) {
+    if (!parentCollectionIds) return common.stripCollectionPath(idOrPath);
+    return [...parentCollectionIds.map(common.stripCollectionPath), common.stripCollectionPath(idOrPath)].join(common.COLLECTION_PATH_SEPARATOR);
+  }
+  const docsToCollectionTree = (docs) => {
+    const collectionsMap = docs.map((doc) => {
+      const id = doc.id;
+      const collection = docToCollection(doc);
+      return {
+        [id]: collection
+      };
+    }).reduce((a, b) => ({
+      ...a,
+      ...b
+    }), {});
+    const orderedKeys = Object.keys(collectionsMap).sort((a, b) => b.split(common.COLLECTION_PATH_SEPARATOR).length - a.split(common.COLLECTION_PATH_SEPARATOR).length);
+    orderedKeys.forEach((id) => {
+      const collection = collectionsMap[id];
+      if (id.includes(common.COLLECTION_PATH_SEPARATOR)) {
+        const parentId = id.split(common.COLLECTION_PATH_SEPARATOR).slice(0, -1).join(common.COLLECTION_PATH_SEPARATOR);
+        const parentCollection = collectionsMap[parentId];
+        if (parentCollection) parentCollection.subcollections = () => [...parentCollection.subcollections?.() ?? [], collection];
+        delete collectionsMap[id];
+      }
+    });
+    return Object.values(collectionsMap);
+  };
+  const docToCollection = (doc) => {
+    const data = doc.data();
+    if (!data) throw Error("Entity collection has not been persisted correctly");
+    const propertiesOrder = data.propertiesOrder;
+    const properties = data.properties ?? {};
+    const normalizedProperties = normalizePropertiesEnumValues(properties, true);
+    const sortedProperties = common.sortProperties(normalizedProperties, propertiesOrder);
+    return {
+      ...data,
+      properties: sortedProperties,
+      slug: data.id ?? data.alias ?? data.slug
+    };
+  };
+  function normalizeEnumValuesToArray(enumValues, sortObjectFormat = false) {
+    if (Array.isArray(enumValues)) {
+      return enumValues;
+    } else if (typeof enumValues === "object" && enumValues !== null) {
+      const entries = Object.entries(enumValues).map(([id, value]) => typeof value === "string" ? {
+        id,
+        label: value
+      } : {
+        ...value,
+        id
+      });
+      if (sortObjectFormat) {
+        entries.sort((a, b) => String(a.id).localeCompare(String(b.id)));
+      }
+      return entries;
+    }
+    return [];
+  }
+  function normalizePropertiesEnumValues(properties, sortObjectFormat = false) {
+    const result = {};
+    Object.entries(properties).forEach(([key, property]) => {
+      if (typeof property === "object" && property !== null) {
+        const normalizedProperty = {
+          ...property
+        };
+        if (normalizedProperty.enum) {
+          normalizedProperty.enum = normalizeEnumValuesToArray(normalizedProperty.enum, sortObjectFormat);
+        }
+        if (normalizedProperty.dataType === "array" && typeof normalizedProperty.of === "object" && normalizedProperty.of !== null) {
+          const ofProp = normalizedProperty.of;
+          if (ofProp.enum) {
+            normalizedProperty.of = {
+              ...ofProp,
+              enum: normalizeEnumValuesToArray(ofProp.enum, sortObjectFormat)
+            };
+          }
+        }
+        if (normalizedProperty.dataType === "map" && normalizedProperty.properties) {
+          normalizedProperty.properties = normalizePropertiesEnumValues(normalizedProperty.properties, sortObjectFormat);
+        }
+        result[key] = normalizedProperty;
+      } else {
+        result[key] = property;
+      }
+    });
+    return result;
+  }
+  async function getFirestoreDataInPath(firebaseApp, path, parentPaths, limit) {
+    const firestore$1 = firestore.getFirestore(firebaseApp);
+    if (!parentPaths || parentPaths.length === 0) {
+      const q = firestore.query(firestore.collection(firestore$1, path), firestore.limit(limit));
+      return firestore.getDocs(q).then((querySnapshot) => {
+        return querySnapshot.docs.map((doc) => doc.data());
+      });
+    } else {
+      let currentDocs = void 0;
+      let index = 0;
+      const allPaths = parentPaths;
+      allPaths.push(path);
+      let parentPath = allPaths[0];
+      while (parentPath) {
+        if (currentDocs) {
+          currentDocs = (await Promise.all(currentDocs.map(async (doc) => {
+            const q = firestore.query(firestore.collection(firestore$1, doc.ref.path, parentPath), firestore.limit(5));
+            return (await firestore.getDocs(q)).docs;
+          }))).flat();
+        } else {
+          const q = firestore.query(firestore.collection(firestore$1, parentPath), firestore.limit(5));
+          currentDocs = (await firestore.getDocs(q)).docs;
+        }
+        index++;
+        parentPath = index < allPaths.length ? allPaths[index] : void 0;
+      }
+      return currentDocs ? currentDocs.map((doc) => doc.data()) : [];
+    }
+  }
+  function performAlgoliaTextSearch(client, indexName, query) {
+    console.debug("Performing Algolia query", client, query);
+    return client.searchSingleIndex({
+      indexName,
+      searchParams: {
+        query
+      }
+    }).then(({
+      hits
+    }) => {
+      return hits.map((hit) => hit.objectID);
+    }).catch((err) => {
+      console.error(err);
+      return [];
+    });
+  }
+  const DEFAULT_SERVER = "https://api.rebase.pro";
+  async function performPineconeTextSearch({
+    host = DEFAULT_SERVER,
+    firebaseToken,
+    projectId,
+    collectionPath,
+    query
+  }) {
+    console.debug("Performing Pinecone query", collectionPath, query);
+    const response = await fetch((host ?? DEFAULT_SERVER) + `/projects/${projectId}/search/${collectionPath}`, {
+      // mode: "no-cors",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Basic ${firebaseToken}`
+        // "x-de-version": version
+      },
+      body: JSON.stringify({
+        query
+      })
+    });
+    const promise = await response.json();
+    return promise.data.ids;
+  }
+  function buildPineconeSearchController({
+    isPathSupported,
+    search
+  }) {
+    return (props) => {
+      const init = (props2) => {
+        return Promise.resolve(isPathSupported(props2.path));
+      };
+      return {
+        init,
+        search
+      };
+    };
+  }
+  function buildExternalSearchController({
+    isPathSupported,
+    search
+  }) {
+    return (props) => {
+      const init = (props2) => {
+        return Promise.resolve(isPathSupported(props2.path));
+      };
+      return {
+        init,
+        search
+      };
+    };
+  }
+  const MAX_SEARCH_RESULTS = 80;
+  const localSearchControllerBuilder = ({
+    firebaseApp
+  }) => {
+    let currentPath;
+    const indexes = {};
+    const listeners = {};
+    const destroyListener = (path) => {
+      if (listeners[path]) {
+        listeners[path]();
+        delete listeners[path];
+        delete indexes[path];
+      }
+    };
+    const init = ({
+      path,
+      collection: collectionProp,
+      databaseId
+    }) => {
+      if (currentPath && path !== currentPath) {
+        destroyListener(currentPath);
+      }
+      currentPath = path;
+      return new Promise(async (resolve, reject) => {
+        if (collectionProp) {
+          console.debug("Init local search controller", path);
+          const firestore$1 = databaseId ? firestore.getFirestore(firebaseApp, databaseId) : firestore.getFirestore(firebaseApp);
+          const col = firestore.collection(firestore$1, path);
+          listeners[path] = firestore.onSnapshot(firestore.query(col), {
+            next: (snapshot) => {
+              if (snapshot.metadata.fromCache && snapshot.metadata.hasPendingWrites) {
+                return;
+              }
+              const docs = snapshot.docs.map((doc) => ({
+                id: doc.id,
+                ...doc.data()
+              }));
+              indexes[path] = buildIndex(docs, collectionProp);
+              console.debug("Added docs to index", path, docs.length);
+              resolve(true);
+            },
+            error: (e) => {
+              console.error("Error initializing local search controller", path);
+              console.error(e);
+              reject(e);
+            }
+          });
+        }
+      });
+    };
+    const search = async ({
+      searchString,
+      path
+    }) => {
+      console.debug("Searching local index", path, searchString);
+      const index = indexes[path];
+      if (!index) {
+        throw new Error(`Index not found for path ${path}`);
+      }
+      let searchResult = index.search(searchString);
+      searchResult = searchResult.splice(0, MAX_SEARCH_RESULTS);
+      searchResult = searchResult.sort((a, b) => {
+        const aExactMatch = a.item.id === searchString;
+        const bExactMatch = b.item.id === searchString;
+        if (aExactMatch && !bExactMatch) {
+          return -1;
+        } else if (!aExactMatch && bExactMatch) {
+          return 1;
+        } else {
+          return (a.score ?? 0) - (b.score ?? 0);
+        }
+      });
+      return searchResult.map((e) => e.item.id);
+    };
+    return {
+      init,
+      search
+    };
+  };
+  function buildIndex(list, collection2) {
+    const keys = ["id", ...Object.keys(collection2.properties)];
+    const fuseOptions = {
+      // isCaseSensitive: false,
+      // includeScore: false,
+      // shouldSort: true,
+      // includeMatches: false,
+      // findAllMatches: false,
+      // minMatchCharLength: 1,
+      // location: 0,
+      threshold: 0.6,
+      // distance: 100,
+      // useExtendedSearch: false,
+      // ignoreLocation: false,
+      // ignoreFieldNorm: false,
+      // fieldNormWeight: 1,
+      includeScore: true,
+      keys: [{
+        name: "title",
+        weight: 1
+      }, ...keys.map((key) => ({
+        name: key,
+        weight: 0.5
+      }))]
+    };
+    return new Fuse(list, fuseOptions);
+  }
+  function buildRebaseSearchController(options) {
+    const region = options?.region || "us-central1";
+    const extensionInstanceId = options?.extensionInstanceId || "typesense-search";
+    let searchConfig = null;
+    let typesenseClient = null;
+    let initPromise = null;
+    return ({
+      firebaseApp
+    }) => {
+      const initializeClient = async () => {
+        if (typesenseClient) return;
+        if (options?.customConfig) {
+          searchConfig = {
+            host: options.customConfig.host,
+            port: options.customConfig.port || 443,
+            protocol: options.customConfig.protocol || "https",
+            apiKey: options.customConfig.apiKey,
+            path: options.customConfig.path,
+            collectionsToIndex: ["*"]
+          };
+        } else {
+          const functions$1 = functions.getFunctions(firebaseApp, region);
+          const getConfig = functions.httpsCallable(functions$1, `ext-${extensionInstanceId}-getSearchConfig`);
+          try {
+            const result = await getConfig();
+            searchConfig = result.data;
+            if (options?.collections && options.collections.length > 0) {
+              searchConfig.collectionsToIndex = options.collections;
+            }
+          } catch (error) {
+            console.error("Failed to get search config from extension:", error);
+            throw new Error(`Failed to initialize Rebase Search. Make sure the rebase-search extension is installed and configured. Error: ${error.message || error}`);
+          }
+        }
+        if (!searchConfig) {
+          throw new Error("Search config not available");
+        }
+        const Typesense = (await import("typesense")).default;
+        typesenseClient = new Typesense.Client({
+          nodes: [{
+            host: searchConfig.host,
+            port: searchConfig.port,
+            protocol: searchConfig.protocol,
+            path: searchConfig.path || ""
+          }],
+          apiKey: searchConfig.apiKey,
+          connectionTimeoutSeconds: 5,
+          retryIntervalSeconds: 0.5,
+          numRetries: 2
+        });
+      };
+      const getTypesenseCollectionName = (path) => {
+        const pathParts = path.split("/");
+        const collectionNames = [];
+        for (let i = 0; i < pathParts.length; i += 2) {
+          if (pathParts[i]) {
+            collectionNames.push(pathParts[i]);
+          }
+        }
+        return collectionNames.join("_");
+      };
+      const getParentFilter = (path) => {
+        const pathParts = path.split("/");
+        if (pathParts.length <= 1) return null;
+        const filters = [];
+        for (let i = 0; i < pathParts.length - 1; i += 2) {
+          const collectionName = pathParts[i];
+          const docId = pathParts[i + 1];
+          if (collectionName && docId) {
+            filters.push(`_parent_${collectionName}_id:=${docId}`);
+          }
+        }
+        return filters.length > 0 ? filters.join(" && ") : null;
+      };
+      const init = async (props) => {
+        try {
+          if (!initPromise) {
+            initPromise = initializeClient();
+          }
+          await initPromise;
+          if (!searchConfig) return false;
+          const pathParts = props.path.split("/");
+          const collectionNames = [];
+          for (let i = 0; i < pathParts.length; i += 2) {
+            if (pathParts[i]) collectionNames.push(pathParts[i]);
+          }
+          const collectionPattern = collectionNames.join("/");
+          const rootCollection = collectionNames[0];
+          if (searchConfig.collectionsToIndex.includes("*")) {
+            return true;
+          }
+          return searchConfig.collectionsToIndex.includes(collectionPattern) || searchConfig.collectionsToIndex.includes(rootCollection);
+        } catch (error) {
+          console.error("Failed to initialize Rebase Search:", error);
+          return false;
+        }
+      };
+      const schemaCache = /* @__PURE__ */ new Map();
+      const getSearchableFieldsFromSchema = async (collectionName) => {
+        if (schemaCache.has(collectionName)) {
+          return schemaCache.get(collectionName);
+        }
+        try {
+          const collection = await typesenseClient.collections(collectionName).retrieve();
+          const stringFields = collection.fields.filter((f) => {
+            const isStringType = f.type === "string" || f.type === "string[]" || f.type === "string*" || f.type === "auto";
+            const isNotInternal = !f.name.startsWith("_") && f.name !== ".*";
+            return isStringType && isNotInternal;
+          }).map((f) => f.name);
+          schemaCache.set(collectionName, stringFields);
+          return stringFields;
+        } catch (error) {
+          if (error.httpStatus === 404) {
+            throw new Error(`Collection "${collectionName}" not found in Typesense. Make sure the collection has been indexed. Try running the backfill function.`);
+          }
+          throw error;
+        }
+      };
+      const search = async (props) => {
+        if (!typesenseClient) {
+          if (!initPromise) {
+            initPromise = initializeClient();
+          }
+          await initPromise;
+        }
+        if (!typesenseClient) {
+          throw new Error("Typesense client not initialized. Check extension configuration.");
+        }
+        const collectionName = getTypesenseCollectionName(props.path);
+        const parentFilter = getParentFilter(props.path);
+        const searchableFields = await getSearchableFieldsFromSchema(collectionName);
+        if (searchableFields.length === 0) {
+          throw new Error(`No searchable string fields found in Typesense collection "${collectionName}". Make sure some documents have been indexed with string fields.`);
+        }
+        const queryBy = searchableFields.join(",");
+        try {
+          const searchParams = {
+            q: props.searchString,
+            query_by: queryBy,
+            per_page: 100,
+            prefix: true,
+            // Enable prefix matching
+            typo_tokens_threshold: 1
+            // Allow some typos
+          };
+          if (parentFilter) {
+            searchParams.filter_by = parentFilter;
+          }
+          const result = await typesenseClient.collections(collectionName).documents().search(searchParams);
+          const ids = result.hits?.map((hit) => hit.document.id) ?? [];
+          return ids;
+        } catch (error) {
+          const message = error.message || error.toString();
+          throw new Error(`Search failed: ${message}`);
+        }
+      };
+      return {
+        init,
+        search
+      };
+    };
+  }
+  function useFirestoreDriver({
+    firebaseApp,
+    textSearchControllerBuilder,
+    firestoreIndexesBuilder,
+    localTextSearchEnabled
+  }) {
+    const searchControllerRef = React.useRef(void 0);
+    React.useEffect(() => {
+      if (!searchControllerRef.current && firebaseApp) {
+        if ((textSearchControllerBuilder || localTextSearchEnabled) && !searchControllerRef.current) {
+          searchControllerRef.current = buildTextSearchControllerWithLocalSearch({
+            firebaseApp,
+            textSearchControllerBuilder,
+            localTextSearchEnabled: localTextSearchEnabled ?? false
+          });
+        }
+      }
+    }, [firebaseApp, localTextSearchEnabled, textSearchControllerBuilder]);
+    const buildQuery = React.useCallback((path, filter, orderBy, order, startAfter, limit, databaseId) => {
+      if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+      const firestore$1 = databaseId ? firestore.getFirestore(firebaseApp, databaseId) : firestore.getFirestore(firebaseApp);
+      const collectionReference = firestore.collection(firestore$1, path);
+      const queryParams = [];
+      if (filter) {
+        Object.entries(filter).filter(([_, entry]) => !!entry).forEach(([key, filterParameter]) => {
+          const [op, value] = filterParameter;
+          queryParams.push(firestore.where(key, op, cmsToFirestoreModel(value, firestore$1)));
+        });
+      }
+      if (orderBy && order) {
+        queryParams.push(firestore.orderBy(orderBy, order));
+      }
+      if (startAfter) {
+        queryParams.push(firestore.startAfter(startAfter));
+      }
+      if (limit) {
+        queryParams.push(firestore.limit(limit));
+      }
+      return firestore.query(collectionReference, ...queryParams);
+    }, [firebaseApp]);
+    const getAndBuildEntity = React.useCallback((path_0, entityId, databaseId_0) => {
+      if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+      const firestore_0 = databaseId_0 ? firestore.getFirestore(firebaseApp, databaseId_0) : firestore.getFirestore(firebaseApp);
+      return firestore.getDoc(firestore.doc(firestore_0, path_0, String(entityId))).then((docSnapshot) => {
+        if (!docSnapshot.exists()) {
+          return void 0;
+        }
+        return createEntityFromDocument(docSnapshot, databaseId_0);
+      });
+    }, [firebaseApp]);
+    const listenEntity = React.useCallback(({
+      path: path_1,
+      entityId: entityId_0,
+      collection,
+      onUpdate,
+      onError
+    }) => {
+      if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+      const databaseId_1 = collection?.databaseId;
+      const firestore_1 = databaseId_1 ? firestore.getFirestore(firebaseApp, databaseId_1) : firestore.getFirestore(firebaseApp);
+      const resolvedPath = path_1;
+      return firestore.onSnapshot(firestore.doc(firestore_1, resolvedPath, String(entityId_0)), {
+        next: (docSnapshot_0) => {
+          onUpdate(createEntityFromDocument(docSnapshot_0, databaseId_1));
+        },
+        error: onError
+      });
+    }, [firebaseApp]);
+    const performTextSearch = React.useCallback(({
+      path: path_2,
+      databaseId: databaseId_2,
+      searchString,
+      onUpdate: onUpdate_0
+    }) => {
+      if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+      const textSearchController = searchControllerRef.current;
+      if (!textSearchController) throw Error("Trying to make text search without specifying a FirestoreTextSearchController");
+      let subscriptions = [];
+      const auth$1 = auth.getAuth(firebaseApp);
+      const currentUser = auth$1?.currentUser;
+      const search = textSearchController.search({
+        path: path_2,
+        searchString,
+        currentUser: currentUser ?? void 0,
+        databaseId: databaseId_2
+      });
+      if (!search) {
+        throw Error("The current path is not supported by the specified FirestoreTextSearchController");
+      }
+      search.then((ids) => {
+        if (!ids || ids.length === 0) {
+          subscriptions = [];
+          onUpdate_0([]);
+        }
+        const entities = [];
+        const addedEntitiesSet = /* @__PURE__ */ new Set();
+        subscriptions = (ids ?? []).map((entityId_1) => {
+          return listenEntity({
+            path: path_2,
+            entityId: entityId_1,
+            onUpdate: (entity) => {
+              if (entity?.values) {
+                if (entity.id && !addedEntitiesSet.has(entity.id)) {
+                  addedEntitiesSet.add(entity.id);
+                  entities.push(entity);
+                  onUpdate_0(entities);
+                }
+              } else if (entity?.id) {
+                addedEntitiesSet.delete(entity.id);
+                onUpdate_0([...entities.filter((e) => e.id !== entityId_1)]);
+              }
+            }
+          });
+        });
+      });
+      return () => {
+        subscriptions.forEach((p) => p());
+      };
+    }, [firebaseApp, listenEntity]);
+    return {
+      key: "firestore",
+      currentTime,
+      initialised: Boolean(firebaseApp),
+      initTextSearch: React.useCallback(async (props) => {
+        console.debug("Init text search controller", searchControllerRef.current, props.path);
+        if (!searchControllerRef.current) {
+          console.warn("You are trying to use text search, but have not provided a text search controller in `useFirestoreDriver`. You can also set the flag `localTextSearchEnabled` to use local search in `useFirestoreDriver`. Local text search can incur in performance issues and higher costs for large datasets.");
+          return false;
+        }
+        try {
+          return searchControllerRef.current.init(props);
+        } catch (e_0) {
+          console.error("Error initializing text search controller", e_0);
+          return false;
+        }
+      }, []),
+      /**
+       * Fetch entities in a Firestore path
+       * @param path
+       * @param collection
+       * @param filter
+       * @param limit
+       * @param startAfter
+       * @param searchString
+       * @param orderBy
+       * @param order
+       * @return Function to cancel subscription
+       * @see useCollectionFetch if you need this functionality implemented as a hook
+       * @group Firestore
+       */
+      fetchCollection: React.useCallback(async ({
+        path: path_3,
+        filter: filter_0,
+        limit: limit_0,
+        startAfter: startAfter_0,
+        searchString: searchString_0,
+        orderBy: orderBy_0,
+        order: order_0,
+        collection: collection_0
+      }) => {
+        const databaseId_3 = collection_0?.databaseId;
+        const resolvedPath_0 = path_3;
+        console.debug("Fetching collection", {
+          path: path_3,
+          limit: limit_0,
+          filter: filter_0,
+          startAfter: startAfter_0,
+          orderBy: orderBy_0,
+          order: order_0
+        });
+        const query2 = buildQuery(resolvedPath_0, filter_0, orderBy_0, order_0, startAfter_0, limit_0, databaseId_3);
+        const snapshot = await firestore.getDocs(query2);
+        return snapshot.docs.map((doc2) => createEntityFromDocument(doc2, databaseId_3));
+      }, [buildQuery]),
+      /**
+       * Listen to a entities in a given path
+       * @param path
+       * @param collection
+       * @param onError
+       * @param filter
+       * @param limit
+       * @param startAfter
+       * @param searchString
+       * @param orderBy
+       * @param order
+       * @param onUpdate
+       * @return Function to cancel subscription
+       * @see useCollectionFetch if you need this functionality implemented as a hook
+       * @group Firestore
+       */
+      listenCollection: React.useCallback(({
+        path: path_4,
+        filter: filter_1,
+        limit: limit_1,
+        startAfter: startAfter_1,
+        searchString: searchString_1,
+        orderBy: orderBy_1,
+        order: order_1,
+        onUpdate: onUpdate_1,
+        onError: onError_0,
+        collection: collection_1
+      }) => {
+        console.debug("Listening collection", {
+          path: path_4,
+          searchString: searchString_1,
+          limit: limit_1,
+          filter: filter_1,
+          startAfter: startAfter_1,
+          orderBy: orderBy_1,
+          order: order_1,
+          collection: collection_1
+        });
+        if (!firebaseApp) {
+          throw Error("useFirestoreDriver Firebase not initialised");
+        }
+        const databaseId_4 = collection_1?.databaseId;
+        if (searchString_1) {
+          return performTextSearch({
+            path: path_4,
+            searchString: searchString_1,
+            onUpdate: onUpdate_1,
+            databaseId: databaseId_4
+          });
+        }
+        const resolvedPath_1 = path_4;
+        console.debug("Resolved path for listening", {
+          path: path_4,
+          resolvedPath: resolvedPath_1
+        });
+        const query_0 = buildQuery(resolvedPath_1, filter_1, orderBy_1, order_1, startAfter_1, limit_1, databaseId_4);
+        return firestore.onSnapshot(query_0, {
+          next: (snapshot_0) => {
+            if (!searchString_1) onUpdate_1(snapshot_0.docs.map((doc_0) => createEntityFromDocument(doc_0, databaseId_4)));
+          },
+          error: onError_0
+        });
+      }, [buildQuery, firebaseApp, performTextSearch]),
+      /**
+       * Retrieve an entity given a path and a collection
+       * @param path
+       * @param entityId
+       * @param collection
+       * @group Firestore
+       */
+      fetchEntity: React.useCallback(({
+        path: path_5,
+        entityId: entityId_2,
+        collection: collection_2
+      }) => {
+        const resolvedPath_2 = path_5;
+        return getAndBuildEntity(resolvedPath_2, entityId_2, collection_2?.databaseId);
+      }, [getAndBuildEntity]),
+      /**
+       *
+       * @param path
+       * @param entityId
+       * @param collection
+       * @param onUpdate
+       * @param onError
+       * @return Function to cancel subscription
+       * @group Firestore
+       */
+      listenEntity,
+      /**
+       * Save entity to the specified path. Note that Firestore does not allow
+       * undefined values.
+       * @param path
+       * @param entityId
+       * @param values
+       * @param schemaId
+       * @param collection
+       * @param status
+       * @group Firestore
+       */
+      saveEntity: React.useCallback(({
+        path: path_6,
+        entityId: entityId_3,
+        values: valuesProp,
+        collection: collection_3,
+        status
+      }) => {
+        if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+        console.debug("1", {
+          path: path_6,
+          entityId: entityId_3,
+          values: valuesProp,
+          collection: collection_3
+        });
+        const values = cmsToFirestoreModel(valuesProp, firestore.getFirestore(firebaseApp));
+        console.debug("2", {
+          path: path_6,
+          entityId: entityId_3,
+          values: valuesProp,
+          collection: collection_3
+        });
+        const databaseId_5 = collection_3?.databaseId;
+        const firestore_2 = databaseId_5 ? firestore.getFirestore(firebaseApp, databaseId_5) : firestore.getFirestore(firebaseApp);
+        const collectionReference_0 = firestore.collection(firestore_2, path_6);
+        console.debug("Saving entity", {
+          path: path_6,
+          entityId: entityId_3,
+          values,
+          databaseId: databaseId_5
+        });
+        let documentReference;
+        if (entityId_3) {
+          documentReference = firestore.doc(collectionReference_0, String(entityId_3));
+        } else {
+          documentReference = firestore.doc(collectionReference_0);
+        }
+        return firestore.setDoc(documentReference, values, {
+          merge: true
+        }).then(() => {
+          return {
+            id: documentReference.id,
+            path: path_6,
+            values: firestoreToCMSModel(values)
+          };
+        }).catch((error) => {
+          console.error("Error saving entity", error);
+          throw error;
+        });
+      }, [firebaseApp]),
+      /**
+       * Delete an entity
+       * @param entity
+       * @param collection
+       * @group Firestore
+       */
+      deleteEntity: React.useCallback(({
+        entity: entity_0
+      }) => {
+        if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+        const databaseId_6 = entity_0.databaseId;
+        const firestore_3 = databaseId_6 ? firestore.getFirestore(firebaseApp, databaseId_6) : firestore.getFirestore(firebaseApp);
+        return firestore.deleteDoc(firestore.doc(firestore_3, entity_0.path, String(entity_0.id)));
+      }, [firebaseApp]),
+      /**
+       * Check if the given property is unique in the given collection
+       * @param path Collection path
+       * @param name of the property
+       * @param value
+       * @param property
+       * @param entityId
+       * @return `true` if there are no other fields besides the given entity
+       * @group Firestore
+       */
+      checkUniqueField: React.useCallback(async (path_7, name, value_0, entityId_4, collection_4) => {
+        if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+        const databaseId_7 = collection_4?.databaseId;
+        const firestore_4 = databaseId_7 ? firestore.getFirestore(firebaseApp, databaseId_7) : firestore.getFirestore(firebaseApp);
+        if (value_0 === void 0 || value_0 === null) {
+          return Promise.resolve(true);
+        }
+        const q = firestore.query(firestore.collection(firestore_4, path_7), firestore.where(name, "==", cmsToFirestoreModel(value_0, firestore_4)));
+        const snapshot_1 = await firestore.getDocs(q);
+        return snapshot_1.docs.filter((doc_1) => doc_1.id !== entityId_4).length === 0;
+      }, [firebaseApp]),
+      countEntities: React.useCallback(async ({
+        path: path_8,
+        filter: filter_2,
+        order: order_2,
+        orderBy: orderBy_2,
+        collection: collection_5
+      }) => {
+        if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+        const databaseId_8 = collection_5?.databaseId;
+        const resolvedPath_4 = path_8;
+        const query_1 = buildQuery(resolvedPath_4, filter_2, orderBy_2, order_2, void 0, void 0, databaseId_8);
+        const snapshot_2 = await firestore.getCountFromServer(query_1);
+        return snapshot_2.data().count;
+      }, [firebaseApp]),
+      isFilterCombinationValid: React.useCallback(({
+        path: path_9,
+        collection: collection_6,
+        filterValues,
+        sortBy
+      }) => {
+        if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+        if (firestoreIndexesBuilder === void 0) return true;
+        const resolvedPath_5 = path_9;
+        const indexes = firestoreIndexesBuilder?.({
+          path: resolvedPath_5,
+          collection: collection_6
+        });
+        const sortKey = sortBy ? sortBy[0] : void 0;
+        const sortDirection = sortBy ? sortBy[1] : void 0;
+        const values_0 = Object.values(filterValues);
+        const filterKeys = Object.keys(filterValues);
+        const filtersCount = filterKeys.length;
+        if (!sortKey && values_0.every((v) => v[0] === "==")) {
+          return true;
+        }
+        if (filtersCount === 1 && (!sortKey || sortKey === filterKeys[0])) {
+          return true;
+        }
+        if (!indexes && filtersCount > 1) {
+          return false;
+        }
+        return !!indexes && indexes.filter((compositeIndex) => !sortKey || sortKey in compositeIndex).find((compositeIndex_0) => Object.entries(filterValues).every(([key_0, value_1]) => compositeIndex_0[key_0] !== void 0 && (!sortDirection || compositeIndex_0[key_0] === sortDirection))) !== void 0;
+      }, [firebaseApp])
+    };
+  }
+  const createEntityFromDocument = (docSnap, databaseId) => {
+    const values = firestoreToCMSModel(docSnap.data());
+    const path = getCMSPathFromFirestorePath(docSnap.ref.path);
+    return {
+      id: docSnap.id,
+      path,
+      values,
+      databaseId
+    };
+  };
+  function firestoreToCMSModel(data) {
+    if (data === null || data === void 0) return null;
+    if (firestore.deleteField().isEqual(data)) {
+      return void 0;
+    }
+    if (firestore.serverTimestamp().isEqual(data)) {
+      return null;
+    }
+    if (data instanceof firestore.Timestamp || typeof data.toDate === "function" && data.toDate() instanceof Date) {
+      return data.toDate();
+    }
+    if (data instanceof Date) {
+      return data;
+    }
+    if (typeof data === "object" && "__type__" in data && data.__type__ === "__vector__") {
+      return data;
+    }
+    if (data instanceof firestore.VectorValue || typeof data === "object" && data !== null && typeof data.toArray === "function" && data.constructor?.name === "VectorValue") {
+      return {
+        __type__: "__vector__",
+        value: data.toArray()
+      };
+    }
+    if (data instanceof firestore.GeoPoint) {
+      return new types.GeoPoint(data.latitude, data.longitude);
+    }
+    if (data instanceof firestore.DocumentReference) {
+      const databaseId = data?.firestore?._databaseId?.database;
+      return new types.EntityReference({
+        id: data.id,
+        path: getCMSPathFromFirestorePath(data.path),
+        databaseId
+      });
+    }
+    if (Array.isArray(data)) {
+      return data.map(firestoreToCMSModel).filter((v) => v !== void 0);
+    }
+    if (typeof data === "object") {
+      const result = {};
+      for (const key of Object.keys(data)) {
+        const childValue = firestoreToCMSModel(data[key]);
+        if (childValue !== void 0) result[key] = childValue;
+      }
+      return result;
+    }
+    return data;
+  }
+  function getCMSPathFromFirestorePath(fsPath) {
+    let to = fsPath.lastIndexOf("/");
+    to = to === -1 ? fsPath.length : to;
+    return fsPath.substring(0, to);
+  }
+  function cmsToFirestoreModel(data, firestore$1, inArray = false) {
+    if (data === void 0) {
+      return firestore.deleteField();
+    } else if (data === null) {
+      return null;
+    } else if (Array.isArray(data)) {
+      return data.filter((v) => v !== void 0).map((v) => cmsToFirestoreModel(v, firestore$1, true));
+    } else if (data.isEntityReference && data.isEntityReference()) {
+      const targetFirestore = data.databaseId ? firestore.getFirestore(firestore$1.app, data.databaseId) : firestore$1;
+      return firestore.doc(targetFirestore, data.path, data.id);
+    } else if (data instanceof types.GeoPoint) {
+      return new firestore.GeoPoint(data.latitude, data.longitude);
+    } else if (data instanceof Date) {
+      return firestore.Timestamp.fromDate(data);
+    } else if (data && typeof data === "object" && "__type__" in data && data.__type__ === "__vector__") {
+      return firestore.vector(data.value || []);
+    } else if (data && typeof data === "object") {
+      return Object.entries(data).map(([key, v]) => {
+        const firestoreModel = cmsToFirestoreModel(v, firestore$1);
+        if (firestoreModel !== void 0) return {
+          [key]: firestoreModel
+        };
+        else return {};
+      }).reduce((a, b) => ({
+        ...a,
+        ...b
+      }), {});
+    }
+    return data;
+  }
+  function currentTime() {
+    return firestore.serverTimestamp();
+  }
+  function buildTextSearchControllerWithLocalSearch({
+    textSearchControllerBuilder,
+    firebaseApp,
+    localTextSearchEnabled
+  }) {
+    if (!textSearchControllerBuilder && localTextSearchEnabled) {
+      console.debug("Using local search only");
+      return localSearchControllerBuilder({
+        firebaseApp
+      });
+    }
+    if (!localTextSearchEnabled && textSearchControllerBuilder) {
+      console.debug("Using external text search only");
+      return textSearchControllerBuilder({
+        firebaseApp
+      });
+    }
+    if (!textSearchControllerBuilder && !localTextSearchEnabled) {
+      return void 0;
+    }
+    const localSearchController = localSearchControllerBuilder({
+      firebaseApp
+    });
+    const textSearchController = textSearchControllerBuilder({
+      firebaseApp
+    });
+    return {
+      init: async (props) => {
+        const b = await textSearchController.init(props);
+        if (b) {
+          console.debug("External Text search controller supports path", props.path);
+          return true;
+        }
+        if (localTextSearchEnabled) return localSearchController.init(props);
+        return false;
+      },
+      search: async (props) => {
+        const search = await textSearchController.search(props);
+        return search ?? await localSearchController.search(props);
+      }
+    };
+  }
+  function useFirebaseRTDBDelegate(t0) {
+    const $ = reactCompilerRuntime.c(22);
+    const {
+      firebaseApp
+    } = t0;
+    let t1;
+    if ($[0] !== firebaseApp) {
+      t1 = async (t22) => {
+        const {
+          path,
+          limit,
+          startAfter
+        } = t22;
+        if (!firebaseApp) {
+          throw new Error("Firebase app not provided");
+        }
+        const database$1 = database.getDatabase(firebaseApp);
+        let dbQuery = database.query(database.ref(database$1, path));
+        if (startAfter !== void 0) {
+          dbQuery = database.query(dbQuery, database.orderByKey(), database.startAt(String(startAfter)));
+        }
+        if (limit !== void 0) {
+          dbQuery = database.query(dbQuery, database.limitToFirst(limit));
+        }
+        const snapshot = await database.get(dbQuery);
+        if (snapshot.exists()) {
+          return Object.entries(snapshot.val()).map((t32) => {
+            const [id, values] = t32;
+            return {
+              id,
+              path,
+              values: delegateToCMSModel(values)
+            };
+          });
+        }
+        return [];
+      };
+      $[0] = firebaseApp;
+      $[1] = t1;
+    } else {
+      t1 = $[1];
+    }
+    const fetchCollection = t1;
+    let t2;
+    if ($[2] !== firebaseApp) {
+      t2 = (t32) => {
+        const {
+          path: path_0,
+          onUpdate
+        } = t32;
+        if (!firebaseApp) {
+          throw new Error("Firebase app not provided");
+        }
+        const database_0 = database.getDatabase(firebaseApp);
+        const dbRef = database.ref(database_0, path_0);
+        const unsubscribe = database.onValue(dbRef, (snapshot_0) => {
+          if (snapshot_0.exists()) {
+            const result = Object.entries(snapshot_0.val()).map((t42) => {
+              const [id_0, values_0] = t42;
+              return {
+                id: id_0,
+                path: path_0,
+                values: delegateToCMSModel(values_0)
+              };
+            });
+            onUpdate(result);
+          } else {
+            onUpdate([]);
+          }
+        });
+        return () => unsubscribe();
+      };
+      $[2] = firebaseApp;
+      $[3] = t2;
+    } else {
+      t2 = $[3];
+    }
+    const listenCollection = t2;
+    let t3;
+    if ($[4] !== firebaseApp) {
+      t3 = async (t42) => {
+        const {
+          path: path_1,
+          entityId
+        } = t42;
+        if (!firebaseApp) {
+          throw new Error("Firebase app not provided");
+        }
+        const database_1 = database.getDatabase(firebaseApp);
+        const snapshot_1 = await database.get(database.ref(database_1, `${path_1}/${entityId}`));
+        if (snapshot_1.exists()) {
+          return {
+            id: entityId,
+            path: path_1,
+            values: delegateToCMSModel(snapshot_1.val())
+          };
+        }
+      };
+      $[4] = firebaseApp;
+      $[5] = t3;
+    } else {
+      t3 = $[5];
+    }
+    const fetchEntity = t3;
+    let t4;
+    if ($[6] !== firebaseApp) {
+      t4 = (t52) => {
+        const {
+          path: path_2,
+          entityId: entityId_0,
+          onUpdate: onUpdate_0,
+          onError
+        } = t52;
+        if (!firebaseApp) {
+          throw new Error("Firebase app not provided");
+        }
+        const database_2 = database.getDatabase(firebaseApp);
+        const dbRef_0 = database.ref(database_2, `${path_2}/${entityId_0}`);
+        const unsubscribe_0 = database.onValue(dbRef_0, (snapshot_2) => {
+          if (snapshot_2.exists()) {
+            onUpdate_0({
+              id: entityId_0,
+              path: path_2,
+              values: delegateToCMSModel(snapshot_2.val())
+            });
+          } else {
+            onError?.(new Error("Entity does not exist"));
+          }
+        });
+        return () => unsubscribe_0();
+      };
+      $[6] = firebaseApp;
+      $[7] = t4;
+    } else {
+      t4 = $[7];
+    }
+    const listenEntity = t4;
+    let t5;
+    if ($[8] !== firebaseApp) {
+      t5 = async (t62) => {
+        const {
+          path: path_3,
+          entityId: entityId_1,
+          values: values_1
+        } = t62;
+        if (!firebaseApp) {
+          throw new Error("Firebase app not provided");
+        }
+        const database_3 = database.getDatabase(firebaseApp);
+        const finalId = entityId_1 ?? database.push(database.ref(database_3, path_3)).key;
+        if (!finalId) {
+          throw new Error("Could not generate a new id");
+        }
+        const transformedValues = cmsToRTDBModel(values_1, database_3);
+        await database.set(database.ref(database_3, `${path_3}/${finalId}`), transformedValues);
+        return {
+          id: finalId,
+          path: path_3,
+          values: values_1
+        };
+      };
+      $[8] = firebaseApp;
+      $[9] = t5;
+    } else {
+      t5 = $[9];
+    }
+    const saveEntity = t5;
+    let t6;
+    if ($[10] !== firebaseApp) {
+      t6 = async (t72) => {
+        const {
+          entity
+        } = t72;
+        if (!firebaseApp) {
+          throw new Error("Firebase app not provided");
+        }
+        const database_4 = database.getDatabase(firebaseApp);
+        await database.remove(database.ref(database_4, `${entity.path}/${entity.id}`));
+      };
+      $[10] = firebaseApp;
+      $[11] = t6;
+    } else {
+      t6 = $[11];
+    }
+    const deleteEntity = t6;
+    let t7;
+    if ($[12] !== firebaseApp) {
+      t7 = async (slug, name, value, entityId_2) => {
+        if (!firebaseApp) {
+          throw new Error("Firebase app not provided");
+        }
+        const database_5 = database.getDatabase(firebaseApp);
+        const dbRef_1 = database.query(database.ref(database_5, slug), database.orderByChild(name), database.startAt(value), database.limitToFirst(1));
+        const snapshot_3 = await database.get(dbRef_1);
+        if (!snapshot_3.exists()) {
+          return true;
+        }
+        const [key, entityValue] = Object.entries(snapshot_3.val())[0];
+        if (entityValue && typeof entityValue === "object" && entityValue[name] === value && key === entityId_2) {
+          return true;
+        }
+        return false;
+      };
+      $[12] = firebaseApp;
+      $[13] = t7;
+    } else {
+      t7 = $[13];
+    }
+    const checkUniqueField = t7;
+    const isFilterCombinationValid = _temp$2;
+    let t8;
+    if ($[14] !== checkUniqueField || $[15] !== deleteEntity || $[16] !== fetchCollection || $[17] !== fetchEntity || $[18] !== listenCollection || $[19] !== listenEntity || $[20] !== saveEntity) {
+      t8 = {
+        key: "firebase_rtdb",
+        fetchCollection,
+        listenCollection,
+        fetchEntity,
+        listenEntity,
+        saveEntity,
+        deleteEntity,
+        checkUniqueField,
+        isFilterCombinationValid,
+        currentTime: _temp2$1
+      };
+      $[14] = checkUniqueField;
+      $[15] = deleteEntity;
+      $[16] = fetchCollection;
+      $[17] = fetchEntity;
+      $[18] = listenCollection;
+      $[19] = listenEntity;
+      $[20] = saveEntity;
+      $[21] = t8;
+    } else {
+      t8 = $[21];
+    }
+    return t8;
+  }
+  function _temp2$1() {
+    return /* @__PURE__ */ new Date();
+  }
+  function _temp$2(t0) {
+    return false;
+  }
+  function delegateToCMSModel(data) {
+    if (data === null || data === void 0) return null;
+    if (Array.isArray(data)) {
+      return data.map(delegateToCMSModel).filter((v) => v !== void 0);
+    }
+    if (typeof data === "object") {
+      const result = {};
+      for (const key of Object.keys(data)) {
+        const childValue = delegateToCMSModel(data[key]);
+        if (childValue !== void 0) result[key] = childValue;
+      }
+      return result;
+    }
+    return data;
+  }
+  function cmsToRTDBModel(data, database$1) {
+    if (data === void 0) {
+      return null;
+    } else if (data === null) {
+      return null;
+    } else if (Array.isArray(data)) {
+      return data.filter((v) => v !== void 0).map((v) => cmsToRTDBModel(v, database$1));
+    } else if (data.isEntityReference && data.isEntityReference()) {
+      return database.ref(database$1, `${data.slug}/${data.id}`);
+    } else if (data instanceof Date) {
+      return data.toISOString();
+    } else if (data && typeof data === "object") {
+      return Object.entries(data).map(([key, v]) => {
+        const rtdbModel = cmsToRTDBModel(v, database$1);
+        if (rtdbModel !== void 0) return {
+          [key]: rtdbModel
+        };
+        else return {};
+      }).reduce((a, b) => ({
+        ...a,
+        ...b
+      }), {});
+    }
+    return data;
+  }
+  const RECAPTCHA_CONTAINER_ID = "recaptcha-container";
+  function useRecaptcha() {
+    const $ = reactCompilerRuntime.c(1);
+    let t0;
+    if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+      t0 = [];
+      $[0] = t0;
+    } else {
+      t0 = $[0];
+    }
+    React.useEffect(_temp$1, t0);
+    return null;
+  }
+  function _temp$1() {
+    if (!window || window?.recaptchaVerifier) {
+      return;
+    }
+    const auth$1 = auth.getAuth();
+    window.recaptchaVerifier = new auth.RecaptchaVerifier(auth$1, RECAPTCHA_CONTAINER_ID, {
+      size: "invisible"
+    });
+  }
+  const googleIcon = (mode) => /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 64 64", width: 32, height: 32, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("linearGradient", { id: "95yY7w43Oj6n2vH63j6HJb", x1: "29.401", x2: "29.401", y1: "4.064", y2: "106.734", gradientTransform: "matrix(1 0 0 -1 0 66)", gradientUnits: "userSpaceOnUse", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: "0", stopColor: "#ff5840" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: ".007", stopColor: "#ff5840" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: ".989", stopColor: "#fa528c" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: "1", stopColor: "#fa528c" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { fill: "url(#95yY7w43Oj6n2vH63j6HJb)", d: "M47.46,15.5l-1.37,1.48c-1.34,1.44-3.5,1.67-5.15,0.6c-2.71-1.75-6.43-3.13-11-2.37 c-4.94,0.83-9.17,3.85-11.64, 7.97l-8.03-6.08C14.99,9.82,23.2,5,32.5,5c5,0,9.94,1.56,14.27,4.46 C48.81,10.83,49.13,13.71,47.46,15.5z" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("linearGradient", { id: "95yY7w43Oj6n2vH63j6HJc", x1: "12.148", x2: "12.148", y1: ".872", y2: "47.812", gradientTransform: "matrix(1 0 0 -1 0 66)", gradientUnits: "userSpaceOnUse", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: "0", stopColor: "#feaa53" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: ".612", stopColor: "#ffcd49" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: "1", stopColor: "#ffde44" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { fill: "url(#95yY7w43Oj6n2vH63j6HJc)", d: "M16.01,30.91c-0.09,2.47,0.37,4.83,1.27,6.96l-8.21,6.05c-1.35-2.51-2.3-5.28-2.75-8.22 c-1.06-6.88,0.54-13.38, 3.95-18.6l8.03,6.08C16.93,25.47,16.1,28.11,16.01,30.91z" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("linearGradient", { id: "95yY7w43Oj6n2vH63j6HJd", x1: "29.76", x2: "29.76", y1: "32.149", y2: "-6.939", gradientTransform: "matrix(1 0 0 -1 0 66)", gradientUnits: "userSpaceOnUse", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: "0", stopColor: "#42d778" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: ".428", stopColor: "#3dca76" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: "1", stopColor: "#34b171" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { fill: "url(#95yY7w43Oj6n2vH63j6HJd)", d: "M50.45,51.28c-4.55,4.07-10.61,6.57-17.36,6.71C22.91,58.2,13.66,52.53,9.07,43.92l8.21-6.05 C19.78,43.81, 25.67,48,32.5,48c3.94,0,7.52-1.28,10.33-3.44L50.45,51.28z" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("linearGradient", { id: "95yY7w43Oj6n2vH63j6HJe", x1: "46", x2: "46", y1: "3.638", y2: "35.593", gradientTransform: "matrix(1 0 0 -1 0 66)", gradientUnits: "userSpaceOnUse", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: "0", stopColor: "#155cde" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: ".278", stopColor: "#1f7fe5" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: ".569", stopColor: "#279ceb" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: ".82", stopColor: "#2cafef" }),
+      /* @__PURE__ */ jsxRuntime.jsx("stop", { offset: "1", stopColor: "#2eb5f0" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { fill: "url(#95yY7w43Oj6n2vH63j6HJe)", d: "M59,31.97c0.01,7.73-3.26,14.58-8.55,19.31l-7.62-6.72c2.1-1.61,3.77-3.71,4.84-6.15\n        c0.29-0.66-0.2-1.41-0.92-1.41H37c-2.21,0-4-1.79-4-4v-2c0-2.21,1.79-4,4-4h17C56.75,27,59,29.22,59,31.97z" })
+  ] }) });
+  const appleIcon = (mode) => /* @__PURE__ */ jsxRuntime.jsx("svg", { width: 32, height: 32, viewBox: "0 0 56 56", style: {
+    transform: "scale(2.8)"
+  }, version: "1.1", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ jsxRuntime.jsx("g", { stroke: mode === "light" ? "#424245" : "white", strokeWidth: "0.5", fillRule: "evenodd", children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M28.2226562,20.3846154 C29.0546875,20.3846154 30.0976562,19.8048315 30.71875,19.0317864 C31.28125,18.3312142 31.6914062,17.352829 31.6914062,16.3744437 C31.6914062,16.2415766 31.6796875,16.1087095 31.65625,16 C30.7304687,16.0362365 29.6171875,16.640178 28.9492187,17.4494596 C28.421875,18.06548 27.9414062,19.0317864 27.9414062,20.0222505 C27.9414062,20.1671964 27.9648438,20.3121424 27.9765625,20.3604577 C28.0351562,20.3725366 28.1289062,20.3846154 28.2226562,20.3846154 Z M25.2929688,35 C26.4296875,35 26.9335938,34.214876 28.3515625,34.214876 C29.7929688,34.214876 30.109375,34.9758423 31.375,34.9758423 C32.6171875,34.9758423 33.4492188,33.792117 34.234375,32.6325493 C35.1132812,31.3038779 35.4765625,29.9993643 35.5,29.9389701 C35.4179688,29.9148125 33.0390625,28.9122695 33.0390625,26.0979021 C33.0390625,23.6579784 34.9140625,22.5588048 35.0195312,22.474253 C33.7773438,20.6382708 31.890625,20.5899555 31.375,20.5899555 C29.9804688,20.5899555 28.84375,21.4596313 28.1289062,21.4596313 C27.3554688,21.4596313 26.3359375,20.6382708 25.1289062,20.6382708 C22.8320312,20.6382708 20.5,22.5950413 20.5,26.2911634 C20.5,28.5861411 21.3671875,31.013986 22.4335938,32.5842339 C23.3476562,33.9129053 24.1445312,35 25.2929688,35 Z", fill: mode === "light" ? "#424245" : "white", fillRule: "nonzero" }) }) });
+  const githubIcon = (mode) => /* @__PURE__ */ jsxRuntime.jsx("svg", { fill: mode === "light" ? "#1c1e21" : "white", role: "img", viewBox: "0 0 24 24", width: 28, height: 28, xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12" }) });
+  const facebookIcon = (mode) => /* @__PURE__ */ jsxRuntime.jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: 28, height: 28, viewBox: "0 0 90 90", children: /* @__PURE__ */ jsxRuntime.jsx("g", { children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M90,15.001C90,7.119,82.884,0,75,0H15C7.116,0,0,7.119,0,15.001v59.998   C0,82.881,7.116,90,15.001,90H45V56H34V41h11v-5.844C45,25.077,52.568,16,61.875,16H74v15H61.875C60.548,31,59,32.611,59,35.024V41   h15v15H59v34h16c7.884,0,15-7.119,15-15.001V15.001z", fill: mode === "light" ? "#39569c" : "white" }) }) });
+  const microsoftIcon = (mode) => /* @__PURE__ */ jsxRuntime.jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: 28, height: 28, viewBox: "0 0 480 480", children: /* @__PURE__ */ jsxRuntime.jsx("g", { children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M0.176,224L0.001,67.963l192-26.072V224H0.176z M224.001,37.241L479.937,0v224H224.001V37.241z M479.999,256l-0.062,224   l-255.936-36.008V256H479.999z M192.001,439.918L0.157,413.621L0.147,256h191.854V439.918z", fill: mode === "light" ? "#00a2ed" : "white" }) }) });
+  const twitterIcon = (mode) => /* @__PURE__ */ jsxRuntime.jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: 28, height: 28, viewBox: "0 0 24 24", children: /* @__PURE__ */ jsxRuntime.jsx("path", { fill: mode === "light" ? "#00acee" : "white", d: "M24 4.557c-.883.392-1.832.656-2.828.775 1.017-.609 1.798-1.574 2.165-2.724-.951.564-2.005.974-3.127 1.195-.897-.957-2.178-1.555-3.594-1.555-3.179 0-5.515 2.966-4.797 6.045-4.091-.205-7.719-2.165-10.148-5.144-1.29 2.213-.669 5.108 1.523 6.574-.806-.026-1.566-.247-2.229-.616-.054 2.281 1.581 4.415 3.949 4.89-.693.188-1.452.232-2.224.084.626 1.956 2.444 3.379 4.6 3.419-2.07 1.623-4.678 2.348-7.29 2.04 2.179 1.397 4.768 2.212 7.548 2.212 9.142 0 14.307-7.721 13.995-14.646.962-.695 1.797-1.562 2.457-2.549z" }) });
+  function FirebaseLoginView({
+    children,
+    allowSkipLogin,
+    logo,
+    signInOptions,
+    firebaseApp,
+    authController,
+    noUserComponent,
+    disableSignupScreen = false,
+    disableResetPassword = false,
+    disabled = false,
+    additionalComponent,
+    notAllowedError,
+    className
+  }) {
+    const modeState = core.useModeController();
+    const [passwordLoginSelected, setPasswordLoginSelected] = React.useState(false);
+    const [phoneLoginSelected, setPhoneLoginSelected] = React.useState(false);
+    const [fadeIn, setFadeIn] = React.useState(false);
+    React.useEffect(() => {
+      const timer = setTimeout(() => {
+        setFadeIn(true);
+      }, 50);
+      return () => clearTimeout(timer);
+    }, []);
+    const resolvedSignInOptions = signInOptions.map((o) => {
+      if (typeof o === "object") {
+        return o.provider;
+      } else return o;
+    });
+    const sendMFASms = React.useCallback(() => {
+      const auth$1 = auth.getAuth(firebaseApp);
+      const recaptchaVerifier = new auth.RecaptchaVerifier(auth$1, "recaptcha", {
+        size: "invisible"
+      });
+      const resolver = auth.getMultiFactorResolver(auth$1, authController.authProviderError);
+      if (resolver.hints[0].factorId === auth.PhoneMultiFactorGenerator.FACTOR_ID) {
+        const phoneInfoOptions = {
+          multiFactorHint: resolver.hints[0],
+          session: resolver.session
+        };
+        const phoneAuthProvider = new auth.PhoneAuthProvider(auth$1);
+        phoneAuthProvider.verifyPhoneNumber(phoneInfoOptions, recaptchaVerifier).then(function(verificationId) {
+          const verificationCode = String(window.prompt("Please enter the verification code that was sent to your mobile device."));
+          const cred = auth.PhoneAuthProvider.credential(verificationId, verificationCode);
+          const multiFactorAssertion = auth.PhoneMultiFactorGenerator.assertion(cred);
+          return resolver.resolveSignIn(multiFactorAssertion);
+        });
+      } else {
+        console.warn("Unsupported second factor.");
+      }
+    }, [authController.authProviderError]);
+    function buildErrorView() {
+      let errorView;
+      if (authController.user != null) return errorView;
+      const ignoredCodes = ["auth/popup-closed-by-user", "auth/cancelled-popup-request"];
+      if (authController.authProviderError) {
+        const authError = authController.authProviderError;
+        if (authError.code === "auth/operation-not-allowed" || authError.code === "auth/configuration-not-found") {
+          errorView = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsx(core.ErrorView, { title: "Firebase Auth not enabled", error: "You need to enable Firebase Auth and the corresponding login provider in your Firebase project" }) }),
+            firebaseApp && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsx("a", { href: `https://console.firebase.google.com/project/${firebaseApp.options.projectId}/authentication/providers`, rel: "noopener noreferrer", target: "_blank", children: /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { variant: "text", color: "error", children: "Open Firebase configuration" }) }) })
+          ] });
+        } else if (authError.code === "auth/invalid-api-key") {
+          errorView = /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsx(core.ErrorView, { title: "Invalid API key", error: "auth/invalid-api-key: Check that your Firebase config is set correctly in your `firebase_config.ts` file" }) });
+        } else if (authError.code === "auth/email-already-in-use") {
+          errorView = /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsx(core.ErrorView, { title: "Email already in use", error: "The selected email is already in use by another account" }) });
+        } else if (authError.code === "auth/invalid-credential") {
+          errorView = /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsx(core.ErrorView, { title: "Invalid credential", error: "The provided credential is not correct" }) });
+        } else if (!ignoredCodes.includes(authError.code)) {
+          if (authError.code === "auth/multi-factor-auth-required") {
+            sendMFASms();
+          }
+          errorView = /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsx(core.ErrorView, { error: authController.authProviderError }) });
+        }
+      }
+      return errorView;
+    }
+    let logoComponent;
+    if (logo) {
+      logoComponent = /* @__PURE__ */ jsxRuntime.jsx("img", { src: logo, style: {
+        height: "100%",
+        width: "100%",
+        objectFit: "contain"
+      }, alt: "Logo" });
+    } else {
+      logoComponent = /* @__PURE__ */ jsxRuntime.jsx(core.RebaseLogo, {});
+    }
+    let notAllowedMessage;
+    if (notAllowedError) {
+      if (typeof notAllowedError === "string") {
+        notAllowedMessage = notAllowedError;
+      } else if (notAllowedError instanceof Error) {
+        notAllowedMessage = notAllowedError.message;
+      } else {
+        notAllowedMessage = "It looks like you don't have access to the CMS, based on the specified Authenticator configuration";
+      }
+    }
+    const fadeStyle = {
+      opacity: fadeIn ? 1 : 0,
+      transition: "opacity 0.6s ease-in-out"
+    };
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: ui.cls("flex flex-col items-center justify-center min-w-full p-4", className), style: fadeStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { id: "recaptcha" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col items-center w-full max-w-[500px]", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-1 w-64 h-64 m-4", children: logoComponent }),
+        children,
+        notAllowedMessage && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-8", children: /* @__PURE__ */ jsxRuntime.jsx(core.ErrorView, { error: notAllowedMessage }) }),
+        buildErrorView(),
+        !passwordLoginSelected && !phoneLoginSelected && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "my-4 w-full", children: [
+          buildOauthLoginButtons(authController, resolvedSignInOptions, modeState.mode, disabled),
+          resolvedSignInOptions.includes("password") && /* @__PURE__ */ jsxRuntime.jsx(LoginButton, { disabled, text: "Email/password", icon: /* @__PURE__ */ jsxRuntime.jsx(ui.MailIcon, { size: 28 }), onClick: () => setPasswordLoginSelected(true) }),
+          resolvedSignInOptions.includes("phone") && /* @__PURE__ */ jsxRuntime.jsx(LoginButton, { disabled, text: "Phone number", icon: /* @__PURE__ */ jsxRuntime.jsx(ui.CallIcon, { size: 28 }), onClick: () => setPhoneLoginSelected(true) }),
+          resolvedSignInOptions.includes("anonymous") && /* @__PURE__ */ jsxRuntime.jsx(LoginButton, { disabled, text: "Log in anonymously", icon: /* @__PURE__ */ jsxRuntime.jsx(ui.PersonIcon, { size: 28 }), onClick: authController.anonymousLogin }),
+          allowSkipLogin && /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { className: "m-1 mb-4", variant: "text", disabled, onClick: authController.skipLogin, children: "Skip login" })
+        ] }),
+        passwordLoginSelected && /* @__PURE__ */ jsxRuntime.jsx(LoginForm, { authController, onClose: () => setPasswordLoginSelected(false), mode: modeState.mode, noUserComponent, disableSignupScreen, disableResetPassword }),
+        phoneLoginSelected && /* @__PURE__ */ jsxRuntime.jsx(PhoneLoginForm, { authController, onClose: () => setPhoneLoginSelected(false) }),
+        !passwordLoginSelected && !phoneLoginSelected && additionalComponent
+      ] })
+    ] });
+  }
+  function LoginButton(t0) {
+    const $ = reactCompilerRuntime.c(15);
+    const {
+      icon,
+      onClick,
+      text,
+      disabled
+    } = t0;
+    const t1 = disabled ? "" : "hover:text-surface-800 hover:dark:text-white";
+    let t2;
+    if ($[0] !== t1) {
+      t2 = ui.cls("w-full bg-white dark:bg-surface-800 text-surface-900 dark:text-surface-100", t1);
+      $[0] = t1;
+      $[1] = t2;
+    } else {
+      t2 = $[1];
+    }
+    let t3;
+    if ($[2] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+      t3 = {
+        height: "40px",
+        borderRadius: "4px",
+        fontSize: "14px"
+      };
+      $[2] = t3;
+    } else {
+      t3 = $[2];
+    }
+    let t4;
+    if ($[3] !== icon) {
+      t4 = /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col w-8 items-center justify-items-center mr-4", children: icon });
+      $[3] = icon;
+      $[4] = t4;
+    } else {
+      t4 = $[4];
+    }
+    let t5;
+    if ($[5] !== text) {
+      t5 = /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grow pl-2 text-center", children: text });
+      $[5] = text;
+      $[6] = t5;
+    } else {
+      t5 = $[6];
+    }
+    let t6;
+    if ($[7] !== t4 || $[8] !== t5) {
+      t6 = /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-1 flex h-8 items-center justify-items-center", children: [
+        t4,
+        t5
+      ] });
+      $[7] = t4;
+      $[8] = t5;
+      $[9] = t6;
+    } else {
+      t6 = $[9];
+    }
+    let t7;
+    if ($[10] !== disabled || $[11] !== onClick || $[12] !== t2 || $[13] !== t6) {
+      t7 = /* @__PURE__ */ jsxRuntime.jsx("div", { className: "my-1 w-full", children: /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { className: t2, style: t3, disabled, onClick, children: t6 }) });
+      $[10] = disabled;
+      $[11] = onClick;
+      $[12] = t2;
+      $[13] = t6;
+      $[14] = t7;
+    } else {
+      t7 = $[14];
+    }
+    return t7;
+  }
+  function PhoneLoginForm(t0) {
+    const $ = reactCompilerRuntime.c(33);
+    const {
+      onClose,
+      authController
+    } = t0;
+    useRecaptcha();
+    const [phone, setPhone] = React.useState();
+    const [code, setCode] = React.useState();
+    const [isInvalidCode, setIsInvalidCode] = React.useState(false);
+    let t1;
+    if ($[0] !== authController || $[1] !== code || $[2] !== phone) {
+      t1 = async (event) => {
+        event.preventDefault();
+        if (code && authController.confirmationResult) {
+          setIsInvalidCode(false);
+          authController.confirmationResult.confirm(code).catch((e) => {
+            if (e.code === "auth/invalid-verification-code") {
+              setIsInvalidCode(true);
+            }
+          });
+        } else {
+          if (phone) {
+            authController.phoneLogin(phone, window.recaptchaVerifier);
+          }
+        }
+      };
+      $[0] = authController;
+      $[1] = code;
+      $[2] = phone;
+      $[3] = t1;
+    } else {
+      t1 = $[3];
+    }
+    const handleSubmit = t1;
+    let t2;
+    if ($[4] !== isInvalidCode) {
+      t2 = isInvalidCode && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-8", children: /* @__PURE__ */ jsxRuntime.jsx(core.ErrorView, { error: "Invalid confirmation code" }) });
+      $[4] = isInvalidCode;
+      $[5] = t2;
+    } else {
+      t2 = $[5];
+    }
+    let t3;
+    if ($[6] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+      t3 = /* @__PURE__ */ jsxRuntime.jsx("div", { id: RECAPTCHA_CONTAINER_ID });
+      $[6] = t3;
+    } else {
+      t3 = $[6];
+    }
+    let t4;
+    if ($[7] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+      t4 = /* @__PURE__ */ jsxRuntime.jsx(ui.ArrowBackIcon, { className: "w-5 h-5" });
+      $[7] = t4;
+    } else {
+      t4 = $[7];
+    }
+    let t5;
+    if ($[8] !== onClose) {
+      t5 = /* @__PURE__ */ jsxRuntime.jsx(ui.IconButton, { onClick: onClose, children: t4 });
+      $[8] = onClose;
+      $[9] = t5;
+    } else {
+      t5 = $[9];
+    }
+    let t6;
+    if ($[10] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+      t6 = /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-1 flex", children: /* @__PURE__ */ jsxRuntime.jsx(ui.Typography, { align: "center", variant: "subtitle2", children: "Please enter your phone number" }) });
+      $[10] = t6;
+    } else {
+      t6 = $[10];
+    }
+    const t7 = phone ?? "";
+    const t8 = Boolean(phone && (authController.authLoading || authController.confirmationResult));
+    let t9;
+    if ($[11] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+      t9 = (event_0) => setPhone(event_0.target.value);
+      $[11] = t9;
+    } else {
+      t9 = $[11];
+    }
+    let t10;
+    if ($[12] !== t7 || $[13] !== t8) {
+      t10 = /* @__PURE__ */ jsxRuntime.jsx(ui.TextField, { placeholder: "", value: t7, disabled: t8, type: "phone", onChange: t9 });
+      $[12] = t7;
+      $[13] = t8;
+      $[14] = t10;
+    } else {
+      t10 = $[14];
+    }
+    let t11;
+    if ($[15] !== authController.confirmationResult || $[16] !== code || $[17] !== phone) {
+      t11 = Boolean(phone && authController.confirmationResult) && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-2 p-1 flex", children: /* @__PURE__ */ jsxRuntime.jsx(ui.Typography, { align: "center", variant: "subtitle2", children: "Please enter the confirmation code" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(ui.TextField, { placeholder: "", value: code ?? "", type: "text", onChange: (event_1) => setCode(event_1.target.value) })
+      ] });
+      $[15] = authController.confirmationResult;
+      $[16] = code;
+      $[17] = phone;
+      $[18] = t11;
+    } else {
+      t11 = $[18];
+    }
+    let t12;
+    if ($[19] !== authController.authLoading) {
+      t12 = authController.authLoading && /* @__PURE__ */ jsxRuntime.jsx(ui.CircularProgress, { className: "p-1", size: "small" });
+      $[19] = authController.authLoading;
+      $[20] = t12;
+    } else {
+      t12 = $[20];
+    }
+    let t13;
+    if ($[21] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+      t13 = /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { type: "submit", children: "Ok" });
+      $[21] = t13;
+    } else {
+      t13 = $[21];
+    }
+    let t14;
+    if ($[22] !== t12) {
+      t14 = /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-end items-center w-full", children: [
+        t12,
+        t13
+      ] });
+      $[22] = t12;
+      $[23] = t14;
+    } else {
+      t14 = $[23];
+    }
+    let t15;
+    if ($[24] !== t10 || $[25] !== t11 || $[26] !== t14 || $[27] !== t5) {
+      t15 = /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1", children: [
+        t5,
+        t6,
+        t10,
+        t11,
+        t14
+      ] });
+      $[24] = t10;
+      $[25] = t11;
+      $[26] = t14;
+      $[27] = t5;
+      $[28] = t15;
+    } else {
+      t15 = $[28];
+    }
+    let t16;
+    if ($[29] !== handleSubmit || $[30] !== t15 || $[31] !== t2) {
+      t16 = /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, children: [
+        t2,
+        t3,
+        t15
+      ] });
+      $[29] = handleSubmit;
+      $[30] = t15;
+      $[31] = t2;
+      $[32] = t16;
+    } else {
+      t16 = $[32];
+    }
+    return t16;
+  }
+  function LoginForm({
+    onClose,
+    authController,
+    mode,
+    noUserComponent,
+    disableSignupScreen,
+    disableResetPassword
+  }) {
+    const passwordRef = React.useRef(null);
+    const [loginState, setLoginState] = React.useState("email");
+    const [email, setEmail] = React.useState();
+    const [password, setPassword] = React.useState();
+    const [previouslyUsedMethodsForUser, setPreviouslyUsedMethodsForUser] = React.useState();
+    const [resettingPassword, setResettingPassword] = React.useState(false);
+    const snackbarController = core.useSnackbarController();
+    React.useEffect(() => {
+      if ((loginState === "password" || loginState === "registration") && passwordRef.current) {
+        passwordRef.current.focus();
+      }
+    }, [loginState]);
+    React.useEffect(() => {
+      if (!document) return;
+      const escFunction = (event) => {
+        if (event.keyCode === 27) {
+          onClose();
+        }
+      };
+      document.addEventListener("keydown", escFunction, false);
+      return () => {
+        document.removeEventListener("keydown", escFunction, false);
+      };
+    }, [onClose]);
+    function handleEnterEmail() {
+      if (email) {
+        authController.fetchSignInMethodsForEmail(email).then((availableProviders) => {
+          setPreviouslyUsedMethodsForUser(availableProviders.filter((p) => p !== "password"));
+        });
+        setLoginState("password");
+      }
+    }
+    function handleEnterPassword() {
+      if (email && password) {
+        authController.emailPasswordLogin(email, password);
+      }
+    }
+    function handleRegistration() {
+      if (email && password) {
+        authController.createUserWithEmailAndPassword(email, password);
+      }
+    }
+    const onBackPressed = () => {
+      if (loginState === "email") {
+        onClose();
+      } else if (loginState === "password" || loginState === "registration") {
+        setLoginState("email");
+      } else {
+        setPreviouslyUsedMethodsForUser(void 0);
+      }
+    };
+    const handleSubmit = (event_0) => {
+      event_0.preventDefault();
+      if (loginState === "email") {
+        handleEnterEmail();
+      } else if (loginState === "password") {
+        handleEnterPassword();
+      } else if (loginState === "registration") {
+        handleRegistration();
+      }
+    };
+    const label = loginState === "registration" ? "Please enter your email and password to create an account" : loginState === "password" ? "Please enter your password" : "Please enter your email";
+    return /* @__PURE__ */ jsxRuntime.jsx("form", { className: "w-full", onSubmit: handleSubmit, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "max-w-[480px] w-full flex flex-col gap-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ui.IconButton, { onClick: onBackPressed, children: /* @__PURE__ */ jsxRuntime.jsx(ui.ArrowBackIcon, { className: "w-5 h-5" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { children: loginState === "registration" && noUserComponent }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Typography, { className: `${loginState === "registration" && disableSignupScreen ? "hidden" : "flex"}`, variant: "subtitle2", children: label }),
+      (loginState === "email" || loginState === "registration") && /* @__PURE__ */ jsxRuntime.jsx(ui.TextField, { placeholder: "Email", autoFocus: true, value: email ?? "", disabled: authController.authLoading, type: "email", onChange: (event_1) => setEmail(event_1.target.value) }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: `${loginState === "password" || loginState === "registration" && !disableSignupScreen ? "block" : "hidden"}`, children: /* @__PURE__ */ jsxRuntime.jsx(ui.TextField, { placeholder: "Password", value: password ?? "", disabled: authController.authLoading, inputRef: passwordRef, type: "password", onChange: (event_2) => setPassword(event_2.target.value) }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `${loginState === "registration" && disableSignupScreen ? "hidden" : "flex"} justify-end items-center w-full flex gap-2`, children: [
+        authController.authLoading && /* @__PURE__ */ jsxRuntime.jsx(ui.CircularProgress, { className: "p-1", size: "small" }),
+        !disableResetPassword && /* @__PURE__ */ jsxRuntime.jsx(ui.LoadingButton, { variant: "text", loading: resettingPassword, onClick: email ? async () => {
+          setResettingPassword(true);
+          try {
+            try {
+              await authController.sendPasswordResetEmail(email);
+              snackbarController.open({
+                message: "Password reset email sent",
+                type: "success"
+              });
+            } catch (e) {
+              snackbarController.open({
+                message: e.message,
+                type: "error"
+              });
+            }
+          } finally {
+            setResettingPassword(false);
+          }
+        } : void 0, children: "Reset password" }),
+        !disableSignupScreen && loginState === "email" && /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { variant: "text", onClick: () => setLoginState("registration"), children: "New user" }),
+        /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { type: "submit", children: loginState === "registration" ? "Create account" : loginState === "password" ? "Login" : "Login" })
+      ] }),
+      previouslyUsedMethodsForUser && previouslyUsedMethodsForUser.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-4 p-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ui.Typography, { variant: "subtitle2", children: "You already have an account" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Typography, { variant: "body2", children: [
+            "You can use one of these methods to login with ",
+            email
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { children: previouslyUsedMethodsForUser && buildOauthLoginButtons(authController, previouslyUsedMethodsForUser, mode, false) })
+      ] })
+    ] }) });
+  }
+  function buildOauthLoginButtons(authController, providers, mode, disabled) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      providers.includes("google.com") && /* @__PURE__ */ jsxRuntime.jsx(LoginButton, { disabled, text: "Sign in with Google", icon: googleIcon(), onClick: authController.googleLogin }),
+      providers.includes("microsoft.com") && /* @__PURE__ */ jsxRuntime.jsx(LoginButton, { disabled, text: "Sign in with Microsoft", icon: microsoftIcon(mode), onClick: authController.microsoftLogin }),
+      providers.includes("apple.com") && /* @__PURE__ */ jsxRuntime.jsx(LoginButton, { disabled, text: "Sign in with Apple", icon: appleIcon(mode), onClick: authController.appleLogin }),
+      providers.includes("github.com") && /* @__PURE__ */ jsxRuntime.jsx(LoginButton, { disabled, text: "Sign in with Github", icon: githubIcon(mode), onClick: authController.githubLogin }),
+      providers.includes("facebook.com") && /* @__PURE__ */ jsxRuntime.jsx(LoginButton, { disabled, text: "Sign in with Facebook", icon: facebookIcon(mode), onClick: authController.facebookLogin }),
+      providers.includes("twitter.com") && /* @__PURE__ */ jsxRuntime.jsx(LoginButton, { disabled, text: "Sign in with Twitter", icon: twitterIcon(mode), onClick: authController.twitterLogin })
+    ] });
+  }
+  const DEFAULT_SIGN_IN_OPTIONS = [auth.GoogleAuthProvider.PROVIDER_ID];
+  function RebaseFirebaseApp(t0) {
+    const $ = reactCompilerRuntime.c(93);
+    const {
+      name,
+      logo,
+      logoDark,
+      authenticator,
+      collections,
+      views,
+      adminViews,
+      textSearchControllerBuilder,
+      allowSkipLogin,
+      signInOptions: t1,
+      firebaseConfig,
+      onFirebaseInit,
+      appCheckOptions,
+      dateTimeFormat,
+      locale,
+      basePath,
+      baseCollectionPath,
+      onAnalyticsEvent,
+      propertyConfigs: propertyConfigsProp,
+      plugins,
+      autoOpenDrawer,
+      firestoreIndexesBuilder,
+      components,
+      localTextSearchEnabled: t2,
+      userManagement
+    } = t0;
+    const signInOptions = t1 === void 0 ? DEFAULT_SIGN_IN_OPTIONS : t1;
+    const localTextSearchEnabled = t2 === void 0 ? false : t2;
+    core.useBrowserTitleAndIcon(name, logo);
+    let t3;
+    if ($[0] !== propertyConfigsProp) {
+      t3 = propertyConfigsProp ?? [];
+      $[0] = propertyConfigsProp;
+      $[1] = t3;
+    } else {
+      t3 = $[1];
+    }
+    let t4;
+    if ($[2] !== t3) {
+      t4 = t3.map(_temp).reduce(_temp2, {});
+      $[2] = t3;
+      $[3] = t4;
+    } else {
+      t4 = $[3];
+    }
+    const propertyConfigs = t4;
+    let t5;
+    if ($[4] !== firebaseConfig || $[5] !== onFirebaseInit) {
+      t5 = {
+        onFirebaseInit,
+        firebaseConfig
+      };
+      $[4] = firebaseConfig;
+      $[5] = onFirebaseInit;
+      $[6] = t5;
+    } else {
+      t5 = $[6];
+    }
+    const {
+      firebaseApp,
+      firebaseConfigLoading,
+      configError
+    } = useInitialiseFirebase(t5);
+    const modeController = core.useBuildModeController();
+    const adminModeController = core.useBuildAdminModeController();
+    let t6;
+    if ($[7] !== appCheckOptions || $[8] !== firebaseApp) {
+      t6 = {
+        firebaseApp,
+        options: appCheckOptions
+      };
+      $[7] = appCheckOptions;
+      $[8] = firebaseApp;
+      $[9] = t6;
+    } else {
+      t6 = $[9];
+    }
+    const {
+      loading
+    } = useAppCheck(t6);
+    let t7;
+    if ($[10] !== firebaseApp || $[11] !== signInOptions) {
+      t7 = {
+        firebaseApp,
+        signInOptions
+      };
+      $[10] = firebaseApp;
+      $[11] = signInOptions;
+      $[12] = t7;
+    } else {
+      t7 = $[12];
+    }
+    const authController = useFirebaseAuthController(t7);
+    const userConfigPersistence = core.useBuildLocalConfigurationPersistence();
+    let t8;
+    if ($[13] !== firebaseApp || $[14] !== firestoreIndexesBuilder || $[15] !== localTextSearchEnabled || $[16] !== textSearchControllerBuilder) {
+      t8 = {
+        firebaseApp,
+        textSearchControllerBuilder,
+        firestoreIndexesBuilder,
+        localTextSearchEnabled
+      };
+      $[13] = firebaseApp;
+      $[14] = firestoreIndexesBuilder;
+      $[15] = localTextSearchEnabled;
+      $[16] = textSearchControllerBuilder;
+      $[17] = t8;
+    } else {
+      t8 = $[17];
+    }
+    const firestoreDelegate = useFirestoreDriver(t8);
+    let t9;
+    if ($[18] !== firebaseApp) {
+      t9 = {
+        firebaseApp
+      };
+      $[18] = firebaseApp;
+      $[19] = t9;
+    } else {
+      t9 = $[19];
+    }
+    const storageSource = useFirebaseStorageSource(t9);
+    let t10;
+    if ($[20] !== firestoreDelegate) {
+      t10 = common.buildRebaseData(firestoreDelegate);
+      $[20] = firestoreDelegate;
+      $[21] = t10;
+    } else {
+      t10 = $[21];
+    }
+    let t11;
+    if ($[22] !== authController || $[23] !== authenticator || $[24] !== storageSource || $[25] !== t10) {
+      t11 = {
+        authController,
+        authenticator,
+        data: t10,
+        storageSource
+      };
+      $[22] = authController;
+      $[23] = authenticator;
+      $[24] = storageSource;
+      $[25] = t10;
+      $[26] = t11;
+    } else {
+      t11 = $[26];
+    }
+    const {
+      authLoading,
+      canAccessMainView,
+      notAllowedError
+    } = core.useValidateAuthenticator(t11);
+    let t12;
+    if ($[27] !== userConfigPersistence) {
+      t12 = {
+        userConfigPersistence
+      };
+      $[27] = userConfigPersistence;
+      $[28] = t12;
+    } else {
+      t12 = $[28];
+    }
+    const collectionRegistryController = cms.useBuildCollectionRegistryController(t12);
+    const t13 = basePath ?? "/";
+    const t14 = baseCollectionPath ?? "/c";
+    let t15;
+    if ($[29] !== collectionRegistryController || $[30] !== t13 || $[31] !== t14) {
+      t15 = {
+        basePath: t13,
+        baseCollectionPath: t14,
+        collectionRegistryController
+      };
+      $[29] = collectionRegistryController;
+      $[30] = t13;
+      $[31] = t14;
+      $[32] = t15;
+    } else {
+      t15 = $[32];
+    }
+    const urlController = cms.useBuildUrlController(t15);
+    let t16;
+    if ($[33] !== firestoreDelegate) {
+      t16 = common.buildRebaseData(firestoreDelegate);
+      $[33] = firestoreDelegate;
+      $[34] = t16;
+    } else {
+      t16 = $[34];
+    }
+    let t17;
+    if ($[35] !== adminModeController.mode || $[36] !== adminViews || $[37] !== authController || $[38] !== collectionRegistryController || $[39] !== collections || $[40] !== plugins || $[41] !== t16 || $[42] !== urlController || $[43] !== userManagement || $[44] !== views) {
+      t17 = {
+        collections,
+        views,
+        adminViews,
+        authController,
+        data: t16,
+        plugins,
+        collectionRegistryController,
+        urlController,
+        adminMode: adminModeController.mode,
+        userManagement
+      };
+      $[35] = adminModeController.mode;
+      $[36] = adminViews;
+      $[37] = authController;
+      $[38] = collectionRegistryController;
+      $[39] = collections;
+      $[40] = plugins;
+      $[41] = t16;
+      $[42] = urlController;
+      $[43] = userManagement;
+      $[44] = views;
+      $[45] = t17;
+    } else {
+      t17 = $[45];
+    }
+    const navigationStateController = cms.useBuildNavigationStateController(t17);
+    if (firebaseConfigLoading || !firebaseApp || loading) {
+      let t182;
+      if ($[46] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+        t182 = /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(ui.CircularProgressCenter, {}) });
+        $[46] = t182;
+      } else {
+        t182 = $[46];
+      }
+      return t182;
+    }
+    if (configError) {
+      let t182;
+      if ($[47] !== configError) {
+        t182 = /* @__PURE__ */ jsxRuntime.jsx(ui.CenteredView, { children: configError });
+        $[47] = configError;
+        $[48] = t182;
+      } else {
+        t182 = $[48];
+      }
+      return t182;
+    }
+    let t18;
+    if ($[49] !== firebaseApp.options.projectId) {
+      t18 = (t192) => {
+        const {
+          entity
+        } = t192;
+        return `https://console.firebase.google.com/project/${firebaseApp.options.projectId}/firestore/data/${entity.path}/${entity.id}`;
+      };
+      $[49] = firebaseApp.options.projectId;
+      $[50] = t18;
+    } else {
+      t18 = $[50];
+    }
+    let t19;
+    if ($[51] !== allowSkipLogin || $[52] !== authController || $[53] !== authLoading || $[54] !== autoOpenDrawer || $[55] !== canAccessMainView || $[56] !== components || $[57] !== firebaseApp || $[58] !== logo || $[59] !== logoDark || $[60] !== modeController || $[61] !== name || $[62] !== notAllowedError || $[63] !== signInOptions) {
+      t19 = (t202) => {
+        const {
+          loading: loading_0
+        } = t202;
+        let component;
+        if (loading_0 || authLoading) {
+          component = /* @__PURE__ */ jsxRuntime.jsx(ui.CircularProgressCenter, { size: "large" });
+        } else {
+          const usedLogo = modeController.mode === "dark" && logoDark ? logoDark : logo;
+          if (!canAccessMainView) {
+            const LoginViewUsed = components?.LoginView ?? FirebaseLoginView;
+            component = /* @__PURE__ */ jsxRuntime.jsx(LoginViewUsed, { logo: usedLogo, allowSkipLogin, signInOptions: signInOptions ?? DEFAULT_SIGN_IN_OPTIONS, firebaseApp, authController, notAllowedError });
+          } else {
+            component = /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Routes, { children: /* @__PURE__ */ jsxRuntime.jsxs(reactRouterDom.Route, { element: /* @__PURE__ */ jsxRuntime.jsxs(cms.Scaffold, { logo: usedLogo, autoOpenDrawer, children: [
+              /* @__PURE__ */ jsxRuntime.jsx(cms.AppBar, { title: name, logo: usedLogo }),
+              /* @__PURE__ */ jsxRuntime.jsx(cms.Drawer, {}),
+              /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Outlet, {}),
+              /* @__PURE__ */ jsxRuntime.jsx(cms.SideDialogs, {})
+            ] }), children: [
+              components?.HomePage && /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Route, { path: "/", element: /* @__PURE__ */ jsxRuntime.jsx(components.HomePage, {}) }),
+              /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Route, { path: "/c/*", element: /* @__PURE__ */ jsxRuntime.jsx(core.RebaseRoutes, {}) })
+            ] }) });
+          }
+        }
+        return component;
+      };
+      $[51] = allowSkipLogin;
+      $[52] = authController;
+      $[53] = authLoading;
+      $[54] = autoOpenDrawer;
+      $[55] = canAccessMainView;
+      $[56] = components;
+      $[57] = firebaseApp;
+      $[58] = logo;
+      $[59] = logoDark;
+      $[60] = modeController;
+      $[61] = name;
+      $[62] = notAllowedError;
+      $[63] = signInOptions;
+      $[64] = t19;
+    } else {
+      t19 = $[64];
+    }
+    let t20;
+    if ($[65] !== authController || $[66] !== dateTimeFormat || $[67] !== firestoreDelegate || $[68] !== locale || $[69] !== onAnalyticsEvent || $[70] !== plugins || $[71] !== propertyConfigs || $[72] !== storageSource || $[73] !== t18 || $[74] !== t19 || $[75] !== userConfigPersistence || $[76] !== userManagement) {
+      t20 = /* @__PURE__ */ jsxRuntime.jsx(core.Rebase, { authController, userConfigPersistence, dateTimeFormat, driver: firestoreDelegate, storageSource, userManagement, entityLinkBuilder: t18, locale, onAnalyticsEvent, plugins, propertyConfigs, children: t19 });
+      $[65] = authController;
+      $[66] = dateTimeFormat;
+      $[67] = firestoreDelegate;
+      $[68] = locale;
+      $[69] = onAnalyticsEvent;
+      $[70] = plugins;
+      $[71] = propertyConfigs;
+      $[72] = storageSource;
+      $[73] = t18;
+      $[74] = t19;
+      $[75] = userConfigPersistence;
+      $[76] = userManagement;
+      $[77] = t20;
+    } else {
+      t20 = $[77];
+    }
+    let t21;
+    if ($[78] !== navigationStateController || $[79] !== t20) {
+      t21 = /* @__PURE__ */ jsxRuntime.jsx(cms.NavigationStateContext.Provider, { value: navigationStateController, children: t20 });
+      $[78] = navigationStateController;
+      $[79] = t20;
+      $[80] = t21;
+    } else {
+      t21 = $[80];
+    }
+    let t22;
+    if ($[81] !== t21 || $[82] !== urlController) {
+      t22 = /* @__PURE__ */ jsxRuntime.jsx(cms.UrlContext.Provider, { value: urlController, children: t21 });
+      $[81] = t21;
+      $[82] = urlController;
+      $[83] = t22;
+    } else {
+      t22 = $[83];
+    }
+    let t23;
+    if ($[84] !== collectionRegistryController || $[85] !== t22) {
+      t23 = /* @__PURE__ */ jsxRuntime.jsx(cms.CollectionRegistryContext.Provider, { value: collectionRegistryController, children: t22 });
+      $[84] = collectionRegistryController;
+      $[85] = t22;
+      $[86] = t23;
+    } else {
+      t23 = $[86];
+    }
+    let t24;
+    if ($[87] !== adminModeController || $[88] !== t23) {
+      t24 = /* @__PURE__ */ jsxRuntime.jsx(core.AdminModeControllerProvider, { value: adminModeController, children: t23 });
+      $[87] = adminModeController;
+      $[88] = t23;
+      $[89] = t24;
+    } else {
+      t24 = $[89];
+    }
+    let t25;
+    if ($[90] !== modeController || $[91] !== t24) {
+      t25 = /* @__PURE__ */ jsxRuntime.jsx(core.SnackbarProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(core.ModeControllerProvider, { value: modeController, children: t24 }) });
+      $[90] = modeController;
+      $[91] = t24;
+      $[92] = t25;
+    } else {
+      t25 = $[92];
+    }
+    return t25;
+  }
+  function _temp2(a, b) {
+    return {
+      ...a,
+      ...b
+    };
+  }
+  function _temp(pc) {
+    return {
+      [pc.key]: pc
+    };
+  }
+  exports2.FirebaseLoginView = FirebaseLoginView;
+  exports2.LoginButton = LoginButton;
+  exports2.RECAPTCHA_CONTAINER_ID = RECAPTCHA_CONTAINER_ID;
+  exports2.RebaseFirebaseApp = RebaseFirebaseApp;
+  exports2.buildCollectionId = buildCollectionId;
+  exports2.buildExternalSearchController = buildExternalSearchController;
+  exports2.buildPineconeSearchController = buildPineconeSearchController;
+  exports2.buildRebaseSearchController = buildRebaseSearchController;
+  exports2.cmsToFirestoreModel = cmsToFirestoreModel;
+  exports2.docToCollection = docToCollection;
+  exports2.docsToCollectionTree = docsToCollectionTree;
+  exports2.firestoreToCMSModel = firestoreToCMSModel;
+  exports2.getFirestoreDataInPath = getFirestoreDataInPath;
+  exports2.localSearchControllerBuilder = localSearchControllerBuilder;
+  exports2.performAlgoliaTextSearch = performAlgoliaTextSearch;
+  exports2.performPineconeTextSearch = performPineconeTextSearch;
+  exports2.useAppCheck = useAppCheck;
+  exports2.useFirebaseAuthController = useFirebaseAuthController;
+  exports2.useFirebaseRTDBDelegate = useFirebaseRTDBDelegate;
+  exports2.useFirebaseStorageSource = useFirebaseStorageSource;
+  exports2.useFirestoreDriver = useFirestoreDriver;
+  exports2.useInitialiseFirebase = useInitialiseFirebase;
+  exports2.useRecaptcha = useRecaptcha;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+}));
+//# sourceMappingURL=index.umd.js.map