@forgerock/journey-client 0.0.0-beta-20251222204813

package/dist/src/lib/webauthn/webauthn.d.ts

@@ -0,0 +1,124 @@
+import { WebAuthnOutcome, WebAuthnStepType } from './enums.js';
+import type { HiddenValueCallback } from '../callbacks/hidden-value-callback.js';
+import type { JourneyStep } from '../step.utils.js';
+import type { AttestationType, RelyingParty, WebAuthnAuthenticationMetadata, WebAuthnCallbacks, WebAuthnRegistrationMetadata } from './interfaces.js';
+import type { MetadataCallback } from '../callbacks/metadata-callback.js';
+import type { TextOutputCallback } from '../callbacks/text-output-callback.js';
+type OutcomeWithName<ClientId extends string, Attestation extends AttestationType, PubKeyCred extends PublicKeyCredential, Name = ''> = Name extends infer P extends string ? `${ClientId}::${Attestation}::${PubKeyCred['id']}${P extends '' ? '' : `::${P}`}` : never;
+/**
+ * Utility for integrating a web browser's WebAuthn API.
+ *
+ * Example:
+ *
+ * ```js
+ * // Determine if a step is a WebAuthn step
+ * const stepType = WebAuthn.getWebAuthnStepType(step);
+ * if (stepType === WebAuthnStepType.Registration) {
+ *   // Register a new device
+ *   await WebAuthn.register(step);
+ * } else if (stepType === WebAuthnStepType.Authentication) {
+ *   // Authenticate with a registered device
+ *   await WebAuthn.authenticate(step);
+ * }
+ * ```
+ */
+export declare abstract class WebAuthn {
+    /**
+     * Determines if the given step is a WebAuthn step.
+     *
+     * @param step The step to evaluate
+     * @return A WebAuthnStepType value
+     */
+    static getWebAuthnStepType(step: JourneyStep): WebAuthnStepType;
+    /**
+     * Populates the step with the necessary authentication outcome.
+     *
+     * @param step The step that contains WebAuthn authentication data
+     * @return The populated step
+     */
+    static authenticate(step: JourneyStep): Promise<JourneyStep>;
+    /**
+     * Populates the step with the necessary registration outcome.
+     *
+     * @param step The step that contains WebAuthn registration data
+     * @return The populated step
+     */
+    static register<T extends string = ''>(step: JourneyStep, deviceName?: T): Promise<JourneyStep>;
+    /**
+     * Returns an object containing the two WebAuthn callbacks.
+     *
+     * @param step The step that contains WebAuthn callbacks
+     * @return The WebAuthn callbacks
+     */
+    static getCallbacks(step: JourneyStep): WebAuthnCallbacks;
+    /**
+     * Returns the WebAuthn metadata callback containing data to pass to the browser
+     * Web Authentication API.
+     *
+     * @param step The step that contains WebAuthn callbacks
+     * @return The metadata callback
+     */
+    static getMetadataCallback(step: JourneyStep): MetadataCallback | undefined;
+    /**
+     * Returns the WebAuthn hidden value callback where the outcome should be populated.
+     *
+     * @param step The step that contains WebAuthn callbacks
+     * @return The hidden value callback
+     */
+    static getOutcomeCallback(step: JourneyStep): HiddenValueCallback | undefined;
+    /**
+     * Returns the WebAuthn metadata callback containing data to pass to the browser
+     * Web Authentication API.
+     *
+     * @param step The step that contains WebAuthn callbacks
+     * @return The metadata callback
+     */
+    static getTextOutputCallback(step: JourneyStep): TextOutputCallback | undefined;
+    /**
+     * Retrieves the credential from the browser Web Authentication API.
+     *
+     * @param options The public key options associated with the request
+     * @return The credential
+     */
+    static getAuthenticationCredential(options: PublicKeyCredentialRequestOptions): Promise<PublicKeyCredential | null>;
+    /**
+     * Converts an authentication credential into the outcome expected by OpenAM.
+     *
+     * @param credential The credential to convert
+     * @return The outcome string
+     */
+    static getAuthenticationOutcome(credential: PublicKeyCredential | null): OutcomeWithName<string, AttestationType, PublicKeyCredential> | OutcomeWithName<string, AttestationType, PublicKeyCredential, string>;
+    /**
+     * Retrieves the credential from the browser Web Authentication API.
+     *
+     * @param options The public key options associated with the request
+     * @return The credential
+     */
+    static getRegistrationCredential(options: PublicKeyCredentialCreationOptions): Promise<PublicKeyCredential | null>;
+    /**
+     * Converts a registration credential into the outcome expected by OpenAM.
+     *
+     * @param credential The credential to convert
+     * @return The outcome string
+     */
+    static getRegistrationOutcome(credential: PublicKeyCredential | null): OutcomeWithName<string, AttestationType, PublicKeyCredential>;
+    /**
+     * Converts authentication tree metadata into options required by the browser
+     * Web Authentication API.
+     *
+     * @param metadata The metadata provided in the authentication tree MetadataCallback
+     * @return The Web Authentication API request options
+     */
+    static createAuthenticationPublicKey(metadata: WebAuthnAuthenticationMetadata): PublicKeyCredentialRequestOptions;
+    /**
+     * Converts authentication tree metadata into options required by the browser
+     * Web Authentication API.
+     *
+     * @param metadata The metadata provided in the authentication tree MetadataCallback
+     * @return The Web Authentication API request options
+     */
+    static createRegistrationPublicKey(metadata: WebAuthnRegistrationMetadata): PublicKeyCredentialCreationOptions;
+}
+export { WebAuthnOutcome, WebAuthnStepType };
+export type { RelyingParty, WebAuthnAuthenticationMetadata, WebAuthnCallbacks, WebAuthnRegistrationMetadata, };
+//# sourceMappingURL=webauthn.d.ts.map

