@adyen/kyc-components 4.20.0 → 4.21.0-beta.0

package/dist/{utils-Be9xux9M.js → bafinUtils-CT-a64QP.js}

@@ -1,18 +1,96 @@
 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] = "d04171c1-f4fa-4660-8f88-07be27188e29", e._sentryDebugIdIdentifier = "sentry-dbid-d04171c1-f4fa-4660-8f88-07be27188e29");
+	n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "3877dfbe-4db5-4680-89f6-907f0f567b18", e._sentryDebugIdIdentifier = "sentry-dbid-3877dfbe-4db5-4680-89f6-907f0f567b18");
 } catch (e) {}
-import { r as useTranslation } from "./translation-DH4IlMCP.js";
+import { r as useTranslation } from "./translation-BOm4lmPx.js";
+import { j as useToggleContext, mt as useAccountHolder } from "./resolveEnvironment-wbFNXSP-.js";
+import { t as Icon } from "./Icon-CurE93CX.js";
+import { t as Typography } from "./Typography-CAc_f5Iq.js";
 import { t as LegalEntityTypes } from "./legal-entity-type-0MfCGzUf.js";
+import { i as noop } from "./genUtils-Ce61IJs8.js";
 import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
-import { l as CompanyTypesValues } from "./bafinUtils-9rBblM1a.js";
-import { r as Field } from "./Select-Dmn4bMEK.js";
-import { a as alphanumericInputs, c as nonInputs, i as alphaInputs, l as numericInputs, o as customInputs, s as makeMask, u as spacer } from "./MaskedInput-DhHmuLSN.js";
-import { t as uppercase } from "./uppercase-DvjwUM0n.js";
-import { a as validateNotEmptyOnBlur, o as validatePatternOnBlur } from "./patternValidators-C8cRrD-t.js";
-import { t as RadioGroup } from "./RadioGroup-C4csROhR.js";
-import { useCallback, useEffect, useMemo } from "preact/hooks";
-import { jsx } from "preact/jsx-runtime";
+import { t as TaskTypes } from "./taskTypes-3vSkMBDm.js";
+import { t as DecisionMakerTypes } from "./decision-maker-type-NR4GFAeT.js";
+import { t as Scenarios } from "./get-scenarios-Bb-paHmJ.js";
+import { i as useAnalyticsContext, r as KEYBOARD_KEYS } from "./Modal-C6gfqa3Z.js";
+import { a as uppercase, c as customInputs, d as numericInputs, f as spacer, l as makeMask, n as MaskedInput, o as alphaInputs, s as alphanumericInputs, u as nonInputs } from "./form-rules-DCZ-uyGo.js";
+import { t as useId } from "./useId-zuKUQ8ly.js";
+import { f as translateTranslatable, r as Field } from "./Select-PqhoL_oQ.js";
+import { c as validatePatternOnBlur, l as resolveFieldMetadata, s as validateNotEmptyOnBlur, t as RadioGroup } from "./RadioGroup-B_lHSMq9.js";
+import { t as Checkbox } from "./Checkbox-B-hhlkoQ.js";
+import { useCallback, useEffect, useMemo, useRef } from "preact/hooks";
+import cx from "classnames";
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { computed, signal } from "@preact/signals";
+//#region src/core/models/api/company-types-value.ts
+/**
+* These are the Company type values present in LEM (note these differ from the values present in KYC)
+*/
+var CompanyTypesValues = {
+	PRIVATE_COMPANY: "privateCompany",
+	PUBLIC_COMPANY: "listedPublicCompany",
+	UNLISTED_PUBLIC_COMPANY: "unlistedPublicCompany",
+	UNINCORPORATED_PARTNERSHIP: "unincorporatedPartnership",
+	INCORPORATED_PARTNERSHIP: "partnershipIncorporated",
+	INCORPORATED_ASSOCIATION: "associationIncorporated",
+	GOVERNMENTAL_ORGANIZATION: "governmentalOrganization",
+	NON_PROFIT_OR_CHARITABLE: "nonProfit",
+	SOLE_PROPRIETORSHIP: "soleProprietorship"
+};
+//#endregion
+//#region src/utils/japanSupportUtils.ts
+var isJapanLocalizationEnabled = (isFeatureEnabled = () => false, country) => {
+	return country === CountryCodes.Japan && isFeatureEnabled("EnableJapanLocalization");
+};
+//#endregion
+//#region src/utils/textTransformation/toFullWidth.ts
+var applyDelta = (delta) => (char) => String.fromCharCode(char.charCodeAt(0) + delta);
+/**
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize#nfkc
+*/
+var standardNormalization = (input) => input.normalize("NFKC");
+/**
+* The order here does matter, since the characters matched by each converter may overlap.
+*/
+var converters = [
+	{
+		name: "latin",
+		match: /[!-~]/g,
+		convert: applyDelta(65248)
+	},
+	{
+		name: "hangul1",
+		match: /[ﾡ-ﾾ]/g,
+		convert: standardNormalization
+	},
+	{
+		name: "hangul2",
+		match: /[ￂ-ￜ]/g,
+		convert: standardNormalization
+	},
+	{
+		name: "katakana",
+		match: /[\uff60-\uff9f]+/g,
+		convert: standardNormalization
+	},
+	{
+		name: "extras",
+		match: /[¢£¬¯¦¥₩\u0020|←↑→↓■°]/g,
+		convert: (char) => {
+			return "￠￡￢￣￤￥￦　｜￩￪￫￬￭￮"["¢£¬¯¦¥₩ |←↑→↓■°".indexOf(char)];
+		}
+	}
+];
+/**
+* Replaces half-width characters with full-width characters.
+* Includes Latin characters, Katakana, Hangul and various symbols.
+*/
+var toFullWidth = (value) => {
+	let input = value;
+	for (const { match, convert } of converters) input = input.replaceAll(match, convert);
+	return input;
+};
+//#endregion
 //#region src/types/datasets/state-code.ts
 var StateCodesUS = {
 	Alabama: "AL",
@@ -1742,6 +1820,132 @@ var getTaxInformationPlaceholderText = ({ country, companyType, taxIdNumberType
 	}
 };
 //#endregion
+//#region src/components/Business/forms/rules.constants.ts
+/**
+* Source of truth for registration-number exemption eligibility in Business Details.
+*
+* This map defines which organization entity types can use
+* `exemptedFromRegistrationNumber`, grouped by country. All exemption checks should
+* be derived from this structure to keep behavior consistent across form rules.
+*
+* Interpretation:
+* - Non-empty array: exemption is allowed only for the listed entity types.
+* - Empty array: exemption is allowed for that country without entity-type restrictions.
+*
+*/
+var REGISTRATION_NUMBER_EXEMPTION_RULES = {
+	[CountryCodes.Australia]: [CompanyTypesValues.GOVERNMENTAL_ORGANIZATION, CompanyTypesValues.INCORPORATED_PARTNERSHIP],
+	[CountryCodes.Denmark]: [CompanyTypesValues.NON_PROFIT_OR_CHARITABLE],
+	[CountryCodes.Germany]: [CompanyTypesValues.GOVERNMENTAL_ORGANIZATION, CompanyTypesValues.NON_PROFIT_OR_CHARITABLE],
+	[CountryCodes.HongKong]: [],
+	[CountryCodes.NewZealand]: []
+};
+var COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION = [
+	CountryCodes.HongKong,
+	CountryCodes.Mexico,
+	CountryCodes.PuertoRico,
+	CountryCodes.UnitedStates
+];
+var COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER = [CountryCodes.Canada, CountryCodes.UnitedStates];
+/**
+*  Also used to determine what documenttype needs to be used
+*  when uploading tax document in mapping.ts
+* */
+var COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT = [
+	CountryCodes.Australia,
+	CountryCodes.Canada,
+	CountryCodes.Gibraltar,
+	CountryCodes.HongKong,
+	CountryCodes.NewZealand,
+	CountryCodes.PuertoRico,
+	CountryCodes.Singapore,
+	CountryCodes.UnitedStates,
+	CountryCodes.Guernsey,
+	CountryCodes.Jersey,
+	CountryCodes.IsleOfMan,
+	CountryCodes.Mexico,
+	CountryCodes.Brazil,
+	CountryCodes.Japan
+];
+var COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES = [];
+var COUNTRIES_THAT_REQUIRE_DATE_OF_INCORPORATION = [CountryCodes.HongKong, CountryCodes.Singapore];
+var COUNTRIES_THAT_USES_UEN_OR_GST = [CountryCodes.Singapore];
+var COUNTRIES_REQUIRING_FINANCIAL_INFORMATION = [
+	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
+];
+var COUNTRIES_REQUIRING_E_INVOICING_CODE = [CountryCodes.Italy];
+var COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4 = [CountryCodes.Australia];
+var TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION = [
+	CountryCodes.Austria,
+	CountryCodes.Belgium,
+	CountryCodes.Croatia,
+	CountryCodes.Cyprus,
+	CountryCodes.Germany,
+	CountryCodes.Greece,
+	CountryCodes.Ireland,
+	CountryCodes.Luxembourg,
+	CountryCodes.Malta,
+	CountryCodes.Netherlands,
+	CountryCodes.Slovakia,
+	CountryCodes.Slovenia
+];
+/**
+* Sole proprietorship specific rules
+*/
+var COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION = [
+	CountryCodes.Australia,
+	CountryCodes.Gibraltar,
+	CountryCodes.Guernsey,
+	CountryCodes.HongKong,
+	CountryCodes.Ireland,
+	CountryCodes.IsleOfMan,
+	CountryCodes.Jersey,
+	CountryCodes.Malta,
+	CountryCodes.PuertoRico,
+	CountryCodes.Spain,
+	CountryCodes.UnitedKingdom,
+	CountryCodes.UnitedStates
+];
+var COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS = [
+	CountryCodes.Canada,
+	CountryCodes.PuertoRico,
+	CountryCodes.UnitedStates
+];
+var COUNTRIES_WITH_POSSIBLE_REGISTRATION_EXEMPTIONS_FOR_SOLE_PROPS = [
+	CountryCodes.Austria,
+	CountryCodes.Canada,
+	CountryCodes.Finland,
+	CountryCodes.Germany,
+	CountryCodes.Lithuania,
+	CountryCodes.Luxembourg,
+	CountryCodes.NewZealand,
+	CountryCodes.Poland,
+	CountryCodes.Sweden,
+	CountryCodes.Switzerland
+];
+var COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP = [CountryCodes.Singapore];
+var COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS = [CountryCodes.Germany];
+//#endregion
 //#region src/components/Shared/fields/TaxInformationField/taxIdNumberTypes.ts
 var restrictedEntityTypes = [
 	CompanyTypesValues.SOLE_PROPRIETORSHIP,
@@ -2033,6 +2237,14 @@ var getTaxIdNumberOptions = (country, companyType) => {
 	if (isRestrictedEntityType(companyType)) return optionsForCountry.filter((option) => option.applicableOnlyFor?.includes(companyType) ?? true);
 	return optionsForCountry.filter((option) => !isApplicableOnlyForSingleRestrictedType(option));
 };
+var getTaxIdNumberSelectorOptions = (country, companyType, exemptedOptionLabel) => {
+	const availableOptions = getTaxIdNumberOptions(country, companyType) ?? [];
+	if (availableOptions.length === 0 || !exemptedOptionLabel) return availableOptions;
+	return [...availableOptions, {
+		id: "exempted",
+		name: exemptedOptionLabel
+	}];
+};
 function getValidCompanyTypesForTaxIdNumberType(country, taxIdNumberType) {
 	if (!taxIdNumberType) return void 0;
 	const taxIdOption = taxIdNumberOptions[country]?.find((option) => option.id === taxIdNumberType);
@@ -2099,154 +2311,6 @@ function getDefaultTaxIdNumberType(taxInformation, country, entityType) {
 	return existingTaxInformation?.type ?? (existingTaxInformation?.number ? inferTaxIdNumberType(taxInformation, country, entityType) : getTaxIdNumberOptions(country, entityType)?.[0]?.id);
 }
 //#endregion
-//#region src/components/Business/forms/rules.constants.ts
-/**
-* Source of truth for registration-number exemption eligibility in Business Details.
-*
-* This map defines which organization entity types can use
-* `exemptedFromRegistrationNumber`, grouped by country. All exemption checks should
-* be derived from this structure to keep behavior consistent across form rules.
-*
-* Interpretation:
-* - Non-empty array: exemption is allowed only for the listed entity types.
-* - Empty array: exemption is allowed for that country without entity-type restrictions.
-*
-*/
-var REGISTRATION_NUMBER_EXEMPTION_RULES = {
-	[CountryCodes.Australia]: [CompanyTypesValues.GOVERNMENTAL_ORGANIZATION, CompanyTypesValues.INCORPORATED_PARTNERSHIP],
-	[CountryCodes.Denmark]: [CompanyTypesValues.NON_PROFIT_OR_CHARITABLE],
-	[CountryCodes.Germany]: [CompanyTypesValues.GOVERNMENTAL_ORGANIZATION, CompanyTypesValues.NON_PROFIT_OR_CHARITABLE],
-	[CountryCodes.HongKong]: [],
-	[CountryCodes.NewZealand]: []
-};
-/**
-* @description Countries in this list use the provider-backed company search flow.
-* For these countries, business details can be prefilled from provider results,
-* and search/verification may require tax identifiers (for example TIN or VAT)
-* in addition to company name/registration details.
-*
-* If a country is in this list, it means it will attempt to make an api call for company search.
-* If the api doesnt have a provider for that country, it will return no results like below
-* ```
-* {
-*   "results": [],
-*   "provider": "NO_PROVIDER"
-* }
-* ```
-*/
-var COUNTRIES_USING_COMPANY_SEARCH = [
-	CountryCodes.UnitedStates,
-	CountryCodes.UnitedKingdom,
-	CountryCodes.Germany,
-	CountryCodes.France
-];
-var COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION = [
-	CountryCodes.HongKong,
-	CountryCodes.Mexico,
-	CountryCodes.PuertoRico,
-	CountryCodes.UnitedStates
-];
-var COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER = [CountryCodes.Canada, CountryCodes.UnitedStates];
-/**
-*  Also used to determine what documenttype needs to be used
-*  when uploading tax document in mapping.ts
-* */
-var COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT = [
-	CountryCodes.Australia,
-	CountryCodes.Canada,
-	CountryCodes.Gibraltar,
-	CountryCodes.HongKong,
-	CountryCodes.NewZealand,
-	CountryCodes.PuertoRico,
-	CountryCodes.Singapore,
-	CountryCodes.UnitedStates,
-	CountryCodes.Guernsey,
-	CountryCodes.Jersey,
-	CountryCodes.IsleOfMan,
-	CountryCodes.Mexico,
-	CountryCodes.Brazil,
-	CountryCodes.Japan
-];
-var COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES = [];
-var COUNTRIES_THAT_REQUIRE_DATE_OF_INCORPORATION = [CountryCodes.HongKong, CountryCodes.Singapore];
-var COUNTRIES_THAT_USES_UEN_OR_GST = [CountryCodes.Singapore];
-var COUNTRY_OF_GOVERNING_LAW_POSSIBLE = [CountryCodes.UnitedKingdom];
-var COUNTRIES_REQUIRING_FINANCIAL_INFORMATION = [
-	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
-];
-var COUNTRIES_REQUIRING_E_INVOICING_CODE = [CountryCodes.Italy];
-var COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4 = [CountryCodes.Australia];
-var TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION = [
-	CountryCodes.Austria,
-	CountryCodes.Belgium,
-	CountryCodes.Croatia,
-	CountryCodes.Cyprus,
-	CountryCodes.Germany,
-	CountryCodes.Greece,
-	CountryCodes.Ireland,
-	CountryCodes.Luxembourg,
-	CountryCodes.Malta,
-	CountryCodes.Netherlands,
-	CountryCodes.Slovakia,
-	CountryCodes.Slovenia
-];
-/**
-* Sole proprietorship specific rules
-*/
-var COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION = [
-	CountryCodes.Australia,
-	CountryCodes.Gibraltar,
-	CountryCodes.Guernsey,
-	CountryCodes.HongKong,
-	CountryCodes.Ireland,
-	CountryCodes.IsleOfMan,
-	CountryCodes.Jersey,
-	CountryCodes.Malta,
-	CountryCodes.PuertoRico,
-	CountryCodes.Spain,
-	CountryCodes.UnitedKingdom,
-	CountryCodes.UnitedStates
-];
-var COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS = [
-	CountryCodes.Canada,
-	CountryCodes.PuertoRico,
-	CountryCodes.UnitedStates
-];
-var COUNTRIES_WITH_POSSIBLE_REGISTRATION_EXEMPTIONS_FOR_SOLE_PROPS = [
-	CountryCodes.Austria,
-	CountryCodes.Canada,
-	CountryCodes.Finland,
-	CountryCodes.Germany,
-	CountryCodes.Lithuania,
-	CountryCodes.Luxembourg,
-	CountryCodes.NewZealand,
-	CountryCodes.Poland,
-	CountryCodes.Sweden,
-	CountryCodes.Switzerland
-];
-var COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP = [CountryCodes.Singapore];
-var COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS = [CountryCodes.Germany];
-//#endregion
 //#region src/components/Shared/fields/TaxInformationField/TaxIdNumberTypeSelector/TaxIdNumberTypeSelector.tsx
 function TaxIdNumberTypeSelector({ country, companyType, selected, setSelected, exemptedOptionLabel, isUsSoleProp, errorMessage }) {
 	const { t } = useTranslation("common");
@@ -2258,14 +2322,7 @@ function TaxIdNumberTypeSelector({ country, companyType, selected, setSelected,
 		}
 		setSelected(newSelected);
 	}, [exemptedOptionLabel, setSelected]);
-	const options = useMemo(() => {
-		const availableOptions = getTaxIdNumberOptions(country, companyType) ?? [];
-		if (availableOptions.length === 0 || !exemptedOptionLabel) return availableOptions;
-		return [...availableOptions, {
-			id: "exempted",
-			name: exemptedOptionLabel
-		}];
-	}, [
+	const options = useMemo(() => getTaxIdNumberSelectorOptions(country, companyType, exemptedOptionLabel), [
 		country,
 		companyType,
 		exemptedOptionLabel
@@ -2312,4 +2369,464 @@ function removeTaxInfoForCountry(taxInformation, country) {
 	return taxInformation?.filter((t) => t.country !== country);
 }
 //#endregion
-export { taxInformationDefaultFieldMetadata as A, getTaxIdNumberOptions as C, exemptedFromTaxDefaultFieldMetadata as D, exemptedFromTaxDefaultFieldConfig as E, businessRegistrationNumberMasks as M, stateFormatGuidanceText as N, getTaxInformationPlaceholderText as O, getDefaultTaxIdNumberType as S, taxIdNumberOptions as T, COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS as _, COUNTRIES_REQUIRING_FINANCIAL_INFORMATION as a, REGISTRATION_NUMBER_EXEMPTION_RULES as b, COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP as c, COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT as d, COUNTRIES_USING_COMPANY_SEARCH as f, COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES as g, COUNTRIES_WITH_POSSIBLE_REGISTRATION_EXEMPTIONS_FOR_SOLE_PROPS as h, COUNTRIES_REQUIRING_E_INVOICING_CODE as i, businessRegistrationNumberPatterns as j, taxInformationDefaultFieldConfig as k, COUNTRIES_THAT_REQUIRE_DATE_OF_INCORPORATION as l, COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS as m, upsertTaxInfoForCountry as n, COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION as o, COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER as p, TaxIdNumberTypeSelector as r, COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION as s, removeTaxInfoForCountry as t, COUNTRIES_THAT_USES_UEN_OR_GST as u, COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4 as v, getValidCompanyTypesForTaxIdNumberType as w, TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION as x, COUNTRY_OF_GOVERNING_LAW_POSSIBLE as y };
+//#region src/components/Shared/fields/TaxInformationField/TaxInformationField.tsx
+var TAX_INFORMATION_FIELD = [
+	"taxInformation",
+	"exemptedFromTax",
+	"isUen"
+];
+/**
+* Renders a dynamic form field for tax identification information, adapting its display
+* and behavior based on country and company type. It supports various tax ID input
+* scenarios, including two specialized handling for US Sole Proprietorships (where SSN option acts as exemption selection)
+* and Singapore Companies (where registration number (UEN) can be used for tax ID).
+*/
+function TaxInformationField({ data, valid, errors, labels, mask, placeholder, readonly, optional, shouldValidate, handleChangeFor, country, canExempt, registrationNumber, entityType, defaultData }) {
+	const { isFeatureEnabled } = useToggleContext();
+	const { t } = useTranslation("common");
+	const { accountHolder } = useAccountHolder();
+	const currentCountryTaxInformation = useMemo(() => data?.taxInformation?.find((taxInfo) => taxInfo.country === country) ?? (!data.exemptedFromTax ? defaultData?.find((taxInfo) => taxInfo.country === country) : void 0), [
+		data?.taxInformation,
+		data.exemptedFromTax,
+		defaultData,
+		country
+	]);
+	const isUsSoleProp = country === "US" && entityType === CompanyTypesValues.SOLE_PROPRIETORSHIP;
+	const options = getTaxIdNumberOptions(country, entityType);
+	const showTaxIdExemptedOptions = canExempt && (options?.length ?? 0) > 1 || isUsSoleProp;
+	const canSaveAbsentState = isFeatureEnabled("EnableRegistrationAndTaxAbsentStatesV4") && COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4.includes(country) && accountHolder === "aTrust";
+	const exemptionLabel = isUsSoleProp ? t(($) => $["socialSecurityNumber"]) : labels.exemptedFromTax;
+	const selectorOptions = getTaxIdNumberSelectorOptions(country, entityType, showTaxIdExemptedOptions ? exemptionLabel : void 0);
+	const shouldRenderInput = isUsSoleProp ? currentCountryTaxInformation?.type === "EIN" : !data.isUen;
+	const taxIdNumberType = useMemo(() => {
+		if (data.exemptedFromTax) return "exempted";
+		if (currentCountryTaxInformation?.type) return currentCountryTaxInformation.type;
+		if (isUsSoleProp) return void 0;
+		return getDefaultTaxIdNumberType(data.taxInformation, country, entityType);
+	}, [
+		country,
+		currentCountryTaxInformation?.type,
+		data.exemptedFromTax,
+		data.taxInformation,
+		entityType,
+		isUsSoleProp
+	]);
+	const shouldDisplayErrorOnSelector = selectorOptions.length > 1 && taxIdNumberType === void 0;
+	const selectorError = shouldDisplayErrorOnSelector ? errors.taxInformation : void 0;
+	const inputError = shouldDisplayErrorOnSelector ? void 0 : errors.taxInformation;
+	const fieldMetadata = resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
+		taxIdNumberType: currentCountryTaxInformation?.type,
+		companyType: entityType
+	}, taxInformationDefaultFieldMetadata);
+	const updateTaxInfo = useCallback((mode, newEntry) => {
+		const entry = canSaveAbsentState ? {
+			...newEntry,
+			numberAbsent: newEntry.numberAbsent ?? false
+		} : newEntry;
+		handleChangeFor("taxInformation", mode)(upsertTaxInfoForCountry(data.taxInformation, country, entry));
+	}, [
+		canSaveAbsentState,
+		country,
+		data.taxInformation,
+		handleChangeFor
+	]);
+	const updateTaxType = useCallback((type, mode) => {
+		updateTaxInfo(mode, {
+			country,
+			number: currentCountryTaxInformation?.number,
+			type
+		});
+	}, [
+		country,
+		currentCountryTaxInformation?.number,
+		updateTaxInfo
+	]);
+	const resetToDefaultData = useCallback(() => {
+		if (defaultData !== void 0) handleChangeFor("taxInformation", "input")(defaultData);
+	}, [defaultData, handleChangeFor]);
+	const removeCountryTaxInfo = useCallback(() => {
+		handleChangeFor("taxInformation", "input")(removeTaxInfoForCountry(data.taxInformation, country));
+	}, [
+		country,
+		data.taxInformation,
+		handleChangeFor
+	]);
+	const setUenAsTaxId = useCallback((uen) => {
+		updateTaxInfo("blur", {
+			country,
+			number: uen ?? "",
+			type: "UEN"
+		});
+	}, [country, updateTaxInfo]);
+	const addTaxAbsentStatus = useCallback((exempted) => {
+		handleChangeFor("taxInformation", "input")(upsertTaxInfoForCountry(data.taxInformation, country, {
+			country,
+			numberAbsent: exempted
+		}));
+	}, [
+		country,
+		data.taxInformation,
+		handleChangeFor
+	]);
+	const handleTaxNumberChange = useCallback((e, mode) => {
+		updateTaxInfo(mode, {
+			country,
+			number: e ? typeof e === "string" ? e : e.currentTarget.value : void 0,
+			type: currentCountryTaxInformation?.type ?? (taxIdNumberType !== "exempted" ? taxIdNumberType : void 0)
+		});
+	}, [
+		country,
+		currentCountryTaxInformation?.type,
+		taxIdNumberType,
+		updateTaxInfo
+	]);
+	const handleTaxIdNumberTypeChange = useCallback((taxIdType) => {
+		if (!canExempt && taxIdType === "exempted") throw Error(`${country} does not allow tax exemptions`);
+		if (taxIdType === "exempted") {
+			handleChangeFor("exemptedFromTax")(true);
+			updateTaxType(void 0, "input");
+			return canSaveAbsentState ? addTaxAbsentStatus(true) : removeCountryTaxInfo();
+		}
+		handleChangeFor("exemptedFromTax")(false);
+		if (country === "SG") if (taxIdType === "UEN") {
+			handleChangeFor("isUen")(true);
+			setUenAsTaxId(registrationNumber);
+		} else {
+			handleChangeFor("isUen")(false);
+			removeCountryTaxInfo();
+		}
+		updateTaxType(taxIdType, "input");
+	}, [
+		addTaxAbsentStatus,
+		canExempt,
+		canSaveAbsentState,
+		country,
+		handleChangeFor,
+		updateTaxType,
+		registrationNumber,
+		removeCountryTaxInfo,
+		setUenAsTaxId
+	]);
+	const handleExemptedFromTaxChange = useCallback((exempted) => {
+		handleChangeFor("exemptedFromTax")(exempted);
+		if (canSaveAbsentState) addTaxAbsentStatus(exempted);
+		else removeCountryTaxInfo();
+	}, [
+		addTaxAbsentStatus,
+		canSaveAbsentState,
+		handleChangeFor,
+		removeCountryTaxInfo
+	]);
+	const prevCountryRef = useRef(country);
+	useEffect(() => {
+		if (!country || prevCountryRef.current === country) return;
+		prevCountryRef.current = country;
+		const hasSavedTaxId = defaultData?.find((taxId) => taxId.country === country);
+		if (currentCountryTaxInformation && !hasSavedTaxId) return;
+		if (entityType === CompanyTypesValues.SOLE_PROPRIETORSHIP) return;
+		resetToDefaultData();
+	}, [country]);
+	useEffect(() => {
+		if (country === "SG" && data.isUen && registrationNumber && registrationNumber !== currentCountryTaxInformation?.number) setUenAsTaxId(registrationNumber);
+	}, [
+		registrationNumber,
+		currentCountryTaxInformation?.number,
+		data.isUen,
+		country,
+		setUenAsTaxId
+	]);
+	const isInitialized = useRef(false);
+	if (!isInitialized.current && country === "SG" && !defaultData?.find((taxInfo) => taxInfo.country === country)?.number) {
+		isInitialized.current = true;
+		handleChangeFor("isUen")(false);
+	}
+	return /* @__PURE__ */ jsxs("div", { children: [
+		/* @__PURE__ */ jsx(TaxIdNumberTypeSelector, {
+			country,
+			companyType: entityType,
+			setSelected: handleTaxIdNumberTypeChange,
+			selected: taxIdNumberType,
+			exemptedOptionLabel: showTaxIdExemptedOptions ? exemptionLabel : void 0,
+			isUsSoleProp,
+			errorMessage: selectorError
+		}),
+		shouldRenderInput && /* @__PURE__ */ jsx(MaskedInput, {
+			type: "text",
+			"aria-required": true,
+			"aria-invalid": !valid.taxInformation,
+			name: "taxInformation",
+			label: labels.taxInformation ?? "",
+			formatGuidance: translateTranslatable(t, fieldMetadata.guidanceText),
+			value: currentCountryTaxInformation?.number ?? "",
+			errorMessage: inputError,
+			placeholder,
+			isValid: Boolean(valid.taxInformation) && !!currentCountryTaxInformation,
+			onInput: (e) => handleTaxNumberChange(e, "input"),
+			onBlur: (e) => handleTaxNumberChange(e, "blur"),
+			disabled: data.exemptedFromTax || data.isUen,
+			readonly,
+			optional,
+			shouldValidate,
+			...mask
+		}),
+		canExempt && !showTaxIdExemptedOptions && /* @__PURE__ */ jsx(Field, {
+			name: "exemptedFromTax",
+			children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+				...childProps,
+				"aria-required": false,
+				"aria-invalid": false,
+				name: "exemptedFromTax",
+				label: labels.exemptedFromTax,
+				value: "exemptedFromTax",
+				checked: Boolean(data.exemptedFromTax),
+				onChange: handleExemptedFromTaxChange
+			})
+		})
+	] });
+}
+var Tile_module_default = {
+	"tile-container": "_tile-container_685mc_1",
+	tileContainer: "_tile-container_685mc_1",
+	tile: "_tile_685mc_1",
+	"tile-icon": "_tile-icon_685mc_18",
+	tileIcon: "_tile-icon_685mc_18",
+	"tile-title": "_tile-title_685mc_35",
+	tileTitle: "_tile-title_685mc_35",
+	"tile-checkbox": "_tile-checkbox_685mc_49",
+	tileCheckbox: "_tile-checkbox_685mc_49",
+	"tile-container-horizontal": "_tile-container-horizontal_685mc_89",
+	tileContainerHorizontal: "_tile-container-horizontal_685mc_89",
+	"tile-label": "_tile-label_685mc_100",
+	tileLabel: "_tile-label_685mc_100"
+};
+//#endregion
+//#region src/components/ui/atoms/Tile/Tile.tsx
+function Tile({ checked, disabled, icon, id, inputType = "checkbox", isHorizontal, label, name, className, onChange, subTitle, value }) {
+	const inputNode = useRef(null);
+	const uniqId = useId("tile");
+	const idUse = id ?? uniqId;
+	const handleChange = (e) => {
+		if (disabled) return;
+		onChange?.(e.currentTarget.checked);
+		inputNode.current?.focus();
+	};
+	const handleClick = (e) => {
+		if (disabled || inputType === "radio") return;
+		if (checked) {
+			e.preventDefault();
+			onChange?.(false);
+			inputNode.current?.focus();
+		}
+	};
+	const handleOnKeyDown = (e) => {
+		if (e.key === KEYBOARD_KEYS.enter || e.key === KEYBOARD_KEYS.space) {
+			e.preventDefault();
+			if (disabled) return;
+			if (inputType === "radio" && !checked) {
+				onChange?.(true);
+				inputNode.current?.focus();
+			} else if (inputType === "checkbox") {
+				onChange?.(!checked);
+				inputNode.current?.focus();
+			}
+		}
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: cx(Tile_module_default.tileContainer, className, { [Tile_module_default.tileContainerHorizontal]: isHorizontal }),
+		children: [/* @__PURE__ */ jsx("input", {
+			ref: inputNode,
+			className: Tile_module_default.tileCheckbox,
+			disabled,
+			checked: !!checked,
+			value,
+			id: idUse,
+			name,
+			type: inputType,
+			onKeyDown: handleOnKeyDown,
+			onChange: handleChange,
+			onClick: handleClick,
+			"aria-disabled": disabled,
+			tabIndex: disabled ? -1 : 0
+		}), /* @__PURE__ */ jsxs("label", {
+			htmlFor: idUse,
+			className: Tile_module_default.tile,
+			children: [icon && /* @__PURE__ */ jsx("div", {
+				className: Tile_module_default.tileIcon,
+				children: /* @__PURE__ */ jsx(Icon, {
+					name: icon,
+					testId: icon
+				})
+			}), /* @__PURE__ */ jsxs("div", {
+				className: Tile_module_default.tileLabel,
+				children: [/* @__PURE__ */ jsx(Typography, {
+					el: "h4",
+					variant: "body-strongest",
+					className: Tile_module_default.tileTitle,
+					children: label
+				}), subTitle && /* @__PURE__ */ jsx(Typography, {
+					el: "p",
+					variant: "body",
+					children: subTitle
+				})]
+			})]
+		})]
+	});
+}
+var TileGroup_module_default = {
+	"tile-group": "_tile-group_6rtof_1",
+	tileGroup: "_tile-group_6rtof_1",
+	"tile-container": "_tile-container_6rtof_8",
+	tileContainer: "_tile-container_6rtof_8",
+	"tile-group-error": "_tile-group-error_6rtof_14",
+	tileGroupError: "_tile-group-error_6rtof_14",
+	"tile-group-error-icon": "_tile-group-error-icon_6rtof_27",
+	tileGroupErrorIcon: "_tile-group-error-icon_6rtof_27",
+	"tile-group-horizontal": "_tile-group-horizontal_6rtof_32",
+	tileGroupHorizontal: "_tile-group-horizontal_6rtof_32"
+};
+//#endregion
+//#region src/components/ui/atoms/TileGroup/TileGroup.tsx
+function TileGroup({ tiles, selected, allowMultiple = false, isHorizontal, name: nameProp, maxSelected = Infinity, errorMessage, onChange = noop, enableTracking = false, trackingFieldName }) {
+	const uniqName = useId("tile");
+	const name = nameProp ?? uniqName;
+	const finalName = allowMultiple ? `${name}[]` : name;
+	const inputType = allowMultiple ? "checkbox" : "radio";
+	const userEvents = useAnalyticsContext();
+	return /* @__PURE__ */ jsxs(Fragment, { children: [!!errorMessage?.message && /* @__PURE__ */ jsxs("div", {
+		"aria-live": "polite",
+		className: TileGroup_module_default.tileGroupError,
+		children: [/* @__PURE__ */ jsx("span", {
+			className: TileGroup_module_default.tileGroupErrorIcon,
+			children: /* @__PURE__ */ jsx(Icon, { name: "field-error" })
+		}), errorMessage.message]
+	}), /* @__PURE__ */ jsx("div", {
+		className: cx(TileGroup_module_default.tileGroup, { [TileGroup_module_default.tileGroupHorizontal]: isHorizontal }),
+		children: tiles.map((tile) => {
+			const { value, id, icon, subTitle, label, disabled } = tile;
+			const handleChange = (checked) => {
+				const newSelected = updateSelectedChoices(tile, checked, selected, allowMultiple);
+				if (enableTracking) userEvents.addFieldEvent("Interacted with form field", {
+					actionType: "input",
+					field: trackingFieldName ?? name,
+					returnValue: typeof newSelected === "string" ? newSelected : void 0
+				});
+				onChange(newSelected);
+			};
+			return /* @__PURE__ */ jsx(Tile, {
+				name: finalName,
+				className: TileGroup_module_default.tileContainer,
+				inputType,
+				isHorizontal,
+				checked: choiceIsSelected(tile, selected, allowMultiple),
+				label,
+				id,
+				subTitle,
+				icon,
+				disabled: !disabled && allowMultiple && selected.length >= maxSelected ? !choiceIsSelected(tile, selected, allowMultiple) : disabled,
+				value,
+				onChange: handleChange
+			}, id);
+		})
+	})] });
+}
+function choiceIsSelected({ value }, selected, allowMultiple) {
+	if (!allowMultiple) return value === selected;
+	return selected.includes(value);
+}
+function updateSelectedChoices({ value }, checked, selected, allowMultiple) {
+	if (!allowMultiple) return checked ? value : "";
+	if (Array.isArray(selected)) {
+		if (checked) return allowMultiple ? [...selected, value] : [value];
+		return selected.filter((selectedChoice) => selectedChoice !== value);
+	}
+	return [];
+}
+//#endregion
+//#region src/components/Individual/forms/IdNowVerificationModal/isIdNowModalOpen.ts
+var showIdNowModal = signal(false);
+var idNowModalChildEntityId = signal();
+var idNowPostSubmit = signal(false);
+var shouldShowIdNowModal = computed(() => {
+	const idNowModalChildEntityIdValue = !!idNowModalChildEntityId.value;
+	return showIdNowModal.value && idNowModalChildEntityIdValue;
+});
+//#endregion
+//#region src/components/Individual/helpers/bafinUtils.ts
+/**
+* Checks whether the legal entity has both required data points for IDnow verification:
+* birth city (placeOfBirth) and nationality.
+*/
+var hasRequiredDataForIdNow = (legalEntity) => Boolean(legalEntity.individual?.birthData?.placeOfBirth && legalEntity.individual?.nationality);
+/**
+* For an IDnow-qualified BAFIN signatory, returns an object describing which of the required
+* data points (placeOfBirth, nationality) are still missing, or `{ missingSelfie: true }` when
+* both are present but the selfie verification is still needed, or `null` when no action is needed.
+*
+* Returns `null` when any of the following conditions are true:
+* - The entity is not a signatory, or the L_BAFIN scenario is not active
+* - The `2_215` (live-selfie) remediation code is absent from problems
+*/
+var getIdNowMissingDataPoints = (problems, legalEntity, scenarios, roles) => {
+	if (!roles.includes(DecisionMakerTypes.SIGNATORY) || !scenarios?.includes(Scenarios.L_BAFIN)) return null;
+	if (!problems) return null;
+	if (!problems.missingData?.some((item) => item.remediatingActions?.some((action) => action.code === "2_215"))) return null;
+	const missingPlaceOfBirth = !legalEntity.individual?.birthData?.placeOfBirth;
+	const missingNationality = !legalEntity.individual?.nationality;
+	if (!missingPlaceOfBirth && !missingNationality) return { missingSelfie: true };
+	return {
+		missingPlaceOfBirth,
+		missingNationality
+	};
+};
+/**
+* For the BAFIN signatory flow, certain ID verification errors and remediation actions are not applicable.
+* This utility function takes a problems object and returns a new, deeply cloned object with all
+* ID verification-related issues removed.
+*
+* Specifically, it removes:
+* - 'missingData' entries related to ID document upload ('1_301').
+* - The '1_301' remediation action from `remediationActions`.
+* - The entire `idVerificationMethod` object from `verificationErrors`.
+* - Any nested sub-errors with code '1_301' from `basicDetails` and `additionalPersonalDetails`.
+*
+* @param problems - The original entity problems object.
+* @returns A new `EntityProblems` object with BAFIN-specific modifications.
+*/
+var removeIdVerificationProblemsForBafinSignatory = (problems, decisionMakerLe) => {
+	const newProblems = structuredClone(problems);
+	if (newProblems.missingData?.some((item) => item.remediatingActions?.some((action) => action.code === "1_301" || action.code === "2_215"))) {
+		if (hasRequiredDataForIdNow(decisionMakerLe)) setTimeout(() => {
+			idNowModalChildEntityId.value = decisionMakerLe;
+			showIdNowModal.value = true;
+		}, 100);
+	}
+	if (Array.isArray(newProblems.missingData)) newProblems.missingData = newProblems.missingData.filter((item) => !item.remediatingActions?.some((action) => action.code === "1_301" || action.code === "2_215"));
+	if (newProblems.remediationActions?.["1_301"]) delete newProblems.remediationActions["1_301"];
+	if (newProblems.remediationActions?.["2_215"]) delete newProblems.remediationActions["2_215"];
+	if (newProblems.verificationErrors?.idVerificationMethod) delete newProblems.verificationErrors.idVerificationMethod;
+	["basicDetails", "additionalPersonalDetails"].forEach((formName) => {
+		const subErrors = newProblems.verificationErrors?.[formName]?.["1_30"]?.["1_3000"];
+		if (newProblems.verificationErrors?.[formName]?.["1_30"] && Array.isArray(subErrors)) newProblems.verificationErrors[formName]["1_30"]["1_3000"] = subErrors.filter((error) => error.code !== "1_301");
+	});
+	return newProblems;
+};
+/**
+* Type guard to check if the data object is a LegalEntityAssociation.
+*/
+var isLegalEntityAssociation = (data) => "legalEntityId" in data;
+/**
+* Checks if the current context matches the specific flow for a BAFIN signatory.
+* This is true when the task is for a decision maker, their role is 'signatory',
+* and the BAFIN scenario is active.
+*
+* @param params - The parameters for the check.
+* @returns `true` if the conditions for the BAFIN signatory flow are met.
+*/
+var isBafinSignatoryFlow = ({ taskType, data, scenarios }) => {
+	if (!data || !scenarios) return false;
+	const isSignatory = isLegalEntityAssociation(data) ? data.type === DecisionMakerTypes.SIGNATORY : data.basicDetails?.role?.includes(DecisionMakerTypes.SIGNATORY);
+	if (taskType === TaskTypes.DECISION_MAKER && isSignatory) return scenarios.includes(Scenarios.L_BAFIN);
+	return false;
+};
+//#endregion
+export { COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_SOLE_PROPS as A, businessRegistrationNumberMasks as B, COUNTRIES_THAT_REQUIRE_DATE_OF_INCORPORATION as C, COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER_SOLE_PROPS as D, COUNTRIES_WITH_OPTIONAL_REGISTRATION_NUMBER as E, exemptedFromTaxDefaultFieldMetadata as F, toFullWidth as H, getTaxInformationPlaceholderText as I, taxInformationDefaultFieldConfig as L, REGISTRATION_NUMBER_EXEMPTION_RULES as M, TAX_ID_REQUIRED_COUNTRIES_ORGANIZATION as N, COUNTRIES_WITH_POSSIBLE_REGISTRATION_EXEMPTIONS_FOR_SOLE_PROPS as O, exemptedFromTaxDefaultFieldConfig as P, taxInformationDefaultFieldMetadata as R, COUNTRIES_THAT_DO_NOT_USE_TAX_ID_FOR_SOLE_PROP as S, COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT as T, isJapanLocalizationEnabled as U, stateFormatGuidanceText as V, CompanyTypesValues as W, taxIdNumberOptions as _, idNowPostSubmit as a, COUNTRIES_THAT_DONT_REQUIRE_COMPANY_REGISTRATION as b, TileGroup as c, removeTaxInfoForCountry as d, upsertTaxInfoForCountry as f, getValidCompanyTypesForTaxIdNumberType as g, getTaxIdNumberOptions as h, idNowModalChildEntityId as i, COUNTRIES_WITH_POSSIBLE_TRUSTEE_TAXID_ABSENT_V4 as j, COUNTRIES_WITH_POSSIBLE_TAX_EXEMPTION_FOR_COMPANIES as k, TAX_INFORMATION_FIELD as l, getDefaultTaxIdNumberType as m, isBafinSignatoryFlow as n, shouldShowIdNowModal as o, TaxIdNumberTypeSelector as p, removeIdVerificationProblemsForBafinSignatory as r, showIdNowModal as s, getIdNowMissingDataPoints as t, TaxInformationField as u, COUNTRIES_REQUIRING_E_INVOICING_CODE as v, COUNTRIES_THAT_USES_UEN_OR_GST as w, COUNTRIES_THAT_DONT_REQUIRE_SOLE_PROP_REGISTRATION as x, COUNTRIES_REQUIRING_FINANCIAL_INFORMATION as y, businessRegistrationNumberPatterns as z };