intelicoreact 1.3.19 → 1.3.21

package/dist/Functions/customEventListener.js

@@ -2,43 +2,57 @@
 
 (function () {
   Element.prototype._addEventListener = Element.prototype.addEventListener;
+
   Element.prototype.addEventListener = function (a, b, c) {
     if (c == undefined) c = false;
+
     this._addEventListener(a, b, c);
+
     if (!this.eventListenerList) this.eventListenerList = {};
-    if (!this.eventListenerList[a]) this.eventListenerList[a] = [];
-    //this.removeEventListener(a,b,c); // TODO - handle duplicates..
+    if (!this.eventListenerList[a]) this.eventListenerList[a] = []; //this.removeEventListener(a,b,c); // TODO - handle duplicates..
+
     this.eventListenerList[a].push({
       listener: b,
       useCapture: c
     });
   };
+
   Element.prototype.getEventListeners = function (a) {
     if (!this.eventListenerList) this.eventListenerList = {};
     if (a == undefined) return this.eventListenerList;
     return this.eventListenerList[a];
   };
+
   Element.prototype.clearEventListeners = function (a) {
     if (!this.eventListenerList) this.eventListenerList = {};
+
     if (a == undefined) {
-      for (var x in this.getEventListeners()) this.clearEventListeners(x);
+      for (var x in this.getEventListeners()) {
+        this.clearEventListeners(x);
+      }
+
       return;
     }
+
     var el = this.getEventListeners(a);
     if (el == undefined) return;
+
     for (var i = el.length - 1; i >= 0; --i) {
       var ev = el[i];
       this.removeEventListener(a, ev.listener, ev.useCapture);
     }
   };
+
   Element.prototype._removeEventListener = Element.prototype.removeEventListener;
+
   Element.prototype.removeEventListener = function (a, b, c) {
     if (c == undefined) c = false;
+
     this._removeEventListener(a, b, c);
+
     if (!this.eventListenerList) this.eventListenerList = {};
-    if (!this.eventListenerList[a]) this.eventListenerList[a] = [];
+    if (!this.eventListenerList[a]) this.eventListenerList[a] = []; // Find the event in the list
 
-    // Find the event in the list
     for (var i = 0; i < this.eventListenerList[a].length; i++) {
       if (this.eventListenerList[a][i].listener == b, this.eventListenerList[a][i].useCapture == c) {
         // Hmm..
@@ -46,6 +60,7 @@
         break;
       }
     }
+
     if (this.eventListenerList[a].length == 0) delete this.eventListenerList[a];
   };
 })();

package/dist/Functions/fieldValueFormatters.js

