@forgerock/login-widget 1.0.0-beta.5 → 1.0.0-beta.6

package/{modal.cjs → index.cjs}

@@ -181,11 +181,6 @@ function set_data(text, data) {
 function set_input_value(input, value) {
     input.value = value == null ? '' : value;
 }
-function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
-    const e = document.createEvent('CustomEvent');
-    e.initCustomEvent(type, bubbles, cancelable, detail);
-    return e;
-}
 class HtmlTag {
     constructor(is_svg = false) {
         this.is_svg = false;
@@ -257,34 +252,6 @@ function onMount(fn) {
 function afterUpdate(fn) {
     get_current_component().$$.after_update.push(fn);
 }
-/**
- * Creates an event dispatcher that can be used to dispatch [component events](/docs#template-syntax-component-directives-on-eventname).
- * Event dispatchers are functions that can take two arguments: `name` and `detail`.
- *
- * Component events created with `createEventDispatcher` create a
- * [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent).
- * These events do not [bubble](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_bubbling_and_capture).
- * The `detail` argument corresponds to the [CustomEvent.detail](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/detail)
- * property and can contain any type of data.
- *
- * https://svelte.dev/docs#run-time-svelte-createeventdispatcher
- */
-function createEventDispatcher() {
-    const component = get_current_component();
-    return (type, detail, { cancelable = false } = {}) => {
-        const callbacks = component.$$.callbacks[type];
-        if (callbacks) {
-            // TODO are there situations where events could be dispatched
-            // in a server (non-DOM) environment?
-            const event = custom_event(type, detail, { cancelable });
-            callbacks.slice().forEach(fn => {
-                fn.call(component, event);
-            });
-            return !event.defaultPrevented;
-        }
-        return true;
-    };
-}
 
 const dirty_components = [];
 const binding_callbacks = [];
@@ -604,6 +571,172 @@ class SvelteComponent {
     }
 }
 
+const subscriber_queue = [];
+/**
+ * Creates a `Readable` store that allows reading by subscription.
+ * @param value initial value
+ * @param {StartStopNotifier}start start and stop notifications for subscriptions
+ */
+function readable(value, start) {
+    return {
+        subscribe: writable(value, start).subscribe
+    };
+}
+/**
+ * Create a `Writable` store that allows both updating and reading by subscription.
+ * @param {*=}value initial value
+ * @param {StartStopNotifier=}start start and stop notifications for subscriptions
+ */
+function writable(value, start = noop) {
+    let stop;
+    const subscribers = new Set();
+    function set(new_value) {
+        if (safe_not_equal(value, new_value)) {
+            value = new_value;
+            if (stop) { // store is ready
+                const run_queue = !subscriber_queue.length;
+                for (const subscriber of subscribers) {
+                    subscriber[1]();
+                    subscriber_queue.push(subscriber, value);
+                }
+                if (run_queue) {
+                    for (let i = 0; i < subscriber_queue.length; i += 2) {
+                        subscriber_queue[i][0](subscriber_queue[i + 1]);
+                    }
+                    subscriber_queue.length = 0;
+                }
+            }
+        }
+    }
+    function update(fn) {
+        set(fn(value));
+    }
+    function subscribe(run, invalidate = noop) {
+        const subscriber = [run, invalidate];
+        subscribers.add(subscriber);
+        if (subscribers.size === 1) {
+            stop = start(set) || noop;
+        }
+        run(value);
+        return () => {
+            subscribers.delete(subscriber);
+            if (subscribers.size === 0) {
+                stop();
+                stop = null;
+            }
+        };
+    }
+    return { set, update, subscribe };
+}
+function derived(stores, fn, initial_value) {
+    const single = !Array.isArray(stores);
+    const stores_array = single
+        ? [stores]
+        : stores;
+    const auto = fn.length < 2;
+    return readable(initial_value, (set) => {
+        let inited = false;
+        const values = [];
+        let pending = 0;
+        let cleanup = noop;
+        const sync = () => {
+            if (pending) {
+                return;
+            }
+            cleanup();
+            const result = fn(single ? values[0] : values, set);
+            if (auto) {
+                set(result);
+            }
+            else {
+                cleanup = is_function(result) ? result : noop;
+            }
+        };
+        const unsubscribers = stores_array.map((store, i) => subscribe(store, (value) => {
+            values[i] = value;
+            pending &= ~(1 << i);
+            if (inited) {
+                sync();
+            }
+        }, () => {
+            pending |= (1 << i);
+        }));
+        inited = true;
+        sync();
+        return function stop() {
+            run_all(unsubscribers);
+            cleanup();
+        };
+    });
+}
+
+const componentStore = writable({
+    modal: null,
+    form: null,
+    error: null,
+    mounted: false,
+    open: null,
+    reason: null,
+    type: null,
+});
+const componentApi = () => {
+    const { update, subscribe } = componentStore;
+    return {
+        close: (args) => {
+            update((state) => {
+                if (state.type === 'inline') {
+                    console.warn('Component type of "inline" has no `close` method');
+                    // There's nothing to do, so just return existing state
+                    return state;
+                }
+                if (!state.modal) {
+                    console.warn('Modal component is not mounted. Please instantiate the Widget before use.');
+                    // There's nothing to do, so just return existing state
+                    return state;
+                }
+                state.modal?.component.closeDialog();
+                return {
+                    ...state,
+                    open: false,
+                    reason: args?.reason || null,
+                };
+            });
+        },
+        mount: (component, element) => {
+            update((state) => {
+                return {
+                    ...state,
+                    modal: {
+                        ...(component && { component, element }),
+                    },
+                    mounted: true,
+                    type: component ? 'modal' : 'inline',
+                };
+            });
+        },
+        open: () => {
+            update((state) => {
+                if (state.type === 'inline') {
+                    console.warn('Component type of "inline" has no `open` method');
+                    // There's nothing to do, so just return existing state
+                    return state;
+                }
+                if (!state.modal) {
+                    console.warn('Modal component is not mounted. Please instantiate the Widget before use.');
+                    // There's nothing to do, so just return existing state
+                    return state;
+                }
+                state.modal.element.showModal();
+                return {
+                    ...state,
+                    open: true,
+                };
+            });
+        },
+        subscribe,
+    };
+};
+
 /*
  * @forgerock/javascript-sdk
  *
@@ -6599,7 +6732,7 @@ enums$2.PolicyKey = PolicyKey;
 
 var messageCreator = {};
 
-var strings$1 = {};
+var strings = {};
 
 /*
  * @forgerock/javascript-sdk
@@ -6610,8 +6743,8 @@ var strings$1 = {};
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
  */
-Object.defineProperty(strings$1, "__esModule", { value: true });
-strings$1.plural = void 0;
+Object.defineProperty(strings, "__esModule", { value: true });
+strings.plural = void 0;
 /**
  * @module
  * @ignore
@@ -6623,7 +6756,7 @@ function plural(n, singularText, pluralText) {
     }
     return pluralText !== undefined ? pluralText : singularText + 's';
 }
-strings$1.plural = plural;
+strings.plural = plural;
 
 var helpers$2 = {};
 
@@ -6657,7 +6790,7 @@ helpers$2.getProp = getProp;
  */
 var _a;
 Object.defineProperty(messageCreator, "__esModule", { value: true });
-var strings_1 = strings$1;
+var strings_1 = strings;
 var enums_1$7 = enums$2;
 var helpers_1$2 = helpers$2;
 var defaultMessageCreator = (_a = {},
@@ -10715,64 +10848,6 @@ var HttpClient = /** @class */ (function (_super) {
 }(event_1.default));
 var _default$2 = httpClient.default = HttpClient;
 
-const subscriber_queue = [];
-/**
- * Creates a `Readable` store that allows reading by subscription.
- * @param value initial value
- * @param {StartStopNotifier}start start and stop notifications for subscriptions
- */
-function readable(value, start) {
-    return {
-        subscribe: writable(value, start).subscribe
-    };
-}
-/**
- * Create a `Writable` store that allows both updating and reading by subscription.
- * @param {*=}value initial value
- * @param {StartStopNotifier=}start start and stop notifications for subscriptions
- */
-function writable(value, start = noop) {
-    let stop;
-    const subscribers = new Set();
-    function set(new_value) {
-        if (safe_not_equal(value, new_value)) {
-            value = new_value;
-            if (stop) { // store is ready
-                const run_queue = !subscriber_queue.length;
-                for (const subscriber of subscribers) {
-                    subscriber[1]();
-                    subscriber_queue.push(subscriber, value);
-                }
-                if (run_queue) {
-                    for (let i = 0; i < subscriber_queue.length; i += 2) {
-                        subscriber_queue[i][0](subscriber_queue[i + 1]);
-                    }
-                    subscriber_queue.length = 0;
-                }
-            }
-        }
-    }
-    function update(fn) {
-        set(fn(value));
-    }
-    function subscribe(run, invalidate = noop) {
-        const subscriber = [run, invalidate];
-        subscribers.add(subscriber);
-        if (subscribers.size === 1) {
-            stop = start(set) || noop;
-        }
-        run(value);
-        return () => {
-            subscribers.delete(subscriber);
-            if (subscribers.size === 0) {
-                stop();
-                stop = null;
-            }
-        };
-    }
-    return { set, update, subscribe };
-}
-
 var util$2;
 (function (util) {
     util.assertEqual = (val) => val;
@@ -13950,240 +14025,80 @@ function configure (config) {
     Config.set(config);
 }
 
-function widgetApiFactory(modal) {
-    let journeyStore;
-    let oauthStore;
-    let userStore;
-    let returnError;
-    let returnResponse;
-    const configuration = {
-        set(options) {
-            // Set base config to SDK
-            // TODO: Move to a shared utility
-            configure({
-                // Set some basics by default
-                ...{
-                    // TODO: Could this be a default OAuth client provided by Platform UI OOTB?
-                    clientId: 'WebLoginWidgetClient',
-                    // TODO: If a realmPath is not provided, should we call the realm endpoint and detect a likely default?
-                    // https://backstage.forgerock.com/docs/am/7/setup-guide/sec-rest-realm-rest.html#rest-api-list-realm
-                    realmPath: 'alpha',
-                    // TODO: Once we move to SSR, this default should be more intelligent
-                    redirectUri: typeof window === 'object' ? window.location.href : 'https://localhost:3000/callback',
-                    scope: 'openid email',
-                },
-                // Let user provided config override defaults
-                ...options,
-                // Force 'legacy' to remove confusion
-                ...{ support: 'legacy' },
-            });
-        },
-    };
-    const journey = {
-        start(options) {
-            const requestsOauth = options?.oauth || true;
-            const requestsUser = options?.user || true;
-            let journey;
-            let oauth;
-            const journeyStoreUnsub = journeyStore.subscribe((response) => {
-                if (!requestsOauth && response.successful) {
-                    returnResponse &&
-                        returnResponse({
-                            journey: response,
-                        });
-                    if (modal) {
-                        modal.close({ reason: 'auto' });
-                    }
-                }
-                else if (requestsOauth && response.successful) {
-                    journey = response;
-                    oauthStore?.get({ forceRenew: true });
-                }
-                else if (response.error) {
-                    journey = response;
-                    returnError &&
-                        returnError({
-                            journey: response,
-                        });
-                }
-                /**
-                 * Clean up unneeded subscription, but only when it's successful
-                 * Leaving the subscription allows for the journey to be
-                 * restarted internally.
-                 */
-                if (response.successful) {
-                    journeyStoreUnsub();
-                }
-            });
-            const oauthStoreUnsub = oauthStore.subscribe((response) => {
-                if (!requestsUser && response.successful) {
-                    returnResponse &&
-                        returnResponse({
-                            journey,
-                            oauth: response,
-                        });
-                    if (modal) {
-                        modal.close({ reason: 'auto' });
-                    }
-                }
-                else if (requestsUser && response.successful) {
-                    oauth = response;
-                    userStore?.get();
-                }
-                else if (response.error) {
-                    oauth = response;
-                    returnError &&
-                        returnError({
-                            journey,
-                            oauth: response,
-                        });
-                }
-                /**
-                 * Clean up unneeded subscription, but only when it's successful
-                 * Leaving the subscription allows for the journey to be
-                 * restarted internally.
-                 */
-                if (response.successful) {
-                    oauthStoreUnsub();
-                }
-            });
-            const userStoreUnsub = userStore.subscribe((response) => {
-                if (response.successful) {
-                    returnResponse &&
-                        returnResponse({
-                            journey,
-                            oauth,
-                            user: response,
-                        });
-                    if (modal) {
-                        modal.close({ reason: 'auto' });
-                    }
-                }
-                else if (response.error) {
-                    returnError &&
-                        returnError({
-                            journey,
-                            oauth,
-                            user: response,
-                        });
-                }
-                /**
-                 * Clean up unneeded subscription, but only when it's successful
-                 * Leaving the subscription allows for the journey to be
-                 * restarted internally.
-                 */
-                if (response.successful) {
-                    userStoreUnsub();
-                }
-            });
-            if (options?.resumeUrl) {
-                journeyStore.resume(options.resumeUrl);
-            }
-            else {
-                journeyStore.start({
-                    ...options?.config,
-                    tree: options?.journey,
-                });
-            }
-        },
-        onFailure(fn) {
-            returnError = (response) => fn(response);
-        },
-        onSuccess(fn) {
-            returnResponse = (response) => fn(response);
-        },
-    };
-    const user = {
-        // TODO: add "scopes" to parameters for "true" authorization
-        async authorized(remote = false) {
-            if (remote) {
-                try {
-                    return await UserManager.getCurrentUser();
-                }
-                catch (err) {
-                    console.warn(err);
-                    return;
-                }
-            }
-            try {
-                return !!(await TokenManager$1.getTokens());
-            }
-            catch (err) {
-                return;
-            }
-        },
-        async info(remote = false) {
-            userStore = userStore;
-            if (remote) {
-                try {
-                    return await UserManager.getCurrentUser();
-                }
-                catch (err) {
-                    console.warn(err);
-                    return;
-                }
-            }
-            return get_store_value(userStore).response;
-        },
-        logout: async () => {
-            const { clientId } = Config.get();
-            userStore = userStore;
-            /**
-             * If configuration has a clientId, then use FRUser to logout to ensure
-             * token revoking and removal; else, just end the session.
-             */
-            if (clientId) {
-                // Call SDK logout
-                await FRUser.logout();
-            }
-            else {
-                await SessionManager.logout();
-            }
-            // Reset stores
-            journeyStore && journeyStore.reset();
-            oauthStore && oauthStore.reset();
-            userStore && userStore.reset();
-            // Fetch fresh journey step
-            journey && journey.start();
-        },
-        async tokens(options) {
-            // `getTokens` throws if no tokens, so catch and just return with `undefined`
-            try {
-                return await TokenManager$1.getTokens(options);
-            }
-            catch (err) {
-                console.warn(err);
-                return;
-            }
-        },
-    };
-    return {
-        configuration,
-        journey,
-        async request(options) {
-            return await _default$2.request(options);
-        },
-        getJourneyStore() {
-            return journeyStore;
-        },
-        getOAuthStore() {
-            return oauthStore;
-        },
-        getUserStore() {
-            return userStore;
-        },
-        ...(modal && { modal }),
-        setJourneyStore(store) {
-            journeyStore = store;
-        },
-        setOAuthStore(store) {
-            oauthStore = store;
-        },
-        setUserStore(store) {
-            userStore = store;
-        },
-        user,
-    };
+const journeyConfigItemSchema = mod.object({
+    journey: mod.string().optional(),
+    match: mod
+        .string()
+        .regex(/^(#\/service|\?journey)/, {
+        message: 'HREF string must start with `?journey` or `#/service`',
+    })
+        .array(),
+});
+const journeyConfigSchema = mod.object({
+    forgotPassword: journeyConfigItemSchema,
+    forgotUsername: journeyConfigItemSchema,
+    login: journeyConfigItemSchema,
+    register: journeyConfigItemSchema,
+});
+const defaultJourneys = {
+    forgotPassword: {
+        journey: 'ResetPassword',
+        match: ['#/service/ResetPassword', '?journey=ResetPassword'],
+    },
+    forgotUsername: {
+        journey: 'ForgottenUsername',
+        match: ['#/service/ForgottenUsername', '?journey=ForgottenUsername'],
+    },
+    login: {
+        journey: undefined,
+        match: ['#/service/Login', '?journey'],
+    },
+    register: {
+        journey: 'Registration',
+        match: ['#/service/Registration', '?journey=Registration'],
+    },
+};
+// Ensure default follows schema
+journeyConfigSchema.parse(defaultJourneys);
+const configuredJourneysStore = writable(Object.keys(defaultJourneys).map((key) => ({
+    ...defaultJourneys[key],
+    key,
+})));
+function initialize$6(customJourneys) {
+    if (customJourneys) {
+        // Provide developer feedback if customized
+        journeyConfigSchema.parse(customJourneys);
+        const arr = Object.keys(customJourneys);
+        configuredJourneysStore.set(arr.map((key) => ({
+            ...customJourneys[key],
+            key,
+        })));
+    }
+    return configuredJourneysStore;
+}
+
+/*
+ * forgerock-sample-web-react
+ *
+ * decode.js
+ *
+ * Copyright (c) 2021 ForgeRock. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+/**
+ * @function htmlDecode - Decodes HTML encoded strings
+ * @param {string} input - string that needs to be HTML decoded
+ * @returns {string} - decoded string
+ */
+function htmlDecode(input) {
+    // Check if running in server before using the document object
+    if (typeof document !== 'object') {
+        return null;
+    }
+    const e = document.createElement('div');
+    e.innerHTML = input;
+    return e.childNodes.length === 0 ? '' : e.childNodes[0].nodeValue;
 }
 
 var libExports$1 = {};
@@ -16108,17 +16023,18 @@ const stringsSchema = mod
 stringsSchema.partial();
 // Ensure fallback follows schema
 stringsSchema.parse(fallback);
-let strings;
-function initialize$6(userLocale) {
+const stringsStore = writable(null);
+function initialize$5(userLocale) {
     if (userLocale) {
         /**
          * Allow widgets to overwrite select portions of the content
          */
-        strings = readable({ ...fallback, ...userLocale });
+        stringsStore.set({ ...fallback, ...userLocale });
     }
     else {
-        strings = readable(fallback);
+        stringsStore.set(fallback);
     }
+    return stringsSchema;
 }
 
 /**
@@ -16133,7 +16049,7 @@ function interpolate(key, values, externalText) {
     if (!key)
         throw new Error('No key provided to t()');
     // Grab the text from the translations store.
-    const contentObj = get_store_value(strings);
+    const contentObj = get_store_value(stringsStore);
     const string = (contentObj && contentObj[key]) || '';
     let messageDirty = '';
     if (values) {
@@ -16238,9 +16154,1024 @@ function textToKey(text) {
     return transformedString.charAt(0).toLowerCase() + transformedString.slice(1);
 }
 
+const authIdTimeoutErrorCode = '110';
+const constrainedViolationMessage = 'constraint violation';
+/**
+ * @function convertStringToKey -
+ * @param {string} string
+ * @returns {string}
+ */
+function convertStringToKey(string) {
+    if (!string) {
+        return '';
+    }
+    if (string.toLocaleLowerCase().includes('constraint violation')) {
+        console.error('Delta Sierra error has occurred. Please communicate this to your system administrator.');
+        if (string.toLocaleLowerCase().includes('password')) {
+            return 'constraintViolationForPassword';
+        }
+        return 'constraintViolationForValue';
+    }
+    const replaceFunction = (_, char) => `${char.toLowerCase()}`;
+    const normalizedString = string
+        .replace(/^([A-Z])/g, replaceFunction)
+        .replace(/\s([a-z])/g, (_, char) => `${char.toUpperCase()}`);
+    const key = normalizedString.replace(/\W/g, '');
+    return key;
+}
+/**
+ * @function initCheckValidation -
+ * @returns {boolean}
+ */
+function initCheckValidation() {
+    let hasPrevError = false;
+    return function checkValidation(callback) {
+        const failedPolices = callback.getOutputByName('failedPolicies', []);
+        if (failedPolices.length && !hasPrevError) {
+            hasPrevError = true;
+            return true;
+        }
+        return false;
+    };
+}
+/**
+ * @function shouldRedirectFromStep -
+ * @returns {boolean}
+ */
+function shouldRedirectFromStep(step) {
+    return step.getCallbacksOfType(CallbackType$1.RedirectCallback).length > 0;
+}
+/**
+ * @function shouldPopulateWithPreviousCallbacks -
+ * @param {object} nextStep
+ * @param {array} previousCallbacks
+ * @param {object} restartedStep
+ * @param {number} stepNumber
+ * @returns {boolean}
+ */
+function shouldPopulateWithPreviousCallbacks(nextStep, previousCallbacks, restartedStep, stepNumber) {
+    if (!Array.isArray(previousCallbacks)) {
+        return false;
+    }
+    if (restartedStep.type !== StepType$1.Step) {
+        return false;
+    }
+    if (stepNumber !== 1) {
+        return false;
+    }
+    const details = nextStep.payload.detail;
+    const message = nextStep.payload.message?.toLowerCase();
+    /**
+     * Now that we know we have previous callbacks, this is of type "Step",
+     * it has payload detail or payload message, and it's just the first step,
+     * we can populate the new step with old callbacks.
+     */
+    if (details?.errorCode === authIdTimeoutErrorCode ||
+        message?.includes(constrainedViolationMessage)) {
+        return true;
+    }
+    // Fallback to false
+    return false;
+}
+
+const selfSubmittingCallbacks = [
+    CallbackType$1.ConfirmationCallback,
+    CallbackType$1.DeviceProfileCallback,
+    CallbackType$1.PollingWaitCallback,
+    CallbackType$1.SelectIdPCallback,
+];
+const userInputCallbacks = [
+    CallbackType$1.BooleanAttributeInputCallback,
+    CallbackType$1.ChoiceCallback,
+    CallbackType$1.ConfirmationCallback,
+    CallbackType$1.KbaCreateCallback,
+    CallbackType$1.NameCallback,
+    CallbackType$1.NumberAttributeInputCallback,
+    CallbackType$1.PasswordCallback,
+    CallbackType$1.ReCaptchaCallback,
+    CallbackType$1.SelectIdPCallback,
+    CallbackType$1.StringAttributeInputCallback,
+    CallbackType$1.TermsAndConditionsCallback,
+    CallbackType$1.ValidatedCreatePasswordCallback,
+    CallbackType$1.ValidatedCreateUsernameCallback,
+];
+// This eventually will be overridable by user of framework
+const forceUserInputOptionalityCallbacks = {
+    SelectIdPCallback: (callback) => {
+        const selectIdpCb = callback;
+        return !!selectIdpCb
+            .getProviders()
+            .find((provider) => provider.provider === 'localAuthentication');
+    },
+};
+function isCbReadyByDefault(callback) {
+    if (callback.getType() === CallbackType$1.ConfirmationCallback) {
+        const cb = callback;
+        if (cb.getOptions().length === 1) {
+            return true;
+        }
+    }
+    return false;
+}
+function canForceUserInputOptionality(callback) {
+    // See if a callback function exists within this collection
+    const fn = forceUserInputOptionalityCallbacks[callback.getType()];
+    // If there is a function, run it and it will return a boolean
+    return fn ? fn(callback) : false;
+}
+/**
+ * @function isSelfSubmitting -
+ * @param {object} callback - generic FRCallback from JavaScript SDK
+ * @returns
+ */
+function isSelfSubmitting(callback) {
+    return selfSubmittingCallbacks.includes(callback.getType());
+}
+/**
+ * @function isStepSelfSubmittable -
+ * @param {array} callbacks - CallbackMetadata
+ * @returns
+ */
+function isStepSelfSubmittable(callbacks, userInputOptional) {
+    if (userInputOptional) {
+        return true;
+    }
+    const unsubmittableCallbacks = callbacks.filter((callback) => callback.derived.isUserInputRequired && !callback.derived.isSelfSubmitting);
+    return !unsubmittableCallbacks.length;
+}
+/**
+ *
+ * @param  {object} callback - Generic callback provided by JavaScript SDK
+ * @returns
+ */
+function requiresUserInput(callback) {
+    if (callback.getType() === CallbackType$1.SelectIdPCallback) {
+        return false;
+    }
+    if (callback.getType() === CallbackType$1.ConfirmationCallback) {
+        const cb = callback;
+        if (cb.getOptions().length === 1) {
+            return false;
+        }
+    }
+    return userInputCallbacks.includes(callback.getType());
+}
+// Notice this function can take a user provided argument function to
+// override behavior (this doesn't have to be well defined)
+function isUserInputOptional(callbackMetadataArray, numOfUserInputCbs, fn) {
+    // default reducer function to check if both overriding callback exists
+    // along with user input required callbacks
+    const fallbackFn = (prev, curr) => {
+        if (curr.derived.canForceUserInputOptionality && numOfUserInputCbs > 0) {
+            prev = true;
+        }
+        return prev;
+    };
+    // Call reduce function with either fallback or user provided function
+    return callbackMetadataArray.reduce(fn || fallbackFn, false);
+}
+
+/**
+ * @function buildCallbackMetadata - Constructs an array of callback metadata that matches to original callback array
+ * @param {object} step - The modified Widget step object
+ * @param checkValidation - function that checks if current callback is the first invalid callback
+ * @returns {array}
+ */
+function buildCallbackMetadata(step, checkValidation, stageJson) {
+    const callbackCount = {};
+    return step?.callbacks.map((callback, idx) => {
+        const cb = callback;
+        const callbackType = cb.getType();
+        let stageCbMetadata;
+        if (callbackCount[callbackType]) {
+            callbackCount[callbackType] = callbackCount[callbackType] + 1;
+        }
+        else {
+            callbackCount[callbackType] = 1;
+        }
+        if (stageJson && stageJson[callbackType]) {
+            const stageCbArray = stageJson[callbackType];
+            stageCbMetadata = stageCbArray[callbackCount[callbackType] - 1];
+        }
+        return {
+            derived: {
+                canForceUserInputOptionality: canForceUserInputOptionality(callback),
+                isFirstInvalidInput: checkValidation(callback),
+                isReadyForSubmission: isCbReadyByDefault(callback),
+                isSelfSubmitting: isSelfSubmitting(callback),
+                isUserInputRequired: requiresUserInput(callback),
+            },
+            idx,
+            // Only use the `platform` prop if there's metadata to add
+            ...(stageCbMetadata && {
+                platform: {
+                    ...stageCbMetadata,
+                },
+            }),
+        };
+    });
+}
+/**
+ * @function buildStepMetadata - Constructs a metadata object that summarizes the step from AM
+ * @param {array} callbackMetadataArray - The array returned from buildCallbackMetadata
+ * @returns {object}
+ */
+function buildStepMetadata(callbackMetadataArray, stageJson, stageName) {
+    const numOfUserInputCbs = callbackMetadataArray.filter((cb) => !!cb.derived.isUserInputRequired).length;
+    const userInputOptional = isUserInputOptional(callbackMetadataArray, numOfUserInputCbs);
+    let stageMetadata;
+    if (stageJson) {
+        stageMetadata = Object.keys(stageJson).reduce((prev, curr) => {
+            // Filter out objects or arrays as those are for the callbacks
+            if (typeof stageJson[curr] !== 'object') {
+                prev[curr] = stageJson[curr];
+            }
+            return prev;
+        }, {});
+    }
+    return {
+        derived: {
+            isStepSelfSubmittable: isStepSelfSubmittable(callbackMetadataArray, userInputOptional),
+            isUserInputOptional: userInputOptional,
+            numOfCallbacks: callbackMetadataArray.length,
+            numOfSelfSubmittableCbs: callbackMetadataArray.filter((cb) => !!cb.derived.isSelfSubmitting)
+                .length,
+            numOfUserInputCbs: numOfUserInputCbs,
+        },
+        // Only use the `platform` prop if there's metadata to add
+        ...(stageMetadata && {
+            platform: {
+                ...stageMetadata,
+            },
+        }),
+        // stageName and stateMetadata are mutually exclusive
+        ...(stageName && {
+            platform: {
+                stageName,
+            }
+        }),
+    };
+}
+
+function initializeStack(initOptions) {
+    const initialValue = initOptions ? [initOptions] : [];
+    const { update, set, subscribe } = writable(initialValue);
+    // Assign to exported variable (see bottom of file)
+    stack = {
+        pop: async () => {
+            return new Promise((resolve) => {
+                update((current) => {
+                    let state;
+                    if (current.length) {
+                        state = current.slice(0, -1);
+                    }
+                    else {
+                        state = current;
+                    }
+                    resolve([...state]);
+                    return state;
+                });
+            });
+        },
+        push: async (options) => {
+            return new Promise((resolve) => {
+                update((current) => {
+                    let state;
+                    if (!current.length) {
+                        state = [{ ...options }];
+                    }
+                    else if (options && options?.tree !== current[current.length - 1]?.tree) {
+                        state = [...current, options];
+                    }
+                    else {
+                        state = current;
+                    }
+                    resolve([...state]);
+                    return state;
+                });
+            });
+        },
+        reset: () => {
+            set([]);
+        },
+        subscribe,
+    };
+    return stack;
+}
+const journeyStore = writable({
+    completed: false,
+    error: null,
+    loading: false,
+    metadata: null,
+    step: null,
+    successful: false,
+    response: null,
+});
+function initialize$4(initOptions) {
+    const stack = initializeStack();
+    let restartOptions;
+    let stepNumber = 0;
+    async function next(prevStep = null, nextOptions, resumeUrl) {
+        /**
+         * Create an options object with nextOptions overriding anything from initOptions
+         * TODO: Does this object merge need to be more granular?
+         */
+        const options = {
+            ...initOptions,
+            ...nextOptions,
+        };
+        // These options are reserved only for restarting a journey after failure
+        if (initOptions || nextOptions) {
+            restartOptions = {
+                // Prioritize next options over initialize options
+                ...initOptions,
+                ...nextOptions,
+            };
+        }
+        /**
+         * Save previous step information just in case we have a total
+         * form failure due to 400 response from ForgeRock.
+         */
+        let previousCallbacks;
+        if (prevStep && prevStep.type === StepType$1.Step) {
+            previousCallbacks = prevStep?.callbacks;
+        }
+        const previousPayload = prevStep?.payload;
+        let nextStep;
+        journeyStore.set({
+            completed: false,
+            error: null,
+            loading: true,
+            metadata: get_store_value(journeyStore).metadata,
+            step: prevStep,
+            successful: false,
+            response: null,
+        });
+        try {
+            if (resumeUrl) {
+                // If resuming an unknown journey remove the tree from the options
+                options.tree = undefined;
+                /**
+                 * Attempt to resume journey
+                 */
+                nextStep = await FRAuth$1.resume(resumeUrl, options);
+            }
+            else if (prevStep) {
+                // If continuing on a tree remove it from the options
+                options.tree = undefined;
+                /**
+                 * Initial attempt to retrieve next step
+                 */
+                nextStep = await FRAuth$1.next(prevStep, options);
+            }
+            else {
+                nextStep = await FRAuth$1.next(undefined, options);
+            }
+        }
+        catch (err) {
+            console.error(`Next step request | ${err}`);
+            /**
+             * Setup an object to display failure message
+             */
+            nextStep = new FRLoginFailure$1({
+                message: interpolate('unknownNetworkError'),
+            });
+        }
+        if (nextStep.type === StepType$1.Step) {
+            const stageAttribute = nextStep.getStage();
+            let stageJson = null;
+            let stageName = null;
+            // Check if stage attribute is serialized JSON
+            if (stageAttribute && stageAttribute.includes('{')) {
+                try {
+                    stageJson = JSON.parse(stageAttribute);
+                }
+                catch (err) {
+                    console.warn('Stage attribute value was not parsable');
+                }
+            }
+            else if (stageAttribute) {
+                stageName = stageAttribute;
+            }
+            const callbackMetadata = buildCallbackMetadata(nextStep, initCheckValidation(), stageJson);
+            const stepMetadata = buildStepMetadata(callbackMetadata, stageJson, stageName);
+            // Iterate on a successful progression
+            stepNumber = stepNumber + 1;
+            journeyStore.set({
+                completed: false,
+                error: null,
+                loading: false,
+                metadata: {
+                    callbacks: callbackMetadata,
+                    step: stepMetadata,
+                },
+                step: nextStep,
+                successful: false,
+                response: null,
+            });
+        }
+        else if (nextStep.type === StepType$1.LoginSuccess) {
+            /**
+             * SUCCESSFUL COMPLETION BLOCK
+             */
+            // Set final state
+            journeyStore.set({
+                completed: true,
+                error: null,
+                loading: false,
+                metadata: null,
+                step: null,
+                successful: true,
+                response: nextStep.payload,
+            });
+        }
+        else if (nextStep.type === StepType$1.LoginFailure) {
+            /**
+             * FAILURE COMPLETION BLOCK
+             *
+             * Grab failure message, which may contain encoded HTML
+             */
+            const failureMessageStr = htmlDecode(nextStep.payload.message || '');
+            let restartedStep = null;
+            try {
+                /**
+                 * Restart tree to get fresh step
+                 */
+                restartedStep = await FRAuth$1.next(undefined, restartOptions);
+            }
+            catch (err) {
+                console.error(`Restart failed step request | ${err}`);
+                /**
+                 * Setup an object to display failure message
+                 */
+                restartedStep = new FRLoginFailure$1({
+                    message: interpolate('unknownNetworkError'),
+                });
+            }
+            /**
+             * Now that we have a new authId (the identification of the
+             * fresh step) let's populate this new step with old callback data if
+             * this is step one and meets a few criteria.
+             *
+             * If error code is 110 or error message includes "Constrained Violation",
+             * then the issue needs special handling.
+             *
+             * If this is the first step in the journey, replace the callbacks with
+             * existing callbacks to resubmit with a fresh authId.
+             ******************************************************************* */
+            if (shouldPopulateWithPreviousCallbacks(nextStep, previousCallbacks, restartedStep, stepNumber)) {
+                /**
+                 * TypeScript notes:
+                 *
+                 * Assert that restartedStep is FRStep as that is required for the above condition to be true.
+                 * Also, assert that previousCallbacks is FRCallback[] as that too is required for above to be true.
+                 *
+                 * Attempt a refactor using Ryan's suggestion found here: https://www.typescriptlang.org/play?#code/PTAEHUFMBsGMHsC2lQBd5oBYoCoE8AHSAZVgCcBLA1UABWgEM8BzM+AVwDsATAGiwoBnUENANQAd0gAjQRVSQAUCEmYKsTKGYUAbpGF4OY0BoadYKdJMoL+gzAzIoz3UNEiPOofEVKVqAHSKymAAmkYI7NCuqGqcANag8ABmIjQUXrFOKBJMggBcISGgoAC0oACCbvCwDKgU8JkY7p7ehCTkVDQS2E6gnPCxGcwmZqDSTgzxxWWVoASMFmgYkAAeRJTInN3ymj4d-jSCeNsMq-wuoPaOltigAKoASgAywhK7SbGQZIIz5VWCFzSeCrZagNYbChbHaxUDcCjJZLfSDbExIAgUdxkUBIursJzCFJtXydajBZJcWD1RqgJyofGcABqDGg7EgAB4cAA+AAUq3y3nBqwUPGEglQlE4IwA-FcJcNQALOOxENJvgBKUAAb0UJT1CNAPNQ7SJoIAvBbQAAiZWq75WzV0hmgUG6vXg6CCFBOsheVZukoB0CKAC+incNCGUtAZtpkHpvuZrI54slzF5VoAjA6ANzkynUrxCYjyqV8gWphUAH36KrVZHVAuB8BaXh17oNRpNqXNloA5JWpX3Ne33XqfZkyGy8+6w0GJziWV683PO8XS8wjXFmOqR0Go8wAhlYKzuPoeVbsNBoPBc6HgiocM0PL7QIh4H0GMD2JG7owpewDDMJA-AnuoiRfvAegiF4VoAKKrAwiALPoVpJNiVrgA4qADqAABykASFaQQqAA8l8ZDvF6-DAUcqCOAorjSHgcbvjoCpfF6aKINCwiXF8kgftEIgGBw2ILEwrAcDwQQlEAA
+                 */
+                restartedStep = restartedStep;
+                // Rebuild callbacks onto restartedStep
+                restartedStep.callbacks = previousCallbacks;
+                // Rebuild payload onto restartedStep ensuring the use of the NEW authId
+                restartedStep.payload = {
+                    ...previousPayload,
+                    authId: restartedStep.payload.authId,
+                };
+                const details = nextStep.payload.detail;
+                /**
+                 * Only if the authId expires do we resubmit with same callback values
+                 */
+                if (details?.errorCode === authIdTimeoutErrorCode) {
+                    restartedStep = await FRAuth$1.next(restartedStep, options);
+                }
+            }
+            /**
+             * SET RESULT OF SUBSEQUENT REQUEST
+             *
+             * After the above attempts to salvage the form submission, let's return
+             * the final result to the user.
+             */
+            if (restartedStep.type === StepType$1.Step) {
+                const stageAttribute = restartedStep.getStage();
+                let stageJson = null;
+                let stageName = null;
+                // Check if stage attribute is serialized JSON
+                if (stageAttribute && stageAttribute.includes('{')) {
+                    try {
+                        stageJson = JSON.parse(stageAttribute);
+                    }
+                    catch (err) {
+                        console.warn('Stage attribute value was not parsable');
+                    }
+                }
+                else if (stageAttribute) {
+                    stageName = stageAttribute;
+                }
+                const callbackMetadata = buildCallbackMetadata(restartedStep, initCheckValidation(), stageJson);
+                const stepMetadata = buildStepMetadata(callbackMetadata, stageJson, stageName);
+                journeyStore.set({
+                    completed: false,
+                    error: {
+                        code: nextStep.getCode(),
+                        message: failureMessageStr,
+                        // TODO: Should we remove the callbacks for PII info?
+                        step: prevStep?.payload,
+                    },
+                    loading: false,
+                    metadata: {
+                        callbacks: callbackMetadata,
+                        step: stepMetadata,
+                    },
+                    step: restartedStep,
+                    successful: false,
+                    response: null,
+                });
+            }
+            else if (restartedStep.type === StepType$1.LoginSuccess) {
+                journeyStore.set({
+                    completed: true,
+                    error: null,
+                    loading: false,
+                    metadata: null,
+                    step: null,
+                    successful: true,
+                    response: restartedStep.payload,
+                });
+            }
+            else {
+                journeyStore.set({
+                    completed: true,
+                    error: {
+                        code: nextStep.getCode(),
+                        message: failureMessageStr,
+                        // TODO: Should we remove the callbacks for PII info?
+                        step: prevStep?.payload,
+                    },
+                    loading: false,
+                    metadata: null,
+                    step: null,
+                    successful: false,
+                    response: restartedStep.payload,
+                });
+            }
+        }
+    }
+    async function pop() {
+        reset();
+        const updatedStack = await stack.pop();
+        const currentJourney = updatedStack[updatedStack.length - 1];
+        await start(currentJourney);
+    }
+    async function push(newOptions) {
+        reset();
+        await stack.push(newOptions);
+        await start(newOptions);
+    }
+    async function resume(url, resumeOptions) {
+        await next(undefined, resumeOptions, url);
+    }
+    async function start(startOptions) {
+        await stack.push(startOptions);
+        await next(undefined, startOptions);
+    }
+    function reset() {
+        journeyStore.set({
+            completed: false,
+            error: null,
+            loading: false,
+            metadata: null,
+            step: null,
+            successful: false,
+            response: null,
+        });
+    }
+    return {
+        next,
+        pop,
+        push,
+        reset,
+        resume,
+        start,
+        subscribe: journeyStore.subscribe,
+    };
+}
+let stack;
+
+const linksSchema = mod
+    .object({
+    termsAndConditions: mod.string(),
+})
+    .strict();
+linksSchema.partial();
+const linksStore = writable();
+function initialize$3(customLinks) {
+    // If customLinks is provided, provide feedback for object
+    if (customLinks) {
+        // Provide developer feedback for custom links
+        linksSchema.parse(customLinks);
+        linksStore.set(customLinks);
+    }
+    return linksStore;
+}
+
+const oauthStore = writable({
+    completed: false,
+    error: null,
+    loading: false,
+    successful: false,
+    response: null,
+});
+function initialize$2(initOptions) {
+    async function get(getOptions) {
+        /**
+         * Create an options object with getOptions overriding anything from initOptions
+         * TODO: Does this object merge need to be more granular?
+         */
+        const options = {
+            ...{ query: { prompt: 'none' } },
+            ...initOptions,
+            ...getOptions,
+        };
+        let tokens;
+        oauthStore.set({
+            completed: false,
+            error: null,
+            loading: true,
+            successful: false,
+            response: null,
+        });
+        try {
+            tokens = await TokenManager$1.getTokens(options);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                oauthStore.set({
+                    completed: true,
+                    error: {
+                        message: err.message,
+                    },
+                    loading: false,
+                    successful: false,
+                    response: null,
+                });
+            }
+            return;
+        }
+        oauthStore.set({
+            completed: true,
+            error: null,
+            loading: false,
+            successful: true,
+            response: tokens,
+        });
+    }
+    function reset() {
+        oauthStore.set({
+            completed: false,
+            error: null,
+            loading: false,
+            successful: false,
+            response: null,
+        });
+    }
+    return {
+        get,
+        reset,
+        subscribe: oauthStore.subscribe,
+    };
+}
+
+const userStore = writable({
+    completed: false,
+    error: null,
+    loading: false,
+    successful: false,
+    response: null,
+});
+function initialize$1(initOptions) {
+    async function get(getOptions) {
+        /**
+         * Create an options object with getOptions overriding anything from initOptions
+         * TODO: Does this object merge need to be more granular?
+         */
+        const options = {
+            ...initOptions,
+            ...getOptions,
+        };
+        userStore.set({
+            completed: false,
+            error: null,
+            loading: true,
+            successful: false,
+            response: null,
+        });
+        try {
+            const user = await UserManager.getCurrentUser(options);
+            userStore.set({
+                completed: true,
+                error: null,
+                loading: false,
+                successful: true,
+                response: user,
+            });
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                userStore.set({
+                    completed: true,
+                    error: {
+                        message: err.message,
+                    },
+                    loading: false,
+                    successful: false,
+                    response: null,
+                });
+            }
+        }
+    }
+    function reset() {
+        userStore.set({
+            completed: false,
+            error: null,
+            loading: false,
+            successful: false,
+            response: null,
+        });
+    }
+    return {
+        get,
+        reset,
+        subscribe: userStore.subscribe,
+    };
+}
+
+const logoSchema = mod
+    .object({
+    dark: mod.string().optional(),
+    height: mod.number().optional(),
+    light: mod.string().optional(),
+    width: mod.number().optional(),
+})
+    .strict();
+const styleSchema = mod
+    .object({
+    checksAndRadios: mod.union([mod.literal('animated'), mod.literal('standard')]).optional(),
+    labels: mod.union([mod.literal('floating').optional(), mod.literal('stacked')]).optional(),
+    logo: logoSchema.optional(),
+    sections: mod
+        .object({
+        header: mod.boolean().optional(),
+    })
+        .optional(),
+    stage: mod
+        .object({
+        icon: mod.boolean().optional(),
+    })
+        .optional(),
+})
+    .strict();
+styleSchema.partial();
+const styleStore = writable({
+    checksAndRadios: 'animated',
+    labels: 'floating',
+    logo: {},
+    sections: {},
+    stage: {},
+});
+function initialize(customStyle) {
+    if (customStyle) {
+        styleSchema.parse(customStyle);
+        styleStore.set(customStyle);
+    }
+    return styleStore;
+}
+
+function widgetApiFactory(componentApi) {
+    let journeyStore;
+    let oauthStore;
+    let userStore;
+    function getStores() {
+        return {
+            journeyStore,
+            oauthStore,
+            userStore,
+        };
+    }
+    function resetAndRestartStores() {
+        // Reset stores
+        journeyStore.reset();
+        oauthStore.reset();
+        userStore.reset();
+        // Fetch fresh journey step
+        journey().start();
+    }
+    const configuration = (options) => {
+        if (options?.config) {
+            configure({
+                // Set some basics by default
+                ...{
+                    // TODO: Could this be a default OAuth client provided by Platform UI OOTB?
+                    clientId: 'WebLoginWidgetClient',
+                    // TODO: If a realmPath is not provided, should we call the realm endpoint and detect a likely default?
+                    // https://backstage.forgerock.com/docs/am/7/setup-guide/sec-rest-realm-rest.html#rest-api-list-realm
+                    realmPath: 'alpha',
+                    // TODO: Once we move to SSR, this default should be more intelligent
+                    redirectUri: typeof window === 'object' ? window.location.href : 'https://localhost:3000/callback',
+                    scope: 'openid email',
+                },
+                // Let user provided config override defaults
+                ...options?.config,
+                // Force 'legacy' to remove confusion
+                ...{ support: 'legacy' },
+            });
+        }
+        /**
+         * Initialize the stores and ensure both variables point to the same reference.
+         * Variables with _ are the reactive version of the original variable from above.
+         */
+        journeyStore = initialize$4(options?.config);
+        oauthStore = initialize$2(options?.config);
+        userStore = initialize$1(options?.config);
+        initialize$5(options?.content);
+        initialize$6(options?.journeys);
+        initialize$3(options?.links);
+        initialize(options?.style);
+        return {
+            set(setOptions) {
+                if (setOptions?.config) {
+                    configure({
+                        // Set some basics by default
+                        ...{
+                            // TODO: Could this be a default OAuth client provided by Platform UI OOTB?
+                            clientId: 'WebLoginWidgetClient',
+                            // TODO: If a realmPath is not provided, should we call the realm endpoint and detect a likely default?
+                            // https://backstage.forgerock.com/docs/am/7/setup-guide/sec-rest-realm-rest.html#rest-api-list-realm
+                            realmPath: 'alpha',
+                            // TODO: Once we move to SSR, this default should be more intelligent
+                            redirectUri: typeof window === 'object'
+                                ? window.location.href
+                                : 'https://localhost:3000/callback',
+                            scope: 'openid email',
+                        },
+                        // Let user provided config override defaults
+                        ...setOptions?.config,
+                        // Force 'legacy' to remove confusion
+                        ...{ support: 'legacy' },
+                    });
+                }
+                /**
+                 * Initialize the stores and ensure both variables point to the same reference.
+                 * Variables with _ are the reactive version of the original variable from above.
+                 */
+                journeyStore = initialize$4(setOptions?.config);
+                oauthStore = initialize$2(setOptions?.config);
+                userStore = initialize$1(setOptions?.config);
+                initialize$5(setOptions?.content);
+                initialize$6(setOptions?.journeys);
+                initialize$3(setOptions?.links);
+                initialize(setOptions?.style);
+            },
+        };
+    };
+    const journey = (options) => {
+        const requestsOauth = options?.oauth || true;
+        const requestsUser = options?.user || true;
+        const { subscribe, } = derived([journeyStore, oauthStore, userStore], ([$journeyStore, $oauthStore, $userStore], set) => {
+            set({
+                journey: $journeyStore,
+                oauth: $oauthStore,
+                user: $userStore,
+            });
+            if ($journeyStore) {
+                if ($journeyStore.successful && $oauthStore.successful && $userStore.completed) {
+                    formFactor === 'modal' && componentApi.close({ reason: 'auto' });
+                }
+                else if ($journeyStore.successful && $oauthStore.successful) {
+                    if (requestsUser && $userStore.loading === false && $userStore.completed === false) {
+                        userStore.get();
+                    }
+                    else if (!requestsUser) {
+                        formFactor === 'modal' && componentApi.close({ reason: 'auto' });
+                    }
+                }
+                else if ($journeyStore.successful) {
+                    if (requestsOauth &&
+                        $oauthStore.loading === false &&
+                        $oauthStore.completed === false) {
+                        oauthStore.get();
+                    }
+                    else if (!requestsOauth) {
+                        formFactor === 'modal' && componentApi.close({ reason: 'auto' });
+                    }
+                }
+            }
+        });
+        // Create a simple reference to prevent repeated subscribing and unsubscribing
+        let formFactor = null;
+        function start(startOptions) {
+            // Grab the form factor and cache it
+            formFactor = get_store_value(componentStore).type;
+            if (startOptions?.resumeUrl) {
+                journeyStore.resume(startOptions.resumeUrl);
+            }
+            else {
+                journeyStore.start({
+                    ...startOptions?.config,
+                    tree: startOptions?.journey,
+                });
+            }
+            return new Promise((resolve) => {
+                const unsubscribe = subscribe((event) => {
+                    if (event.journey.successful && event.oauth.successful && event.user.completed) {
+                        resolve(event);
+                        unsubscribe();
+                    }
+                    else if (event.journey.successful && event.oauth.successful) {
+                        if (!requestsUser) {
+                            resolve(event);
+                            unsubscribe();
+                        }
+                    }
+                    else if (event.journey.successful) {
+                        if (!requestsOauth) {
+                            resolve(event);
+                            unsubscribe();
+                        }
+                    }
+                });
+            });
+        }
+        return { start, subscribe };
+    };
+    const user = {
+        info() {
+            const { get, subscribe } = userStore;
+            function wrappedGet(options) {
+                get(options);
+                return new Promise((resolve) => {
+                    const unsubscribe = userStore.subscribe((event) => {
+                        if (event.completed) {
+                            resolve(event);
+                            unsubscribe();
+                        }
+                    });
+                });
+            }
+            return { get: wrappedGet, subscribe };
+        },
+        async logout() {
+            const { clientId } = Config.get();
+            let obj;
+            /**
+             * If configuration has a clientId, then use FRUser to logout to ensure
+             * token revoking and removal; else, just end the session.
+             */
+            if (clientId) {
+                obj = FRUser;
+            }
+            else {
+                obj = SessionManager;
+            }
+            try {
+                await obj.logout();
+                resetAndRestartStores();
+            }
+            catch (err) {
+                // Regardless of errors, reset all stores and restart journey
+                resetAndRestartStores();
+                throw err;
+            }
+            // Return undefined as there's no response information to share
+            return;
+        },
+        tokens() {
+            const { get, subscribe } = oauthStore;
+            function wrappedGet(options) {
+                get(options);
+                return new Promise((resolve) => {
+                    const unsubscribe = oauthStore.subscribe((event) => {
+                        if (event.completed) {
+                            resolve(event);
+                            unsubscribe();
+                        }
+                    });
+                });
+            }
+            return { get: wrappedGet, subscribe };
+        },
+    };
+    return {
+        component: componentApi,
+        configuration,
+        getStores,
+        journey,
+        request: _default$2.request,
+        user,
+    };
+}
+
 /* src/lib/components/_utilities/locale-strings.svelte generated by Svelte v3.55.1 */
 
-function create_else_block$9(ctx) {
+function create_else_block$a(ctx) {
 	let current;
 	const default_slot_template = /*#slots*/ ctx[5].default;
 	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[4], null);
@@ -16293,7 +17224,7 @@ function create_else_block$9(ctx) {
 }
 
 // (11:0) {#if html}
-function create_if_block$m(ctx) {
+function create_if_block$n(ctx) {
 	let current;
 	const default_slot_template = /*#slots*/ ctx[5].default;
 	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[4], null);
@@ -16395,7 +17326,7 @@ function create_fragment$W(ctx) {
 	let if_block;
 	let if_block_anchor;
 	let current;
-	const if_block_creators = [create_if_block$m, create_else_block$9];
+	const if_block_creators = [create_if_block$n, create_else_block$a];
 	const if_blocks = [];
 
 	function select_block_type(ctx, dirty) {
@@ -16590,53 +17521,9 @@ class X_icon extends SvelteComponent {
 	}
 }
 
-const logoSchema = mod
-    .object({
-    dark: mod.string().optional(),
-    height: mod.number().optional(),
-    light: mod.string().optional(),
-    width: mod.number().optional(),
-})
-    .strict();
-const styleSchema = mod
-    .object({
-    checksAndRadios: mod.union([mod.literal('animated'), mod.literal('standard')]).optional(),
-    labels: mod.union([mod.literal('floating').optional(), mod.literal('stacked')]).optional(),
-    logo: logoSchema.optional(),
-    sections: mod
-        .object({
-        header: mod.boolean().optional(),
-    })
-        .optional(),
-    stage: mod
-        .object({
-        icon: mod.boolean().optional(),
-    })
-        .optional(),
-})
-    .strict();
-styleSchema.partial();
-let style;
-const fallbackStyle = {
-    checksAndRadios: 'animated',
-    labels: 'floating',
-    logo: {},
-    sections: {},
-    stage: {},
-};
-function initialize$5(customStyle) {
-    if (customStyle) {
-        styleSchema.parse(customStyle);
-        style = readable(customStyle);
-    }
-    else {
-        style = readable(fallbackStyle);
-    }
-}
-
 /* src/lib/components/compositions/dialog/dialog.svelte generated by Svelte v3.55.1 */
 
-function create_else_block$8(ctx) {
+function create_else_block$9(ctx) {
 	let div;
 	let button;
 	let xicon;
@@ -16654,7 +17541,7 @@ function create_else_block$8(ctx) {
 			}
 		});
 
-	let if_block = /*$style*/ ctx[5]?.logo && create_if_block_1$c(ctx);
+	let if_block = /*$styleStore*/ ctx[5]?.logo && create_if_block_1$c(ctx);
 
 	return {
 		c() {
@@ -16666,7 +17553,7 @@ function create_else_block$8(ctx) {
 			attr(button, "class", "tw_dialog-x md:tw_dialog-x_medium tw_focusable-element dark:tw_focusable-element_dark");
 			attr(button, "aria-controls", /*dialogId*/ ctx[1]);
 
-			attr(div, "class", div_class_value = `tw_pt-10 md:tw_pt-10 tw_text-right ${(/*$style*/ ctx[5]?.logo)
+			attr(div, "class", div_class_value = `tw_pt-10 md:tw_pt-10 tw_text-right ${(/*$styleStore*/ ctx[5]?.logo)
 			? 'tw_h-32 md:tw_h-36  tw_pb-6'
 			: ''}`);
 		},
@@ -16679,14 +17566,14 @@ function create_else_block$8(ctx) {
 			current = true;
 
 			if (!mounted) {
-				dispose = listen(button, "click", /*click_handler_1*/ ctx[9]);
+				dispose = listen(button, "click", /*click_handler_1*/ ctx[8]);
 				mounted = true;
 			}
 		},
 		p(ctx, dirty) {
 			const xicon_changes = {};
 
-			if (dirty & /*$$scope*/ 2048) {
+			if (dirty & /*$$scope*/ 1024) {
 				xicon_changes.$$scope = { dirty, ctx };
 			}
 
@@ -16696,7 +17583,7 @@ function create_else_block$8(ctx) {
 				attr(button, "aria-controls", /*dialogId*/ ctx[1]);
 			}
 
-			if (/*$style*/ ctx[5]?.logo) {
+			if (/*$styleStore*/ ctx[5]?.logo) {
 				if (if_block) {
 					if_block.p(ctx, dirty);
 				} else {
@@ -16709,7 +17596,7 @@ function create_else_block$8(ctx) {
 				if_block = null;
 			}
 
-			if (!current || dirty & /*$style*/ 32 && div_class_value !== (div_class_value = `tw_pt-10 md:tw_pt-10 tw_text-right ${(/*$style*/ ctx[5]?.logo)
+			if (!current || dirty & /*$styleStore*/ 32 && div_class_value !== (div_class_value = `tw_pt-10 md:tw_pt-10 tw_text-right ${(/*$styleStore*/ ctx[5]?.logo)
 			? 'tw_h-32 md:tw_h-36  tw_pb-6'
 			: ''}`)) {
 				attr(div, "class", div_class_value);
@@ -16734,8 +17621,8 @@ function create_else_block$8(ctx) {
 	};
 }
 
-// (39:2) {#if withHeader}
-function create_if_block$l(ctx) {
+// (45:2) {#if withHeader}
+function create_if_block$m(ctx) {
 	let div1;
 	let div0;
 	let div0_style_value;
@@ -16763,10 +17650,10 @@ function create_if_block$l(ctx) {
 			create_component(xicon.$$.fragment);
 			attr(div0, "class", "tw_dialog-logo dark:tw_dialog-logo_dark");
 
-			attr(div0, "style", div0_style_value = `--logo-dark: url("${/*$style*/ ctx[5]?.logo?.dark}"); --logo-light: url("${/*$style*/ ctx[5]?.logo?.light}"); ${(/*$style*/ ctx[5]?.logo?.height)
-			? `height: ${/*$style*/ ctx[5]?.logo.height}px;`
-			: ''} ${(/*$style*/ ctx[5]?.logo?.width)
-			? `width: ${/*$style*/ ctx[5]?.logo.width}px;`
+			attr(div0, "style", div0_style_value = `--logo-dark: url("${/*$styleStore*/ ctx[5]?.logo?.dark}"); --logo-light: url("${/*$styleStore*/ ctx[5]?.logo?.light}"); ${(/*$styleStore*/ ctx[5]?.logo?.height)
+			? `height: ${/*$styleStore*/ ctx[5]?.logo.height}px;`
+			: ''} ${(/*$styleStore*/ ctx[5]?.logo?.width)
+			? `width: ${/*$styleStore*/ ctx[5]?.logo.width}px;`
 			: ''}`);
 
 			attr(button, "class", "tw_dialog-x md:tw_dialog-x_medium tw_focusable-element dark:tw_focusable-element_dark");
@@ -16782,22 +17669,22 @@ function create_if_block$l(ctx) {
 			current = true;
 
 			if (!mounted) {
-				dispose = listen(button, "click", /*click_handler*/ ctx[8]);
+				dispose = listen(button, "click", /*click_handler*/ ctx[7]);
 				mounted = true;
 			}
 		},
 		p(ctx, dirty) {
-			if (!current || dirty & /*$style*/ 32 && div0_style_value !== (div0_style_value = `--logo-dark: url("${/*$style*/ ctx[5]?.logo?.dark}"); --logo-light: url("${/*$style*/ ctx[5]?.logo?.light}"); ${(/*$style*/ ctx[5]?.logo?.height)
-			? `height: ${/*$style*/ ctx[5]?.logo.height}px;`
-			: ''} ${(/*$style*/ ctx[5]?.logo?.width)
-			? `width: ${/*$style*/ ctx[5]?.logo.width}px;`
+			if (!current || dirty & /*$styleStore*/ 32 && div0_style_value !== (div0_style_value = `--logo-dark: url("${/*$styleStore*/ ctx[5]?.logo?.dark}"); --logo-light: url("${/*$styleStore*/ ctx[5]?.logo?.light}"); ${(/*$styleStore*/ ctx[5]?.logo?.height)
+			? `height: ${/*$styleStore*/ ctx[5]?.logo.height}px;`
+			: ''} ${(/*$styleStore*/ ctx[5]?.logo?.width)
+			? `width: ${/*$styleStore*/ ctx[5]?.logo.width}px;`
 			: ''}`)) {
 				attr(div0, "style", div0_style_value);
 			}
 
 			const xicon_changes = {};
 
-			if (dirty & /*$$scope*/ 2048) {
+			if (dirty & /*$$scope*/ 1024) {
 				xicon_changes.$$scope = { dirty, ctx };
 			}
 
@@ -16825,7 +17712,7 @@ function create_if_block$l(ctx) {
 	};
 }
 
-// (71:8) <XIcon           classes="tw_inline-block tw_fill-current tw_text-secondary-dark dark:tw_text-secondary-light"           >
+// (77:8) <XIcon           classes="tw_inline-block tw_fill-current tw_text-secondary-dark dark:tw_text-secondary-light"           >
 function create_default_slot_1$c(ctx) {
 	let t;
 	let current;
@@ -16855,7 +17742,7 @@ function create_default_slot_1$c(ctx) {
 	};
 }
 
-// (76:6) {#if $style?.logo}
+// (82:6) {#if $styleStore?.logo}
 function create_if_block_1$c(ctx) {
 	let div;
 	let div_style_value;
@@ -16864,13 +17751,13 @@ function create_if_block_1$c(ctx) {
 		c() {
 			div = element("div");
 			attr(div, "class", "tw_dialog-logo dark:tw_dialog-logo_dark");
-			attr(div, "style", div_style_value = `--logo-dark: url("${/*$style*/ ctx[5]?.logo?.dark}"); --logo-light: url("${/*$style*/ ctx[5]?.logo?.light}")`);
+			attr(div, "style", div_style_value = `--logo-dark: url("${/*$styleStore*/ ctx[5]?.logo?.dark}"); --logo-light: url("${/*$styleStore*/ ctx[5]?.logo?.light}")`);
 		},
 		m(target, anchor) {
 			insert(target, div, anchor);
 		},
 		p(ctx, dirty) {
-			if (dirty & /*$style*/ 32 && div_style_value !== (div_style_value = `--logo-dark: url("${/*$style*/ ctx[5]?.logo?.dark}"); --logo-light: url("${/*$style*/ ctx[5]?.logo?.light}")`)) {
+			if (dirty & /*$styleStore*/ 32 && div_style_value !== (div_style_value = `--logo-dark: url("${/*$styleStore*/ ctx[5]?.logo?.dark}"); --logo-light: url("${/*$styleStore*/ ctx[5]?.logo?.light}")`)) {
 				attr(div, "style", div_style_value);
 			}
 		},
@@ -16880,7 +17767,7 @@ function create_if_block_1$c(ctx) {
 	};
 }
 
-// (54:8) <XIcon           classes="tw_inline-block tw_fill-current tw_text-secondary-dark dark:tw_text-secondary-light"           >
+// (60:8) <XIcon           classes="tw_inline-block tw_fill-current tw_text-secondary-dark dark:tw_text-secondary-light"           >
 function create_default_slot$o(ctx) {
 	let t;
 	let current;
@@ -16918,7 +17805,7 @@ function create_fragment$U(ctx) {
 	let div;
 	let dialog_class_value;
 	let current;
-	const if_block_creators = [create_if_block$l, create_else_block$8];
+	const if_block_creators = [create_if_block$m, create_else_block$9];
 	const if_blocks = [];
 
 	function select_block_type(ctx, dirty) {
@@ -16928,8 +17815,8 @@ function create_fragment$U(ctx) {
 
 	current_block_type_index = select_block_type(ctx);
 	if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
-	const default_slot_template = /*#slots*/ ctx[7].default;
-	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[11], null);
+	const default_slot_template = /*#slots*/ ctx[6].default;
+	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[10], null);
 
 	return {
 		c() {
@@ -16953,7 +17840,7 @@ function create_fragment$U(ctx) {
 				default_slot.m(div, null);
 			}
 
-			/*dialog_binding*/ ctx[10](dialog);
+			/*dialog_binding*/ ctx[9](dialog);
 			current = true;
 		},
 		p(ctx, [dirty]) {
@@ -16984,15 +17871,15 @@ function create_fragment$U(ctx) {
 			}
 
 			if (default_slot) {
-				if (default_slot.p && (!current || dirty & /*$$scope*/ 2048)) {
+				if (default_slot.p && (!current || dirty & /*$$scope*/ 1024)) {
 					update_slot_base(
 						default_slot,
 						default_slot_template,
 						ctx,
-						/*$$scope*/ ctx[11],
+						/*$$scope*/ ctx[10],
 						!current
-						? get_all_dirty_from_scope(/*$$scope*/ ctx[11])
-						: get_slot_changes(default_slot_template, /*$$scope*/ ctx[11], dirty, null),
+						? get_all_dirty_from_scope(/*$$scope*/ ctx[10])
+						: get_slot_changes(default_slot_template, /*$$scope*/ ctx[10], dirty, null),
 						null
 					);
 				}
@@ -17025,30 +17912,34 @@ function create_fragment$U(ctx) {
 			if (detaching) detach(dialog);
 			if_blocks[current_block_type_index].d();
 			if (default_slot) default_slot.d(detaching);
-			/*dialog_binding*/ ctx[10](null);
+			/*dialog_binding*/ ctx[9](null);
 		}
 	};
 }
 
 function instance$V($$self, $$props, $$invalidate) {
-	let $style;
-	component_subscribe($$self, style, $$value => $$invalidate(5, $style = $$value));
+	let $styleStore;
+	component_subscribe($$self, styleStore, $$value => $$invalidate(5, $styleStore = $$value));
 	let { $$slots: slots = {}, $$scope } = $$props;
-	let { closeCallback } = $$props;
 	let { dialogEl = null } = $$props;
 	let { dialogId } = $$props;
 	let { forceOpen = false } = $$props;
 	let { withHeader = false } = $$props;
 
-	function closeDialog(args) {
-		const { reason } = args || { reason: 'external' };
-
+	function closeDialog(reason) {
 		function completeClose() {
 			dialogEl?.close();
 			dialogEl?.classList.remove('tw_dialog-closing');
 
-			// Call dev provided callback function for event hook
-			closeCallback && closeCallback({ reason });
+			// Ensure we have a store and it has an update method on it
+			componentStore?.update(state => {
+				if (state.open === false) {
+					// If state is already correct, just return the same reference
+					return state;
+				}
+
+				return { ...state, open: false, reason };
+			});
 		}
 
 		// Create timer in case the CSS is not loaded
@@ -17070,8 +17961,8 @@ function instance$V($$self, $$props, $$invalidate) {
 		dialogEl?.classList.add('tw_dialog-closing');
 	}
 
-	const click_handler = () => closeDialog({ reason: 'user' });
-	const click_handler_1 = () => closeDialog({ reason: 'user' });
+	const click_handler = () => closeDialog('user');
+	const click_handler_1 = () => closeDialog('user');
 
 	function dialog_binding($$value) {
 		binding_callbacks[$$value ? 'unshift' : 'push'](() => {
@@ -17081,12 +17972,11 @@ function instance$V($$self, $$props, $$invalidate) {
 	}
 
 	$$self.$$set = $$props => {
-		if ('closeCallback' in $$props) $$invalidate(6, closeCallback = $$props.closeCallback);
 		if ('dialogEl' in $$props) $$invalidate(0, dialogEl = $$props.dialogEl);
 		if ('dialogId' in $$props) $$invalidate(1, dialogId = $$props.dialogId);
 		if ('forceOpen' in $$props) $$invalidate(2, forceOpen = $$props.forceOpen);
 		if ('withHeader' in $$props) $$invalidate(3, withHeader = $$props.withHeader);
-		if ('$$scope' in $$props) $$invalidate(11, $$scope = $$props.$$scope);
+		if ('$$scope' in $$props) $$invalidate(10, $$scope = $$props.$$scope);
 	};
 
 	return [
@@ -17095,8 +17985,7 @@ function instance$V($$self, $$props, $$invalidate) {
 		forceOpen,
 		withHeader,
 		closeDialog,
-		$style,
-		closeCallback,
+		$styleStore,
 		slots,
 		click_handler,
 		click_handler_1,
@@ -17110,7 +17999,6 @@ class Dialog extends SvelteComponent {
 		super();
 
 		init(this, options, instance$V, create_fragment$U, safe_not_equal, {
-			closeCallback: 6,
 			dialogEl: 0,
 			dialogId: 1,
 			forceOpen: 2,
@@ -17423,7 +18311,7 @@ class Warning_icon extends SvelteComponent {
 
 /* src/lib/components/primitives/alert/alert.svelte generated by Svelte v3.55.1 */
 
-function create_else_block$7(ctx) {
+function create_else_block$8(ctx) {
 	let infoicon;
 	let current;
 	infoicon = new Info_icon({});
@@ -17481,7 +18369,7 @@ function create_if_block_1$b(ctx) {
 }
 
 // (41:4) {#if type === 'error'}
-function create_if_block$k(ctx) {
+function create_if_block$l(ctx) {
 	let alerticon;
 	let current;
 	alerticon = new Alert_icon({});
@@ -17518,7 +18406,7 @@ function create_fragment$Q(ctx) {
 	let span;
 	let div_class_value;
 	let current;
-	const if_block_creators = [create_if_block$k, create_if_block_1$b, create_else_block$7];
+	const if_block_creators = [create_if_block$l, create_if_block_1$b, create_else_block$8];
 	const if_blocks = [];
 
 	function select_block_type(ctx, dirty) {
@@ -17753,7 +18641,7 @@ class Spinner extends SvelteComponent {
 
 /* src/lib/components/primitives/button/button.svelte generated by Svelte v3.55.1 */
 
-function create_if_block$j(ctx) {
+function create_if_block$k(ctx) {
 	let spinner;
 	let current;
 
@@ -17811,7 +18699,7 @@ function create_fragment$O(ctx) {
 	let current;
 	let mounted;
 	let dispose;
-	let if_block = /*busy*/ ctx[0] && create_if_block$j();
+	let if_block = /*busy*/ ctx[0] && create_if_block$k();
 	const default_slot_template = /*#slots*/ ctx[7].default;
 	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[6], null);
 	const default_slot_or_fallback = default_slot || fallback_block$1();
@@ -17853,7 +18741,7 @@ function create_fragment$O(ctx) {
 						transition_in(if_block, 1);
 					}
 				} else {
-					if_block = create_if_block$j();
+					if_block = create_if_block$k();
 					if_block.c();
 					transition_in(if_block, 1);
 					if_block.m(button, t);
@@ -17923,684 +18811,57 @@ function generateClassString$2(...args) {
 				case 'outline':
 					return `${prev} tw_button-outline dark:tw_button-outline_dark`;
 				case 'auto':
-					return `${prev} tw_w-auto`;
-				case 'full':
-					return `${prev} tw_w-full`;
-				default:
-					return prev;
-			}
-		},
-		''
-	);
-}
-
-function instance$P($$self, $$props, $$invalidate) {
-	let { $$slots: slots = {}, $$scope } = $$props;
-	let { busy = false } = $$props;
-	let { classes = '' } = $$props;
-
-	let { onClick = e => {
-		
-	} } = $$props;
-
-	let { style = 'outline' } = $$props;
-	let { type = null } = $$props;
-	let { width = 'auto' } = $$props;
-
-	$$self.$$set = $$props => {
-		if ('busy' in $$props) $$invalidate(0, busy = $$props.busy);
-		if ('classes' in $$props) $$invalidate(1, classes = $$props.classes);
-		if ('onClick' in $$props) $$invalidate(2, onClick = $$props.onClick);
-		if ('style' in $$props) $$invalidate(3, style = $$props.style);
-		if ('type' in $$props) $$invalidate(4, type = $$props.type);
-		if ('width' in $$props) $$invalidate(5, width = $$props.width);
-		if ('$$scope' in $$props) $$invalidate(6, $$scope = $$props.$$scope);
-	};
-
-	return [busy, classes, onClick, style, type, width, $$scope, slots];
-}
-
-class Button extends SvelteComponent {
-	constructor(options) {
-		super();
-
-		init(this, options, instance$P, create_fragment$O, safe_not_equal, {
-			busy: 0,
-			classes: 1,
-			onClick: 2,
-			style: 3,
-			type: 4,
-			width: 5
-		});
-	}
-}
-
-/*
- * forgerock-sample-web-react
- *
- * decode.js
- *
- * Copyright (c) 2021 ForgeRock. All rights reserved.
- * This software may be modified and distributed under the terms
- * of the MIT license. See the LICENSE file for details.
- */
-/**
- * @function htmlDecode - Decodes HTML encoded strings
- * @param {string} input - string that needs to be HTML decoded
- * @returns {string} - decoded string
- */
-function htmlDecode(input) {
-    // Check if running in server before using the document object
-    if (typeof document !== 'object') {
-        return null;
-    }
-    const e = document.createElement('div');
-    e.innerHTML = input;
-    return e.childNodes.length === 0 ? '' : e.childNodes[0].nodeValue;
-}
-
-const authIdTimeoutErrorCode = '110';
-const constrainedViolationMessage = 'constraint violation';
-/**
- * @function convertStringToKey -
- * @param {string} string
- * @returns {string}
- */
-function convertStringToKey(string) {
-    if (!string) {
-        return '';
-    }
-    if (string.toLocaleLowerCase().includes('constraint violation')) {
-        console.error('Delta Sierra error has occurred. Please communicate this to your system administrator.');
-        if (string.toLocaleLowerCase().includes('password')) {
-            return 'constraintViolationForPassword';
-        }
-        return 'constraintViolationForValue';
-    }
-    const replaceFunction = (_, char) => `${char.toLowerCase()}`;
-    const normalizedString = string
-        .replace(/^([A-Z])/g, replaceFunction)
-        .replace(/\s([a-z])/g, (_, char) => `${char.toUpperCase()}`);
-    const key = normalizedString.replace(/\W/g, '');
-    return key;
-}
-/**
- * @function initCheckValidation -
- * @returns {boolean}
- */
-function initCheckValidation() {
-    let hasPrevError = false;
-    return function checkValidation(callback) {
-        const failedPolices = callback.getOutputByName('failedPolicies', []);
-        if (failedPolices.length && !hasPrevError) {
-            hasPrevError = true;
-            return true;
-        }
-        return false;
-    };
-}
-/**
- * @function shouldRedirectFromStep -
- * @returns {boolean}
- */
-function shouldRedirectFromStep(step) {
-    return step.getCallbacksOfType(CallbackType$1.RedirectCallback).length > 0;
-}
-/**
- * @function shouldPopulateWithPreviousCallbacks -
- * @param {object} nextStep
- * @param {array} previousCallbacks
- * @param {object} restartedStep
- * @param {number} stepNumber
- * @returns {boolean}
- */
-function shouldPopulateWithPreviousCallbacks(nextStep, previousCallbacks, restartedStep, stepNumber) {
-    if (!Array.isArray(previousCallbacks)) {
-        return false;
-    }
-    if (restartedStep.type !== StepType$1.Step) {
-        return false;
-    }
-    if (stepNumber !== 1) {
-        return false;
-    }
-    const details = nextStep.payload.detail;
-    const message = nextStep.payload.message?.toLowerCase();
-    /**
-     * Now that we know we have previous callbacks, this is of type "Step",
-     * it has payload detail or payload message, and it's just the first step,
-     * we can populate the new step with old callbacks.
-     */
-    if (details?.errorCode === authIdTimeoutErrorCode ||
-        message?.includes(constrainedViolationMessage)) {
-        return true;
-    }
-    // Fallback to false
-    return false;
-}
-
-const selfSubmittingCallbacks = [
-    CallbackType$1.ConfirmationCallback,
-    CallbackType$1.DeviceProfileCallback,
-    CallbackType$1.PollingWaitCallback,
-    CallbackType$1.SelectIdPCallback,
-];
-const userInputCallbacks = [
-    CallbackType$1.BooleanAttributeInputCallback,
-    CallbackType$1.ChoiceCallback,
-    CallbackType$1.ConfirmationCallback,
-    CallbackType$1.KbaCreateCallback,
-    CallbackType$1.NameCallback,
-    CallbackType$1.NumberAttributeInputCallback,
-    CallbackType$1.PasswordCallback,
-    CallbackType$1.ReCaptchaCallback,
-    CallbackType$1.SelectIdPCallback,
-    CallbackType$1.StringAttributeInputCallback,
-    CallbackType$1.TermsAndConditionsCallback,
-    CallbackType$1.ValidatedCreatePasswordCallback,
-    CallbackType$1.ValidatedCreateUsernameCallback,
-];
-// This eventually will be overridable by user of framework
-const forceUserInputOptionalityCallbacks = {
-    SelectIdPCallback: (callback) => {
-        const selectIdpCb = callback;
-        return !!selectIdpCb
-            .getProviders()
-            .find((provider) => provider.provider === 'localAuthentication');
-    },
-};
-function isCbReadyByDefault(callback) {
-    if (callback.getType() === CallbackType$1.ConfirmationCallback) {
-        const cb = callback;
-        if (cb.getOptions().length === 1) {
-            return true;
-        }
-    }
-    return false;
-}
-function canForceUserInputOptionality(callback) {
-    // See if a callback function exists within this collection
-    const fn = forceUserInputOptionalityCallbacks[callback.getType()];
-    // If there is a function, run it and it will return a boolean
-    return fn ? fn(callback) : false;
-}
-/**
- * @function isSelfSubmitting -
- * @param {object} callback - generic FRCallback from JavaScript SDK
- * @returns
- */
-function isSelfSubmitting(callback) {
-    return selfSubmittingCallbacks.includes(callback.getType());
-}
-/**
- * @function isStepSelfSubmittable -
- * @param {array} callbacks - CallbackMetadata
- * @returns
- */
-function isStepSelfSubmittable(callbacks, userInputOptional) {
-    if (userInputOptional) {
-        return true;
-    }
-    const unsubmittableCallbacks = callbacks.filter((callback) => callback.derived.isUserInputRequired && !callback.derived.isSelfSubmitting);
-    return !unsubmittableCallbacks.length;
-}
-/**
- *
- * @param  {object} callback - Generic callback provided by JavaScript SDK
- * @returns
- */
-function requiresUserInput(callback) {
-    if (callback.getType() === CallbackType$1.SelectIdPCallback) {
-        return false;
-    }
-    if (callback.getType() === CallbackType$1.ConfirmationCallback) {
-        const cb = callback;
-        if (cb.getOptions().length === 1) {
-            return false;
-        }
-    }
-    return userInputCallbacks.includes(callback.getType());
-}
-// Notice this function can take a user provided argument function to
-// override behavior (this doesn't have to be well defined)
-function isUserInputOptional(callbackMetadataArray, numOfUserInputCbs, fn) {
-    // default reducer function to check if both overriding callback exists
-    // along with user input required callbacks
-    const fallbackFn = (prev, curr) => {
-        if (curr.derived.canForceUserInputOptionality && numOfUserInputCbs > 0) {
-            prev = true;
-        }
-        return prev;
-    };
-    // Call reduce function with either fallback or user provided function
-    return callbackMetadataArray.reduce(fn || fallbackFn, false);
-}
-
-/**
- * @function buildCallbackMetadata - Constructs an array of callback metadata that matches to original callback array
- * @param {object} step - The modified Widget step object
- * @param checkValidation - function that checks if current callback is the first invalid callback
- * @returns {array}
- */
-function buildCallbackMetadata(step, checkValidation, stageJson) {
-    const callbackCount = {};
-    return step?.callbacks.map((callback, idx) => {
-        const cb = callback;
-        const callbackType = cb.getType();
-        let stageCbMetadata;
-        if (callbackCount[callbackType]) {
-            callbackCount[callbackType] = callbackCount[callbackType] + 1;
-        }
-        else {
-            callbackCount[callbackType] = 1;
-        }
-        if (stageJson && stageJson[callbackType]) {
-            const stageCbArray = stageJson[callbackType];
-            stageCbMetadata = stageCbArray[callbackCount[callbackType] - 1];
-        }
-        return {
-            derived: {
-                canForceUserInputOptionality: canForceUserInputOptionality(callback),
-                isFirstInvalidInput: checkValidation(callback),
-                isReadyForSubmission: isCbReadyByDefault(callback),
-                isSelfSubmitting: isSelfSubmitting(callback),
-                isUserInputRequired: requiresUserInput(callback),
-            },
-            idx,
-            // Only use the `platform` prop if there's metadata to add
-            ...(stageCbMetadata && {
-                platform: {
-                    ...stageCbMetadata,
-                },
-            }),
-        };
-    });
-}
-/**
- * @function buildStepMetadata - Constructs a metadata object that summarizes the step from AM
- * @param {array} callbackMetadataArray - The array returned from buildCallbackMetadata
- * @returns {object}
- */
-function buildStepMetadata(callbackMetadataArray, stageJson, stageName) {
-    const numOfUserInputCbs = callbackMetadataArray.filter((cb) => !!cb.derived.isUserInputRequired).length;
-    const userInputOptional = isUserInputOptional(callbackMetadataArray, numOfUserInputCbs);
-    let stageMetadata;
-    if (stageJson) {
-        stageMetadata = Object.keys(stageJson).reduce((prev, curr) => {
-            // Filter out objects or arrays as those are for the callbacks
-            if (typeof stageJson[curr] !== 'object') {
-                prev[curr] = stageJson[curr];
-            }
-            return prev;
-        }, {});
-    }
-    return {
-        derived: {
-            isStepSelfSubmittable: isStepSelfSubmittable(callbackMetadataArray, userInputOptional),
-            isUserInputOptional: userInputOptional,
-            numOfCallbacks: callbackMetadataArray.length,
-            numOfSelfSubmittableCbs: callbackMetadataArray.filter((cb) => !!cb.derived.isSelfSubmitting)
-                .length,
-            numOfUserInputCbs: numOfUserInputCbs,
-        },
-        // Only use the `platform` prop if there's metadata to add
-        ...(stageMetadata && {
-            platform: {
-                ...stageMetadata,
-            },
-        }),
-        // stageName and stateMetadata are mutually exclusive
-        ...(stageName && {
-            platform: {
-                stageName,
-            }
-        }),
-    };
+					return `${prev} tw_w-auto`;
+				case 'full':
+					return `${prev} tw_w-full`;
+				default:
+					return prev;
+			}
+		},
+		''
+	);
 }
 
-function initializeStack(initOptions) {
-    const initialValue = initOptions ? [initOptions] : [];
-    const { update, set, subscribe } = writable(initialValue);
-    // Assign to exported variable (see bottom of file)
-    stack = {
-        pop: async () => {
-            return new Promise((resolve) => {
-                update((current) => {
-                    let state;
-                    if (current.length) {
-                        state = current.slice(0, -1);
-                    }
-                    else {
-                        state = current;
-                    }
-                    resolve([...state]);
-                    return state;
-                });
-            });
-        },
-        push: async (options) => {
-            return new Promise((resolve) => {
-                update((current) => {
-                    let state;
-                    if (!current.length) {
-                        state = [{ ...options }];
-                    }
-                    else if (options && options?.tree !== current[current.length - 1]?.tree) {
-                        state = [...current, options];
-                    }
-                    else {
-                        state = current;
-                    }
-                    resolve([...state]);
-                    return state;
-                });
-            });
-        },
-        reset: () => {
-            set([]);
-        },
-        subscribe,
-    };
-    return stack;
+function instance$P($$self, $$props, $$invalidate) {
+	let { $$slots: slots = {}, $$scope } = $$props;
+	let { busy = false } = $$props;
+	let { classes = '' } = $$props;
+
+	let { onClick = e => {
+		
+	} } = $$props;
+
+	let { style = 'outline' } = $$props;
+	let { type = null } = $$props;
+	let { width = 'auto' } = $$props;
+
+	$$self.$$set = $$props => {
+		if ('busy' in $$props) $$invalidate(0, busy = $$props.busy);
+		if ('classes' in $$props) $$invalidate(1, classes = $$props.classes);
+		if ('onClick' in $$props) $$invalidate(2, onClick = $$props.onClick);
+		if ('style' in $$props) $$invalidate(3, style = $$props.style);
+		if ('type' in $$props) $$invalidate(4, type = $$props.type);
+		if ('width' in $$props) $$invalidate(5, width = $$props.width);
+		if ('$$scope' in $$props) $$invalidate(6, $$scope = $$props.$$scope);
+	};
+
+	return [busy, classes, onClick, style, type, width, $$scope, slots];
 }
-function initialize$4(initOptions) {
-    const journeyStore = writable({
-        completed: false,
-        error: null,
-        loading: false,
-        metadata: null,
-        step: null,
-        successful: false,
-        response: null,
-    });
-    const { set, subscribe } = journeyStore;
-    const stack = initializeStack();
-    let restartOptions;
-    let stepNumber = 0;
-    async function next(prevStep = null, nextOptions, resumeUrl) {
-        /**
-         * Create an options object with nextOptions overriding anything from initOptions
-         * TODO: Does this object merge need to be more granular?
-         */
-        const options = {
-            ...initOptions,
-            ...nextOptions,
-        };
-        // These options are reserved only for restarting a journey after failure
-        if (initOptions || nextOptions) {
-            restartOptions = {
-                // Prioritize next options over initialize options
-                ...initOptions,
-                ...nextOptions,
-            };
-        }
-        /**
-         * Save previous step information just in case we have a total
-         * form failure due to 400 response from ForgeRock.
-         */
-        let previousCallbacks;
-        if (prevStep && prevStep.type === StepType$1.Step) {
-            previousCallbacks = prevStep?.callbacks;
-        }
-        const previousPayload = prevStep?.payload;
-        let nextStep;
-        set({
-            completed: false,
-            error: null,
-            loading: true,
-            metadata: get_store_value(journeyStore).metadata,
-            step: prevStep,
-            successful: false,
-            response: null,
-        });
-        try {
-            if (resumeUrl) {
-                // If resuming an unknown journey remove the tree from the options
-                options.tree = undefined;
-                /**
-                 * Attempt to resume journey
-                 */
-                nextStep = await FRAuth$1.resume(resumeUrl, options);
-            }
-            else if (prevStep) {
-                // If continuing on a tree remove it from the options
-                options.tree = undefined;
-                /**
-                 * Initial attempt to retrieve next step
-                 */
-                nextStep = await FRAuth$1.next(prevStep, options);
-            }
-            else {
-                nextStep = await FRAuth$1.next(undefined, options);
-            }
-        }
-        catch (err) {
-            console.error(`Next step request | ${err}`);
-            /**
-             * Setup an object to display failure message
-             */
-            nextStep = new FRLoginFailure$1({
-                message: interpolate('unknownNetworkError'),
-            });
-        }
-        if (nextStep.type === StepType$1.Step) {
-            const stageAttribute = nextStep.getStage();
-            let stageJson = null;
-            let stageName = null;
-            // Check if stage attribute is serialized JSON
-            if (stageAttribute && stageAttribute.includes('{')) {
-                try {
-                    stageJson = JSON.parse(stageAttribute);
-                }
-                catch (err) {
-                    console.warn('Stage attribute value was not parsable');
-                }
-            }
-            else if (stageAttribute) {
-                stageName = stageAttribute;
-            }
-            const callbackMetadata = buildCallbackMetadata(nextStep, initCheckValidation(), stageJson);
-            const stepMetadata = buildStepMetadata(callbackMetadata, stageJson, stageName);
-            // Iterate on a successful progression
-            stepNumber = stepNumber + 1;
-            set({
-                completed: false,
-                error: null,
-                loading: false,
-                metadata: {
-                    callbacks: callbackMetadata,
-                    step: stepMetadata,
-                },
-                step: nextStep,
-                successful: false,
-                response: null,
-            });
-        }
-        else if (nextStep.type === StepType$1.LoginSuccess) {
-            /**
-             * SUCCESSFUL COMPLETION BLOCK
-             */
-            // Set final state
-            set({
-                completed: true,
-                error: null,
-                loading: false,
-                metadata: null,
-                step: null,
-                successful: true,
-                response: nextStep.payload,
-            });
-        }
-        else if (nextStep.type === StepType$1.LoginFailure) {
-            /**
-             * FAILURE COMPLETION BLOCK
-             *
-             * Grab failure message, which may contain encoded HTML
-             */
-            const failureMessageStr = htmlDecode(nextStep.payload.message || '');
-            let restartedStep = null;
-            try {
-                /**
-                 * Restart tree to get fresh step
-                 */
-                restartedStep = await FRAuth$1.next(undefined, restartOptions);
-            }
-            catch (err) {
-                console.error(`Restart failed step request | ${err}`);
-                /**
-                 * Setup an object to display failure message
-                 */
-                restartedStep = new FRLoginFailure$1({
-                    message: interpolate('unknownNetworkError'),
-                });
-            }
-            /**
-             * Now that we have a new authId (the identification of the
-             * fresh step) let's populate this new step with old callback data if
-             * this is step one and meets a few criteria.
-             *
-             * If error code is 110 or error message includes "Constrained Violation",
-             * then the issue needs special handling.
-             *
-             * If this is the first step in the journey, replace the callbacks with
-             * existing callbacks to resubmit with a fresh authId.
-             ******************************************************************* */
-            if (shouldPopulateWithPreviousCallbacks(nextStep, previousCallbacks, restartedStep, stepNumber)) {
-                /**
-                 * TypeScript notes:
-                 *
-                 * Assert that restartedStep is FRStep as that is required for the above condition to be true.
-                 * Also, assert that previousCallbacks is FRCallback[] as that too is required for above to be true.
-                 *
-                 * Attempt a refactor using Ryan's suggestion found here: https://www.typescriptlang.org/play?#code/PTAEHUFMBsGMHsC2lQBd5oBYoCoE8AHSAZVgCcBLA1UABWgEM8BzM+AVwDsATAGiwoBnUENANQAd0gAjQRVSQAUCEmYKsTKGYUAbpGF4OY0BoadYKdJMoL+gzAzIoz3UNEiPOofEVKVqAHSKymAAmkYI7NCuqGqcANag8ABmIjQUXrFOKBJMggBcISGgoAC0oACCbvCwDKgU8JkY7p7ehCTkVDQS2E6gnPCxGcwmZqDSTgzxxWWVoASMFmgYkAAeRJTInN3ymj4d-jSCeNsMq-wuoPaOltigAKoASgAywhK7SbGQZIIz5VWCFzSeCrZagNYbChbHaxUDcCjJZLfSDbExIAgUdxkUBIursJzCFJtXydajBZJcWD1RqgJyofGcABqDGg7EgAB4cAA+AAUq3y3nBqwUPGEglQlE4IwA-FcJcNQALOOxENJvgBKUAAb0UJT1CNAPNQ7SJoIAvBbQAAiZWq75WzV0hmgUG6vXg6CCFBOsheVZukoB0CKAC+incNCGUtAZtpkHpvuZrI54slzF5VoAjA6ANzkynUrxCYjyqV8gWphUAH36KrVZHVAuB8BaXh17oNRpNqXNloA5JWpX3Ne33XqfZkyGy8+6w0GJziWV683PO8XS8wjXFmOqR0Go8wAhlYKzuPoeVbsNBoPBc6HgiocM0PL7QIh4H0GMD2JG7owpewDDMJA-AnuoiRfvAegiF4VoAKKrAwiALPoVpJNiVrgA4qADqAABykASFaQQqAA8l8ZDvF6-DAUcqCOAorjSHgcbvjoCpfF6aKINCwiXF8kgftEIgGBw2ILEwrAcDwQQlEAA
-                 */
-                restartedStep = restartedStep;
-                // Rebuild callbacks onto restartedStep
-                restartedStep.callbacks = previousCallbacks;
-                // Rebuild payload onto restartedStep ensuring the use of the NEW authId
-                restartedStep.payload = {
-                    ...previousPayload,
-                    authId: restartedStep.payload.authId,
-                };
-                const details = nextStep.payload.detail;
-                /**
-                 * Only if the authId expires do we resubmit with same callback values
-                 */
-                if (details?.errorCode === authIdTimeoutErrorCode) {
-                    restartedStep = await FRAuth$1.next(restartedStep, options);
-                }
-            }
-            /**
-             * SET RESULT OF SUBSEQUENT REQUEST
-             *
-             * After the above attempts to salvage the form submission, let's return
-             * the final result to the user.
-             */
-            if (restartedStep.type === StepType$1.Step) {
-                const stageAttribute = restartedStep.getStage();
-                let stageJson = null;
-                let stageName = null;
-                // Check if stage attribute is serialized JSON
-                if (stageAttribute && stageAttribute.includes('{')) {
-                    try {
-                        stageJson = JSON.parse(stageAttribute);
-                    }
-                    catch (err) {
-                        console.warn('Stage attribute value was not parsable');
-                    }
-                }
-                else if (stageAttribute) {
-                    stageName = stageAttribute;
-                }
-                const callbackMetadata = buildCallbackMetadata(restartedStep, initCheckValidation(), stageJson);
-                const stepMetadata = buildStepMetadata(callbackMetadata, stageJson, stageName);
-                set({
-                    completed: false,
-                    error: {
-                        code: nextStep.getCode(),
-                        message: failureMessageStr,
-                        // TODO: Should we remove the callbacks for PII info?
-                        step: prevStep?.payload,
-                    },
-                    loading: false,
-                    metadata: {
-                        callbacks: callbackMetadata,
-                        step: stepMetadata,
-                    },
-                    step: restartedStep,
-                    successful: false,
-                    response: null,
-                });
-            }
-            else if (restartedStep.type === StepType$1.LoginSuccess) {
-                set({
-                    completed: true,
-                    error: null,
-                    loading: false,
-                    metadata: null,
-                    step: null,
-                    successful: true,
-                    response: restartedStep.payload,
-                });
-            }
-            else {
-                set({
-                    completed: true,
-                    error: {
-                        code: nextStep.getCode(),
-                        message: failureMessageStr,
-                        // TODO: Should we remove the callbacks for PII info?
-                        step: prevStep?.payload,
-                    },
-                    loading: false,
-                    metadata: null,
-                    step: null,
-                    successful: false,
-                    response: restartedStep.payload,
-                });
-            }
-        }
-    }
-    async function pop() {
-        reset();
-        const updatedStack = await stack.pop();
-        const currentJourney = updatedStack[updatedStack.length - 1];
-        await start(currentJourney);
-    }
-    async function push(newOptions) {
-        reset();
-        await stack.push(newOptions);
-        await start(newOptions);
-    }
-    async function resume(url, resumeOptions) {
-        await next(undefined, resumeOptions, url);
-    }
-    async function start(startOptions) {
-        await stack.push(startOptions);
-        await next(undefined, startOptions);
-    }
-    function reset() {
-        set({
-            completed: false,
-            error: null,
-            loading: false,
-            metadata: null,
-            step: null,
-            successful: false,
-            response: null,
-        });
-    }
-    return {
-        next,
-        pop,
-        push,
-        reset,
-        resume,
-        start,
-        subscribe,
-    };
+
+class Button extends SvelteComponent {
+	constructor(options) {
+		super();
+
+		init(this, options, instance$P, create_fragment$O, safe_not_equal, {
+			busy: 0,
+			classes: 1,
+			onClick: 2,
+			style: 3,
+			type: 4,
+			width: 5
+		});
+	}
 }
-let stack;
 
 /* src/lib/components/primitives/form/form.svelte generated by Svelte v3.55.1 */
 
@@ -18831,7 +19092,7 @@ class Form extends SvelteComponent {
 
 /* src/lib/components/_utilities/server-strings.svelte generated by Svelte v3.55.1 */
 
-function create_else_block$6(ctx) {
+function create_else_block$7(ctx) {
 	let current;
 	const default_slot_template = /*#slots*/ ctx[4].default;
 	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[3], null);
@@ -18884,7 +19145,7 @@ function create_else_block$6(ctx) {
 }
 
 // (10:0) {#if html}
-function create_if_block$i(ctx) {
+function create_if_block$j(ctx) {
 	let current;
 	const default_slot_template = /*#slots*/ ctx[4].default;
 	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[3], null);
@@ -18986,7 +19247,7 @@ function create_fragment$M(ctx) {
 	let if_block;
 	let if_block_anchor;
 	let current;
-	const if_block_creators = [create_if_block$i, create_else_block$6];
+	const if_block_creators = [create_if_block$j, create_else_block$7];
 	const if_blocks = [];
 
 	function select_block_type(ctx, dirty) {
@@ -19179,64 +19440,9 @@ class Shield_icon extends SvelteComponent {
 	}
 }
 
-const journeyConfigItemSchema = mod.object({
-    journey: mod.string().optional(),
-    match: mod
-        .string()
-        .regex(/^(#\/service|\?journey)/, {
-        message: 'HREF string must start with `?journey` or `#/service`',
-    })
-        .array(),
-});
-const journeyConfigSchema = mod.object({
-    forgotPassword: journeyConfigItemSchema,
-    forgotUsername: journeyConfigItemSchema,
-    login: journeyConfigItemSchema,
-    register: journeyConfigItemSchema,
-});
-const defaultJourneys = {
-    forgotPassword: {
-        journey: 'ResetPassword',
-        match: ['#/service/ResetPassword', '?journey=ResetPassword'],
-    },
-    forgotUsername: {
-        journey: 'ForgottenUsername',
-        match: ['#/service/ForgottenUsername', '?journey=ForgottenUsername'],
-    },
-    login: {
-        journey: undefined,
-        match: ['#/service/Login', '?journey'],
-    },
-    register: {
-        journey: 'Registration',
-        match: ['#/service/Registration', '?journey=Registration'],
-    },
-};
-// Ensure default follows schema
-journeyConfigSchema.parse(defaultJourneys);
-let configuredJourneys;
-function initialize$3(customJourneys) {
-    if (customJourneys) {
-        // Provide developer feedback if customized
-        journeyConfigSchema.parse(customJourneys);
-        const arr = Object.keys(customJourneys);
-        configuredJourneys = readable(arr.map((key) => ({
-            ...customJourneys[key],
-            key,
-        })));
-    }
-    else {
-        const arr = Object.keys(defaultJourneys);
-        configuredJourneys = readable(arr.map((key) => ({
-            ...defaultJourneys[key],
-            key,
-        })));
-    }
-}
-
 /* src/lib/journey/stages/_utilities/back-to.svelte generated by Svelte v3.55.1 */
 
-function create_if_block$h(ctx) {
+function create_if_block$i(ctx) {
 	let p;
 	let button;
 	let t_value = interpolate(/*string*/ ctx[1]) + "";
@@ -19274,7 +19480,7 @@ function create_if_block$h(ctx) {
 
 function create_fragment$K(ctx) {
 	let if_block_anchor;
-	let if_block = /*$stack*/ ctx[2].length > 1 && create_if_block$h(ctx);
+	let if_block = /*$stack*/ ctx[2].length > 1 && create_if_block$i(ctx);
 
 	return {
 		c() {
@@ -19290,7 +19496,7 @@ function create_fragment$K(ctx) {
 				if (if_block) {
 					if_block.p(ctx, dirty);
 				} else {
-					if_block = create_if_block$h(ctx);
+					if_block = create_if_block$i(ctx);
 					if_block.c();
 					if_block.m(if_block_anchor.parentNode, if_block_anchor);
 				}
@@ -19310,15 +19516,15 @@ function create_fragment$K(ctx) {
 
 function instance$L($$self, $$props, $$invalidate) {
 	let $stack;
-	let $configuredJourneys;
-	component_subscribe($$self, configuredJourneys, $$value => $$invalidate(5, $configuredJourneys = $$value));
+	let $configuredJourneysStore;
+	component_subscribe($$self, configuredJourneysStore, $$value => $$invalidate(5, $configuredJourneysStore = $$value));
 	let { journey } = $$props;
 	let stack = journey.stack;
 	component_subscribe($$self, stack, value => $$invalidate(2, $stack = value));
 	let string = '';
 
 	function constructString() {
-		const currentJourney = $configuredJourneys.find(journey => {
+		const currentJourney = $configuredJourneysStore.find(journey => {
 			return journey.journey === $stack[$stack.length - 2]?.tree;
 		});
 
@@ -19359,7 +19565,7 @@ class Back_to extends SvelteComponent {
  * @param {object} currentJourney - The current stage's journey object
  */
 function captureLinks(linkWrapper, currentJourney) {
-    const journeys = get_store_value(configuredJourneys);
+    const journeys = get_store_value(configuredJourneysStore);
     const stack = get_store_value(currentJourney.stack);
     linkWrapper.addEventListener('click', (event) => {
         const target = event.target;
@@ -19666,7 +19872,7 @@ function getAttributeValidationFailureText(callback) {
 
 /* src/lib/components/primitives/message/input-message.svelte generated by Svelte v3.55.1 */
 
-function create_if_block$g(ctx) {
+function create_if_block$h(ctx) {
 	let p;
 	let p_class_value;
 	let p_id_value;
@@ -19699,7 +19905,7 @@ function create_if_block$g(ctx) {
 
 function create_fragment$J(ctx) {
 	let if_block_anchor;
-	let if_block = /*dirtyMessage*/ ctx[1] && create_if_block$g(ctx);
+	let if_block = /*dirtyMessage*/ ctx[1] && create_if_block$h(ctx);
 
 	return {
 		c() {
@@ -19715,7 +19921,7 @@ function create_fragment$J(ctx) {
 				if (if_block) {
 					if_block.p(ctx, dirty);
 				} else {
-					if_block = create_if_block$g(ctx);
+					if_block = create_if_block$h(ctx);
 					if_block.c();
 					if_block.m(if_block_anchor.parentNode, if_block_anchor);
 				}
@@ -21194,7 +21400,7 @@ function create_each_block$7(ctx) {
 }
 
 // (62:0) {#if labelOrder === 'last'}
-function create_if_block$f(ctx) {
+function create_if_block$g(ctx) {
 	let label_1;
 	let current;
 
@@ -21284,7 +21490,7 @@ function create_fragment$C(ctx) {
 		each_blocks[i] = create_each_block$7(get_each_context$7(ctx, each_value, i));
 	}
 
-	let if_block1 = /*labelOrder*/ ctx[7] === 'last' && create_if_block$f(ctx);
+	let if_block1 = /*labelOrder*/ ctx[7] === 'last' && create_if_block$g(ctx);
 
 	return {
 		c() {
@@ -21406,7 +21612,7 @@ function create_fragment$C(ctx) {
 						transition_in(if_block1, 1);
 					}
 				} else {
-					if_block1 = create_if_block$f(ctx);
+					if_block1 = create_if_block$g(ctx);
 					if_block1.c();
 					transition_in(if_block1, 1);
 					if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
@@ -21710,7 +21916,7 @@ let Floating_label$1 = class Floating_label extends SvelteComponent {
 
 /* src/lib/journey/callbacks/choice/choice.svelte generated by Svelte v3.55.1 */
 
-function create_else_block$5(ctx) {
+function create_else_block$6(ctx) {
 	let select;
 	let current;
 
@@ -21759,7 +21965,7 @@ function create_else_block$5(ctx) {
 }
 
 // (62:0) {#if callbackMetadata?.platform?.displayType === 'radio'}
-function create_if_block$e(ctx) {
+function create_if_block$f(ctx) {
 	let radio;
 	let current;
 
@@ -21814,7 +22020,7 @@ function create_fragment$A(ctx) {
 	let if_block;
 	let if_block_anchor;
 	let current;
-	const if_block_creators = [create_if_block$e, create_else_block$5];
+	const if_block_creators = [create_if_block$f, create_else_block$6];
 	const if_blocks = [];
 
 	function select_block_type(ctx, dirty) {
@@ -22096,7 +22302,7 @@ function get_each_context$6(ctx, list, i) {
 }
 
 // (96:0) {#if stepMetadata?.platform?.stageName !== 'OneTimePassword'}
-function create_if_block$d(ctx) {
+function create_if_block$e(ctx) {
 	let current_block_type_index;
 	let if_block;
 	let if_block_anchor;
@@ -22217,7 +22423,7 @@ function create_if_block_1$9(ctx) {
 	let if_block;
 	let if_block_anchor;
 	let current;
-	const if_block_creators = [create_if_block_2$8, create_else_block$4];
+	const if_block_creators = [create_if_block_2$8, create_else_block$5];
 	const if_blocks = [];
 
 	function select_block_type_1(ctx, dirty) {
@@ -22452,7 +22658,7 @@ function create_default_slot_1$a(ctx) {
 }
 
 // (107:4) {:else}
-function create_else_block$4(ctx) {
+function create_else_block$5(ctx) {
 	let checkbox;
 	let current;
 
@@ -22573,7 +22779,7 @@ function create_default_slot$h(ctx) {
 function create_fragment$y(ctx) {
 	let if_block_anchor;
 	let current;
-	let if_block = /*stepMetadata*/ ctx[1]?.platform?.stageName !== 'OneTimePassword' && create_if_block$d(ctx);
+	let if_block = /*stepMetadata*/ ctx[1]?.platform?.stageName !== 'OneTimePassword' && create_if_block$e(ctx);
 
 	return {
 		c() {
@@ -22594,7 +22800,7 @@ function create_fragment$y(ctx) {
 						transition_in(if_block, 1);
 					}
 				} else {
-					if_block = create_if_block$d(ctx);
+					if_block = create_if_block$e(ctx);
 					if_block.c();
 					transition_in(if_block, 1);
 					if_block.m(if_block_anchor.parentNode, if_block_anchor);
@@ -23368,7 +23574,7 @@ function create_if_block_1$8(ctx) {
 }
 
 // (129:0) {#if labelOrder === 'last'}
-function create_if_block$c(ctx) {
+function create_if_block$d(ctx) {
 	let label_1;
 	let current;
 
@@ -23452,7 +23658,7 @@ function create_fragment$x(ctx) {
 	let if_block4 = /*type*/ ctx[11] === 'password' && create_if_block_3$3(ctx);
 	let if_block5 = /*type*/ ctx[11] === 'phone' && create_if_block_2$7(ctx);
 	let if_block6 = /*type*/ ctx[11] === 'text' && create_if_block_1$8(ctx);
-	let if_block7 = /*labelOrder*/ ctx[6] === 'last' && create_if_block$c(ctx);
+	let if_block7 = /*labelOrder*/ ctx[6] === 'last' && create_if_block$d(ctx);
 
 	return {
 		c() {
@@ -23602,7 +23808,7 @@ function create_fragment$x(ctx) {
 						transition_in(if_block7, 1);
 					}
 				} else {
-					if_block7 = create_if_block$c(ctx);
+					if_block7 = create_if_block$d(ctx);
 					if_block7.c();
 					transition_in(if_block7, 1);
 					if_block7.m(if_block7_anchor.parentNode, if_block7_anchor);
@@ -24461,7 +24667,7 @@ class Lock_icon extends SvelteComponent {
 
 /* src/lib/journey/callbacks/kba/kba-create.svelte generated by Svelte v3.55.1 */
 
-function create_if_block$b(ctx) {
+function create_if_block$c(ctx) {
 	let input;
 	let current;
 
@@ -24540,7 +24746,7 @@ function create_fragment$t(ctx) {
 			}
 		});
 
-	let if_block = /*displayCustomQuestionInput*/ ctx[3] && create_if_block$b(ctx);
+	let if_block = /*displayCustomQuestionInput*/ ctx[3] && create_if_block$c(ctx);
 
 	function input_value_binding(value) {
 		/*input_value_binding*/ ctx[20](value);
@@ -24618,7 +24824,7 @@ function create_fragment$t(ctx) {
 						transition_in(if_block, 1);
 					}
 				} else {
-					if_block = create_if_block$b(ctx);
+					if_block = create_if_block$c(ctx);
 					if_block.c();
 					transition_in(if_block, 1);
 					if_block.m(fieldset, t6);
@@ -25000,7 +25206,7 @@ class Name extends SvelteComponent {
 
 /* src/lib/components/icons/eye-icon.svelte generated by Svelte v3.55.1 */
 
-function create_else_block$3(ctx) {
+function create_else_block$4(ctx) {
 	let svg;
 	let path0;
 	let path1;
@@ -25082,7 +25288,7 @@ function create_else_block$3(ctx) {
 }
 
 // (6:0) {#if !visible}
-function create_if_block$a(ctx) {
+function create_if_block$b(ctx) {
 	let svg;
 	let path0;
 	let path1;
@@ -25168,7 +25374,7 @@ function create_fragment$r(ctx) {
 	let if_block;
 	let if_block_anchor;
 	let current;
-	const if_block_creators = [create_if_block$a, create_else_block$3];
+	const if_block_creators = [create_if_block$b, create_else_block$4];
 	const if_blocks = [];
 
 	function select_block_type(ctx, dirty) {
@@ -25681,7 +25887,7 @@ function create_input_button_slot(ctx) {
 }
 
 // (89:0) {#if callbackMetadata?.platform?.confirmPassword}
-function create_if_block$9(ctx) {
+function create_if_block$a(ctx) {
 	let confirminput;
 	let current;
 
@@ -25759,7 +25965,7 @@ function create_fragment$p(ctx) {
 			}
 		});
 
-	let if_block = /*callbackMetadata*/ ctx[1]?.platform?.confirmPassword && create_if_block$9(ctx);
+	let if_block = /*callbackMetadata*/ ctx[1]?.platform?.confirmPassword && create_if_block$a(ctx);
 
 	return {
 		c() {
@@ -25808,7 +26014,7 @@ function create_fragment$p(ctx) {
 						transition_in(if_block, 1);
 					}
 				} else {
-					if_block = create_if_block$9(ctx);
+					if_block = create_if_block$a(ctx);
 					if_block.c();
 					transition_in(if_block, 1);
 					if_block.m(if_block_anchor.parentNode, if_block_anchor);
@@ -27132,7 +27338,7 @@ function create_each_block$5(ctx) {
 }
 
 // (81:0) {#if stepMetadata && stepMetadata.derived.numOfCallbacks > 1}
-function create_if_block$8(ctx) {
+function create_if_block$9(ctx) {
 	let grid;
 	let current;
 
@@ -27201,7 +27407,7 @@ function create_fragment$h(ctx) {
 		each_blocks[i] = null;
 	});
 
-	let if_block = /*stepMetadata*/ ctx[0] && /*stepMetadata*/ ctx[0].derived.numOfCallbacks > 1 && create_if_block$8(ctx);
+	let if_block = /*stepMetadata*/ ctx[0] && /*stepMetadata*/ ctx[0].derived.numOfCallbacks > 1 && create_if_block$9(ctx);
 
 	return {
 		c() {
@@ -27257,7 +27463,7 @@ function create_fragment$h(ctx) {
 						transition_in(if_block, 1);
 					}
 				} else {
-					if_block = create_if_block$8(ctx);
+					if_block = create_if_block$9(ctx);
 					if_block.c();
 					transition_in(if_block, 1);
 					if_block.m(if_block_anchor.parentNode, if_block_anchor);
@@ -27496,7 +27702,7 @@ function create_if_block_1$6(ctx) {
 }
 
 // (23:0) {#if simplifiedFailures.length}
-function create_if_block$7(ctx) {
+function create_if_block$8(ctx) {
 	let div;
 	let p;
 	let t0;
@@ -27646,7 +27852,7 @@ function create_fragment$g(ctx) {
 	let if_block;
 	let if_block_anchor;
 	let current;
-	const if_block_creators = [create_if_block$7, create_if_block_1$6];
+	const if_block_creators = [create_if_block$8, create_if_block_1$6];
 	const if_blocks = [];
 
 	function select_block_type(ctx, dirty) {
@@ -28099,28 +28305,9 @@ class Link extends SvelteComponent {
 	}
 }
 
-const linksSchema = mod
-    .object({
-    termsAndConditions: mod.string(),
-})
-    .strict();
-linksSchema.partial();
-let links;
-function initialize$2(customLinks) {
-    // If customLinks is provided, provide feedback for object
-    if (customLinks) {
-        // Provide developer feedback for custom links
-        linksSchema.parse(customLinks);
-        links = readable(customLinks);
-    }
-    else {
-        links = readable();
-    }
-}
-
 /* src/lib/journey/callbacks/terms-and-conditions/terms-conditions.svelte generated by Svelte v3.55.1 */
 
-function create_else_block$2(ctx) {
+function create_else_block$3(ctx) {
 	let p;
 
 	return {
@@ -28141,8 +28328,8 @@ function create_else_block$2(ctx) {
 	};
 }
 
-// (43:0) {#if $links?.termsAndConditions}
-function create_if_block$6(ctx) {
+// (43:0) {#if $linksStore?.termsAndConditions}
+function create_if_block$7(ctx) {
 	let link;
 	let t;
 	let checkbox;
@@ -28151,7 +28338,7 @@ function create_if_block$6(ctx) {
 	link = new Link({
 			props: {
 				classes: "tw_block tw_mb-4",
-				href: /*$links*/ ctx[2]?.termsAndConditions,
+				href: /*$linksStore*/ ctx[2]?.termsAndConditions,
 				target: "_blank",
 				$$slots: { default: [create_default_slot_1$5] },
 				$$scope: { ctx }
@@ -28183,7 +28370,7 @@ function create_if_block$6(ctx) {
 		},
 		p(ctx, dirty) {
 			const link_changes = {};
-			if (dirty & /*$links*/ 4) link_changes.href = /*$links*/ ctx[2]?.termsAndConditions;
+			if (dirty & /*$linksStore*/ 4) link_changes.href = /*$linksStore*/ ctx[2]?.termsAndConditions;
 
 			if (dirty & /*$$scope*/ 1024) {
 				link_changes.$$scope = { dirty, ctx };
@@ -28219,7 +28406,7 @@ function create_if_block$6(ctx) {
 	};
 }
 
-// (44:2) <Link classes="tw_block tw_mb-4" href={$links?.termsAndConditions} target="_blank">
+// (44:2) <Link classes="tw_block tw_mb-4" href={$linksStore?.termsAndConditions} target="_blank">
 function create_default_slot_1$5(ctx) {
 	let t_value = interpolate('termsAndConditionsLinkText') + "";
 	let t;
@@ -28273,11 +28460,11 @@ function create_fragment$d(ctx) {
 	let if_block;
 	let if_block_anchor;
 	let current;
-	const if_block_creators = [create_if_block$6, create_else_block$2];
+	const if_block_creators = [create_if_block$7, create_else_block$3];
 	const if_blocks = [];
 
 	function select_block_type(ctx, dirty) {
-		if (/*$links*/ ctx[2]?.termsAndConditions) return 0;
+		if (/*$linksStore*/ ctx[2]?.termsAndConditions) return 0;
 		return 1;
 	}
 
@@ -28338,8 +28525,8 @@ function create_fragment$d(ctx) {
 }
 
 function instance$d($$self, $$props, $$invalidate) {
-	let $links;
-	component_subscribe($$self, links, $$value => $$invalidate(2, $links = $$value));
+	let $linksStore;
+	component_subscribe($$self, linksStore, $$value => $$invalidate(2, $linksStore = $$value));
 	const selfSubmitFunction = null;
 	const stepMetadata = null;
 	const style = {};
@@ -28390,7 +28577,7 @@ function instance$d($$self, $$props, $$invalidate) {
 	return [
 		callbackMetadata,
 		inputName,
-		$links,
+		$linksStore,
 		Checkbox,
 		setValue,
 		selfSubmitFunction,
@@ -29210,7 +29397,7 @@ function get_if_ctx(ctx) {
 }
 
 // (198:0) {:else}
-function create_else_block$1(ctx) {
+function create_else_block$2(ctx) {
 	let unknown;
 	let current;
 	const unknown_spread_levels = [/*newProps*/ ctx[19]];
@@ -29898,7 +30085,7 @@ function create_if_block_1$5(ctx) {
 }
 
 // (102:0) {#if cbType === CallbackType.BooleanAttributeInputCallback}
-function create_if_block$5(ctx) {
+function create_if_block$6(ctx) {
 	let boolean;
 	let current;
 	const boolean_spread_levels = [/*newProps*/ ctx[19]];
@@ -29947,7 +30134,7 @@ function create_fragment$8(ctx) {
 	let current;
 
 	const if_block_creators = [
-		create_if_block$5,
+		create_if_block$6,
 		create_if_block_1$5,
 		create_if_block_2$5,
 		create_if_block_3$1,
@@ -29963,7 +30150,7 @@ function create_fragment$8(ctx) {
 		create_if_block_13,
 		create_if_block_14,
 		create_if_block_15,
-		create_else_block$1
+		create_else_block$2
 	];
 
 	const if_blocks = [];
@@ -30310,7 +30497,7 @@ function create_each_block$3(ctx) {
 					callbackMetadata: /*metadata*/ ctx[3]?.callbacks[/*idx*/ ctx[17]],
 					selfSubmitFunction: /*determineSubmission*/ ctx[11],
 					stepMetadata: /*metadata*/ ctx[3]?.step && { .../*metadata*/ ctx[3].step },
-					style: /*$style*/ ctx[10]
+					style: /*$styleStore*/ ctx[10]
 				}
 			}
 		});
@@ -30326,12 +30513,12 @@ function create_each_block$3(ctx) {
 		p(ctx, dirty) {
 			const callbackmapper_changes = {};
 
-			if (dirty & /*step, metadata, $style*/ 1048) callbackmapper_changes.props = {
+			if (dirty & /*step, metadata, $styleStore*/ 1048) callbackmapper_changes.props = {
 				callback: /*callback*/ ctx[15],
 				callbackMetadata: /*metadata*/ ctx[3]?.callbacks[/*idx*/ ctx[17]],
 				selfSubmitFunction: /*determineSubmission*/ ctx[11],
 				stepMetadata: /*metadata*/ ctx[3]?.step && { .../*metadata*/ ctx[3].step },
-				style: /*$style*/ ctx[10]
+				style: /*$styleStore*/ ctx[10]
 			};
 
 			callbackmapper.$set(callbackmapper_changes);
@@ -30352,7 +30539,7 @@ function create_each_block$3(ctx) {
 }
 
 // (105:2) {#if metadata?.step?.derived.isUserInputOptional || !metadata?.step?.derived.isStepSelfSubmittable}
-function create_if_block$4(ctx) {
+function create_if_block$5(ctx) {
 	let button;
 	let current;
 
@@ -30473,7 +30660,7 @@ function create_default_slot$5(ctx) {
 		each_blocks[i] = null;
 	});
 
-	let if_block2 = (/*metadata*/ ctx[3]?.step?.derived.isUserInputOptional || !/*metadata*/ ctx[3]?.step?.derived.isStepSelfSubmittable) && create_if_block$4(ctx);
+	let if_block2 = (/*metadata*/ ctx[3]?.step?.derived.isUserInputOptional || !/*metadata*/ ctx[3]?.step?.derived.isStepSelfSubmittable) && create_if_block$5(ctx);
 	backto = new Back_to({ props: { journey: /*journey*/ ctx[2] } });
 
 	return {
@@ -30578,7 +30765,7 @@ function create_default_slot$5(ctx) {
 				check_outros();
 			}
 
-			if (dirty & /*step, metadata, determineSubmission, $style*/ 3096) {
+			if (dirty & /*step, metadata, determineSubmission, $styleStore*/ 3096) {
 				each_value = /*step*/ ctx[4]?.callbacks;
 				let i;
 
@@ -30613,7 +30800,7 @@ function create_default_slot$5(ctx) {
 						transition_in(if_block2, 1);
 					}
 				} else {
-					if_block2 = create_if_block$4(ctx);
+					if_block2 = create_if_block$5(ctx);
 					if_block2.c();
 					transition_in(if_block2, 1);
 					if_block2.m(t5.parentNode, t5);
@@ -30719,7 +30906,7 @@ function create_fragment$7(ctx) {
 			if (dirty & /*formAriaDescriptor*/ 128) form_1_changes.ariaDescribedBy = /*formAriaDescriptor*/ ctx[7];
 			if (dirty & /*formNeedsFocus*/ 256) form_1_changes.needsFocus = /*formNeedsFocus*/ ctx[8];
 
-			if (dirty & /*$$scope, journey, metadata, step, $style, alertNeedsFocus, formMessageKey, form, linkWrapper*/ 263806) {
+			if (dirty & /*$$scope, journey, metadata, step, $styleStore, alertNeedsFocus, formMessageKey, form, linkWrapper*/ 263806) {
 				form_1_changes.$$scope = { dirty, ctx };
 			}
 
@@ -30751,8 +30938,8 @@ const formHeaderId = 'genericStepHeader';
 const formElementId = 'genericStepForm';
 
 function instance$7($$self, $$props, $$invalidate) {
-	let $style;
-	component_subscribe($$self, style, $$value => $$invalidate(10, $style = $$value));
+	let $styleStore;
+	component_subscribe($$self, styleStore, $$value => $$invalidate(10, $styleStore = $$value));
 	let { form } = $$props;
 	let { formEl = null } = $$props;
 	let { journey } = $$props;
@@ -30833,7 +31020,7 @@ function instance$7($$self, $$props, $$invalidate) {
 		formAriaDescriptor,
 		formNeedsFocus,
 		linkWrapper,
-		$style,
+		$styleStore,
 		determineSubmission,
 		submitFormWrapper,
 		header_binding,
@@ -31131,7 +31318,7 @@ function create_each_block$2(ctx) {
 }
 
 // (71:2) {#if metadata?.step?.derived.isUserInputOptional || !metadata?.step?.derived.isStepSelfSubmittable}
-function create_if_block$3(ctx) {
+function create_if_block$4(ctx) {
 	let button;
 	let current;
 
@@ -31244,7 +31431,7 @@ function create_default_slot$4(ctx) {
 		each_blocks[i] = null;
 	});
 
-	let if_block2 = (/*metadata*/ ctx[3]?.step?.derived.isUserInputOptional || !/*metadata*/ ctx[3]?.step?.derived.isStepSelfSubmittable) && create_if_block$3(ctx);
+	let if_block2 = (/*metadata*/ ctx[3]?.step?.derived.isUserInputOptional || !/*metadata*/ ctx[3]?.step?.derived.isStepSelfSubmittable) && create_if_block$4(ctx);
 
 	return {
 		c() {
@@ -31370,7 +31557,7 @@ function create_default_slot$4(ctx) {
 						transition_in(if_block2, 1);
 					}
 				} else {
-					if_block2 = create_if_block$3(ctx);
+					if_block2 = create_if_block$4(ctx);
 					if_block2.c();
 					transition_in(if_block2, 1);
 					if_block2.m(if_block2_anchor.parentNode, if_block2_anchor);
@@ -31496,7 +31683,7 @@ function create_fragment$5(ctx) {
 
 function instance$5($$self, $$props, $$invalidate) {
 	let $style;
-	component_subscribe($$self, style, $$value => $$invalidate(7, $style = $$value));
+	component_subscribe($$self, styleStore, $$value => $$invalidate(7, $style = $$value));
 	let { form } = $$props;
 	let { formEl = null } = $$props;
 	let { journey } = $$props;
@@ -31801,7 +31988,7 @@ function create_each_block$1(ctx) {
 					callbackMetadata: /*metadata*/ ctx[3]?.callbacks[/*idx*/ ctx[14]],
 					selfSubmitFunction: /*determineSubmission*/ ctx[9],
 					stepMetadata: /*metadata*/ ctx[3]?.step && { .../*metadata*/ ctx[3].step },
-					style: /*$style*/ ctx[8]
+					style: /*$styleStore*/ ctx[8]
 				}
 			}
 		});
@@ -31817,12 +32004,12 @@ function create_each_block$1(ctx) {
 		p(ctx, dirty) {
 			const callbackmapper_changes = {};
 
-			if (dirty & /*step, metadata, $style*/ 280) callbackmapper_changes.props = {
+			if (dirty & /*step, metadata, $styleStore*/ 280) callbackmapper_changes.props = {
 				callback: /*callback*/ ctx[12],
 				callbackMetadata: /*metadata*/ ctx[3]?.callbacks[/*idx*/ ctx[14]],
 				selfSubmitFunction: /*determineSubmission*/ ctx[9],
 				stepMetadata: /*metadata*/ ctx[3]?.step && { .../*metadata*/ ctx[3].step },
-				style: /*$style*/ ctx[8]
+				style: /*$styleStore*/ ctx[8]
 			};
 
 			callbackmapper.$set(callbackmapper_changes);
@@ -31843,7 +32030,7 @@ function create_each_block$1(ctx) {
 }
 
 // (77:2) {#if metadata?.step?.derived.isUserInputOptional || !metadata?.step?.derived.isStepSelfSubmittable}
-function create_if_block$2(ctx) {
+function create_if_block$3(ctx) {
 	let button;
 	let current;
 
@@ -31953,7 +32140,7 @@ function create_default_slot$3(ctx) {
 		each_blocks[i] = null;
 	});
 
-	let if_block2 = (/*metadata*/ ctx[3]?.step?.derived.isUserInputOptional || !/*metadata*/ ctx[3]?.step?.derived.isStepSelfSubmittable) && create_if_block$2(ctx);
+	let if_block2 = (/*metadata*/ ctx[3]?.step?.derived.isUserInputOptional || !/*metadata*/ ctx[3]?.step?.derived.isStepSelfSubmittable) && create_if_block$3(ctx);
 
 	return {
 		c() {
@@ -32045,7 +32232,7 @@ function create_default_slot$3(ctx) {
 				check_outros();
 			}
 
-			if (dirty & /*step, metadata, determineSubmission, $style*/ 792) {
+			if (dirty & /*step, metadata, determineSubmission, $styleStore*/ 792) {
 				each_value = /*step*/ ctx[4]?.callbacks;
 				let i;
 
@@ -32080,7 +32267,7 @@ function create_default_slot$3(ctx) {
 						transition_in(if_block2, 1);
 					}
 				} else {
-					if_block2 = create_if_block$2(ctx);
+					if_block2 = create_if_block$3(ctx);
 					if_block2.c();
 					transition_in(if_block2, 1);
 					if_block2.m(if_block2_anchor.parentNode, if_block2_anchor);
@@ -32178,7 +32365,7 @@ function create_fragment$3(ctx) {
 			const form_1_changes = {};
 			if (dirty & /*form*/ 2) form_1_changes.onSubmitWhenValid = /*form*/ ctx[1]?.submit;
 
-			if (dirty & /*$$scope, journey, metadata, step, $style, alertNeedsFocus, formMessageKey, form, linkWrapper*/ 33278) {
+			if (dirty & /*$$scope, journey, metadata, step, $styleStore, alertNeedsFocus, formMessageKey, form, linkWrapper*/ 33278) {
 				form_1_changes.$$scope = { dirty, ctx };
 			}
 
@@ -32206,8 +32393,8 @@ function create_fragment$3(ctx) {
 }
 
 function instance$3($$self, $$props, $$invalidate) {
-	let $style;
-	component_subscribe($$self, style, $$value => $$invalidate(8, $style = $$value));
+	let $styleStore;
+	component_subscribe($$self, styleStore, $$value => $$invalidate(8, $styleStore = $$value));
 	let { form } = $$props;
 	let { formEl = null } = $$props;
 	let { journey } = $$props;
@@ -32269,7 +32456,7 @@ function instance$3($$self, $$props, $$invalidate) {
 		alertNeedsFocus,
 		formMessageKey,
 		linkWrapper,
-		$style,
+		$styleStore,
 		determineSubmission,
 		p_binding,
 		form_1_formEl_binding
@@ -32420,7 +32607,7 @@ function create_each_block(ctx) {
 					callbackMetadata: /*metadata*/ ctx[3]?.callbacks[/*idx*/ ctx[16]],
 					selfSubmitFunction: /*determineSubmission*/ ctx[9],
 					stepMetadata: /*metadata*/ ctx[3]?.step && { .../*metadata*/ ctx[3].step },
-					style: /*$style*/ ctx[8]
+					style: /*$styleStore*/ ctx[8]
 				}
 			}
 		});
@@ -32436,12 +32623,12 @@ function create_each_block(ctx) {
 		p(ctx, dirty) {
 			const callbackmapper_changes = {};
 
-			if (dirty & /*step, metadata, $style*/ 280) callbackmapper_changes.props = {
+			if (dirty & /*step, metadata, $styleStore*/ 280) callbackmapper_changes.props = {
 				callback: /*callback*/ ctx[14],
 				callbackMetadata: /*metadata*/ ctx[3]?.callbacks[/*idx*/ ctx[16]],
 				selfSubmitFunction: /*determineSubmission*/ ctx[9],
 				stepMetadata: /*metadata*/ ctx[3]?.step && { .../*metadata*/ ctx[3].step },
-				style: /*$style*/ ctx[8]
+				style: /*$styleStore*/ ctx[8]
 			};
 
 			callbackmapper.$set(callbackmapper_changes);
@@ -32462,7 +32649,7 @@ function create_each_block(ctx) {
 }
 
 // (71:2) {#if metadata?.step?.derived.isUserInputOptional || !metadata?.step?.derived.isStepSelfSubmittable}
-function create_if_block$1(ctx) {
+function create_if_block$2(ctx) {
 	let button;
 	let current;
 
@@ -32575,7 +32762,7 @@ function create_default_slot$2(ctx) {
 		each_blocks[i] = null;
 	});
 
-	let if_block2 = (/*metadata*/ ctx[3]?.step?.derived.isUserInputOptional || !/*metadata*/ ctx[3]?.step?.derived.isStepSelfSubmittable) && create_if_block$1(ctx);
+	let if_block2 = (/*metadata*/ ctx[3]?.step?.derived.isUserInputOptional || !/*metadata*/ ctx[3]?.step?.derived.isStepSelfSubmittable) && create_if_block$2(ctx);
 
 	t11 = new Locale_strings({
 			props: { key: "dontHaveAnAccount", html: true }
@@ -32696,7 +32883,7 @@ function create_default_slot$2(ctx) {
 				check_outros();
 			}
 
-			if (dirty & /*step, metadata, determineSubmission, $style*/ 792) {
+			if (dirty & /*step, metadata, determineSubmission, $styleStore*/ 792) {
 				each_value = /*step*/ ctx[4]?.callbacks;
 				let i;
 
@@ -32731,7 +32918,7 @@ function create_default_slot$2(ctx) {
 						transition_in(if_block2, 1);
 					}
 				} else {
-					if_block2 = create_if_block$1(ctx);
+					if_block2 = create_if_block$2(ctx);
 					if_block2.c();
 					transition_in(if_block2, 1);
 					if_block2.m(t5.parentNode, t5);
@@ -32834,7 +33021,7 @@ function create_fragment$2(ctx) {
 			const form_1_changes = {};
 			if (dirty & /*form*/ 2) form_1_changes.onSubmitWhenValid = /*form*/ ctx[1]?.submit;
 
-			if (dirty & /*$$scope, linkWrapper, journey, metadata, step, $style, alertNeedsFocus, formMessageKey, form*/ 131582) {
+			if (dirty & /*$$scope, linkWrapper, journey, metadata, step, $styleStore, alertNeedsFocus, formMessageKey, form*/ 131582) {
 				form_1_changes.$$scope = { dirty, ctx };
 			}
 
@@ -32862,8 +33049,8 @@ function create_fragment$2(ctx) {
 }
 
 function instance$2($$self, $$props, $$invalidate) {
-	let $style;
-	component_subscribe($$self, style, $$value => $$invalidate(8, $style = $$value));
+	let $styleStore;
+	component_subscribe($$self, styleStore, $$value => $$invalidate(8, $styleStore = $$value));
 	let { form } = $$props;
 	let { formEl = null } = $$props;
 	let { journey } = $$props;
@@ -32933,7 +33120,7 @@ function instance$2($$self, $$props, $$invalidate) {
 		alertNeedsFocus,
 		formMessageKey,
 		linkWrapper,
-		$style,
+		$styleStore,
 		determineSubmission,
 		click_handler,
 		click_handler_1,
@@ -32981,7 +33168,7 @@ function mapStepToStage(currentStep) {
 
 /* src/lib/journey/journey.svelte generated by Svelte v3.55.1 */
 
-function create_else_block(ctx) {
+function create_else_block$1(ctx) {
 	let alert;
 	let t;
 	let button;
@@ -33096,7 +33283,7 @@ function create_if_block_3(ctx) {
 }
 
 // (26:0) {#if !$journeyStore?.completed}
-function create_if_block(ctx) {
+function create_if_block$1(ctx) {
 	let current_block_type_index;
 	let if_block;
 	let if_block_anchor;
@@ -33411,7 +33598,7 @@ function create_fragment$1(ctx) {
 	let if_block;
 	let if_block_anchor;
 	let current;
-	const if_block_creators = [create_if_block, create_if_block_3, create_else_block];
+	const if_block_creators = [create_if_block$1, create_if_block_3, create_else_block$1];
 	const if_blocks = [];
 
 	function select_block_type(ctx, dirty) {
@@ -33537,139 +33724,21 @@ class Journey extends SvelteComponent {
 	}
 }
 
-function initialize$1(initOptions) {
-    const { set, subscribe } = writable({
-        completed: false,
-        error: null,
-        loading: false,
-        successful: false,
-        response: null,
-    });
-    async function get(getOptions) {
-        /**
-         * Create an options object with getOptions overriding anything from initOptions
-         * TODO: Does this object merge need to be more granular?
-         */
-        const options = {
-            ...{ query: { prompt: 'none' } },
-            ...initOptions,
-            ...getOptions,
-        };
-        let tokens;
-        try {
-            tokens = await TokenManager$1.getTokens(options);
-        }
-        catch (err) {
-            console.error(`Get tokens | ${err}`);
-            if (err instanceof Error) {
-                set({
-                    completed: true,
-                    error: {
-                        message: err.message,
-                    },
-                    loading: false,
-                    successful: false,
-                    response: null,
-                });
-            }
-            return;
-        }
-        set({
-            completed: true,
-            error: null,
-            loading: false,
-            successful: true,
-            response: tokens,
-        });
-    }
-    function reset() {
-        set({
-            completed: false,
-            error: null,
-            loading: false,
-            successful: false,
-            response: null,
-        });
-    }
-    return {
-        get,
-        reset,
-        subscribe,
-    };
-}
-
-function initialize(initOptions) {
-    const { set, subscribe } = writable({
-        completed: false,
-        error: null,
-        loading: false,
-        successful: false,
-        response: null,
-    });
-    async function get(getOptions) {
-        /**
-         * Create an options object with getOptions overriding anything from initOptions
-         * TODO: Does this object merge need to be more granular?
-         */
-        const options = {
-            ...initOptions,
-            ...getOptions,
-        };
-        try {
-            const user = await UserManager.getCurrentUser(options);
-            set({
-                completed: true,
-                error: null,
-                loading: false,
-                successful: true,
-                response: user,
-            });
-        }
-        catch (err) {
-            console.error(`Get current user | ${err}`);
-            if (err instanceof Error) {
-                set({
-                    completed: true,
-                    error: {
-                        message: err.message,
-                    },
-                    loading: false,
-                    successful: false,
-                    response: null,
-                });
-            }
-        }
-    }
-    function reset() {
-        set({
-            completed: false,
-            error: null,
-            loading: false,
-            successful: false,
-            response: null,
-        });
-    }
-    return {
-        get,
-        reset,
-        subscribe,
-    };
-}
+/* src/lib/widget/index.svelte generated by Svelte v3.55.1 */
 
-/* src/lib/widget/modal.svelte generated by Svelte v3.55.1 */
-
-function create_default_slot(ctx) {
+function create_else_block(ctx) {
+	let div;
 	let journey_1;
 	let updating_formEl;
 	let current;
 
-	function journey_1_formEl_binding(value) {
-		/*journey_1_formEl_binding*/ ctx[9](value);
+	function journey_1_formEl_binding_1(value) {
+		/*journey_1_formEl_binding_1*/ ctx[9](value);
 	}
 
 	let journey_1_props = {
-		displayIcon: /*style*/ ctx[0]?.stage?.icon || !/*style*/ ctx[0]?.logo,
-		journeyStore: api.getJourneyStore()
+		displayIcon: /*$styleStore*/ ctx[4]?.stage?.icon ?? true,
+		journeyStore: /*journeyStore*/ ctx[5]
 	};
 
 	if (/*formEl*/ ctx[3] !== void 0) {
@@ -33677,19 +33746,22 @@ function create_default_slot(ctx) {
 	}
 
 	journey_1 = new Journey({ props: journey_1_props });
-	binding_callbacks.push(() => bind(journey_1, 'formEl', journey_1_formEl_binding));
+	binding_callbacks.push(() => bind(journey_1, 'formEl', journey_1_formEl_binding_1));
 
 	return {
 		c() {
+			div = element("div");
 			create_component(journey_1.$$.fragment);
+			attr(div, "class", "fr_widget-root");
 		},
 		m(target, anchor) {
-			mount_component(journey_1, target, anchor);
+			insert(target, div, anchor);
+			mount_component(journey_1, div, null);
 			current = true;
 		},
 		p(ctx, dirty) {
 			const journey_1_changes = {};
-			if (dirty & /*style*/ 1) journey_1_changes.displayIcon = /*style*/ ctx[0]?.stage?.icon || !/*style*/ ctx[0]?.logo;
+			if (dirty & /*$styleStore*/ 16) journey_1_changes.displayIcon = /*$styleStore*/ ctx[4]?.stage?.icon ?? true;
 
 			if (!updating_formEl && dirty & /*formEl*/ 8) {
 				updating_formEl = true;
@@ -33709,36 +33781,37 @@ function create_default_slot(ctx) {
 			current = false;
 		},
 		d(detaching) {
-			destroy_component(journey_1, detaching);
+			if (detaching) detach(div);
+			destroy_component(journey_1);
 		}
 	};
 }
 
-function create_fragment(ctx) {
+// (28:0) {#if type === 'modal'}
+function create_if_block(ctx) {
 	let div;
 	let dialog;
 	let updating_dialogEl;
 	let current;
 
 	function dialog_dialogEl_binding(value) {
-		/*dialog_dialogEl_binding*/ ctx[10](value);
+		/*dialog_dialogEl_binding*/ ctx[7](value);
 	}
 
 	let dialog_props = {
-		closeCallback: /*_closeCallback*/ ctx[4],
 		dialogId: "sampleDialog",
-		withHeader: /*style*/ ctx[0]?.sections?.header,
+		withHeader: /*$styleStore*/ ctx[4]?.sections?.header,
 		$$slots: { default: [create_default_slot] },
 		$$scope: { ctx }
 	};
 
-	if (/*_dialogEl*/ ctx[2] !== void 0) {
-		dialog_props.dialogEl = /*_dialogEl*/ ctx[2];
+	if (/*dialogEl*/ ctx[2] !== void 0) {
+		dialog_props.dialogEl = /*dialogEl*/ ctx[2];
 	}
 
 	dialog = new Dialog({ props: dialog_props });
 	binding_callbacks.push(() => bind(dialog, 'dialogEl', dialog_dialogEl_binding));
-	/*dialog_binding*/ ctx[11](dialog);
+	/*dialog_binding*/ ctx[8](dialog);
 
 	return {
 		c() {
@@ -33751,17 +33824,17 @@ function create_fragment(ctx) {
 			mount_component(dialog, div, null);
 			current = true;
 		},
-		p(ctx, [dirty]) {
+		p(ctx, dirty) {
 			const dialog_changes = {};
-			if (dirty & /*style*/ 1) dialog_changes.withHeader = /*style*/ ctx[0]?.sections?.header;
+			if (dirty & /*$styleStore*/ 16) dialog_changes.withHeader = /*$styleStore*/ ctx[4]?.sections?.header;
 
-			if (dirty & /*$$scope, style, formEl*/ 8201) {
+			if (dirty & /*$$scope, $styleStore, formEl*/ 2072) {
 				dialog_changes.$$scope = { dirty, ctx };
 			}
 
-			if (!updating_dialogEl && dirty & /*_dialogEl*/ 4) {
+			if (!updating_dialogEl && dirty & /*dialogEl*/ 4) {
 				updating_dialogEl = true;
-				dialog_changes.dialogEl = /*_dialogEl*/ ctx[2];
+				dialog_changes.dialogEl = /*dialogEl*/ ctx[2];
 				add_flush_callback(() => updating_dialogEl = false);
 			}
 
@@ -33778,121 +33851,160 @@ function create_fragment(ctx) {
 		},
 		d(detaching) {
 			if (detaching) detach(div);
-			/*dialog_binding*/ ctx[11](null);
+			/*dialog_binding*/ ctx[8](null);
 			destroy_component(dialog);
 		}
 	};
 }
 
-let dialogComp;
-let dialogEl;
-let callMounted;
-let closeCallback;
-
-const api = widgetApiFactory({
-	close(args) {
-		dialogComp.closeDialog(args);
-	},
-	onClose(fn) {
-		closeCallback = args => fn(args);
-	},
-	onMount(fn) {
-		callMounted = (dialog, form) => fn(dialog, form);
-	},
-	open(options, forceRestart) {
-		// If journey does not have a step, start the journey
-		if (!get_store_value(api.getJourneyStore()).step || forceRestart) {
-			journey.start(options);
-		}
+// (30:4) <Dialog       bind:dialogEl       bind:this={dialogComp}       dialogId="sampleDialog"       withHeader={$styleStore?.sections?.header}     >
+function create_default_slot(ctx) {
+	let journey_1;
+	let updating_formEl;
+	let current;
 
-		dialogEl.showModal();
+	function journey_1_formEl_binding(value) {
+		/*journey_1_formEl_binding*/ ctx[6](value);
 	}
-});
 
-const configuration = api.configuration;
-const journey = api.journey;
-const modal = api.modal;
-const request = api.request;
-const user = api.user;
+	let journey_1_props = {
+		displayIcon: /*$styleStore*/ ctx[4]?.stage?.icon ?? !/*$styleStore*/ ctx[4]?.logo,
+		journeyStore: /*journeyStore*/ ctx[5]
+	};
 
-function instance($$self, $$props, $$invalidate) {
-	let { config = undefined } = $$props;
-	let { content = undefined } = $$props;
-	let { journeys = undefined } = $$props;
-	let { links = undefined } = $$props;
-	let { style = undefined } = $$props;
-	const dispatch = createEventDispatcher();
+	if (/*formEl*/ ctx[3] !== void 0) {
+		journey_1_props.formEl = /*formEl*/ ctx[3];
+	}
 
-	// Reference to the closeCallback from the above module context
-	let _closeCallback = closeCallback;
+	journey_1 = new Journey({ props: journey_1_props });
+	binding_callbacks.push(() => bind(journey_1, 'formEl', journey_1_formEl_binding));
 
-	// Variables that reference the Svelte component and the DOM element
-	// Variables with `_` reference points to the same variables from the `context="module"`
-	let _dialogComp;
+	return {
+		c() {
+			create_component(journey_1.$$.fragment);
+		},
+		m(target, anchor) {
+			mount_component(journey_1, target, anchor);
+			current = true;
+		},
+		p(ctx, dirty) {
+			const journey_1_changes = {};
+			if (dirty & /*$styleStore*/ 16) journey_1_changes.displayIcon = /*$styleStore*/ ctx[4]?.stage?.icon ?? !/*$styleStore*/ ctx[4]?.logo;
 
-	let _dialogEl;
+			if (!updating_formEl && dirty & /*formEl*/ 8) {
+				updating_formEl = true;
+				journey_1_changes.formEl = /*formEl*/ ctx[3];
+				add_flush_callback(() => updating_formEl = false);
+			}
 
-	// The single reference to the `form` DOM element
-	let formEl;
+			journey_1.$set(journey_1_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(journey_1.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(journey_1.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			destroy_component(journey_1, detaching);
+		}
+	};
+}
 
-	if (config) {
-		// Set base config to SDK
-		// TODO: Move to a shared utility
-		configure({
-			// Set some basics by default
-			...{
-				// TODO: Could this be a default OAuth client provided by Platform UI OOTB?
-				clientId: 'WebLoginWidgetClient',
-				// TODO: If a realmPath is not provided, should we call the realm endpoint and detect a likely default?
-				// https://backstage.forgerock.com/docs/am/7/setup-guide/sec-rest-realm-rest.html#rest-api-list-realm
-				realmPath: 'alpha',
-				// TODO: Once we move to SSR, this default should be more intelligent
-				redirectUri: typeof window === 'object'
-				? window.location.href
-				: 'https://localhost:3000/callback',
-				scope: 'openid email'
-			},
-			// Let user provided config override defaults
-			...config,
-			// Force 'legacy' to remove confusion
-			...{ support: 'legacy' }
-		});
+function create_fragment(ctx) {
+	let current_block_type_index;
+	let if_block;
+	let if_block_anchor;
+	let current;
+	const if_block_creators = [create_if_block, create_else_block];
+	const if_blocks = [];
+
+	function select_block_type(ctx, dirty) {
+		if (/*type*/ ctx[0] === 'modal') return 0;
+		return 1;
 	}
 
-	/**
- * Initialize the stores and ensure both variables point to the same reference.
- * Variables with _ are the reactive version of the original variable from above.
- */
-	api.setJourneyStore(initialize$4(config));
+	current_block_type_index = select_block_type(ctx);
+	if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
 
-	api.setOAuthStore(initialize$1(config));
-	api.setUserStore(initialize(config));
-	initialize$6(content);
-	initialize$3(journeys);
-	initialize$2(links);
-	initialize$5(style);
+	return {
+		c() {
+			if_block.c();
+			if_block_anchor = empty();
+		},
+		m(target, anchor) {
+			if_blocks[current_block_type_index].m(target, anchor);
+			insert(target, if_block_anchor, anchor);
+			current = true;
+		},
+		p(ctx, [dirty]) {
+			let previous_block_index = current_block_type_index;
+			current_block_type_index = select_block_type(ctx);
 
-	onMount(() => {
-		dialogComp = _dialogComp;
-		dialogEl = _dialogEl;
+			if (current_block_type_index === previous_block_index) {
+				if_blocks[current_block_type_index].p(ctx, dirty);
+			} else {
+				group_outros();
 
-		/**
- * Call mounted event for Singleton users
- */
-		callMounted && callMounted(_dialogEl, formEl);
+				transition_out(if_blocks[previous_block_index], 1, 1, () => {
+					if_blocks[previous_block_index] = null;
+				});
 
-		/**
- * Call mounted event for Instance users
- * NOTE: needs to be wrapped in setTimeout. Asked in Svelte Discord
- * if this is an issue or expected. Answer: Object instantiation seems
- * to be synchronous, so this doesn't get called without `setTimeout`.
- */
-		setTimeout(
-			() => {
-				dispatch('modal-mount', 'Modal mounted');
-			},
-			0
-		);
+				check_outros();
+				if_block = if_blocks[current_block_type_index];
+
+				if (!if_block) {
+					if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+					if_block.c();
+				} else {
+					if_block.p(ctx, dirty);
+				}
+
+				transition_in(if_block, 1);
+				if_block.m(if_block_anchor.parentNode, if_block_anchor);
+			}
+		},
+		i(local) {
+			if (current) return;
+			transition_in(if_block);
+			current = true;
+		},
+		o(local) {
+			transition_out(if_block);
+			current = false;
+		},
+		d(detaching) {
+			if_blocks[current_block_type_index].d(detaching);
+			if (detaching) detach(if_block_anchor);
+		}
+	};
+}
+
+const api = widgetApiFactory(componentApi());
+const configuration = api.configuration;
+const journey = api.journey;
+const component = componentApi;
+const request = api.request;
+const user = api.user;
+
+function instance($$self, $$props, $$invalidate) {
+	let $styleStore;
+	component_subscribe($$self, styleStore, $$value => $$invalidate(4, $styleStore = $$value));
+	let { type = 'modal' } = $$props;
+	const componentEvents = componentApi();
+	const { journeyStore } = api.getStores();
+
+	// Variables that reference the Svelte component and the DOM elements
+	let dialogComp;
+
+	let dialogEl;
+	let formEl;
+
+	onMount(() => {
+		componentEvents.mount(dialogComp, dialogEl);
 	});
 
 	function journey_1_formEl_binding(value) {
@@ -33901,59 +34013,51 @@ function instance($$self, $$props, $$invalidate) {
 	}
 
 	function dialog_dialogEl_binding(value) {
-		_dialogEl = value;
-		$$invalidate(2, _dialogEl);
+		dialogEl = value;
+		$$invalidate(2, dialogEl);
 	}
 
 	function dialog_binding($$value) {
 		binding_callbacks[$$value ? 'unshift' : 'push'](() => {
-			_dialogComp = $$value;
-			$$invalidate(1, _dialogComp);
+			dialogComp = $$value;
+			$$invalidate(1, dialogComp);
 		});
 	}
 
+	function journey_1_formEl_binding_1(value) {
+		formEl = value;
+		$$invalidate(3, formEl);
+	}
+
 	$$self.$$set = $$props => {
-		if ('config' in $$props) $$invalidate(5, config = $$props.config);
-		if ('content' in $$props) $$invalidate(6, content = $$props.content);
-		if ('journeys' in $$props) $$invalidate(7, journeys = $$props.journeys);
-		if ('links' in $$props) $$invalidate(8, links = $$props.links);
-		if ('style' in $$props) $$invalidate(0, style = $$props.style);
+		if ('type' in $$props) $$invalidate(0, type = $$props.type);
 	};
 
 	return [
-		style,
-		_dialogComp,
-		_dialogEl,
+		type,
+		dialogComp,
+		dialogEl,
 		formEl,
-		_closeCallback,
-		config,
-		content,
-		journeys,
-		links,
+		$styleStore,
+		journeyStore,
 		journey_1_formEl_binding,
 		dialog_dialogEl_binding,
-		dialog_binding
+		dialog_binding,
+		journey_1_formEl_binding_1
 	];
 }
 
-class Modal extends SvelteComponent {
+class Widget extends SvelteComponent {
 	constructor(options) {
 		super();
-
-		init(this, options, instance, create_fragment, safe_not_equal, {
-			config: 5,
-			content: 6,
-			journeys: 7,
-			links: 8,
-			style: 0
-		});
+		init(this, options, instance, create_fragment, safe_not_equal, { type: 0 });
 	}
 }
 
+exports.component = component;
 exports.configuration = configuration;
-exports.default = Modal;
+exports.default = Widget;
 exports.journey = journey;
-exports.modal = modal;
 exports.request = request;
 exports.user = user;
-//# sourceMappingURL=modal.cjs.map
+//# sourceMappingURL=index.cjs.map