@servicetitan/anvil2 1.43.3 → 1.44.0

package/dist/{usePopoverSupport-B9Lsqryr-DhZHMoNb.js → index.esm-dyoPQhi6.js}

@@ -1,5 +1,4 @@
 import { useState, useCallback, useRef, useLayoutEffect, useEffect } from 'react';
-import { s as supportsPopover } from './ProgressBar-BRvB-bD4-DppwBrFg.js';
 
 function getContentEditableSelection(element) {
     const { anchorOffset = 0, focusOffset = 0 } = element.ownerDocument.getSelection() || {};
@@ -972,6 +971,9 @@ const DATE_SEGMENTS_MAX_VALUES = {
     year: 9999,
 };
 
+// eslint-disable-next-line i18n/no-russian-character
+const DEFAULT_DECIMAL_PSEUDO_SEPARATORS = ['.', ',', 'б', 'ю'];
+
 const DEFAULT_MIN_DATE = new Date('0001-01-01T00:00');
 const DEFAULT_MAX_DATE = new Date('9999-12-31T23:59:59.999');
 
@@ -992,6 +994,10 @@ const DEFAULT_TIME_SEGMENT_MIN_VALUES = {
  * {@link https://unicode-table.com/en/00A0/ Non-breaking space}.
  */
 const CHAR_NO_BREAK_SPACE = '\u00A0';
+/**
+ * {@link https://symbl.cc/en/200B/ Zero width space}.
+ */
+const CHAR_ZERO_WIDTH_SPACE = '\u200B';
 /**
  * {@link https://unicode-table.com/en/2013/ EN dash}
  * is used to indicate a range of numbers or a span of time.
@@ -1119,6 +1125,21 @@ function escapeRegExp(str) {
         : str;
 }
 
+function extractAffixes(value, { prefix, postfix }) {
+    var _a, _b;
+    const prefixRegExp = new RegExp(`^${escapeRegExp(prefix)}`);
+    const postfixRegExp = new RegExp(`${escapeRegExp(postfix)}$`);
+    const [extractedPrefix = ''] = (_a = value.match(prefixRegExp)) !== null && _a !== void 0 ? _a : [];
+    const [extractedPostfix = ''] = (_b = value.match(postfixRegExp)) !== null && _b !== void 0 ? _b : [];
+    return {
+        extractedPrefix,
+        extractedPostfix,
+        cleanValue: extractedPrefix || extractedPostfix
+            ? value.slice(extractedPrefix.length, extractedPostfix.length ? -extractedPostfix.length : Infinity)
+            : value,
+    };
+}
+
 function findCommonBeginningSubstr(a, b) {
     let res = '';
     for (let i = 0; i < a.length; i++) {
@@ -2108,6 +2129,717 @@ function cutExpression(expression, value) {
     return expression.slice(0, afterLastDigit);
 }
 
+/**
+ * It drops prefix and postfix from data
+ * Needed for case, when prefix or postfix contain decimalSeparator, to ignore it in resulting number
+ * @example User pastes '{prefix}123.45{postfix}' => 123.45
+ */
+function createAffixesFilterPreprocessor({ prefix, postfix, }) {
+    return ({ elementState, data }) => {
+        const { cleanValue: cleanData } = extractAffixes(data, {
+            prefix,
+            postfix,
+        });
+        return {
+            elementState,
+            data: cleanData,
+        };
+    };
+}
+
+function generateMaskExpression({ decimalPseudoSeparators, decimalSeparator, maximumFractionDigits, min, minusSign, postfix, prefix, pseudoMinuses, thousandSeparator, }) {
+    const computedPrefix = min < 0 && [minusSign, ...pseudoMinuses].includes(prefix)
+        ? ''
+        : computeAllOptionalCharsRegExp(prefix);
+    const digit = String.raw `\d`;
+    const optionalMinus = min < 0 ? `[${minusSign}${pseudoMinuses.map((x) => `\\${x}`).join('')}]?` : '';
+    const integerPart = thousandSeparator
+        ? `[${digit}${escapeRegExp(thousandSeparator).replaceAll(/\s/g, String.raw `\s`)}]*`
+        : `[${digit}]*`;
+    const precisionPart = Number.isFinite(maximumFractionDigits)
+        ? maximumFractionDigits
+        : '';
+    const decimalPart = maximumFractionDigits > 0
+        ? `([${escapeRegExp(decimalSeparator)}${decimalPseudoSeparators
+            .map(escapeRegExp)
+            .join('')}]${digit}{0,${precisionPart}})?`
+        : '';
+    const computedPostfix = computeAllOptionalCharsRegExp(postfix);
+    return new RegExp(`^${computedPrefix}${optionalMinus}${integerPart}${decimalPart}${computedPostfix}$`);
+}
+function computeAllOptionalCharsRegExp(str) {
+    return str
+        ? `${str
+            .split('')
+            .map((char) => `${escapeRegExp(char)}?`)
+            .join('')}`
+        : '';
+}
+
+function maskitoParseNumber(maskedNumber, 
+// TODO(v4): decimalSeparatorOrParams: MaskitoNumberParams | string => params: MaskitoNumberParams = {}
+decimalSeparatorOrParams = {}) {
+    const { decimalSeparator = '.', minusSign = '' } = typeof decimalSeparatorOrParams === 'string'
+        ? { decimalSeparator: decimalSeparatorOrParams }
+        : decimalSeparatorOrParams;
+    const hasNegativeSign = !!new RegExp(`^\\D*[${escapeRegExp(minusSign)}\\${DEFAULT_PSEUDO_MINUSES.join('\\')}]`).exec(maskedNumber);
+    const escapedDecimalSeparator = escapeRegExp(decimalSeparator);
+    const unmaskedNumber = maskedNumber
+        // drop all decimal separators not followed by a digit
+        .replaceAll(new RegExp(`${escapedDecimalSeparator}(?!\\d)`, 'g'), '')
+        // drop all non-digit characters except decimal separator
+        .replaceAll(new RegExp(`[^\\d${escapedDecimalSeparator}]`, 'g'), '')
+        .replace(decimalSeparator, decimalSeparator && '.');
+    if (unmaskedNumber) {
+        const sign = hasNegativeSign ? CHAR_HYPHEN : '';
+        return Number(`${sign}${unmaskedNumber}`);
+    }
+    return NaN;
+}
+
+function maskitoStringifyNumber(number, params) {
+    if (Number.isNaN(number) || number === null) {
+        return '';
+    }
+    const { min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER, decimalSeparator = '.', } = params;
+    const value = clamp(number, min, max).toString().replace('.', decimalSeparator);
+    return maskitoTransform(value, maskitoNumberOptionsGenerator(params));
+}
+
+/**
+ * Convert number to string with replacing exponent part on decimals
+ *
+ * @param value the number
+ * @return string representation of a number
+ */
+function stringifyNumberWithoutExp(value) {
+    var _a;
+    const valueAsString = String(value);
+    const [numberPart = '', expPart] = valueAsString.split('e-');
+    let valueWithoutExp = valueAsString;
+    if (expPart) {
+        const [, fractionalPart] = numberPart.split('.');
+        const decimalDigits = Number(expPart) + ((_a = fractionalPart === null || fractionalPart === void 0 ? void 0 : fractionalPart.length) !== null && _a !== void 0 ? _a : 0);
+        valueWithoutExp = value.toFixed(decimalDigits);
+    }
+    return valueWithoutExp;
+}
+
+function toNumberParts(value, { decimalSeparator, minusSign }) {
+    const [integerWithMinus = '', decimalPart = ''] = decimalSeparator
+        ? value.split(decimalSeparator)
+        : [value];
+    const escapedMinus = escapeRegExp(minusSign);
+    const [, minus = '', integerPart = ''] = new RegExp(`^(?:[^\\d${escapedMinus}])?(${escapedMinus})?(.*)`).exec(integerWithMinus) || [];
+    return { minus, integerPart, decimalPart };
+}
+
+function validateDecimalPseudoSeparators({ decimalSeparator, thousandSeparator, decimalPseudoSeparators = DEFAULT_DECIMAL_PSEUDO_SEPARATORS, }) {
+    return decimalPseudoSeparators.filter((char) => char !== thousandSeparator && char !== decimalSeparator);
+}
+
+/**
+ * If `minimumFractionDigits` is `>0`, it pads decimal part with zeroes
+ * (until number of digits after decimalSeparator is equal to the `minimumFractionDigits`).
+ * @example 1,42 => (`minimumFractionDigits` is equal to 4) => 1,4200.
+ */
+function createDecimalZeroPaddingPostprocessor({ decimalSeparator, minimumFractionDigits, prefix, postfix, minusSign, }) {
+    if (!minimumFractionDigits) {
+        return identity;
+    }
+    return ({ value, selection }) => {
+        const { cleanValue, extractedPrefix, extractedPostfix } = extractAffixes(value, {
+            prefix,
+            postfix,
+        });
+        if (Number.isNaN(maskitoParseNumber(cleanValue, { decimalSeparator, minusSign }))) {
+            return { value, selection };
+        }
+        const [integerPart, decimalPart = ''] = cleanValue.split(decimalSeparator);
+        return {
+            value: extractedPrefix +
+                integerPart +
+                decimalSeparator +
+                decimalPart.padEnd(minimumFractionDigits, '0') +
+                extractedPostfix,
+            selection,
+        };
+    };
+}
+
+/**
+ * Make textfield empty if there is no integer part and all decimal digits are zeroes.
+ * @example 0|,00 => Backspace => Empty.
+ * @example -0|,00 => Backspace => -.
+ * @example ,42| => Backspace x2 => ,|00 => Backspace => Empty
+ */
+function emptyPostprocessor({ prefix, postfix, decimalSeparator, minusSign, }) {
+    return ({ value, selection }) => {
+        const [caretIndex] = selection;
+        const { cleanValue, extractedPrefix, extractedPostfix } = extractAffixes(value, {
+            prefix,
+            postfix,
+        });
+        const { minus, integerPart, decimalPart } = toNumberParts(cleanValue, {
+            decimalSeparator,
+            minusSign,
+        });
+        const aloneDecimalSeparator = !integerPart &&
+            !decimalPart &&
+            Boolean(decimalSeparator) &&
+            cleanValue.includes(decimalSeparator);
+        if ((!integerPart &&
+            !Number(decimalPart) &&
+            caretIndex === (minus + extractedPrefix).length) ||
+            aloneDecimalSeparator) {
+            return {
+                selection,
+                value: extractedPrefix + minus + extractedPostfix,
+            };
+        }
+        return { value, selection };
+    };
+}
+
+/**
+ * This preprocessor works only once at initialization phase (when `new Maskito(...)` is executed).
+ * This preprocessor helps to avoid conflicts during transition from one mask to another (for the same input).
+ * For example, the developer changes postfix (or other mask's props) during run-time.
+ * ```
+ * let maskitoOptions = maskitoNumberOptionsGenerator({postfix: ' year'});
+ * // [3 seconds later]
+ * maskitoOptions = maskitoNumberOptionsGenerator({postfix: ' years'});
+ * ```
+ */
+function createInitializationOnlyPreprocessor({ decimalPseudoSeparators, decimalSeparator, minusSign, postfix, prefix, pseudoMinuses, }) {
+    let isInitializationPhase = true;
+    const cleanNumberMask = generateMaskExpression({
+        decimalSeparator,
+        decimalPseudoSeparators,
+        pseudoMinuses,
+        prefix: '',
+        postfix: '',
+        thousandSeparator: '',
+        maximumFractionDigits: Infinity,
+        min: Number.MIN_SAFE_INTEGER,
+        minusSign,
+    });
+    return ({ elementState, data }) => {
+        if (!isInitializationPhase) {
+            return { elementState, data };
+        }
+        isInitializationPhase = false;
+        const { value, selection } = elementState;
+        const [from, to] = selection;
+        const { extractedPrefix, cleanValue, extractedPostfix } = extractAffixes(value, {
+            prefix,
+            postfix,
+        });
+        const cleanState = maskitoTransform({
+            selection: [
+                Math.max(from - extractedPrefix.length, 0),
+                clamp(to - extractedPrefix.length, 0, cleanValue.length),
+            ],
+            value: cleanValue,
+        }, {
+            mask: cleanNumberMask,
+        });
+        const [cleanFrom, cleanTo] = cleanState.selection;
+        return {
+            elementState: {
+                selection: [
+                    cleanFrom + extractedPrefix.length,
+                    cleanTo + extractedPrefix.length,
+                ],
+                value: extractedPrefix + cleanState.value + extractedPostfix,
+            },
+            data,
+        };
+    };
+}
+
+/**
+ * It removes repeated leading zeroes for integer part.
+ * @example 0,|00005 => Backspace => |5
+ * @example -0,|00005 => Backspace => -|5
+ * @example User types "000000" => 0|
+ * @example 0| => User types "5" => 5|
+ */
+function createLeadingZeroesValidationPostprocessor({ decimalSeparator, thousandSeparator, prefix, postfix, }) {
+    const trimLeadingZeroes = (value) => {
+        const escapedThousandSeparator = escapeRegExp(thousandSeparator);
+        return value
+            .replace(
+        // all leading zeroes followed by another zero
+        new RegExp(`^(\\D+)?[0${escapedThousandSeparator}]+(?=0)`), '$1')
+            .replace(
+        // zero followed by not-zero digit
+        new RegExp(`^(\\D+)?[0${escapedThousandSeparator}]+(?=[1-9])`), '$1');
+    };
+    const countTrimmedZeroesBefore = (value, index) => {
+        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 { cleanValue, extractedPrefix, extractedPostfix } = extractAffixes(value, {
+            prefix,
+            postfix,
+        });
+        const hasDecimalSeparator = Boolean(decimalSeparator) && cleanValue.includes(decimalSeparator);
+        const [integerPart = '', decimalPart = ''] = decimalSeparator
+            ? cleanValue.split(decimalSeparator)
+            : [cleanValue];
+        const zeroTrimmedIntegerPart = trimLeadingZeroes(integerPart);
+        if (integerPart === zeroTrimmedIntegerPart) {
+            return { value, selection };
+        }
+        const newFrom = from - countTrimmedZeroesBefore(value, from);
+        const newTo = to - countTrimmedZeroesBefore(value, to);
+        return {
+            value: extractedPrefix +
+                zeroTrimmedIntegerPart +
+                (hasDecimalSeparator ? decimalSeparator : '') +
+                decimalPart +
+                extractedPostfix,
+            selection: [Math.max(newFrom, 0), Math.max(newTo, 0)],
+        };
+    };
+}
+
+/**
+ * This postprocessor is connected with {@link createMinMaxPlugin}:
+ * both validate `min`/`max` bounds of entered value (but at the different point of time).
+ */
+function createMinMaxPostprocessor({ min, max, decimalSeparator, minusSign, }) {
+    return ({ value, selection }) => {
+        const parsedNumber = maskitoParseNumber(value, { decimalSeparator, minusSign });
+        const limitedValue = 
+        /**
+         * We cannot limit lower bound if user enters positive number.
+         * The same for upper bound and negative number.
+         * ___
+         * @example (min = 5)
+         * Empty input => Without this condition user cannot type 42 (the first digit will be rejected)
+         * ___
+         * @example (max = -10)
+         * Value is -10 => Without this condition user cannot delete 0 to enter another digit
+         */
+        parsedNumber > 0 ? Math.min(parsedNumber, max) : Math.max(parsedNumber, min);
+        if (parsedNumber && limitedValue !== parsedNumber) {
+            const newValue = `${limitedValue}`
+                .replace('.', decimalSeparator)
+                .replace(CHAR_HYPHEN, minusSign);
+            return {
+                value: newValue,
+                selection: [newValue.length, newValue.length],
+            };
+        }
+        return {
+            value,
+            selection,
+        };
+    };
+}
+
+/**
+ * Manage caret-navigation when user "deletes" non-removable digits or separators
+ * @example 1,|42 => Backspace => 1|,42 (only if `minimumFractionDigits` is `>0`)
+ * @example 1|,42 => Delete => 1,|42 (only if `minimumFractionDigits` is `>0`)
+ * @example 0,|00 => Delete => 0,0|0 (only if `minimumFractionDigits` is `>0`)
+ * @example 1 |000 => Backspace => 1| 000 (always)
+ */
+function createNonRemovableCharsDeletionPreprocessor({ decimalSeparator, thousandSeparator, minimumFractionDigits, }) {
+    return ({ elementState, data }, actionType) => {
+        const { value, selection } = elementState;
+        const [from, to] = selection;
+        const selectedCharacters = value.slice(from, to);
+        const nonRemovableSeparators = minimumFractionDigits
+            ? [decimalSeparator, thousandSeparator]
+            : [thousandSeparator];
+        const areNonRemovableZeroesSelected = Boolean(minimumFractionDigits) &&
+            from > value.indexOf(decimalSeparator) &&
+            Boolean(selectedCharacters.match(/^0+$/gi));
+        if ((actionType !== 'deleteBackward' && actionType !== 'deleteForward') ||
+            (!nonRemovableSeparators.includes(selectedCharacters) &&
+                !areNonRemovableZeroesSelected)) {
+            return {
+                elementState,
+                data,
+            };
+        }
+        return {
+            elementState: {
+                value,
+                selection: actionType === 'deleteForward' ? [to, to] : [from, from],
+            },
+            data,
+        };
+    };
+}
+
+/**
+ * It pads integer part with zero if user types decimal separator (for empty input).
+ * @example Empty input => User types "," (decimal separator) => 0,|
+ */
+function createNotEmptyIntegerPartPreprocessor({ decimalSeparator, maximumFractionDigits, prefix, postfix, }) {
+    const startWithDecimalSepRegExp = new RegExp(`^\\D*${escapeRegExp(decimalSeparator)}`);
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+        const { cleanValue, extractedPrefix } = extractAffixes(value, {
+            prefix,
+            postfix,
+        });
+        const [from, to] = selection;
+        const cleanFrom = clamp(from - extractedPrefix.length, 0, cleanValue.length);
+        const cleanTo = clamp(to - extractedPrefix.length, 0, cleanValue.length);
+        if (maximumFractionDigits <= 0 ||
+            cleanValue.slice(0, cleanFrom).includes(decimalSeparator) ||
+            cleanValue.slice(cleanTo).includes(decimalSeparator) ||
+            !data.match(startWithDecimalSepRegExp)) {
+            return { elementState, data };
+        }
+        const digitsBeforeCursor = /\d+/.exec(cleanValue.slice(0, cleanFrom));
+        return {
+            elementState,
+            data: digitsBeforeCursor ? data : `0${data}`,
+        };
+    };
+}
+
+/**
+ * It replaces pseudo characters with valid one.
+ * @example User types '.' (but separator is equal to comma) => dot is replaced with comma.
+ * @example User types hyphen / en-dash / em-dash => it is replaced with minus.
+ */
+function createPseudoCharactersPreprocessor({ validCharacter, pseudoCharacters, prefix, postfix, }) {
+    const pseudoCharactersRegExp = new RegExp(`[${pseudoCharacters.join('')}]`, 'gi');
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+        const { cleanValue, extractedPostfix, extractedPrefix } = extractAffixes(value, {
+            prefix,
+            postfix,
+        });
+        return {
+            elementState: {
+                selection,
+                value: extractedPrefix +
+                    cleanValue.replace(pseudoCharactersRegExp, validCharacter) +
+                    extractedPostfix,
+            },
+            data: data.replace(pseudoCharactersRegExp, validCharacter),
+        };
+    };
+}
+
+/**
+ * It rejects new typed decimal separator if it already exists in text field.
+ * Behaviour is similar to native <input type="number"> (Chrome).
+ * @example 1|23,45 => Press comma (decimal separator) => 1|23,45 (do nothing).
+ */
+function createRepeatedDecimalSeparatorPreprocessor({ decimalSeparator, prefix, postfix, }) {
+    if (!decimalSeparator) {
+        return identity;
+    }
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+        const [from, to] = selection;
+        const { cleanValue } = extractAffixes(value, { prefix, postfix });
+        return {
+            elementState,
+            data: !cleanValue.includes(decimalSeparator) ||
+                value.slice(from, to + 1).includes(decimalSeparator)
+                ? data
+                : data.replaceAll(new RegExp(escapeRegExp(decimalSeparator), 'gi'), ''),
+        };
+    };
+}
+
+/**
+ * It adds symbol for separating thousands.
+ * @example 1000000 => (thousandSeparator is equal to space) => 1 000 000.
+ */
+function createThousandSeparatorPostprocessor({ thousandSeparator, decimalSeparator, prefix, postfix, minusSign, }) {
+    if (!thousandSeparator) {
+        return identity;
+    }
+    const isAllSpaces = (...chars) => chars.every((x) => /\s/.test(x));
+    return ({ value, selection }) => {
+        const [initialFrom, initialTo] = selection;
+        let [from, to] = selection;
+        const { cleanValue, extractedPostfix, extractedPrefix } = extractAffixes(value, {
+            prefix,
+            postfix,
+        });
+        const { minus, integerPart, decimalPart } = toNumberParts(cleanValue, {
+            decimalSeparator,
+            minusSign,
+        });
+        const hasDecimalSeparator = decimalSeparator && cleanValue.includes(decimalSeparator);
+        const deletedChars = cleanValue.length -
+            (minus +
+                integerPart +
+                (hasDecimalSeparator ? decimalSeparator + decimalPart : '')).length;
+        if (deletedChars > 0 && initialFrom && initialFrom <= deletedChars) {
+            from -= deletedChars;
+        }
+        if (deletedChars > 0 && initialTo && initialTo <= deletedChars) {
+            to -= deletedChars;
+        }
+        const processedIntegerPart = Array.from(integerPart).reduceRight((formattedValuePart, char, i) => {
+            const isLeadingThousandSeparator = !i && char === thousandSeparator;
+            const isPositionForSeparator = !isLeadingThousandSeparator &&
+                Boolean(formattedValuePart.length) &&
+                (formattedValuePart.length + 1) % 4 === 0;
+            const isSeparator = char === thousandSeparator || isAllSpaces(char, thousandSeparator);
+            if (isPositionForSeparator && isSeparator) {
+                return thousandSeparator + formattedValuePart;
+            }
+            if (!isPositionForSeparator && isSeparator) {
+                if (i && i <= initialFrom) {
+                    from--;
+                }
+                if (i && i <= initialTo) {
+                    to--;
+                }
+                return formattedValuePart;
+            }
+            if (!isPositionForSeparator) {
+                return char + formattedValuePart;
+            }
+            if (i < initialFrom) {
+                from++;
+            }
+            if (i < initialTo) {
+                to++;
+            }
+            return char + thousandSeparator + formattedValuePart;
+        }, '');
+        return {
+            value: extractedPrefix +
+                minus +
+                processedIntegerPart +
+                (hasDecimalSeparator ? decimalSeparator : '') +
+                decimalPart +
+                extractedPostfix,
+            selection: [from, to],
+        };
+    };
+}
+
+/**
+ * It drops decimal part if `maximumFractionDigits` is zero.
+ * @example User pastes '123.45' (but `maximumFractionDigits` is zero) => 123
+ */
+function createZeroPrecisionPreprocessor({ maximumFractionDigits, decimalSeparator, prefix, postfix, }) {
+    if (maximumFractionDigits > 0 ||
+        !decimalSeparator // all separators should be treated only as thousand separators
+    ) {
+        return identity;
+    }
+    const decimalPartRegExp = new RegExp(`${escapeRegExp(decimalSeparator)}.*$`, 'g');
+    return ({ elementState, data }) => {
+        const { value, selection } = elementState;
+        const { cleanValue, extractedPrefix, extractedPostfix } = extractAffixes(value, {
+            prefix,
+            postfix,
+        });
+        const [from, to] = selection;
+        const newValue = extractedPrefix +
+            cleanValue.replace(decimalPartRegExp, '') +
+            extractedPostfix;
+        return {
+            elementState: {
+                selection: [
+                    Math.min(from, newValue.length),
+                    Math.min(to, newValue.length),
+                ],
+                value: newValue,
+            },
+            data: data.replace(decimalPartRegExp, ''),
+        };
+    };
+}
+
+const DUMMY_SELECTION = [0, 0];
+/**
+ * It removes repeated leading zeroes for integer part on blur-event.
+ * @example 000000 => blur => 0
+ * @example 00005 => blur => 5
+ */
+function createLeadingZeroesValidationPlugin({ decimalSeparator, thousandSeparator, prefix, postfix, }) {
+    const dropRepeatedLeadingZeroes = createLeadingZeroesValidationPostprocessor({
+        decimalSeparator,
+        thousandSeparator,
+        prefix,
+        postfix,
+    });
+    return maskitoEventHandler('blur', (element) => {
+        const newValue = dropRepeatedLeadingZeroes({
+            value: element.value,
+            selection: DUMMY_SELECTION,
+        }, { value: '', selection: DUMMY_SELECTION }).value;
+        maskitoUpdateElement(element, newValue);
+    }, { capture: true });
+}
+
+/**
+ * This plugin is connected with {@link createMinMaxPostprocessor}:
+ * both validate `min`/`max` bounds of entered value (but at the different point of time).
+ */
+function createMinMaxPlugin({ min, max, decimalSeparator, minusSign, }) {
+    return maskitoEventHandler('blur', (element, options) => {
+        const parsedNumber = maskitoParseNumber(element.value, {
+            decimalSeparator,
+            minusSign,
+        });
+        const clampedNumber = clamp(parsedNumber, min, max);
+        if (!Number.isNaN(parsedNumber) && parsedNumber !== clampedNumber) {
+            maskitoUpdateElement(element, maskitoTransform(stringifyNumberWithoutExp(clampedNumber), options));
+        }
+    }, { capture: true });
+}
+
+/**
+ * It pads EMPTY integer part with zero if decimal parts exists.
+ * It works on blur event only!
+ * @example 1|,23 => Backspace => Blur => 0,23
+ */
+function createNotEmptyIntegerPlugin({ decimalSeparator, prefix, postfix, }) {
+    if (!decimalSeparator) {
+        return noop;
+    }
+    return maskitoEventHandler('blur', (element) => {
+        const { cleanValue, extractedPostfix, extractedPrefix } = extractAffixes(element.value, { prefix, postfix });
+        const newValue = extractedPrefix +
+            cleanValue.replace(new RegExp(`^(\\D+)?${escapeRegExp(decimalSeparator)}`), `$10${decimalSeparator}`) +
+            extractedPostfix;
+        maskitoUpdateElement(element, newValue);
+    }, { capture: true });
+}
+
+const DEFAULT_PSEUDO_MINUSES = [
+    CHAR_HYPHEN,
+    CHAR_EN_DASH,
+    CHAR_EM_DASH,
+    CHAR_JP_HYPHEN,
+    CHAR_MINUS,
+];
+function maskitoNumberOptionsGenerator({ max = Number.MAX_SAFE_INTEGER, min = Number.MIN_SAFE_INTEGER, precision = 0, thousandSeparator = CHAR_NO_BREAK_SPACE, decimalSeparator = '.', decimalPseudoSeparators, decimalZeroPadding = false, prefix: unsafePrefix = '', postfix = '', minusSign = CHAR_MINUS, maximumFractionDigits = precision, minimumFractionDigits = decimalZeroPadding ? maximumFractionDigits : 0, } = {}) {
+    const pseudoMinuses = DEFAULT_PSEUDO_MINUSES.filter((char) => char !== thousandSeparator && char !== decimalSeparator && char !== minusSign);
+    const validatedDecimalPseudoSeparators = validateDecimalPseudoSeparators({
+        decimalSeparator,
+        thousandSeparator,
+        decimalPseudoSeparators,
+    });
+    const prefix = unsafePrefix.endsWith(decimalSeparator) && maximumFractionDigits > 0
+        ? `${unsafePrefix}${CHAR_ZERO_WIDTH_SPACE}`
+        : unsafePrefix;
+    const initializationOnlyPreprocessor = createInitializationOnlyPreprocessor({
+        decimalSeparator,
+        decimalPseudoSeparators: validatedDecimalPseudoSeparators,
+        pseudoMinuses,
+        prefix,
+        postfix,
+        minusSign,
+    });
+    decimalSeparator =
+        maximumFractionDigits <= 0 && decimalSeparator === thousandSeparator
+            ? ''
+            : decimalSeparator;
+    return Object.assign(Object.assign({}, MASKITO_DEFAULT_OPTIONS), { mask: generateMaskExpression({
+            decimalSeparator,
+            maximumFractionDigits,
+            min,
+            minusSign,
+            postfix,
+            prefix,
+            pseudoMinuses,
+            thousandSeparator,
+            decimalPseudoSeparators: validatedDecimalPseudoSeparators,
+        }), preprocessors: [
+            createFullWidthToHalfWidthPreprocessor(),
+            initializationOnlyPreprocessor,
+            createAffixesFilterPreprocessor({ prefix, postfix }),
+            createPseudoCharactersPreprocessor({
+                validCharacter: minusSign,
+                pseudoCharacters: pseudoMinuses,
+                prefix,
+                postfix,
+            }),
+            createPseudoCharactersPreprocessor({
+                validCharacter: decimalSeparator,
+                pseudoCharacters: validatedDecimalPseudoSeparators,
+                prefix,
+                postfix,
+            }),
+            createNotEmptyIntegerPartPreprocessor({
+                decimalSeparator,
+                maximumFractionDigits,
+                prefix,
+                postfix,
+            }),
+            createNonRemovableCharsDeletionPreprocessor({
+                decimalSeparator,
+                minimumFractionDigits,
+                thousandSeparator,
+            }),
+            createZeroPrecisionPreprocessor({
+                maximumFractionDigits,
+                decimalSeparator,
+                prefix,
+                postfix,
+            }),
+            createRepeatedDecimalSeparatorPreprocessor({
+                decimalSeparator,
+                prefix,
+                postfix,
+            }),
+        ], postprocessors: [
+            createMinMaxPostprocessor({ decimalSeparator, min, max, minusSign }),
+            maskitoPrefixPostprocessorGenerator(prefix),
+            maskitoPostfixPostprocessorGenerator(postfix),
+            createThousandSeparatorPostprocessor({
+                decimalSeparator,
+                thousandSeparator,
+                prefix,
+                postfix,
+                minusSign,
+            }),
+            createDecimalZeroPaddingPostprocessor({
+                decimalSeparator,
+                prefix,
+                postfix,
+                minusSign,
+                minimumFractionDigits: Math.min(minimumFractionDigits, maximumFractionDigits),
+            }),
+            emptyPostprocessor({
+                prefix,
+                postfix,
+                decimalSeparator,
+                minusSign,
+            }),
+        ], plugins: [
+            createLeadingZeroesValidationPlugin({
+                decimalSeparator,
+                thousandSeparator,
+                prefix,
+                postfix,
+            }),
+            createNotEmptyIntegerPlugin({
+                decimalSeparator,
+                prefix,
+                postfix,
+            }),
+            createMinMaxPlugin({ min, max, decimalSeparator, minusSign }),
+        ], overwriteMode: minimumFractionDigits > 0
+            ? ({ value, selection: [from] }) => from <= value.indexOf(decimalSeparator) ? 'shift' : 'replace'
+            : 'shift' });
+}
+
 /**
  * React adds `_valueTracker` property to every textfield elements for its internal logic with controlled inputs.
  * Also, React monkey-patches `value`-setter of the native textfield elements to update state inside its `_valueTracker`.
@@ -2221,15 +2953,5 @@ const useMaskito = ({
   return onRefChange;
 };
 
-function usePopoverSupport() {
-  const [popoverSupported, setPopoverSupported] = useState(
-    void 0
-  );
-  useEffect(() => {
-    setPopoverSupported(supportsPopover());
-  }, []);
-  return popoverSupported;
-}
-
-export { useMaskito as a, maskitoWithPlaceholder as b, maskitoParseDate as c, maskitoDateOptionsGenerator as d, maskitoTimeOptionsGenerator as e, maskitoDateRangeOptionsGenerator as m, usePopoverSupport as u };
-//# sourceMappingURL=usePopoverSupport-B9Lsqryr-DhZHMoNb.js.map
+export { maskitoWithPlaceholder as a, maskitoParseDate as b, maskitoDateOptionsGenerator as c, maskitoTimeOptionsGenerator as d, maskitoNumberOptionsGenerator as e, maskitoParseNumber as f, maskitoStringifyNumber as g, maskitoDateRangeOptionsGenerator as m, useMaskito as u };
+//# sourceMappingURL=index.esm-dyoPQhi6.js.map