@comitor/ui 2.0.0 → 3.0.0

package/dist/components/ui/mask-input-constants.js

@@ -0,0 +1,600 @@
+const PAST_YEARS_LIMIT = 120;
+const FUTURE_YEARS_LIMIT = 10;
+const DEFAULT_CURRENCY = "USD";
+const DEFAULT_LOCALE = "en-US";
+const NUMERIC_MASK_PATTERNS = /^(phone|zipCode|zipCodeExtended|ssn|ein|time|date|creditCard|creditCardExpiry)$/;
+const CURRENCY_PERCENTAGE_SYMBOLS = /[€$%]/;
+const formattersCache = /* @__PURE__ */ new Map();
+const currencyAtEndCache = /* @__PURE__ */ new Map();
+const currencySymbolsCache = /* @__PURE__ */ new Map();
+const fractionDigitsCache = /* @__PURE__ */ new Map();
+const daysInMonthCache = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const REGEX_CACHE = {
+  digitsOnly: /^\d+$/,
+  nonDigits: /\D/g,
+  nonAlphaNumeric: /[^A-Z0-9]/gi,
+  nonNumericDot: /[^0-9.]/g,
+  nonCurrencyChars: /[^\d.,]/g,
+  hashPattern: /#/g,
+  currencyAtEnd: /\d\s*[^\d\s]+$/,
+  percentageChars: /[^\d.]/g,
+  phone: /^\d{10}$/,
+  ssn: /^\d{9}$/,
+  zipCode: /^\d{5}$/,
+  zipCodeExtended: /^\d{9}$/,
+  isbn: /^\d{13}$/,
+  ein: /^\d{9}$/,
+  time: /^\d{4}$/,
+  creditCard: /^\d{13,19}$/,
+  creditCardExpiry: /^\d{4}$/,
+  licensePlate: /^[A-Z0-9]{6}$/,
+  macAddress: /^[A-F0-9]{12}$/,
+  currencyValidation: /^\d+(\.\d{1,2})?$/,
+  ipv4Segment: /^\d{1,3}$/
+};
+function getCachedFormatter(locale, opts) {
+  const { currency, minimumFractionDigits = 0, maximumFractionDigits = 2 } = opts;
+  const key = `${locale}|${currency}|${minimumFractionDigits}|${maximumFractionDigits}`;
+  if (!formattersCache.has(key)) {
+    try {
+      formattersCache.set(
+        key,
+        new Intl.NumberFormat(locale, {
+          style: "currency",
+          currency,
+          ...opts
+        })
+      );
+    } catch {
+      formattersCache.set(
+        key,
+        new Intl.NumberFormat(DEFAULT_LOCALE, {
+          style: "currency",
+          currency: DEFAULT_CURRENCY,
+          ...opts
+        })
+      );
+    }
+  }
+  const formatter = formattersCache.get(key);
+  if (!formatter) {
+    throw new Error(`Kh\xF4ng t\u1EA1o \u0111\u01B0\u1EE3c b\u1ED9 \u0111\u1ECBnh d\u1EA1ng ti\u1EC1n t\u1EC7 cho ${key}`);
+  }
+  return formatter;
+}
+function getCachedCurrencySymbols(opts) {
+  const { locale, currency } = opts;
+  const key = `${locale}|${currency}`;
+  const cached = currencySymbolsCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  let currencySymbol = "$";
+  let decimalSeparator = ".";
+  let groupSeparator = ",";
+  try {
+    const formatter = getCachedFormatter(locale, {
+      currency,
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 2
+    });
+    const parts = formatter.formatToParts(1234.5);
+    const currencyPart = parts.find((part) => part.type === "currency");
+    const decimalPart = parts.find((part) => part.type === "decimal");
+    const groupPart = parts.find((part) => part.type === "group");
+    if (currencyPart) currencySymbol = currencyPart.value;
+    if (decimalPart) decimalSeparator = decimalPart.value;
+    if (groupPart) groupSeparator = groupPart.value;
+  } catch {
+  }
+  const symbols = {
+    currency: currencySymbol,
+    decimal: decimalSeparator,
+    group: groupSeparator
+  };
+  currencySymbolsCache.set(key, symbols);
+  return symbols;
+}
+function getCurrencyFractionDigits(opts) {
+  const { locale, currency } = opts;
+  const key = `${locale}|${currency}`;
+  const cached = fractionDigitsCache.get(key);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let digits = 2;
+  try {
+    const resolved = new Intl.NumberFormat(locale, { style: "currency", currency }).resolvedOptions();
+    digits = Math.min(2, resolved.maximumFractionDigits ?? 2);
+  } catch {
+  }
+  fractionDigitsCache.set(key, digits);
+  return digits;
+}
+function isCurrencyAtEnd(opts) {
+  const { locale, currency } = opts;
+  const key = `${locale}|${currency}`;
+  const cached = currencyAtEndCache.get(key);
+  if (cached !== void 0) {
+    return cached;
+  }
+  try {
+    const formatter = getCachedFormatter(locale, {
+      currency,
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 0
+    });
+    const sample = formatter.format(123);
+    const result = REGEX_CACHE.currencyAtEnd.test(sample);
+    currencyAtEndCache.set(key, result);
+    return result;
+  } catch {
+    currencyAtEndCache.set(key, false);
+    return false;
+  }
+}
+function isCurrencyMask(opts) {
+  const { mask, pattern } = opts;
+  return mask === "currency" || Boolean(pattern && (pattern.includes("$") || pattern.includes("\u20AC")));
+}
+const MASK_PATTERNS = {
+  /**
+   * Số điện thoại **Hoa Kỳ** `(###) ###-####`, đúng 10 chữ số.
+   *
+   * ⚠ Không dùng cho số điện thoại ở app Comitor: số Việt Nam (và mọi số quốc tế) đi qua
+   * `PhoneInput` — có chọn quốc gia, tự nhận mã vùng và lưu dạng `+84…`.
+   */
+  phone: {
+    pattern: "(###) ###-####",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => REGEX_CACHE.phone.test(value.replace(REGEX_CACHE.nonDigits, ""))
+  },
+  ssn: {
+    pattern: "###-##-####",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => REGEX_CACHE.ssn.test(value.replace(REGEX_CACHE.nonDigits, ""))
+  },
+  /**
+   * Ngày kiểu **Hoa Kỳ** `MM/DD/YYYY` — `validate` đọc 2 chữ số ĐẦU là THÁNG. Ngày kiểu Việt Nam
+   * (`dd/MM/yyyy`) thì dùng `DatePicker` của gói, hoặc một `MaskPattern` riêng.
+   */
+  date: {
+    pattern: "##/##/####",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => {
+      const cleaned = value.replace(REGEX_CACHE.nonDigits, "");
+      if (cleaned.length !== 8) return false;
+      const month = Number.parseInt(cleaned.substring(0, 2), 10);
+      const day = Number.parseInt(cleaned.substring(2, 4), 10);
+      const year = Number.parseInt(cleaned.substring(4, 8), 10);
+      const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+      const minYear = currentYear - PAST_YEARS_LIMIT;
+      const maxYear = currentYear + FUTURE_YEARS_LIMIT;
+      if (month < 1 || month > 12 || day < 1 || year < minYear || year > maxYear) return false;
+      const maxDays = month === 2 && (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) ? 29 : daysInMonthCache[month - 1] ?? 31;
+      return day <= maxDays;
+    }
+  },
+  time: {
+    pattern: "##:##",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => {
+      const cleaned = value.replace(REGEX_CACHE.nonDigits, "");
+      if (!REGEX_CACHE.time.test(cleaned)) return false;
+      const hours = Number.parseInt(cleaned.substring(0, 2), 10);
+      const minutes = Number.parseInt(cleaned.substring(2, 4), 10);
+      return hours <= 23 && minutes <= 59;
+    }
+  },
+  creditCard: {
+    pattern: "#### #### #### ####",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => {
+      const cleaned = value.replace(REGEX_CACHE.nonDigits, "");
+      if (!REGEX_CACHE.creditCard.test(cleaned)) return false;
+      let sum = 0;
+      let isEven = false;
+      for (let i = cleaned.length - 1; i >= 0; i--) {
+        const digitChar = cleaned[i];
+        if (!digitChar) continue;
+        let digit = Number.parseInt(digitChar, 10);
+        if (isEven) {
+          digit *= 2;
+          if (digit > 9) {
+            digit -= 9;
+          }
+        }
+        sum += digit;
+        isEven = !isEven;
+      }
+      return sum % 10 === 0;
+    }
+  },
+  creditCardExpiry: {
+    pattern: "##/##",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => {
+      const cleaned = value.replace(REGEX_CACHE.nonDigits, "");
+      if (!REGEX_CACHE.creditCardExpiry.test(cleaned)) return false;
+      const month = Number.parseInt(cleaned.substring(0, 2), 10);
+      const year = Number.parseInt(cleaned.substring(2, 4), 10);
+      if (month < 1 || month > 12) return false;
+      const now = /* @__PURE__ */ new Date();
+      const currentYear = now.getFullYear();
+      const currentMonth = now.getMonth() + 1;
+      const fullYear = year <= 75 ? 2e3 + year : 1900 + year;
+      if (fullYear < currentYear || fullYear === currentYear && month < currentMonth) {
+        return false;
+      }
+      const maxYear = currentYear + 50;
+      if (fullYear > maxYear) {
+        return false;
+      }
+      return true;
+    }
+  },
+  zipCode: {
+    pattern: "#####",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => REGEX_CACHE.zipCode.test(value.replace(REGEX_CACHE.nonDigits, ""))
+  },
+  zipCodeExtended: {
+    pattern: "#####-####",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => REGEX_CACHE.zipCodeExtended.test(value.replace(REGEX_CACHE.nonDigits, ""))
+  },
+  /**
+   * Tiền tệ — định dạng thật đi qua `Intl.NumberFormat` theo `currency`/`locale` (mặc định USD /
+   * en-US → `$1,234,567`; `VND` / `vi-VN` → `1.234.567 ₫`). Chuỗi `pattern` ở đây chỉ là DẤU NHẬN
+   * DẠNG cho nhánh tiền tệ, không phải khuôn chữ số.
+   */
+  currency: {
+    pattern: "$###,###.##",
+    transform: (value, { currency = DEFAULT_CURRENCY, locale = DEFAULT_LOCALE } = {}) => {
+      if (getCurrencyFractionDigits({ currency, locale }) === 0) {
+        return value.replace(REGEX_CACHE.nonDigits, "");
+      }
+      let localeDecimalSeparator = ".";
+      try {
+        const formatter = getCachedFormatter(locale, {
+          currency,
+          minimumFractionDigits: 0,
+          maximumFractionDigits: 2
+        });
+        const parts = formatter.formatToParts(1234.5);
+        const decimalPart = parts.find((part) => part.type === "decimal");
+        if (decimalPart) localeDecimalSeparator = decimalPart.value;
+      } catch {
+      }
+      const cleaned = value.replace(REGEX_CACHE.nonCurrencyChars, "");
+      const dotIndex = cleaned.indexOf(".");
+      const commaIndex = cleaned.indexOf(",");
+      let hasDecimalSeparator = false;
+      let decimalIndex = -1;
+      if (localeDecimalSeparator === ",") {
+        const lastCommaIndex = cleaned.lastIndexOf(",");
+        if (lastCommaIndex !== -1) {
+          const afterComma = cleaned.substring(lastCommaIndex + 1);
+          if (afterComma.length <= 2 && /^\d*$/.test(afterComma)) {
+            hasDecimalSeparator = true;
+            decimalIndex = lastCommaIndex;
+          }
+        }
+        if (!hasDecimalSeparator && dotIndex !== -1) {
+          const afterDot = cleaned.substring(dotIndex + 1);
+          if (afterDot.length <= 2 && /^\d*$/.test(afterDot)) {
+            hasDecimalSeparator = true;
+            decimalIndex = dotIndex;
+          }
+        }
+        if (!hasDecimalSeparator && cleaned.length >= 4) {
+          const match = cleaned.match(/^(\d+)\.(\d{3})(\d{1,2})$/);
+          if (match) {
+            const [, beforeDot, thousandsPart, decimalPart] = match;
+            const integerPart = (beforeDot ?? "") + (thousandsPart ?? "");
+            const result = `${integerPart}.${decimalPart}`;
+            return result;
+          }
+        }
+      } else {
+        const lastDotIndex = cleaned.lastIndexOf(".");
+        if (lastDotIndex !== -1) {
+          const afterDot = cleaned.substring(lastDotIndex + 1);
+          if (afterDot.length <= 2 && /^\d*$/.test(afterDot)) {
+            hasDecimalSeparator = true;
+            decimalIndex = lastDotIndex;
+          }
+        }
+        if (!hasDecimalSeparator && commaIndex !== -1) {
+          const afterComma = cleaned.substring(commaIndex + 1);
+          const looksLikeThousands = commaIndex <= 3 && afterComma.length >= 3;
+          if (!looksLikeThousands && afterComma.length <= 2 && /^\d*$/.test(afterComma)) {
+            hasDecimalSeparator = true;
+            decimalIndex = commaIndex;
+          }
+        }
+      }
+      if (hasDecimalSeparator && decimalIndex !== -1) {
+        const beforeDecimal = cleaned.substring(0, decimalIndex).replace(/[.,]/g, "");
+        const afterDecimal = cleaned.substring(decimalIndex + 1).replace(/[.,]/g, "");
+        if (afterDecimal === "") {
+          const result2 = `${beforeDecimal}.`;
+          return result2;
+        }
+        const result = `${beforeDecimal}.${afterDecimal.substring(0, 2)}`;
+        return result;
+      }
+      const digitsOnly = cleaned.replace(/[.,]/g, "");
+      return digitsOnly;
+    },
+    validate: (value) => {
+      if (!REGEX_CACHE.currencyValidation.test(value)) return false;
+      const num = Number.parseFloat(value);
+      return !Number.isNaN(num) && num >= 0;
+    }
+  },
+  /**
+   * Phần trăm `##.##%` — dấu thập phân là `.` cố định, KHÔNG theo `locale` (dấu `,` bị bỏ qua).
+   */
+  percentage: {
+    pattern: "##.##%",
+    transform: (value) => {
+      const cleaned = value.replace(REGEX_CACHE.percentageChars, "");
+      const parts = cleaned.split(".");
+      if (parts.length > 2) {
+        return `${parts[0]}.${parts.slice(1).join("")}`;
+      }
+      if (parts[1] && parts[1].length > 2) {
+        return `${parts[0]}.${parts[1].substring(0, 2)}`;
+      }
+      return cleaned;
+    },
+    validate: (value, opts = {}) => {
+      const num = Number.parseFloat(value);
+      const min = opts.min ?? 0;
+      const max = opts.max ?? 100;
+      return !Number.isNaN(num) && num >= min && num <= max;
+    }
+  },
+  licensePlate: {
+    pattern: "###-###",
+    transform: (value) => value.replace(REGEX_CACHE.nonAlphaNumeric, "").toUpperCase(),
+    validate: (value) => REGEX_CACHE.licensePlate.test(value)
+  },
+  ipv4: {
+    pattern: "###.###.###.###",
+    transform: (value) => value.replace(REGEX_CACHE.nonNumericDot, ""),
+    validate: (value) => {
+      if (value.includes(".")) {
+        const segments = value.split(".");
+        if (segments.length > 4) return false;
+        return segments.every((segment) => {
+          if (segment === "") return true;
+          if (!REGEX_CACHE.ipv4Segment.test(segment)) return false;
+          const num = Number.parseInt(segment, 10);
+          return num <= 255;
+        });
+      }
+      if (!REGEX_CACHE.digitsOnly.test(value)) return false;
+      if (value.length > 12) return false;
+      const chunks = [];
+      for (let i = 0; i < value.length; i += 3) {
+        chunks.push(value.substring(i, i + 3));
+      }
+      if (chunks.length > 4) return false;
+      return chunks.every((chunk) => {
+        const num = Number.parseInt(chunk, 10);
+        return num >= 0 && num <= 255;
+      });
+    }
+  },
+  macAddress: {
+    pattern: "##:##:##:##:##:##",
+    transform: (value) => value.replace(REGEX_CACHE.nonAlphaNumeric, "").toUpperCase(),
+    validate: (value) => REGEX_CACHE.macAddress.test(value)
+  },
+  isbn: {
+    pattern: "###-#-###-#####-#",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => REGEX_CACHE.isbn.test(value.replace(REGEX_CACHE.nonDigits, ""))
+  },
+  ein: {
+    pattern: "##-#######",
+    transform: (value) => value.replace(REGEX_CACHE.nonDigits, ""),
+    validate: (value) => REGEX_CACHE.ein.test(value.replace(REGEX_CACHE.nonDigits, ""))
+  }
+};
+function applyMask(opts) {
+  const { value, pattern, currency, locale, mask } = opts;
+  const cleanValue = value;
+  if (pattern.includes("$") || pattern.includes("\u20AC") || mask === "currency") {
+    return applyCurrencyMask({
+      value: cleanValue,
+      currency: currency ?? DEFAULT_CURRENCY,
+      locale: locale ?? DEFAULT_LOCALE
+    });
+  }
+  if (pattern.includes("%")) {
+    return applyPercentageMask(cleanValue);
+  }
+  if (mask === "ipv4") {
+    return cleanValue;
+  }
+  const maskedChars = [];
+  let valueIndex = 0;
+  for (let i = 0; i < pattern.length && valueIndex < cleanValue.length; i++) {
+    const patternChar = pattern[i];
+    const valueChar = cleanValue[valueIndex];
+    if (patternChar === "#" && valueChar) {
+      maskedChars.push(valueChar);
+      valueIndex++;
+    } else if (patternChar) {
+      maskedChars.push(patternChar);
+    }
+  }
+  return maskedChars.join("");
+}
+function applyCurrencyMask(opts) {
+  const { value, currency = DEFAULT_CURRENCY, locale = DEFAULT_LOCALE } = opts;
+  if (!value) return "";
+  const {
+    currency: currencySymbol,
+    decimal: decimalSeparator,
+    group: groupSeparator
+  } = getCachedCurrencySymbols({ locale, currency });
+  const normalizedValue = value.replace(new RegExp(`\\${groupSeparator.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "g"), "").replace(decimalSeparator, ".");
+  const parts = normalizedValue.split(".");
+  const integerPart = parts[0] ?? "";
+  const fractionalPart = parts[1] ?? "";
+  if (!integerPart && !fractionalPart) return "";
+  const fractionDigits = getCurrencyFractionDigits({ currency, locale });
+  const intValue = integerPart ?? "0";
+  const fracValue = fractionalPart.slice(0, fractionDigits);
+  const num = Number(`${intValue}.${fracValue ?? ""}`);
+  if (Number.isNaN(num)) {
+    const cleanedDigits = value.replace(/[^\d]/g, "");
+    if (!cleanedDigits) return "";
+    return `${currencySymbol}${cleanedDigits}`;
+  }
+  const hasExplicitDecimal = fractionDigits > 0 && (value.includes(".") || value.includes(decimalSeparator));
+  try {
+    const formatter = getCachedFormatter(locale, {
+      currency,
+      minimumFractionDigits: fracValue ? fracValue.length : 0,
+      maximumFractionDigits: 2
+    });
+    const result = formatter.format(num);
+    if (hasExplicitDecimal && !fracValue) {
+      if (result.match(/^[^\d\s]+/)) {
+        const finalResult2 = result.replace(/(\d)$/, `$1${decimalSeparator}`);
+        return finalResult2;
+      }
+      const finalResult = result.replace(/(\d)(\s*)([^\d\s]+)$/, `$1${decimalSeparator}$2$3`);
+      return finalResult;
+    }
+    return result;
+  } catch {
+    const formattedInt = intValue.replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator);
+    let result = `${currencySymbol}${formattedInt}`;
+    if (hasExplicitDecimal) {
+      result += `${decimalSeparator}${fracValue}`;
+    }
+    return result;
+  }
+}
+function applyPercentageMask(value) {
+  if (!value) return "";
+  const parts = value.split(".");
+  let result = parts[0] ?? "0";
+  if (value.includes(".")) {
+    result += `.${(parts[1] ?? "").substring(0, 2)}`;
+  }
+  return `${result}%`;
+}
+function getUnmaskedValue(opts) {
+  const { value, transform, currency, locale } = opts;
+  return transform ? transform(value, { currency, locale }) : value.replace(REGEX_CACHE.nonDigits, "");
+}
+function toUnmaskedIndex(opts) {
+  const { masked, pattern, caret } = opts;
+  let idx = 0;
+  for (let i = 0; i < caret && i < masked.length && i < pattern.length; i++) {
+    if (pattern[i] === "#") {
+      idx++;
+    }
+  }
+  return idx;
+}
+function fromUnmaskedIndex(opts) {
+  const { masked, pattern, unmaskedIndex } = opts;
+  let seen = 0;
+  for (let i = 0; i < masked.length && i < pattern.length; i++) {
+    if (pattern[i] === "#") {
+      seen++;
+      if (seen === unmaskedIndex) {
+        return i + 1;
+      }
+    }
+  }
+  return masked.length;
+}
+function getCurrencyCaretPosition(opts) {
+  const { newValue, mask, transformOpts, oldCursorPosition, oldValue, previousUnmasked } = opts;
+  if (oldCursorPosition !== void 0 && oldValue && previousUnmasked !== void 0) {
+    if (oldCursorPosition < oldValue.length) {
+      const digitsBeforeCursor = oldValue.substring(0, oldCursorPosition).replace(/\D/g, "").length;
+      let digitCount = 0;
+      for (let i = 0; i < newValue.length; i++) {
+        if (/\d/.test(newValue[i] ?? "")) {
+          digitCount++;
+          if (digitCount === digitsBeforeCursor) {
+            return i + 1;
+          }
+        }
+      }
+    }
+  }
+  if (mask === "currency") {
+    const currencyAtEnd = isCurrencyAtEnd(transformOpts);
+    if (currencyAtEnd) {
+      const match = newValue.match(/(\d)\s*([^\d\s]+)$/);
+      if (match?.[1]) {
+        return newValue.lastIndexOf(match[1]) + 1;
+      }
+      return newValue.length;
+    }
+    return newValue.length;
+  }
+  return newValue.length;
+}
+function getPatternCaretPosition(opts) {
+  const { newValue, maskPattern, currentUnmasked, oldCursorPosition, oldValue, previousUnmasked } = opts;
+  let position = 0;
+  let unmaskedCount = 0;
+  if (oldCursorPosition !== void 0 && oldValue && previousUnmasked !== void 0) {
+    const oldUnmaskedIndex = toUnmaskedIndex({
+      masked: oldValue,
+      pattern: maskPattern.pattern,
+      caret: oldCursorPosition
+    });
+    if (oldCursorPosition < oldValue.length) {
+      const targetUnmaskedIndex = Math.min(oldUnmaskedIndex, currentUnmasked.length);
+      for (let i = 0; i < maskPattern.pattern.length && i < newValue.length; i++) {
+        if (maskPattern.pattern[i] === "#") {
+          unmaskedCount++;
+          if (unmaskedCount <= targetUnmaskedIndex) {
+            position = i + 1;
+          }
+        }
+      }
+      return position;
+    }
+  }
+  for (let i = 0; i < maskPattern.pattern.length && i < newValue.length; i++) {
+    if (maskPattern.pattern[i] === "#") {
+      unmaskedCount++;
+      if (unmaskedCount <= currentUnmasked.length) {
+        position = i + 1;
+      }
+    }
+  }
+  return position;
+}
+export {
+  CURRENCY_PERCENTAGE_SYMBOLS,
+  DEFAULT_CURRENCY,
+  MASK_PATTERNS,
+  NUMERIC_MASK_PATTERNS,
+  REGEX_CACHE,
+  applyCurrencyMask,
+  applyMask,
+  applyPercentageMask,
+  fromUnmaskedIndex,
+  getCurrencyCaretPosition,
+  getPatternCaretPosition,
+  getUnmaskedValue,
+  isCurrencyAtEnd,
+  isCurrencyMask,
+  toUnmaskedIndex
+};
+//# sourceMappingURL=mask-input-constants.js.map