intelicoreact 1.8.68 → 2.0.0

package/dist/presets.cjs

@@ -0,0 +1,905 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/presets.ts
+var presets_exports = {};
+__export(presets_exports, {
+  ALL_KEYBOARD_TYPES: () => ALL_KEYBOARD_TYPES,
+  ANDROID_CHROME_TEXT_CODE: () => ANDROID_CHROME_TEXT_CODE,
+  DEFAULT_ERRORS: () => DEFAULT_ERRORS,
+  DIGIT_MASK_CHAR: () => DIGIT_MASK_CHAR,
+  EMAIL_KEYBOARD: () => EMAIL_KEYBOARD,
+  EXCLUDED_KEYS: () => EXCLUDED_KEYS,
+  INPUT_PRESETS: () => INPUT_PRESETS,
+  LOWERCASE_LETTER_MASK_CHAR: () => LOWERCASE_LETTER_MASK_CHAR,
+  MASK_PRESETS: () => MASK_PRESETS,
+  NAME_SYMBOLS_EXCLUDER: () => NAME_SYMBOLS_EXCLUDER,
+  NUMERIC_KEYBOARD: () => NUMERIC_KEYBOARD,
+  ONLY_STRING_AND_DASH: () => ONLY_STRING_AND_DASH,
+  SPACE_CHAR: () => SPACE_CHAR,
+  UPPERCASE_LETTER_MASK_CHAR: () => UPPERCASE_LETTER_MASK_CHAR,
+  copyToClipboard: () => copyToClipboard,
+  getSelectionText: () => getSelectionText,
+  isDigit: () => isDigit,
+  isDigitMaskChar: () => isDigitMaskChar,
+  isLetter: () => isLetter,
+  isLetterMaskChar: () => isLetterMaskChar,
+  isLowerCaseLetter: () => isLowerCaseLetter,
+  isUpperCaseLetter: () => isUpperCaseLetter,
+  resetSelectionText: () => resetSelectionText,
+  selectElementContents: () => selectElementContents,
+  voidFn: () => voidFn
+});
+module.exports = __toCommonJS(presets_exports);
+
+// src/Atomic/FormElements/InputMask3/config.ts
+var DEFAULT_ERRORS = {
+  onlyLetter: "Type letter",
+  onlyDigit: "Type digit",
+  onlyUpperCase: "Type letter in UpperCase",
+  onlyLowerCase: "Type letter in LowerCase",
+  default: null
+};
+var UPPERCASE_LETTER_MASK_CHAR = "L";
+var LOWERCASE_LETTER_MASK_CHAR = "l";
+var DIGIT_MASK_CHAR = "D";
+var SPACE_CHAR = "\xA0";
+var ANDROID_CHROME_TEXT_CODE = 229;
+var EXCLUDED_KEYS = ["Tab"];
+
+// src/Atomic/FormElements/InputMask3/functions.ts
+function getSelectionText() {
+  let text = "";
+  if (window.getSelection) {
+    text = window.getSelection()?.toString() ?? "";
+  } else if (document.getSelection() && document.getSelection()?.type !== "Control") {
+    text = document.getSelection()?.toString() ?? "";
+  }
+  return text?.replace(/\n/g, "");
+}
+function resetSelectionText() {
+  if (window.getSelection) {
+    window.getSelection()?.removeAllRanges();
+  }
+}
+function copyToClipboard(str) {
+  if (navigator && navigator.clipboard && navigator.clipboard.writeText)
+    return navigator.clipboard.writeText(str);
+  return Promise.reject("The Clipboard API is not available.");
+}
+function selectElementContents(el) {
+  const sel = window.getSelection();
+  sel?.selectAllChildren(el);
+}
+function isLetter(char) {
+  return Boolean(char?.length === 1 && char?.match(/[a-z]/i));
+}
+function isUpperCaseLetter(char) {
+  return isLetter(char) ? char === char.slice().toUpperCase() : false;
+}
+function isLowerCaseLetter(char) {
+  return isLetter(char) ? char === char.slice().toLowerCase() : false;
+}
+function isDigit(char) {
+  return Boolean(Number.isInteger(Number.parseInt(char, 10)));
+}
+function isDigitMaskChar(char) {
+  return char === DIGIT_MASK_CHAR;
+}
+function isLetterMaskChar(char) {
+  return char === UPPERCASE_LETTER_MASK_CHAR || char === LOWERCASE_LETTER_MASK_CHAR;
+}
+function voidFn() {
+  console.error("Void Function Called");
+}
+
+// src/Functions/presets/inputMaskPresets.js
+var DATE_PRESET = {
+  type: "inputMask",
+  maskPattern: "DD.DD.DDDD",
+  maskPatternPlaceholder: "MM.DD.YYYY",
+  usePatternPlaceholder: true,
+  isNumericMobileKeyboard: true,
+  blinkErrors: true,
+  showErrors: false,
+  autocomplete: "bday",
+  focusSelector: "input"
+};
+var ZIP_PRESET = {
+  type: "inputMask",
+  focusSelector: "input",
+  maskPattern: "DDDDD",
+  maskPlaceholder: "X",
+  isNumericMobileKeyboard: true,
+  blinkErrors: true,
+  showErrors: false,
+  autocomplete: "postal-code",
+  rules: "fieldZip"
+};
+var SSN_PRESET = {
+  type: "inputMask",
+  maskPattern: "DDDDDDDDD",
+  maskPlaceholder: "X",
+  focusSelector: "input",
+  isNumericMobileKeyboard: true,
+  blinkErrors: true,
+  showErrors: false
+};
+var MOBILE_PHONE_PRESET = {
+  type: "inputMask",
+  // maskPattern: 'DDD-DDD-DDDD',
+  maskPattern: "(DDD) DDD-DDDD",
+  maskPlaceholder: "X",
+  focusSelector: "input",
+  isNumericMobileKeyboard: true,
+  blinkErrors: true,
+  showErrors: false,
+  autocomplete: "tel-national"
+};
+var SHORT_SSN_PRESET = {
+  type: "inputMask3",
+  maskPattern: "DDDD",
+  maskPlaceholder: "X",
+  focusSelector: "input",
+  isNumericMobileKeyboard: true,
+  blinkErrors: true,
+  showErrors: false
+};
+var ABA_PRESET = {
+  type: "inputMask",
+  maskPattern: "DDDDDDDDD",
+  maskPlaceholder: "X",
+  isNumericMobileKeyboard: true,
+  blinkErrors: true,
+  showErrors: false
+};
+var CC_EXPIRATION_DATE = {
+  type: "inputMask",
+  maskPattern: "MM/YY",
+  maskPatternPlaceholder: "MM/YY",
+  usePatternPlaceholder: true,
+  isNumericMobileKeyboard: true,
+  blinkErrors: true,
+  showErrors: false,
+  focusSelector: "input"
+};
+var BANK_ACCOUNT = {
+  type: "inputMask",
+  maskPattern: "DDDDDDDDDD",
+  maskPlaceholder: "X",
+  isNumericMobileKeyboard: true,
+  blinkErrors: true,
+  showErrors: false
+};
+var MASK_PRESETS = {
+  BANK_ACCOUNT,
+  CC_EXPIRATION_DATE,
+  DATE_PRESET,
+  ZIP_PRESET,
+  SSN_PRESET,
+  MOBILE_PHONE_PRESET,
+  SHORT_SSN_PRESET,
+  ABA_PRESET
+};
+
+// src/Constants/index.constants.js
+var KEYBOARD_SERVICE_KEYS = [
+  "Escape",
+  "F1",
+  "F2",
+  "F3",
+  "F4",
+  "F5",
+  "F6",
+  "F7",
+  "F8",
+  "F9",
+  "F10",
+  "F11",
+  "F12",
+  "Tab",
+  "CapsLock",
+  "Shift",
+  "Control",
+  "Meta",
+  "Option",
+  "Alt",
+  "ContextMenu",
+  "ArrowLeft",
+  "ArrowRight",
+  "ArrowUp",
+  "ArrowDown",
+  "NumLock",
+  "Backspace",
+  "Delete",
+  "Enter",
+  "Return",
+  "Insert",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "PrintScreen",
+  "ScrollLock",
+  "Pause"
+];
+var MAX_PHONE_LENGTH = 10;
+var MAX_NAME_LENGTH = 128;
+var DEFAULT_DATE_MASK_NO_VALUE_SYMBOL = "_";
+var DEFAULT_COLORS = [
+  "#D9C1FF",
+  "#FFBAF0",
+  "#FFB8CE",
+  "#FFC3A2",
+  "#FFDB7C",
+  "#F9F871",
+  "#C3FCF1",
+  "#F6F2CB",
+  "#E0F8D1",
+  "#B1DFFB",
+  "#8DECFE",
+  "#76F7ED",
+  "#8AFEC8"
+];
+var KEYBOARD_KEY_CODES = {
+  Backspace: 8,
+  Delete: 46,
+  ARROW_LEFT: 37,
+  ARROW_RIGHT: 39
+};
+var OS = {
+  iOS: "iOS",
+  Android: "Android",
+  WP: "Windows Phone",
+  Linux: "Linux",
+  Windows: "Windows",
+  MacOS: "MacOS",
+  Unknown: "unknown"
+};
+
+// src/Functions/utils.js
+var import_react = require("react");
+var import_moment_timezone = __toESM(require("moment-timezone"), 1);
+var uuid = () => Date.now().toString(36) + Math.random().toString(36).substring(2);
+var getIsOnlyAnObject = (input) => {
+  return typeof input === "object" && // "отбивает" примитивы и функции
+  input instanceof Object && // "отбивает" null
+  !Array.isArray(input) && // "отбивает" массивы
+  !(input instanceof Set) && // "отбивает" сеты
+  !(input instanceof Map);
+};
+var handleObjectChange = (updateObject, updateFunction) => (data, prop = "", isNumber) => {
+  let value;
+  if (data?.target) {
+    value = data.target.type === "checkbox" ? data.target.checked : data.target.value;
+  } else value = data;
+  value = isNumber ? Number(value) : value;
+  const props = prop.split(".");
+  const currentObject = props.reduce((res, chapter, index) => {
+    if (props.length !== index + 1) res = res[chapter];
+    return res;
+  }, updateObject);
+  currentObject[props.pop()] = value;
+  updateFunction();
+};
+var useOutsideToggle = (ref, setOut, open) => {
+  function handleClickOutside(event) {
+    if (ref.current && !ref.current.contains(event.target)) {
+      setOut(open);
+    }
+  }
+  (0, import_react.useEffect)(() => {
+    document.addEventListener("mouseup", handleClickOutside);
+    return () => {
+      document.removeEventListener("mouseup", handleClickOutside);
+    };
+  }, [ref]);
+};
+var clone = (input) => {
+  if (input === null || typeof input !== "object") return input;
+  const data = input instanceof Array ? [] : {};
+  for (const i in input) data[i] = clone(input[i]);
+  return data;
+};
+var getResponseClone = async (res) => await (typeof res?.clone === "function" ? res.clone() : clone(res));
+function transformUTCTimeToLocal(date, format = "YYYY-MM-DD HH:mm:ss") {
+  if (!date) return;
+  const utcDate = import_moment_timezone.default.utc(date).toDate();
+  return (0, import_moment_timezone.default)(utcDate, format).local().format(format);
+}
+function transformLocalTimeToUTC(date, format = "YYYY-MM-DD HH:mm:ss") {
+  if (!date) return;
+  return (0, import_moment_timezone.default)(date, format).utc().format(format);
+}
+function transformUTCHoursToLocal(time, format = "HH:mm:ss") {
+  if (!time) return;
+  const splitedTime = time.split(":");
+  const offset = (0, import_moment_timezone.default)().utcOffset();
+  let HH = Number(splitedTime[0]);
+  let mm = Number(splitedTime[1]);
+  const ss = splitedTime[2];
+  mm = mm + offset;
+  while (mm > 59) {
+    mm -= 60;
+    HH += 1;
+  }
+  if (HH > 23) HH -= 24;
+  while (mm < 0) {
+    mm += 60;
+    HH -= 1;
+  }
+  if (HH < 0) HH += 24;
+  return `${HH}:${mm}:${ss}`;
+}
+function transformDateOrTimeOrTogetherToFormat(data, outputFormat = "HH:mm", additional) {
+  const ERROR_VALUE = "Invalid date";
+  const ERROR_MESSGE = `Invalid input data for ${outputFormat} format`;
+  const { parseFormat, isReturnAsMomentInstance } = getIsOnlyAnObject(
+    additional
+  ) ? additional : {};
+  if (typeof data !== "string" && typeof data !== "number") {
+    return isReturnAsMomentInstance ? (0, import_moment_timezone.default)("error") : ERROR_MESSGE;
+  }
+  const momentArgs = [
+    data,
+    ...!Number.isNaN(Number(data)) || typeof parseFormat === "string" ? [] : [parseFormat]
+  ];
+  const momentInstance = (() => {
+    let instance = (0, import_moment_timezone.default)(...momentArgs);
+    if (instance.format(outputFormat) !== ERROR_VALUE) return instance;
+    else if (/^\d\d.\d\d/.test(data)) {
+      instance = (0, import_moment_timezone.default)();
+      const symbols = data.split("");
+      const timeArr = symbols.reduce(
+        (acc, symbol, idx) => {
+          if (Number.isNaN(Number(symbol))) {
+            if (acc.group) acc.result.push(acc.group);
+            acc.group = "";
+          } else acc.group = `${acc.group}${symbol}`;
+          if (idx === symbols.length - 1 && acc.group)
+            acc.result.push(acc.group);
+          return acc;
+        },
+        { result: [], group: "" }
+      ).result.reverse();
+      instance.hours(Number(timeArr.pop()));
+      instance.minutes(Number(timeArr.pop()));
+      instance.seconds(timeArr.length ? Number(timeArr.pop()) : 0);
+      instance.milliseconds(timeArr.length ? Number(timeArr.pop()) : 0);
+    } else instance = (0, import_moment_timezone.default)("error");
+    return instance;
+  })();
+  if (isReturnAsMomentInstance) return momentInstance;
+  const output = momentInstance.format(outputFormat);
+  return output === ERROR_VALUE ? ERROR_MESSGE : output;
+}
+function transformDateOrTimeOrTogetherToFormattedLocal(data, outputFormat = "HH:mm", additional) {
+  const ERROR_VALUE = "Invalid date";
+  const ERROR_MESSGE = `Invalid input data for ${outputFormat} format`;
+  if (additional && !getIsOnlyAnObject(additional)) {
+    throw new Error(
+      "Bad additional [transformDateOrTimeOrTogetherToFormattedLocal]"
+    );
+  }
+  const compositeAdditional = {
+    ...additional || {},
+    isReturnAsMomentInstance: true
+  };
+  const date = transformDateOrTimeOrTogetherToFormat(
+    data,
+    outputFormat,
+    compositeAdditional
+  );
+  const dateWithLocale = date.add((0, import_moment_timezone.default)().utcOffset(), "minutes");
+  const output = dateWithLocale.format(outputFormat);
+  return output === ERROR_VALUE ? ERROR_MESSGE : output;
+}
+var omitKeys = (obj = {}, keys = []) => keys.reduce((acc, key) => {
+  const { [key]: omit, ...rest } = acc;
+  return rest;
+}, obj);
+var logout = () => {
+  window.localStorage.removeItem("accessToken");
+  window.localStorage.removeItem("tokenExpires");
+  window.location.reload();
+};
+var getStyles = (el, prop) => {
+  if (!el) return null;
+  if (!prop) return window.getComputedStyle(el);
+  return window.getComputedStyle(el).getPropertyValue(prop);
+};
+var getColorById = (id, colors) => {
+  if (!id) return "#FF7D00";
+  const idToArr = Array.from(id);
+  const colorsArr = colors && colors.length > 0 ? colors : DEFAULT_COLORS;
+  let number = idToArr.reduce((acc, item) => {
+    if (Number(item)) {
+      return acc + Number(item);
+    }
+    return acc;
+  }, 0);
+  while (number >= colorsArr.length) {
+    number -= colorsArr.length;
+  }
+  return colorsArr[number];
+};
+var debounce = (fn, ms) => {
+  let id = null;
+  return (...args) => {
+    clearTimeout(id);
+    id = setTimeout(() => {
+      clearTimeout(id);
+      fn(...args);
+    }, ms);
+  };
+};
+var throttle = (fn, ms) => {
+  let id = null;
+  return (...args) => {
+    if (id) return;
+    fn(...args);
+    id = setTimeout(() => {
+      clearTimeout(id);
+      id = null;
+    }, ms);
+  };
+};
+var addBitDepthPoints = (value, step = 3) => {
+  const isFraction = value?.includes(".");
+  const valueBeforeDot = isFraction ? value?.slice(0, value?.indexOf(".")) : value;
+  const intPart = valueBeforeDot.split("").reverse().reduce(
+    (acc, item, idx) => idx % step === 0 && idx !== 0 ? [...acc, ",", item] : [...acc, item],
+    []
+  ).reverse().join("");
+  return isFraction ? intPart + value?.slice(value?.indexOf(".")) : intPart;
+};
+var changeMeta = (key, items = []) => {
+  const defaultMeta = items.find((i) => i.key === "default");
+  if (key) {
+    const item = items.find((i) => i.key === key);
+    document.title = item?.title ?? defaultMeta?.title;
+    document.querySelector('meta[name="description"]').setAttribute("content", item?.description ?? defaultMeta?.description);
+  }
+};
+var firstLetterCapital = (str) => typeof str === "string" ? `${str.charAt(0).toUpperCase()}${str.slice(1)}` : str;
+var capitalized = firstLetterCapital;
+var checkedRef = (ref) => ref ? typeof ref === "function" ? (node) => ref(node) : ref : null;
+function downloadEmulation(data, filename, type = "image/*") {
+  const file = new Blob([data], { type });
+  if (window.navigator.msSaveOrOpenBlob)
+    window.navigator.msSaveOrOpenBlob(file, filename);
+  else {
+    const a = document.createElement("a"), url = URL.createObjectURL(file);
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    setTimeout(() => {
+      document.body.removeChild(a);
+      window.URL.revokeObjectURL(url);
+    }, 0);
+  }
+}
+var downloadFile = async ({ url, name, type = null }) => {
+  const response = await fetch(url).then(async (res) => ({
+    data: await res.blob(),
+    type: type ?? res.headers.get("content-type")
+  }));
+  downloadEmulation(response.data, name, response.type);
+};
+var compare = (first, second, keys = []) => {
+  if (typeof first !== typeof second) return false;
+  if (Array.isArray(first) !== Array.isArray(second)) return false;
+  if (!(first instanceof Object)) return first === second;
+  const getComparationStructure = (data) => {
+    if (typeof data === "function") return data.toString();
+    if (!(data instanceof Object)) return data;
+    return Object.entries(data).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => [key, getComparationStructure(data[key])]);
+  };
+  const structureForComparingOfFirst = getComparationStructure(first);
+  const structureForComparingOfSecond = getComparationStructure(second);
+  return JSON.stringify(structureForComparingOfFirst) === JSON.stringify(structureForComparingOfSecond);
+};
+var setCarretToEnd = (input) => {
+  setTimeout(() => {
+    const tmp = input.value;
+    input.value = "";
+    input.value = tmp;
+  }, 10);
+};
+var compareAlphabetical = (a, b, key = "label") => {
+  let item1 = a?.[key];
+  let item2 = b?.[key];
+  if (typeof item1 !== "string" || typeof item2 !== "string") return 0;
+  item1 = item1?.toLowerCase();
+  item2 = item2?.toLowerCase();
+  if (item1 < item2) {
+    return -1;
+  }
+  if (item1 > item2) {
+    return 1;
+  }
+  return 0;
+};
+var getBase64 = (file) => {
+  if (file) {
+    return new Promise(function(resolve, reject) {
+      const reader = new FileReader();
+      reader.readAsDataURL(file);
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = (error) => reject("Error: ", error);
+    });
+  }
+};
+var renderFileSize = (bytes, decimals = 2) => {
+  if (!Number(bytes)) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};
+var getUniqueFileExtensions = (extListString) => {
+  const extArray = extListString?.split(",").map((ext) => ext.trim().toUpperCase());
+  const uniqueExts = [...new Set(extArray)];
+  return uniqueExts.join(", ");
+};
+var getOS = () => {
+  let userAgent = window.navigator.userAgent, platform = window.navigator?.userAgentData?.platform || window.navigator.platform, macosPlatforms = ["Macintosh", "MacIntel", "MacPPC", "Mac68K"], windowsPlatforms = ["Win32", "Win64", "Windows", "WinCE"], iosPlatforms = ["iPhone", "iPad", "iPod"], os = OS.Unknown;
+  if (macosPlatforms.indexOf(platform) !== -1) {
+    os = OS.MacOS;
+  } else if (iosPlatforms.indexOf(platform) !== -1) {
+    os = OS.iOS;
+  } else if (windowsPlatforms.indexOf(platform) !== -1) {
+    os = OS.Windows;
+  } else if (/Android/.test(userAgent)) {
+    os = OS.Android;
+  } else if (/Linux/.test(platform)) {
+    os = OS.Linux;
+  }
+  return os;
+};
+String.prototype.longerThan = function(compareWith) {
+  return this?.length > compareWith?.length;
+};
+String.prototype.lastIndexEqualsTo = function(index) {
+  return this?.length - 1 === index;
+};
+var getCorrectTestId = ({ testId = "", withTier = true }) => testId && testId !== void 0 ? `${withTier ? "-" : ""}${testId}` : "";
+
+// src/Functions/fieldValueFormatters.js
+var getSafelyValue = (value) => value !== void 0 && value !== null ? value?.toString?.() || "" : "";
+var intlNumbersFormatter = (inputValue, settings = {}) => {
+  const safelyInputValue = getSafelyValue(inputValue);
+  const previousValue = safelyInputValue.slice(0, -1);
+  const lastSym = safelyInputValue.slice(-1);
+  const value = lastSym === "." ? previousValue : safelyInputValue;
+  if (Number.isNaN(Number(value)) || !getSafelyValue(value)) return "";
+  const {
+    // локаль, даже региональная, влияет на отображение знаков и формата.
+    locale = "en-US",
+    // percent || currency(default case) || decimal(просто число) влияет на ТИП обработки.
+    withSymbol,
+    //группировка запятыми поразрядно.
+    useGrouping = true,
+    //!!работает только при withSymbol: 'currency' !! влияет на то, как именно будет выглядет формат валюты.
+    currency = {},
+    //сколько знаков после точки, и всегда ли они будут.
+    // !!если поставить  isAlwaysRender: true, но не дать центов, то будет 100.00
+    fractionDigits = {}
+  } = settings;
+  const { currencyType = "USD", currencyDisplay: inputCurrencyDisplay } = currency;
+  let currencyDisplay;
+  switch (inputCurrencyDisplay) {
+    case "name":
+      currencyDisplay = "name";
+      break;
+    case "code":
+      currencyDisplay = "code";
+      break;
+    case "narrowSymbol":
+      currencyDisplay = "narrowSymbol";
+      break;
+    default:
+      currencyDisplay = "symbol";
+  }
+  let numberStyle;
+  switch (withSymbol) {
+    case "percent":
+      numberStyle = "percent";
+      break;
+    case "currency":
+      numberStyle = "currency";
+      break;
+    default:
+      numberStyle = "decimal";
+      break;
+  }
+  const {
+    quantity,
+    isRenderAlways = false,
+    minimumFractionDigits: inputMinimumFractionDigits,
+    maximumFractionDigits: inputMaximumFractionDigits,
+    conditionallyMinimumFractionDigits
+  } = fractionDigits;
+  const dotIndex = safelyInputValue?.indexOf(".");
+  const afterDot = dotIndex !== -1 ? safelyInputValue.slice(dotIndex + 1) : "";
+  const minimumFractionDigits = (() => {
+    if (typeof inputMinimumFractionDigits === "number")
+      return inputMinimumFractionDigits;
+    if (typeof conditionallyMinimumFractionDigits === "number") {
+      return afterDot && lastSym !== "." ? conditionallyMinimumFractionDigits : 0;
+    }
+    return afterDot && lastSym !== "." ? safelyInputValue.slice(dotIndex).length - 1 : isRenderAlways ? quantity : 0;
+  })();
+  const priceSettings = {
+    useGrouping,
+    //группировка разрядов
+    style: numberStyle,
+    //тип форматирования (валюта или число). decimal - без знака валюты
+    currency: currencyType,
+    //валюта
+    currencyDisplay,
+    //валюта в виде символа
+    //минимально не надо отображать центы, если их нет, иначе всегда будет .00
+    minimumFractionDigits,
+    //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
+    //! чем указано в (inputMaximumFractionDigits ?? quantity) - округлит по правилам округления
+    //максимально отображать 2 цифры после запятой, если центы всё же есть
+    maximumFractionDigits: inputMaximumFractionDigits ?? quantity
+  };
+  let output;
+  try {
+    output = new Intl.NumberFormat(locale, priceSettings).format(value);
+  } catch (e) {
+    output = value;
+    console.warn("Intl.NumberFormat error", e);
+  }
+  return lastSym === "." ? output + lastSym : output;
+};
+var formatOnlyNumbers = (value) => getSafelyValue(value).replace(/\D/g, "");
+var formatToRemoveComa = (value) => getSafelyValue(value).replace(/,/g, "");
+var formatToAddBitDepthPoints = (value, settings) => intlNumbersFormatter(getSafelyValue(value), {
+  fractionDigits: {
+    quantity: settings?.type === "int" ? 0 : settings?.decimalPlaces
+  }
+});
+var formatToPriceWithUSD = (value) => {
+  if (isNaN(Number(value))) return value;
+  return intlNumbersFormatter(getSafelyValue(value), {
+    withSymbol: "currency",
+    currency: { currencyType: "USD" },
+    fractionDigits: { quantity: 2, conditionallyMinimumFractionDigits: 2 }
+  });
+};
+var formatToPriceWithCurrency = (value, currencyCode, symbolPosition = "before") => {
+  if (isNaN(Number(value))) return value;
+  return intlNumbersFormatter(getSafelyValue(value), {
+    withSymbol: "currency",
+    currency: { currencyType: currencyCode },
+    fractionDigits: { quantity: 2, conditionallyMinimumFractionDigits: 2 }
+  });
+};
+var formatAsPercentage = (value, settings) => {
+  const {
+    isCommonPercentageSymbol = true,
+    decimalPlaces = 2,
+    beforeValueSymbol = "",
+    afterValueSymbol = "",
+    isGlueSameRangesTogether = false,
+    // ? Тут удобный ф-л, поэтому иной раз удобно обработать обычный диапазан (НЕ проценты).
+    // ? Добавил возможность выпиливать значек процентов.
+    // todo(VL) - вообще правильно заренеймить (formatAsDiapason), а добавление процентов сделать как опцию,
+    // todo(VL) - но как обычно нет времени, нужно будет перечекать по всем проектам где тянется со старым неймингом
+    isUseAsSimpleDiapason = false
+  } = getIsOnlyAnObject(settings) ? settings : {};
+  let safelyInputValue;
+  const checkValue = (value2) => getSafelyValue(value2) || "0";
+  const transform = (valueAsSting) => {
+    const processedValue = valueAsSting.replace(/,/g, ".");
+    if (Number.isNaN(Number(processedValue))) return processedValue;
+    return `${intlNumbersFormatter(getSafelyValue(Number(processedValue)), {
+      fractionDigits: {
+        quantity: decimalPlaces,
+        minimumFractionDigits: decimalPlaces
+      }
+    })}`;
+  };
+  if (getIsOnlyAnObject(value)) {
+    safelyInputValue = {
+      from: checkValue(value.from),
+      to: checkValue(value.to)
+    };
+  } else {
+    safelyInputValue = checkValue(value);
+    if (safelyInputValue.includes(" - ")) {
+      const valuesArr = safelyInputValue.split(" - ").map((partOfValue) => partOfValue.trim());
+      safelyInputValue = {
+        from: checkValue(valuesArr[0]),
+        to: checkValue(valuesArr[1])
+      };
+    } else {
+      return `${beforeValueSymbol}${transform(safelyInputValue)}${afterValueSymbol}${isUseAsSimpleDiapason ? "" : "%"}`;
+    }
+  }
+  if (safelyInputValue.from === safelyInputValue.to && !!isGlueSameRangesTogether) {
+    return `${beforeValueSymbol}${transform(safelyInputValue.from)}${afterValueSymbol}${isUseAsSimpleDiapason ? "" : "%"}`;
+  }
+  if (isCommonPercentageSymbol)
+    return `${beforeValueSymbol}${transform(safelyInputValue.from)} - ${transform(
+      safelyInputValue.to
+    )}${afterValueSymbol}${isUseAsSimpleDiapason ? "" : "%"}`;
+  else
+    return `${beforeValueSymbol}${transform(safelyInputValue.from)}${isUseAsSimpleDiapason ? "" : "%"} - ${transform(
+      safelyInputValue.to
+    )}${isUseAsSimpleDiapason ? "" : "%"}${afterValueSymbol}`;
+};
+var formatToOnlyASCIICodeText = (text) => getSafelyValue(text).replace(/[^\x00-\x7F]+/g, "");
+var formatNumberValueToMask = (inputValue, settings) => {
+  const safelyInputValue = getSafelyValue(inputValue);
+  const {
+    mask = "XXX-XXX-XXXX",
+    valueSymbol = "X",
+    isReturnAdvanced = false
+  } = settings || {};
+  const processing = mask.split("").reduce(
+    (acc, item) => {
+      if (acc.value.length) ++acc.cursorPosition;
+      acc.newValue.push(
+        item === valueSymbol && acc.value.length ? acc.value.shift() : item
+      );
+      return acc;
+    },
+    {
+      value: safelyInputValue.split("").filter((sym) => /[0-9]/g.test(sym)),
+      newValue: [],
+      cursorPosition: 0
+    }
+  );
+  return isReturnAdvanced ? {
+    value: processing.newValue.join(""),
+    cursorPosition: processing.cursorPosition
+  } : processing.newValue.join("");
+};
+var formatToLimitLength = (inputValue, limit) => {
+  const value = getSafelyValue(inputValue);
+  return limit && typeof limit === "number" && !Number.isNaN(limit) && value?.length > limit ? value.substr(0, limit) : value;
+};
+var formatToHex = ({ inputValue, withSharp }) => {
+  const value = getSafelyValue(inputValue);
+  if (withSharp) return `#${value.replace(/[^a-f0-9]/gi, "")}`;
+  return `${value.replace(/[^#a-f0-9]/gi, "")}`;
+};
+function formatToReplaceAllWhiteSpace(str) {
+  const value = getSafelyValue(str);
+  return value.replace(/\s+/g, "");
+}
+var filterFloat = (inputValue, decimalPlaces) => {
+  const replaser = (input) => ("" + input).replace(/[^\.\d]/g, "");
+  const value = getSafelyValue(inputValue);
+  const safelyDecimalPlaces = (() => {
+    if (decimalPlaces === null) return decimalPlaces;
+    const DEFAULT_VALUE = 2;
+    const isNumber = typeof decimalPlaces === "number" || typeof decimalPlaces === "string" && !Number.isNaN(+decimalPlaces);
+    return isNumber ? Number((+decimalPlaces).toFixed()) : DEFAULT_VALUE;
+  })();
+  if (value.length === 1 && (value[0] === "." || value[0] === ",")) return "0.";
+  let output = ("" + value)?.replace(/,/g, ".");
+  if (value.length > 1 && value[0] === "0" && value[1] !== "." && value[0] !== ",") output = value.slice(1);
+  const previousValue = "" + output.slice(0, -1);
+  const lastSym = "" + output.slice(-1);
+  if (lastSym === "." && previousValue.includes(".")) output = previousValue;
+  if (typeof safelyDecimalPlaces === "number") {
+    if (!safelyDecimalPlaces && lastSym === ".") return replaser(previousValue);
+    if (previousValue.includes(".") && previousValue.indexOf(".") + 1 + safelyDecimalPlaces === previousValue?.length) {
+      return replaser(previousValue);
+    }
+  }
+  return replaser(output);
+};
+var filterNumeric = (value, settings) => {
+  value = getSafelyValue(value)?.replace(/,/g, "");
+  const { type = "float", decimalPlaces } = settings || {};
+  const executor = type === "float" ? filterFloat : formatOnlyNumbers;
+  return executor(getSafelyValue(value), decimalPlaces);
+};
+var formatToHideValuePartially = (value, settings) => {
+  const {
+    showSymbolsCount = 4,
+    isVisibleFromFront = false,
+    isCutOutWhiteSpaces = true
+  } = settings || {};
+  const safelyValue = getSafelyValue(value);
+  const newValue = isCutOutWhiteSpaces ? safelyValue.replace(/\s/g, "") : safelyValue;
+  if (newValue.length <= showSymbolsCount) return newValue;
+  const hide = (val) => val.split("").map(() => "*").join("");
+  const visiblePart = isVisibleFromFront ? newValue.slice(0, showSymbolsCount) : newValue.slice(-1 * showSymbolsCount);
+  const hiddenPart = isVisibleFromFront ? newValue.slice(showSymbolsCount) : newValue.slice(0, -1 * showSymbolsCount);
+  return isVisibleFromFront ? `${visiblePart}${hide(hiddenPart)}` : `${hide(hiddenPart)}${visiblePart}`;
+};
+
+// src/Functions/presets/inputPresets.js
+var NAME_SYMBOLS_EXCLUDER = {
+  /**
+   * @name fieldChangesMiddleware
+   * @description Обрабатывает входящую строку, удаляет все символы, которые не являются
+   * алфавитными, дефисами, апострофами или пробелами. Не дает ввести дубли символов дефиса или апострофа.
+   * Режет спецсимволы, если после них не идет буква.
+   *
+   * @param {string} value - Входная строка для обработки.
+   * @returns {string} - Обработанная строка.
+   */
+  fieldChangesMiddleware: (value) => {
+    const invalidCharacters = new RegExp(/[^a-zA-Z-\s']/g);
+    const sideBySideHyphenOrApostrophe = new RegExp(/['-]{2,}/g);
+    const multipleSpaces = new RegExp(/\s{2,}/g);
+    const beforeSpace = new RegExp(/['-](?=\s)/g);
+    const sanitizedValue = getSafelyValue(value).replace(invalidCharacters, "").replace(sideBySideHyphenOrApostrophe, "").replace(multipleSpaces, " ").replace(beforeSpace, "");
+    return sanitizedValue;
+  },
+  blurTrim: {
+    trimStart: true,
+    trimEnd: true,
+    characters: ["-", "'", " "]
+  }
+};
+var ONLY_STRING_AND_DASH = {
+  /**
+   * @name fieldChangesMiddleware
+   * @description Обрабатывает входную строку, удаляет все неалфавитные символы, заменяет двойные дефисы на одинарные
+   * и удаляет все дефисы в начале или конце строки.
+   * @param {string} value - входная строка для обработки
+   * @returns {string} обработанная строка
+   */
+  fieldChangesMiddleware: (value) => {
+    const nonAlphabeticAndNotSingleDash = new RegExp(/[^a-zA-Z-]|--/gi);
+    const consecutiveDashes = new RegExp(/-+/g);
+    const sanitizedInput = getSafelyValue(value);
+    return sanitizedInput.replace(nonAlphabeticAndNotSingleDash, "").replace(consecutiveDashes, "-");
+  }
+};
+var INPUT_PRESETS = {
+  NAME_SYMBOLS_EXCLUDER,
+  ONLY_STRING_AND_DASH
+};
+
+// src/Functions/presets/mobileKeyboardTypesPresets.js
+var ALL_KEYBOARD_TYPES = {
+  numeric: { inputMode: "decimal" },
+  email: { inputMode: "email" }
+};
+var NUMERIC_KEYBOARD = {
+  attributesOfNativeInput: ALL_KEYBOARD_TYPES.numeric
+};
+var EMAIL_KEYBOARD = {
+  attributesOfNativeInput: ALL_KEYBOARD_TYPES.email
+};
+//! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
+//! чем указано в quantity - округлит по правилам округления
+//! чем указано в decimalPlaces - округлит по правилам округления
+//# sourceMappingURL=presets.cjs.map