@@ -6,16 +6,15 @@ Object.defineProperty(exports, "__esModule", {
 exports.formatToRemoveComa = exports.formatToPriceWithUSD = exports.formatToPriceWithCurrency = exports.formatToOnlyASCIICodeText = exports.formatToLimitLength = exports.formatToHideValuePartially = exports.formatToHex = exports.formatToAddBitDepthPoints = exports.formatOnlyNumbers = exports.formatNumberValueToMask = exports.formatAsPercentage = exports.filterNumeric = exports.filterFloat = void 0;
 exports.formatToReplaceAllWhiteSpace = formatToReplaceAllWhiteSpace;
 exports.intlNumbersFormatter = exports.getSafelyValue = void 0;
+
 var _utils = require("./utils");
+
 //? The first word "format" in the function name means a logic
 //? in which the function transforms the incoming value in any case.
-
 //? The first word "transform" in the function name means a logic
 //? in which the function converts the whole value, but this is not suitable for sequential input
-
 //? The first word "filter" in the function name means a logic
 //? in which the function works as a changer for sequential input
-
 // ****************************
 // Base utils
 // ****************************
@@ -24,127 +23,149 @@ var _utils = require("./utils");
  * If the value is not undefined or null, return the value's toString() method, otherwise return an
  * empty string.
  */
-const getSafelyValue = value => {
+var getSafelyValue = function getSafelyValue(value) {
   var _value$toString;
-  return value !== undefined && value !== null ? (value === null || value === void 0 || (_value$toString = value.toString) === null || _value$toString === void 0 ? void 0 : _value$toString.call(value)) || '' : '';
-};
 
-// базовая реализация
+  return value !== undefined && value !== null ? (value === null || value === void 0 ? void 0 : (_value$toString = value.toString) === null || _value$toString === void 0 ? void 0 : _value$toString.call(value)) || '' : '';
+}; // базовая реализация
+
+
 exports.getSafelyValue = getSafelyValue;
-const intlNumbersFormatter = function (inputValue) {
-  let settings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  const safelyInputValue = getSafelyValue(inputValue);
-  const previousValue = safelyInputValue.slice(0, -1);
-  const lastSym = safelyInputValue.slice(-1);
-  let value = lastSym === '.' ? previousValue : safelyInputValue;
+
+var intlNumbersFormatter = function intlNumbersFormatter(inputValue) {
+  var settings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var safelyInputValue = getSafelyValue(inputValue);
+  var previousValue = safelyInputValue.slice(0, -1);
+  var lastSym = safelyInputValue.slice(-1);
+  var value = lastSym === '.' ? previousValue : safelyInputValue;
   if (Number.isNaN(+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;
+  var _settings$locale = settings.locale,
+      locale = _settings$locale === void 0 ? 'en-US' : _settings$locale,
+      withSymbol = settings.withSymbol,
+      _settings$useGrouping = settings.useGrouping,
+      useGrouping = _settings$useGrouping === void 0 ? true : _settings$useGrouping,
+      _settings$currency = settings.currency,
+      currency = _settings$currency === void 0 ? {} : _settings$currency,
+      _settings$fractionDig = settings.fractionDigits,
+      fractionDigits = _settings$fractionDig === void 0 ? {} : _settings$fractionDig;
+  var _currency$currencyTyp = currency.currencyType,
+      currencyType = _currency$currencyTyp === void 0 ? 'USD' : _currency$currencyTyp,
+      inputCurrencyDisplay = currency.currencyDisplay;
+  var currencyDisplay;
+
   switch (inputCurrencyDisplay) {
     case 'name':
       currencyDisplay = 'name';
       break;
+
     case 'code':
       currencyDisplay = 'code';
       break;
+
     case 'narrowSymbol':
       currencyDisplay = 'narrowSymbol';
       break;
+
     default:
       currencyDisplay = 'symbol';
   }
-  let numberStyle;
+
+  var 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 === null || safelyInputValue === void 0 ? void 0 : safelyInputValue.indexOf('.');
-  const afterDot = dotIndex !== -1 ? safelyInputValue.slice(dotIndex + 1) : '';
-  const minimumFractionDigits = (() => {
+
+  var quantity = fractionDigits.quantity,
+      _fractionDigits$isRen = fractionDigits.isRenderAlways,
+      isRenderAlways = _fractionDigits$isRen === void 0 ? false : _fractionDigits$isRen,
+      inputMinimumFractionDigits = fractionDigits.minimumFractionDigits,
+      inputMaximumFractionDigits = fractionDigits.maximumFractionDigits,
+      conditionallyMinimumFractionDigits = fractionDigits.conditionallyMinimumFractionDigits;
+  var dotIndex = safelyInputValue === null || safelyInputValue === void 0 ? void 0 : safelyInputValue.indexOf('.');
+  var afterDot = dotIndex !== -1 ? safelyInputValue.slice(dotIndex + 1) : '';
+
+  var minimumFractionDigits = function () {
     //? Безусловное минимальное количество. Всегда отрендерит дробную часть, в количестве символов сколько указано
-    if (typeof inputMinimumFractionDigits === 'number') return inputMinimumFractionDigits;
-    //? Условное минимальное количество. Если есть дробная часть, то отрендерит дробных символов сколько указано
+    if (typeof inputMinimumFractionDigits === 'number') return inputMinimumFractionDigits; //? Условное минимальное количество. Если есть дробная часть, то отрендерит дробных символов сколько указано
+
     if (typeof conditionallyMinimumFractionDigits === 'number') {
       return afterDot && lastSym !== '.' ? conditionallyMinimumFractionDigits : 0;
-    }
-    //? Дефолтное минимальное количество. Если есть дробная часть, то отрендерит дробных символов столько, сколько есть
+    } //? Дефолтное минимальное количество. Если есть дробная часть, то отрендерит дробных символов столько, сколько есть
     //? Флаг isRenderAlways превращает дефолтный кейс в безусловное минимальное количество
+
+
     return afterDot && lastSym !== '.' ? safelyInputValue.slice(dotIndex).length - 1 : isRenderAlways ? quantity : 0;
-  })();
-  const priceSettings = {
-    useGrouping,
+  }();
+
+  var priceSettings = {
+    useGrouping: useGrouping,
     //группировка разрядов
     style: numberStyle,
     //тип форматирования (валюта или число). decimal - без знака валюты
     currency: currencyType,
     //валюта
-    currencyDisplay,
+    currencyDisplay: currencyDisplay,
     //валюта в виде символа
     //минимально не надо отображать центы, если их нет, иначе всегда будет .00
-    minimumFractionDigits,
+    minimumFractionDigits: minimumFractionDigits,
     //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
     //! чем указано в (inputMaximumFractionDigits ?? quantity) - округлит по правилам округления
     //максимально отображать 2 цифры после запятой, если центы всё же есть
     maximumFractionDigits: inputMaximumFractionDigits !== null && inputMaximumFractionDigits !== void 0 ? inputMaximumFractionDigits : quantity
   };
-  let output;
+  var 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;
-};
 
-// ****************************
+  return lastSym === '.' ? output + lastSym : output;
+}; // ****************************
 // format
 // ****************************
+
+
 exports.intlNumbersFormatter = intlNumbersFormatter;
-const formatOnlyNumbers = value => getSafelyValue(value).replace(/\D/g, '');
+
+var formatOnlyNumbers = function formatOnlyNumbers(value) {
+  return getSafelyValue(value).replace(/\D/g, '');
+};
+
 exports.formatOnlyNumbers = formatOnlyNumbers;
-const formatToRemoveComa = value => getSafelyValue(value).replace(/,/g, '');
+
+var formatToRemoveComa = function formatToRemoveComa(value) {
+  return getSafelyValue(value).replace(/,/g, '');
+};
+
 exports.formatToRemoveComa = formatToRemoveComa;
-const formatToAddBitDepthPoints = (value, settings) => intlNumbersFormatter(getSafelyValue(value), {
-  fractionDigits: {
-    quantity: (settings === null || settings === void 0 ? void 0 : settings.type) === 'int' ? 0 : settings === null || settings === void 0 ? void 0 : settings.decimalPlaces
-  }
-});
 
-//! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
+var formatToAddBitDepthPoints = function formatToAddBitDepthPoints(value, settings) {
+  return intlNumbersFormatter(getSafelyValue(value), {
+    fractionDigits: {
+      quantity: (settings === null || settings === void 0 ? void 0 : settings.type) === 'int' ? 0 : settings === null || settings === void 0 ? void 0 : settings.decimalPlaces
+    }
+  });
+}; //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
 //! чем указано в quantity - округлит по правилам округления
+
+
 exports.formatToAddBitDepthPoints = formatToAddBitDepthPoints;
-const formatToPriceWithUSD = value => {
+
+var formatToPriceWithUSD = function formatToPriceWithUSD(value) {
   if (isNaN(Number(value))) return value;
   return intlNumbersFormatter(getSafelyValue(value), {
     withSymbol: 'currency',
@@ -156,15 +177,15 @@ const formatToPriceWithUSD = value => {
       conditionallyMinimumFractionDigits: 2
     }
   });
-};
-
-//! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
+}; //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
 //! чем указано в quantity - округлит по правилам округления
-
 // ToDo - symbolPosition временно не реализовано
+
+
 exports.formatToPriceWithUSD = formatToPriceWithUSD;
-const formatToPriceWithCurrency = function (value, currencyCode) {
-  let symbolPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'before';
+
+var formatToPriceWithCurrency = function formatToPriceWithCurrency(value, currencyCode) {
+  var symbolPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'before';
   if (isNaN(Number(value))) return value;
   return intlNumbersFormatter(getSafelyValue(value), {
     withSymbol: 'currency',
@@ -176,38 +197,42 @@ const formatToPriceWithCurrency = function (value, currencyCode) {
       conditionallyMinimumFractionDigits: 2
     }
   });
-};
-
-//? Добавляет в конец знак %. Работает как с одиночными значениями, так и с диапазонами.
-
+}; //? Добавляет в конец знак %. Работает как с одиночными значениями, так и с диапазонами.
 //? value может быть любое, но ожидается что будет
 //?   - числом
 //?   - строкой в формате "значение"
 //?   - строкой в формате "значение - значение" (значение_пробел_тире_пробел_значение)
 //?   - объект в формате { from: значение, to: значение }
-
 //? Предполагается, что "значение" может быть приведено к числу операторм + (пример: +значение приводится к числу).
 //? Если не может быть приведено, то "значение" вернется как есть, к результату добавится %
-
 //? Если "значение" пустое (getSafelyValue(значение) вернет пустую строку),
 //? то это воспринимается как 0, приводится к 0.00%
-
 //? Одиноково работает как для ".", так и "," в качестве разделителя дробных разрядов
-
 //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
 //! чем указано в decimalPlaces - округлит по правилам округления
+
+
 exports.formatToPriceWithCurrency = formatToPriceWithCurrency;
-const formatAsPercentage = (value, settings) => {
-  const {
-    isCommonPercentageSymbol = true,
-    decimalPlaces = 2,
-    beforeValueSymbol = '',
-    afterValueSymbol = ''
-  } = (0, _utils.getIsOnlyAnObject)(settings) ? settings : {};
-  let safelyInputValue;
-  const checkValue = value => getSafelyValue(value) || '0';
-  const transform = valueAsSting => {
-    const processedValue = valueAsSting.replace(/,/g, '.');
+
+var formatAsPercentage = function formatAsPercentage(value, settings) {
+  var _ref = (0, _utils.getIsOnlyAnObject)(settings) ? settings : {},
+      _ref$isCommonPercenta = _ref.isCommonPercentageSymbol,
+      isCommonPercentageSymbol = _ref$isCommonPercenta === void 0 ? true : _ref$isCommonPercenta,
+      _ref$decimalPlaces = _ref.decimalPlaces,
+      decimalPlaces = _ref$decimalPlaces === void 0 ? 2 : _ref$decimalPlaces,
+      _ref$beforeValueSymbo = _ref.beforeValueSymbol,
+      beforeValueSymbol = _ref$beforeValueSymbo === void 0 ? '' : _ref$beforeValueSymbo,
+      _ref$afterValueSymbol = _ref.afterValueSymbol,
+      afterValueSymbol = _ref$afterValueSymbol === void 0 ? '' : _ref$afterValueSymbol;
+
+  var safelyInputValue;
+
+  var checkValue = function checkValue(value) {
+    return getSafelyValue(value) || '0';
+  };
+
+  var transform = function transform(valueAsSting) {
+    var processedValue = valueAsSting.replace(/,/g, '.');
     if (Number.isNaN(+processedValue)) return processedValue;
     return "".concat(intlNumbersFormatter(getSafelyValue(+processedValue), {
       fractionDigits: {
@@ -216,6 +241,7 @@ const formatAsPercentage = (value, settings) => {
       }
     }));
   };
+
   if ((0, _utils.getIsOnlyAnObject)(value)) {
     safelyInputValue = {
       from: checkValue(value.from),
@@ -223,8 +249,11 @@ const formatAsPercentage = (value, settings) => {
     };
   } else {
     safelyInputValue = checkValue(value);
+
     if (safelyInputValue.includes(' - ')) {
-      const valuesArr = safelyInputValue.split(' - ').map(partOfValue => partOfValue.trim());
+      var valuesArr = safelyInputValue.split(' - ').map(function (partOfValue) {
+        return partOfValue.trim();
+      });
       safelyInputValue = {
         from: checkValue(valuesArr[0]),
         to: checkValue(valuesArr[1])
@@ -233,30 +262,39 @@ const formatAsPercentage = (value, settings) => {
       return "".concat(beforeValueSymbol).concat(transform(safelyInputValue)).concat(afterValueSymbol, "%");
     }
   }
+
   if (isCommonPercentageSymbol) return "".concat(beforeValueSymbol).concat(transform(safelyInputValue.from), " - ").concat(transform(safelyInputValue.to)).concat(afterValueSymbol, "%");else return "".concat(beforeValueSymbol).concat(transform(safelyInputValue.from), "% - ").concat(transform(safelyInputValue.to), "%").concat(afterValueSymbol);
-};
+}; // eslint-disable-next-line no-control-regex
+
 
-// eslint-disable-next-line no-control-regex
 exports.formatAsPercentage = formatAsPercentage;
-const formatToOnlyASCIICodeText = text => getSafelyValue(text).replace(/[^\x00-\x7F]+/g, '');
 
-// eslint-disable-next-line default-param-last
+var formatToOnlyASCIICodeText = function formatToOnlyASCIICodeText(text) {
+  return getSafelyValue(text).replace(/[^\x00-\x7F]+/g, '');
+}; // eslint-disable-next-line default-param-last
+
+
 exports.formatToOnlyASCIICodeText = formatToOnlyASCIICodeText;
-const formatNumberValueToMask = (inputValue, settings) => {
-  const safelyInputValue = getSafelyValue(inputValue);
-
-  // default valueSymbol === 'n', default mask === 'nnn-nnn-nnnn'
-  const {
-    mask = 'XXX-XXX-XXXX',
-    valueSymbol = 'X',
-    isReturnAdvanced = false
-  } = settings || {};
-  const processing = mask.split('').reduce((acc, item) => {
+
+var formatNumberValueToMask = function formatNumberValueToMask(inputValue, settings) {
+  var safelyInputValue = getSafelyValue(inputValue); // default valueSymbol === 'n', default mask === 'nnn-nnn-nnnn'
+
+  var _ref2 = settings || {},
+      _ref2$mask = _ref2.mask,
+      mask = _ref2$mask === void 0 ? 'XXX-XXX-XXXX' : _ref2$mask,
+      _ref2$valueSymbol = _ref2.valueSymbol,
+      valueSymbol = _ref2$valueSymbol === void 0 ? 'X' : _ref2$valueSymbol,
+      _ref2$isReturnAdvance = _ref2.isReturnAdvanced,
+      isReturnAdvanced = _ref2$isReturnAdvance === void 0 ? false : _ref2$isReturnAdvance;
+
+  var processing = mask.split('').reduce(function (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)),
+    value: safelyInputValue.split('').filter(function (sym) {
+      return /[0-9]/g.test(sym);
+    }),
     newValue: [],
     cursorPosition: 0
   });
@@ -265,50 +303,49 @@ const formatNumberValueToMask = (inputValue, settings) => {
     cursorPosition: processing.cursorPosition
   } : processing.newValue.join('');
 };
+
 exports.formatNumberValueToMask = formatNumberValueToMask;
-const formatToLimitLength = (inputValue, limit) => {
-  const value = getSafelyValue(inputValue);
+
+var formatToLimitLength = function formatToLimitLength(inputValue, limit) {
+  var value = getSafelyValue(inputValue);
   return limit && typeof limit === 'number' && !Number.isNaN(limit) && (value === null || value === void 0 ? void 0 : value.length) > limit ? value.substr(0, limit) : value;
 };
-
 /**
  * It takes a string and returns a hexadecimal string
  * @param inputValue - The value to be formatted.
  * @param withSharp - boolean - if true, the returned value will have a sharp (#) at the beginning.
  * @returns A function that takes two arguments, inputValue and withSharp.
  */
+
+
 exports.formatToLimitLength = formatToLimitLength;
-const formatToHex = _ref => {
-  let {
-    inputValue,
-    withSharp
-  } = _ref;
-  const value = getSafelyValue(inputValue);
+
+var formatToHex = function formatToHex(_ref3) {
+  var inputValue = _ref3.inputValue,
+      withSharp = _ref3.withSharp;
+  var value = getSafelyValue(inputValue);
   if (withSharp) return "#".concat(value.replace(/[^a-f0-9]/gi, ''));
   return "".concat(value.replace(/[^#a-f0-9]/gi, ''));
 };
-
 /**
  * It takes a string and returns a string with all white space removed
  * @param str - The string to be formatted.
  * @returns A string with all white space removed.
  */
+
+
 exports.formatToHex = formatToHex;
+
 function formatToReplaceAllWhiteSpace(str) {
-  let value = getSafelyValue(str);
+  var value = getSafelyValue(str);
   return value.replace(/\s+/g, '');
-}
-
-// ****************************
+} // ****************************
 // transform
 // ****************************
-
 // ...
-
 // ****************************
 // filter
 // ****************************
-
 // export const filterFloat = (inputValue, decimalPlaces = null) => {
 //   const value = getSafelyValue(inputValue);
 //   const replaser = input => ('' + input).replace(/[^\.\d]/g, '');
@@ -330,51 +367,77 @@ function formatToReplaceAllWhiteSpace(str) {
 //   return replaser(lastSym === '.' && previousValue.includes('.') ? previousValue : output);
 // };
 
-const filterFloat = function (inputValue) {
+
+var filterFloat = function filterFloat(inputValue) {
   var _output, _output2, _output3, _output4;
-  let decimalPlaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  const value = getSafelyValue(inputValue);
-  const replacer = input => {
-    var _ref2;
-    return (_ref2 = '' + input) === null || _ref2 === void 0 ? void 0 : _ref2.replace(/[^\.\d,]/g, '');
+
+  var decimalPlaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var value = getSafelyValue(inputValue);
+
+  var replacer = function replacer(input) {
+    var _ref4;
+
+    return (_ref4 = '' + input) === null || _ref4 === void 0 ? void 0 : _ref4.replace(/[^\.\d,]/g, '');
   };
+
   if (value.length === 1 && (value[0] === '.' || value[0] === ',')) return '0.';
-  let output = value;
-  const previousValue = '' + ((_output = output) === null || _output === void 0 ? void 0 : _output.slice(0, -1));
-  const lastSym = '' + ((_output2 = output) === null || _output2 === void 0 ? void 0 : _output2.slice(-1));
+  var output = value;
+  var previousValue = '' + ((_output = output) === null || _output === void 0 ? void 0 : _output.slice(0, -1));
+  var lastSym = '' + ((_output2 = output) === null || _output2 === void 0 ? void 0 : _output2.slice(-1));
+
   if (decimalPlaces && typeof decimalPlaces === 'number' && previousValue !== null && previousValue !== void 0 && previousValue.includes('.') && (previousValue === null || previousValue === void 0 ? void 0 : previousValue.indexOf('.')) + 1 + decimalPlaces === (previousValue === null || previousValue === void 0 ? void 0 : previousValue.length)) {
     return replacer(previousValue);
   }
+
   if ((_output3 = output) !== null && _output3 !== void 0 && _output3.includes('.') && output[((_output4 = output) === null || _output4 === void 0 ? void 0 : _output4.indexOf('.')) + 3] !== undefined && Number(output)) {
     var _Number;
+
     output = (_Number = Number(output)) === null || _Number === void 0 ? void 0 : _Number.toFixed(decimalPlaces);
   }
+
   return replacer(lastSym === '.' && previousValue !== null && previousValue !== void 0 && previousValue.includes('.') ? previousValue : output);
 };
+
 exports.filterFloat = filterFloat;
-const filterNumeric = (value, settings) => {
+
+var filterNumeric = function filterNumeric(value, settings) {
   var _getSafelyValue;
+
   value = (_getSafelyValue = getSafelyValue(value)) === null || _getSafelyValue === void 0 ? void 0 : _getSafelyValue.replace(/,/g, '');
-  const {
-    type = 'float',
-    decimalPlaces
-  } = settings || {};
-  const executor = type === 'float' ? filterFloat : formatOnlyNumbers;
+
+  var _ref5 = settings || {},
+      _ref5$type = _ref5.type,
+      type = _ref5$type === void 0 ? 'float' : _ref5$type,
+      decimalPlaces = _ref5.decimalPlaces;
+
+  var executor = type === 'float' ? filterFloat : formatOnlyNumbers;
   return executor(getSafelyValue(value), decimalPlaces);
 };
+
 exports.filterNumeric = filterNumeric;
-const formatToHideValuePartially = (value, settings) => {
-  const {
-    showSymbolsCount = 4,
-    isVisibleFromFront = false,
-    isCutOutWhiteSpaces = true
-  } = settings || {};
-  const safelyValue = getSafelyValue(value);
-  let newValue = isCutOutWhiteSpaces ? safelyValue.replace(/\s/g, '') : safelyValue;
+
+var formatToHideValuePartially = function formatToHideValuePartially(value, settings) {
+  var _ref6 = settings || {},
+      _ref6$showSymbolsCoun = _ref6.showSymbolsCount,
+      showSymbolsCount = _ref6$showSymbolsCoun === void 0 ? 4 : _ref6$showSymbolsCoun,
+      _ref6$isVisibleFromFr = _ref6.isVisibleFromFront,
+      isVisibleFromFront = _ref6$isVisibleFromFr === void 0 ? false : _ref6$isVisibleFromFr,
+      _ref6$isCutOutWhiteSp = _ref6.isCutOutWhiteSpaces,
+      isCutOutWhiteSpaces = _ref6$isCutOutWhiteSp === void 0 ? true : _ref6$isCutOutWhiteSp;
+
+  var safelyValue = getSafelyValue(value);
+  var 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);
+
+  var hide = function hide(val) {
+    return val.split('').map(function () {
+      return '*';
+    }).join('');
+  };
+
+  var visiblePart = isVisibleFromFront ? newValue.slice(0, showSymbolsCount) : newValue.slice(-1 * showSymbolsCount);
+  var hiddenPart = isVisibleFromFront ? newValue.slice(showSymbolsCount) : newValue.slice(0, -1 * showSymbolsCount);
   return isVisibleFromFront ? "".concat(visiblePart).concat(hide(hiddenPart)) : "".concat(hide(hiddenPart)).concat(visiblePart);
 };
+
 exports.formatToHideValuePartially = formatToHideValuePartially;