@adyen/kyc-components 4.25.0 → 4.26.0-beta.0

package/dist/resolveEnvironment-D8-1H8bU.js

@@ -0,0 +1,2516 @@
+try {
+	let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+	n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f91e2604-fff9-48f8-8b24-069a632bf6af", e._sentryDebugIdIdentifier = "sentry-dbid-f91e2604-fff9-48f8-8b24-069a632bf6af");
+} catch (e) {}
+import { a as setDefaults, i as setI18n, n as addResourceBundles, r as useTranslation } from "./translation-CpH8D2NK.js";
+import { t as createLogger } from "./logger-Z8AeTE4x.js";
+import { t as Icon } from "./Icon-_YUEZg1p.js";
+import { t as Typography } from "./Typography-CAc_f5Iq.js";
+import { t as Loader } from "./Loader-BDaKGf77.js";
+import { n as IconButton, t as Button } from "./Button-Dwr6jvJZ.js";
+import { a as setSdkTokenHandler, i as refreshSession, n as httpGet, o as ApiProvider, r as httpPost, s as useApiContext } from "./http-C8rt2BZk.js";
+import { r as useLegalEntity, t as ROOT_LE } from "./useLegalEntity-CxeMoCm4.js";
+import { t as getLegalEntityCountry } from "./getLegalEntityCountry-BK-HHa65.js";
+import { n as SettingsContext, t as useSettingsContext } from "./useSettingsContext-Bpf4UqRT.js";
+import { c as valuesOf, i as noop, o as entriesOf, s as keysOf, t as cloneObject } from "./genUtils-nphCwt1A.js";
+import { t as StackLayout } from "./StackLayout-J1ynSX-P.js";
+import { t as TaskVerificationStatus } from "./TaskVerificationStatus-zoxTZ2mt.js";
+import { i as TaskStatuses, r as TASK_STATUS_PRIORITY } from "./taskStatus-BtekPA8E.js";
+import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
+import { t as Skeleton } from "./Skeleton-7xDqhYr-.js";
+import { t as Accordion } from "./Accordion-BAdwrgCR.js";
+import { C as CUSTOMER_SUPPORT_DATA_MISSING_ERROR_CODES, n as getCapabilityProblems, t as getCapabilities } from "./processCapabilities-FL4-KAbd.js";
+import { t as TaskTypes } from "./taskTypes-3vSkMBDm.js";
+import { a as getLegalRepresentative, i as getDirectEntityAssociations, l as getOwnSoleProprietorshipIdArray } from "./entityAssociationUtil-BlfcBl3i.js";
+import { i as getOwnDecisionMakersLegalEntityIds, n as getDecisionMakers, o as hasMinRequiredDecisionMakerCount } from "./decisionMakerRoles-DA8MK9Dh.js";
+import { n as TrustMemberGuidanceLabels, r as TrustMemberTypes } from "./trustMemberGuidance-BpeDHAJP.js";
+import { t as getNestedPropertyKeys } from "./getNestedPropertyKeys-Cd8HKupP.js";
+import { n as isEuCountry, r as isHkSgCountry } from "./country-WYlusjTL.js";
+import i18n from "i18next";
+import { Suspense, lazy } from "preact/compat";
+import { useCallback as useCallback$1, useContext as useContext$1, useEffect as useEffect$1, useMemo as useMemo$1, useReducer, useRef as useRef$1, useState as useState$1 } from "preact/hooks";
+import cx from "classnames";
+import { Fragment as Fragment$1, jsx, jsxs } from "preact/jsx-runtime";
+import { computed, signal } from "@preact/signals";
+import { QueryCache, QueryClient, QueryClientProvider, useMutation, useQuery } from "@tanstack/preact-query";
+import { createContext as createContext$1, isValidElement as isValidElement$1 } from "preact";
+import { defineSlots } from "named-slots";
+//#region node_modules/.pnpm/vite-plugin-shadow-styles@0.0.3_vite@8.2.2_@types+node@26.3.0_esbuild@0.27.7_jiti@2.7.0_sass@1.99.0_/node_modules/vite-plugin-shadow-styles/dist/stylesheets.js
+var sheet = new CSSStyleSheet();
+var stylesheets = [sheet];
+import("./styles-DYaAeu4q.js").then(({ css }) => {
+	sheet.replaceSync(css);
+}).catch((err) => console.error("Error loading styles", err));
+//#endregion
+//#region src/language/i18n.ts
+/**
+* Initializes i18next and defines configurations
+* i18next-resources-to-backend is a simple plugin used for the lazy loading of translation resources
+*/
+i18n.use({
+	type: "3rdParty",
+	init(instance) {
+		setDefaults(instance.options.react);
+		setI18n(instance);
+	}
+}).init({
+	defaultNS: false,
+	fallbackLng: "en-US",
+	load: "currentOnly",
+	resources: {},
+	showSupportNotice: false,
+	react: {
+		transSupportBasicHtmlNodes: true,
+		transKeepBasicHtmlNodesFor: [
+			"strong",
+			"i",
+			"em"
+		],
+		bindI18n: "languageChanged",
+		bindI18nStore: "added"
+	},
+	interpolation: {
+		prefix: "%{",
+		suffix: "}"
+	}
+});
+//#endregion
+//#region src/api/configurations/useVersionConfiguration.ts
+/**
+* Retrieves information about the onboarding version and version-specific features to enable
+* linked to the legalEntityId
+*/
+var getVersionConfiguration = async (legalEntityId, baseUrl) => {
+	return httpGet({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/configurations/version`
+	});
+};
+var useVersionConfiguration = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: ["versionConfiguration"],
+		queryFn: () => getVersionConfiguration(rootLegalEntityId.value, baseUrl.value),
+		...options
+	});
+};
+//#endregion
+//#region src/api/uiAnalytics/useAnalyticsSession.ts
+/**
+* @description Request to get an analytics session ID and fire an "Initiate session" event on Mixpanel
+* @param data.userData Sets user profile properties on Mixpanel
+* @returns a session id that is sent with every subsequent log event request
+*/
+var getAnalyticsSession = async (baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `analytics/ui`
+	}, data);
+};
+var useAnalyticsSession = (sessionData, onboardingVersion, options) => {
+	const { baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: ["analyticsSession", onboardingVersion],
+		queryFn: () => getAnalyticsSession(baseUrl.value, sessionData),
+		enabled: Boolean(onboardingVersion),
+		...options
+	});
+};
+//#endregion
+//#region src/core/user-events.ts
+var UserEvents = class {
+	queue = [];
+	subscriptions = /* @__PURE__ */ new Set();
+	/** payload of commmon props sent in every event */
+	baseTrackingPayload;
+	/** properties not set with every event but that may be shared between some events
+	* ex. `page` value for `Interacted with form field` events
+	*/
+	sharedEventProperties;
+	constructor() {
+		this.baseTrackingPayload = {
+			category: "onboarding",
+			subCategory: "hosted onboarding"
+		};
+		this.sharedEventProperties = {};
+	}
+	add(...args) {
+		this.queue.push(...args);
+	}
+	notifySubscribers() {
+		while (this.queue.length > 0) {
+			const lastEvent = this.queue.pop();
+			this.subscriptions.forEach((callback) => callback(lastEvent));
+		}
+	}
+	/**
+	* Adds an analytics event with all base event properties.
+	*/
+	addEvent(eventName, properties) {
+		const completeEvent = {
+			...this.baseTrackingPayload,
+			...properties
+		};
+		this.add({
+			type: "add_event",
+			name: eventName,
+			properties: completeEvent
+		});
+		this.notifySubscribers();
+	}
+	/**
+	* Adds an event with context specific to journey-related events
+	*/
+	addJourneyEvent(eventName, properties) {
+		this.addEvent(eventName, {
+			actionLevel: "journey",
+			...properties
+		});
+	}
+	/**
+	* Adds an event with context specific to task-related events
+	*/
+	addTaskEvent(eventName, properties) {
+		this.addEvent(eventName, {
+			actionLevel: "task",
+			...properties
+		});
+	}
+	/**
+	* Adds an event with context specific to page-related events
+	*/
+	addPageEvent(eventName, properties) {
+		this.addEvent(eventName, {
+			actionLevel: "page",
+			page: this.sharedEventProperties.page,
+			...properties
+		});
+	}
+	/**
+	* Adds an event with context specific to field-related events
+	*/
+	addFieldEvent(eventName, properties) {
+		this.addEvent(eventName, {
+			actionLevel: "field",
+			page: this.sharedEventProperties.page,
+			...properties
+		});
+	}
+	/**
+	* Tracks an experiment for Mixpanel experiment reporting
+	*/
+	trackExperiment({ name, variant }) {
+		this.add({
+			type: "add_event",
+			name: "$experiment_started",
+			properties: {
+				...this.baseTrackingPayload,
+				"Experiment name": name,
+				"Variant name": variant
+			}
+		});
+	}
+	/**
+	* Subscribes a callback to analytics events. It gets called every time
+	* one of the above public methods get called, and the event data is passed back as an array.
+	* The callback must have a single argument which is an array of [eventName, eventPayload?].
+	* @example
+	* ```js
+	* const callback = ([eventName, eventPayload]) => console.log(eventName, eventPayload);
+	* this.subscribe(callback);
+	*
+	* const exampleEventPayload = { count: 1, segmentation: { foo: 'bar' } };
+	* this.addEvent('exampleEventDidOccur', exampleEventPayload);
+	*
+	* // `callback` will get called with `['exampleEventDidOccur', exampleEventPayload]`
+	* ```
+	*/
+	subscribe(callback) {
+		this.subscriptions.add(callback);
+	}
+	/**
+	* Sets params that are sent on every event
+	* */
+	updateBaseTrackingPayload(baseTrackingPayload) {
+		this.baseTrackingPayload = {
+			...this.baseTrackingPayload,
+			...baseTrackingPayload
+		};
+	}
+	/**
+	* Sets params that may be shared between events
+	* */
+	updateSharedEventProperties = (props) => {
+		this.sharedEventProperties = {
+			...this.sharedEventProperties,
+			...props
+		};
+	};
+	/**
+	* Removes a subscribed callback
+	*/
+	unsubscribe(callback) {
+		if (this.subscriptions.has(callback)) this.subscriptions.delete(callback);
+	}
+};
+var createUserEvents = () => {
+	return new UserEvents();
+};
+//#endregion
+//#region src/api/uiAnalytics/usePushAnalyticEvent.ts
+var pushAnalyticEvent = async (baseUrl, sessionId, data) => {
+	return httpPost({
+		baseUrl,
+		path: `analytics/ui/${sessionId}`
+	}, data);
+};
+var usePushAnalyticEvent = (sessionId, options) => {
+	const { baseUrl } = useApiContext();
+	return useMutation({
+		mutationFn: (data) => pushAnalyticEvent(baseUrl.value, sessionId, data),
+		...options
+	});
+};
+//#endregion
+//#region src/utils/analytics/convertToEmbeddedEvent.ts
+var convertToEmbeddedEvent = (eventQueueItem, sessionData) => {
+	const { type, name, properties } = eventQueueItem;
+	return {
+		eventName: name,
+		eventType: type,
+		eventData: properties || {},
+		legalEntityId: sessionData.legalEntityId,
+		userAgent: sessionData.userAgent,
+		componentName: sessionData.componentName,
+		sdkVersion: sessionData.sdkVersion
+	};
+};
+//#endregion
+//#region src/utils/analytics/getAnalyticsAssociatedEntityDetails.ts
+/**
+* Gets associated legal entity type and ID for the base tracking payload
+* Based on selected account holder type
+*/
+var getAnalyticsAssociatedEntityDetails = (rootLegalEntity, accountHolderType) => {
+	let associatedLegalEntityType;
+	switch (accountHolderType) {
+		case "aTrust":
+			associatedLegalEntityType = "trust";
+			break;
+		case "mySoleProprietorName":
+			associatedLegalEntityType = "soleProprietorship";
+			break;
+		case "anUnincorporatedPartnership":
+			associatedLegalEntityType = "unincorporatedPartnership";
+			break;
+		default: associatedLegalEntityType = void 0;
+	}
+	const associatedLegalEntity = rootLegalEntity.entityAssociations?.find((ea) => ea.type === associatedLegalEntityType);
+	return {
+		associatedLegalEntityType,
+		associatedLegalEntityId: associatedLegalEntity?.legalEntityId
+	};
+};
+//#endregion
+//#region src/utils/testing/ignoreLocalStorage.tsx
+var IgnoreLocalStorageContext = createContext$1(false);
+var useIgnoreLocalStorage = () => useContext$1(IgnoreLocalStorageContext);
+//#endregion
+//#region src/hooks/useLocalStorage.ts
+var logger$4 = createLogger();
+var useLocalStorage = (key, defaultValue, options) => {
+	const { serializer, parser, syncData } = useMemo$1(() => ({
+		serializer: JSON.stringify,
+		parser: JSON.parse,
+		syncData: true,
+		...options
+	}), [options]);
+	const ignoreLocalStorage = useIgnoreLocalStorage() || typeof window === "undefined";
+	const rawValueRef = useRef$1(null);
+	const [value, setValue] = useState$1(() => {
+		if (ignoreLocalStorage) return defaultValue;
+		try {
+			rawValueRef.current = window.localStorage.getItem(key);
+			return rawValueRef.current ? parser(rawValueRef.current) : defaultValue;
+		} catch (err) {
+			logger$4.error(err);
+			return defaultValue;
+		}
+	});
+	useEffect$1(() => {
+		if (ignoreLocalStorage) return;
+		const updateLocalStorage = () => {
+			if (value !== void 0) {
+				const newValue = serializer(value);
+				const oldValue = rawValueRef.current;
+				rawValueRef.current = newValue;
+				window.localStorage.setItem(key, newValue);
+				window.dispatchEvent(new StorageEvent("storage", {
+					storageArea: window.localStorage,
+					url: window.location.href,
+					key,
+					newValue,
+					oldValue
+				}));
+			} else {
+				window.localStorage.removeItem(key);
+				window.dispatchEvent(new StorageEvent("storage", {
+					storageArea: window.localStorage,
+					url: window.location.href,
+					key
+				}));
+			}
+		};
+		try {
+			updateLocalStorage();
+		} catch (err) {
+			logger$4.error(err);
+		}
+	}, [value, ignoreLocalStorage]);
+	useEffect$1(() => {
+		if (!syncData) return;
+		const handleStorageChange = (event) => {
+			if (event.key !== key || event.storageArea !== window.localStorage) return;
+			try {
+				if (event.newValue !== rawValueRef.current) {
+					rawValueRef.current = event.newValue;
+					setValue(event.newValue ? parser(event.newValue) : void 0);
+				}
+			} catch (err) {
+				logger$4.error(err);
+			}
+		};
+		if (ignoreLocalStorage) return;
+		window.addEventListener("storage", handleStorageChange);
+		return () => {
+			window.removeEventListener("storage", handleStorageChange);
+		};
+	}, [
+		key,
+		syncData,
+		ignoreLocalStorage
+	]);
+	return [value, setValue];
+};
+//#endregion
+//#region src/hooks/useAccountHolder.ts
+var getAccountHolderStorageKey = (legalEntityId) => `ACCOUNT_HOLDER-${legalEntityId}`;
+var useAccountHolder = () => {
+	const { rootLegalEntityId } = useApiContext();
+	const [accountHolderFromLocalStorage, setAccountHolderIntoLocalStorage] = useLocalStorage(getAccountHolderStorageKey(rootLegalEntityId.value), void 0);
+	return {
+		accountHolder: accountHolderFromLocalStorage,
+		setAccountHolder: setAccountHolderIntoLocalStorage
+	};
+};
+//#endregion
+//#region src/hooks/useAnalytics/useAnalytics.ts
+var useAnalytics = ({ userEvents, sessionId, sessionData }) => {
+	const sdkVersion = "4.26.0-beta.0";
+	const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+	const { mutateAsync } = usePushAnalyticEvent(sessionId ?? "");
+	const { accountHolder } = useAccountHolder();
+	useEffect$1(() => {
+		if (!rootLegalEntity) return;
+		const countryCode = getLegalEntityCountry(rootLegalEntity);
+		const capabilities = Object.keys(rootLegalEntity?.capabilities ?? {});
+		userEvents.updateBaseTrackingPayload({
+			entityType: rootLegalEntity.type,
+			countryCode,
+			capabilities,
+			sdkVersion,
+			componentName: sessionData.componentName,
+			userAgent: navigator.userAgent,
+			...getAnalyticsAssociatedEntityDetails(rootLegalEntity, accountHolder)
+		});
+	}, [
+		rootLegalEntity,
+		accountHolder,
+		sdkVersion,
+		sessionData.componentName,
+		userEvents
+	]);
+	const pushEvents = useCallback$1((data) => {
+		const eventItem = convertToEmbeddedEvent(data, sessionData);
+		mutateAsync(eventItem);
+	}, [mutateAsync, sessionData]);
+	useEffect$1(() => {
+		if (!sessionId) return;
+		userEvents.subscribe(pushEvents);
+		return () => {
+			userEvents.unsubscribe(pushEvents);
+		};
+	}, [
+		sessionId,
+		mutateAsync,
+		userEvents,
+		sessionData,
+		pushEvents
+	]);
+};
+//#endregion
+//#region src/utils/analytics/getPrefilledDetails.ts
+var getOrganizationPrefilledFields = (organization) => {
+	const { dateOfIncorporation, financialReports, registeredAddress, registrationNumber, support, taxInformation, type, vatNumber } = organization;
+	const financialReport = financialReports?.[0];
+	return {
+		dateOfIncorporation: !!dateOfIncorporation,
+		financialReport: {
+			annualTurnover: !!financialReport?.annualTurnover,
+			balanceSheetTotal: !!financialReport?.balanceSheetTotal,
+			dateOfFinancialData: !!financialReport?.dateOfFinancialData,
+			employeeCount: !!financialReport?.employeeCount
+		},
+		registeredAddress: {
+			city: !!registeredAddress?.city,
+			postalCode: !!registeredAddress?.postalCode,
+			stateOrProvince: !!registeredAddress?.stateOrProvince,
+			street: !!registeredAddress?.street
+		},
+		registrationNumber: !!registrationNumber,
+		support: {
+			email: !!support?.email,
+			phone: !!support?.phone
+		},
+		taxInformation: !!taxInformation?.some((taxInfo) => taxInfo.country && taxInfo.number),
+		type: !!type,
+		vatNumber: !!vatNumber
+	};
+};
+var getPrefilledDetails = (legalEntity) => {
+	if (!legalEntity) return;
+	const { organization, transferInstruments, entityAssociations } = legalEntity;
+	return {
+		transferInstrumentCount: transferInstruments?.length || 0,
+		entityAssociations: entityAssociations?.map((entity) => entity.type) || [],
+		organization: organization && getOrganizationPrefilledFields(organization)
+	};
+};
+var AnalyticsContext = createContext$1({
+	addEvent: noop,
+	addJourneyEvent: noop,
+	addTaskEvent: noop,
+	addPageEvent: noop,
+	addFieldEvent: noop,
+	startEvent: noop,
+	subscribe: noop,
+	trackExperiment: noop,
+	updateBaseTrackingPayload: noop,
+	updateSharedEventProperties: noop,
+	unsubscribe: noop
+});
+//#endregion
+//#region src/context/AnalyticsContext/AnalyticsProvider.tsx
+/**
+* The provider exists to scope analytics to one application instance.
+* This would otherwise be problematic when a consumer might have several
+* instantiations of a embedded Component for instance on the same page
+*/
+var AnalyticsProvider = ({ componentName, children, rootLegalEntityId, locale }) => {
+	const { settings } = useSettingsContext();
+	const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+	const { data: versionData, isError, isLoading } = useVersionConfiguration();
+	const userEvents = useMemo$1(() => createUserEvents(), []);
+	const onboardingVersion = isLoading ? void 0 : isError ? 1 : versionData?.version;
+	const capabilities = rootLegalEntity?.capabilities && Object.keys(rootLegalEntity.capabilities);
+	const shouldTrackPrefilledDetails = capabilities?.includes("receivePayments") && onboardingVersion && onboardingVersion > 1;
+	const sessionData = {
+		sdkVersion: "4.26.0-beta.0",
+		componentName,
+		userAgent: navigator.userAgent,
+		legalEntityId: rootLegalEntityId,
+		capabilities,
+		entityType: rootLegalEntity?.type,
+		eventData: shouldTrackPrefilledDetails ? getPrefilledDetails(rootLegalEntity) : void 0,
+		userData: {
+			onboardingVersion,
+			isDirectMerchant: settings.merchantType === "direct",
+			settings,
+			country: rootLegalEntity && getLegalEntityCountry(rootLegalEntity)
+		}
+	};
+	const { data } = useAnalyticsSession(sessionData, onboardingVersion);
+	userEvents.updateBaseTrackingPayload({ locale });
+	useAnalytics({
+		userEvents,
+		sessionId: data?.id,
+		sessionData
+	});
+	return /* @__PURE__ */ jsx(AnalyticsContext.Provider, {
+		value: userEvents,
+		children
+	});
+};
+//#endregion
+//#region src/context/QueryContext/QueryClient.ts
+var QueryClient$1 = new QueryClient({
+	defaultOptions: {
+		queries: {
+			staleTime: 3e5,
+			refetchOnWindowFocus: false,
+			refetchOnReconnect: true,
+			refetchOnMount: true,
+			retry: 2
+		},
+		mutations: { retry: 1 }
+	},
+	queryCache: new QueryCache({
+		onSuccess: (data, query) => {
+			if (query.meta?.onSuccess && typeof query.meta.onSuccess === "function") query.meta.onSuccess(data);
+		},
+		onError: (data, query) => {
+			if (query.meta?.onError && typeof query.meta.onError === "function") query.meta.onError(data);
+		}
+	})
+});
+//#endregion
+//#region src/context/QueryContext/QueryClientProvider.tsx
+/** Standard tanstack query provider, needed for it to work */
+var QueryClientProvider$1 = ({ children }) => /* @__PURE__ */ jsx(QueryClientProvider, {
+	client: QueryClient$1,
+	children
+});
+//#endregion
+//#region src/context/SettingsContext/SettingsProvider.tsx
+var settingsDefaults = {
+	acceptedCountries: void 0,
+	allowBankAccountFormatSelection: false,
+	allowDebugUi: false,
+	allowIntraRegionCrossBorderPayout: false,
+	changeLegalEntityType: true,
+	editPrefilledCountry: true,
+	enableEInvoicingCodeField: false,
+	enableJapanLocalization: false,
+	requirePciSignEcomMoto: false,
+	requirePciSignEcommerce: false,
+	requirePciSignPos: false,
+	requirePciSignPosMoto: false,
+	hideOnboardingIntroductionIndividual: true,
+	hideOnboardingIntroductionOrganization: true,
+	hideOnboardingIntroductionTrust: true,
+	hideOnboardingIntroductionSoleProprietor: true,
+	hidePayoutAccountTask: false,
+	transferInstrumentLimit: 0,
+	instantBankVerification: true,
+	showServiceAgreementsFirst: false,
+	showBusinessFinancingFirst: false,
+	enforceLegalAge: false,
+	showExtraTaxExemptionReasons: false,
+	merchantType: void 0,
+	allowBusinessLines: false,
+	allowCrossBorderPayout: false
+};
+/**
+* Consumers can pass settings @see settingsDefaults, which can alter on runtime
+* the behaviour of our library
+* The settings are dynamically passed during SDK initialization (same as legalEntityId)
+* @param settings - dictionary of type Settings
+*/
+function SettingsProvider({ children, settings }) {
+	const mergedSettings = {
+		...settingsDefaults,
+		...settings
+	};
+	const contextValue = useMemo$1(() => ({
+		isSettingEnabled: (settingName) => mergedSettings[settingName],
+		getSetting: (settingName) => mergedSettings[settingName],
+		settings: mergedSettings
+	}), [settings]);
+	return /* @__PURE__ */ jsx(SettingsContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+//#endregion
+//#region src/context/StateContext/StateContext.ts
+var StateContext = createContext$1(null);
+//#endregion
+//#region src/utils/validatorUtils.ts
+var MAX_LENGTH = 30;
+var getMaxLengthByFieldAndCountry = (formattingRules, field, country, ignoreIfFormatterExists) => {
+	if (!country) return void 0;
+	if (ignoreIfFormatterExists && formattingRules[country]?.[field]?.formatter) return;
+	return formattingRules[country]?.[field]?.maxlength || MAX_LENGTH;
+};
+var isUndefinedOrNull = (input) => input === void 0 || input === null;
+var isEmpty = (input) => isUndefinedOrNull(input) || typeof input === "object" && Object.keys(input).length === 0 || typeof input === "string" && /^\s*$/.test(input);
+var hasEmptyFields = (input) => input !== void 0 && (Object.keys(input).length === 0 || Object.values(input).some((value) => value === void 0 || value === null || value === ""));
+var isAccountIdentifierObscured = (payload) => {
+	const accountIdentifier = payload?.type === "iban" ? payload.iban : payload?.accountNumber;
+	return Boolean(accountIdentifier) && accountIdentifier.includes("*");
+};
+var extractFieldName = (inputString) => {
+	const fieldNames = inputString?.split(".");
+	return fieldNames?.length > 0 ? fieldNames[fieldNames.length - 1] : "";
+};
+var concatenateFieldNames = (fieldNames) => fieldNames?.join(", ");
+var isString = (input) => typeof input === "string" || input instanceof String;
+var hasText = (input) => isString(input) && !isEmpty(input);
+var SPECIAL_CHARS = "?\\-\\+_=!@#$%^&*(){}~<>\\[\\]\\/\\\\";
+var getFormattingRegEx = (specChars, flags = "g") => new RegExp(`[${specChars}]`, flags);
+var EMOJI_REGEX = /(\p{Emoji}\uFE0F|\p{Emoji_Presentation}|\p{Extended_Pictographic})/gu;
+var NO_ALPHABET_REGEX = /^[^a-zA-Z]*$/;
+var NO_ALPHABET_UNICODE_REGEX = /^[^\p{L}]*$/u;
+var INDIVIDUAL_VALID_CHAR_REGEX = /^[\p{L}\p{M}\d\s\-—./']*$/u;
+var ADDRESS_VALID_CHAR_REGEX = /^[\p{L}\p{M}\d\s\-—.,/']*$/u;
+var OTHER_ENTITIES_VALID_CHAR_REGEX = /^[\w\s,.;:\-—&!?@()"'/\\+\p{L}\p{M}]+$/u;
+var URL_REGEX = /^(https?:\/\/)\S+$/i;
+var HAS_PROTOCOL_REGEX = /^https?:\/\//i;
+var LATIN_SPACE_MARK_PUNCTUATION_NUMBERS_REGEX = /^[\p{sc=Latin}\p{Zs}\p{M}\p{Punctuation}\p{N}]+$/u;
+var matchesRegex = (regex, input) => isString(input) && regex.test(input ?? "");
+var hasRepeatedCharacters = (input) => !isEmpty(input) && input.length > 1 && new Set(input.toLowerCase()).size === 1;
+var hasMaximumTwoRepeatedCharacters = (input) => !isEmpty(input) && input.length > 2 && new Set(input.toLowerCase()).size === 1;
+var isValidMinLength = (input, minLength = 1) => !isEmpty(input) && input.length >= minLength;
+var isInvalidName = (input) => {
+	return (/* @__PURE__ */ new Set([
+		"John Doe",
+		"Jane Doe",
+		"ABCD",
+		"ABCDE",
+		"ABCDEF",
+		"ABCDEFG",
+		"My Customer",
+		"An other",
+		"n/a",
+		"not applicable",
+		"n/A",
+		"N/A",
+		"N/a",
+		"N\\ /A",
+		"not app",
+		"null"
+	])).has(input || "");
+};
+var standardKanjiValidator = (input) => {
+	const regex = /* @__PURE__ */ new RegExp("^[一-鿿㐀-䶿豈-﫿ぁ-ゖァ-ヺー-ヿ０-９Ａ-Ｚａ-ｚ・ー‐－−’，．＆　Ⅰ-Ⅺ･-ﾟA-Za-z0-9,.& ]+$");
+	return !isEmpty(input) && regex.test(input);
+};
+var standardKatakanaValidator = (input) => {
+	const regex = /* @__PURE__ */ new RegExp("^[ァ-ヶㇰ-ㇿＡ-Ｚａ-ｚ０-９・ー‐－−’，．＆　Ⅰ-Ⅺ･-ﾟA-Za-z0-9 ,.& へべぺ]+$");
+	return !isEmpty(input) && regex.test(input);
+};
+var chomeAndBanchiValidator = (input) => {
+	const regex = /* @__PURE__ */ new RegExp("^([0-9]{1,4}-[0-9]{1,4}|[0-9]{1,4}-[0-9]{1,4}-[0-9]{1,4}|[0-9]{1,4}-[0-9]{1,4}-[0-9]{1,4}-[0-9]{1,4})$");
+	return !isEmpty(input) && regex.test(input);
+};
+function assertString(input) {
+	if (input === void 0 || input === null) throw new TypeError(`Expected a string but received a ${input}`);
+	if (input.constructor.name !== "String") throw new TypeError(`Expected a string but received a ${input.constructor.name}`);
+}
+var isin = /^[A-Z]{2}[0-9A-Z]{9}[0-9]$/;
+function isISIN(str) {
+	assertString(str);
+	if (!isin.test(str)) return false;
+	let double = true;
+	let sum = 0;
+	for (let i = str.length - 2; i >= 0; i--) {
+		const char = str[i];
+		if (char >= "A" && char <= "Z") {
+			const value = char.charCodeAt(0) - 55;
+			const lo = value % 10;
+			const hi = Math.trunc(value / 10);
+			for (const digit of [lo, hi]) {
+				if (double) {
+					if (digit >= 5) sum += 1 + (digit - 5) * 2;
+					else sum += digit * 2;
+				} else sum += digit;
+				double = !double;
+			}
+		} else {
+			const digit = parseInt(char, 10);
+			if (double) {
+				if (digit >= 5) sum += 1 + (digit - 5) * 2;
+				else sum += digit * 2;
+			} else sum += digit;
+			double = !double;
+		}
+	}
+	const check = Math.trunc((sum + 9) / 10) * 10 - sum;
+	const lastChar = str[str.length - 1];
+	if (lastChar === void 0 || isNaN(parseInt(lastChar, 10))) return false;
+	return parseInt(lastChar, 10) === check;
+}
+//#endregion
+//#region src/utils/removeObjectEmptyValues.ts
+function removeObjectPropsWithEmptyValues(obj) {
+	keysOf(obj).forEach((key) => {
+		if (obj[key] === null || isEmpty(obj[key])) delete obj[key];
+	});
+	return obj;
+}
+//#endregion
+//#region src/context/StateContext/StateReducer.ts
+var INITIAL_STATE = {
+	data: {},
+	allData: {},
+	initialData: {},
+	errors: {},
+	valid: {},
+	fieldProblems: {},
+	isValid: false,
+	allValid: false
+};
+var logger$3 = createLogger();
+function StateReducer() {
+	const [schemas, setSchemas] = useState$1({});
+	const [activeForms, setActiveForms] = useState$1([]);
+	const setCurrentForms = (forms) => {
+		setActiveForms(forms);
+	};
+	function reducer({ currentState: currState, prevState }, action) {
+		switch (action.type) {
+			case "addToState": {
+				if (!action.value.dataStoreId) {
+					logger$3.warn("No dataStoreId provided, hence no update can be done");
+					return {
+						currentState: currState,
+						prevState
+					};
+				}
+				const dataStoreId = action.value.dataStoreId;
+				const state = structuredClone(currState);
+				const schema = action.value.schema || null;
+				const schemaHasChanged = schema && schemas?.[dataStoreId]?.toString() !== schema.toString();
+				const mergedState = {
+					...state,
+					data: {
+						...state.data,
+						[dataStoreId]: {
+							...state.data[dataStoreId],
+							...action.value.data
+						}
+					},
+					allData: {
+						...state.allData,
+						[dataStoreId]: {
+							...state.allData[dataStoreId],
+							...removeObjectPropsWithEmptyValues(action.value.data)
+						}
+					},
+					errors: {
+						...state.errors,
+						[dataStoreId]: {
+							...state.errors[dataStoreId],
+							...action.value.errors
+						}
+					},
+					valid: {
+						...state.valid,
+						[dataStoreId]: {
+							...state.valid[dataStoreId],
+							...action.value.valid
+						}
+					},
+					fieldProblems: {
+						...state.fieldProblems,
+						[dataStoreId]: {
+							...state.fieldProblems[dataStoreId],
+							...action.value.fieldProblems
+						}
+					}
+				};
+				/**
+				* Some components e.g. personalDetails, are parents for other components and the data from these children is collected
+				* under the parent's id (aka dataStoreId) i.e. 'personalDetails.
+				*
+				* With these parents sometimes their schema for their useForm implementation updates at run time - so this fny checks
+				* if a schema has changed and if so ensures that the keys output in the data, valid, errors, fieldProblems objects
+				* match those of the parent schema
+				*/
+				if (schemaHasChanged) {
+					setSchemas({
+						...schemas,
+						[dataStoreId]: schema
+					});
+					const processedBySchema = schema.reduce((acc, fieldKey) => {
+						const dataObjByFormId = mergedState.data[dataStoreId];
+						const allDataObjByFormId = mergedState.allData[dataStoreId];
+						const validObjByFormId = mergedState.valid[dataStoreId];
+						const errorsObjByFormId = mergedState.errors[dataStoreId];
+						const fieldProblemsObjByFormId = mergedState.fieldProblems[dataStoreId];
+						return {
+							data: {
+								...acc.data,
+								[fieldKey]: dataObjByFormId[fieldKey] ?? allDataObjByFormId[fieldKey]
+							},
+							valid: {
+								...acc.valid,
+								[fieldKey]: validObjByFormId[fieldKey]
+							},
+							errors: {
+								...acc.errors,
+								[fieldKey]: errorsObjByFormId[fieldKey]
+							},
+							fieldProblems: {
+								...acc.fieldProblems,
+								[fieldKey]: fieldProblemsObjByFormId[fieldKey]
+							}
+						};
+					}, {
+						data: {},
+						valid: {},
+						errors: {},
+						fieldProblems: {}
+					});
+					mergedState.data[dataStoreId] = processedBySchema.data;
+					mergedState.valid[dataStoreId] = processedBySchema.valid;
+					mergedState.errors[dataStoreId] = processedBySchema.errors;
+					mergedState.fieldProblems[dataStoreId] = processedBySchema.fieldProblems;
+				}
+				mergedState.validityByForm = {
+					...mergedState.validityByForm,
+					[dataStoreId]: Object.values(mergedState.valid[dataStoreId]).every((isValid) => isValid)
+				};
+				mergedState.allValid = Object.values(mergedState.validityByForm).every((isValid) => isValid);
+				mergedState.isValid = !activeForms.length ? mergedState.allValid : activeForms.every((item) => mergedState.validityByForm?.[item]);
+				mergedState.initialData = structuredClone(state.initialData);
+				return {
+					currentState: mergedState,
+					prevState: state
+				};
+			}
+			case "removeFromState": {
+				if (!action.value.dataStoreId) {
+					logger$3.warn("No dataStoreId provided, hence no update can be done");
+					return {
+						currentState: currState,
+						prevState
+					};
+				}
+				const dataStoreId = action.value.dataStoreId;
+				const state = structuredClone(currState);
+				const mergedState = {
+					...state,
+					data: {
+						...state.data,
+						[dataStoreId]: {}
+					},
+					allData: {
+						...state.allData,
+						[dataStoreId]: {}
+					},
+					errors: {
+						...state.errors,
+						[dataStoreId]: {}
+					},
+					valid: {
+						...state.valid,
+						[dataStoreId]: false
+					},
+					fieldProblems: {
+						...state.fieldProblems,
+						[dataStoreId]: {}
+					}
+				};
+				mergedState.validityByForm = {
+					...mergedState.validityByForm,
+					[dataStoreId]: false
+				};
+				mergedState.allValid = Object.values(mergedState.validityByForm).every((isValid) => isValid);
+				mergedState.isValid = !activeForms.length ? mergedState.allValid : activeForms.every((item) => mergedState.validityByForm?.[item]);
+				mergedState.initialData = structuredClone(state.initialData);
+				return {
+					currentState: mergedState,
+					prevState: state
+				};
+			}
+			case "resetState": return {
+				currentState: INITIAL_STATE,
+				prevState: currState
+			};
+			default: throw new Error(`Unhandled action type: ${action.type}`);
+		}
+	}
+	return {
+		reducer,
+		setCurrentForms
+	};
+}
+//#endregion
+//#region src/context/StateContext/StateProvider.tsx
+function StateProvider({ defaultData = {}, children }) {
+	const defaultState = {
+		currentState: {
+			data: defaultData,
+			allData: defaultData,
+			valid: {},
+			errors: {},
+			fieldProblems: {},
+			validityByForm: {},
+			initialData: defaultData
+		},
+		prevState: {}
+	};
+	const reducerObj = StateReducer();
+	const [state, dispatch] = useReducer(reducerObj.reducer, defaultState);
+	/**
+	* Create an object from the returned reducer props
+	* - the state property in this object will be available to any handler functions set on StateContextWatcher
+	* - the dispatch property is made available to the StateContextSetter
+	*/
+	const contextValue = useMemo$1(() => ({
+		state,
+		dispatch,
+		setActiveForms: reducerObj.setCurrentForms,
+		getData: () => state?.currentState?.data ?? {},
+		getState: () => state?.currentState
+	}), [reducerObj, state]);
+	return /* @__PURE__ */ jsx(StateContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+var Toast_module_default = {
+	toast: "_toast_5bwuk_1",
+	"present-toast": "_present-toast_5bwuk_1",
+	presentToast: "_present-toast_5bwuk_1",
+	"toast-image": "_toast-image_5bwuk_22",
+	toastImage: "_toast-image_5bwuk_22",
+	"toast-image-success": "_toast-image-success_5bwuk_32",
+	toastImageSuccess: "_toast-image-success_5bwuk_32",
+	"toast-image-error": "_toast-image-error_5bwuk_37",
+	toastImageError: "_toast-image-error_5bwuk_37",
+	"toast-label": "_toast-label_5bwuk_42",
+	toastLabel: "_toast-label_5bwuk_42",
+	"toast-actions": "_toast-actions_5bwuk_55",
+	toastActions: "_toast-actions_5bwuk_55",
+	"toast-action-close": "_toast-action-close_5bwuk_64",
+	toastActionClose: "_toast-action-close_5bwuk_64"
+};
+//#endregion
+//#region src/components/ui/molecules/Toast/Toast.tsx
+var Toast = ({ action, duration = 1e4, label, onDismiss, variant = "info" }) => {
+	const hasIcon = variant === "success" || variant === "error";
+	const hasAction = action !== void 0;
+	const role = hasAction ? "alertdialog" : "alert";
+	const iconNames = {
+		error: "field-error",
+		success: "checkmark"
+	};
+	const imageClassname = cx(Toast_module_default.toastImage, {
+		[Toast_module_default.toastImageSuccess]: variant === "success",
+		[Toast_module_default.toastImageError]: variant === "error"
+	});
+	useEffect$1(() => {
+		let dismissToastTimer;
+		if (duration !== "indefinite") dismissToastTimer = setTimeout(() => {
+			onDismiss();
+		}, duration);
+		return () => {
+			clearTimeout(dismissToastTimer);
+		};
+	}, [duration, onDismiss]);
+	return /* @__PURE__ */ jsxs("div", {
+		"aria-label": label,
+		className: Toast_module_default.toast,
+		role,
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: Toast_module_default.toastLabel,
+			children: [hasIcon && /* @__PURE__ */ jsx("div", {
+				className: imageClassname,
+				"data-testId": iconNames[variant],
+				children: /* @__PURE__ */ jsx(Icon, { name: iconNames[variant] })
+			}), label]
+		}), /* @__PURE__ */ jsxs("div", {
+			className: Toast_module_default.toastActions,
+			children: [hasAction && /* @__PURE__ */ jsx(Button, {
+				onClick: action.onClick,
+				children: action.label
+			}), /* @__PURE__ */ jsx("div", {
+				className: Toast_module_default.toastActionClose,
+				children: /* @__PURE__ */ jsx(IconButton, {
+					icon: "cross",
+					ariaLabel: "Close",
+					onClick: onDismiss
+				})
+			})]
+		})]
+	});
+};
+//#endregion
+//#region src/context/ToastContext/ToastContext.ts
+var ToastContext = createContext$1({
+	showToast: noop,
+	clearToasts: noop
+});
+//#endregion
+//#region src/context/ToastContext/ToastContextProvider.tsx
+function ToastContextProvider({ children }) {
+	const [toastOptions, setToastOptions] = useState$1();
+	const clearToasts = () => {
+		setToastOptions(void 0);
+	};
+	const contextValue = useMemo$1(() => ({
+		showToast: (options) => {
+			setToastOptions(options);
+		},
+		clearToasts
+	}), []);
+	return /* @__PURE__ */ jsxs(ToastContext.Provider, {
+		value: contextValue,
+		children: [!!toastOptions && /* @__PURE__ */ jsx(Toast, {
+			label: toastOptions.label,
+			variant: toastOptions.variant,
+			action: toastOptions.action,
+			duration: toastOptions.duration,
+			onDismiss: clearToasts
+		}), children]
+	});
+}
+//#endregion
+//#region src/api/toggles/useToggles.ts
+/**
+* Retrieves experiments and onboardingcomponents-specific feature flags
+* as defined in `OnboardingcomponentsFeatures.java` linked to the legalEntityId
+*/
+var getToggles = async (legalEntityId, baseUrl) => {
+	const { experiments, features } = await httpGet({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/flags`
+	});
+	return {
+		experiments: experiments ? Object.values(experiments).reduce((acc, val) => {
+			return {
+				...acc,
+				[val]: true
+			};
+		}, {}) : {},
+		features
+	};
+};
+var useToggles = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: ["toggles"],
+		queryFn: () => getToggles(rootLegalEntityId.value, baseUrl.value),
+		...options
+	});
+};
+//#endregion
+//#region src/utils/listToRecord.ts
+var listToRecord = (list, getValue) => list.reduce((acc, k) => ({
+	...acc,
+	[k]: getValue(k)
+}), {});
+//#endregion
+//#region src/context/ToggleContext/ToggleContext.tsx
+var ToggleContext = createContext$1({
+	features: {},
+	isFeatureEnabled: () => false,
+	experiments: {},
+	isExperimentEnabled: () => false,
+	refreshExperiments: () => {}
+});
+//#endregion
+//#region src/context/ToggleContext/types.ts
+/**
+* Features which are passed into our SDK via a prop (ex. `adyen-onboarding.tsx` or `EmbedShell.tsx`)
+* These are enabled/disabled via our feature framework and are intended to be short-lived. Used for feature rollout purposes.
+*/
+var PropFeatureNames = {
+	/**
+	* Old features
+	*/
+	AllowMoreRolesForMainRootTrustee: "AllowMoreRolesForMainRootTrustee",
+	EnablePhoneFieldScenario: "EnablePhoneFieldScenario",
+	ShowUnsupportedEntityType: "ShowUnsupportedEntityType"
+};
+/**
+* Features which are returned from a call made to onboardingcomponents for feature flags and experiments (see `useToggles`).
+* These are enabled/disabled via our feature framework and are intended to be short-lived. Used for feature rollout purposes.
+* Defined in the BE (`OnboardingcomponentsFeatures.java`).
+*/
+var FeatureFrameworkFeatureNames = {
+	/**
+	* OXP-6596: Enable Bank Document Classification in HO
+	*/
+	EnableBankDocumentClassification: "EnableBankDocumentClassification",
+	/**
+	* OXP-6596: Enable Bank Document Classification in ShadowMode in HO
+	*/
+	EnableBankDocumentClassificationShadowMode: "EnableBankDocumentClassificationShadowMode",
+	/**
+	* OXP-6032: Enable editing a single business line
+	*/
+	EnableDeleteBusinessLines: "EnableDeleteBusinessLines",
+	/**
+	* OXP-6799: Enable limit to a single business line
+	*/
+	EnableLimitToSingleBusinessLine: "EnableLimitToSingleBusinessLine",
+	/**
+	* OXP-6032: Enable editing a single business line
+	*/
+	EnableModifyBusinessLines: "EnableModifyBusinessLines",
+	/**
+	* Enable "Verify by Invite" flow for decision makers in Identity Verification
+	*/
+	EnableVerifyByInvite: "EnableVerifyByInvite",
+	/**
+	OXP-6566: Create new payout intro screen
+	*/
+	EnableBankAccountDetailsLandingPage: "EnableBankAccountDetailsLandingPage",
+	/**
+	Enable AWE generated UI for PoC
+	*/
+	EnableAdaptivePoc: "EnableAdaptivePoc",
+	/**
+	* OXP-7774: Enable LEI field in Business Details Task
+	*/
+	EnableLegalEntityIdentifierField: "EnableLegalEntityIdentifierField",
+	/**
+	* OXP-7836: Enable bank account type selection for US payout details
+	*/
+	EnableUSBankAccountTypeSelection: "EnableUSBankAccountTypeSelection",
+	/**
+	* Enable Singpass MyInfo login for the individual flow. When disabled, individual legal entities
+	* are not eligible for Singpass, all other flows keep their existing eligibility
+	*/
+	SingpassMyInfoEnabled: "SingpassMyInfoEnabled"
+};
+/**
+* Features which are returned from a call made to onboardingcomponents for version-specific features. (see `useVersions`).
+* Version specific features are tied to the specific onboarding/LEM version (ex. v4-specific features) rather than for feature rollout purposes.
+* Defined in the BE (`VersionSpecificToggle.java`).
+*/
+var VersionFeatureNames = {
+	/**
+	*
+	*/
+	EnableAgeVerification: "EnableAgeVerification",
+	/**
+	* Allows users to specify a 'Country of Governing Law' for UK companies
+	* within Business Details Task
+	*/
+	EnableCountryOfGoverningLawForUKCompanies: "EnableCountryOfGoverningLawForUKCompanies",
+	/**
+	*
+	*/
+	EnableDoingBusinessAsNameV4: "EnableDoingBusinessAsNameV4",
+	/**
+	*
+	*/
+	EnableFinancialInformationComponentV4: "EnableFinancialInformationComponentV4",
+	/**
+	*
+	*/
+	EnableNationalitySGHK: "EnableNationalitySGHK",
+	/**
+	*
+	*/
+	EnableRegistrationAndTaxAbsentStatesV4: "EnableRegistrationAndTaxAbsentStatesV4",
+	/**
+	* OXP-7814: Allows businesses to declare that their registered business address
+	* is a personal address or PO box
+	*/
+	EnableResidentialAddressIndicator: "EnableResidentialAddressIndicator",
+	/**
+	*
+	*/
+	ShowCustomerSupportV4: "ShowCustomerSupportV4",
+	/**
+	*
+	*/
+	StrictNameAndAddressValidationV4: "StrictNameAndAddressValidationV4",
+	/**
+	* OXP-7861: Enable Global Entry Flow
+	*/
+	EnableGlobalEntryFlow: "EnableGlobalEntryFlow"
+};
+/**
+* Experiments which are returned from a call made to onboardingcomponents for feature flags and experiments (see `useToggles`).
+* Experiments are used to toggle behavior for A/B testing purposes.
+* Defined using the Experimentation Platform in BO.
+*
+* Naming convention: `${ExperimentName}_${TreatmentGroupNameOrControl}` ex. `BankingVerificationExperiment_Treatment1` or `BusinessSearchExperiment_control`
+*/
+var ExperimentNames = {
+	/**
+	* OXP-7319: Experiment with Forced Manual Payout Flow
+	*/
+	BankingPayoutFlow_ForcedManualVerification: "BankingPayoutFlow_ForcedManualVerification",
+	/**
+	* Test a clearer remediation message when a bank document needs review.
+	*/
+	BankDocumentClassification_WarningMessaging: "BankDocumentClassification_WarningMessaging"
+};
+var FeatureNames = {
+	...PropFeatureNames,
+	...FeatureFrameworkFeatureNames,
+	...VersionFeatureNames
+};
+//#endregion
+//#region src/context/ToggleContext/ToggleContextProvider.tsx
+/**
+* To manage accessing non-production-ready features of SDK
+* or features under active experimentation/testing.
+* @param children - components rendered
+* @param features - dictionary of type Features
+* @param refreshExperiments - handler to refresh experiments for the legal entity
+*/
+function ToggleContextProvider({ children, features: propFeatures, refreshExperiments }) {
+	const { data: toggleData } = useToggles();
+	const { data: versionData } = useVersionConfiguration();
+	const features = useMemo$1(() => ({
+		...toggleData?.features,
+		...propFeatures,
+		...listToRecord(versionData?.features ?? [], () => true)
+	}), [
+		versionData,
+		propFeatures,
+		toggleData?.features
+	]);
+	const experiments = useMemo$1(() => ({
+		...listToRecord(valuesOf(ExperimentNames), (experiment) => propFeatures[experiment] ?? false),
+		...toggleData?.experiments
+	}), [propFeatures, toggleData?.experiments]);
+	const contextValue = useMemo$1(() => ({
+		features,
+		isFeatureEnabled: (feature) => features[feature] ?? false,
+		experiments,
+		isExperimentEnabled: (experiment) => experiments[experiment] ?? false,
+		refreshExperiments
+	}), [
+		features,
+		experiments,
+		refreshExperiments
+	]);
+	return /* @__PURE__ */ jsx(ToggleContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+//#endregion
+//#region \0rolldown_dynamic_import_helper.js
+var _rolldown_dynamic_import_helper_default = (glob, path, segments) => {
+	const query = path.lastIndexOf("?");
+	const v = glob[query === -1 || query < path.lastIndexOf("/") ? path : path.slice(0, query)];
+	if (v) return typeof v === "function" ? v() : Promise.resolve(v);
+	return new Promise((_, reject) => {
+		(typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(reject.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + path + (path.split("/").length !== segments ? ". Note that variables only represent file names one level deep." : ""))));
+	});
+};
+var Header_module_default = {
+	header: "_header_15umz_1",
+	"header-margin": "_header-margin_15umz_7",
+	headerMargin: "_header-margin_15umz_7",
+	"header-margin-secondary": "_header-margin-secondary_15umz_11",
+	headerMarginSecondary: "_header-margin-secondary_15umz_11",
+	"header-left": "_header-left_15umz_15",
+	headerLeft: "_header-left_15umz_15",
+	"header-center": "_header-center_15umz_20",
+	headerCenter: "_header-center_15umz_20",
+	"header-right": "_header-right_15umz_25",
+	headerRight: "_header-right_15umz_25",
+	"header-content": "_header-content_15umz_30",
+	headerContent: "_header-content_15umz_30",
+	"header-actions": "_header-actions_15umz_36",
+	headerActions: "_header-actions_15umz_36",
+	"header-title": "_header-title_15umz_40",
+	headerTitle: "_header-title_15umz_40",
+	"header-title-primary": "_header-title-primary_15umz_45",
+	headerTitlePrimary: "_header-title-primary_15umz_45",
+	"header-title-secondary": "_header-title-secondary_15umz_52",
+	headerTitleSecondary: "_header-title-secondary_15umz_52",
+	"header-description": "_header-description_15umz_58",
+	headerDescription: "_header-description_15umz_58",
+	"header-description-primary": "_header-description-primary_15umz_65",
+	headerDescriptionPrimary: "_header-description-primary_15umz_65",
+	"header-description-secondary": "_header-description-secondary_15umz_69",
+	headerDescriptionSecondary: "_header-description-secondary_15umz_69"
+};
+//#endregion
+//#region src/components/ui/atoms/Header/Header.tsx
+var alignmentStyles = {
+	left: Header_module_default.headerLeft,
+	center: Header_module_default.headerCenter,
+	right: Header_module_default.headerRight
+};
+var Header = ({ align = "left", children, description, secondary = false, status, title }) => {
+	const { Slot, hasSlot } = defineSlots(children ?? [], ["actions", "description"]);
+	const HeadingElement = secondary ? "h2" : "h1";
+	const rootClassname = cx(Header_module_default.header, alignmentStyles[align], {
+		[Header_module_default.headerMargin]: !secondary,
+		[Header_module_default.headerMarginSecondary]: secondary
+	});
+	const titleClassname = cx(Header_module_default.headerTitle, {
+		[Header_module_default.headerTitlePrimary]: !secondary,
+		[Header_module_default.headerTitleSecondary]: secondary
+	});
+	const descriptionClassname = cx(Header_module_default.headerDescription, {
+		[Header_module_default.headerDescriptionPrimary]: !secondary,
+		[Header_module_default.headerDescriptionSecondary]: secondary
+	});
+	return /* @__PURE__ */ jsxs("header", {
+		className: rootClassname,
+		children: [
+			status && /* @__PURE__ */ jsx(TaskVerificationStatus, {
+				status,
+				responsive: false
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: Header_module_default.headerContent,
+				children: [/* @__PURE__ */ jsx(HeadingElement, {
+					className: titleClassname,
+					children: title
+				}), (hasSlot("description") || description) && /* @__PURE__ */ jsx("div", {
+					className: descriptionClassname,
+					children: /* @__PURE__ */ jsx(Slot, {
+						name: "description",
+						children: description
+					})
+				})]
+			}),
+			hasSlot("actions") && /* @__PURE__ */ jsx("div", {
+				className: Header_module_default.headerActions,
+				children: /* @__PURE__ */ jsx(StackLayout, {
+					gap: "small",
+					horizontal: true,
+					children: /* @__PURE__ */ jsx(Slot, { name: "actions" })
+				})
+			})
+		]
+	});
+};
+//#endregion
+//#region src/api/configurations/useSupportedCountries.ts
+/**
+* Retrieves from the backend information about supported countries
+* linked to the legalEntityId
+*
+* @param id legalEntityId
+* @param options additional options passed to Tanstack Query, eg; refetchInterval for polling
+*/
+var getSupportedCountries = async (legalEntityId, baseUrl) => {
+	return httpGet({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/configurations/supportedCountries`
+	});
+};
+var useSupportedCountries = (options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: ["supportedCountries"],
+		queryFn: () => getSupportedCountries(rootLegalEntityId.value, baseUrl.value),
+		...options
+	});
+};
+//#endregion
+//#region src/context/SettingsContext/useSetting.ts
+var useSetting = (settingName) => {
+	const { getSetting } = useContext$1(SettingsContext);
+	return getSetting(settingName);
+};
+//#endregion
+//#region src/utils/api/useCapabilities.ts
+var useCapabilities = () => {
+	const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+	return rootLegalEntity?.capabilities;
+};
+//#endregion
+//#region src/hooks/useAllowedCountries.ts
+var businessAccountCountries = [
+	CountryCodes.Austria,
+	CountryCodes.Belgium,
+	CountryCodes.Croatia,
+	CountryCodes.Cyprus,
+	CountryCodes.Estonia,
+	CountryCodes.Finland,
+	CountryCodes.France,
+	CountryCodes.Germany,
+	CountryCodes.Greece,
+	CountryCodes.Ireland,
+	CountryCodes.Italy,
+	CountryCodes.Latvia,
+	CountryCodes.Lithuania,
+	CountryCodes.Luxembourg,
+	CountryCodes.Malta,
+	CountryCodes.Netherlands,
+	CountryCodes.Portugal,
+	CountryCodes.Slovakia,
+	CountryCodes.Slovenia,
+	CountryCodes.Spain,
+	CountryCodes.UnitedKingdom,
+	CountryCodes.UnitedStates
+];
+var useAllowedCountries = () => {
+	const isLimitCountryBusinessAccountCustomersEnabled = Object.keys(useCapabilities() ?? {}).includes("issueBankAccount");
+	const acceptedCountriesSetting = useSetting("acceptedCountries");
+	const { data } = useSupportedCountries({ enabled: !acceptedCountriesSetting });
+	const allowedCountries = acceptedCountriesSetting ?? data?.countries;
+	if (!allowedCountries) return;
+	return isLimitCountryBusinessAccountCustomersEnabled ? businessAccountCountries.filter((country) => allowedCountries.includes(country)) : allowedCountries;
+};
+//#endregion
+//#region src/datasets/generators/loadCountries.ts
+var logger$2 = createLogger();
+var countriesImports = /* #__PURE__ */ Object.assign({
+	"../countries/de-DE.json": () => import("./de-DE-DY_EJohI.js"),
+	"../countries/el-GR.json": () => import("./el-GR-zFv0QxMR.js"),
+	"../countries/en-US.json": () => import("./en-US-CI7y0UEH.js"),
+	"../countries/es-ES.json": () => import("./es-ES-BdByhG4y.js"),
+	"../countries/fr-FR.json": () => import("./fr-FR-Doo1FVx-.js"),
+	"../countries/it-IT.json": () => import("./it-IT-BFIW0DCO.js"),
+	"../countries/ja-JP.json": () => import("./ja-JP-DOuEAOlh.js"),
+	"../countries/nl-NL.json": () => import("./nl-NL-BUwMAW5C.js"),
+	"../countries/pt-PT.json": () => import("./pt-PT-Du2K44jh.js"),
+	"../countries/sv-SE.json": () => import("./sv-SE-DESDUMyu.js")
+});
+var loadCountriesDataset = async (locale) => {
+	const importForLocale = countriesImports[`../countries/${locale}.json`];
+	if (!importForLocale) {
+		logger$2.warn(`No countries dataset for ${locale}, falling back to en-US`);
+		return (await import("./en-US-CI7y0UEH.js")).default;
+	}
+	return (await importForLocale()).default;
+};
+//#endregion
+//#region src/datasets/generators/loadStatesDataset.ts
+var logger$1 = createLogger();
+var statesImports = /* #__PURE__ */ Object.assign({
+	"../states/AU/en-US.json": () => import("./en-US-CRoNUEFi.js"),
+	"../states/BR/en-US.json": () => import("./en-US-C6sEvgbn.js"),
+	"../states/BR/pt-BR.json": () => import("./pt-BR-C3I_7Mcz.js"),
+	"../states/CA/en-US.json": () => import("./en-US-D0pPfuzx.js"),
+	"../states/JP/en-US.json": () => import("./en-US-BqvVH-Pi.js"),
+	"../states/JP/ja-JP.json": () => import("./ja-JP-eKLuhutG.js"),
+	"../states/NZ/en-US.json": () => import("./en-US-KKriaTJw.js"),
+	"../states/US/en-US.json": () => import("./en-US-t-Z87qeJ.js")
+});
+var loadStatesDataset = async (country, locale) => {
+	const importForLocale = statesImports[`../states/${country}/${locale}.json`];
+	if (!importForLocale) {
+		logger$1.warn(`No ${country} states dataset for ${locale}, falling back to en-US`);
+		const fallbackImport = statesImports[`../states/${country}/en-US.json`];
+		return (await fallbackImport()).default;
+	}
+	return (await importForLocale()).default;
+};
+//#endregion
+//#region src/utils/datasetUtil.ts
+var normalizedDatasets = {};
+var datasets = {};
+var createDatasetKey = (identifier, locale) => `${identifier}_${locale}`.toLowerCase();
+var getNormalizeDataset = (datasetKey) => {
+	if (!normalizedDatasets[datasetKey]) {
+		normalizedDatasets[datasetKey] = {};
+		datasets[datasetKey].forEach(({ id, name }) => {
+			normalizedDatasets[datasetKey][id] = name;
+		});
+	}
+	return normalizedDatasets[datasetKey];
+};
+var getDataName = (datasetKey, key) => {
+	if (datasets[datasetKey]) return getNormalizeDataset(datasetKey)[key];
+	return null;
+};
+var datasetIdentifier = {
+	country: "countries",
+	state: (countryCode) => `states/${countryCode}`
+};
+function datasetUtilities(locale) {
+	return {
+		getCountryName: (countryCode) => {
+			if (!countryCode) return null;
+			return getDataName(createDatasetKey(datasetIdentifier.country, locale), countryCode);
+		},
+		getStateName: (stateCode, countryCode) => {
+			return getDataName(createDatasetKey(datasetIdentifier.state(countryCode), locale), stateCode);
+		},
+		setDataset: (identifier, dataset) => {
+			const datasetKey = createDatasetKey(identifier, locale);
+			datasets[datasetKey] = dataset;
+		},
+		getDataset: (identifier) => {
+			return datasets[createDatasetKey(identifier, locale)];
+		},
+		getDatasetKey: (identifier) => createDatasetKey(identifier, locale)
+	};
+}
+//#endregion
+//#region src/core/services/agnostic/get-dataset.ts
+var loadDataset = async (identifier, locale) => {
+	if (identifier === datasetIdentifier.country) return loadCountriesDataset(locale);
+	if (identifier.startsWith("states")) return loadStatesDataset(identifier.slice(identifier.indexOf("/") + 1), locale);
+	throw new Error(`Unknown dataset: ${identifier}`);
+};
+var getDataset = async (identifier, locale) => {
+	const datasetUtils = datasetUtilities(locale);
+	const dataset = datasetUtils.getDataset(identifier);
+	if (dataset) return new Promise((resolve) => {
+		resolve(dataset);
+	});
+	return loadDataset(identifier, locale).then((datasetResponse) => {
+		datasetUtils.setDataset(identifier, datasetResponse);
+		return datasetResponse;
+	});
+};
+//#endregion
+//#region src/hooks/useDataset.ts
+function useDataset(datasetIdentifier, skip) {
+	const { i18n } = useTranslation();
+	const [dataset, setDataset] = useState$1([]);
+	const [loaded, setLoaded] = useState$1(false);
+	useEffect$1(() => {
+		if (skip) return;
+		getDataset(datasetIdentifier, i18n.language).then((response) => {
+			const result = response && response.length ? response : [];
+			setDataset(result);
+		}).catch(() => {
+			setDataset([]);
+		}).finally(() => {
+			setLoaded(true);
+		});
+	}, [
+		datasetIdentifier,
+		i18n.language,
+		skip
+	]);
+	return {
+		dataset,
+		loaded
+	};
+}
+var alert_module_default = {
+	alert: "_alert_jgk1f_1",
+	"alert-without-icon": "_alert-without-icon_jgk1f_10",
+	alertWithoutIcon: "_alert-without-icon_jgk1f_10",
+	"alert-explanation": "_alert-explanation_jgk1f_10",
+	alertExplanation: "_alert-explanation_jgk1f_10",
+	"alert-actions": "_alert-actions_jgk1f_11",
+	alertActions: "_alert-actions_jgk1f_11",
+	"alert-basic": "_alert-basic_jgk1f_15",
+	alertBasic: "_alert-basic_jgk1f_15",
+	"alert-info": "_alert-info_jgk1f_19",
+	alertInfo: "_alert-info_jgk1f_19",
+	"alert-error": "_alert-error_jgk1f_23",
+	alertError: "_alert-error_jgk1f_23",
+	"alert-warning": "_alert-warning_jgk1f_27",
+	alertWarning: "_alert-warning_jgk1f_27",
+	"alert-success": "_alert-success_jgk1f_31",
+	alertSuccess: "_alert-success_jgk1f_31",
+	"alert-header": "_alert-header_jgk1f_35",
+	alertHeader: "_alert-header_jgk1f_35",
+	"alert-header-without-children": "_alert-header-without-children_jgk1f_40",
+	alertHeaderWithoutChildren: "_alert-header-without-children_jgk1f_40",
+	"alert-icon": "_alert-icon_jgk1f_44",
+	alertIcon: "_alert-icon_jgk1f_44",
+	"alert-icon-info": "_alert-icon-info_jgk1f_48",
+	alertIconInfo: "_alert-icon-info_jgk1f_48",
+	"alert-icon-error": "_alert-icon-error_jgk1f_52",
+	alertIconError: "_alert-icon-error_jgk1f_52",
+	"alert-icon-warning": "_alert-icon-warning_jgk1f_56",
+	alertIconWarning: "_alert-icon-warning_jgk1f_56",
+	"alert-icon-success": "_alert-icon-success_jgk1f_60",
+	alertIconSuccess: "_alert-icon-success_jgk1f_60",
+	"alert-title": "_alert-title_jgk1f_64",
+	alertTitle: "_alert-title_jgk1f_64"
+};
+//#endregion
+//#region src/components/ui/molecules/Alert/Alert.tsx
+var variantMap = {
+	basic: alert_module_default.alertBasic,
+	info: alert_module_default.alertInfo,
+	error: alert_module_default.alertError,
+	warning: alert_module_default.alertWarning,
+	success: alert_module_default.alertSuccess
+};
+var iconVariantMap = {
+	basic: "",
+	info: alert_module_default.alertIconInfo,
+	error: alert_module_default.alertIconError,
+	warning: alert_module_default.alertIconWarning,
+	success: alert_module_default.alertIconSuccess
+};
+var Alert = ({ title, variant = "basic", type = "default", className, actions, children, icon, testId, onClose, onToggle }) => {
+	const { t } = useTranslation("ui");
+	const [isClosed, setIsClosed] = useState$1(false);
+	if (isClosed) return null;
+	const closeAlert = () => {
+		if (onClose) onClose();
+		setIsClosed(true);
+	};
+	const renderIcon = () => {
+		if (icon === false) return void 0;
+		if (isValidElement$1(icon)) return icon;
+		return /* @__PURE__ */ jsx("span", {
+			className: cx(alert_module_default.alertIcon, iconVariantMap[variant]),
+			children: /* @__PURE__ */ jsx(AlertIcon, { variant })
+		});
+	};
+	const renderedIcon = renderIcon();
+	if (type === "collapsible") return /* @__PURE__ */ jsxs(Accordion, {
+		variant,
+		onToggle: onToggle || void 0,
+		narrow: true,
+		className,
+		children: [
+			/* @__PURE__ */ jsx("template", {
+				slot: "title",
+				children: title
+			}),
+			/* @__PURE__ */ jsx("template", {
+				slot: "icon",
+				children: renderedIcon
+			}),
+			/* @__PURE__ */ jsxs("template", {
+				slot: "content",
+				children: [children, !!actions && /* @__PURE__ */ jsx("div", {
+					className: alert_module_default.alertActions,
+					children: actions
+				})]
+			})
+		]
+	});
+	if (type === "callToAction") return /* @__PURE__ */ jsxs("div", {
+		className: cx(alert_module_default.alert, className, variantMap[variant], { [alert_module_default.alertWithoutIcon]: !renderedIcon }),
+		role: "alert",
+		"data-testid": testId,
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: cx(alert_module_default.alertHeader, { [alert_module_default.alertHeaderWithoutChildren]: !children }),
+			children: [
+				renderedIcon,
+				title && /* @__PURE__ */ jsx(Typography, {
+					el: "h3",
+					variant: "body-strongest",
+					className: alert_module_default.alertTitle,
+					children: title
+				}),
+				!!actions && /* @__PURE__ */ jsx("div", {
+					className: alert_module_default.alertActions,
+					children: actions
+				})
+			]
+		}), !!children && /* @__PURE__ */ jsx("div", {
+			className: alert_module_default.alertExplanation,
+			children
+		})]
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: cx(alert_module_default.alert, className, variantMap[variant], { [alert_module_default.alertWithoutIcon]: !renderedIcon }),
+		role: "alert",
+		"data-testid": testId,
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: alert_module_default.alertHeader,
+				children: [
+					renderedIcon,
+					title && /* @__PURE__ */ jsx(Typography, {
+						el: "h3",
+						variant: "body-strongest",
+						className: alert_module_default.alertTitle,
+						children: title
+					}),
+					type === "dismissible" && /* @__PURE__ */ jsx(Button, {
+						variant: "tertiary",
+						icon: "cross",
+						onClick: closeAlert,
+						children: t(($) => $["close"])
+					})
+				]
+			}),
+			!!children && /* @__PURE__ */ jsx("div", {
+				className: alert_module_default.alertExplanation,
+				children
+			}),
+			!!actions && /* @__PURE__ */ jsx("div", {
+				className: alert_module_default.alertActions,
+				children: actions
+			})
+		]
+	});
+};
+var AlertIcon = ({ variant }) => {
+	switch (variant) {
+		case "success": return /* @__PURE__ */ jsx(Icon, { name: "checkmark" });
+		case "error": return /* @__PURE__ */ jsx(Icon, { name: "error" });
+		case "warning": return /* @__PURE__ */ jsx(Icon, { name: "warning" });
+		default: return /* @__PURE__ */ jsx(Icon, { name: "info-circle-filled" });
+	}
+};
+//#endregion
+//#region src/components/Shared/AllowedCountryGate/AllowedCountryGate.tsx
+/**
+* Blocks the user from onboarding if they are from a disallowed country.
+*/
+var AllowedCountryGate = ({ children }) => {
+	const allowedCountries = useAllowedCountries();
+	const { t, i18n } = useTranslation("common");
+	const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+	const { dataset: countries } = useDataset(datasetIdentifier.country);
+	addResourceBundles(i18n, [{
+		ns: "common",
+		importFn: (lang) => _rolldown_dynamic_import_helper_default(/* #__PURE__ */ Object.assign({
+			"../../../language/locales/bg-BG.json": () => import("./bg-BG-Cdrkwxmc.js"),
+			"../../../language/locales/cs-CZ.json": () => import("./cs-CZ-DpiH1UkS.js"),
+			"../../../language/locales/da-DK.json": () => import("./da-DK-B-BJLcqw.js"),
+			"../../../language/locales/de-DE.json": () => import("./de-DE-BxTGFyOs.js"),
+			"../../../language/locales/el-GR.json": () => import("./el-GR-IQwyd9ws.js"),
+			"../../../language/locales/en-US.instructions.json": () => import("./en-US.instructions-BVNIyLRs.js"),
+			"../../../language/locales/en-US.json": () => import("./en-US-U0d3NI20.js"),
+			"../../../language/locales/es-ES.json": () => import("./es-ES-Cg2IadcX.js"),
+			"../../../language/locales/es-LA.json": () => import("./es-LA-DvMpG4FP.js"),
+			"../../../language/locales/et-EE.json": () => import("./et-EE-eGeytyQh.js"),
+			"../../../language/locales/fi-FI.json": () => import("./fi-FI-C02wZfgW.js"),
+			"../../../language/locales/fr-FR.json": () => import("./fr-FR-CE7k9H5_.js"),
+			"../../../language/locales/hr-HR.json": () => import("./hr-HR-B12DcJ3l.js"),
+			"../../../language/locales/hu-HU.json": () => import("./hu-HU-cosbDuos.js"),
+			"../../../language/locales/it-IT.json": () => import("./it-IT-CiKoOxzk.js"),
+			"../../../language/locales/ja-JP.json": () => import("./ja-JP-D7PEVMmT.js"),
+			"../../../language/locales/lt-LT.json": () => import("./lt-LT-C2oxTakB.js"),
+			"../../../language/locales/lv-LV.json": () => import("./lv-LV-C_KVkpid.js"),
+			"../../../language/locales/nl-NL.json": () => import("./nl-NL-CwNBy0Ku.js"),
+			"../../../language/locales/no-NO.json": () => import("./no-NO-VqkeNhzB.js"),
+			"../../../language/locales/pl-PL.json": () => import("./pl-PL-Bp218jDD.js"),
+			"../../../language/locales/pt-BR.json": () => import("./pt-BR-CPbFPNwq.js"),
+			"../../../language/locales/pt-PT.json": () => import("./pt-PT-Bz39smeX.js"),
+			"../../../language/locales/ro-RO.json": () => import("./ro-RO-jNItoBZk.js"),
+			"../../../language/locales/sk-SK.json": () => import("./sk-SK-CsSqXqf_.js"),
+			"../../../language/locales/sl-SI.json": () => import("./sl-SI-PRqWis0E.js"),
+			"../../../language/locales/sv-SE.json": () => import("./sv-SE-Dv-rMOdB.js")
+		}), `../../../language/locales/${lang}.json`, 6)
+	}]);
+	if (!rootLegalEntity || !allowedCountries) return /* @__PURE__ */ jsx(Loader, {});
+	const country = getLegalEntityCountry(rootLegalEntity);
+	const isAllowed = allowedCountries.includes(country);
+	const countryName = countries.find(({ id }) => id === country)?.name ?? country;
+	if (!isAllowed) return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(AlertIcon, { variant: "error" }), /* @__PURE__ */ jsx(Header, {
+		title: t(($) => $["countryNotSupported"]),
+		description: t(($) => $["weDontSupportOnboardingInCountry"], { country: countryName })
+	})] });
+	return /* @__PURE__ */ jsx(Fragment$1, { children });
+};
+//#endregion
+//#region src/components/Shared/devex/DebugListener/DebugListener.tsx
+var DebugModal = lazy(async () => (await import("./DebugModal-YjFFNeOM.js")).DebugModal);
+/**
+* Adds a listener on the page to open the debug modal when the
+* debug modal key combination is pressed to open it
+*/
+var DebugListener = () => {
+	const [debugUiOpen, setDebugUiOpen] = useState$1(false);
+	const { isSettingEnabled } = useSettingsContext();
+	const debugUiAllowed = isSettingEnabled("allowDebugUi");
+	useEffect$1(() => {
+		if (!debugUiAllowed) return;
+		const handleKeyDown = ({ code, ctrlKey, altKey, shiftKey }) => {
+			if (ctrlKey && (altKey || shiftKey) && code === "Backslash") setDebugUiOpen(true);
+		};
+		document.addEventListener("keydown", handleKeyDown);
+		return () => document.removeEventListener("keydown", handleKeyDown);
+	}, [debugUiAllowed]);
+	return /* @__PURE__ */ jsx(Fragment$1, { children: debugUiAllowed && debugUiOpen ? /* @__PURE__ */ jsx(Suspense, {
+		fallback: /* @__PURE__ */ jsx("div", {}),
+		children: /* @__PURE__ */ jsx(DebugModal, { onExit: () => setDebugUiOpen(false) })
+	}) : null });
+};
+//#endregion
+//#region src/utils/bankUtils.ts
+function isTransferInstrument(account) {
+	return account.bankAccount !== void 0;
+}
+var isInstantVerifiedAccount = (account) => Boolean(isTransferInstrument(account) ? account.bankAccount.trustedSource : account.trustedSource);
+var getObscuredAccountNumber = ({ accountIdentifier, realLastFour }) => realLastFour ? `*******${realLastFour}` : accountIdentifier;
+//#endregion
+//#region src/utils/unincorporatedParnershipUtils.ts
+var isPartOfUnincorporatedPartnership = (legalEntity) => legalEntity?.entityAssociations?.some((ea) => ea.entityType === "unincorporatedPartnership" && ea.associatorId === legalEntity.id);
+var getOwnUnincorporatedPartnershipLegalEntityId = (legalEntity) => legalEntity?.entityAssociations?.find((ea) => ea.entityType === "unincorporatedPartnership" && ea.associatorId === legalEntity.id)?.legalEntityId;
+var getOwnUnincorporatedPartnershipLegalEntityIdAsArray = (legalEntity) => {
+	const legalEntityId = getOwnUnincorporatedPartnershipLegalEntityId(legalEntity);
+	return legalEntityId ? [legalEntityId] : [];
+};
+var getOwnUnincorporatedPartnershipProblems = (legalEntity, capabilityProblems) => {
+	const legalEntityId = getOwnUnincorporatedPartnershipLegalEntityId(legalEntity);
+	if (legalEntityId) return capabilityProblems?.LegalEntity?.[legalEntityId];
+};
+/**
+* Gathers all legal entity IDs relevant for calculating the task status of an unincorporated partnership.
+*.
+* These ids includes the root legal entity itself, the direct members of the partnership, and any owners
+* (e.g., UBOs through ownership) associated with those members.
+*
+* @param rootLegalEntity The root legal entity
+* @returns A list of legal entity IDs, including the root entity, its partnership members, and their owners.
+*/
+var getOwnMembersLegalEntityIds = (rootLegalEntity) => {
+	const unincorporatedPartnershipEntityId = getOwnUnincorporatedPartnershipLegalEntityId(rootLegalEntity);
+	if (!unincorporatedPartnershipEntityId) return [];
+	const memberAssociationsIds = getDirectEntityAssociations(rootLegalEntity, unincorporatedPartnershipEntityId).map((association) => association.legalEntityId).filter((id) => id !== void 0);
+	const ownerIds = memberAssociationsIds.flatMap((associationId) => getDirectEntityAssociations(rootLegalEntity, associationId)).map((association) => association.legalEntityId).filter((id) => id !== void 0);
+	return [
+		rootLegalEntity.id,
+		...memberAssociationsIds,
+		...ownerIds
+	];
+};
+//#endregion
+//#region src/components/Trust/forms/TrustRegistrationDetails/types.ts
+var nzSpecificTrustTypes = [
+	"discretionaryTrust",
+	"familyTrust",
+	"charitableTrust",
+	"businessTrust",
+	"otherTrust"
+];
+var auSpecificTrustTypes = [
+	"cashManagementTrust",
+	"corporateUnitTrust",
+	"deceasedEstate",
+	"discretionaryInvestmentTrust",
+	"discretionaryServicesManagementTrust",
+	"discretionaryTradingTrust",
+	"firstHomeSaverAccountsTrust",
+	"fixedTrust",
+	"fixedUnitTrust",
+	"hybridTrust",
+	"listedPublicUnitTrust",
+	"otherTrust",
+	"pooledSuperannuationTrust",
+	"publicTradingTrust",
+	"unlistedPublicUnitTrust"
+];
+var countryToTrustTypes = {
+	[CountryCodes.Australia]: auSpecificTrustTypes,
+	[CountryCodes.NewZealand]: nzSpecificTrustTypes
+};
+//#endregion
+//#region src/components/Trust/utils/trustMemberRequirements.ts
+var DEFAULT_TRUST_MEMBER_REQUIREMENTS = [
+	{
+		roleTypes: [TrustMemberTypes.SETTLOR],
+		min: 1,
+		max: 1,
+		label: TrustMemberGuidanceLabels.SETTLOR
+	},
+	{
+		roleTypes: [TrustMemberTypes.DEFINED_BENEFICIARY, TrustMemberTypes.UNDEFINED_BENEFICIARY],
+		min: 1,
+		max: Infinity,
+		label: TrustMemberGuidanceLabels.BENEFICIARY
+	},
+	{
+		roleTypes: [TrustMemberTypes.PROTECTOR],
+		min: 0,
+		max: Infinity,
+		label: TrustMemberGuidanceLabels.PROTECTOR
+	},
+	{
+		roleTypes: [TrustMemberTypes.TRUSTEE],
+		min: 1,
+		max: Infinity,
+		label: TrustMemberGuidanceLabels.TRUSTEE
+	}
+];
+//#endregion
+//#region src/components/Trust/utils/trustUtil.ts
+var isPartOfTrustFromLegalEntity = (legalEntity) => legalEntity?.entityAssociations?.some((ea) => ea.entityType === "trust" && ea.associatorId === legalEntity.id);
+var getOwnTrustMembersLegalEntityIds = (rootLegalEntity) => {
+	const trustLegalEntityId = getOwnTrustLegalEntityId(rootLegalEntity);
+	if (!trustLegalEntityId) return [];
+	const trustMemberIds = getDirectEntityAssociations(rootLegalEntity, trustLegalEntityId).map((association) => association.legalEntityId).filter((id) => id !== void 0);
+	return [...trustMemberIds, ...trustMemberIds.flatMap((trustMemberId) => getTrustMemberCompanyDecisionMakerIds(rootLegalEntity, trustMemberId))];
+};
+var getTrustMemberCompanyDecisionMakerIds = (rootLegalEntity, trustMemberCompanyId) => {
+	return getDecisionMakers(rootLegalEntity, trustMemberCompanyId).map((association) => association.legalEntityId).filter((id) => id !== void 0);
+};
+var getOwnTrustLegalEntityId = (legalEntity) => legalEntity?.entityAssociations?.find((ea) => ea.entityType === "trust" && ea.associatorId === legalEntity.id)?.legalEntityId;
+var getOwnTrustLegalEntityIdAsArray = (legalEntity) => {
+	const trustLegalEntityId = getOwnTrustLegalEntityId(legalEntity);
+	return trustLegalEntityId ? [trustLegalEntityId] : [];
+};
+var getOwnTrustProblems = (legalEntity, capabilityProblems) => {
+	const trustLegalEntityId = getOwnTrustLegalEntityId(legalEntity);
+	if (trustLegalEntityId) return capabilityProblems?.LegalEntity?.[trustLegalEntityId];
+};
+var hasRequiredTrustMemberCount = (trustMembers) => {
+	if (!trustMembers.length) return false;
+	return DEFAULT_TRUST_MEMBER_REQUIREMENTS.every(({ roleTypes, min }) => {
+		if (min === 0) return true;
+		return (trustMembers.filter(({ roles }) => roleTypes.some((label) => roles.includes(label)))?.length ?? 0) >= min;
+	});
+};
+var getCountrySpecificTrustTypeOptions = (country) => {
+	return countryToTrustTypes[country] || [];
+};
+//#endregion
+//#region src/types/verificationStatus.ts
+var VerificationStatuses = {
+	VALID: "valid",
+	PENDING: "pending",
+	INVALID: "invalid",
+	REJECTED: "rejected"
+};
+//#endregion
+//#region src/stores/globalStore/isEmptyEntity.ts
+/**
+* These fields will be present on an empty (just created) entity of the given type.
+* If any more fields than these are present, we consider the LE to not be "empty".
+*/
+var emptyFieldsForIndividual = [
+	"name.firstName",
+	"name.lastName",
+	"residentialAddress.country"
+];
+var emptyFieldsForOrganization = ["legalName", "registeredAddress.country"];
+var emptyFieldsForTrust = ["name", "registeredAddress.country"];
+var emptyFieldsForSoleProp = ["name", "registeredAddress.country"];
+var emptyFieldsForUnincorporatedPartnership = [
+	"name",
+	"countryOfGoverningLaw",
+	"registeredAddress.country"
+];
+var emptyFieldsByEntityType = {
+	["individual"]: emptyFieldsForIndividual,
+	["organization"]: emptyFieldsForOrganization,
+	["trust"]: emptyFieldsForTrust,
+	["soleProprietorship"]: emptyFieldsForSoleProp,
+	["unincorporatedPartnership"]: emptyFieldsForUnincorporatedPartnership
+};
+function isEmptyEntity(legalEntity) {
+	const type = legalEntity?.type;
+	if (!type) return true;
+	if (legalEntity.documentDetails?.length) return false;
+	const minimumFields = emptyFieldsByEntityType[type];
+	const typeSpecificSection = legalEntity[type];
+	if (!typeSpecificSection) return true;
+	const fieldsOnEntity = getNestedPropertyKeys(typeSpecificSection, false, false);
+	const sortedMinimumFields = [...minimumFields].sort();
+	return [...fieldsOnEntity].sort().every((value, index) => value === sortedMinimumFields[index]);
+}
+//#endregion
+//#region src/stores/globalStore/get-task-status.ts
+var calculateCustomerSupportTask = (capabilityProblems, rootLegalEntity) => {
+	const supportData = rootLegalEntity.individual?.support ?? rootLegalEntity.organization?.support;
+	const hasMissingDataErrors = capabilityProblems.LegalEntity?.[rootLegalEntity.id]?.missingData?.some((error) => CUSTOMER_SUPPORT_DATA_MISSING_ERROR_CODES.includes(error.code));
+	if (!supportData) return {
+		status: TaskStatuses.DETAILS_REQUIRED,
+		reason: "rootLegalEntityIsEmpty"
+	};
+	if (hasMissingDataErrors) return {
+		status: TaskStatuses.DETAILS_REQUIRED,
+		reason: "dataMissingError",
+		details: { missingData: capabilityProblems.LegalEntity?.[rootLegalEntity.id].missingData?.filter((error) => CUSTOMER_SUPPORT_DATA_MISSING_ERROR_CODES.includes(error.code)) }
+	};
+	const pendingCapabilities = getPendingCapabilities(rootLegalEntity);
+	if (pendingCapabilities.length > 0) return {
+		status: TaskStatuses.PROCESSING,
+		reason: "pendingCapabilities",
+		details: { pendingCapabilities }
+	};
+	if (hasAllCapabilitiesValid(rootLegalEntity)) return {
+		status: TaskStatuses.FINISHED,
+		reason: "allCapabilitiesValid"
+	};
+	return {
+		status: TaskStatuses.FINISHED,
+		reason: "noIssuesFound"
+	};
+};
+var getRegularTaskStatus = ({ taskType, capabilityProblems, rootLegalEntity, relevantEntityIds, ignorePendingCapabilities = false }) => {
+	const entityType = taskType === TaskTypes.PAYIN || taskType == TaskTypes.PAYOUT ? "BankAccount" : "LegalEntity";
+	if (relevantEntityIds.length === 0) return {
+		status: TaskStatuses.EMPTY,
+		reason: "newEntityAlwaysEmpty"
+	};
+	if (relevantEntityIds.includes(rootLegalEntity.id) && isEmptyEntity(rootLegalEntity)) return {
+		status: TaskStatuses.EMPTY,
+		reason: "rootLegalEntityIsEmpty"
+	};
+	const importantProblems = findImportantProblems(entityType, capabilityProblems, relevantEntityIds, taskType);
+	if (importantProblems.length > 0) return importantProblems[0].statusWithReason;
+	const pendingCapabilities = getPendingCapabilities(rootLegalEntity);
+	if (!ignorePendingCapabilities && pendingCapabilities.length > 0) return {
+		status: TaskStatuses.PROCESSING,
+		reason: "pendingCapabilities",
+		details: { pendingCapabilities }
+	};
+	if (relevantEntityIds.includes(rootLegalEntity.id)) {
+		if (hasAllCapabilitiesValid(rootLegalEntity)) return {
+			status: TaskStatuses.FINISHED,
+			reason: "allCapabilitiesValid"
+		};
+	}
+	return {
+		status: TaskStatuses.FINISHED,
+		reason: "noIssuesFound"
+	};
+};
+var getDecisionMakerOverviewStatus = ({ capabilityProblems, rootLegalEntity, relevantEntityIds }) => {
+	if (relevantEntityIds.length === 0) return {
+		status: TaskStatuses.EMPTY,
+		reason: "newEntityAlwaysEmpty"
+	};
+	if (relevantEntityIds.includes(rootLegalEntity.id) && isEmptyEntity(rootLegalEntity)) return {
+		status: TaskStatuses.EMPTY,
+		reason: "rootLegalEntityIsEmpty"
+	};
+	const importantProblems = findImportantProblems("LegalEntity", capabilityProblems, relevantEntityIds, TaskTypes.DECISION_MAKER_OVERVIEW);
+	if (importantProblems.length > 0) return importantProblems[0].statusWithReason;
+	const pendingCapabilities = getPendingCapabilities(rootLegalEntity).filter((capability) => !/.*TransferInstrument/gim.test(capability));
+	if (pendingCapabilities.length > 0) return {
+		status: TaskStatuses.PROCESSING,
+		reason: "pendingCapabilities",
+		details: { pendingCapabilities }
+	};
+	if (relevantEntityIds.includes(rootLegalEntity.id) && hasAllNonTransferInstrumentCapabilitiesValid(rootLegalEntity)) return {
+		status: TaskStatuses.FINISHED,
+		reason: "allCapabilitiesValid"
+	};
+	return {
+		status: TaskStatuses.FINISHED,
+		reason: "noIssuesFound"
+	};
+};
+var IMPORTANT_STATUSES = [
+	TaskStatuses.DETAILS_REQUIRED,
+	TaskStatuses.DOWNLOAD,
+	TaskStatuses.ERROR,
+	TaskStatuses.PROCESSING
+];
+function findImportantProblems(type, capabilityProblems, entityIds, taskType) {
+	if (!capabilityProblems?.[type] || !entityIds.length) return [];
+	const problems = cloneObject(capabilityProblems);
+	if (taskType !== TaskTypes.CUSTOMER_SUPPORT) entityIds.forEach((id) => {
+		if (problems.LegalEntity?.[id]?.missingData) problems.LegalEntity[id].missingData = problems.LegalEntity?.[id]?.missingData?.filter((missingDataErrors) => !CUSTOMER_SUPPORT_DATA_MISSING_ERROR_CODES.includes(missingDataErrors.code));
+	});
+	return Object.entries(problems[type] ?? {}).filter(([key]) => entityIds.includes(key)).map(([, value]) => value).filter((problems) => problems.statusWithReason !== void 0 && IMPORTANT_STATUSES.includes(problems.statusWithReason.status)).sort((prev, curr) => TASK_STATUS_PRIORITY[curr.statusWithReason.status] - TASK_STATUS_PRIORITY[prev.statusWithReason.status]);
+}
+var getPendingCapabilities = (legalEntityResponse) => entriesOf(legalEntityResponse.capabilities ?? {}).filter(([, capability]) => capability?.verificationStatus === "pending").reduce((acc, [name]) => [...acc, name], []);
+var hasAllCapabilitiesResolved = (legalEntityResponse) => Object.values(legalEntityResponse?.capabilities ?? {}).every((capability) => capability.verificationStatus !== VerificationStatuses.PENDING);
+var hasRejectedCapabilities = (legalEntityResponse) => Object.values(legalEntityResponse?.capabilities ?? {}).some((capability) => capability.verificationStatus === VerificationStatuses.REJECTED);
+var hasAllCapabilitiesValid = (legalEntityResponse) => Object.values(legalEntityResponse?.capabilities ?? {}).every((capability) => capability.verificationStatus === VerificationStatuses.VALID);
+var hasAllNonTransferInstrumentCapabilitiesValid = (legalEntityResponse) => {
+	for (const [name, capability] of Object.entries(legalEntityResponse?.capabilities ?? {})) if (!/.*TransferInstrument/gim.test(name) && capability.verificationStatus !== VerificationStatuses.VALID) return false;
+	return true;
+};
+//#endregion
+//#region src/stores/globalStore/calculateTaskStatus.ts
+var calculateTaskStatus = ({ taskIdentifier, capabilityProblems, rootLegalEntity, accountHolder, legalRepresentative, trustMembers, transferInstruments }) => {
+	const { taskType, id } = splitTaskIdentifier(taskIdentifier);
+	let relevantEntityIds = [];
+	let ignorePendingCapabilities = false;
+	switch (taskType) {
+		case TaskTypes.INDIVIDUAL:
+		case TaskTypes.BUSINESS_DETAILS:
+			relevantEntityIds = [rootLegalEntity.id];
+			break;
+		case TaskTypes.LEGAL_REPRESENTATIVE_DETAILS:
+			if (!legalRepresentative) return {
+				status: TaskStatuses.DETAILS_REQUIRED,
+				reason: "legalRepresentativeNeeded"
+			};
+			relevantEntityIds = [legalRepresentative.legalEntityId];
+			break;
+		case TaskTypes.SOLE_PROPRIETOR_COMPANY:
+			relevantEntityIds = getOwnSoleProprietorshipIdArray(rootLegalEntity);
+			break;
+		case TaskTypes.DECISION_MAKER_OVERVIEW:
+			if (!hasMinRequiredDecisionMakerCount(rootLegalEntity)) return {
+				status: TaskStatuses.DETAILS_REQUIRED,
+				reason: "missingRequiredDecisionMakers"
+			};
+			relevantEntityIds = getOwnDecisionMakersLegalEntityIds(rootLegalEntity);
+			return getDecisionMakerOverviewStatus({
+				capabilityProblems,
+				rootLegalEntity,
+				relevantEntityIds
+			});
+		case TaskTypes.DECISION_MAKER:
+			if (!id) throw new Error("Decision maker task identifier should specify an ID");
+			relevantEntityIds = [id];
+			break;
+		case TaskTypes.TRUST: {
+			const trustIds = getOwnTrustLegalEntityIdAsArray(rootLegalEntity);
+			if (accountHolder === "aTrust" && trustIds.length === 0) return {
+				status: TaskStatuses.EMPTY,
+				reason: "newEntityAlwaysEmpty"
+			};
+			relevantEntityIds = trustIds;
+			break;
+		}
+		case TaskTypes.TRUST_MEMBER_OVERVIEW:
+			if (!hasRequiredTrustMemberCount(trustMembers)) return {
+				status: TaskStatuses.DETAILS_REQUIRED,
+				reason: "missingRequiredTrustMembers"
+			};
+			relevantEntityIds = getOwnTrustMembersLegalEntityIds(rootLegalEntity);
+			break;
+		case TaskTypes.TRUST_MEMBER:
+		case TaskTypes.TRUST_MEMBER_INDIVIDUAL:
+		case TaskTypes.TRUST_MEMBER_COMPANY:
+		case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY:
+		case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL:
+			if (!id) throw new Error("Trust member task identifier should specify an ID");
+			if (id === "undefinedBeneficiary") {
+				relevantEntityIds = [];
+				break;
+			}
+			relevantEntityIds = [id, ...getDirectEntityAssociations(rootLegalEntity, id).map((association) => association.legalEntityId)];
+			break;
+		case TaskTypes.PAYIN:
+		case TaskTypes.PAYOUT: {
+			if (!id) return {
+				status: TaskStatuses.DETAILS_REQUIRED,
+				reason: "bankAccountNeeded"
+			};
+			const matchingAccount = transferInstruments.find((ti) => ti.id === id);
+			if (!matchingAccount) throw new Error(`Could not find transfer instrument with id ${id}`);
+			ignorePendingCapabilities = isInstantVerifiedAccount(matchingAccount);
+			relevantEntityIds = [id];
+			break;
+		}
+		case TaskTypes.CUSTOMER_SUPPORT: return calculateCustomerSupportTask(capabilityProblems, rootLegalEntity);
+		case TaskTypes.UNINCORPORATED_PARTNERSHIP: {
+			const partnerIds = getOwnUnincorporatedPartnershipLegalEntityIdAsArray(rootLegalEntity);
+			if (accountHolder === "anUnincorporatedPartnership" && partnerIds.length === 0) return {
+				status: TaskStatuses.EMPTY,
+				reason: "newEntityAlwaysEmpty"
+			};
+			relevantEntityIds = partnerIds;
+			break;
+		}
+		case TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW:
+			relevantEntityIds = getOwnMembersLegalEntityIds(rootLegalEntity);
+			if (relevantEntityIds?.length === 1) return {
+				status: TaskStatuses.EMPTY,
+				reason: "newEntityAlwaysEmpty"
+			};
+	}
+	return getRegularTaskStatus({
+		taskType,
+		rootLegalEntity,
+		capabilityProblems,
+		relevantEntityIds,
+		ignorePendingCapabilities
+	});
+};
+/**
+* Splits a {@link TaskIdentifier} (e.g. `PAYOUT_ACCOUNT-abc-123`) into the task type and id
+*/
+var splitTaskIdentifier = (taskIdentifier) => {
+	const firstDashIndex = taskIdentifier.indexOf("-");
+	if (firstDashIndex === -1) return { taskType: taskIdentifier };
+	return {
+		taskType: taskIdentifier.slice(0, firstDashIndex),
+		id: taskIdentifier.slice(firstDashIndex + 1)
+	};
+};
+//#endregion
+//#region src/utils/birthDateUtils.tsx
+/**
+* Calculates the age of a person based on their birthdate.
+*
+* The birthdate is compared as calendar parts rather than through `new Date(birthdate)`, because a
+* 'YYYY-MM-DD' string is parsed as UTC midnight. Reading such a date back with local getters
+* shifts it to the previous day for anyone behind UTC, which would age the person by a year around
+* month boundaries.
+* @param birthdate - The birthdate of the person in 'YYYY-MM-DD' format.
+* @returns The age of the person in years.
+*/
+var getAgeToday = (birthdate) => {
+	const [birthYear, birthMonth, birthDay] = birthdate.slice(0, 10).split("-").map(Number);
+	const today = /* @__PURE__ */ new Date();
+	const yearDifference = today.getFullYear() - birthYear;
+	const todayMonth = today.getMonth() + 1;
+	const todayDay = today.getDate();
+	return todayMonth > birthMonth || todayMonth === birthMonth && todayDay >= birthDay ? yearDifference : yearDifference - 1;
+};
+/**
+* Returns the age range for a legal representative based on the country.
+* @param country - The country code.
+* @returns An object with min and max age, or undefined if not applicable.
+*/
+var getAgeRangeForLegalRepresentative = (country) => {
+	if (!country || isHkSgCountry(country)) return;
+	if (isEuCountry(country)) return {
+		min: 16,
+		max: 18
+	};
+	return {
+		min: 13,
+		max: 18
+	};
+};
+/**
+* Checks if a person is under the required age for KYC based on their birthdate and country.
+* @param birthDate - The birthdate of the person.
+* @param country - The country of residence.
+* @returns True if the person is under the required age, false otherwise.
+*/
+var isPersonUnderAge = (birthDate, country) => {
+	if (!birthDate || !country) return false;
+	const ageRange = getAgeRangeForLegalRepresentative(country);
+	if (!ageRange) return false;
+	return isAgeWithinRange(getAgeToday(birthDate), ageRange);
+};
+/**
+* Determines if a legal representative is needed based on age, country, and task type.
+* @param birthDate - The birthdate of the person.
+* @param country - The country of residence.
+* @param taskType - The type of task being performed.
+* @returns True if a legal representative is needed, false otherwise.
+*/
+var isLegalRepresentativeNeeded = (birthDate, country, taskType) => {
+	if (taskType === TaskTypes.LEGAL_REPRESENTATIVE_DETAILS) return false;
+	return isPersonUnderAge(birthDate, country);
+};
+/**
+* Checks if an age is within a given range.
+* @param age - The age to check.
+* @param ageRange - An object with min and max age.
+* @returns True if the age is within the range, false otherwise.
+*/
+var isAgeWithinRange = (age, ageRange) => ageRange.min <= age && age < ageRange.max;
+/**
+* Checks if a legal entity requires a legal representative based on the individual's age.
+* @param legalEntity - The existing legal entity.
+* @returns True if a legal representative is required, false otherwise.
+*/
+var doesLegalEntityRequiresLegalRepresentative = (legalEntity) => {
+	if (!legalEntity || !legalEntity?.individual) return false;
+	const birthDate = legalEntity?.individual?.birthData?.dateOfBirth;
+	return isPersonUnderAge(birthDate, getLegalEntityCountry(legalEntity));
+};
+//#endregion
+//#region src/stores/globalStore/determineTaskIdentifiers.ts
+var determineTaskIdentifiers = ({ taskTypes: receivedTaskTypes, rootLegalEntity, accountHolder, capabilityProblems, trustMembers, transferInstruments, unincorporatedPartnershipMembers, legalRepresentative }) => {
+	if (!rootLegalEntity || !capabilityProblems) return [];
+	const taskTypes = receivedTaskTypes.map(mapReceivedTaskType);
+	const tasks = [...taskTypes];
+	if (taskTypes.includes(TaskTypes.PAYIN)) transferInstruments.forEach((account) => tasks.push(`PAYIN-${account.id}`));
+	if (taskTypes.includes(TaskTypes.PAYOUT)) transferInstruments.forEach((account) => tasks.push(`PAYOUT-${account.id}`));
+	if (taskTypes.includes(TaskTypes.DECISION_MAKER_OVERVIEW)) getOwnDecisionMakersLegalEntityIds(rootLegalEntity).forEach((id) => tasks.push(`DECISION_MAKER-${id}`));
+	if (legalRepresentative || doesLegalEntityRequiresLegalRepresentative(rootLegalEntity)) tasks.push(TaskTypes.LEGAL_REPRESENTATIVE_DETAILS);
+	if (accountHolder === "mySoleProprietorName") tasks.push(TaskTypes.SOLE_PROPRIETOR_COMPANY);
+	if (accountHolder === "aTrust") {
+		tasks.push(TaskTypes.TRUST);
+		tasks.push(TaskTypes.TRUST_MEMBER_OVERVIEW);
+		trustMembers.forEach((member) => {
+			if (member.trustMemberType === "undefinedBeneficiary") {
+				tasks.push(`TRUST_MEMBER-undefinedBeneficiary`);
+				return;
+			}
+			switch (member.legalEntityType) {
+				case "individual":
+					tasks.push(`TRUST_MEMBER_INDIVIDUAL-${String(member.legalEntityId)}`);
+					return;
+				case "organization":
+					tasks.push(`TRUST_MEMBER_COMPANY-${String(member.legalEntityId)}`);
+					return;
+			}
+		});
+	}
+	if (accountHolder === "anUnincorporatedPartnership") {
+		tasks.push(TaskTypes.UNINCORPORATED_PARTNERSHIP);
+		tasks.push(TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW);
+		unincorporatedPartnershipMembers?.forEach((member) => {
+			switch (member.legalEntityType) {
+				case "individual":
+					tasks.push(`UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL-${String(member.legalEntityId)}`);
+					return;
+				case "organization":
+					tasks.push(`UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY-${String(member.legalEntityId)}`);
+					return;
+			}
+		});
+	}
+	return tasks;
+};
+var mapReceivedTaskType = (taskType) => {
+	switch (taskType) {
+		case TaskTypes.DECISION_MAKER: return TaskTypes.DECISION_MAKER_OVERVIEW;
+		case TaskTypes.TRUST_MEMBER: return TaskTypes.TRUST_MEMBER_OVERVIEW;
+		default: return taskType;
+	}
+};
+//#endregion
+//#region src/stores/globalStore/globalStore.tsx
+var logger = createLogger();
+/**
+* Initializes the store. Should only be called from {@link StoreProvider}.
+*/
+var createGlobalStore = ({ rootLegalEntity: rootLegalEntityIn }) => {
+	const rootLegalEntity = signal(rootLegalEntityIn);
+	const taskTypes = signal([]);
+	const accountHolder = signal();
+	const trustMembers = signal([]);
+	const unincorporatedPartnershipMembers = signal([]);
+	const rootLegalEntityCountry = computed(() => getLegalEntityCountry(rootLegalEntity.value));
+	const capabilities = computed(() => getCapabilities(rootLegalEntity.value));
+	const capabilityProblems = computed(() => getCapabilityProblems(rootLegalEntity.value, rootLegalEntityCountry.value));
+	const legalRepresentative = computed(() => getLegalRepresentative(rootLegalEntity.value));
+	const transferInstruments = computed(() => rootLegalEntity.value.transferInstruments ?? []);
+	const tasks = computed(() => determineTaskIdentifiers({
+		taskTypes: taskTypes.value,
+		rootLegalEntity: rootLegalEntity.value,
+		accountHolder: accountHolder.value,
+		capabilities: capabilities.value,
+		capabilityProblems: capabilityProblems.value,
+		legalRepresentative: legalRepresentative.value,
+		transferInstruments: transferInstruments.value,
+		trustMembers: trustMembers.value,
+		unincorporatedPartnershipMembers: unincorporatedPartnershipMembers.value
+	}));
+	return {
+		rootLegalEntity,
+		taskTypes,
+		accountHolder,
+		trustMembers,
+		unincorporatedPartnershipMembers,
+		rootLegalEntityCountry,
+		capabilities,
+		capabilityProblems,
+		legalRepresentative,
+		transferInstruments,
+		tasks,
+		taskStatuses: computed(() => tasks.value.reduce((acc, taskIdentifier) => {
+			try {
+				acc[taskIdentifier] = calculateTaskStatus({
+					taskIdentifier,
+					accountHolder: accountHolder.value,
+					capabilityProblems: capabilityProblems.value,
+					rootLegalEntity: rootLegalEntity.value,
+					legalRepresentative: legalRepresentative.value,
+					trustMembers: trustMembers.value,
+					transferInstruments: transferInstruments.value
+				});
+			} catch (err) {
+				logger.error(`Could not calculate task status for ${taskIdentifier}. `, err);
+			}
+			return acc;
+		}, {})),
+		setRootLegalEntity: (newVal) => rootLegalEntity.value = newVal,
+		setTaskTypes: (newVal) => taskTypes.value = newVal,
+		setAccountHolder: (newVal) => accountHolder.value = newVal,
+		setTrustMembers: (newVal) => trustMembers.value = newVal,
+		setUnincorporatedPartnershipMembers: (newVal) => unincorporatedPartnershipMembers.value = newVal
+	};
+};
+var StoreContext = createContext$1(null);
+function useGlobalStore() {
+	const store = useContext$1(StoreContext);
+	if (!store) throw new Error("`useGlobalStore()` must be called from within a `StoreContext.Provider`");
+	return store;
+}
+var useGetTaskStatus = () => {
+	const taskStatusesSignal = useGlobalStore().taskStatuses;
+	return useCallback$1((taskType, id) => {
+		const taskIdentifier = id ? `${taskType}-${id}` : taskType;
+		const status = taskStatusesSignal.value[taskIdentifier]?.status;
+		if (status === void 0) {
+			logger.warn(`No status for task '${taskIdentifier}', returning UNKNOWN`);
+			return TaskStatuses.UNKNOWN;
+		}
+		return status;
+	}, [taskStatusesSignal]);
+};
+//#endregion
+//#region src/stores/globalStore/StoreProvider.tsx
+/**
+* `<StoreProvider>` postpones render of the remaining tree until root legal entity data has been
+* retrieved and the {@link GlobalStore} has been initialized.
+*
+* This provider can (and should) also be used from tests and stories.
+* If you prefer to mock global state, see {@link MockedStoreProvider}.
+*/
+var StoreProvider = ({ children }) => {
+	const [store, setStore] = useState$1();
+	const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+	useEffect$1(() => {
+		if (!rootLegalEntity || store) return;
+		setStore(createGlobalStore({ rootLegalEntity }));
+	}, [rootLegalEntity, store]);
+	if (!store) return /* @__PURE__ */ jsx(Skeleton, {});
+	return /* @__PURE__ */ jsx(StoreContext.Provider, {
+		value: store,
+		children
+	});
+};
+//#endregion
+//#region src/core/EmbedShell/EmbedShell.tsx
+/** conditional polyfill for container queries */
+if (CSS.supports("container", "foo / inline-size") === false) import("container-query-polyfill");
+var LanguageSwitcher = ({ locale }) => {
+	const { i18n } = useTranslation();
+	const { isSettingEnabled } = useSettingsContext();
+	useEffect$1(() => {
+		if (locale === "ja-JP" && !isSettingEnabled("enableJapanLocalization")) return;
+		i18n.changeLanguage(locale);
+	}, [
+		locale,
+		i18n,
+		isSettingEnabled
+	]);
+	return null;
+};
+/**
+* Bootstraps any component for external usage by consumers
+* Import it in your component and wrap it inside the EmbedShell, eg:
+*
+* @example
+* ```jsx
+* <EmbedShell {...consumerProps}>
+*    <MyReadyToGoForm {...consumerProps} />
+* </EmbedShell>
+* ```
+*
+* @param props given by consumer, be it HO, merchant using library or a TaskList component
+* @returns
+*/
+var EmbedShell = ({ children, rootLegalEntityId, settings, features, refreshExperiments, baseUrl, getSdkToken, componentName, locale, themeMode = "light" }) => {
+	const [isLoading, setIsLoading] = useState$1(true);
+	const [hasError, setHasError] = useState$1(false);
+	setSdkTokenHandler(getSdkToken);
+	useEffect$1(() => {
+		refreshSession().then((hasRefreshed) => {
+			if (!hasRefreshed) setHasError(true);
+			setIsLoading(false);
+		});
+	}, []);
+	if (hasError) return /* @__PURE__ */ jsxs("div", { children: ["Something went wrong, please", /* @__PURE__ */ jsx(Button, {
+		onClick: () => location.reload(),
+		children: "refresh the page."
+	})] });
+	if (isLoading) return /* @__PURE__ */ jsx(Loader, {});
+	return /* @__PURE__ */ jsx(SettingsProvider, {
+		settings,
+		children: /* @__PURE__ */ jsx(QueryClientProvider$1, { children: /* @__PURE__ */ jsx(ApiProvider, {
+			rootLegalEntityId,
+			baseUrl,
+			children: /* @__PURE__ */ jsxs(ToggleContextProvider, {
+				features,
+				refreshExperiments,
+				children: [/* @__PURE__ */ jsx(LanguageSwitcher, { locale }), /* @__PURE__ */ jsxs(StoreProvider, { children: [/* @__PURE__ */ jsx("span", {
+					id: "sdk-version",
+					hidden: true,
+					children: "4.26.0-beta.0"
+				}), /* @__PURE__ */ jsx(AnalyticsProvider, {
+					componentName,
+					locale,
+					rootLegalEntityId,
+					children: /* @__PURE__ */ jsx(Suspense, {
+						fallback: /* @__PURE__ */ jsx(Loader, {}),
+						children: /* @__PURE__ */ jsxs(AllowedCountryGate, { children: [/* @__PURE__ */ jsx(DebugListener, {}), /* @__PURE__ */ jsx("div", {
+							className: `adyen-kyc-ui-element-container-wrapper ${themeMode}`,
+							children: /* @__PURE__ */ jsx("div", {
+								className: "adyen-kyc-ui-element-container",
+								children: /* @__PURE__ */ jsx(ToastContextProvider, { children: /* @__PURE__ */ jsx(StateProvider, { children }) })
+							})
+						})] })
+					})
+				})] })]
+			})
+		}) })
+	});
+};
+//#endregion
+//#region src/core/environment/normalizeEnvironment.ts
+var normalizeEnvironment = (env) => env.endsWith("/") ? env : `${env}/`;
+//#endregion
+//#region src/core/environment/resolveEnvironment.ts
+var environmentMap = Object.freeze({
+	live: "https://onboardingcomponents-live.adyen.com/",
+	test: "https://test.adyen.com/"
+});
+var resolveEnvironment = (environment) => environmentMap[environment] ?? normalizeEnvironment(environment);
+//#endregion
+export { hasEmptyFields as $, _rolldown_dynamic_import_helper_default as A, HAS_PROTOCOL_REGEX as B, useDataset as C, useCapabilities as D, useAllowedCountries as E, useToggles as F, OTHER_ENTITIES_VALID_CHAR_REGEX as G, LATIN_SPACE_MARK_PUNCTUATION_NUMBERS_REGEX as H, ToastContextProvider as I, chomeAndBanchiValidator as J, SPECIAL_CHARS as K, ToastContext as L, FeatureNames as M, ToggleContext as N, useSetting as O, listToRecord as P, getMaxLengthByFieldAndCountry as Q, ADDRESS_VALID_CHAR_REGEX as R, AlertIcon as S, datasetUtilities as T, NO_ALPHABET_REGEX as U, INDIVIDUAL_VALID_CHAR_REGEX as V, NO_ALPHABET_UNICODE_REGEX as W, extractFieldName as X, concatenateFieldNames as Y, getFormattingRegEx as Z, getOwnUnincorporatedPartnershipProblems as _, doesLegalEntityRequiresLegalRepresentative as a, isISIN as at, isInstantVerifiedAccount as b, isLegalRepresentativeNeeded as c, isValidMinLength as ct, hasRejectedCapabilities as d, standardKatakanaValidator as dt, hasMaximumTwoRepeatedCharacters as et, isEmptyEntity as f, StateContext as ft, DEFAULT_TRUST_MEMBER_REQUIREMENTS as g, stylesheets as gt, isPartOfTrustFromLegalEntity as h, useLocalStorage as ht, useGlobalStore as i, isEmpty as it, ExperimentNames as j, Header as k, splitTaskIdentifier as l, matchesRegex as lt, getOwnTrustProblems as m, useAccountHolder as mt, EmbedShell as n, hasText as nt, getAgeRangeForLegalRepresentative as o, isInvalidName as ot, getCountrySpecificTrustTypeOptions as p, AnalyticsContext as pt, URL_REGEX as q, useGetTaskStatus as r, isAccountIdentifierObscured as rt, getAgeToday as s, isUndefinedOrNull as st, resolveEnvironment as t, hasRepeatedCharacters as tt, hasAllCapabilitiesResolved as u, standardKanjiValidator as ut, isPartOfUnincorporatedPartnership as v, datasetIdentifier as w, Alert as x, getObscuredAccountNumber as y, EMOJI_REGEX as z };