@adyen/kyc-components 4.23.0 → 4.24.0-beta.0

package/dist/form-rules-zzbZ2bV6.js

@@ -1,1089 +0,0 @@
-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] = "88dc39f0-a09c-479d-bd0e-c982c332e7b3", e._sentryDebugIdIdentifier = "sentry-dbid-88dc39f0-a09c-479d-bd0e-c982c332e7b3");
-} catch (e) {}
-import { r as useTranslation } from "./translation-BOm4lmPx.js";
-import { nt as isEmpty } from "./resolveEnvironment-BYEL10Nc.js";
-import { t as createLogger } from "./logger-Z8AeTE4x.js";
-import { t as Icon } from "./Icon-C3S5_kkS.js";
-import { t as Typography } from "./Typography-CAc_f5Iq.js";
-import { s as keysOf, t as cloneObject } from "./genUtils-Ce61IJs8.js";
-import { t as StackLayout } from "./StackLayout-IUdNMDgW.js";
-import { E as dataMissingRemediationsToFieldsMap, h as businessDetailsApiKeyMapping, r as remediationHasFileUploadField, s as individualApiKeyMapping } from "./processCapabilities-DRD0Aq2i.js";
-import { r as KEYBOARD_KEYS } from "./Modal-BsivDPTd.js";
-import { i as formDebugInfo, n as useForwardedRef, r as InputBase, t as InputText } from "./InputText-CTpVF0Mu.js";
-import { r as Field } from "./Select-ByVcS_J2.js";
-import { forwardRef } from "preact/compat";
-import { useCallback as useCallback$1, useEffect as useEffect$1, useLayoutEffect, useMemo as useMemo$1, useRef as useRef$1, useState as useState$1 } from "preact/hooks";
-import { Fragment as Fragment$1, jsx, jsxs } from "preact/jsx-runtime";
-//#region src/core/models/api/trusted-fields-provider.ts
-var TrustedFieldsProviders = {
-	SINGPASS: "singpass",
-	KOMPANY: "kompany"
-};
-var LandingLayout_module_default = {
-	"landing-layout-image": "_landing-layout-image_1nous_1",
-	landingLayoutImage: "_landing-layout-image_1nous_1",
-	"landing-layout-help-action": "_landing-layout-help-action_1nous_11",
-	landingLayoutHelpAction: "_landing-layout-help-action_1nous_11",
-	"landing-layout-actions": "_landing-layout-actions_1nous_16",
-	landingLayoutActions: "_landing-layout-actions_1nous_16",
-	"landing-layout-errors": "_landing-layout-errors_1nous_23",
-	landingLayoutErrors: "_landing-layout-errors_1nous_23",
-	"landing-layout-disclaimer": "_landing-layout-disclaimer_1nous_31",
-	landingLayoutDisclaimer: "_landing-layout-disclaimer_1nous_31",
-	"landing-layout-center": "_landing-layout-center_1nous_36",
-	landingLayoutCenter: "_landing-layout-center_1nous_36"
-};
-//#endregion
-//#region src/components/ui/layout/LandingLayout/LandingLayout.tsx
-var LandingLayout = ({ actions, content, description, error, disclaimer, helpAction, media, title }) => {
-	return /* @__PURE__ */ jsxs(StackLayout, {
-		gap: "large",
-		align: "center",
-		children: [
-			media && /* @__PURE__ */ jsx("div", {
-				role: "region",
-				className: LandingLayout_module_default.landingLayoutImage,
-				children: media
-			}),
-			error && /* @__PURE__ */ jsx("div", {
-				className: LandingLayout_module_default.landingLayoutErrors,
-				children: error
-			}),
-			/* @__PURE__ */ jsxs(StackLayout, {
-				gap: "small",
-				children: [
-					/* @__PURE__ */ jsx(Typography, {
-						el: "h2",
-						className: LandingLayout_module_default.landingLayoutCenter,
-						variant: "title-l",
-						children: title
-					}),
-					description && /* @__PURE__ */ jsx(Typography, {
-						className: LandingLayout_module_default.landingLayoutCenter,
-						variant: "body",
-						color: "primary",
-						children: description
-					}),
-					/* @__PURE__ */ jsx("div", {
-						className: LandingLayout_module_default.landingLayoutHelpAction,
-						children: helpAction
-					})
-				]
-			}),
-			content,
-			/* @__PURE__ */ jsx("div", {
-				className: LandingLayout_module_default.landingLayoutActions,
-				children: /* @__PURE__ */ jsxs(StackLayout, {
-					gap: "small",
-					children: [actions, disclaimer && /* @__PURE__ */ jsx(Typography, {
-						variant: "caption",
-						color: "tertiary",
-						className: LandingLayout_module_default.landingLayoutDisclaimer,
-						children: disclaimer
-					})]
-				})
-			})
-		]
-	});
-};
-//#endregion
-//#region src/utils/addLinkedFields.ts
-var linkedFieldsMap = { "additionalInformation.vatNumber": ["additionalInformation.exemptedFromVat", "additionalInformation.vatAbsenceReason"] };
-/**
-* This function is used to process fields linked to other fields that have custom rules that can return either REQUIRED or OPTIONAL
-* depending on the value of their links. An example of this is the Vat number, this will be REQUIRED when exemption is false but OPTIONAL when exemption is true.
-* This needs to be done due to functions like isFieldRequiredToRemediateDataMissingError, which do not take into account the custom rules and instead mark
-* these fields as required regardless of the rule.
-*
-* @param field - Field being processed
-* @param formId - Form this field is associated to
-* @param customRules - The rules associated to the form flow
-* @param scenarioConfiguration - The static configuration returned from the scenario, i.e. L1, L, etc
-* @param dataMissingErrors - Missing data problems on the LE response
-* @param formFieldsWithExistingData - The current fields that have existing data within the LE response
-*/
-function calculateLinkedRequiredFields({ field, formId, customRules, scenarioConfiguration, dataMissingErrors, formFieldsWithExistingData }) {
-	const tldsField = makeTLDSFieldName(formId, field);
-	if (Boolean(linkedFieldsMap[tldsField])) {
-		const linkedFields = linkedFieldsMap[tldsField];
-		const fieldSettings = scenarioConfiguration?.[field];
-		const isFieldRequiredBySettings = fieldSettings && isFieldRequired(fieldSettings, customRules);
-		const isFieldPopulated = formFieldsWithExistingData?.includes(field);
-		const isFieldNeededToRemediateDataMissingError = isFieldRequiredToRemediateDataMissingError(formId, field, dataMissingErrors);
-		const areLinkedFieldsPopulated = linkedFields?.some((linkedField) => {
-			const linkedFieldKey = linkedField.split(".")[1];
-			return formFieldsWithExistingData?.includes(linkedFieldKey);
-		});
-		if (!(isFieldRequiredBySettings || isFieldPopulated || isFieldNeededToRemediateDataMissingError || areLinkedFieldsPopulated)) return {
-			isRequiredFromLinkedField: false,
-			isOptionalFromLinkedField: false
-		};
-		switch (field) {
-			case "vatNumber": {
-				const processedRule = customRules["countryUsesVat"]?.();
-				return {
-					isRequiredFromLinkedField: processedRule === "REQUIRED",
-					isOptionalFromLinkedField: processedRule === "OPTIONAL"
-				};
-			}
-			default: break;
-		}
-	}
-	const rootLinkedField = Object.entries(linkedFieldsMap).find(([, linkedFields]) => linkedFields?.includes(tldsField))?.[0];
-	if (!rootLinkedField) return {
-		isRequiredFromLinkedField: false,
-		isOptionalFromLinkedField: false
-	};
-	const rootFieldKey = rootLinkedField.split(".")[1];
-	const rootFieldSettings = scenarioConfiguration?.[rootFieldKey];
-	const isRootFieldRequired = rootFieldSettings && isFieldRequired(rootFieldSettings, customRules);
-	const isRootFieldPopulated = formFieldsWithExistingData?.includes(rootFieldKey);
-	const areLinkedFieldsPopulated = linkedFieldsMap[rootLinkedField]?.some((linkedField) => {
-		const fieldKey = linkedField.split(".")[1];
-		return formFieldsWithExistingData?.includes(fieldKey);
-	});
-	const isRootFieldRequiredToRemediateDataMissingError = isFieldRequiredToRemediateDataMissingError(formId, rootFieldKey, dataMissingErrors);
-	if (!(isRootFieldRequired || isRootFieldPopulated || areLinkedFieldsPopulated || isRootFieldRequiredToRemediateDataMissingError)) return {
-		isRequiredFromLinkedField: false,
-		isOptionalFromLinkedField: false
-	};
-	switch (field) {
-		case "exemptedFromVat": {
-			const processedRule = customRules["isVatExempt"]?.();
-			return {
-				isRequiredFromLinkedField: processedRule === "REQUIRED",
-				isOptionalFromLinkedField: processedRule === "OPTIONAL"
-			};
-		}
-		case "vatAbsenceReason": {
-			const processedRule = customRules["isVatExempt"]?.();
-			return {
-				isRequiredFromLinkedField: processedRule === "REQUIRED",
-				isOptionalFromLinkedField: processedRule === "OPTIONAL"
-			};
-		}
-		default: return {
-			isRequiredFromLinkedField: false,
-			isOptionalFromLinkedField: false
-		};
-	}
-}
-//#endregion
-//#region src/core/process-field-configurations.ts
-var logger = createLogger();
-var composePerScenarioFormConfigurations = (scenarios = [], configurations) => scenarios.reduce((composedConfiguration, scenarioName) => ({
-	...composedConfiguration,
-	...configurations[scenarioName]
-}), {});
-var augmentWithCountryConfigs = (countrySpecificConfig, baseFormConfig) => {
-	if (!countrySpecificConfig) return baseFormConfig;
-	return keysOf(countrySpecificConfig).reduce((mergedConfig, field) => ({
-		...mergedConfig,
-		[field]: {
-			...baseFormConfig[field],
-			...countrySpecificConfig[field]
-		}
-	}), baseFormConfig);
-};
-var evaluateRules = (fieldSettings, customRules) => {
-	const ruleNames = [fieldSettings.rule, ...fieldSettings.rules ?? []].filter(Boolean);
-	return ruleNames.map((ruleName) => {
-		switch (ruleName) {
-			case "REQUIRED": return () => "REQUIRED";
-			case "OPTIONAL": return () => "OPTIONAL";
-			default: {
-				const ruleFn = customRules[ruleName];
-				if (!ruleFn) {
-					logger.error(`Rule with name '${ruleName}' is not defined`);
-					return () => void 0;
-				}
-				return ruleFn;
-			}
-		}
-	}).map((rule, index) => ({
-		ruleName: ruleNames[index],
-		result: rule()
-	}));
-};
-var isFieldRequired = (fieldSettings, customRules, reasons) => {
-	const ruleResults = evaluateRules(fieldSettings, customRules);
-	if (reasons) ruleResults.forEach(({ ruleName, result }) => {
-		reasons.push(`Rule '${ruleName}': ${result ?? "undefined"}`);
-	});
-	return ruleResults.every(({ result }) => result === "REQUIRED");
-};
-var isFieldOptional = (fieldSettings, customRules, reasons) => {
-	const ruleResults = evaluateRules(fieldSettings, customRules);
-	if (reasons) ruleResults.forEach(({ ruleName, result }) => {
-		reasons.push(`Rule '${ruleName}': ${result ?? "undefined"}`);
-	});
-	return ruleResults.every(({ result }) => result === "OPTIONAL");
-};
-/**
-* function: getPropsFromScenarios
-*
-* Configurations are stored as a flat list of fields and their properties.(see identity.ts), they
-* should be agnostic of how forms are structured and implemented. While parsing the configurations
-* the form structure information will be used to generate props specific to the passed form.
-* This also means the field names in configurations and forms should match.
-*
-* @returns value Eg:
-* ```
-* {
-*     requiredFields: {
-*         personalDetails: ['firstName', 'lastName', 'idNumber', 'residencyCountry' ],
-*         contactDetails: ['phoneNumber', 'email']
-*     },
-*     optionalFields: {
-*         contactDetails: ['email']
-*     },
-*     labels: {
-*         personalDetails: {
-*             firstName: 'givenName',
-*             lastName: 'surName'
-*         }
-*     },
-*     validators: {
-*         phoneNumber: {
-*              validate: (value, context?) => boolean;
-*              errorMessage?: string | ErrorMessageObject;
-*              modes: 'blur' | 'input';
-*        }
-*     }
-*
-* }
-* ```
-*/
-function getPropsFromConfigurations({ scenarioConfiguration, forms, remediationActions, dataMissingErrors, fieldsWithExistingData, customRules, legalEntityType, legalEntityTrustedFields, remediationFieldAsOptional = false }) {
-	const requiredFields = {};
-	const optionalFields = {};
-	const allFields = {};
-	const obscuredFields = {};
-	const trustedFields = {};
-	const fieldDebugStore = {};
-	formDebugInfo.value = {};
-	if (!scenarioConfiguration) return;
-	const readonly = ["legalFormDescription"];
-	/**
-	* Converts the LEM model trusted mappings to the component form field mappings
-	*/
-	const trustedFieldMappings = legalEntityTrustedFields?.reduce((acc, trusted) => {
-		switch (trusted.provider) {
-			case TrustedFieldsProviders.KOMPANY:
-				if (legalEntityType === "organization") return [...acc, ...trusted.fields.map((tf) => businessDetailsApiKeyMapping[tf])];
-				return acc;
-			case TrustedFieldsProviders.SINGPASS:
-				if (legalEntityType === "organization") {
-					const orgFields = trusted.fields.filter((field) => field.split(".")[0] === "organization");
-					return [...acc, ...orgFields.map((tf) => businessDetailsApiKeyMapping[tf])];
-				}
-				if (legalEntityType === "individual") {
-					const individualFields = trusted.fields.filter((field) => field.split(".")[0] === "individual");
-					return [...acc, ...individualFields.map((tf) => individualApiKeyMapping[tf])];
-				}
-				return acc;
-			default: return acc;
-		}
-	}, []);
-	Object.entries(forms).forEach(([_formId, formDetails]) => {
-		const formId = _formId;
-		const formFieldsWithExistingData = fieldsWithExistingData.filter((field) => field.startsWith(formId)).map((field) => field.slice(field.lastIndexOf(".") + 1));
-		if (trustedFieldMappings) trustedFields[formId] = getFormTrustedFields(formId, trustedFieldMappings);
-		formDetails.fields?.forEach((_field) => {
-			const field = _field;
-			const fieldName = `${formId}.${field}`;
-			const reasons = [];
-			const fieldSettings = scenarioConfiguration[field];
-			const isRequiredFromFieldConfig = fieldSettings && isFieldRequired(fieldSettings, customRules, reasons);
-			const isOptionalFromFieldConfig = fieldSettings && isFieldOptional(fieldSettings, customRules);
-			const isFieldRequiredByRemediationAction = showRemediationField(field, remediationActions);
-			if (isFieldRequiredByRemediationAction) reasons.push("Required by remediation action");
-			const isFieldNeededToRemediateDataMissingError = isFieldRequiredToRemediateDataMissingError(formId, field, dataMissingErrors);
-			if (isFieldNeededToRemediateDataMissingError) reasons.push("Required to remediate dataMissing error");
-			const isRequiredByRemediationAction = !remediationFieldAsOptional && isFieldRequiredByRemediationAction;
-			const isOptionalByRemediationAction = remediationFieldAsOptional && isFieldRequiredByRemediationAction;
-			const isRequiredFieldPopulated = !isOptionalFromFieldConfig && formFieldsWithExistingData.includes(field);
-			if (isRequiredFieldPopulated) reasons.push("Required because field is already populated");
-			const { isRequiredFromLinkedField, isOptionalFromLinkedField } = calculateLinkedRequiredFields({
-				field,
-				formId,
-				customRules,
-				scenarioConfiguration,
-				dataMissingErrors,
-				formFieldsWithExistingData
-			});
-			if (isRequiredFromLinkedField) reasons.push("Required by linked field");
-			if (isOptionalFromLinkedField) reasons.push("Optional by linked field");
-			const isRequired = (isRequiredFromFieldConfig || isRequiredByRemediationAction || isFieldNeededToRemediateDataMissingError || isRequiredFieldPopulated || isRequiredFromLinkedField) && !isOptionalFromLinkedField;
-			if (isRequired && !readonly.includes(field)) {
-				requiredFields[formId] = requiredFields[formId] ? [...requiredFields[formId], field] : [field];
-				allFields[formId] = allFields[formId] ? [...allFields[formId], field] : [field];
-			}
-			const isOptional = !isRequired && (isOptionalFromFieldConfig || isOptionalByRemediationAction || isOptionalFromLinkedField);
-			if (isOptional) {
-				optionalFields[formId] = optionalFields[formId] ? [...optionalFields[formId], field] : [field];
-				allFields[formId] = allFields[formId] ? [...allFields[formId], field] : [field];
-			}
-			fieldDebugStore[fieldName] = {
-				status: isRequired ? "REQUIRED" : isOptional ? "OPTIONAL" : "HIDDEN",
-				reasons
-			};
-			if (fieldSettings?.obscured) obscuredFields[formId] = obscuredFields[formId] ? [...obscuredFields[formId], field] : [field];
-		});
-	});
-	formDebugInfo.value = fieldDebugStore;
-	return {
-		requiredFields,
-		optionalFields,
-		allFields,
-		obscuredFields,
-		trustedFields
-	};
-}
-/**
-* The following field is made a visible "required" field if :
-*  - is a remediation action field AND is a document upload field
-* @param field - field key
-* @param remediationActions - array of remediation actions
-*/
-var showRemediationField = (field, remediationActions) => remediationActions.some((rem) => rem.fields?.includes(field) && remediationHasFileUploadField(rem));
-var makeTLDSFieldName = (formId, fieldName) => {
-	if (fieldName === "proofOfOrganizationTaxInfo") return `${formId}.taxDocument`;
-	return `${formId}.${fieldName}`;
-};
-var isFieldRequiredToRemediateDataMissingError = (formId, field, dataMissingErrors) => {
-	return dataMissingErrors.flatMap((error) => error.remediatingActions).filter((remediatingAction) => !!remediatingAction && remediatingAction.code in dataMissingRemediationsToFieldsMap).flatMap((remediatingAction) => dataMissingRemediationsToFieldsMap[remediatingAction.code]).filter((missingField) => Boolean(missingField)).map((missingField) => makeTLDSFieldName(formId, missingField)).includes(makeTLDSFieldName(formId, field));
-};
-var getFormTrustedFields = (formId, trustedFields) => trustedFields.filter((field) => field.split(".")[0] === formId).map((field) => field.split(".").filter((item) => formId !== item).join("."));
-//#endregion
-//#region src/utils/fieldConfigurations.ts
-var resolveFieldMetadata = (countryEntry, params, defaultMetadata) => {
-	if (typeof countryEntry === "object") return countryEntry;
-	if (typeof countryEntry === "function") return countryEntry(params);
-	return defaultMetadata;
-};
-//#endregion
-//#region src/utils/formFields/formFieldsUtils.ts
-/**
-* Replaces full-width Latin characters with regular (half-width) characters.
-*
-* E.g. `ｔｅｓｔ＠email１２３.com` -> `test@email123.com`
-*/
-var convertFullToHalf = (str) => str.replace(/[！-～]/g, (r) => String.fromCharCode(r.charCodeAt(0) - 65248));
-//#endregion
-//#region src/utils/masking/displayValueToPureValue.ts
-var cachedStripPatterns = /* @__PURE__ */ new Map();
-var makeStripPattern = (mask) => {
-	const inputPatterns = mask.tokens.filter((token) => token.type === "input" && !!token.allow).map((token) => token.allow);
-	const nonInputChars = mask.tokens.filter((token) => token.type === "nonInput" && !token.includeInValue).map((token) => token.char);
-	const strippedChars = [...new Set(nonInputChars.filter((char) => !inputPatterns.some((pattern) => pattern.test(char))))];
-	const stripPattern = new RegExp(`[${strippedChars.join("")}]`, "g");
-	cachedStripPatterns.set(mask, stripPattern);
-	return stripPattern;
-};
-/**
-* Takes a formatted value and converts it back into a pure value by stripping the non-input /
-* non-included characters in a given {@link Mask}.
-*
-* This is the inverse of {@link matchAgainstMask}.
-*
-* @see matchAgainstMask
-*/
-var displayValueToPureValue = (displayValue, mask) => {
-	const stripPattern = cachedStripPatterns.get(mask) ?? makeStripPattern(mask);
-	return displayValue.replaceAll(stripPattern, "");
-};
-//#endregion
-//#region src/utils/isValueObscured.ts
-var isValueObscured = (value) => typeof value === "string" && !!value.match(/[*]{1,}/)?.length;
-//#endregion
-//#region src/utils/masking/shiftRight.ts
-var shiftRight = (possibleShifts, matchedTokens, remainingTokens) => {
-	let shiftsToTry = [...possibleShifts];
-	let current = {
-		matchedTokens,
-		remainingTokens
-	};
-	while (current.remainingTokens.length > 0 && shiftsToTry.length > 0) {
-		const possibleShift = shiftsToTry[0];
-		const shifted = tryShift(current.matchedTokens, current.remainingTokens, possibleShift.fromIndex, possibleShift.shiftDistance);
-		if (shifted === "notPossible") shiftsToTry = shiftsToTry.slice(1);
-		else {
-			current = shifted;
-			shiftsToTry = [...possibleShifts];
-		}
-	}
-	return current;
-};
-/**
-* Returns all possible shifts of optional inputs, sorted by best to worst
-* @param mask
-*/
-var findPossibleShifts = (mask) => {
-	const inputOnlyMask = mask.filter((t) => t.type === "input");
-	const optionals = inputOnlyMask.filter((t) => t.optional);
-	const possibleShifts = [];
-	for (const optional of optionals) {
-		const index = inputOnlyMask.indexOf(optional);
-		for (let i = index + 1; i < inputOnlyMask.length; i += 1) if (inputOnlyMask[i].type === "input") possibleShifts.push({
-			fromIndex: index,
-			shiftDistance: i - index
-		});
-	}
-	return possibleShifts.sort((s1, s2) => {
-		if (s1.fromIndex === s2.fromIndex) return s2.shiftDistance - s1.shiftDistance;
-		return s1.fromIndex - s2.fromIndex;
-	});
-};
-var tryShift = (matchedTokens, remainingTokens, fromIndex, shiftDistance) => {
-	const normalizedTokens = [...matchedTokens.map((token, i) => ({
-		...token,
-		currentValue: token.char,
-		originalIndex: i
-	})), ...remainingTokens.map((token, i) => ({
-		...token,
-		currentValue: null,
-		originalIndex: i + matchedTokens.length
-	}))];
-	const normalizedInputTokens = normalizedTokens.filter((token) => token.type === "input");
-	if (!normalizedTokens[fromIndex] || normalizedTokens[fromIndex].currentValue === null) return "notPossible";
-	if (shiftDistance > normalizedInputTokens.slice(fromIndex + 1).filter((t) => !t.currentValue).length) return "notPossible";
-	for (let i = 0; i < normalizedInputTokens.length; i += 1) {
-		const token = normalizedInputTokens[i];
-		if (i < fromIndex) token.potentialValue = token.currentValue;
-		else if (i < fromIndex + shiftDistance) token.potentialValue = null;
-		else token.potentialValue = normalizedInputTokens[i - shiftDistance].currentValue;
-	}
-	if (!normalizedInputTokens.every((token) => {
-		if (!token.potentialValue) return token.optional;
-		return token.allow?.test(token.potentialValue) ?? true;
-	})) return "notPossible";
-	let matchedUpTo = 0;
-	for (let i = 0; i < normalizedTokens.length; i += 1) {
-		const token = normalizedInputTokens.find((t) => t.originalIndex === i) ?? normalizedTokens[i];
-		if (token.type === "input" && !token.potentialValue && !token.optional) break;
-		matchedUpTo = i + 1;
-	}
-	return {
-		matchedTokens: normalizedTokens.slice(0, matchedUpTo).map((token) => ({
-			...token,
-			char: token.type === "nonInput" ? token.char : token.potentialValue
-		})),
-		remainingTokens: normalizedTokens.slice(matchedUpTo)
-	};
-};
-//#endregion
-//#region src/utils/masking/stripNonAllowedValues.ts
-var cachedAllowedPatterns = /* @__PURE__ */ new Map();
-/**
-* Creates a regular expression that matches any of the provided patterns.
-*
-* @param regexArray - An array of regular expressions.
-* @returns A combined regular expression.
-*/
-var combineRegexArray = (regexArray) => {
-	const combinedPattern = regexArray.map((pattern) => {
-		const match = String(pattern).match(/\/?(.*)\//);
-		return match ? match[1] : pattern;
-	}).join("|");
-	return new RegExp(`(?:${combinedPattern})`, "g");
-};
-/**
-* Creates a regular expression that matches the allowed input patterns for the given mask.
-*
-* @param mask - The mask definition.
-* @returns The compiled regular expression.
-*/
-var createAllowedPattern = (mask) => {
-	const inputPatterns = mask.tokens.filter((token) => token.type === "input" && !!token.allow).map((token) => token.allow);
-	const allowedRegex = combineRegexArray([...new Set(inputPatterns.map((r) => r.toString()))].map((str) => {
-		const [_, pattern] = str.match(/\/(.*)\/([gimsuy]*)/) || [];
-		return new RegExp(pattern);
-	}));
-	cachedAllowedPatterns.set(mask, allowedRegex);
-	return allowedRegex;
-};
-var replaceNonMatchingChars = (value, allowedInputPatterns) => {
-	const matches = value.match(allowedInputPatterns);
-	return matches ? matches.join("") : "";
-};
-var stripNonAllowedValues = (pureValue, mask) => {
-	return replaceNonMatchingChars(pureValue, cachedAllowedPatterns.get(mask) ?? createAllowedPattern(mask));
-};
-//#endregion
-//#region src/utils/masking/matchAgainstMask.ts
-var getAvailableInputTokens = (tokens) => {
-	const availableTokens = [];
-	for (const token of tokens) {
-		if (token.type === "nonInput") {
-			if (token.includeInValue) availableTokens.push({
-				...token,
-				offset: tokens.indexOf(token)
-			});
-			continue;
-		}
-		availableTokens.push({
-			...token,
-			offset: tokens.indexOf(token)
-		});
-		if (token.type !== "input" || !token.optional) break;
-	}
-	return availableTokens;
-};
-var findMatchingToken = (tokensWithOffset, char) => tokensWithOffset.find((token) => token.type === "nonInput" || !token.allow || token.allow.test(char)) ?? null;
-var getEagerSuffix = (tokens) => {
-	let suffix = "";
-	for (const token of tokens) {
-		if (token.type === "input") if (token.optional) continue;
-		else break;
-		if (!token.displayEagerly) break;
-		suffix += token.char;
-	}
-	return suffix;
-};
-var getPotentialForMoreOptionalInput = (tokens) => tokens.some((token) => token.type === "input" && token.optional);
-/**
-* Takes some pure value e.g. `NL123456` and a {@link Mask}, and returns a `partialCorrect`,
-* `correct` or `mismatch` {@link MaskResult} accordingly.
-*
-* This is the inverse of {@link displayValueToPureValue}.
-*
-* @returns the result of matching the given value against the mask
-* @param pureValue the pure, unformatted input value
-* @param mask the mask to match against
-* @param acceptObscuredValue whether to accept
-*
-* @see displayValueToPureValue
-*/
-var matchAgainstMask = (pureValue, mask, acceptObscuredValue = false, stripNonAllowedInputs = false) => {
-	let tokensToProcess = [...mask.tokens];
-	let charsToProcess = pureValue;
-	let charIndex = 0;
-	let matchedTokens = [];
-	if (acceptObscuredValue && isValueObscured(pureValue)) return {
-		outcome: "obscureCorrect",
-		displayValue: pureValue
-	};
-	const shiftChars = (increment) => {
-		charIndex += increment;
-		charsToProcess = charsToProcess.slice(increment);
-	};
-	const shiftTokens = (increment) => {
-		tokensToProcess = tokensToProcess.slice(increment);
-	};
-	const displayValue = () => matchedTokens.map((token) => token.char).join("");
-	const getNonInputCharacters = () => matchedTokens.filter((token) => token.type === "nonInput" && token.includeInValue === false).map((token) => token.char).join("");
-	while (true) {
-		let partialDisplayValue = displayValue();
-		if (stripNonAllowedInputs) {
-			partialDisplayValue = partialDisplayValue.replaceAll(getNonInputCharacters(), "");
-			if (!partialDisplayValue.length) partialDisplayValue = stripNonAllowedValues(charsToProcess, mask);
-		}
-		const char = charsToProcess[0];
-		const token = tokensToProcess[0];
-		if (!char && !tokensToProcess.some((t) => t.type === "input" && !t.optional)) return {
-			outcome: "correct",
-			displayValue: displayValue() + getEagerSuffix(tokensToProcess),
-			potentialForMoreOptionalInput: getPotentialForMoreOptionalInput(tokensToProcess)
-		};
-		if (!char) {
-			const output = shiftRight(mask.possibleShifts, matchedTokens, tokensToProcess);
-			matchedTokens = output.matchedTokens;
-			tokensToProcess = output.remainingTokens;
-			return {
-				outcome: "partialCorrect",
-				displayValue: displayValue() + getEagerSuffix(tokensToProcess)
-			};
-		}
-		if (!token) return {
-			outcome: "mismatch",
-			badChar: char,
-			mismatchAtChar: charIndex,
-			mismatchedToken: "inputTooLong",
-			partialDisplayValue
-		};
-		if (token.type === "nonInput") {
-			if (token.includeInValue) {
-				if (char !== token.char) return {
-					outcome: "mismatch",
-					badChar: char,
-					mismatchAtChar: charIndex,
-					mismatchedToken: token,
-					partialDisplayValue
-				};
-				shiftChars(1);
-			}
-			matchedTokens.push(token);
-			shiftTokens(1);
-		}
-		if (token.type === "input") {
-			const matchingToken = findMatchingToken(getAvailableInputTokens(tokensToProcess), char);
-			if (!matchingToken) return {
-				outcome: "mismatch",
-				badChar: char,
-				mismatchAtChar: charIndex,
-				mismatchedToken: token,
-				partialDisplayValue
-			};
-			matchedTokens.push({
-				...matchingToken,
-				char
-			});
-			shiftTokens(matchingToken.offset + 1);
-			shiftChars(1);
-		}
-	}
-};
-//#endregion
-//#region src/components/ui/molecules/InputEmail/InputEmail.tsx
-var InputEmail = forwardRef(({ onInput, transformInput, ...props }, ref) => {
-	const [cursorPosition, setCursorPosition] = useState$1(null);
-	const localRef = useForwardedRef(ref);
-	const inputHandler = useCallback$1((event) => {
-		const inputEl = event.currentTarget;
-		if (transformInput) {
-			setCursorPosition(inputEl.selectionStart);
-			const transformedInput = transformInput(inputEl.value);
-			onInput({
-				...event,
-				target: {
-					...event.target,
-					value: transformedInput
-				}
-			});
-		} else onInput(event);
-	}, [transformInput, onInput]);
-	useLayoutEffect(() => {
-		if (cursorPosition && localRef.current?.selectionStart !== cursorPosition) localRef?.current?.setSelectionRange(cursorPosition, cursorPosition, "none");
-	}, [cursorPosition, localRef]);
-	return /* @__PURE__ */ jsx(InputBase, {
-		...props,
-		onInput: inputHandler,
-		ref: localRef,
-		type: "email",
-		autoCapitalize: "off"
-	});
-});
-//#endregion
-//#region src/components/ui/molecules/InputTelephone/InputTelephone.tsx
-var InputTelephone = forwardRef(({ onInput, transformInput, ...props }, ref) => {
-	const [cursorPosition, setCursorPosition] = useState$1(null);
-	const localRef = useForwardedRef(ref);
-	const inputHandler = useCallback$1((event) => {
-		const inputEl = event.currentTarget;
-		if (transformInput) {
-			setCursorPosition(inputEl.selectionStart);
-			const transformedInput = transformInput(inputEl.value);
-			onInput({
-				...event,
-				target: {
-					...event.target,
-					value: transformedInput
-				}
-			});
-		} else onInput(event);
-	}, [transformInput, onInput]);
-	useLayoutEffect(() => {
-		if (cursorPosition && localRef.current?.selectionStart !== cursorPosition) localRef?.current?.setSelectionRange(cursorPosition, cursorPosition, "none");
-	}, [cursorPosition, localRef]);
-	return /* @__PURE__ */ jsx(InputBase, {
-		...props,
-		onInput: inputHandler,
-		ref: localRef,
-		type: "tel"
-	});
-});
-var MaskedInput_module_default = {
-	mismatch: "_mismatch_nyvqg_1",
-	mismatchShake: "_mismatchShake_nyvqg_1"
-};
-//#endregion
-//#region src/components/ui/molecules/MaskedInput/MaskedInput.tsx
-var deriveInputState = (isValid, isFocused, isDisabled, isOptional, hasNullishValue, hasBlurred, errorMessage, shouldValidate, potentiallyMoreOptionalCharacters, formatGuidance, t) => {
-	if (isDisabled) return { isError: false };
-	if (isOptional && hasNullishValue) return { isError: false };
-	if (isValid && (!potentiallyMoreOptionalCharacters || !isFocused)) return {
-		isError: false,
-		text: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Icon, {
-			name: "checkmark-small",
-			className: "adyen-kyc-helper-text__valid-format-check"
-		}), t(($) => $["formatIsCorrect"])] })
-	};
-	if (isFocused && formatGuidance) return {
-		isError: false,
-		text: formatGuidance
-	};
-	if (!isValid && (shouldValidate || hasBlurred)) return {
-		isError: true,
-		errorMessage,
-		text: formatGuidance
-	};
-	return { isError: false };
-};
-var MISMATCH_ANIMATION_NAME = "mismatchShake";
-var Inner = ({ name, inputState, optional, disabled, readonly, placeholder, displayValue, inputRef, type, id, showingMismatch, onInput, onBlur, onFocus, onPaste, onKeyDown, ...props }) => {
-	switch (type) {
-		case "text": return /* @__PURE__ */ jsx(InputText, {
-			id,
-			"aria-describedby": props["aria-describedby"],
-			"aria-label": props["aria-label"],
-			"aria-labelledby": props["aria-labelledby"],
-			"aria-invalid": inputState.isError,
-			"aria-placeholder": placeholder,
-			ref: inputRef,
-			name,
-			isValid: !inputState.isError,
-			isInvalid: inputState.isError,
-			required: !optional,
-			disabled,
-			readonly,
-			placeholder,
-			value: displayValue,
-			className: showingMismatch ? MaskedInput_module_default.mismatch : void 0,
-			onInput,
-			onPaste,
-			onKeyDown,
-			onFocusHandler: onFocus,
-			onBlurHandler: onBlur
-		});
-		case "email": return /* @__PURE__ */ jsx(InputEmail, {
-			id,
-			"aria-describedby": props["aria-describedby"],
-			"aria-label": props["aria-label"],
-			"aria-labelledby": props["aria-labelledby"],
-			"aria-invalid": inputState.isError,
-			"aria-placeholder": placeholder,
-			ref: inputRef,
-			name,
-			isValid: !inputState.isError,
-			isInvalid: inputState.isError,
-			required: !optional,
-			disabled,
-			readonly,
-			placeholder,
-			value: displayValue,
-			onInput,
-			onPaste,
-			onKeyDown,
-			onFocusHandler: onFocus,
-			onBlurHandler: onBlur
-		});
-		case "tel": return /* @__PURE__ */ jsx(InputTelephone, {
-			id,
-			"aria-describedby": props["aria-describedby"],
-			"aria-label": props["aria-label"],
-			"aria-labelledby": props["aria-labelledby"],
-			"aria-invalid": inputState.isError,
-			"aria-placeholder": placeholder,
-			ref: inputRef,
-			name,
-			isValid: !inputState.isError,
-			isInvalid: inputState.isError,
-			required: !optional,
-			disabled,
-			readonly,
-			placeholder,
-			value: displayValue,
-			onInput,
-			onPaste,
-			onKeyDown,
-			onFocusHandler: onFocus,
-			onBlurHandler: onBlur
-		});
-	}
-};
-var MaskedInput = ({ value, onInput, onBlur, onFocus, onMismatch: onMismatchExternal, isValid: validationIsValid, errorMessage, shouldValidate, mask, name, label, placeholder, transformOnType, type = "text", readonly = false, disabled = false, optional = false, formatGuidance = "", acceptObscuredValue = false, helper, helperPosition = "below", persistHelper = false, useFieldComponent = true, stripNonAllowedInputs = false }) => {
-	const hasExistingData = !isEmpty(value);
-	const [preservingMismatchedValue, setPreservingMismatchedValue] = useState$1(false);
-	const [isFocused, setIsFocused] = useState$1(false);
-	const [hasBlurred, setHasBlurred] = useState$1(hasExistingData);
-	const [caretReturnPosition, setCaretReturnPosition] = useState$1(null);
-	const inputRef = useRef$1(null);
-	const [showingMismatch, setShowingMismatch] = useState$1(false);
-	const { t } = useTranslation("ui");
-	const onAnimationEnd = (event) => {
-		if (!event.animationName.includes(MISMATCH_ANIMATION_NAME)) return;
-		setShowingMismatch(false);
-	};
-	const onMismatch = useCallback$1((mismatch) => {
-		if (!inputRef.current) return;
-		setShowingMismatch(true);
-		inputRef.current.addEventListener("animationend", onAnimationEnd);
-		onMismatchExternal?.(mismatch);
-	}, [onMismatchExternal]);
-	useEffect$1(() => {
-		const inputEl = inputRef.current;
-		if (inputEl) return () => {
-			inputEl.removeEventListener("animationend", onAnimationEnd);
-		};
-	}, []);
-	const getMaskResult = useCallback$1((pureValue) => {
-		if (!mask) return {
-			outcome: "partialCorrect",
-			displayValue: pureValue
-		};
-		return matchAgainstMask(transformOnType ? transformOnType(pureValue) : pureValue, mask, acceptObscuredValue, stripNonAllowedInputs);
-	}, [
-		mask,
-		transformOnType,
-		acceptObscuredValue,
-		stripNonAllowedInputs
-	]);
-	const displayValueToPure = useCallback$1((displayValue) => {
-		if (!mask) return displayValue;
-		return displayValueToPureValue(displayValue, mask);
-	}, [mask]);
-	const maskResult = useMemo$1(() => getMaskResult(value), [getMaskResult, value]);
-	const displayValue = preservingMismatchedValue ? value : maskResult.outcome === "mismatch" ? maskResult.partialDisplayValue : maskResult.displayValue;
-	const inputState = deriveInputState(validationIsValid && maskResult.outcome !== "mismatch", isFocused, disabled, optional, !displayValue, hasBlurred, errorMessage, shouldValidate, maskResult.outcome === "correct" && !!maskResult.potentialForMoreOptionalInput, formatGuidance, t);
-	useEffect$1(() => {
-		if (mask && maskResult.outcome === "mismatch") {
-			const strippedValue = displayValueToPure(value);
-			if (getMaskResult(strippedValue).outcome !== "mismatch") {
-				onInput(strippedValue);
-				return;
-			}
-			setPreservingMismatchedValue(true);
-			if (stripNonAllowedInputs) onInput(maskResult.partialDisplayValue);
-		}
-	}, [
-		mask,
-		maskResult,
-		value,
-		onInput,
-		displayValueToPure,
-		getMaskResult,
-		stripNonAllowedInputs
-	]);
-	useLayoutEffect(() => {
-		if (caretReturnPosition && inputRef.current && caretReturnPosition !== inputRef.current.selectionStart) {
-			inputRef.current.setSelectionRange(caretReturnPosition, caretReturnPosition, "none");
-			setCaretReturnPosition(null);
-		}
-	}, [caretReturnPosition]);
-	const handleInput = useCallback$1((event) => {
-		const inputEl = event.currentTarget;
-		if (!inputEl) return;
-		const newPureValue = displayValueToPure(inputEl.value);
-		const newMaskResult = getMaskResult(newPureValue);
-		const returnCaretLater = (offset = 0) => {
-			if (!inputEl.selectionStart) return;
-			setCaretReturnPosition(inputEl.selectionStart + offset);
-		};
-		const cancelInput = () => {
-			returnCaretLater(-1);
-			inputEl.value = displayValue;
-			if (typeof event.preventDefault === "function") {
-				event.preventDefault();
-				event.stopPropagation();
-			}
-		};
-		if (newMaskResult.outcome === "mismatch") {
-			if (newMaskResult.partialDisplayValue) {
-				if (newMaskResult.mismatchedToken === "inputTooLong" && displayValue) {
-					cancelInput();
-					onMismatch(newMaskResult);
-					return;
-				}
-				cancelInput();
-				onMismatch(newMaskResult);
-				setPreservingMismatchedValue(false);
-				onInput(newMaskResult.partialDisplayValue);
-				return;
-			}
-			cancelInput();
-			onMismatch(newMaskResult);
-			return;
-		}
-		if (inputEl.selectionStart && inputEl.selectionStart < inputEl.value.length) returnCaretLater();
-		setPreservingMismatchedValue(false);
-		inputEl.value = newMaskResult.displayValue;
-		onInput(newPureValue);
-	}, [
-		displayValue,
-		displayValueToPure,
-		getMaskResult,
-		onInput,
-		onMismatch
-	]);
-	const handleBlur = useCallback$1((event, fieldOnBlur) => {
-		fieldOnBlur?.(event);
-		const eventWithProcessedValue = {
-			...event,
-			currentTarget: {
-				...event.currentTarget,
-				value: displayValueToPure(event.currentTarget.value)
-			},
-			target: {
-				...event.target,
-				value: displayValueToPure(event.currentTarget.value)
-			}
-		};
-		onBlur?.(eventWithProcessedValue);
-		setIsFocused(false);
-		setHasBlurred(true);
-	}, [displayValueToPure, onBlur]);
-	const handlePaste = useCallback$1((event) => {
-		const pasteValue = event.clipboardData?.getData("text/plain");
-		const inputEl = event.currentTarget;
-		const { selectionStart, selectionEnd } = inputEl;
-		if (!pasteValue || !selectionStart || selectionStart !== selectionEnd) return;
-		const pureDisplayValue = displayValueToPure(displayValue);
-		const purePasteValue = displayValueToPure(pasteValue);
-		const newPureValue = pureDisplayValue.slice(0, selectionStart) + purePasteValue + pureDisplayValue.slice(selectionStart);
-		if (newPureValue.startsWith(pureDisplayValue + pureDisplayValue)) {
-			const withPrefixRemoved = newPureValue.replace(pureDisplayValue, "");
-			event.preventDefault();
-			inputEl.value = withPrefixRemoved;
-			handleInput({
-				...event,
-				currentTarget: inputEl,
-				target: inputEl
-			});
-		}
-	}, [
-		displayValue,
-		displayValueToPure,
-		handleInput
-	]);
-	const handleFocus = useCallback$1((event, fieldOnFocus) => {
-		onFocus?.();
-		fieldOnFocus?.(event);
-		setIsFocused(true);
-	}, [onFocus]);
-	const handleKeyDown = useCallback$1((event) => {
-		const inputEl = event.currentTarget;
-		const isCaretAtEndWithNoSelection = inputEl.selectionStart === inputEl.value.length && inputEl.selectionStart === inputEl.selectionEnd;
-		if (event.key !== KEYBOARD_KEYS.backspace || !isCaretAtEndWithNoSelection) return;
-		event.preventDefault();
-		const withLastCharRemoved = value.slice(0, value.length - 1);
-		const newMaskResult = getMaskResult(withLastCharRemoved);
-		if (newMaskResult.outcome === "mismatch") {
-			inputEl.value = newMaskResult.partialDisplayValue;
-			onMismatch(newMaskResult);
-		} else {
-			inputEl.value = newMaskResult.displayValue;
-			onInput(withLastCharRemoved);
-		}
-	}, [
-		getMaskResult,
-		onInput,
-		onMismatch,
-		value
-	]);
-	const getHelper = () => {
-		if (inputState.isError && !persistHelper) return inputState.text;
-		if (helper) return /* @__PURE__ */ jsxs("span", { children: [/* @__PURE__ */ jsx("div", { children: helper }), /* @__PURE__ */ jsx("div", {
-			style: { display: persistHelper ? "flex" : "unset" },
-			children: inputState.text
-		})] });
-		return inputState.text;
-	};
-	return useFieldComponent ? /* @__PURE__ */ jsx(Field, {
-		name,
-		label,
-		isValid: !inputState.isError,
-		errorMessage: inputState.errorMessage,
-		helper: getHelper(),
-		helperPosition,
-		disabled,
-		optional,
-		children: ({ onBlurHandler: fieldOnBlur, onFocusHandler: fieldOnFocus, id, ...childProps }) => /* @__PURE__ */ jsx(Inner, {
-			...childProps,
-			id,
-			name,
-			optional,
-			disabled,
-			readonly,
-			placeholder,
-			displayValue,
-			inputRef,
-			inputState,
-			type,
-			showingMismatch,
-			onInput: handleInput,
-			onBlur: (event) => {
-				handleBlur(event, fieldOnBlur);
-			},
-			onPaste: handlePaste,
-			onFocus: (event) => {
-				handleFocus(event, fieldOnFocus);
-			},
-			onKeyDown: handleKeyDown
-		})
-	}) : /* @__PURE__ */ jsx(Inner, {
-		name,
-		"aria-label": label,
-		optional,
-		disabled,
-		readonly,
-		placeholder,
-		displayValue,
-		inputRef,
-		inputState,
-		type,
-		showingMismatch,
-		onInput: handleInput,
-		onBlur: (event) => {
-			handleBlur(event);
-		},
-		onPaste: handlePaste,
-		onFocus: (event) => {
-			handleFocus(event);
-		},
-		onKeyDown: handleKeyDown
-	});
-};
-//#endregion
-//#region src/utils/makeArrayOfRepeatedObjects.ts
-var makeArrayOfRepeatedObjects = (length, obj) => {
-	const array = [];
-	for (let i = 0; i < length; i += 1) array.push(cloneObject(obj));
-	return array;
-};
-//#endregion
-//#region src/utils/masking/maskHelpers.ts
-var nonInputs = (str, options) => Array.from(str).map((char) => ({
-	type: "nonInput",
-	char,
-	includeInValue: options?.includeInValue ?? false,
-	displayEagerly: options?.displayEagerly ?? true
-}));
-var spacer = nonInputs(" ")[0];
-var alphaInputs = (length, optional = false) => makeArrayOfRepeatedObjects(length, {
-	type: "input",
-	allow: /[A-Za-z]/,
-	optional
-});
-var numericInputs = (length, optional = false) => makeArrayOfRepeatedObjects(length, {
-	type: "input",
-	allow: /\d/,
-	optional
-});
-var alphanumericInputs = (length, optional = false) => makeArrayOfRepeatedObjects(length, {
-	type: "input",
-	allow: /[\dA-Za-z]/,
-	optional
-});
-var customInputs = (length, regex, optional = false) => makeArrayOfRepeatedObjects(length, {
-	type: "input",
-	allow: regex,
-	optional
-});
-var makeMask = (...tokens) => ({
-	tokens,
-	possibleShifts: findPossibleShifts(tokens)
-});
-//#endregion
-//#region src/utils/masking/transformers/uppercase.ts
-var uppercase = (str) => str?.toUpperCase() ?? str;
-//#endregion
-//#region src/types/form-rules.ts
-/**
-* Identity function that guarantees strictly typed rules with the provided rule names
-*/
-var createFormRules = (rules) => rules;
-//#endregion
-export { getPropsFromConfigurations as _, customInputs as a, numericInputs as c, InputEmail as d, isValueObscured as f, composePerScenarioFormConfigurations as g, augmentWithCountryConfigs as h, alphanumericInputs as i, spacer as l, resolveFieldMetadata as m, uppercase as n, makeMask as o, convertFullToHalf as p, alphaInputs as r, nonInputs as s, createFormRules as t, MaskedInput as u, LandingLayout as v, TrustedFieldsProviders as y };