package/dist/src/lib/webauthn/webauthn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webauthn.d.ts","sourceRoot":"","sources":["../../../../src/lib/webauthn/webauthn.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,eAAe,EAAuB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAQpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,8BAA8B,EAC9B,iBAAiB,EACjB,4BAA4B,EAE7B,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAG/E,KAAK,eAAe,CAClB,QAAQ,SAAS,MAAM,EACvB,WAAW,SAAS,eAAe,EACnC,UAAU,SAAS,mBAAmB,EACtC,IAAI,GAAG,EAAE,IACP,IAAI,SAAS,MAAM,CAAC,SAAS,MAAM,GACnC,GAAG,QAAQ,KAAK,WAAW,KAAK,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,EAAE,EAAE,GACjF,KAAK,CAAC;AAIV;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,QAAQ;IAC5B;;;;;OAKG;WACW,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,gBAAgB;IA6BtE;;;;;OAKG;WACiB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAqDzE;;;;;OAKG;WAIiB,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,EAAE,EAChD,IAAI,EAAE,WAAW,EACjB,UAAU,CAAC,EAAE,CAAC,GACb,OAAO,CAAC,WAAW,CAAC;IAyDvB;;;;;OAKG;WACW,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,iBAAiB;IAiBhE;;;;;;OAMG;WACW,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,gBAAgB,GAAG,SAAS;IAQlF;;;;;OAKG;WACW,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,mBAAmB,GAAG,SAAS;IAMpF;;;;;;OAMG;WACW,qBAAqB,CAAC,IAAI,EAAE,WAAW,GAAG,kBAAkB,GAAG,SAAS;IAStF;;;;;OAKG;WACiB,2BAA2B,CAC7C,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAWtC;;;;;OAKG;WACW,wBAAwB,CACpC,UAAU,EAAE,mBAAmB,GAAG,IAAI,GAEpC,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,mBAAmB,CAAC,GAC7D,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,CAAC;IA6CzE;;;;;OAKG;WACiB,yBAAyB,CAC3C,OAAO,EAAE,kCAAkC,GAC1C,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAatC;;;;;OAKG;WACW,sBAAsB,CAClC,UAAU,EAAE,mBAAmB,GAAG,IAAI,GACrC,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,mBAAmB,CAAC;IAqBhE;;;;;;OAMG;WACW,6BAA6B,CACzC,QAAQ,EAAE,8BAA8B,GACvC,iCAAiC;IAsBpC;;;;;;OAMG;WACW,2BAA2B,CACvC,QAAQ,EAAE,4BAA4B,GACrC,kCAAkC;CA0CtC;AAED,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,CAAC;AAC7C,YAAY,EACV,YAAY,EACZ,8BAA8B,EAC9B,iBAAiB,EACjB,4BAA4B,GAC7B,CAAC"}

