@alfalab/core-components-number-input 1.3.0 → 2.0.1

package/src/utils.ts

@@ -1,46 +1,324 @@
-export const SIGNS = ['-', '+'];
+/* eslint-disable no-param-reassign */
+import {
+    MaskitoOptions,
+    MaskitoPlugin,
+    MaskitoPostprocessor,
+    MaskitoPreprocessor,
+    maskitoTransform,
+} from '@maskito/core';
+
+import { fnUtils } from '@alfalab/core-components-shared';
+
+export const MINUS_SIGN = '-';
 export const SEPARATORS = [',', '.'];
+export const MAX_SAFE_INTEGER = 2 ** 53 - 1;
+export const MIN_SAFE_INTEGER = -MAX_SAFE_INTEGER;
+export const MAX_DIGITS = 15; // с 16 уже упираемся в MAX_SAFE_INTEGER
+
+export function parseNumber(value: string | number | null = '') {
+    if (typeof value === 'number') return value;
+
+    const pseudoSeparatorsRegExp = new RegExp(`[${SEPARATORS.join('')}]`, 'gi');
+
+    return value
+        ? parseFloat(
+              value
+                  .replace(new RegExp(`[^${MINUS_SIGN}${SEPARATORS.join('')}0-9]`, 'gi'), '')
+                  .replace(pseudoSeparatorsRegExp, '.'),
+          )
+        : NaN;
+}
+
+/**
+ * Преобразовать число в строку с заменой экспоненты на десятичную дробь
+ */
+export function stringifyNumberWithoutExp(value: number): string {
+    const valueString = String(value);
+    const [numberPart, expPart] = valueString.split('e-');
+
+    let valueWithoutExp = valueString;
 
-export function createSeparatorsRegExp() {
-    return new RegExp(`[${SEPARATORS.map((s) => `\\${s}`).join('')}]`, 'g');
+    if (expPart) {
+        const [, fractionalPart] = numberPart.split('.');
+        const decimalDigits = Number(expPart) + (fractionalPart?.length || 0);
+
+        valueWithoutExp = value.toFixed(decimalDigits);
+    }
+
+    return valueWithoutExp;
 }
 
-const getNumberRegExp = (fractionLength?: number): RegExp => {
-    let reStr = '[0-9]+';
+const getNumberRegExp = (min: number, fractionLength: number): RegExp => {
+    let reStr = '[0-9]*';
+
+    if (min < 0) {
+        reStr = `(\\${MINUS_SIGN})?${reStr}`;
+    }
 
     if (fractionLength !== 0) {
         reStr = `${reStr}[${SEPARATORS.map((s) => `\\${s}`).join('')}]?[0-9]{0,${
-            fractionLength || Number.MAX_SAFE_INTEGER
+            fractionLength || MAX_DIGITS
         }}`;
     }
 
     return new RegExp(`^${reStr}$`);
 };
 
+export function createMaskOptions({
+    separator,
+    fractionLength,
+    min,
+    max,
+}: {
+    separator: string;
+    fractionLength: number;
+    min: number;
+    max: number;
+}): MaskitoOptions {
+    return {
+        mask: getNumberRegExp(min, fractionLength),
+        preprocessors: [
+            createPseudoSeparatorPreprocessor(separator),
+            createNotEmptyIntegerPartPreprocessor({ separator, fractionLength }),
+            createZeroFractionLengthPreprocessor(fractionLength, separator),
+            createRepeatedSeparatorPreprocessor(separator),
+        ],
+        postprocessors: [
+            createLeadingZeroesValidationPostprocessor(separator),
+            createMinMaxPostprocessor({ min, max, separator }),
+        ],
+        plugins: [createNotEmptyPartsPlugin(separator), createMinMaxPlugin({ min, max })],
+    };
+}
+
 /**
- * Проверка вводимых значений.
+ *  Заполняет целочисленную часть при вводе separator.
+ *  @example Type , => 0,
  */
-export const getAllowedValue = ({
-    value = '',
-    fractionLength,
+function createNotEmptyIntegerPartPreprocessor({
     separator,
-    allowSigns,
+    fractionLength,
 }: {
-    value: string;
-    fractionLength?: number;
     separator: string;
-    allowSigns: boolean;
-}): string => {
-    const sign = allowSigns && SIGNS.some((s) => s === value[0]) ? value[0] : '';
-    const testedValue = sign ? value.slice(1) : value;
+    fractionLength: number;
+}): MaskitoPreprocessor {
+    const startWithDecimalSepRegExp = new RegExp(`^\\D*\\${separator}`);
+
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+        const [from] = selection;
+
+        if (
+            fractionLength <= 0 ||
+            value.includes(separator) ||
+            !data.match(startWithDecimalSepRegExp)
+        ) {
+            return { elementState, data };
+        }
 
-    if (getNumberRegExp(fractionLength).test(testedValue)) {
-        return value;
+        const digitsBeforeCursor = value.slice(0, from).match(/\d+/);
+
+        return {
+            elementState,
+            data: digitsBeforeCursor ? data : `0${data}`,
+        };
+    };
+}
+
+/**
+ * Не позволяет вводить невалидный разделитель.
+ */
+function createPseudoSeparatorPreprocessor(separator: string): MaskitoPreprocessor {
+    const pseudoSeparatorsRegExp = new RegExp(`[${SEPARATORS.join('')}]`, 'gi');
+
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+
+        return {
+            elementState: {
+                selection,
+                value: value.replace(pseudoSeparatorsRegExp, separator),
+            },
+            data: data.replace(pseudoSeparatorsRegExp, separator),
+        };
+    };
+}
+
+/**
+ * Помогает верно обрезать значения при вставке, если fractionLength===0
+ * @example paste 123,123 -> 123
+ */
+function createZeroFractionLengthPreprocessor(
+    fractionLength: number,
+    separator: string,
+): MaskitoPreprocessor {
+    if (fractionLength > 0) {
+        return (state) => state;
     }
 
-    const [majorPart, minorPart] = testedValue
-        .split(separator)
-        .map((v) => v.replace(/[^0-9]/g, ''));
+    const decimalPartRegExp = new RegExp(`\\${separator}.*$`, 'g');
 
-    return `${sign}${majorPart}${minorPart ? separator + minorPart.slice(0, fractionLength) : ''}`;
-};
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+        const [from, to] = selection;
+        const newValue = value.replace(decimalPartRegExp, '');
+
+        return {
+            elementState: {
+                selection: [Math.min(from, newValue.length), Math.min(to, newValue.length)],
+                value: newValue,
+            },
+            data: data.replace(decimalPartRegExp, ''),
+        };
+    };
+}
+
+/**
+ *  Запрещает вводить второй сепаратор
+ */
+function createRepeatedSeparatorPreprocessor(separator: string): MaskitoPreprocessor {
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+        const [from, to] = selection;
+
+        return {
+            elementState,
+            data:
+                !value.includes(separator) || value.slice(from, to + 1).includes(separator)
+                    ? data
+                    : data.replace(new RegExp(`\\${separator}`), ''),
+        };
+    };
+}
+
+/**
+ * Удаляет лишние нули в начале целой части.
+ * @example 0,|00005 => Backspace => |5
+ * @example -0,|00005 => Backspace => -|5
+ * @example "000000" => 0|
+ * @example 0| => Type "5" => 5|
+ */
+function createLeadingZeroesValidationPostprocessor(separator: string): MaskitoPostprocessor {
+    const trimLeadingZeroes = (value: string): string =>
+        value
+            .replace(new RegExp('^(\\D+)?0+(?=0)'), '$1')
+            .replace(new RegExp('^(\\D+)?0+(?=[1-9])'), '$1');
+
+    const countTrimmedZeroesBefore = (value: string, index: number): number => {
+        const valueBefore = value.slice(0, index);
+        const followedByZero = value.slice(index).startsWith('0');
+
+        return (
+            valueBefore.length - trimLeadingZeroes(valueBefore).length + (followedByZero ? 1 : 0)
+        );
+    };
+
+    return ({ value, selection }) => {
+        const [from, to] = selection;
+        const hasSeparator = value.includes(separator);
+        const [integerPart, decimalPart = ''] = value.split(separator);
+        const zeroTrimmedIntegerPart = trimLeadingZeroes(integerPart);
+
+        if (integerPart === zeroTrimmedIntegerPart) {
+            return { value, selection };
+        }
+
+        const newFrom = from - countTrimmedZeroesBefore(value, from);
+        const newTo = to - countTrimmedZeroesBefore(value, to);
+
+        return {
+            value: zeroTrimmedIntegerPart + (hasSeparator ? separator : '') + decimalPart,
+            selection: [Math.max(newFrom, 0), Math.max(newTo, 0)],
+        };
+    };
+}
+
+/**
+ * Валидирует значение с учетом min max значений.
+ * Работает совместно с createMinMaxPlugin
+ */
+function createMinMaxPostprocessor({
+    min,
+    max,
+    separator,
+}: {
+    min: number;
+    max: number;
+    separator: string;
+}): MaskitoPostprocessor {
+    return ({ value, selection }) => {
+        const parsedNumber = parseNumber(value);
+
+        const limitedValue =
+            /**
+             * Здесь невозможно ограничить нижнюю границу, если пользователь вводит положительное число.
+             * То же самое для верхней границы и отрицательного числа.
+             * Если min=5, то без этого условия не получится ввести 40, похожая ситуация и с отрицательным max
+             */
+            parsedNumber > 0 ? Math.min(parsedNumber, max) : Math.max(parsedNumber, min);
+
+        if (!Number.isNaN(parsedNumber) && limitedValue !== parsedNumber) {
+            const newValue = `${limitedValue}`.replace('.', separator);
+
+            return {
+                value: newValue,
+                selection: [newValue.length, newValue.length],
+            };
+        }
+
+        return {
+            value,
+            selection,
+        };
+    };
+}
+
+export function createMinMaxPlugin({ min, max }: { min: number; max: number }): MaskitoPlugin {
+    return (element, options) => {
+        const listener = () => {
+            const parsedNumber = parseNumber(element.value);
+
+            const clampedNumber = fnUtils.clamp(parsedNumber, min, max);
+
+            if (!Number.isNaN(parsedNumber) && parsedNumber !== clampedNumber) {
+                element.value = maskitoTransform(stringifyNumberWithoutExp(clampedNumber), options);
+                element.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        };
+
+        const evListenerOptions = { capture: true };
+
+        element.addEventListener('blur', listener, evListenerOptions);
+
+        return () => element.removeEventListener('blur', listener, evListenerOptions);
+    };
+}
+
+export function createNotEmptyPartsPlugin(separator: string): MaskitoPlugin {
+    return (element) => {
+        const listener = () => {
+            const newValue = element.value
+                // 0,9000000 -> 0,9
+                .replace(new RegExp(`(\\${separator}\\d*?)(0+$)`), '$1')
+                // ,2 => 0,2
+                .replace(new RegExp(`^(\\D+)?\\${separator}`), `$10${separator}`)
+                // 0, -> 0
+                .replace(new RegExp(`\\${separator}$`), '')
+                // -0 -> 0
+                .replace(new RegExp(`^${MINUS_SIGN}0$`), '0')
+                // - -> ''
+                .replace(new RegExp(`^${MINUS_SIGN}$`), '');
+
+            if (newValue !== element.value) {
+                element.value = newValue;
+                element.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        };
+
+        const evListenerOptions = { capture: true };
+
+        element.addEventListener('blur', listener, evListenerOptions);
+
+        return () => element.removeEventListener('blur', listener, evListenerOptions);
+    };
+}

package/utils.d.ts

@@ -1,13 +1,23 @@
-declare const SIGNS: string[];
+import { MaskitoOptions, MaskitoPlugin } from '@maskito/core';
+declare const MINUS_SIGN = "-";
 declare const SEPARATORS: string[];
-declare function createSeparatorsRegExp(): RegExp;
+declare const MAX_SAFE_INTEGER: number;
+declare const MIN_SAFE_INTEGER: number;
+declare const MAX_DIGITS = 15;
+declare function parseNumber(value?: string | number | null): number;
 /**
- * Проверка вводимых значений.
+ * Преобразовать число в строку с заменой экспоненты на десятичную дробь
  */
-declare const getAllowedValue: ({ value, fractionLength, separator, allowSigns, }: {
-    value: string;
-    fractionLength?: number | undefined;
+declare function stringifyNumberWithoutExp(value: number): string;
+declare function createMaskOptions({ separator, fractionLength, min, max, }: {
     separator: string;
-    allowSigns: boolean;
-}) => string;
-export { SIGNS, SEPARATORS, createSeparatorsRegExp, getAllowedValue };
+    fractionLength: number;
+    min: number;
+    max: number;
+}): MaskitoOptions;
+declare function createMinMaxPlugin({ min, max }: {
+    min: number;
+    max: number;
+}): MaskitoPlugin;
+declare function createNotEmptyPartsPlugin(separator: string): MaskitoPlugin;
+export { MINUS_SIGN, SEPARATORS, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, MAX_DIGITS, parseNumber, stringifyNumberWithoutExp, createMaskOptions, createMinMaxPlugin, createNotEmptyPartsPlugin };

package/utils.js

@@ -2,35 +2,258 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var SIGNS = ['-', '+'];
+var core = require('@maskito/core');
+var coreComponentsShared = require('@alfalab/core-components-shared');
+
+/* eslint-disable no-param-reassign */
+var MINUS_SIGN = '-';
 var SEPARATORS = [',', '.'];
-function createSeparatorsRegExp() {
-    return new RegExp("[".concat(SEPARATORS.map(function (s) { return "\\".concat(s); }).join(''), "]"), 'g');
+var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
+var MIN_SAFE_INTEGER = -MAX_SAFE_INTEGER;
+var MAX_DIGITS = 15; // с 16 уже упираемся в MAX_SAFE_INTEGER
+function parseNumber(value) {
+    if (value === void 0) { value = ''; }
+    if (typeof value === 'number')
+        return value;
+    var pseudoSeparatorsRegExp = new RegExp("[".concat(SEPARATORS.join(''), "]"), 'gi');
+    return value
+        ? parseFloat(value
+            .replace(new RegExp("[^".concat(MINUS_SIGN).concat(SEPARATORS.join(''), "0-9]"), 'gi'), '')
+            .replace(pseudoSeparatorsRegExp, '.'))
+        : NaN;
 }
-var getNumberRegExp = function (fractionLength) {
-    var reStr = '[0-9]+';
+/**
+ * Преобразовать число в строку с заменой экспоненты на десятичную дробь
+ */
+function stringifyNumberWithoutExp(value) {
+    var valueString = String(value);
+    var _a = valueString.split('e-'), numberPart = _a[0], expPart = _a[1];
+    var valueWithoutExp = valueString;
+    if (expPart) {
+        var _b = numberPart.split('.'), fractionalPart = _b[1];
+        var decimalDigits = Number(expPart) + ((fractionalPart === null || fractionalPart === void 0 ? void 0 : fractionalPart.length) || 0);
+        valueWithoutExp = value.toFixed(decimalDigits);
+    }
+    return valueWithoutExp;
+}
+var getNumberRegExp = function (min, fractionLength) {
+    var reStr = '[0-9]*';
+    if (min < 0) {
+        reStr = "(\\".concat(MINUS_SIGN, ")?").concat(reStr);
+    }
     if (fractionLength !== 0) {
-        reStr = "".concat(reStr, "[").concat(SEPARATORS.map(function (s) { return "\\".concat(s); }).join(''), "]?[0-9]{0,").concat(fractionLength || Number.MAX_SAFE_INTEGER, "}");
+        reStr = "".concat(reStr, "[").concat(SEPARATORS.map(function (s) { return "\\".concat(s); }).join(''), "]?[0-9]{0,").concat(fractionLength || MAX_DIGITS, "}");
     }
     return new RegExp("^".concat(reStr, "$"));
 };
+function createMaskOptions(_a) {
+    var separator = _a.separator, fractionLength = _a.fractionLength, min = _a.min, max = _a.max;
+    return {
+        mask: getNumberRegExp(min, fractionLength),
+        preprocessors: [
+            createPseudoSeparatorPreprocessor(separator),
+            createNotEmptyIntegerPartPreprocessor({ separator: separator, fractionLength: fractionLength }),
+            createZeroFractionLengthPreprocessor(fractionLength, separator),
+            createRepeatedSeparatorPreprocessor(separator),
+        ],
+        postprocessors: [
+            createLeadingZeroesValidationPostprocessor(separator),
+            createMinMaxPostprocessor({ min: min, max: max, separator: separator }),
+        ],
+        plugins: [createNotEmptyPartsPlugin(separator), createMinMaxPlugin({ min: min, max: max })],
+    };
+}
 /**
- * Проверка вводимых значений.
+ *  Заполняет целочисленную часть при вводе separator.
+ *  @example Type , => 0,
  */
-var getAllowedValue = function (_a) {
-    var _b = _a.value, value = _b === void 0 ? '' : _b, fractionLength = _a.fractionLength, separator = _a.separator, allowSigns = _a.allowSigns;
-    var sign = allowSigns && SIGNS.some(function (s) { return s === value[0]; }) ? value[0] : '';
-    var testedValue = sign ? value.slice(1) : value;
-    if (getNumberRegExp(fractionLength).test(testedValue)) {
-        return value;
+function createNotEmptyIntegerPartPreprocessor(_a) {
+    var separator = _a.separator, fractionLength = _a.fractionLength;
+    var startWithDecimalSepRegExp = new RegExp("^\\D*\\".concat(separator));
+    return function (_a) {
+        var elementState = _a.elementState, data = _a.data;
+        var value = elementState.value, selection = elementState.selection;
+        var from = selection[0];
+        if (fractionLength <= 0 ||
+            value.includes(separator) ||
+            !data.match(startWithDecimalSepRegExp)) {
+            return { elementState: elementState, data: data };
+        }
+        var digitsBeforeCursor = value.slice(0, from).match(/\d+/);
+        return {
+            elementState: elementState,
+            data: digitsBeforeCursor ? data : "0".concat(data),
+        };
+    };
+}
+/**
+ * Не позволяет вводить невалидный разделитель.
+ */
+function createPseudoSeparatorPreprocessor(separator) {
+    var pseudoSeparatorsRegExp = new RegExp("[".concat(SEPARATORS.join(''), "]"), 'gi');
+    return function (_a) {
+        var elementState = _a.elementState, data = _a.data;
+        var value = elementState.value, selection = elementState.selection;
+        return {
+            elementState: {
+                selection: selection,
+                value: value.replace(pseudoSeparatorsRegExp, separator),
+            },
+            data: data.replace(pseudoSeparatorsRegExp, separator),
+        };
+    };
+}
+/**
+ * Помогает верно обрезать значения при вставке, если fractionLength===0
+ * @example paste 123,123 -> 123
+ */
+function createZeroFractionLengthPreprocessor(fractionLength, separator) {
+    if (fractionLength > 0) {
+        return function (state) { return state; };
     }
-    var _c = testedValue
-        .split(separator)
-        .map(function (v) { return v.replace(/[^0-9]/g, ''); }), majorPart = _c[0], minorPart = _c[1];
-    return "".concat(sign).concat(majorPart).concat(minorPart ? separator + minorPart.slice(0, fractionLength) : '');
-};
+    var decimalPartRegExp = new RegExp("\\".concat(separator, ".*$"), 'g');
+    return function (_a) {
+        var elementState = _a.elementState, data = _a.data;
+        var value = elementState.value, selection = elementState.selection;
+        var from = selection[0], to = selection[1];
+        var newValue = value.replace(decimalPartRegExp, '');
+        return {
+            elementState: {
+                selection: [Math.min(from, newValue.length), Math.min(to, newValue.length)],
+                value: newValue,
+            },
+            data: data.replace(decimalPartRegExp, ''),
+        };
+    };
+}
+/**
+ *  Запрещает вводить второй сепаратор
+ */
+function createRepeatedSeparatorPreprocessor(separator) {
+    return function (_a) {
+        var elementState = _a.elementState, data = _a.data;
+        var value = elementState.value, selection = elementState.selection;
+        var from = selection[0], to = selection[1];
+        return {
+            elementState: elementState,
+            data: !value.includes(separator) || value.slice(from, to + 1).includes(separator)
+                ? data
+                : data.replace(new RegExp("\\".concat(separator)), ''),
+        };
+    };
+}
+/**
+ * Удаляет лишние нули в начале целой части.
+ * @example 0,|00005 => Backspace => |5
+ * @example -0,|00005 => Backspace => -|5
+ * @example "000000" => 0|
+ * @example 0| => Type "5" => 5|
+ */
+function createLeadingZeroesValidationPostprocessor(separator) {
+    var trimLeadingZeroes = function (value) {
+        return value
+            .replace(new RegExp('^(\\D+)?0+(?=0)'), '$1')
+            .replace(new RegExp('^(\\D+)?0+(?=[1-9])'), '$1');
+    };
+    var countTrimmedZeroesBefore = function (value, index) {
+        var valueBefore = value.slice(0, index);
+        var followedByZero = value.slice(index).startsWith('0');
+        return (valueBefore.length - trimLeadingZeroes(valueBefore).length + (followedByZero ? 1 : 0));
+    };
+    return function (_a) {
+        var value = _a.value, selection = _a.selection;
+        var from = selection[0], to = selection[1];
+        var hasSeparator = value.includes(separator);
+        var _b = value.split(separator), integerPart = _b[0], _c = _b[1], decimalPart = _c === void 0 ? '' : _c;
+        var zeroTrimmedIntegerPart = trimLeadingZeroes(integerPart);
+        if (integerPart === zeroTrimmedIntegerPart) {
+            return { value: value, selection: selection };
+        }
+        var newFrom = from - countTrimmedZeroesBefore(value, from);
+        var newTo = to - countTrimmedZeroesBefore(value, to);
+        return {
+            value: zeroTrimmedIntegerPart + (hasSeparator ? separator : '') + decimalPart,
+            selection: [Math.max(newFrom, 0), Math.max(newTo, 0)],
+        };
+    };
+}
+/**
+ * Валидирует значение с учетом min max значений.
+ * Работает совместно с createMinMaxPlugin
+ */
+function createMinMaxPostprocessor(_a) {
+    var min = _a.min, max = _a.max, separator = _a.separator;
+    return function (_a) {
+        var value = _a.value, selection = _a.selection;
+        var parsedNumber = parseNumber(value);
+        var limitedValue = 
+        /**
+         * Здесь невозможно ограничить нижнюю границу, если пользователь вводит положительное число.
+         * То же самое для верхней границы и отрицательного числа.
+         * Если min=5, то без этого условия не получится ввести 40, похожая ситуация и с отрицательным max
+         */
+        parsedNumber > 0 ? Math.min(parsedNumber, max) : Math.max(parsedNumber, min);
+        if (!Number.isNaN(parsedNumber) && limitedValue !== parsedNumber) {
+            var newValue = "".concat(limitedValue).replace('.', separator);
+            return {
+                value: newValue,
+                selection: [newValue.length, newValue.length],
+            };
+        }
+        return {
+            value: value,
+            selection: selection,
+        };
+    };
+}
+function createMinMaxPlugin(_a) {
+    var min = _a.min, max = _a.max;
+    return function (element, options) {
+        var listener = function () {
+            var parsedNumber = parseNumber(element.value);
+            var clampedNumber = coreComponentsShared.fnUtils.clamp(parsedNumber, min, max);
+            if (!Number.isNaN(parsedNumber) && parsedNumber !== clampedNumber) {
+                element.value = core.maskitoTransform(stringifyNumberWithoutExp(clampedNumber), options);
+                element.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        };
+        var evListenerOptions = { capture: true };
+        element.addEventListener('blur', listener, evListenerOptions);
+        return function () { return element.removeEventListener('blur', listener, evListenerOptions); };
+    };
+}
+function createNotEmptyPartsPlugin(separator) {
+    return function (element) {
+        var listener = function () {
+            var newValue = element.value
+                // 0,9000000 -> 0,9
+                .replace(new RegExp("(\\".concat(separator, "\\d*?)(0+$)")), '$1')
+                // ,2 => 0,2
+                .replace(new RegExp("^(\\D+)?\\".concat(separator)), "$10".concat(separator))
+                // 0, -> 0
+                .replace(new RegExp("\\".concat(separator, "$")), '')
+                // -0 -> 0
+                .replace(new RegExp("^".concat(MINUS_SIGN, "0$")), '0')
+                // - -> ''
+                .replace(new RegExp("^".concat(MINUS_SIGN, "$")), '');
+            if (newValue !== element.value) {
+                element.value = newValue;
+                element.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        };
+        var evListenerOptions = { capture: true };
+        element.addEventListener('blur', listener, evListenerOptions);
+        return function () { return element.removeEventListener('blur', listener, evListenerOptions); };
+    };
+}
 
+exports.MAX_DIGITS = MAX_DIGITS;
+exports.MAX_SAFE_INTEGER = MAX_SAFE_INTEGER;
+exports.MINUS_SIGN = MINUS_SIGN;
+exports.MIN_SAFE_INTEGER = MIN_SAFE_INTEGER;
 exports.SEPARATORS = SEPARATORS;
-exports.SIGNS = SIGNS;
-exports.createSeparatorsRegExp = createSeparatorsRegExp;
-exports.getAllowedValue = getAllowedValue;
+exports.createMaskOptions = createMaskOptions;
+exports.createMinMaxPlugin = createMinMaxPlugin;
+exports.createNotEmptyPartsPlugin = createNotEmptyPartsPlugin;
+exports.parseNumber = parseNumber;
+exports.stringifyNumberWithoutExp = stringifyNumberWithoutExp;