@absolutejs/auth 0.36.0 → 0.38.0

package/dist/client/react.js

@@ -1,8 +1,563 @@
 // @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// node_modules/@simplewebauthn/browser/esm/helpers/bufferToBase64URLString.js
+function bufferToBase64URLString(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let str = "";
+  for (const charCode of bytes) {
+    str += String.fromCharCode(charCode);
+  }
+  const base64String = btoa(str);
+  return base64String.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/base64URLStringToBuffer.js
+function base64URLStringToBuffer(base64URLString) {
+  const base64 = base64URLString.replace(/-/g, "+").replace(/_/g, "/");
+  const padLength = (4 - base64.length % 4) % 4;
+  const padded = base64.padEnd(base64.length + padLength, "=");
+  const binary = atob(padded);
+  const buffer = new ArrayBuffer(binary.length);
+  const bytes = new Uint8Array(buffer);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return buffer;
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/browserSupportsWebAuthn.js
+function browserSupportsWebAuthn() {
+  return _browserSupportsWebAuthnInternals.stubThis(globalThis?.PublicKeyCredential !== undefined && typeof globalThis.PublicKeyCredential === "function");
+}
+var _browserSupportsWebAuthnInternals;
+var init_browserSupportsWebAuthn = __esm(() => {
+  _browserSupportsWebAuthnInternals = {
+    stubThis: (value) => value
+  };
+});
+
+// node_modules/@simplewebauthn/browser/esm/helpers/toPublicKeyCredentialDescriptor.js
+function toPublicKeyCredentialDescriptor(descriptor) {
+  const { id } = descriptor;
+  return {
+    ...descriptor,
+    id: base64URLStringToBuffer(id),
+    transports: descriptor.transports
+  };
+}
+var init_toPublicKeyCredentialDescriptor = () => {};
+
+// node_modules/@simplewebauthn/browser/esm/helpers/isValidDomain.js
+function isValidDomain(hostname) {
+  return hostname === "localhost" || /^((xn--[a-z0-9-]+|[a-z0-9]+(-[a-z0-9]+)*)\.)+([a-z]{2,}|xn--[a-z0-9-]+)$/i.test(hostname);
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/webAuthnError.js
+var WebAuthnError;
+var init_webAuthnError = __esm(() => {
+  WebAuthnError = class WebAuthnError extends Error {
+    constructor({ message, code, cause, name }) {
+      super(message, { cause });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.name = name ?? cause.name;
+      this.code = code;
+    }
+  };
+});
+
+// node_modules/@simplewebauthn/browser/esm/helpers/identifyRegistrationError.js
+function identifyRegistrationError({ error, options }) {
+  const { publicKey } = options;
+  if (!publicKey) {
+    throw Error("options was missing required publicKey property");
+  }
+  if (error.name === "AbortError") {
+    if (options.signal instanceof AbortSignal) {
+      return new WebAuthnError({
+        message: "Registration ceremony was sent an abort signal",
+        code: "ERROR_CEREMONY_ABORTED",
+        cause: error
+      });
+    }
+  } else if (error.name === "ConstraintError") {
+    if (publicKey.authenticatorSelection?.requireResidentKey === true) {
+      return new WebAuthnError({
+        message: "Discoverable credentials were required but no available authenticator supported it",
+        code: "ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT",
+        cause: error
+      });
+    } else if (options.mediation === "conditional" && publicKey.authenticatorSelection?.userVerification === "required") {
+      return new WebAuthnError({
+        message: "User verification was required during automatic registration but it could not be performed",
+        code: "ERROR_AUTO_REGISTER_USER_VERIFICATION_FAILURE",
+        cause: error
+      });
+    } else if (publicKey.authenticatorSelection?.userVerification === "required") {
+      return new WebAuthnError({
+        message: "User verification was required but no available authenticator supported it",
+        code: "ERROR_AUTHENTICATOR_MISSING_USER_VERIFICATION_SUPPORT",
+        cause: error
+      });
+    }
+  } else if (error.name === "InvalidStateError") {
+    return new WebAuthnError({
+      message: "The authenticator was previously registered",
+      code: "ERROR_AUTHENTICATOR_PREVIOUSLY_REGISTERED",
+      cause: error
+    });
+  } else if (error.name === "NotAllowedError") {
+    return new WebAuthnError({
+      message: error.message,
+      code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY",
+      cause: error
+    });
+  } else if (error.name === "NotSupportedError") {
+    const validPubKeyCredParams = publicKey.pubKeyCredParams.filter((param) => param.type === "public-key");
+    if (validPubKeyCredParams.length === 0) {
+      return new WebAuthnError({
+        message: 'No entry in pubKeyCredParams was of type "public-key"',
+        code: "ERROR_MALFORMED_PUBKEYCREDPARAMS",
+        cause: error
+      });
+    }
+    return new WebAuthnError({
+      message: "No available authenticator supported any of the specified pubKeyCredParams algorithms",
+      code: "ERROR_AUTHENTICATOR_NO_SUPPORTED_PUBKEYCREDPARAMS_ALG",
+      cause: error
+    });
+  } else if (error.name === "SecurityError") {
+    const effectiveDomain = globalThis.location.hostname;
+    if (!isValidDomain(effectiveDomain)) {
+      return new WebAuthnError({
+        message: `${globalThis.location.hostname} is an invalid domain`,
+        code: "ERROR_INVALID_DOMAIN",
+        cause: error
+      });
+    } else if (publicKey.rp.id !== effectiveDomain) {
+      return new WebAuthnError({
+        message: `The RP ID "${publicKey.rp.id}" is invalid for this domain`,
+        code: "ERROR_INVALID_RP_ID",
+        cause: error
+      });
+    }
+  } else if (error.name === "TypeError") {
+    if (publicKey.user.id.byteLength < 1 || publicKey.user.id.byteLength > 64) {
+      return new WebAuthnError({
+        message: "User ID was not between 1 and 64 characters",
+        code: "ERROR_INVALID_USER_ID_LENGTH",
+        cause: error
+      });
+    }
+  } else if (error.name === "UnknownError") {
+    return new WebAuthnError({
+      message: "The authenticator was unable to process the specified options, or could not create a new credential",
+      code: "ERROR_AUTHENTICATOR_GENERAL_ERROR",
+      cause: error
+    });
+  }
+  return error;
+}
+var init_identifyRegistrationError = __esm(() => {
+  init_webAuthnError();
+});
+
+// node_modules/@simplewebauthn/browser/esm/helpers/webAuthnAbortService.js
+class BaseWebAuthnAbortService {
+  constructor() {
+    Object.defineProperty(this, "controller", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+  }
+  createNewAbortSignal() {
+    if (this.controller) {
+      const abortError = new Error("Cancelling existing WebAuthn API call for new one");
+      abortError.name = "AbortError";
+      this.controller.abort(abortError);
+    }
+    const newController = new AbortController;
+    this.controller = newController;
+    return newController.signal;
+  }
+  cancelCeremony() {
+    if (this.controller) {
+      const abortError = new Error("Manually cancelling existing WebAuthn API call");
+      abortError.name = "AbortError";
+      this.controller.abort(abortError);
+      this.controller = undefined;
+    }
+  }
+}
+var WebAuthnAbortService;
+var init_webAuthnAbortService = __esm(() => {
+  WebAuthnAbortService = new BaseWebAuthnAbortService;
+});
+
+// node_modules/@simplewebauthn/browser/esm/helpers/toAuthenticatorAttachment.js
+function toAuthenticatorAttachment(attachment) {
+  if (!attachment) {
+    return;
+  }
+  if (attachments.indexOf(attachment) < 0) {
+    return;
+  }
+  return attachment;
+}
+var attachments;
+var init_toAuthenticatorAttachment = __esm(() => {
+  attachments = ["cross-platform", "platform"];
+});
+
+// node_modules/@simplewebauthn/browser/esm/methods/startRegistration.js
+async function startRegistration(options) {
+  if (!options.optionsJSON && options.challenge) {
+    console.warn("startRegistration() was not called correctly. It will try to continue with the provided options, but this call should be refactored to use the expected call structure instead. See https://simplewebauthn.dev/docs/packages/browser#typeerror-cannot-read-properties-of-undefined-reading-challenge for more information.");
+    options = { optionsJSON: options };
+  }
+  const { optionsJSON, useAutoRegister = false } = options;
+  if (!browserSupportsWebAuthn()) {
+    throw new Error("WebAuthn is not supported in this browser");
+  }
+  const publicKey = {
+    ...optionsJSON,
+    challenge: base64URLStringToBuffer(optionsJSON.challenge),
+    user: {
+      ...optionsJSON.user,
+      id: base64URLStringToBuffer(optionsJSON.user.id)
+    },
+    excludeCredentials: optionsJSON.excludeCredentials?.map(toPublicKeyCredentialDescriptor)
+  };
+  const createOptions = {};
+  if (useAutoRegister) {
+    createOptions.mediation = "conditional";
+  }
+  createOptions.publicKey = publicKey;
+  createOptions.signal = WebAuthnAbortService.createNewAbortSignal();
+  let credential;
+  try {
+    credential = await navigator.credentials.create(createOptions);
+  } catch (err) {
+    throw identifyRegistrationError({ error: err, options: createOptions });
+  }
+  if (!credential) {
+    throw new Error("Registration was not completed");
+  }
+  const { id, rawId, response, type } = credential;
+  let transports = undefined;
+  if (typeof response.getTransports === "function") {
+    transports = response.getTransports();
+  }
+  let responsePublicKeyAlgorithm = undefined;
+  if (typeof response.getPublicKeyAlgorithm === "function") {
+    try {
+      responsePublicKeyAlgorithm = response.getPublicKeyAlgorithm();
+    } catch (error) {
+      warnOnBrokenImplementation("getPublicKeyAlgorithm()", error);
+    }
+  }
+  let responsePublicKey = undefined;
+  if (typeof response.getPublicKey === "function") {
+    try {
+      const _publicKey = response.getPublicKey();
+      if (_publicKey !== null) {
+        responsePublicKey = bufferToBase64URLString(_publicKey);
+      }
+    } catch (error) {
+      warnOnBrokenImplementation("getPublicKey()", error);
+    }
+  }
+  let responseAuthenticatorData;
+  if (typeof response.getAuthenticatorData === "function") {
+    try {
+      responseAuthenticatorData = bufferToBase64URLString(response.getAuthenticatorData());
+    } catch (error) {
+      warnOnBrokenImplementation("getAuthenticatorData()", error);
+    }
+  }
+  return {
+    id,
+    rawId: bufferToBase64URLString(rawId),
+    response: {
+      attestationObject: bufferToBase64URLString(response.attestationObject),
+      clientDataJSON: bufferToBase64URLString(response.clientDataJSON),
+      transports,
+      publicKeyAlgorithm: responsePublicKeyAlgorithm,
+      publicKey: responsePublicKey,
+      authenticatorData: responseAuthenticatorData
+    },
+    type,
+    clientExtensionResults: credential.getClientExtensionResults(),
+    authenticatorAttachment: toAuthenticatorAttachment(credential.authenticatorAttachment)
+  };
+}
+function warnOnBrokenImplementation(methodName, cause) {
+  console.warn(`The browser extension that intercepted this WebAuthn API call incorrectly implemented ${methodName}. You should report this error to them.
+`, cause);
+}
+var init_startRegistration = __esm(() => {
+  init_browserSupportsWebAuthn();
+  init_toPublicKeyCredentialDescriptor();
+  init_identifyRegistrationError();
+  init_webAuthnAbortService();
+  init_toAuthenticatorAttachment();
+});
+
+// node_modules/@simplewebauthn/browser/esm/helpers/browserSupportsWebAuthnAutofill.js
+function browserSupportsWebAuthnAutofill() {
+  if (!browserSupportsWebAuthn()) {
+    return _browserSupportsWebAuthnAutofillInternals.stubThis(new Promise((resolve) => resolve(false)));
+  }
+  const globalPublicKeyCredential = globalThis.PublicKeyCredential;
+  if (globalPublicKeyCredential?.isConditionalMediationAvailable === undefined) {
+    return _browserSupportsWebAuthnAutofillInternals.stubThis(new Promise((resolve) => resolve(false)));
+  }
+  return _browserSupportsWebAuthnAutofillInternals.stubThis(globalPublicKeyCredential.isConditionalMediationAvailable());
+}
+var _browserSupportsWebAuthnAutofillInternals;
+var init_browserSupportsWebAuthnAutofill = __esm(() => {
+  init_browserSupportsWebAuthn();
+  _browserSupportsWebAuthnAutofillInternals = {
+    stubThis: (value) => value
+  };
+});
+
+// node_modules/@simplewebauthn/browser/esm/helpers/identifyAuthenticationError.js
+function identifyAuthenticationError({ error, options }) {
+  const { publicKey } = options;
+  if (!publicKey) {
+    throw Error("options was missing required publicKey property");
+  }
+  if (error.name === "AbortError") {
+    if (options.signal instanceof AbortSignal) {
+      return new WebAuthnError({
+        message: "Authentication ceremony was sent an abort signal",
+        code: "ERROR_CEREMONY_ABORTED",
+        cause: error
+      });
+    }
+  } else if (error.name === "NotAllowedError") {
+    return new WebAuthnError({
+      message: error.message,
+      code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY",
+      cause: error
+    });
+  } else if (error.name === "SecurityError") {
+    const effectiveDomain = globalThis.location.hostname;
+    if (!isValidDomain(effectiveDomain)) {
+      return new WebAuthnError({
+        message: `${globalThis.location.hostname} is an invalid domain`,
+        code: "ERROR_INVALID_DOMAIN",
+        cause: error
+      });
+    } else if (publicKey.rpId !== effectiveDomain) {
+      return new WebAuthnError({
+        message: `The RP ID "${publicKey.rpId}" is invalid for this domain`,
+        code: "ERROR_INVALID_RP_ID",
+        cause: error
+      });
+    }
+  } else if (error.name === "UnknownError") {
+    return new WebAuthnError({
+      message: "The authenticator was unable to process the specified options, or could not create a new assertion signature",
+      code: "ERROR_AUTHENTICATOR_GENERAL_ERROR",
+      cause: error
+    });
+  }
+  return error;
+}
+var init_identifyAuthenticationError = __esm(() => {
+  init_webAuthnError();
+});
+
+// node_modules/@simplewebauthn/browser/esm/methods/startAuthentication.js
+async function startAuthentication(options) {
+  if (!options.optionsJSON && options.challenge) {
+    console.warn("startAuthentication() was not called correctly. It will try to continue with the provided options, but this call should be refactored to use the expected call structure instead. See https://simplewebauthn.dev/docs/packages/browser#typeerror-cannot-read-properties-of-undefined-reading-challenge for more information.");
+    options = { optionsJSON: options };
+  }
+  const { optionsJSON, useBrowserAutofill = false, verifyBrowserAutofillInput = true } = options;
+  if (!browserSupportsWebAuthn()) {
+    throw new Error("WebAuthn is not supported in this browser");
+  }
+  let allowCredentials;
+  if (optionsJSON.allowCredentials?.length !== 0) {
+    allowCredentials = optionsJSON.allowCredentials?.map(toPublicKeyCredentialDescriptor);
+  }
+  const publicKey = {
+    ...optionsJSON,
+    challenge: base64URLStringToBuffer(optionsJSON.challenge),
+    allowCredentials
+  };
+  const getOptions = {};
+  if (useBrowserAutofill) {
+    if (!await browserSupportsWebAuthnAutofill()) {
+      throw Error("Browser does not support WebAuthn autofill");
+    }
+    const eligibleInputs = document.querySelectorAll("input[autocomplete$='webauthn']");
+    if (eligibleInputs.length < 1 && verifyBrowserAutofillInput) {
+      throw Error('No <input> with "webauthn" as the only or last value in its `autocomplete` attribute was detected');
+    }
+    getOptions.mediation = "conditional";
+    publicKey.allowCredentials = [];
+  }
+  getOptions.publicKey = publicKey;
+  getOptions.signal = WebAuthnAbortService.createNewAbortSignal();
+  let credential;
+  try {
+    credential = await navigator.credentials.get(getOptions);
+  } catch (err) {
+    throw identifyAuthenticationError({ error: err, options: getOptions });
+  }
+  if (!credential) {
+    throw new Error("Authentication was not completed");
+  }
+  const { id, rawId, response, type } = credential;
+  let userHandle = undefined;
+  if (response.userHandle) {
+    userHandle = bufferToBase64URLString(response.userHandle);
+  }
+  return {
+    id,
+    rawId: bufferToBase64URLString(rawId),
+    response: {
+      authenticatorData: bufferToBase64URLString(response.authenticatorData),
+      clientDataJSON: bufferToBase64URLString(response.clientDataJSON),
+      signature: bufferToBase64URLString(response.signature),
+      userHandle
+    },
+    type,
+    clientExtensionResults: credential.getClientExtensionResults(),
+    authenticatorAttachment: toAuthenticatorAttachment(credential.authenticatorAttachment)
+  };
+}
+var init_startAuthentication = __esm(() => {
+  init_browserSupportsWebAuthn();
+  init_browserSupportsWebAuthnAutofill();
+  init_toPublicKeyCredentialDescriptor();
+  init_identifyAuthenticationError();
+  init_webAuthnAbortService();
+  init_toAuthenticatorAttachment();
+});
+
+// node_modules/@simplewebauthn/browser/esm/helpers/platformAuthenticatorIsAvailable.js
+function platformAuthenticatorIsAvailable() {
+  if (!browserSupportsWebAuthn()) {
+    return new Promise((resolve) => resolve(false));
+  }
+  return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
+}
+var init_platformAuthenticatorIsAvailable = __esm(() => {
+  init_browserSupportsWebAuthn();
+});
+
+// node_modules/@simplewebauthn/browser/esm/types/index.js
+var init_types = () => {};
+
+// node_modules/@simplewebauthn/browser/esm/index.js
+var exports_esm = {};
+__export(exports_esm, {
+  startRegistration: () => startRegistration,
+  startAuthentication: () => startAuthentication,
+  platformAuthenticatorIsAvailable: () => platformAuthenticatorIsAvailable,
+  bufferToBase64URLString: () => bufferToBase64URLString,
+  browserSupportsWebAuthnAutofill: () => browserSupportsWebAuthnAutofill,
+  browserSupportsWebAuthn: () => browserSupportsWebAuthn,
+  base64URLStringToBuffer: () => base64URLStringToBuffer,
+  _browserSupportsWebAuthnInternals: () => _browserSupportsWebAuthnInternals,
+  _browserSupportsWebAuthnAutofillInternals: () => _browserSupportsWebAuthnAutofillInternals,
+  WebAuthnError: () => WebAuthnError,
+  WebAuthnAbortService: () => WebAuthnAbortService
+});
+var init_esm = __esm(() => {
+  init_startRegistration();
+  init_startAuthentication();
+  init_browserSupportsWebAuthn();
+  init_platformAuthenticatorIsAvailable();
+  init_browserSupportsWebAuthnAutofill();
+  init_webAuthnAbortService();
+  init_webAuthnError();
+  init_types();
+});
+
 // src/client/react.ts
 import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/client/passkeyHelpers.ts
+var loadBrowser = async () => {
+  const mod = await Promise.resolve().then(() => (init_esm(), exports_esm));
+  return mod;
+};
+var errorFor = (caught) => ({
+  body: null,
+  message: caught instanceof Error ? caught.message : "webauthn_failed",
+  status: 0
+});
+var runConditionalAuthentication = async (client) => {
+  if (typeof window === "undefined" || !window.PublicKeyCredential) {
+    return {
+      data: null,
+      error: errorFor(new Error("webauthn_unavailable"))
+    };
+  }
+  const options = await client.passkeys.authenticateOptions();
+  if (options.error)
+    return { data: null, error: options.error };
+  try {
+    const { startAuthentication: startAuthentication3 } = await loadBrowser();
+    const credential = await startAuthentication3({
+      optionsJSON: options.data,
+      useBrowserAutofill: true
+    });
+    return client.passkeys.authenticateVerify(credential);
+  } catch (caught) {
+    return { data: null, error: errorFor(caught) };
+  }
+};
+var runPasskeyRegistration = async (client) => {
+  if (typeof window === "undefined" || !window.PublicKeyCredential) {
+    return {
+      data: null,
+      error: errorFor(new Error("webauthn_unavailable"))
+    };
+  }
+  const options = await client.passkeys.registerOptions();
+  if (options.error)
+    return { data: null, error: options.error };
+  try {
+    const { startRegistration: startRegistration3 } = await loadBrowser();
+    const credential = await startRegistration3({
+      optionsJSON: options.data
+    });
+    return client.passkeys.registerVerify(credential);
+  } catch (caught) {
+    return { data: null, error: errorFor(caught) };
+  }
+};
+
+// src/client/react.ts
 var useMutation = (run) => {
   const [data, setData] = useState(null);
   const [error, setError] = useState(null);
@@ -30,6 +585,58 @@ var useMutation = (run) => {
   return { data, error, isPending, mutate, reset };
 };
 var useMagicLink = (client) => useMutation(client.passwordless.requestMagicLink);
+var usePasskeyAutofill = (client) => {
+  const [data, setData] = useState(null);
+  const [error, setError] = useState(null);
+  const [isPending, setIsPending] = useState(false);
+  const mountedRef = useRef(true);
+  useEffect(() => () => {
+    mountedRef.current = false;
+  }, []);
+  const start = useCallback(async () => {
+    setIsPending(true);
+    setError(null);
+    const result = await runConditionalAuthentication(client);
+    if (mountedRef.current) {
+      setData(result.data);
+      setError(result.error);
+      setIsPending(false);
+    }
+  }, [client]);
+  const cancel = useCallback(() => {
+    setIsPending(false);
+  }, []);
+  return { cancel, data, error, isPending, start };
+};
+var useUpgradeToPasskey = (client) => {
+  const [passkeys, setPasskeys] = useState(null);
+  const [error, setError] = useState(null);
+  const [isPending, setIsPending] = useState(true);
+  const mountedRef = useRef(true);
+  useEffect(() => () => {
+    mountedRef.current = false;
+  }, []);
+  const refetch = useCallback(async () => {
+    setIsPending(true);
+    const result = await client.passkeys.list();
+    if (mountedRef.current) {
+      setPasskeys(result.data);
+      setError(result.error);
+      setIsPending(false);
+    }
+  }, [client]);
+  useEffect(() => {
+    refetch();
+  }, [refetch]);
+  const register = useCallback(async () => {
+    const result = await runPasskeyRegistration(client);
+    if (result.error === null)
+      await refetch();
+    return result;
+  }, [client, refetch]);
+  const shouldPrompt = passkeys !== null && passkeys.length === 0;
+  return { error, isPending, passkeys, refetch, register, shouldPrompt };
+};
 var useMfaChallenge = (client) => useMutation(client.mfa.challenge);
 var usePasswordReset = (client) => useMutation(client.passwordReset.request);
 var useSessions = (client) => {
@@ -64,14 +671,16 @@ var useSignIn = (client) => useMutation(client.signIn.email);
 var useSignOut = (client) => useMutation(client.signOut);
 var useSignUp = (client) => useMutation(client.signUp.email);
 export {
+  useUpgradeToPasskey,
   useSignUp,
   useSignOut,
   useSignIn,
   useSessions,
   usePasswordReset,
+  usePasskeyAutofill,
   useMfaChallenge,
   useMagicLink
 };
 
-//# debugId=A814F633A26BF2D664756E2164756E21
+//# debugId=FA8CEE907CE1FBFC64756E2164756E21
 //# sourceMappingURL=react.js.map