@absolutejs/auth 0.56.18 → 0.57.0

package/dist/client/svelte.js

@@ -46,500 +46,11 @@ var __export = (target, all) => {
 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/svelte.ts
 import { writable } from "svelte/store";
 
 // src/client/passkeyHelpers.ts
-var loadBrowser = async () => {
-  const mod = await Promise.resolve().then(() => (init_esm(), exports_esm));
-  return mod;
-};
+var loadBrowser = () => import("@simplewebauthn/browser");
 var errorFor = (caught) => ({
   body: null,
   message: caught instanceof Error ? caught.message : "webauthn_failed",
@@ -556,8 +67,8 @@ var runConditionalAuthentication = async (client) => {
   if (options.error)
     return { data: null, error: options.error };
   try {
-    const { startAuthentication: startAuthentication3 } = await loadBrowser();
-    const credential = await startAuthentication3({
+    const { startAuthentication } = await loadBrowser();
+    const credential = await startAuthentication({
       optionsJSON: options.data,
       useBrowserAutofill: true
     });
@@ -577,8 +88,8 @@ var runPasskeyRegistration = async (client) => {
   if (options.error)
     return { data: null, error: options.error };
   try {
-    const { startRegistration: startRegistration3 } = await loadBrowser();
-    const credential = await startRegistration3({
+    const { startRegistration } = await loadBrowser();
+    const credential = await startRegistration({
       optionsJSON: options.data
     });
     return client.passkeys.registerVerify(credential);
@@ -609,6 +120,7 @@ var useMutation = (run) => {
   return { data, error, isPending, mutate, reset };
 };
 var useMagicLink = (client) => useMutation(client.passwordless.requestMagicLink);
+var useMfaChallenge = (client) => useMutation(client.mfa.challenge);
 var usePasskeyAutofill = (client) => {
   const data = writable(null);
   const error = writable(null);
@@ -626,56 +138,55 @@ var usePasskeyAutofill = (client) => {
   };
   return { cancel, data, error, isPending, start };
 };
-var useUpgradeToPasskey = (client) => {
-  const passkeys = writable(null);
+var usePasswordReset = (client) => useMutation(client.passwordReset.request);
+var useSessions = (client) => {
+  const data = writable(null);
   const error = writable(null);
   const isPending = writable(true);
-  const shouldPrompt = writable(false);
-  const recompute = (list) => {
-    shouldPrompt.set(list !== null && list.length === 0);
-  };
   const refetch = async () => {
     isPending.set(true);
-    const result = await client.passkeys.list();
-    passkeys.set(result.data);
+    const result = await client.sessions.list();
+    data.set(result.data);
     error.set(result.error);
     isPending.set(false);
-    recompute(result.data);
   };
-  const register = async () => {
-    const result = await runPasskeyRegistration(client);
+  const revoke = async (sessionId) => {
+    const result = await client.sessions.revoke(sessionId);
     if (result.error === null)
       await refetch();
     return result;
   };
   refetch();
-  return { error, isPending, passkeys, refetch, register, shouldPrompt };
+  return { data, error, isPending, refetch, revoke };
 };
-var useMfaChallenge = (client) => useMutation(client.mfa.challenge);
-var usePasswordReset = (client) => useMutation(client.passwordReset.request);
-var useSessions = (client) => {
-  const data = writable(null);
+var useSignIn = (client) => useMutation(client.signIn.email);
+var useSignOut = (client) => useMutation(client.signOut);
+var useSignUp = (client) => useMutation(client.signUp.email);
+var useUpgradeToPasskey = (client) => {
+  const passkeys = writable(null);
   const error = writable(null);
   const isPending = writable(true);
+  const shouldPrompt = writable(false);
+  const recompute = (list) => {
+    shouldPrompt.set(list !== null && list.length === 0);
+  };
   const refetch = async () => {
     isPending.set(true);
-    const result = await client.sessions.list();
-    data.set(result.data);
+    const result = await client.passkeys.list();
+    passkeys.set(result.data);
     error.set(result.error);
     isPending.set(false);
+    recompute(result.data);
   };
-  const revoke = async (sessionId) => {
-    const result = await client.sessions.revoke(sessionId);
+  const register = async () => {
+    const result = await runPasskeyRegistration(client);
     if (result.error === null)
       await refetch();
     return result;
   };
   refetch();
-  return { data, error, isPending, refetch, revoke };
+  return { error, isPending, passkeys, refetch, register, shouldPrompt };
 };
-var useSignIn = (client) => useMutation(client.signIn.email);
-var useSignOut = (client) => useMutation(client.signOut);
-var useSignUp = (client) => useMutation(client.signUp.email);
 export {
   useUpgradeToPasskey,
   useSignUp,
@@ -688,5 +199,5 @@ export {
   useMagicLink
 };
 
-//# debugId=D1D3E2E0E04ECF6A64756E2164756E21
+//# debugId=0DCC16C45A0B9F4D64756E2164756E21
 //# sourceMappingURL=svelte.js.map