@adyen/kyc-components 4.0.1 → 4.2.0-beta.0

package/dist/fieldConfigurations-D99U6JIQ.js

@@ -1,1402 +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] = "69d8f98d-eaa3-4e35-88f9-d55cab1a9629", e._sentryDebugIdIdentifier = "sentry-dbid-69d8f98d-eaa3-4e35-88f9-d55cab1a9629");
-  } catch (e) {
-  }
-}
-;
-import { c as useLegalEntity, R as ROOT_LE, p as useExperimentsContext, az as getCapabilityProblems, g as getLegalEntityCountry, aA as cloneObject, C as CountryCodes, aB as hasText, aC as isValidMinLength, aD as matchesRegex, X as isEmpty, aE as NO_ALPHABET_REGEX, aF as EMOJI_REGEX, aG as hasRepeatedCharacters, aH as isInvalidName, aI as OTHER_ENTITIES_VALID_CHAR_REGEX, aJ as LATIN_SPACE_MARK_PUNCTUATION_REGEX, aK as standardKatakanaValidator, aL as standardKanjiValidator, a0 as useAnalyticsContext, U as createLogger, u as useTranslation, ay as StateContext, L as Loader, a3 as Icon, H as Typography, Y as IconButton } from "./StoreProvider-l6WD5T55.js";
-import { jsx, jsxs, Fragment } from "preact/jsx-runtime";
-import { a as Alert } from "./Alert-BVHHWVgg.js";
-import cx from "classnames";
-import { useState, useMemo, useEffect, useCallback, useLayoutEffect, useRef } from "preact/hooks";
-import { a as debouncedInputEvent } from "./debouncedInputEvent-Bifj90NU.js";
-import { Suspense, lazy, forwardRef } from "preact/compat";
-import { b as useId } from "./useToastContext-mFlAEux_.js";
-import { R as Radio } from "./CountryField-D36v7bff.js";
-import { F as Field } from "./useForm-C8SA0ETz.js";
-import { K as KEYBOARD_KEYS } from "./Modal-lDK70UQc.js";
-import { u as useForwardedRef, a as InputBase, I as InputText } from "./InputText-DHRZ5RNd.js";
-const useCapabilityProblems = () => {
-  const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
-  const { isExperimentEnabled } = useExperimentsContext();
-  return rootLegalEntity ? getCapabilityProblems(
-    rootLegalEntity,
-    getLegalEntityCountry(rootLegalEntity),
-    isExperimentEnabled
-  ) : void 0;
-};
-const getProblemsForEntity = (capabilityProblems, entityType, entityId) => capabilityProblems[entityType]?.[entityId];
-const TrustedFieldsProviders = {
-  SINGPASS: "singpass",
-  KOMPANY: "kompany"
-};
-const makeArrayOfRepeatedObjects = (length, obj) => {
-  const array = [];
-  for (let i = 0; i < length; i += 1) {
-    array.push(cloneObject(obj));
-  }
-  return array;
-};
-const 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;
-};
-const 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) {
-      const laterToken = inputOnlyMask[i];
-      if (laterToken.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;
-  });
-};
-const 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].currentValue === null) {
-    return "notPossible";
-  }
-  const emptyInputsAfter = normalizedInputTokens.slice(fromIndex + 1).filter((t) => !t.currentValue);
-  if (shiftDistance > emptyInputsAfter.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;
-    }
-  }
-  const allValid = normalizedInputTokens.every((token) => {
-    if (!token.potentialValue) {
-      return token.optional;
-    }
-    return token.allow?.test(token.potentialValue) ?? true;
-  });
-  if (!allValid) 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;
-  }
-  const newMatchedTokens = normalizedTokens.slice(0, matchedUpTo).map((token) => ({
-    ...token,
-    char: token.type === "nonInput" ? token.char : token.potentialValue
-  }));
-  const newRemainingTokens = normalizedTokens.slice(matchedUpTo);
-  return {
-    matchedTokens: newMatchedTokens,
-    remainingTokens: newRemainingTokens
-  };
-};
-const nonInputs = (str, options) => Array.from(str).map((char) => ({
-  type: "nonInput",
-  char,
-  includeInValue: options?.includeInValue ?? false,
-  displayEagerly: options?.displayEagerly ?? true
-}));
-const spacer = nonInputs(" ")[0];
-const alphaInputs = (length, optional = false) => makeArrayOfRepeatedObjects(length, { type: "input", allow: /[A-Za-z]/, optional });
-const numericInputs = (length, optional = false) => makeArrayOfRepeatedObjects(length, { type: "input", allow: /\d/, optional });
-const alphanumericInputs = (length, optional = false) => makeArrayOfRepeatedObjects(length, { type: "input", allow: /[\dA-Za-z]/, optional });
-const customInputs = (length, regex, optional = false) => makeArrayOfRepeatedObjects(length, { type: "input", allow: regex, optional });
-const makeMask = (...tokens) => ({
-  tokens,
-  possibleShifts: findPossibleShifts(tokens)
-});
-const isExistingFile = (file) => "existing" in file && file.existing;
-const isNewlyUploadedFile = (file) => !isExistingFile(file);
-function getLocalizedIdDocumentTypeOptions(country) {
-  switch (country) {
-    case CountryCodes.Japan:
-      return [
-        { id: "driversLicense", name: "driversLicense", hasBackPage: true },
-        { id: "passport", name: "passport", hasBackPage: false },
-        { id: "identityCard", name: "identityCard__JP", hasBackPage: true }
-      ];
-    default:
-      return [
-        { id: "driversLicense", name: "driversLicense", hasBackPage: true },
-        { id: "passport", name: "passport", hasBackPage: false },
-        { id: "identityCard", name: "identityCard", hasBackPage: true }
-      ];
-  }
-}
-const isValueObscured = (value) => typeof value === "string" && !!value.match(/[*]{1,}/)?.length;
-const uppercase = (str) => str?.toUpperCase() ?? str;
-const validateNotEmptyOnBlur = {
-  modes: ["blur"],
-  validate: (val) => !isEmpty(val),
-  errorMessage: "fieldIsRequired"
-};
-const validateLegalCompanyName = [
-  {
-    modes: ["blur"],
-    validate: hasText,
-    errorMessage: "fieldIsRequired"
-  },
-  {
-    modes: ["blur"],
-    validate: (input) => !matchesRegex(NO_ALPHABET_REGEX, input),
-    errorMessage: "nameMustContainLetters"
-  },
-  {
-    modes: ["blur"],
-    validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasRepeatedCharacters(input) && isValidMinLength(input, 3) && !isInvalidName(input) && matchesRegex(OTHER_ENTITIES_VALID_CHAR_REGEX, input),
-    errorMessage: "checkForTypos"
-  }
-];
-const validateJaHaniLegalCompanyName = [
-  {
-    modes: ["blur"],
-    validate: hasText,
-    errorMessage: "fieldIsRequired"
-  },
-  {
-    modes: ["blur"],
-    validate: (input) => standardKanjiValidator(input),
-    errorMessage: "nameMustContainLetters"
-  },
-  {
-    modes: ["blur"],
-    validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasRepeatedCharacters(input) && isValidMinLength(input, 3) && !isInvalidName(input) && matchesRegex(OTHER_ENTITIES_VALID_CHAR_REGEX, input),
-    errorMessage: "checkForTypos"
-  }
-];
-const validateJaKanaLegalCompanyName = [
-  {
-    modes: ["blur"],
-    validate: hasText,
-    errorMessage: "fieldIsRequired"
-  },
-  {
-    modes: ["blur"],
-    validate: (input) => standardKatakanaValidator(input),
-    errorMessage: "nameMustContainLetters"
-  },
-  {
-    modes: ["blur"],
-    validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasRepeatedCharacters(input) && isValidMinLength(input, 3) && !isInvalidName(input) && matchesRegex(OTHER_ENTITIES_VALID_CHAR_REGEX, input),
-    errorMessage: "checkForTypos"
-  }
-];
-const validateLatinSpaceMarkPunctuationOnlyOnBlur = {
-  modes: ["blur"],
-  validate: (input) => matchesRegex(LATIN_SPACE_MARK_PUNCTUATION_REGEX, input),
-  errorMessage: "kanjiAndKanaCharactersAreNotAllowed"
-};
-const validatePatternOnBlur = (pattern) => ({
-  modes: ["blur"],
-  validate: (val) => !!val && pattern.test(val)
-});
-function ContextGuidance({
-  title,
-  content,
-  titleId,
-  contentId,
-  trackingParams
-}) {
-  const userEvents = useAnalyticsContext();
-  const onGuidanceToggle = (status) => {
-    userEvents.addFieldEvent("Clicked accordion", {
-      actionType: status,
-      field: "context guidance",
-      label: titleId,
-      content: contentId,
-      ...trackingParams
-    });
-  };
-  return /* @__PURE__ */ jsx(Alert, { title, type: "collapsible", variant: "info", onToggle: onGuidanceToggle, children: content });
-}
-const convertFullToHalf = (str) => str.replace(/[！-～]/g, (r) => String.fromCharCode(r.charCodeAt(0) - 65248));
-const logger = createLogger();
-function TextArea(props) {
-  const {
-    autoCorrect,
-    isInvalid,
-    isValid,
-    readonly = null,
-    spellCheck,
-    disabled,
-    maxLength,
-    className,
-    trimOnBlur,
-    enableTracking = false,
-    name,
-    "aria-describedby": ariaDescribedBy,
-    "aria-invalid": ariaInvalid,
-    "aria-labelledby": ariaLabelledBy
-  } = props;
-  const { t } = useTranslation("ui");
-  const userEvents = useAnalyticsContext();
-  const [value, setValue] = useState("");
-  if (Object.prototype.hasOwnProperty.call(props, "onChange")) {
-    logger.error("Error: Form fields that rely on InputBase may not have an onChange property");
-  }
-  const handleInput = (e) => {
-    if (enableTracking) {
-      debouncedInputEvent(userEvents, {
-        actionType: "input",
-        field: name
-      });
-    }
-    e.currentTarget.value = convertFullToHalf(e.currentTarget.value);
-    setValue(e.currentTarget.value);
-    props?.onInput?.(e);
-  };
-  const handleBlur = (e) => {
-    if (enableTracking) {
-      userEvents.addFieldEvent("Interacted with form field", {
-        actionType: "blur",
-        field: name
-      });
-    }
-    props?.onBlurHandler?.(e);
-    if (trimOnBlur) {
-      e.currentTarget.value = e.currentTarget.value.trim();
-    }
-    props?.onBlur?.(e);
-  };
-  const handleFocus = (e) => {
-    if (enableTracking) {
-      userEvents.addFieldEvent("Interacted with form field", {
-        actionType: "focus",
-        field: name
-      });
-    }
-    props?.onFocusHandler?.(e);
-  };
-  const inputClassNames = cx("adyen-kyc-input", "adyen-kyc-input--textarea", className, {
-    "adyen-kyc-input--invalid": isInvalid,
-    "adyen-kyc-field--valid": isValid,
-    "adyen-kyc-input--disabled": disabled
-  });
-  const charactersLeft = maxLength - value.length;
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(
-      "textarea",
-      {
-        ...props,
-        className: inputClassNames,
-        readOnly: readonly,
-        spellCheck,
-        autoCorrect,
-        "aria-describedby": ariaDescribedBy,
-        "aria-invalid": ariaInvalid,
-        "aria-labelledby": ariaLabelledBy,
-        ...disabled && { "aria-disabled": true },
-        onInput: handleInput,
-        onBlur: handleBlur,
-        onFocus: handleFocus
-      }
-    ),
-    !isInvalid && maxLength && charactersLeft >= 0 ? /* @__PURE__ */ jsx("span", { className: "adyen-kyc-input__counter", children: t(($) => $["xCharactersLeft"], { charactersLeft }) }) : null
-  ] });
-}
-function StateContextSetter({ stateRef }) {
-  if (stateRef.current.setState) {
-    return null;
-  }
-  return /* @__PURE__ */ jsx(StateContext.Consumer, { children: (stateContextValue) => {
-    const { dispatch, setActiveForms } = stateContextValue;
-    stateRef.current.setState = dispatch;
-    stateRef.current.setActiveForms = setActiveForms;
-    return null;
-  } });
-}
-const Image = ({
-  lazyLoadedImage,
-  className
-}) => {
-  const LazyLoadedImageComponent = lazyLoadedImage;
-  return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Loader, {}), children: /* @__PURE__ */ jsx(LazyLoadedImageComponent, { className, "aria-hidden": true }) });
-};
-const getDocumentGuidancePrefix = (documentType) => {
-  switch (documentType) {
-    case "passport":
-      return "passport";
-    case "driversLicense":
-    case "identityCard":
-      return "id";
-    case "bankStatement":
-    case "vatDocument":
-    case "registrationDocument":
-    case "proofOfAddress":
-    case "proofOfResidency":
-    default:
-      return "document";
-  }
-};
-const documentBlurredImage = lazy(() => import("./document-blurred-2Zpodj3_.js"));
-const documentCutOffImage = lazy(() => import("./document-cut-off-ClS7RiOp.js"));
-const documentExpiredImage = lazy(() => import("./document-expired-CjksBq-N.js"));
-const documentFrontImage = lazy(() => import("./document-front-DiAairT3.js"));
-const idBlurredImage = lazy(() => import("./id-blurred-9dzBOWCE.js"));
-const idCutOffImage = lazy(() => import("./id-cut-off-CohJCI2h.js"));
-const idFrontImage = lazy(() => import("./id-front-CSZfvdRg.js"));
-const idGlareImage = lazy(() => import("./id-glare-Q2JWo5ts.js"));
-const passportBlurredImage = lazy(() => import("./passport-blurred-B4UDQfmc.js"));
-const passportCutOffImage = lazy(() => import("./passport-cut-off-C0N2mgLk.js"));
-const passportFrontImage = lazy(() => import("./passport-front-BwA7wR91.js"));
-const passportGlareImage = lazy(() => import("./passport-glare-Mg2ixsYA.js"));
-const documentMap = {
-  "document-blurred": documentBlurredImage,
-  "document-cutoff": documentCutOffImage,
-  "document-expired": documentExpiredImage,
-  "document-front": documentFrontImage,
-  "id-blurred": idBlurredImage,
-  "id-cutoff": idCutOffImage,
-  "id-front": idFrontImage,
-  "id-glare": idGlareImage,
-  "passport-blurred": passportBlurredImage,
-  "passport-cutoff": passportCutOffImage,
-  "passport-front": passportFrontImage,
-  "passport-glare": passportGlareImage
-};
-function DocumentGuidance({ type, className }) {
-  const { t } = useTranslation("ui");
-  const documentGuidanceItems = useMemo(() => {
-    const guidancePrefix = getDocumentGuidancePrefix(type);
-    const guidanceItems = [
-      { svgName: `${guidancePrefix}-front`, translationKey: "good", valid: true },
-      { svgName: `${guidancePrefix}-cutoff`, translationKey: "notCutOff" },
-      { svgName: `${guidancePrefix}-blurred`, translationKey: "notBlurry" },
-      guidancePrefix === "document" ? { svgName: `document-expired`, translationKey: "notExpired" } : { svgName: `${guidancePrefix}-glare`, translationKey: "noGlare" }
-    ];
-    return type === "constitutionalDocument" ? guidanceItems.filter((item) => item.svgName !== "document-expired") : guidanceItems;
-  }, [type]);
-  return /* @__PURE__ */ jsx("div", { className: cx("adyen-kyc-document-guidance", className), children: /* @__PURE__ */ jsx("div", { className: "adyen-kyc-document-guidance__container", children: documentGuidanceItems.map((item) => /* @__PURE__ */ jsxs("figure", { className: "adyen-kyc-document-guidance__item", children: [
-    /* @__PURE__ */ jsx(Image, { lazyLoadedImage: documentMap[item.svgName] }),
-    /* @__PURE__ */ jsxs("figcaption", { className: "adyen-kyc-document-guidance__description", children: [
-      item.valid ? /* @__PURE__ */ jsx(Icon, { name: "check", className: "adyen-kyc-document-guidance__icon" }) : /* @__PURE__ */ jsx(
-        Icon,
-        {
-          name: "cross",
-          className: "adyen-kyc-document-guidance__icon adyen-kyc-document-guidance__icon--invalid"
-        }
-      ),
-      /* @__PURE__ */ jsx("span", { className: "adyen-kyc-document-guidance__description-text", children: t(($) => $[item.translationKey]) })
-    ] })
-  ] }, item.translationKey)) }) });
-}
-function bytesToSize(bytes) {
-  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
-  if (bytes === 0) return "n/a";
-  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)).toString());
-  if (i === 0) return `${bytes} ${sizes[i]}`;
-  return `${(bytes / 1024 ** i).toFixed()} ${sizes[i]}`;
-}
-function DropzoneFile(props) {
-  const { file, errorMessage, onDelete, loading } = props;
-  const { t } = useTranslation("common");
-  const userEvents = useAnalyticsContext();
-  let documentIcon;
-  const formatSize = (bytes) => {
-    const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
-    if (!bytes || bytes === 0) return "n/a";
-    const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)).toString());
-    if (i === 0) return `${bytes} ${sizes[i]}`;
-    return `${(bytes / 1024 ** i).toFixed(1)} ${sizes[i]}`;
-  };
-  switch (file.type?.split("/")[0]) {
-    case "image":
-      documentIcon = "image";
-      break;
-    default:
-      documentIcon = "document";
-  }
-  useEffect(() => {
-    if (!errorMessage) return;
-    userEvents.addFieldEvent("Encountered error", {
-      actionType: "change",
-      field: "dropzone file",
-      returnType: "validation",
-      returnValue: errorMessage
-    });
-  }, [errorMessage, userEvents]);
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      className: cx("adyen-kyc-dropzone-file", { "adyen-kyc-dropzone-file--error": errorMessage }),
-      children: [
-        /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-dropzone-file__details", children: [
-          /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-dropzone-file__labels", children: [
-            errorMessage ? /* @__PURE__ */ jsx(
-              Icon,
-              {
-                testId: "document-invalid",
-                name: "warning",
-                className: "adyen-kyc-dropzone-file__icon"
-              }
-            ) : /* @__PURE__ */ jsx(
-              Icon,
-              {
-                testId: "document-valid",
-                name: documentIcon,
-                className: "adyen-kyc-dropzone-file__icon"
-              }
-            ),
-            /* @__PURE__ */ jsx(Typography, { variant: "body-stronger", className: "adyen-kyc-dropzone-file__name", children: file.name }),
-            /* @__PURE__ */ jsx(Typography, { className: "adyen-kyc-dropzone-file__size", children: isNewlyUploadedFile(file) && formatSize(file.size) })
-          ] }),
-          errorMessage && /* @__PURE__ */ jsx("div", { className: "adyen-kyc-dropzone-file__error", children: t(($) => $[errorMessage]) })
-        ] }),
-        loading ? /* @__PURE__ */ jsx("div", { className: "adyen-kyc-dropzone-file__loading", children: /* @__PURE__ */ jsx(Loader, { size: "medium" }) }) : errorMessage ? /* @__PURE__ */ jsx(
-          IconButton,
-          {
-            ariaLabel: t(($) => $["close"]),
-            icon: "cross",
-            variant: "tertiary",
-            onClick: onDelete
-          }
-        ) : /* @__PURE__ */ jsx(
-          IconButton,
-          {
-            ariaLabel: t(($) => $["deleteDocument"]),
-            icon: "bin",
-            variant: "tertiary",
-            onClick: onDelete
-          }
-        )
-      ]
-    }
-  );
-}
-const hasDuplicates = (arr) => arr.some((item, currIndex) => arr.indexOf(item) !== currIndex);
-const defaultFileValidationOptions = {
-  allowedFileTypes: ["JPG", "JPEG", "PNG", "PDF"],
-  maxNumberOfFiles: 1,
-  maxSize: 4194304,
-  // 4MB by default
-  isOptional: false
-};
-const filterOnlyNewlyUploadedFiles = (files) => files.filter(isNewlyUploadedFile);
-const fileValidationRules = ({
-  allowedFileTypes,
-  maxNumberOfFiles,
-  maxSize,
-  isOptional
-}) => [
-  {
-    validate: (files) => {
-      if (isOptional && (!files || files.length === 0)) return true;
-      return Boolean(files && files.length > 0);
-    },
-    errorMessage: "fieldIsRequired",
-    modes: ["blur", "input"]
-  },
-  {
-    validate: (files) => {
-      if (!files) return true;
-      return files.length <= maxNumberOfFiles;
-    },
-    errorMessage: "tooManyFiles",
-    modes: ["blur", "input"]
-  },
-  {
-    validate: (files) => {
-      if (!files) return true;
-      return !hasDuplicates(files.map((file) => file.name));
-    },
-    errorMessage: "duplicatedFiles",
-    modes: ["blur", "input"]
-  },
-  {
-    validate: (files) => {
-      if (!files) return true;
-      return filterOnlyNewlyUploadedFiles(files).every(
-        (file) => allowedFileTypes.some(
-          (filetype) => file.name.toLowerCase().endsWith(filetype.toLowerCase())
-        )
-      );
-    },
-    errorMessage: "unsupportedFiletype",
-    modes: ["blur", "input"]
-  },
-  {
-    validate: (files) => {
-      if (!files) return true;
-      return filterOnlyNewlyUploadedFiles(files).every((file) => !file.size || file.size < maxSize);
-    },
-    errorMessage: "maximumFileSizeExceeded",
-    modes: ["blur", "input"]
-  }
-];
-const RadioCard = ({
-  optionId,
-  optionName,
-  optionDescription,
-  optionSubtitle,
-  name,
-  isInvalid,
-  isSelected,
-  onSelect,
-  classNames,
-  disabled,
-  loading,
-  icon,
-  body,
-  footer,
-  floatingRadio
-}) => {
-  const id = useId("radio");
-  const elementIds = {
-    label: `${id}-label`,
-    description: `${id}-description`,
-    subtitle: `${id}-subtitle`
-  };
-  const ariaDescribedBy = `${optionSubtitle ? elementIds.subtitle : ""} ${optionDescription || body ? elementIds.description : ""}`.trim();
-  return /* @__PURE__ */ jsxs(
-    "label",
-    {
-      "data-testId": optionId,
-      className: cx([
-        "adyen-kyc-radio-card",
-        classNames?.label,
-        { "adyen-kyc-radio-card--disabled": disabled }
-      ]),
-      children: [
-        icon && /* @__PURE__ */ jsx("div", { className: cx("adyen-kyc-radio-card__icon", classNames?.icon), "aria-hidden": "true", children: icon }),
-        /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-radio-card__content", children: [
-          /* @__PURE__ */ jsx("div", { className: "adyen-kyc-radio-card__header adyen-kyc-u-display-flex adyen-kyc-u-align-items-center", children: /* @__PURE__ */ jsxs(
-            "div",
-            {
-              className: cx([
-                "adyen-kyc-radio-group-card__label",
-                classNames?.header,
-                { "adyen-kyc-radio-group-card__label--invalid": isInvalid }
-              ]),
-              children: [
-                optionSubtitle && /* @__PURE__ */ jsxs("div", { id: elementIds.subtitle, className: "adyen-kyc-radio-group-card__subtitle", children: [
-                  optionSubtitle,
-                  /* @__PURE__ */ jsx("span", { className: "adyen-kyc-u-screen-reader-only", children: "." })
-                ] }),
-                /* @__PURE__ */ jsx("span", { id: elementIds.label, children: optionName })
-              ]
-            }
-          ) }),
-          /* @__PURE__ */ jsx(
-            "div",
-            {
-              id: elementIds.description,
-              className: cx("adyen-kyc-radio-card__body", classNames?.body),
-              children: body ?? optionDescription
-            }
-          ),
-          footer && /* @__PURE__ */ jsx("div", { className: cx("adyen-kyc-radio-card__footer", classNames?.footer), children: footer })
-        ] }),
-        loading ? /* @__PURE__ */ jsx("span", { className: "adyen-kyc-radio-card__loading-icon", children: /* @__PURE__ */ jsx(Loader, { size: "small", dot: true }) }) : /* @__PURE__ */ jsx(
-          Radio,
-          {
-            id,
-            "aria-describedby": ariaDescribedBy,
-            "aria-labelledby": elementIds.label,
-            checked: isSelected,
-            groupName: name,
-            onClick: onSelect,
-            value: optionId,
-            disabled,
-            className: cx({ "adyen-kyc-radio-group-card__radio--floating": floatingRadio })
-          }
-        )
-      ]
-    },
-    optionId
-  );
-};
-const RadioGroupCard = ({
-  options,
-  name,
-  onSelect,
-  selected,
-  isInvalid,
-  className,
-  optionId,
-  optionName,
-  optionDescription,
-  optionSubtitle,
-  optionClassNames,
-  renderOptionIcon,
-  renderOptionBody,
-  renderOptionFooter,
-  isOptionDisabled,
-  floatingRadio,
-  enableTracking = false
-}) => {
-  const userEvents = useAnalyticsContext();
-  const handleSelect = (option) => {
-    if (enableTracking) {
-      userEvents.addFieldEvent("Interacted with form field", {
-        actionType: "input",
-        field: name,
-        returnValue: typeof option === "string" ? option : void 0
-      });
-    }
-    onSelect(option);
-  };
-  return /* @__PURE__ */ jsx("div", { className: className ?? "adyen-kyc-radio-group-card", children: options.map((option) => /* @__PURE__ */ jsx(
-    RadioCard,
-    {
-      optionId: optionId(option),
-      optionName: optionName(option),
-      optionDescription: optionDescription?.(option),
-      optionSubtitle: optionSubtitle?.(option),
-      isInvalid,
-      isSelected: selected === option,
-      onSelect: () => handleSelect(option),
-      name,
-      classNames: optionClassNames?.(option),
-      icon: renderOptionIcon?.(option),
-      body: renderOptionBody?.(option),
-      footer: renderOptionFooter?.(option),
-      disabled: isOptionDisabled?.(option),
-      floatingRadio
-    },
-    optionId(option)
-  )) });
-};
-const cachedStripPatterns = /* @__PURE__ */ new Map();
-const 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;
-};
-const displayValueToPureValue = (displayValue, mask) => {
-  const stripPattern = cachedStripPatterns.get(mask) ?? makeStripPattern(mask);
-  return displayValue.replaceAll(stripPattern, "");
-};
-const cachedAllowedPatterns = /* @__PURE__ */ new Map();
-const combineRegexArray = (regexArray) => {
-  const combinedPattern = regexArray.map((pattern) => {
-    const match = String(pattern).match(/\/?(.*)\//);
-    return match ? match[1] : pattern;
-  }).join("|");
-  return new RegExp(`(?:${combinedPattern})`, "g");
-};
-const createAllowedPattern = (mask) => {
-  const inputPatterns = mask.tokens.filter((token) => token.type === "input" && !!token.allow).map((token) => token.allow);
-  const uniqueRegexSet = new Set(inputPatterns.map((r) => r.toString()));
-  const uniqueRegexArray = [...uniqueRegexSet].map((str) => {
-    const [_, pattern] = str.match(/\/(.*)\/([gimsuy]*)/) || [];
-    return new RegExp(pattern);
-  });
-  const allowedRegex = combineRegexArray(uniqueRegexArray);
-  cachedAllowedPatterns.set(mask, allowedRegex);
-  return allowedRegex;
-};
-const replaceNonMatchingChars = (value, allowedInputPatterns) => {
-  const matches = value.match(allowedInputPatterns);
-  return matches ? matches.join("") : "";
-};
-const stripNonAllowedValues = (pureValue, mask) => {
-  return replaceNonMatchingChars(
-    pureValue,
-    cachedAllowedPatterns.get(mask) ?? createAllowedPattern(mask)
-  );
-};
-const 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;
-};
-const findMatchingToken = (tokensWithOffset, char) => tokensWithOffset.find(
-  (token) => token.type === "nonInput" || !token.allow || token.allow.test(char)
-) ?? null;
-const 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;
-};
-const getPotentialForMoreOptionalInput = (tokens) => tokens.some((token) => token.type === "input" && token.optional);
-const 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 availableTokens = getAvailableInputTokens(tokensToProcess);
-      const matchingToken = findMatchingToken(availableTokens, char);
-      if (!matchingToken)
-        return {
-          outcome: "mismatch",
-          badChar: char,
-          mismatchAtChar: charIndex,
-          mismatchedToken: token,
-          partialDisplayValue
-        };
-      matchedTokens.push({ ...matchingToken, char });
-      shiftTokens(matchingToken.offset + 1);
-      shiftChars(1);
-    }
-  }
-};
-const InputEmail = forwardRef(
-  ({ onInput, transformInput, ...props }, ref) => {
-    const [cursorPosition, setCursorPosition] = useState(null);
-    const localRef = useForwardedRef(ref);
-    const inputHandler = useCallback(
-      (event) => {
-        const inputEl = event.target;
-        if (transformInput) {
-          setCursorPosition(inputEl.selectionStart);
-          const transformedInput = transformInput(inputEl.value);
-          const eventWithTransformedValue = {
-            ...event,
-            target: { ...event.target, value: transformedInput }
-          };
-          onInput(eventWithTransformedValue);
-        } 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"
-      }
-    );
-  }
-);
-const InputTelephone = forwardRef(
-  ({ onInput, transformInput, ...props }, ref) => {
-    const [cursorPosition, setCursorPosition] = useState(null);
-    const localRef = useForwardedRef(ref);
-    const inputHandler = useCallback(
-      (event) => {
-        const inputEl = event.target;
-        if (transformInput) {
-          setCursorPosition(inputEl.selectionStart);
-          const transformedInput = transformInput(inputEl.value);
-          const eventWithTransformedValue = {
-            ...event,
-            target: { ...event.target, value: transformedInput }
-          };
-          onInput(eventWithTransformedValue);
-        } 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" });
-  }
-);
-const mismatch = "adyen-kyc-mismatch";
-const styles = {
-  mismatch
-};
-const 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, { 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
-  };
-};
-const MISMATCH_ANIMATION_NAME = "mismatchShake";
-const 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 ? styles.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
-        }
-      );
-  }
-};
-const 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",
-  useFieldComponent = true,
-  stripNonAllowedInputs = false
-}) => {
-  const hasExistingData = !isEmpty(value);
-  const [preservingMismatchedValue, setPreservingMismatchedValue] = useState(false);
-  const [isFocused, setIsFocused] = useState(false);
-  const [hasBlurred, setHasBlurred] = useState(hasExistingData);
-  const [caretReturnPosition, setCaretReturnPosition] = useState(null);
-  const inputRef = useRef(null);
-  const [showingMismatch, setShowingMismatch] = useState(false);
-  const { t } = useTranslation("ui");
-  const onAnimationEnd = (event) => {
-    if (!event.animationName.includes(MISMATCH_ANIMATION_NAME)) return;
-    setShowingMismatch(false);
-  };
-  const onMismatch = useCallback(
-    (mismatch2) => {
-      if (!inputRef.current) return;
-      setShowingMismatch(true);
-      inputRef.current.addEventListener("animationend", onAnimationEnd);
-      onMismatchExternal?.(mismatch2);
-    },
-    [onMismatchExternal]
-  );
-  useEffect(() => {
-    const inputEl = inputRef.current;
-    if (inputEl) {
-      return () => {
-        inputEl.removeEventListener("animationend", onAnimationEnd);
-      };
-    }
-  }, []);
-  const getMaskResult = useCallback(
-    (pureValue) => {
-      if (!mask) return { outcome: "partialCorrect", displayValue: pureValue };
-      return matchAgainstMask(
-        transformOnType ? transformOnType(pureValue) : pureValue,
-        mask,
-        acceptObscuredValue,
-        stripNonAllowedInputs
-      );
-    },
-    [mask, transformOnType, acceptObscuredValue, stripNonAllowedInputs]
-  );
-  const displayValueToPure = useCallback(
-    (displayValue2) => {
-      if (!mask) return displayValue2;
-      return displayValueToPureValue(displayValue2, mask);
-    },
-    [mask]
-  );
-  const maskResult = useMemo(() => 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(() => {
-    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(
-    (event) => {
-      const inputEl = event.target;
-      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(
-    (event, fieldOnBlur) => {
-      fieldOnBlur?.(event);
-      const eventWithProcessedValue = {
-        ...event,
-        target: {
-          ...event.target,
-          value: displayValueToPure(event.target.value)
-        }
-      };
-      onBlur?.(eventWithProcessedValue);
-      setIsFocused(false);
-      setHasBlurred(true);
-    },
-    [displayValueToPure, onBlur]
-  );
-  const handlePaste = useCallback(
-    (event) => {
-      const pasteValue = event.clipboardData?.getData("text/plain");
-      const inputEl = event.target;
-      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();
-        handleInput({
-          ...event,
-          target: { ...event.target, value: withPrefixRemoved }
-        });
-      }
-    },
-    [displayValue, displayValueToPure, handleInput]
-  );
-  const handleFocus = useCallback(
-    (event, fieldOnFocus) => {
-      onFocus?.();
-      fieldOnFocus?.(event);
-      setIsFocused(true);
-    },
-    [onFocus]
-  );
-  const handleKeyDown = useCallback(
-    (event) => {
-      const inputEl = event.target;
-      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) {
-      return inputState.text;
-    }
-    if (helper) {
-      return /* @__PURE__ */ jsxs("span", { children: [
-        /* @__PURE__ */ jsx("div", { children: helper }),
-        /* @__PURE__ */ jsx("div", { children: inputState.text })
-      ] });
-    }
-    return inputState.text;
-  };
-  return useFieldComponent ? /* @__PURE__ */ jsx(
-    Field,
-    {
-      name,
-      label,
-      isValid: !inputState.isError,
-      errorMessage: inputState.errorMessage || inputState.isError,
-      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
-    }
-  );
-};
-const createFormRules = (rules) => rules;
-const resolveFieldMetadata = (countryEntry, params, defaultMetadata) => {
-  if (typeof countryEntry === "object") {
-    return countryEntry;
-  }
-  if (typeof countryEntry === "function") {
-    return countryEntry(params);
-  }
-  return defaultMetadata;
-};
-export {
-  isValueObscured as A,
-  ContextGuidance as C,
-  DropzoneFile as D,
-  Image as I,
-  MaskedInput as M,
-  RadioGroupCard as R,
-  StateContextSetter as S,
-  TrustedFieldsProviders as T,
-  validateNotEmptyOnBlur as a,
-  alphanumericInputs as b,
-  nonInputs as c,
-  alphaInputs as d,
-  validateLegalCompanyName as e,
-  validateLatinSpaceMarkPunctuationOnlyOnBlur as f,
-  validateJaKanaLegalCompanyName as g,
-  validateJaHaniLegalCompanyName as h,
-  useCapabilityProblems as i,
-  getProblemsForEntity as j,
-  customInputs as k,
-  defaultFileValidationOptions as l,
-  makeMask as m,
-  numericInputs as n,
-  fileValidationRules as o,
-  bytesToSize as p,
-  DocumentGuidance as q,
-  resolveFieldMetadata as r,
-  spacer as s,
-  TextArea as t,
-  uppercase as u,
-  validatePatternOnBlur as v,
-  getLocalizedIdDocumentTypeOptions as w,
-  createFormRules as x,
-  InputEmail as y,
-  isNewlyUploadedFile as z
-};