package/dist/src/lib/webauthn/webauthn.js

@@ -0,0 +1,383 @@
+/*
+ * @forgerock/ping-javascript-sdk
+ *
+ * index.ts
+ *
+ * Copyright (c) 2024 - 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+import { callbackType } from '@forgerock/sdk-types';
+import { WebAuthnOutcome, WebAuthnOutcomeType, WebAuthnStepType } from './enums.js';
+import { arrayBufferToString, parseCredentials, parsePubKeyArray, parseRelyingPartyId, } from './helpers.js';
+/**
+ * Utility for integrating a web browser's WebAuthn API.
+ *
+ * Example:
+ *
+ * ```js
+ * // Determine if a step is a WebAuthn step
+ * const stepType = WebAuthn.getWebAuthnStepType(step);
+ * if (stepType === WebAuthnStepType.Registration) {
+ *   // Register a new device
+ *   await WebAuthn.register(step);
+ * } else if (stepType === WebAuthnStepType.Authentication) {
+ *   // Authenticate with a registered device
+ *   await WebAuthn.authenticate(step);
+ * }
+ * ```
+ */
+export class WebAuthn {
+    /**
+     * Determines if the given step is a WebAuthn step.
+     *
+     * @param step The step to evaluate
+     * @return A WebAuthnStepType value
+     */
+    static getWebAuthnStepType(step) {
+        const outcomeCallback = this.getOutcomeCallback(step);
+        const metadataCallback = this.getMetadataCallback(step);
+        const textOutputCallback = this.getTextOutputCallback(step);
+        if (outcomeCallback && metadataCallback) {
+            const metadata = metadataCallback.getOutputValue('data');
+            if (metadata?.pubKeyCredParams) {
+                return WebAuthnStepType.Registration;
+            }
+            return WebAuthnStepType.Authentication;
+        }
+        if (outcomeCallback && textOutputCallback) {
+            const message = textOutputCallback.getMessage();
+            if (message.includes('pubKeyCredParams')) {
+                return WebAuthnStepType.Registration;
+            }
+            return WebAuthnStepType.Authentication;
+        }
+        else {
+            return WebAuthnStepType.None;
+        }
+    }
+    /**
+     * Populates the step with the necessary authentication outcome.
+     *
+     * @param step The step that contains WebAuthn authentication data
+     * @return The populated step
+     */
+    static async authenticate(step) {
+        const { hiddenCallback, metadataCallback, textOutputCallback } = this.getCallbacks(step);
+        if (hiddenCallback && (metadataCallback || textOutputCallback)) {
+            let outcome;
+            let credential = null;
+            try {
+                let publicKey;
+                if (metadataCallback) {
+                    const meta = metadataCallback.getOutputValue('data');
+                    publicKey = this.createAuthenticationPublicKey(meta);
+                    credential = await this.getAuthenticationCredential(publicKey);
+                    outcome = this.getAuthenticationOutcome(credential);
+                }
+                else {
+                    throw new Error('No metadata callback found for WebAuthn authentication. Please disable JavaScript in server node.');
+                }
+            }
+            catch (error) {
+                if (!(error instanceof Error))
+                    throw error;
+                // NotSupportedError is a special case
+                if (error.name === WebAuthnOutcomeType.NotSupportedError) {
+                    hiddenCallback.setInputValue(WebAuthnOutcome.Unsupported);
+                    throw error;
+                }
+                hiddenCallback.setInputValue(`${WebAuthnOutcome.Error}::${error.name}:${error.message}`);
+                throw error;
+            }
+            if (metadataCallback) {
+                const meta = metadataCallback.getOutputValue('data');
+                if (meta?.supportsJsonResponse && credential && 'authenticatorAttachment' in credential) {
+                    hiddenCallback.setInputValue(JSON.stringify({
+                        authenticatorAttachment: credential.authenticatorAttachment,
+                        legacyData: outcome,
+                    }));
+                    return step;
+                }
+            }
+            hiddenCallback.setInputValue(outcome);
+            return step;
+        }
+        else {
+            const e = new Error('Incorrect callbacks for WebAuthn authentication');
+            e.name = WebAuthnOutcomeType.DataError;
+            hiddenCallback?.setInputValue(`${WebAuthnOutcome.Error}::${e.name}:${e.message}`);
+            throw e;
+        }
+    }
+    /**
+     * Populates the step with the necessary registration outcome.
+     *
+     * @param step The step that contains WebAuthn registration data
+     * @return The populated step
+     */
+    // Can make this generic const in Typescript 5.0 > and the name itself will
+    // be inferred from the type so `typeof deviceName` will not just return string
+    // but the actual name of the deviceName passed in as a generic.
+    static async register(step, deviceName) {
+        const { hiddenCallback, metadataCallback, textOutputCallback } = this.getCallbacks(step);
+        if (hiddenCallback && (metadataCallback || textOutputCallback)) {
+            let outcome;
+            let credential = null;
+            try {
+                let publicKey;
+                if (metadataCallback) {
+                    const meta = metadataCallback.getOutputValue('data');
+                    publicKey = this.createRegistrationPublicKey(meta);
+                    credential = await this.getRegistrationCredential(publicKey);
+                    outcome = this.getRegistrationOutcome(credential);
+                }
+                else {
+                    throw new Error('No metadata callback found for WebAuthn registration. Please disable JavaScript in server node.');
+                }
+            }
+            catch (error) {
+                if (!(error instanceof Error))
+                    throw error;
+                // NotSupportedError is a special case
+                if (error.name === WebAuthnOutcomeType.NotSupportedError) {
+                    hiddenCallback.setInputValue(WebAuthnOutcome.Unsupported);
+                    throw error;
+                }
+                hiddenCallback.setInputValue(`${WebAuthnOutcome.Error}::${error.name}:${error.message}`);
+                throw error;
+            }
+            if (metadataCallback) {
+                const meta = metadataCallback.getOutputValue('data');
+                if (meta?.supportsJsonResponse && credential && 'authenticatorAttachment' in credential) {
+                    hiddenCallback.setInputValue(JSON.stringify({
+                        authenticatorAttachment: credential.authenticatorAttachment,
+                        legacyData: deviceName && deviceName.length > 0 ? `${outcome}::${deviceName}` : outcome,
+                    }));
+                    return step;
+                }
+            }
+            hiddenCallback.setInputValue(deviceName && deviceName.length > 0 ? `${outcome}::${deviceName}` : outcome);
+            return step;
+        }
+        else {
+            const e = new Error('Incorrect callbacks for WebAuthn registration');
+            e.name = WebAuthnOutcomeType.DataError;
+            hiddenCallback?.setInputValue(`${WebAuthnOutcome.Error}::${e.name}:${e.message}`);
+            throw e;
+        }
+    }
+    /**
+     * Returns an object containing the two WebAuthn callbacks.
+     *
+     * @param step The step that contains WebAuthn callbacks
+     * @return The WebAuthn callbacks
+     */
+    static getCallbacks(step) {
+        const hiddenCallback = this.getOutcomeCallback(step);
+        const metadataCallback = this.getMetadataCallback(step);
+        const textOutputCallback = this.getTextOutputCallback(step);
+        const returnObj = {
+            hiddenCallback,
+        };
+        if (metadataCallback) {
+            returnObj.metadataCallback = metadataCallback;
+        }
+        else if (textOutputCallback) {
+            returnObj.textOutputCallback = textOutputCallback;
+        }
+        return returnObj;
+    }
+    /**
+     * Returns the WebAuthn metadata callback containing data to pass to the browser
+     * Web Authentication API.
+     *
+     * @param step The step that contains WebAuthn callbacks
+     * @return The metadata callback
+     */
+    static getMetadataCallback(step) {
+        return step.getCallbacksOfType(callbackType.MetadataCallback).find((x) => {
+            const cb = x.getOutputByName('data', undefined);
+            // eslint-disable-next-line no-prototype-builtins
+            return cb && cb.hasOwnProperty('relyingPartyId');
+        });
+    }
+    /**
+     * Returns the WebAuthn hidden value callback where the outcome should be populated.
+     *
+     * @param step The step that contains WebAuthn callbacks
+     * @return The hidden value callback
+     */
+    static getOutcomeCallback(step) {
+        return step
+            .getCallbacksOfType(callbackType.HiddenValueCallback)
+            .find((x) => x.getOutputByName('id', '') === 'webAuthnOutcome');
+    }
+    /**
+     * Returns the WebAuthn metadata callback containing data to pass to the browser
+     * Web Authentication API.
+     *
+     * @param step The step that contains WebAuthn callbacks
+     * @return The metadata callback
+     */
+    static getTextOutputCallback(step) {
+        return step
+            .getCallbacksOfType(callbackType.TextOutputCallback)
+            .find((x) => {
+            const cb = x.getOutputByName('message', undefined);
+            return cb && cb.includes('webAuthnOutcome');
+        });
+    }
+    /**
+     * Retrieves the credential from the browser Web Authentication API.
+     *
+     * @param options The public key options associated with the request
+     * @return The credential
+     */
+    static async getAuthenticationCredential(options) {
+        // Feature check before we attempt registering a device
+        if (!window.PublicKeyCredential) {
+            const e = new Error('PublicKeyCredential not supported by this browser');
+            e.name = WebAuthnOutcomeType.NotSupportedError;
+            throw e;
+        }
+        const credential = await navigator.credentials.get({ publicKey: options });
+        return credential;
+    }
+    /**
+     * Converts an authentication credential into the outcome expected by OpenAM.
+     *
+     * @param credential The credential to convert
+     * @return The outcome string
+     */
+    static getAuthenticationOutcome(credential) {
+        if (credential === null) {
+            const e = new Error('No credential generated from authentication');
+            e.name = WebAuthnOutcomeType.UnknownError;
+            throw e;
+        }
+        try {
+            const clientDataJSON = arrayBufferToString(credential.response.clientDataJSON);
+            const assertionResponse = credential.response;
+            const authenticatorData = new Int8Array(assertionResponse.authenticatorData).toString();
+            const signature = new Int8Array(assertionResponse.signature).toString();
+            // Current native typing for PublicKeyCredential does not include `userHandle`
+            // eslint-disable-next-line
+            // @ts-ignore
+            const userHandle = arrayBufferToString(credential.response.userHandle);
+            let stringOutput = `${clientDataJSON}::${authenticatorData}::${signature}::${credential.id}`;
+            // Check if Username is stored on device
+            if (userHandle) {
+                stringOutput = `${stringOutput}::${userHandle}`;
+                return stringOutput;
+            }
+            return stringOutput;
+        }
+        catch {
+            const e = new Error('Transforming credential object to string failed');
+            e.name = WebAuthnOutcomeType.EncodingError;
+            throw e;
+        }
+    }
+    /**
+     * Retrieves the credential from the browser Web Authentication API.
+     *
+     * @param options The public key options associated with the request
+     * @return The credential
+     */
+    static async getRegistrationCredential(options) {
+        // Feature check before we attempt registering a device
+        if (!window.PublicKeyCredential) {
+            const e = new Error('PublicKeyCredential not supported by this browser');
+            e.name = WebAuthnOutcomeType.NotSupportedError;
+            throw e;
+        }
+        const credential = await navigator.credentials.create({
+            publicKey: options,
+        });
+        return credential;
+    }
+    /**
+     * Converts a registration credential into the outcome expected by OpenAM.
+     *
+     * @param credential The credential to convert
+     * @return The outcome string
+     */
+    static getRegistrationOutcome(credential) {
+        if (credential === null) {
+            const e = new Error('No credential generated from registration');
+            e.name = WebAuthnOutcomeType.UnknownError;
+            throw e;
+        }
+        try {
+            const clientDataJSON = arrayBufferToString(credential.response.clientDataJSON);
+            const attestationResponse = credential.response;
+            const attestationObject = new Int8Array(attestationResponse.attestationObject).toString();
+            return `${clientDataJSON}::${attestationObject}::${credential.id}`;
+        }
+        catch {
+            const e = new Error('Transforming credential object to string failed');
+            e.name = WebAuthnOutcomeType.EncodingError;
+            throw e;
+        }
+    }
+    /**
+     * Converts authentication tree metadata into options required by the browser
+     * Web Authentication API.
+     *
+     * @param metadata The metadata provided in the authentication tree MetadataCallback
+     * @return The Web Authentication API request options
+     */
+    static createAuthenticationPublicKey(metadata) {
+        const { acceptableCredentials, allowCredentials, challenge, relyingPartyId, timeout, userVerification, } = metadata;
+        const rpId = parseRelyingPartyId(relyingPartyId);
+        const allowCredentialsValue = parseCredentials(allowCredentials || acceptableCredentials || '');
+        return {
+            challenge: Uint8Array.from(atob(challenge), (c) => c.charCodeAt(0)).buffer,
+            timeout,
+            // only add key-value pair if proper value is provided
+            ...(allowCredentialsValue && { allowCredentials: allowCredentialsValue }),
+            ...(userVerification && { userVerification }),
+            ...(rpId && { rpId }),
+        };
+    }
+    /**
+     * Converts authentication tree metadata into options required by the browser
+     * Web Authentication API.
+     *
+     * @param metadata The metadata provided in the authentication tree MetadataCallback
+     * @return The Web Authentication API request options
+     */
+    static createRegistrationPublicKey(metadata) {
+        const { pubKeyCredParams: pubKeyCredParamsString } = metadata;
+        const pubKeyCredParams = parsePubKeyArray(pubKeyCredParamsString);
+        if (!pubKeyCredParams) {
+            const e = new Error('Missing pubKeyCredParams property from registration options');
+            e.name = WebAuthnOutcomeType.DataError;
+            throw e;
+        }
+        const excludeCredentials = parseCredentials(metadata.excludeCredentials);
+        const { attestationPreference, authenticatorSelection, challenge, relyingPartyId, relyingPartyName, timeout, userId, userName, displayName, } = metadata;
+        const rpId = parseRelyingPartyId(relyingPartyId);
+        const rp = {
+            name: relyingPartyName,
+            ...(rpId && { id: rpId }),
+        };
+        return {
+            attestation: attestationPreference,
+            authenticatorSelection: JSON.parse(authenticatorSelection),
+            challenge: Uint8Array.from(atob(challenge), (c) => c.charCodeAt(0)).buffer,
+            ...(excludeCredentials.length && { excludeCredentials }),
+            pubKeyCredParams,
+            rp,
+            timeout,
+            user: {
+                displayName: displayName || userName,
+                id: Int8Array.from(userId.split('').map((c) => c.charCodeAt(0))),
+                name: displayName || userName,
+            },
+        };
+    }
+}
+export { WebAuthnOutcome, WebAuthnStepType };