ngx-mask 18.0.3 → 19.0.0

package/fesm2022/ngx-mask.mjs

@@ -3,6 +3,51 @@ import { InjectionToken, EventEmitter, inject, Injectable, ElementRef, Renderer2
 import { DOCUMENT } from '@angular/common';
 import { NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';
 
+var MaskExpression;
+(function (MaskExpression) {
+    MaskExpression["SEPARATOR"] = "separator";
+    MaskExpression["PERCENT"] = "percent";
+    MaskExpression["IP"] = "IP";
+    MaskExpression["CPF_CNPJ"] = "CPF_CNPJ";
+    MaskExpression["MONTH"] = "M";
+    MaskExpression["MONTHS"] = "M0";
+    MaskExpression["MINUTE"] = "m";
+    MaskExpression["HOUR"] = "h";
+    MaskExpression["HOURS"] = "H";
+    MaskExpression["MINUTES"] = "m0";
+    MaskExpression["HOURS_HOUR"] = "Hh";
+    MaskExpression["SECONDS"] = "s0";
+    MaskExpression["HOURS_MINUTES_SECONDS"] = "Hh:m0:s0";
+    MaskExpression["EMAIL_MASK"] = "A*@A*.A*";
+    MaskExpression["HOURS_MINUTES"] = "Hh:m0";
+    MaskExpression["MINUTES_SECONDS"] = "m0:s0";
+    MaskExpression["DAYS_MONTHS_YEARS"] = "d0/M0/0000";
+    MaskExpression["DAYS_MONTHS"] = "d0/M0";
+    MaskExpression["DAYS"] = "d0";
+    MaskExpression["DAY"] = "d";
+    MaskExpression["SECOND"] = "s";
+    MaskExpression["LETTER_S"] = "S";
+    MaskExpression["DOT"] = ".";
+    MaskExpression["COMMA"] = ",";
+    MaskExpression["CURLY_BRACKETS_LEFT"] = "{";
+    MaskExpression["CURLY_BRACKETS_RIGHT"] = "}";
+    MaskExpression["MINUS"] = "-";
+    MaskExpression["OR"] = "||";
+    MaskExpression["HASH"] = "#";
+    MaskExpression["EMPTY_STRING"] = "";
+    MaskExpression["SYMBOL_STAR"] = "*";
+    MaskExpression["SYMBOL_QUESTION"] = "?";
+    MaskExpression["SLASH"] = "/";
+    MaskExpression["WHITE_SPACE"] = " ";
+    MaskExpression["NUMBER_ZERO"] = "0";
+    MaskExpression["NUMBER_NINE"] = "9";
+    MaskExpression["BACKSPACE"] = "Backspace";
+    MaskExpression["DELETE"] = "Delete";
+    MaskExpression["ARROW_LEFT"] = "ArrowLeft";
+    MaskExpression["ARROW_UP"] = "ArrowUp";
+    MaskExpression["DOUBLE_ZERO"] = "00";
+})(MaskExpression || (MaskExpression = {}));
+
 const NGX_MASK_CONFIG = new InjectionToken('ngx-mask config');
 const NEW_CONFIG = new InjectionToken('new ngx-mask config');
 const INITIAL_CONFIG = new InjectionToken('initial ngx-mask config');
@@ -16,7 +61,7 @@ const initialConfig = {
     showMaskTyped: false,
     placeHolderCharacter: '_',
     dropSpecialCharacters: true,
-    hiddenInput: false,
+    hiddenInput: null,
     shownMaskExpression: '',
     separatorLimit: '',
     allowNegativeNumbers: false,
@@ -75,147 +120,63 @@ const initialConfig = {
     },
 };
 const timeMasks = [
-    "Hh:m0:s0" /* MaskExpression.HOURS_MINUTES_SECONDS */,
-    "Hh:m0" /* MaskExpression.HOURS_MINUTES */,
-    "m0:s0" /* MaskExpression.MINUTES_SECONDS */,
+    MaskExpression.HOURS_MINUTES_SECONDS,
+    MaskExpression.HOURS_MINUTES,
+    MaskExpression.MINUTES_SECONDS,
 ];
 const withoutValidation = [
-    "percent" /* MaskExpression.PERCENT */,
-    "Hh" /* MaskExpression.HOURS_HOUR */,
-    "s0" /* MaskExpression.SECONDS */,
-    "m0" /* MaskExpression.MINUTES */,
-    "separator" /* MaskExpression.SEPARATOR */,
-    "d0/M0/0000" /* MaskExpression.DAYS_MONTHS_YEARS */,
-    "d0/M0" /* MaskExpression.DAYS_MONTHS */,
-    "d0" /* MaskExpression.DAYS */,
-    "M0" /* MaskExpression.MONTHS */,
+    MaskExpression.PERCENT,
+    MaskExpression.HOURS_HOUR,
+    MaskExpression.SECONDS,
+    MaskExpression.MINUTES,
+    MaskExpression.SEPARATOR,
+    MaskExpression.DAYS_MONTHS_YEARS,
+    MaskExpression.DAYS_MONTHS,
+    MaskExpression.DAYS,
+    MaskExpression.MONTHS,
 ];
 
 class NgxMaskApplierService {
-    constructor() {
-        this._config = inject(NGX_MASK_CONFIG);
-        this.dropSpecialCharacters = this._config.dropSpecialCharacters;
-        this.hiddenInput = this._config.hiddenInput;
-        this.clearIfNotMatch = this._config.clearIfNotMatch;
-        this.specialCharacters = this._config.specialCharacters;
-        this.patterns = this._config.patterns;
-        this.prefix = this._config.prefix;
-        this.suffix = this._config.suffix;
-        this.thousandSeparator = this._config.thousandSeparator;
-        this.decimalMarker = this._config.decimalMarker;
-        this.showMaskTyped = this._config.showMaskTyped;
-        this.placeHolderCharacter = this._config.placeHolderCharacter;
-        this.validation = this._config.validation;
-        this.separatorLimit = this._config.separatorLimit;
-        this.allowNegativeNumbers = this._config.allowNegativeNumbers;
-        this.leadZeroDateTime = this._config.leadZeroDateTime;
-        this.leadZero = this._config.leadZero;
-        this.apm = this._config.apm;
-        this.inputTransformFn = this._config.inputTransformFn;
-        this.outputTransformFn = this._config.outputTransformFn;
-        this.keepCharacterPositions = this._config.keepCharacterPositions;
-        this._shift = new Set();
-        this.plusOnePosition = false;
-        this.maskExpression = '';
-        this.actualValue = '';
-        this.showKeepCharacterExp = '';
-        this.shownMaskExpression = '';
-        this.deletedSpecialCharacter = false;
-        this._formatWithSeparators = (str, thousandSeparatorChar, decimalChars, precision) => {
-            let x = [];
-            let decimalChar = '';
-            if (Array.isArray(decimalChars)) {
-                const regExp = new RegExp(decimalChars.map((v) => ('[\\^$.|?*+()'.indexOf(v) >= 0 ? `\\${v}` : v)).join('|'));
-                x = str.split(regExp);
-                decimalChar = str.match(regExp)?.[0] ?? "" /* MaskExpression.EMPTY_STRING */;
-            }
-            else {
-                x = str.split(decimalChars);
-                decimalChar = decimalChars;
-            }
-            const decimals = x.length > 1 ? `${decimalChar}${x[1]}` : "" /* MaskExpression.EMPTY_STRING */;
-            let res = x[0] ?? "" /* MaskExpression.EMPTY_STRING */;
-            const separatorLimit = this.separatorLimit.replace(/\s/g, "" /* MaskExpression.EMPTY_STRING */);
-            if (separatorLimit && +separatorLimit) {
-                if (res[0] === "-" /* MaskExpression.MINUS */) {
-                    res = `-${res.slice(1, res.length).slice(0, separatorLimit.length)}`;
-                }
-                else {
-                    res = res.slice(0, separatorLimit.length);
-                }
-            }
-            const rgx = /(\d+)(\d{3})/;
-            while (thousandSeparatorChar && rgx.test(res)) {
-                res = res.replace(rgx, '$1' + thousandSeparatorChar + '$2');
-            }
-            if (typeof precision === 'undefined') {
-                return res + decimals;
-            }
-            else if (precision === 0) {
-                return res;
-            }
-            return res + decimals.substring(0, precision + 1);
-        };
-        this.percentage = (str) => {
-            const sanitizedStr = str.replace(',', '.');
-            const value = Number(this.allowNegativeNumbers && str.includes("-" /* MaskExpression.MINUS */)
-                ? sanitizedStr.slice(1, str.length)
-                : sanitizedStr);
-            return !isNaN(value) && value >= 0 && value <= 100;
-        };
-        this.getPrecision = (maskExpression) => {
-            const x = maskExpression.split("." /* MaskExpression.DOT */);
-            if (x.length > 1) {
-                return Number(x[x.length - 1]);
-            }
-            return Infinity;
-        };
-        this.checkAndRemoveSuffix = (inputValue) => {
-            for (let i = this.suffix?.length - 1; i >= 0; i--) {
-                const substr = this.suffix.substring(i, this.suffix?.length);
-                if (inputValue.includes(substr) &&
-                    i !== this.suffix?.length - 1 &&
-                    (i - 1 < 0 ||
-                        !inputValue.includes(this.suffix.substring(i - 1, this.suffix?.length)))) {
-                    return inputValue.replace(substr, "" /* MaskExpression.EMPTY_STRING */);
-                }
-            }
-            return inputValue;
-        };
-        this.checkInputPrecision = (inputValue, precision, decimalMarker) => {
-            let processedInputValue = inputValue;
-            let processedDecimalMarker = decimalMarker;
-            if (precision < Infinity) {
-                // TODO need think about decimalMarker
-                if (Array.isArray(processedDecimalMarker)) {
-                    const marker = processedDecimalMarker.find((dm) => dm !== this.thousandSeparator);
-                    processedDecimalMarker = marker ? marker : processedDecimalMarker[0];
-                }
-                const precisionRegEx = new RegExp(this._charToRegExpExpression(processedDecimalMarker) + `\\d{${precision}}.*$`);
-                const precisionMatch = processedInputValue.match(precisionRegEx);
-                const precisionMatchLength = (precisionMatch && precisionMatch[0]?.length) ?? 0;
-                if (precisionMatchLength - 1 > precision) {
-                    const diff = precisionMatchLength - 1 - precision;
-                    processedInputValue = processedInputValue.substring(0, processedInputValue.length - diff);
-                }
-                if (precision === 0 &&
-                    this._compareOrIncludes(processedInputValue[processedInputValue.length - 1], processedDecimalMarker, this.thousandSeparator)) {
-                    processedInputValue = processedInputValue.substring(0, processedInputValue.length - 1);
-                }
-            }
-            return processedInputValue;
-        };
-    }
+    _config = inject(NGX_MASK_CONFIG);
+    dropSpecialCharacters = this._config.dropSpecialCharacters;
+    hiddenInput = this._config.hiddenInput;
+    showTemplate;
+    clearIfNotMatch = this._config.clearIfNotMatch;
+    specialCharacters = this._config.specialCharacters;
+    patterns = this._config.patterns;
+    prefix = this._config.prefix;
+    suffix = this._config.suffix;
+    thousandSeparator = this._config.thousandSeparator;
+    decimalMarker = this._config.decimalMarker;
+    customPattern;
+    showMaskTyped = this._config.showMaskTyped;
+    placeHolderCharacter = this._config.placeHolderCharacter;
+    validation = this._config.validation;
+    separatorLimit = this._config.separatorLimit;
+    allowNegativeNumbers = this._config.allowNegativeNumbers;
+    leadZeroDateTime = this._config.leadZeroDateTime;
+    leadZero = this._config.leadZero;
+    apm = this._config.apm;
+    inputTransformFn = this._config.inputTransformFn;
+    outputTransformFn = this._config.outputTransformFn;
+    keepCharacterPositions = this._config.keepCharacterPositions;
+    _shift = new Set();
+    plusOnePosition = false;
+    maskExpression = '';
+    actualValue = '';
+    showKeepCharacterExp = '';
+    shownMaskExpression = '';
+    deletedSpecialCharacter = false;
+    ipError;
+    cpfCnpjError;
     applyMaskWithPattern(inputValue, maskAndPattern) {
         const [mask, customPattern] = maskAndPattern;
         this.customPattern = customPattern;
         return this.applyMask(inputValue, mask);
     }
-    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, 
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    cb = () => { }) {
+    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, cb = () => { }) {
         if (!maskExpression || typeof inputValue !== 'string') {
-            return "" /* MaskExpression.EMPTY_STRING */;
+            return MaskExpression.EMPTY_STRING;
         }
         let cursor = 0;
         let result = '';
@@ -234,59 +195,53 @@ class NgxMaskApplierService {
         if (processedValue === '(' && this.prefix) {
             processedValue = '';
         }
-        const inputArray = processedValue.toString().split("" /* MaskExpression.EMPTY_STRING */);
+        const inputArray = processedValue.toString().split(MaskExpression.EMPTY_STRING);
         if (this.allowNegativeNumbers &&
-            processedValue.slice(cursor, cursor + 1) === "-" /* MaskExpression.MINUS */) {
+            processedValue.slice(cursor, cursor + 1) === MaskExpression.MINUS) {
             result += processedValue.slice(cursor, cursor + 1);
         }
-        if (maskExpression === "IP" /* MaskExpression.IP */) {
-            const valuesIP = processedValue.split("." /* MaskExpression.DOT */);
+        if (maskExpression === MaskExpression.IP) {
+            const valuesIP = processedValue.split(MaskExpression.DOT);
             this.ipError = this._validIP(valuesIP);
-            // eslint-disable-next-line no-param-reassign
             maskExpression = '099.099.099.099';
         }
         const arr = [];
-        // eslint-disable-next-line @typescript-eslint/prefer-for-of
         for (let i = 0; i < processedValue.length; i++) {
             if (processedValue[i]?.match('\\d')) {
-                arr.push(processedValue[i] ?? "" /* MaskExpression.EMPTY_STRING */);
+                arr.push(processedValue[i] ?? MaskExpression.EMPTY_STRING);
             }
         }
-        if (maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */) {
+        if (maskExpression === MaskExpression.CPF_CNPJ) {
             this.cpfCnpjError = arr.length !== 11 && arr.length !== 14;
             if (arr.length > 11) {
-                // eslint-disable-next-line no-param-reassign
                 maskExpression = '00.000.000/0000-00';
             }
             else {
-                // eslint-disable-next-line no-param-reassign
                 maskExpression = '000.000.000-00';
             }
         }
-        if (maskExpression.startsWith("percent" /* MaskExpression.PERCENT */)) {
+        if (maskExpression.startsWith(MaskExpression.PERCENT)) {
             if (processedValue.match('[a-z]|[A-Z]') ||
-                // eslint-disable-next-line no-useless-escape
                 (processedValue.match(/[-!$%^&*()_+|~=`{}\[\]:";'<>?,\/.]/) && !backspaced)) {
                 processedValue = this._stripToDecimal(processedValue);
                 const precision = this.getPrecision(maskExpression);
                 processedValue = this.checkInputPrecision(processedValue, precision, this.decimalMarker);
             }
-            const decimalMarker = typeof this.decimalMarker === 'string' ? this.decimalMarker : "." /* MaskExpression.DOT */;
+            const decimalMarker = typeof this.decimalMarker === 'string' ? this.decimalMarker : MaskExpression.DOT;
             if (processedValue.indexOf(decimalMarker) > 0 &&
                 !this.percentage(processedValue.substring(0, processedValue.indexOf(decimalMarker)))) {
                 let base = processedValue.substring(0, processedValue.indexOf(decimalMarker) - 1);
                 if (this.allowNegativeNumbers &&
-                    processedValue.slice(cursor, cursor + 1) === "-" /* MaskExpression.MINUS */ &&
+                    processedValue.slice(cursor, cursor + 1) === MaskExpression.MINUS &&
                     !backspaced) {
                     base = processedValue.substring(0, processedValue.indexOf(decimalMarker));
                 }
                 processedValue = `${base}${processedValue.substring(processedValue.indexOf(decimalMarker), processedValue.length)}`;
             }
             let value = '';
-            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
             this.allowNegativeNumbers &&
-                processedValue.slice(cursor, cursor + 1) === "-" /* MaskExpression.MINUS */
-                ? (value = `${"-" /* MaskExpression.MINUS */}${processedValue.slice(cursor + 1, cursor + processedValue.length)}`)
+                processedValue.slice(cursor, cursor + 1) === MaskExpression.MINUS
+                ? (value = `${MaskExpression.MINUS}${processedValue.slice(cursor + 1, cursor + processedValue.length)}`)
                 : (value = processedValue);
             if (this.percentage(value)) {
                 result = this._splitPercentZero(processedValue);
@@ -295,7 +250,7 @@ class NgxMaskApplierService {
                 result = this._splitPercentZero(processedValue.substring(0, processedValue.length - 1));
             }
         }
-        else if (maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+        else if (maskExpression.startsWith(MaskExpression.SEPARATOR)) {
             if (processedValue.match('[wа-яА-Я]') ||
                 processedValue.match('[ЁёА-я]') ||
                 processedValue.match('[a-z]|[A-Z]') ||
@@ -305,42 +260,42 @@ class NgxMaskApplierService {
             }
             const precision = this.getPrecision(maskExpression);
             const decimalMarker = Array.isArray(this.decimalMarker)
-                ? this.thousandSeparator === "." /* MaskExpression.DOT */
-                    ? "," /* MaskExpression.COMMA */
-                    : "." /* MaskExpression.DOT */
+                ? this.thousandSeparator === MaskExpression.DOT
+                    ? MaskExpression.COMMA
+                    : MaskExpression.DOT
                 : this.decimalMarker;
             if (precision === 0) {
                 processedValue = this.allowNegativeNumbers
                     ? processedValue.length > 2 &&
-                        processedValue[0] === "-" /* MaskExpression.MINUS */ &&
-                        processedValue[1] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                        processedValue[0] === MaskExpression.MINUS &&
+                        processedValue[1] === MaskExpression.NUMBER_ZERO &&
                         processedValue[2] !== this.thousandSeparator &&
-                        processedValue[2] !== "," /* MaskExpression.COMMA */ &&
-                        processedValue[2] !== "." /* MaskExpression.DOT */
+                        processedValue[2] !== MaskExpression.COMMA &&
+                        processedValue[2] !== MaskExpression.DOT
                         ? '-' + processedValue.slice(2, processedValue.length)
-                        : processedValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                        : processedValue[0] === MaskExpression.NUMBER_ZERO &&
                             processedValue.length > 1 &&
                             processedValue[1] !== this.thousandSeparator &&
-                            processedValue[1] !== "," /* MaskExpression.COMMA */ &&
-                            processedValue[1] !== "." /* MaskExpression.DOT */
+                            processedValue[1] !== MaskExpression.COMMA &&
+                            processedValue[1] !== MaskExpression.DOT
                             ? processedValue.slice(1, processedValue.length)
                             : processedValue
                     : processedValue.length > 1 &&
-                        processedValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                        processedValue[0] === MaskExpression.NUMBER_ZERO &&
                         processedValue[1] !== this.thousandSeparator &&
-                        processedValue[1] !== "," /* MaskExpression.COMMA */ &&
-                        processedValue[1] !== "." /* MaskExpression.DOT */
+                        processedValue[1] !== MaskExpression.COMMA &&
+                        processedValue[1] !== MaskExpression.DOT
                         ? processedValue.slice(1, processedValue.length)
                         : processedValue;
             }
             else {
                 if (processedValue[0] === decimalMarker && processedValue.length > 1) {
                     processedValue =
-                        "0" /* MaskExpression.NUMBER_ZERO */ +
+                        MaskExpression.NUMBER_ZERO +
                             processedValue.slice(0, processedValue.length + 1);
                     this.plusOnePosition = true;
                 }
-                if (processedValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                if (processedValue[0] === MaskExpression.NUMBER_ZERO &&
                     processedValue[1] !== decimalMarker &&
                     processedValue[1] !== this.thousandSeparator) {
                     processedValue =
@@ -352,15 +307,15 @@ class NgxMaskApplierService {
                     this.plusOnePosition = true;
                 }
                 if (this.allowNegativeNumbers &&
-                    processedValue[0] === "-" /* MaskExpression.MINUS */ &&
+                    processedValue[0] === MaskExpression.MINUS &&
                     (processedValue[1] === decimalMarker ||
-                        processedValue[1] === "0" /* MaskExpression.NUMBER_ZERO */)) {
+                        processedValue[1] === MaskExpression.NUMBER_ZERO)) {
                     processedValue =
                         processedValue[1] === decimalMarker && processedValue.length > 2
                             ? processedValue.slice(0, 1) +
-                                "0" /* MaskExpression.NUMBER_ZERO */ +
+                                MaskExpression.NUMBER_ZERO +
                                 processedValue.slice(1, processedValue.length)
-                            : processedValue[1] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                            : processedValue[1] === MaskExpression.NUMBER_ZERO &&
                                 processedValue.length > 2 &&
                                 processedValue[2] !== decimalMarker
                                 ? processedValue.slice(0, 2) +
@@ -372,13 +327,13 @@ class NgxMaskApplierService {
             }
             if (backspaced) {
                 const inputValueAfterZero = processedValue.slice(this._findFirstNonZeroDigitIndex(processedValue), processedValue.length);
-                const positionOfZeroOrDecimalMarker = processedValue[processedPosition] === "0" /* MaskExpression.NUMBER_ZERO */ ||
+                const positionOfZeroOrDecimalMarker = processedValue[processedPosition] === MaskExpression.NUMBER_ZERO ||
                     processedValue[processedPosition] === decimalMarker;
-                const zeroIndexNumberZero = processedValue[0] === "0" /* MaskExpression.NUMBER_ZERO */;
-                const zeroIndexMinus = processedValue[0] === "-" /* MaskExpression.MINUS */;
+                const zeroIndexNumberZero = processedValue[0] === MaskExpression.NUMBER_ZERO;
+                const zeroIndexMinus = processedValue[0] === MaskExpression.MINUS;
                 const zeroIndexThousand = processedValue[0] === this.thousandSeparator;
                 const firstIndexDecimalMarker = processedValue[1] === decimalMarker;
-                const firstIndexNumberZero = processedValue[1] === "0" /* MaskExpression.NUMBER_ZERO */;
+                const firstIndexNumberZero = processedValue[1] === MaskExpression.NUMBER_ZERO;
                 const secondIndexDecimalMarker = processedValue[2] === decimalMarker;
                 if (zeroIndexNumberZero &&
                     firstIndexDecimalMarker &&
@@ -391,27 +346,24 @@ class NgxMaskApplierService {
                     secondIndexDecimalMarker &&
                     positionOfZeroOrDecimalMarker &&
                     processedPosition < 3) {
-                    processedValue = "-" /* MaskExpression.MINUS */ + inputValueAfterZero;
+                    processedValue = MaskExpression.MINUS + inputValueAfterZero;
                 }
-                if (inputValueAfterZero !== "-" /* MaskExpression.MINUS */ &&
+                if (inputValueAfterZero !== MaskExpression.MINUS &&
                     ((processedPosition === 0 && (zeroIndexNumberZero || zeroIndexThousand)) ||
                         (this.allowNegativeNumbers &&
                             processedPosition === 1 &&
                             zeroIndexMinus &&
                             !firstIndexNumberZero))) {
                     processedValue = zeroIndexMinus
-                        ? "-" /* MaskExpression.MINUS */ + inputValueAfterZero
+                        ? MaskExpression.MINUS + inputValueAfterZero
                         : inputValueAfterZero;
                 }
             }
-            // TODO: we had different rexexps here for the different cases... but tests dont seam to bother - check this
-            //  separator: no COMMA, dot-sep: no SPACE, COMMA OK, comma-sep: no SPACE, COMMA OK
             const thousandSeparatorCharEscaped = this._charToRegExpExpression(this.thousandSeparator);
             let invalidChars = '@#!$%^&*()_+|~=`{}\\[\\]:\\s,\\.";<>?\\/'.replace(thousandSeparatorCharEscaped, '');
-            //.replace(decimalMarkerEscaped, '');
             if (Array.isArray(this.decimalMarker)) {
                 for (const marker of this.decimalMarker) {
-                    invalidChars = invalidChars.replace(this._charToRegExpExpression(marker), "" /* MaskExpression.EMPTY_STRING */);
+                    invalidChars = invalidChars.replace(this._charToRegExpExpression(marker), MaskExpression.EMPTY_STRING);
                 }
             }
             else {
@@ -424,7 +376,7 @@ class NgxMaskApplierService {
             processedValue = this.checkInputPrecision(processedValue, precision, this.decimalMarker);
             const strForSep = processedValue.replace(new RegExp(thousandSeparatorCharEscaped, 'g'), '');
             result = this._formatWithSeparators(strForSep, this.thousandSeparator, this.decimalMarker, precision);
-            const commaShift = result.indexOf("," /* MaskExpression.COMMA */) - processedValue.indexOf("," /* MaskExpression.COMMA */);
+            const commaShift = result.indexOf(MaskExpression.COMMA) - processedValue.indexOf(MaskExpression.COMMA);
             const shiftStep = result.length - processedValue.length;
             const backspacedDecimalMarkerWithSeparatorLimit = backspaced && result.length < inputValue.length && this.separatorLimit;
             if ((result[processedPosition - 1] === this.thousandSeparator ||
@@ -451,9 +403,9 @@ class NgxMaskApplierService {
             }
             else if ((commaShift !== 0 &&
                 processedPosition > 0 &&
-                !(result.indexOf("," /* MaskExpression.COMMA */) >= processedPosition &&
+                !(result.indexOf(MaskExpression.COMMA) >= processedPosition &&
                     processedPosition > 3)) ||
-                (!(result.indexOf("." /* MaskExpression.DOT */) >= processedPosition && processedPosition > 3) &&
+                (!(result.indexOf(MaskExpression.DOT) >= processedPosition && processedPosition > 3) &&
                     shiftStep <= 0)) {
                 this._shift.clear();
                 backspaceShift = true;
@@ -466,38 +418,36 @@ class NgxMaskApplierService {
             }
         }
         else {
-            for (
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            let i = 0, inputSymbol = inputArray[0]; i < inputArray.length; i++, inputSymbol = inputArray[i] ?? "" /* MaskExpression.EMPTY_STRING */) {
+            for (let i = 0, inputSymbol = inputArray[0]; i < inputArray.length; i++, inputSymbol = inputArray[i] ?? MaskExpression.EMPTY_STRING) {
                 if (cursor === maskExpression.length) {
                     break;
                 }
-                const symbolStarInPattern = "*" /* MaskExpression.SYMBOL_STAR */ in this.patterns;
-                if (this._checkSymbolMask(inputSymbol, maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */) &&
-                    maskExpression[cursor + 1] === "?" /* MaskExpression.SYMBOL_QUESTION */) {
+                const symbolStarInPattern = MaskExpression.SYMBOL_STAR in this.patterns;
+                if (this._checkSymbolMask(inputSymbol, maskExpression[cursor] ?? MaskExpression.EMPTY_STRING) &&
+                    maskExpression[cursor + 1] === MaskExpression.SYMBOL_QUESTION) {
                     result += inputSymbol;
                     cursor += 2;
                 }
-                else if (maskExpression[cursor + 1] === "*" /* MaskExpression.SYMBOL_STAR */ &&
+                else if (maskExpression[cursor + 1] === MaskExpression.SYMBOL_STAR &&
                     multi &&
-                    this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2] ?? "" /* MaskExpression.EMPTY_STRING */)) {
+                    this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2] ?? MaskExpression.EMPTY_STRING)) {
                     result += inputSymbol;
                     cursor += 3;
                     multi = false;
                 }
-                else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */) &&
-                    maskExpression[cursor + 1] === "*" /* MaskExpression.SYMBOL_STAR */ &&
+                else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor] ?? MaskExpression.EMPTY_STRING) &&
+                    maskExpression[cursor + 1] === MaskExpression.SYMBOL_STAR &&
                     !symbolStarInPattern) {
                     result += inputSymbol;
                     multi = true;
                 }
-                else if (maskExpression[cursor + 1] === "?" /* MaskExpression.SYMBOL_QUESTION */ &&
-                    this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2] ?? "" /* MaskExpression.EMPTY_STRING */)) {
+                else if (maskExpression[cursor + 1] === MaskExpression.SYMBOL_QUESTION &&
+                    this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2] ?? MaskExpression.EMPTY_STRING)) {
                     result += inputSymbol;
                     cursor += 3;
                 }
-                else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */)) {
-                    if (maskExpression[cursor] === "H" /* MaskExpression.HOURS */) {
+                else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor] ?? MaskExpression.EMPTY_STRING)) {
+                    if (maskExpression[cursor] === MaskExpression.HOURS) {
                         if (this.apm ? Number(inputSymbol) > 9 : Number(inputSymbol) > 2) {
                             processedPosition = !this.leadZeroDateTime
                                 ? processedPosition + 1
@@ -511,7 +461,7 @@ class NgxMaskApplierService {
                             continue;
                         }
                     }
-                    if (maskExpression[cursor] === "h" /* MaskExpression.HOUR */) {
+                    if (maskExpression[cursor] === MaskExpression.HOUR) {
                         if (this.apm
                             ? (result.length === 1 && Number(result) > 1) ||
                                 (result === '1' && Number(inputSymbol) > 2) ||
@@ -532,8 +482,8 @@ class NgxMaskApplierService {
                             continue;
                         }
                     }
-                    if (maskExpression[cursor] === "m" /* MaskExpression.MINUTE */ ||
-                        maskExpression[cursor] === "s" /* MaskExpression.SECOND */) {
+                    if (maskExpression[cursor] === MaskExpression.MINUTE ||
+                        maskExpression[cursor] === MaskExpression.SECOND) {
                         if (Number(inputSymbol) > 5) {
                             processedPosition = !this.leadZeroDateTime
                                 ? processedPosition + 1
@@ -557,9 +507,9 @@ class NgxMaskApplierService {
                     const inputValueSliceMinusOnePlusOne = processedValue.slice(cursor - 1, cursor + 1);
                     const inputValueSliceCursorPlusTwo = processedValue.slice(cursor, cursor + 2);
                     const inputValueSliceMinusTwoCursor = processedValue.slice(cursor - 2, cursor);
-                    if (maskExpression[cursor] === "d" /* MaskExpression.DAY */) {
-                        const maskStartWithMonth = maskExpression.slice(0, 2) === "M0" /* MaskExpression.MONTHS */;
-                        const startWithMonthInput = maskExpression.slice(0, 2) === "M0" /* MaskExpression.MONTHS */ &&
+                    if (maskExpression[cursor] === MaskExpression.DAY) {
+                        const maskStartWithMonth = maskExpression.slice(0, 2) === MaskExpression.MONTHS;
+                        const startWithMonthInput = maskExpression.slice(0, 2) === MaskExpression.MONTHS &&
                             this.specialCharacters.includes(inputValueCursorMinusTwo);
                         if ((Number(inputSymbol) > 3 && this.leadZeroDateTime) ||
                             (!maskStartWithMonth &&
@@ -586,15 +536,13 @@ class NgxMaskApplierService {
                             continue;
                         }
                     }
-                    if (maskExpression[cursor] === "M" /* MaskExpression.MONTH */) {
+                    if (maskExpression[cursor] === MaskExpression.MONTH) {
                         const monthsCount = 12;
-                        // mask without day
                         const withoutDays = cursor === 0 &&
                             (Number(inputSymbol) > 2 ||
                                 Number(inputValueSliceCursorPlusTwo) > monthsCount ||
                                 (this.specialCharacters.includes(inputValueCursorPlusOne) &&
                                     !backspaced));
-                        // day<10 && month<12 for input
                         const specialChart = maskExpression.slice(cursor + 2, cursor + 3);
                         const day1monthInput = inputValueSliceMinusThreeMinusOne.includes(specialChart) &&
                             maskExpression.includes('d0') &&
@@ -602,23 +550,19 @@ class NgxMaskApplierService {
                                 Number(inputValueSliceMinusOnePlusOne) > monthsCount &&
                                 !this.specialCharacters.includes(inputValueCursor)) ||
                                 this.specialCharacters.includes(inputValueCursor));
-                        //  month<12 && day<10 for input
                         const day2monthInput = Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&
                             !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
                             this.specialCharacters.includes(inputValueCursorMinusOne) &&
                             (Number(inputValueSliceCursorPlusTwo) > monthsCount ||
                                 this.specialCharacters.includes(inputValueCursorPlusOne));
-                        // cursor === 5 && without days
                         const day2monthInputDot = (Number(inputValueSliceCursorPlusTwo) > monthsCount && cursor === 5) ||
                             (this.specialCharacters.includes(inputValueCursorPlusOne) &&
                                 cursor === 5);
-                        // // day<10 && month<12 for paste whole data
                         const day1monthPaste = Number(inputValueSliceMinusThreeMinusOne) > daysCount &&
                             !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
                             !this.specialCharacters.includes(inputValueSliceMinusTwoCursor) &&
                             Number(inputValueSliceMinusTwoCursor) > monthsCount &&
                             maskExpression.includes('d0');
-                        // 10<day<31 && month<12 for paste whole data
                         const day2monthPaste = Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&
                             !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
                             !this.specialCharacters.includes(inputValueCursorMinusOne) &&
@@ -650,43 +594,43 @@ class NgxMaskApplierService {
                     result += inputSymbol;
                     cursor++;
                 }
-                else if (this.specialCharacters.indexOf(maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */) !== -1) {
+                else if (this.specialCharacters.indexOf(maskExpression[cursor] ?? MaskExpression.EMPTY_STRING) !== -1) {
                     result += maskExpression[cursor];
                     cursor++;
                     this._shiftStep(maskExpression, cursor, inputArray.length);
                     i--;
                 }
-                else if (maskExpression[cursor] === "9" /* MaskExpression.NUMBER_NINE */ &&
+                else if (maskExpression[cursor] === MaskExpression.NUMBER_NINE &&
                     this.showMaskTyped) {
                     this._shiftStep(maskExpression, cursor, inputArray.length);
                 }
-                else if (this.patterns[maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */] &&
-                    this.patterns[maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */]?.optional) {
+                else if (this.patterns[maskExpression[cursor] ?? MaskExpression.EMPTY_STRING] &&
+                    this.patterns[maskExpression[cursor] ?? MaskExpression.EMPTY_STRING]?.optional) {
                     if (!!inputArray[cursor] &&
                         maskExpression !== '099.099.099.099' &&
                         maskExpression !== '000.000.000-00' &&
                         maskExpression !== '00.000.000/0000-00' &&
                         !maskExpression.match(/^9+\.0+$/) &&
-                        !this.patterns[maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */]
+                        !this.patterns[maskExpression[cursor] ?? MaskExpression.EMPTY_STRING]
                             ?.optional) {
                         result += inputArray[cursor];
                     }
-                    if (maskExpression.includes("9" /* MaskExpression.NUMBER_NINE */ + "*" /* MaskExpression.SYMBOL_STAR */) &&
-                        maskExpression.includes("0" /* MaskExpression.NUMBER_ZERO */ + "*" /* MaskExpression.SYMBOL_STAR */)) {
+                    if (maskExpression.includes(MaskExpression.NUMBER_NINE + MaskExpression.SYMBOL_STAR) &&
+                        maskExpression.includes(MaskExpression.NUMBER_ZERO + MaskExpression.SYMBOL_STAR)) {
                         cursor++;
                     }
                     cursor++;
                     i--;
                 }
-                else if (this.maskExpression[cursor + 1] === "*" /* MaskExpression.SYMBOL_STAR */ &&
-                    this._findSpecialChar(this.maskExpression[cursor + 2] ?? "" /* MaskExpression.EMPTY_STRING */) &&
+                else if (this.maskExpression[cursor + 1] === MaskExpression.SYMBOL_STAR &&
+                    this._findSpecialChar(this.maskExpression[cursor + 2] ?? MaskExpression.EMPTY_STRING) &&
                     this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&
                     multi) {
                     cursor += 3;
                     result += inputSymbol;
                 }
-                else if (this.maskExpression[cursor + 1] === "?" /* MaskExpression.SYMBOL_QUESTION */ &&
-                    this._findSpecialChar(this.maskExpression[cursor + 2] ?? "" /* MaskExpression.EMPTY_STRING */) &&
+                else if (this.maskExpression[cursor + 1] === MaskExpression.SYMBOL_QUESTION &&
+                    this._findSpecialChar(this.maskExpression[cursor + 2] ?? MaskExpression.EMPTY_STRING) &&
                     this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&
                     multi) {
                     cursor += 3;
@@ -701,7 +645,7 @@ class NgxMaskApplierService {
             }
         }
         if (result.length + 1 === maskExpression.length &&
-            this.specialCharacters.indexOf(maskExpression[maskExpression.length - 1] ?? "" /* MaskExpression.EMPTY_STRING */) !== -1) {
+            this.specialCharacters.indexOf(maskExpression[maskExpression.length - 1] ?? MaskExpression.EMPTY_STRING) !== -1) {
             result += maskExpression[maskExpression.length - 1];
         }
         let newPosition = processedPosition + 1;
@@ -709,7 +653,7 @@ class NgxMaskApplierService {
             shift++;
             newPosition++;
         }
-        let actualShift = justPasted && !maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)
+        let actualShift = justPasted && !maskExpression.startsWith(MaskExpression.SEPARATOR)
             ? cursor
             : this._shift.has(processedPosition)
                 ? shift
@@ -725,7 +669,7 @@ class NgxMaskApplierService {
         if (backspaced) {
             onlySpecial = inputArray.every((char) => this.specialCharacters.includes(char));
         }
-        let res = `${this.prefix}${onlySpecial ? "" /* MaskExpression.EMPTY_STRING */ : result}${this.showMaskTyped ? '' : this.suffix}`;
+        let res = `${this.prefix}${onlySpecial ? MaskExpression.EMPTY_STRING : result}${this.showMaskTyped ? '' : this.suffix}`;
         if (result.length === 0) {
             res = !this.dropSpecialCharacters ? `${this.prefix}${result}` : `${result}`;
         }
@@ -736,13 +680,13 @@ class NgxMaskApplierService {
             isSpecialCharacterMaskFirstSymbol) {
             return '';
         }
-        if (result.includes("-" /* MaskExpression.MINUS */) && this.prefix && this.allowNegativeNumbers) {
-            if (backspaced && result === "-" /* MaskExpression.MINUS */) {
+        if (result.includes(MaskExpression.MINUS) && this.prefix && this.allowNegativeNumbers) {
+            if (backspaced && result === MaskExpression.MINUS) {
                 return '';
             }
-            res = `${"-" /* MaskExpression.MINUS */}${this.prefix}${result
-                .split("-" /* MaskExpression.MINUS */)
-                .join("" /* MaskExpression.EMPTY_STRING */)}${this.suffix}`;
+            res = `${MaskExpression.MINUS}${this.prefix}${result
+                .split(MaskExpression.MINUS)
+                .join(MaskExpression.EMPTY_STRING)}${this.suffix}`;
         }
         return res;
     }
@@ -761,25 +705,105 @@ class NgxMaskApplierService {
             this.patterns[maskSymbol]?.pattern.test(inputSymbol)) ??
             false);
     }
+    _formatWithSeparators = (str, thousandSeparatorChar, decimalChars, precision) => {
+        let x = [];
+        let decimalChar = '';
+        if (Array.isArray(decimalChars)) {
+            const regExp = new RegExp(decimalChars.map((v) => ('[\\^$.|?*+()'.indexOf(v) >= 0 ? `\\${v}` : v)).join('|'));
+            x = str.split(regExp);
+            decimalChar = str.match(regExp)?.[0] ?? MaskExpression.EMPTY_STRING;
+        }
+        else {
+            x = str.split(decimalChars);
+            decimalChar = decimalChars;
+        }
+        const decimals = x.length > 1 ? `${decimalChar}${x[1]}` : MaskExpression.EMPTY_STRING;
+        let res = x[0] ?? MaskExpression.EMPTY_STRING;
+        const separatorLimit = this.separatorLimit.replace(/\s/g, MaskExpression.EMPTY_STRING);
+        if (separatorLimit && +separatorLimit) {
+            if (res[0] === MaskExpression.MINUS) {
+                res = `-${res.slice(1, res.length).slice(0, separatorLimit.length)}`;
+            }
+            else {
+                res = res.slice(0, separatorLimit.length);
+            }
+        }
+        const rgx = /(\d+)(\d{3})/;
+        while (thousandSeparatorChar && rgx.test(res)) {
+            res = res.replace(rgx, '$1' + thousandSeparatorChar + '$2');
+        }
+        if (typeof precision === 'undefined') {
+            return res + decimals;
+        }
+        else if (precision === 0) {
+            return res;
+        }
+        return res + decimals.substring(0, precision + 1);
+    };
+    percentage = (str) => {
+        const sanitizedStr = str.replace(',', '.');
+        const value = Number(this.allowNegativeNumbers && str.includes(MaskExpression.MINUS)
+            ? sanitizedStr.slice(1, str.length)
+            : sanitizedStr);
+        return !isNaN(value) && value >= 0 && value <= 100;
+    };
+    getPrecision = (maskExpression) => {
+        const x = maskExpression.split(MaskExpression.DOT);
+        if (x.length > 1) {
+            return Number(x[x.length - 1]);
+        }
+        return Infinity;
+    };
+    checkAndRemoveSuffix = (inputValue) => {
+        for (let i = this.suffix?.length - 1; i >= 0; i--) {
+            const substr = this.suffix.substring(i, this.suffix?.length);
+            if (inputValue.includes(substr) &&
+                i !== this.suffix?.length - 1 &&
+                (i - 1 < 0 ||
+                    !inputValue.includes(this.suffix.substring(i - 1, this.suffix?.length)))) {
+                return inputValue.replace(substr, MaskExpression.EMPTY_STRING);
+            }
+        }
+        return inputValue;
+    };
+    checkInputPrecision = (inputValue, precision, decimalMarker) => {
+        let processedInputValue = inputValue;
+        let processedDecimalMarker = decimalMarker;
+        if (precision < Infinity) {
+            if (Array.isArray(processedDecimalMarker)) {
+                const marker = processedDecimalMarker.find((dm) => dm !== this.thousandSeparator);
+                processedDecimalMarker = marker ? marker : processedDecimalMarker[0];
+            }
+            const precisionRegEx = new RegExp(this._charToRegExpExpression(processedDecimalMarker) + `\\d{${precision}}.*$`);
+            const precisionMatch = processedInputValue.match(precisionRegEx);
+            const precisionMatchLength = (precisionMatch && precisionMatch[0]?.length) ?? 0;
+            if (precisionMatchLength - 1 > precision) {
+                const diff = precisionMatchLength - 1 - precision;
+                processedInputValue = processedInputValue.substring(0, processedInputValue.length - diff);
+            }
+            if (precision === 0 &&
+                this._compareOrIncludes(processedInputValue[processedInputValue.length - 1], processedDecimalMarker, this.thousandSeparator)) {
+                processedInputValue = processedInputValue.substring(0, processedInputValue.length - 1);
+            }
+        }
+        return processedInputValue;
+    };
     _stripToDecimal(str) {
         return str
-            .split("" /* MaskExpression.EMPTY_STRING */)
+            .split(MaskExpression.EMPTY_STRING)
             .filter((i, idx) => {
             const isDecimalMarker = typeof this.decimalMarker === 'string'
                 ? i === this.decimalMarker
-                : // TODO (inepipenko) use utility type
+                :
                     this.decimalMarker.includes(i);
             return (i.match('^-?\\d') ||
                 i === this.thousandSeparator ||
                 isDecimalMarker ||
-                (i === "-" /* MaskExpression.MINUS */ && idx === 0 && this.allowNegativeNumbers));
+                (i === MaskExpression.MINUS && idx === 0 && this.allowNegativeNumbers));
         })
-            .join("" /* MaskExpression.EMPTY_STRING */);
+            .join(MaskExpression.EMPTY_STRING);
     }
     _charToRegExpExpression(char) {
-        // if (Array.isArray(char)) {
-        // 	return char.map((v) => ('[\\^$.|?*+()'.indexOf(v) >= 0 ? `\\${v}` : v)).join('|');
-        // }
         if (char) {
             const charsToEscape = '[\\^$.|?*+()';
             return char === ' ' ? '\\s' : charsToEscape.indexOf(char) >= 0 ? `\\${char}` : char;
@@ -801,32 +825,32 @@ class NgxMaskApplierService {
         return !(valuesIP.length === 4 &&
             !valuesIP.some((value, index) => {
                 if (valuesIP.length !== index + 1) {
-                    return value === "" /* MaskExpression.EMPTY_STRING */ || Number(value) > 255;
+                    return value === MaskExpression.EMPTY_STRING || Number(value) > 255;
                 }
-                return value === "" /* MaskExpression.EMPTY_STRING */ || Number(value.substring(0, 3)) > 255;
+                return value === MaskExpression.EMPTY_STRING || Number(value.substring(0, 3)) > 255;
             }));
     }
     _splitPercentZero(value) {
-        if (value === "-" /* MaskExpression.MINUS */ && this.allowNegativeNumbers) {
+        if (value === MaskExpression.MINUS && this.allowNegativeNumbers) {
             return value;
         }
         const decimalIndex = typeof this.decimalMarker === 'string'
             ? value.indexOf(this.decimalMarker)
-            : value.indexOf("." /* MaskExpression.DOT */);
-        const emptyOrMinus = this.allowNegativeNumbers && value.includes("-" /* MaskExpression.MINUS */) ? '-' : '';
+            : value.indexOf(MaskExpression.DOT);
+        const emptyOrMinus = this.allowNegativeNumbers && value.includes(MaskExpression.MINUS) ? '-' : '';
         if (decimalIndex === -1) {
             const parsedValue = parseInt(emptyOrMinus ? value.slice(1, value.length) : value, 10);
             return isNaN(parsedValue)
-                ? "" /* MaskExpression.EMPTY_STRING */
+                ? MaskExpression.EMPTY_STRING
                 : `${emptyOrMinus}${parsedValue}`;
         }
         else {
             const integerPart = parseInt(value.replace('-', '').substring(0, decimalIndex), 10);
             const decimalPart = value.substring(decimalIndex + 1);
             const integerString = isNaN(integerPart) ? '' : integerPart.toString();
-            const decimal = typeof this.decimalMarker === 'string' ? this.decimalMarker : "." /* MaskExpression.DOT */;
-            return integerString === "" /* MaskExpression.EMPTY_STRING */
-                ? "" /* MaskExpression.EMPTY_STRING */
+            const decimal = typeof this.decimalMarker === 'string' ? this.decimalMarker : MaskExpression.DOT;
+            return integerString === MaskExpression.EMPTY_STRING
+                ? MaskExpression.EMPTY_STRING
                 : `${emptyOrMinus}${integerString}${decimal}${decimalPart}`;
         }
     }
@@ -839,73 +863,64 @@ class NgxMaskApplierService {
         }
         return -1;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskApplierService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskApplierService }); }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskApplierService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskApplierService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskApplierService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskApplierService, decorators: [{
             type: Injectable
         }] });
 
 class NgxMaskService extends NgxMaskApplierService {
-    constructor() {
-        super(...arguments);
-        this.isNumberValue = false;
-        this.maskIsShown = '';
-        this.selStart = null;
-        this.selEnd = null;
-        /**
-         * Whether we are currently in writeValue function, in this case when applying the mask we don't want to trigger onChange function,
-         * since writeValue should be a one way only process of writing the DOM value based on the Angular model value.
-         */
-        this.writingValue = false;
-        this.maskChanged = false;
-        this._maskExpressionArray = [];
-        this.triggerOnMaskChange = false;
-        this._previousValue = '';
-        this._currentValue = '';
-        this._emitValue = false;
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        this.onChange = (_) => { };
-        this._elementRef = inject(ElementRef, { optional: true });
-        this.document = inject(DOCUMENT);
-        this._config = inject(NGX_MASK_CONFIG);
-        this._renderer = inject(Renderer2, { optional: true });
-    }
-    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, 
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    cb = () => { }) {
+    isNumberValue = false;
+    maskIsShown = '';
+    selStart = null;
+    selEnd = null;
+    writingValue = false;
+    maskChanged = false;
+    _maskExpressionArray = [];
+    triggerOnMaskChange = false;
+    _previousValue = '';
+    _currentValue = '';
+    _emitValue = false;
+    _start;
+    _end;
+    onChange = (_) => { };
+    _elementRef = inject(ElementRef, { optional: true });
+    document = inject(DOCUMENT);
+    _config = inject(NGX_MASK_CONFIG);
+    _renderer = inject(Renderer2, { optional: true });
+    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, cb = () => { }) {
         if (!maskExpression) {
             return inputValue !== this.actualValue ? this.actualValue : inputValue;
         }
         this.maskIsShown = this.showMaskTyped
             ? this.showMaskInInput()
-            : "" /* MaskExpression.EMPTY_STRING */;
-        if (this.maskExpression === "IP" /* MaskExpression.IP */ && this.showMaskTyped) {
-            this.maskIsShown = this.showMaskInInput(inputValue || "#" /* MaskExpression.HASH */);
+            : MaskExpression.EMPTY_STRING;
+        if (this.maskExpression === MaskExpression.IP && this.showMaskTyped) {
+            this.maskIsShown = this.showMaskInInput(inputValue || MaskExpression.HASH);
         }
-        if (this.maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */ && this.showMaskTyped) {
-            this.maskIsShown = this.showMaskInInput(inputValue || "#" /* MaskExpression.HASH */);
+        if (this.maskExpression === MaskExpression.CPF_CNPJ && this.showMaskTyped) {
+            this.maskIsShown = this.showMaskInInput(inputValue || MaskExpression.HASH);
         }
         if (!inputValue && this.showMaskTyped) {
             this.formControlResult(this.prefix);
             return `${this.prefix}${this.maskIsShown}${this.suffix}`;
         }
         const getSymbol = !!inputValue && typeof this.selStart === 'number'
-            ? (inputValue[this.selStart] ?? "" /* MaskExpression.EMPTY_STRING */)
-            : "" /* MaskExpression.EMPTY_STRING */;
+            ? (inputValue[this.selStart] ?? MaskExpression.EMPTY_STRING)
+            : MaskExpression.EMPTY_STRING;
         let newInputValue = '';
         let newPosition = position;
-        if (this.hiddenInput && !this.writingValue) {
+        if (this.hiddenInput !== null && !this.writingValue) {
             let actualResult = inputValue && inputValue.length === 1
-                ? inputValue.split("" /* MaskExpression.EMPTY_STRING */)
-                : this.actualValue.split("" /* MaskExpression.EMPTY_STRING */);
+                ? inputValue.split(MaskExpression.EMPTY_STRING)
+                : this.actualValue.split(MaskExpression.EMPTY_STRING);
             if (typeof this.selStart === 'object' && typeof this.selEnd === 'object') {
                 this.selStart = Number(this.selStart);
                 this.selEnd = Number(this.selEnd);
             }
             else {
-                // eslint-disable-next-line no-unused-expressions,@typescript-eslint/no-unused-expressions
-                inputValue !== "" /* MaskExpression.EMPTY_STRING */ && actualResult.length
+                inputValue !== MaskExpression.EMPTY_STRING && actualResult.length
                     ? typeof this.selStart === 'number' && typeof this.selEnd === 'number'
                         ? inputValue.length > actualResult.length
                             ? actualResult.splice(this.selStart, 0, getSymbol)
@@ -924,14 +939,14 @@ class NgxMaskService extends NgxMaskApplierService {
             }
             newInputValue =
                 this.actualValue.length && actualResult.length <= inputValue.length
-                    ? this.shiftTypedSymbols(actualResult.join("" /* MaskExpression.EMPTY_STRING */))
+                    ? this.shiftTypedSymbols(actualResult.join(MaskExpression.EMPTY_STRING))
                     : inputValue;
         }
         if (justPasted && (this.hiddenInput || !this.hiddenInput)) {
             newInputValue = inputValue;
         }
         if (backspaced &&
-            this.specialCharacters.indexOf(this.maskExpression[newPosition] ?? "" /* MaskExpression.EMPTY_STRING */) !== -1 &&
+            this.specialCharacters.indexOf(this.maskExpression[newPosition] ?? MaskExpression.EMPTY_STRING) !== -1 &&
             this.showMaskTyped &&
             !this.prefix) {
             newInputValue = this._currentValue;
@@ -940,7 +955,7 @@ class NgxMaskService extends NgxMaskApplierService {
             if (this.specialCharacters.includes(this.actualValue.slice(newPosition, newPosition + 1))) {
                 newPosition = newPosition + 1;
             }
-            else if (maskExpression.slice(newPosition - 1, newPosition + 1) !== "M0" /* MaskExpression.MONTHS */) {
+            else if (maskExpression.slice(newPosition - 1, newPosition + 1) !== MaskExpression.MONTHS) {
                 newPosition = newPosition - 2;
             }
             this.deletedSpecialCharacter = false;
@@ -972,17 +987,13 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         const result = super.applyMask(newInputValue, maskExpression, newPosition, justPasted, backspaced, cb);
         this.actualValue = this.getActualValue(result);
-        // handle some separator implications:
-        // a.) adjust decimalMarker default (. -> ,) if thousandSeparator is a dot
-        if (this.thousandSeparator === "." /* MaskExpression.DOT */ &&
-            this.decimalMarker === "." /* MaskExpression.DOT */) {
-            this.decimalMarker = "," /* MaskExpression.COMMA */;
-        }
-        // b) remove decimal marker from list of special characters to mask
-        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+        if (this.thousandSeparator === MaskExpression.DOT &&
+            this.decimalMarker === MaskExpression.DOT) {
+            this.decimalMarker = MaskExpression.COMMA;
+        }
+        if (this.maskExpression.startsWith(MaskExpression.SEPARATOR) &&
             this.dropSpecialCharacters === true) {
-            this.specialCharacters = this.specialCharacters.filter((item) => !this._compareOrIncludes(item, this.decimalMarker, this.thousandSeparator) //item !== this.decimalMarker, // !
-            );
+            this.specialCharacters = this.specialCharacters.filter((item) => !this._compareOrIncludes(item, this.decimalMarker, this.thousandSeparator));
         }
         if (result || result === '') {
             this._previousValue = this._currentValue;
@@ -993,7 +1004,6 @@ class NgxMaskService extends NgxMaskApplierService {
                     this.writingValue ||
                     (this._previousValue === this._currentValue && justPasted);
         }
-        // eslint-disable-next-line no-unused-expressions,@typescript-eslint/no-unused-expressions
         this._emitValue
             ? this.writingValue && this.triggerOnMaskChange
                 ? requestAnimationFrame(() => this.formControlResult(result))
@@ -1010,17 +1020,16 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         const resLen = result.length;
         const prefNmask = `${this.prefix}${this.maskIsShown}${this.suffix}`;
-        if (this.maskExpression.includes("H" /* MaskExpression.HOURS */)) {
+        if (this.maskExpression.includes(MaskExpression.HOURS)) {
             const countSkipedSymbol = this._numberSkipedSymbols(result);
             return `${result}${prefNmask.slice(resLen + countSkipedSymbol)}`;
         }
-        else if (this.maskExpression === "IP" /* MaskExpression.IP */ ||
-            this.maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */) {
+        else if (this.maskExpression === MaskExpression.IP ||
+            this.maskExpression === MaskExpression.CPF_CNPJ) {
             return `${result}${prefNmask}`;
         }
         return `${result}${prefNmask.slice(resLen)}`;
     }
-    // get the number of characters that were shifted
     _numberSkipedSymbols(value) {
         const regex = /(^|\D)(\d\D)/g;
         let match = regex.exec(value);
@@ -1031,9 +1040,7 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         return countSkipedSymbol;
     }
-    applyValueChanges(position, justPasted, backspaced, 
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    cb = () => { }) {
+    applyValueChanges(position, justPasted, backspaced, cb = () => { }) {
         const formElement = this._elementRef?.nativeElement;
         if (!formElement) {
             return;
@@ -1046,29 +1053,28 @@ class NgxMaskService extends NgxMaskApplierService {
     }
     hideInput(inputValue, maskExpression) {
         return inputValue
-            .split("" /* MaskExpression.EMPTY_STRING */)
+            .split(MaskExpression.EMPTY_STRING)
             .map((curr, index) => {
             if (this.patterns &&
-                this.patterns[maskExpression[index] ?? "" /* MaskExpression.EMPTY_STRING */] &&
-                this.patterns[maskExpression[index] ?? "" /* MaskExpression.EMPTY_STRING */]?.symbol) {
-                return this.patterns[maskExpression[index] ?? "" /* MaskExpression.EMPTY_STRING */]
+                this.patterns[maskExpression[index] ?? MaskExpression.EMPTY_STRING] &&
+                this.patterns[maskExpression[index] ?? MaskExpression.EMPTY_STRING]?.symbol) {
+                return this.patterns[maskExpression[index] ?? MaskExpression.EMPTY_STRING]
                     ?.symbol;
             }
             return curr;
         })
-            .join("" /* MaskExpression.EMPTY_STRING */);
+            .join(MaskExpression.EMPTY_STRING);
     }
-    // this function is not necessary, it checks result against maskExpression
     getActualValue(res) {
         const compare = res
-            .split("" /* MaskExpression.EMPTY_STRING */)
+            .split(MaskExpression.EMPTY_STRING)
             .filter((symbol, i) => {
-            const maskChar = this.maskExpression[i] ?? "" /* MaskExpression.EMPTY_STRING */;
+            const maskChar = this.maskExpression[i] ?? MaskExpression.EMPTY_STRING;
             return (this._checkSymbolMask(symbol, maskChar) ||
                 (this.specialCharacters.includes(maskChar) && symbol === maskChar));
         });
-        if (compare.join("" /* MaskExpression.EMPTY_STRING */) === res) {
-            return compare.join("" /* MaskExpression.EMPTY_STRING */);
+        if (compare.join(MaskExpression.EMPTY_STRING) === res) {
+            return compare.join(MaskExpression.EMPTY_STRING);
         }
         return res;
     }
@@ -1076,33 +1082,28 @@ class NgxMaskService extends NgxMaskApplierService {
         let symbolToReplace = '';
         const newInputValue = (inputValue &&
             inputValue
-                .split("" /* MaskExpression.EMPTY_STRING */)
+                .split(MaskExpression.EMPTY_STRING)
                 .map((currSymbol, index) => {
-                if (this.specialCharacters.includes(inputValue[index + 1] ?? "" /* MaskExpression.EMPTY_STRING */) &&
+                if (this.specialCharacters.includes(inputValue[index + 1] ?? MaskExpression.EMPTY_STRING) &&
                     inputValue[index + 1] !== this.maskExpression[index + 1]) {
                     symbolToReplace = currSymbol;
                     return inputValue[index + 1];
                 }
                 if (symbolToReplace.length) {
                     const replaceSymbol = symbolToReplace;
-                    symbolToReplace = "" /* MaskExpression.EMPTY_STRING */;
+                    symbolToReplace = MaskExpression.EMPTY_STRING;
                     return replaceSymbol;
                 }
                 return currSymbol;
             })) ||
             [];
-        return newInputValue.join("" /* MaskExpression.EMPTY_STRING */);
+        return newInputValue.join(MaskExpression.EMPTY_STRING);
     }
-    /**
-     * Convert number value to string
-     * 3.1415 -> '3.1415'
-     * 1e-7 -> '0.0000001'
-     */
     numberToString(value) {
         if ((!value && value !== 0) ||
-            (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+            (this.maskExpression.startsWith(MaskExpression.SEPARATOR) &&
                 (this.leadZero || !this.dropSpecialCharacters)) ||
-            (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+            (this.maskExpression.startsWith(MaskExpression.SEPARATOR) &&
                 this.separatorLimit.length > 14 &&
                 String(value).length > 14)) {
             return String(value);
@@ -1112,7 +1113,7 @@ class NgxMaskService extends NgxMaskApplierService {
             useGrouping: false,
             maximumFractionDigits: 20,
         })
-            .replace(`/${"-" /* MaskExpression.MINUS */}/`, "-" /* MaskExpression.MINUS */);
+            .replace(`/${MaskExpression.MINUS}/`, MaskExpression.MINUS);
     }
     showMaskInInput(inputVal) {
         if (this.showMaskTyped && !!this.shownMaskExpression) {
@@ -1125,10 +1126,10 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         else if (this.showMaskTyped) {
             if (inputVal) {
-                if (this.maskExpression === "IP" /* MaskExpression.IP */) {
+                if (this.maskExpression === MaskExpression.IP) {
                     return this._checkForIp(inputVal);
                 }
-                if (this.maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */) {
+                if (this.maskExpression === MaskExpression.CPF_CNPJ) {
                     return this._checkForCpfCnpj(inputVal);
                 }
             }
@@ -1146,9 +1147,9 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         if (this.clearIfNotMatch &&
             this.prefix.length + this.maskExpression.length + this.suffix.length !==
-                formElement.value.replace(this.placeHolderCharacter, "" /* MaskExpression.EMPTY_STRING */)
+                formElement.value.replace(this.placeHolderCharacter, MaskExpression.EMPTY_STRING)
                     .length) {
-            this.formElementProperty = ['value', "" /* MaskExpression.EMPTY_STRING */];
+            this.formElementProperty = ['value', MaskExpression.EMPTY_STRING];
             this.applyMask('', this.maskExpression);
         }
     }
@@ -1156,12 +1157,11 @@ class NgxMaskService extends NgxMaskApplierService {
         if (!this._renderer || !this._elementRef) {
             return;
         }
-        //[TODO]: andriikamaldinov1 find better solution
         Promise.resolve().then(() => this._renderer?.setProperty(this._elementRef?.nativeElement, name, value));
     }
     checkDropSpecialCharAmount(mask) {
         const chars = mask
-            .split("" /* MaskExpression.EMPTY_STRING */)
+            .split(MaskExpression.EMPTY_STRING)
             .filter((item) => this._findDropSpecialChar(item));
         return chars.length;
     }
@@ -1169,13 +1169,12 @@ class NgxMaskService extends NgxMaskApplierService {
         return this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.specialCharacters.concat('_').concat(this.placeHolderCharacter));
     }
     _checkForIp(inputVal) {
-        if (inputVal === "#" /* MaskExpression.HASH */) {
+        if (inputVal === MaskExpression.HASH) {
             return `${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}`;
         }
         const arr = [];
-        // eslint-disable-next-line @typescript-eslint/prefer-for-of
         for (let i = 0; i < inputVal.length; i++) {
-            const value = inputVal[i] ?? "" /* MaskExpression.EMPTY_STRING */;
+            const value = inputVal[i] ?? MaskExpression.EMPTY_STRING;
             if (!value) {
                 continue;
             }
@@ -1207,13 +1206,12 @@ class NgxMaskService extends NgxMaskApplierService {
             `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
             `/${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
             `-${this.placeHolderCharacter}${this.placeHolderCharacter}`;
-        if (inputVal === "#" /* MaskExpression.HASH */) {
+        if (inputVal === MaskExpression.HASH) {
             return cpf;
         }
         const arr = [];
-        // eslint-disable-next-line @typescript-eslint/prefer-for-of
         for (let i = 0; i < inputVal.length; i++) {
-            const value = inputVal[i] ?? "" /* MaskExpression.EMPTY_STRING */;
+            const value = inputVal[i] ?? MaskExpression.EMPTY_STRING;
             if (!value) {
                 continue;
             }
@@ -1247,9 +1245,6 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         return '';
     }
-    /**
-     * Recursively determine the current active element by navigating the Shadow DOM until the Active Element is found.
-     */
     _getActiveElement(document = this.document) {
         const shadowRootEl = document?.activeElement?.shadowRoot;
         if (!shadowRootEl?.activeElement) {
@@ -1259,20 +1254,12 @@ class NgxMaskService extends NgxMaskApplierService {
             return this._getActiveElement(shadowRootEl);
         }
     }
-    /**
-     * Propogates the input value back to the Angular model by triggering the onChange function. It won't do this if writingValue
-     * is true. If that is true it means we are currently in the writeValue function, which is supposed to only update the actual
-     * DOM element based on the Angular model value. It should be a one way process, i.e. writeValue should not be modifying the Angular
-     * model value too. Therefore, we don't trigger onChange in this scenario.
-     * @param inputValue the current form input value
-     */
     formControlResult(inputValue) {
         if (this.writingValue && !inputValue) {
             this.onChange('');
             return;
         }
         if (this.writingValue || (!this.triggerOnMaskChange && this.maskChanged)) {
-            // eslint-disable-next-line no-unused-expressions,@typescript-eslint/no-unused-expressions
             this.triggerOnMaskChange && this.maskChanged
                 ? this.onChange(this.outputTransformFn(this._toNumber(this._checkSymbols(this._removeSuffix(this._removePrefix(inputValue))))))
                 : '';
@@ -1291,43 +1278,43 @@ class NgxMaskService extends NgxMaskApplierService {
         }
     }
     _toNumber(value) {
-        if (!this.isNumberValue || value === "" /* MaskExpression.EMPTY_STRING */) {
+        if (!this.isNumberValue || value === MaskExpression.EMPTY_STRING) {
             return value;
         }
-        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+        if (this.maskExpression.startsWith(MaskExpression.SEPARATOR) &&
             (this.leadZero || !this.dropSpecialCharacters)) {
             return value;
         }
-        if (String(value).length > 14 && this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+        if (String(value).length > 14 && this.maskExpression.startsWith(MaskExpression.SEPARATOR)) {
             return String(value);
         }
         const num = Number(value);
-        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) && Number.isNaN(num)) {
+        if (this.maskExpression.startsWith(MaskExpression.SEPARATOR) && Number.isNaN(num)) {
             const val = String(value).replace(',', '.');
             return Number(val);
         }
         return Number.isNaN(num) ? value : num;
     }
     _removeMask(value, specialCharactersForRemove) {
-        if (this.maskExpression.startsWith("percent" /* MaskExpression.PERCENT */) &&
-            value.includes("." /* MaskExpression.DOT */)) {
+        if (this.maskExpression.startsWith(MaskExpression.PERCENT) &&
+            value.includes(MaskExpression.DOT)) {
             return value;
         }
         return value
-            ? value.replace(this._regExpForRemove(specialCharactersForRemove), "" /* MaskExpression.EMPTY_STRING */)
+            ? value.replace(this._regExpForRemove(specialCharactersForRemove), MaskExpression.EMPTY_STRING)
             : value;
     }
     _removePrefix(value) {
         if (!this.prefix) {
             return value;
         }
-        return value ? value.replace(this.prefix, "" /* MaskExpression.EMPTY_STRING */) : value;
+        return value ? value.replace(this.prefix, MaskExpression.EMPTY_STRING) : value;
     }
     _removeSuffix(value) {
         if (!this.suffix) {
             return value;
         }
-        return value ? value.replace(this.suffix, "" /* MaskExpression.EMPTY_STRING */) : value;
+        return value ? value.replace(this.suffix, MaskExpression.EMPTY_STRING) : value;
     }
     _retrieveSeparatorValue(result) {
         let specialCharacters = Array.isArray(this.dropSpecialCharacters)
@@ -1337,9 +1324,9 @@ class NgxMaskService extends NgxMaskApplierService {
             : this.specialCharacters;
         if (!this.deletedSpecialCharacter &&
             this._checkPatternForSpace() &&
-            result.includes(" " /* MaskExpression.WHITE_SPACE */) &&
-            this.maskExpression.includes("*" /* MaskExpression.SYMBOL_STAR */)) {
-            specialCharacters = specialCharacters.filter((char) => char !== " " /* MaskExpression.WHITE_SPACE */);
+            result.includes(MaskExpression.WHITE_SPACE) &&
+            this.maskExpression.includes(MaskExpression.SYMBOL_STAR)) {
+            specialCharacters = specialCharacters.filter((char) => char !== MaskExpression.WHITE_SPACE);
         }
         return this._removeMask(result, specialCharacters);
     }
@@ -1350,16 +1337,16 @@ class NgxMaskService extends NgxMaskApplierService {
         const markers = Array.isArray(this.decimalMarker)
             ? this.decimalMarker
             : [this.decimalMarker];
-        return value.replace(this._regExpForRemove(markers), "." /* MaskExpression.DOT */);
+        return value.replace(this._regExpForRemove(markers), MaskExpression.DOT);
     }
     _checkSymbols(result) {
         let processedResult = result;
-        if (processedResult === "" /* MaskExpression.EMPTY_STRING */) {
+        if (processedResult === MaskExpression.EMPTY_STRING) {
             return processedResult;
         }
-        if (this.maskExpression.startsWith("percent" /* MaskExpression.PERCENT */) &&
-            this.decimalMarker === "," /* MaskExpression.COMMA */) {
-            processedResult = processedResult.replace("," /* MaskExpression.COMMA */, "." /* MaskExpression.DOT */);
+        if (this.maskExpression.startsWith(MaskExpression.PERCENT) &&
+            this.decimalMarker === MaskExpression.COMMA) {
+            processedResult = processedResult.replace(MaskExpression.COMMA, MaskExpression.DOT);
         }
         const separatorPrecision = this._retrieveSeparatorPrecision(this.maskExpression);
         const separatorValue = this._replaceDecimalMarkerToDot(this._retrieveSeparatorValue(processedResult));
@@ -1381,11 +1368,10 @@ class NgxMaskService extends NgxMaskApplierService {
     }
     _checkPatternForSpace() {
         for (const key in this.patterns) {
-            // eslint-disable-next-line no-prototype-builtins
             if (this.patterns[key] && this.patterns[key]?.hasOwnProperty('pattern')) {
                 const patternString = this.patterns[key]?.pattern.toString();
                 const pattern = this.patterns[key]?.pattern;
-                if (patternString?.includes(" " /* MaskExpression.WHITE_SPACE */) &&
+                if (patternString?.includes(MaskExpression.WHITE_SPACE) &&
                     pattern?.test(this.maskExpression)) {
                     return true;
                 }
@@ -1393,7 +1379,6 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         return false;
     }
-    // TODO should think about helpers or separting decimal precision to own property
     _retrieveSeparatorPrecision(maskExpretion) {
         const matcher = maskExpretion.match(new RegExp(`^separator\\.([^d]*)`));
         return matcher ? Number(matcher[1]) : null;
@@ -1403,7 +1388,7 @@ class NgxMaskService extends NgxMaskApplierService {
         let value = separatorValue;
         if (separatorExpression.indexOf('2') > 0 ||
             (this.leadZero && Number(separatorPrecision) > 0)) {
-            if (this.decimalMarker === "," /* MaskExpression.COMMA */ && this.leadZero) {
+            if (this.decimalMarker === MaskExpression.COMMA && this.leadZero) {
                 value = value.replace(',', '.');
             }
             return this.leadZero
@@ -1415,20 +1400,20 @@ class NgxMaskService extends NgxMaskApplierService {
     _repeatPatternSymbols(maskExp) {
         return ((maskExp.match(/{[0-9]+}/) &&
             maskExp
-                .split("" /* MaskExpression.EMPTY_STRING */)
+                .split(MaskExpression.EMPTY_STRING)
                 .reduce((accum, currVal, index) => {
                 this._start =
-                    currVal === "{" /* MaskExpression.CURLY_BRACKETS_LEFT */ ? index : this._start;
-                if (currVal !== "}" /* MaskExpression.CURLY_BRACKETS_RIGHT */) {
+                    currVal === MaskExpression.CURLY_BRACKETS_LEFT ? index : this._start;
+                if (currVal !== MaskExpression.CURLY_BRACKETS_RIGHT) {
                     return this._findSpecialChar(currVal) ? accum + currVal : accum;
                 }
                 this._end = index;
                 const repeatNumber = Number(maskExp.slice(this._start + 1, this._end));
                 const replaceWith = new Array(repeatNumber + 1).join(maskExp[this._start - 1]);
                 if (maskExp.slice(0, this._start).length > 1 &&
-                    maskExp.includes("S" /* MaskExpression.LETTER_S */)) {
+                    maskExp.includes(MaskExpression.LETTER_S)) {
                     const symbols = maskExp.slice(0, this._start - 1);
-                    return symbols.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)
+                    return symbols.includes(MaskExpression.CURLY_BRACKETS_LEFT)
                         ? accum + replaceWith
                         : symbols + accum + replaceWith;
                 }
@@ -1441,16 +1426,13 @@ class NgxMaskService extends NgxMaskApplierService {
     currentLocaleDecimalMarker() {
         return (1.1).toLocaleString().substring(1, 2);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskService }); }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskService, decorators: [{
             type: Injectable
         }] });
 
-/**
- * @internal
- */
 function _configFactory() {
     const initConfig = inject(INITIAL_CONFIG);
     const configValue = inject(NEW_CONFIG);
@@ -1480,48 +1462,45 @@ function provideEnvironmentNgxMask(configValue) {
 }
 
 class NgxMaskDirective {
-    constructor() {
-        this.maskExpression = '';
-        this.specialCharacters = [];
-        this.patterns = {};
-        this.prefix = '';
-        this.suffix = '';
-        this.thousandSeparator = ' ';
-        this.decimalMarker = '.';
-        this.dropSpecialCharacters = null;
-        this.hiddenInput = null;
-        this.showMaskTyped = null;
-        this.placeHolderCharacter = null;
-        this.shownMaskExpression = null;
-        this.showTemplate = null;
-        this.clearIfNotMatch = null;
-        this.validation = null;
-        this.separatorLimit = null;
-        this.allowNegativeNumbers = null;
-        this.leadZeroDateTime = null;
-        this.leadZero = null;
-        this.triggerOnMaskChange = null;
-        this.apm = null;
-        this.inputTransformFn = null;
-        this.outputTransformFn = null;
-        this.keepCharacterPositions = null;
-        this.maskFilled = new EventEmitter();
-        this._maskValue = '';
-        this._position = null;
-        this._maskExpressionArray = [];
-        this._allowFewMaskChangeMask = false;
-        this._justPasted = false;
-        this._isFocused = false;
-        /**For IME composition event */
-        this._isComposing = false;
-        this.document = inject(DOCUMENT);
-        this._maskService = inject(NgxMaskService, { self: true });
-        this._config = inject(NGX_MASK_CONFIG);
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        this.onChange = (_) => { };
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        this.onTouch = () => { };
-    }
+    maskExpression = '';
+    specialCharacters = [];
+    patterns = {};
+    prefix = '';
+    suffix = '';
+    thousandSeparator = ' ';
+    decimalMarker = '.';
+    dropSpecialCharacters = null;
+    hiddenInput = null;
+    showMaskTyped = null;
+    placeHolderCharacter = null;
+    shownMaskExpression = null;
+    showTemplate = null;
+    clearIfNotMatch = null;
+    validation = null;
+    separatorLimit = null;
+    allowNegativeNumbers = null;
+    leadZeroDateTime = null;
+    leadZero = null;
+    triggerOnMaskChange = null;
+    apm = null;
+    inputTransformFn = null;
+    outputTransformFn = null;
+    keepCharacterPositions = null;
+    maskFilled = new EventEmitter();
+    _maskValue = '';
+    _inputValue;
+    _position = null;
+    _code;
+    _maskExpressionArray = [];
+    _allowFewMaskChangeMask = false;
+    _justPasted = false;
+    _isFocused = false;
+    _isComposing = false;
+    document = inject(DOCUMENT);
+    _maskService = inject(NgxMaskService, { self: true });
+    _config = inject(NGX_MASK_CONFIG);
+    onChange = (_) => { };
+    onTouch = () => { };
     ngOnChanges(changes) {
         const { maskExpression, specialCharacters, patterns, prefix, suffix, thousandSeparator, decimalMarker, dropSpecialCharacters, hiddenInput, showMaskTyped, placeHolderCharacter, shownMaskExpression, showTemplate, clearIfNotMatch, validation, separatorLimit, allowNegativeNumbers, leadZeroDateTime, leadZero, triggerOnMaskChange, apm, inputTransformFn, outputTransformFn, keepCharacterPositions, } = changes;
         if (maskExpression) {
@@ -1530,9 +1509,9 @@ class NgxMaskDirective {
                 this._maskService.maskChanged = true;
             }
             if (maskExpression.currentValue &&
-                maskExpression.currentValue.split("||" /* MaskExpression.OR */).length > 1) {
+                maskExpression.currentValue.split(MaskExpression.OR).length > 1) {
                 this._maskExpressionArray = maskExpression.currentValue
-                    .split("||" /* MaskExpression.OR */)
+                    .split(MaskExpression.OR)
                     .sort((a, b) => {
                     return a.length - b.length;
                 });
@@ -1540,7 +1519,7 @@ class NgxMaskDirective {
             }
             else {
                 this._maskExpressionArray = [];
-                this._maskValue = maskExpression.currentValue || "" /* MaskExpression.EMPTY_STRING */;
+                this._maskValue = maskExpression.currentValue || MaskExpression.EMPTY_STRING;
                 this._maskService.maskExpression = this._maskValue;
             }
         }
@@ -1555,10 +1534,9 @@ class NgxMaskDirective {
         if (allowNegativeNumbers) {
             this._maskService.allowNegativeNumbers = allowNegativeNumbers.currentValue;
             if (this._maskService.allowNegativeNumbers) {
-                this._maskService.specialCharacters = this._maskService.specialCharacters.filter((c) => c !== "-" /* MaskExpression.MINUS */);
+                this._maskService.specialCharacters = this._maskService.specialCharacters.filter((c) => c !== MaskExpression.MINUS);
             }
         }
-        // Only overwrite the mask available patterns if a pattern has actually been passed in
         if (patterns && patterns.currentValue) {
             this._maskService.patterns = patterns.currentValue;
         }
@@ -1642,7 +1620,7 @@ class NgxMaskDirective {
         if (this._maskService.cpfCnpjError) {
             return this._createValidationError(processedValue);
         }
-        if (this._maskValue.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+        if (this._maskValue.startsWith(MaskExpression.SEPARATOR)) {
             return null;
         }
         if (withoutValidation.includes(this._maskValue)) {
@@ -1654,7 +1632,7 @@ class NgxMaskDirective {
         if (timeMasks.includes(this._maskValue)) {
             return this._validateTime(processedValue);
         }
-        if (this._maskValue === "A*@A*.A*" /* MaskExpression.EMAIL_MASK */) {
+        if (this._maskValue === MaskExpression.EMAIL_MASK) {
             const emailPattern = /^[^@]+@[^@]+\.[^@]+$/;
             if (!emailPattern.test(processedValue) && processedValue) {
                 return this._createValidationError(processedValue);
@@ -1665,23 +1643,23 @@ class NgxMaskDirective {
         }
         if (processedValue && processedValue.length >= 1) {
             let counterOfOpt = 0;
-            if (this._maskValue.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */) &&
-                this._maskValue.includes("}" /* MaskExpression.CURLY_BRACKETS_RIGHT */)) {
-                const lengthInsideCurlyBrackets = this._maskValue.slice(this._maskValue.indexOf("{" /* MaskExpression.CURLY_BRACKETS_LEFT */) + 1, this._maskValue.indexOf("}" /* MaskExpression.CURLY_BRACKETS_RIGHT */));
+            if (this._maskValue.includes(MaskExpression.CURLY_BRACKETS_LEFT) &&
+                this._maskValue.includes(MaskExpression.CURLY_BRACKETS_RIGHT)) {
+                const lengthInsideCurlyBrackets = this._maskValue.slice(this._maskValue.indexOf(MaskExpression.CURLY_BRACKETS_LEFT) + 1, this._maskValue.indexOf(MaskExpression.CURLY_BRACKETS_RIGHT));
                 return lengthInsideCurlyBrackets === String(processedValue.length)
                     ? null
                     : this._createValidationError(processedValue);
             }
-            if (this._maskValue.startsWith("percent" /* MaskExpression.PERCENT */)) {
+            if (this._maskValue.startsWith(MaskExpression.PERCENT)) {
                 return null;
             }
             for (const key in this._maskService.patterns) {
                 if (this._maskService.patterns[key]?.optional) {
                     if (this._maskValue.indexOf(key) !== this._maskValue.lastIndexOf(key)) {
                         const opt = this._maskValue
-                            .split("" /* MaskExpression.EMPTY_STRING */)
+                            .split(MaskExpression.EMPTY_STRING)
                             .filter((i) => i === key)
-                            .join("" /* MaskExpression.EMPTY_STRING */);
+                            .join(MaskExpression.EMPTY_STRING);
                         counterOfOpt += opt.length;
                     }
                     else if (this._maskValue.indexOf(key) !== -1) {
@@ -1696,14 +1674,14 @@ class NgxMaskDirective {
                     }
                 }
             }
-            if ((this._maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */) > 1 &&
-                processedValue.length < this._maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */)) ||
-                (this._maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */) > 1 &&
-                    processedValue.length < this._maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */))) {
+            if ((this._maskValue.indexOf(MaskExpression.SYMBOL_STAR) > 1 &&
+                processedValue.length < this._maskValue.indexOf(MaskExpression.SYMBOL_STAR)) ||
+                (this._maskValue.indexOf(MaskExpression.SYMBOL_QUESTION) > 1 &&
+                    processedValue.length < this._maskValue.indexOf(MaskExpression.SYMBOL_QUESTION))) {
                 return this._createValidationError(processedValue);
             }
-            if (this._maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */) === -1 ||
-                this._maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */) === -1) {
+            if (this._maskValue.indexOf(MaskExpression.SYMBOL_STAR) === -1 ||
+                this._maskValue.indexOf(MaskExpression.SYMBOL_QUESTION) === -1) {
                 const array = this._maskValue.split('*');
                 const length = this._maskService.dropSpecialCharacters
                     ? this._maskValue.length -
@@ -1740,8 +1718,8 @@ class NgxMaskDirective {
                     }
                 }
             }
-            if (this._maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */) === 1 ||
-                this._maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */) === 1) {
+            if (this._maskValue.indexOf(MaskExpression.SYMBOL_STAR) === 1 ||
+                this._maskValue.indexOf(MaskExpression.SYMBOL_QUESTION) === 1) {
                 return null;
             }
         }
@@ -1758,16 +1736,14 @@ class NgxMaskDirective {
         this._isFocused = true;
     }
     onModelChange(value) {
-        // on form reset we need to update the actualValue
-        if ((value === "" /* MaskExpression.EMPTY_STRING */ ||
+        if ((value === MaskExpression.EMPTY_STRING ||
             value === null ||
             typeof value === 'undefined') &&
             this._maskService.actualValue) {
-            this._maskService.actualValue = this._maskService.getActualValue("" /* MaskExpression.EMPTY_STRING */);
+            this._maskService.actualValue = this._maskService.getActualValue(MaskExpression.EMPTY_STRING);
         }
     }
     onInput(e) {
-        // If IME is composing text, we wait for the composed text.
         if (this._isComposing) {
             return;
         }
@@ -1791,14 +1767,14 @@ class NgxMaskDirective {
                     const inputSymbol = el.value.slice(position - 1, position);
                     const prefixLength = this.prefix.length;
                     const checkSymbols = this._maskService._checkSymbolMask(inputSymbol, this._maskService.maskExpression[position - 1 - prefixLength] ??
-                        "" /* MaskExpression.EMPTY_STRING */);
+                        MaskExpression.EMPTY_STRING);
                     const checkSpecialCharacter = this._maskService._checkSymbolMask(inputSymbol, this._maskService.maskExpression[position + 1 - prefixLength] ??
-                        "" /* MaskExpression.EMPTY_STRING */);
+                        MaskExpression.EMPTY_STRING);
                     const selectRangeBackspace = this._maskService.selStart === this._maskService.selEnd;
                     const selStart = Number(this._maskService.selStart) - prefixLength;
                     const selEnd = Number(this._maskService.selEnd) - prefixLength;
-                    const backspaceOrDelete = this._code === "Backspace" /* MaskExpression.BACKSPACE */ ||
-                        this._code === "Delete" /* MaskExpression.DELETE */;
+                    const backspaceOrDelete = this._code === MaskExpression.BACKSPACE ||
+                        this._code === MaskExpression.DELETE;
                     if (backspaceOrDelete) {
                         if (!selectRangeBackspace) {
                             if (this._maskService.selStart === prefixLength) {
@@ -1831,7 +1807,7 @@ class NgxMaskDirective {
                                 this._maskService.actualValue = `${part1}${this._maskService.placeHolderCharacter}${part2}`;
                             }
                         }
-                        position = this._code === "Delete" /* MaskExpression.DELETE */ ? position + 1 : position;
+                        position = this._code === MaskExpression.DELETE ? position + 1 : position;
                     }
                     if (!backspaceOrDelete) {
                         if (!checkSymbols && !checkSpecialCharacter && selectRangeBackspace) {
@@ -1858,19 +1834,19 @@ class NgxMaskDirective {
                             el.value.length === 1 &&
                             position - prefixLength === 1 &&
                             this._maskService._checkSymbolMask(el.value, this._maskService.maskExpression[position - 1 - prefixLength] ??
-                                "" /* MaskExpression.EMPTY_STRING */)) {
+                                MaskExpression.EMPTY_STRING)) {
                             this._maskService.actualValue = `${this.prefix}${el.value}${this._maskService.maskIsShown.slice(1, this._maskService.maskIsShown.length)}${this.suffix}`;
                         }
                     }
                 }
                 let caretShift = 0;
                 let backspaceShift = false;
-                if (this._code === "Delete" /* MaskExpression.DELETE */ && "separator" /* MaskExpression.SEPARATOR */) {
+                if (this._code === MaskExpression.DELETE && MaskExpression.SEPARATOR) {
                     this._maskService.deletedSpecialCharacter = true;
                 }
                 if (this._inputValue.length >= this._maskService.maskExpression.length - 1 &&
-                    this._code !== "Backspace" /* MaskExpression.BACKSPACE */ &&
-                    this._maskService.maskExpression === "d0/M0/0000" /* MaskExpression.DAYS_MONTHS_YEARS */ &&
+                    this._code !== MaskExpression.BACKSPACE &&
+                    this._maskService.maskExpression === MaskExpression.DAYS_MONTHS_YEARS &&
                     position < 10) {
                     const inputSymbol = this._inputValue.slice(position - 1, position);
                     el.value =
@@ -1878,29 +1854,28 @@ class NgxMaskDirective {
                             inputSymbol +
                             this._inputValue.slice(position + 1);
                 }
-                if (this._maskService.maskExpression === "d0/M0/0000" /* MaskExpression.DAYS_MONTHS_YEARS */ &&
+                if (this._maskService.maskExpression === MaskExpression.DAYS_MONTHS_YEARS &&
                     this.leadZeroDateTime) {
                     if ((position < 3 && Number(el.value) > 31 && Number(el.value) < 40) ||
                         (position === 5 && Number(el.value.slice(3, 5)) > 12)) {
                         position = position + 2;
                     }
                 }
-                if (this._maskService.maskExpression === "Hh:m0:s0" /* MaskExpression.HOURS_MINUTES_SECONDS */ &&
+                if (this._maskService.maskExpression === MaskExpression.HOURS_MINUTES_SECONDS &&
                     this.apm) {
-                    if (this._justPasted && el.value.slice(0, 2) === "00" /* MaskExpression.DOUBLE_ZERO */) {
+                    if (this._justPasted && el.value.slice(0, 2) === MaskExpression.DOUBLE_ZERO) {
                         el.value = el.value.slice(1, 2) + el.value.slice(2, el.value.length);
                     }
                     el.value =
-                        el.value === "00" /* MaskExpression.DOUBLE_ZERO */
-                            ? "0" /* MaskExpression.NUMBER_ZERO */
+                        el.value === MaskExpression.DOUBLE_ZERO
+                            ? MaskExpression.NUMBER_ZERO
                             : el.value;
                 }
-                this._maskService.applyValueChanges(position, this._justPasted, this._code === "Backspace" /* MaskExpression.BACKSPACE */ || this._code === "Delete" /* MaskExpression.DELETE */, (shift, _backspaceShift) => {
+                this._maskService.applyValueChanges(position, this._justPasted, this._code === MaskExpression.BACKSPACE || this._code === MaskExpression.DELETE, (shift, _backspaceShift) => {
                     this._justPasted = false;
                     caretShift = shift;
                     backspaceShift = _backspaceShift;
                 });
-                // only set the selection if the element is active
                 if (this._getActiveElement() !== el) {
                     return;
                 }
@@ -1908,9 +1883,8 @@ class NgxMaskDirective {
                     position = position + 1;
                     this._maskService.plusOnePosition = false;
                 }
-                // update position after applyValueChanges to prevent cursor on wrong position when it has an array of maskExpression
                 if (this._maskExpressionArray.length) {
-                    if (this._code === "Backspace" /* MaskExpression.BACKSPACE */) {
+                    if (this._code === MaskExpression.BACKSPACE) {
                         const specialChartMinusOne = this.specialCharacters.includes(this._maskService.actualValue.slice(position - 1, position));
                         const specialChartPlusOne = this.specialCharacters.includes(this._maskService.actualValue.slice(position, position + 1));
                         if (this._allowFewMaskChangeMask && !specialChartPlusOne) {
@@ -1933,7 +1907,7 @@ class NgxMaskDirective {
                 let positionToApply = this._position
                     ? this._inputValue.length + position + caretShift
                     : position +
-                        (this._code === "Backspace" /* MaskExpression.BACKSPACE */ && !backspaceShift ? 0 : caretShift);
+                        (this._code === MaskExpression.BACKSPACE && !backspaceShift ? 0 : caretShift);
                 if (positionToApply > this._getActualInputLength()) {
                     positionToApply =
                         el.value === this._maskService.decimalMarker && el.value.length === 1
@@ -1947,7 +1921,6 @@ class NgxMaskDirective {
                 this._position = null;
             }
             else {
-                // eslint-disable-next-line no-console
                 console.warn('Ngx-mask writeValue work with string | number, your current value:', typeof transformedValue);
             }
         }
@@ -1956,14 +1929,12 @@ class NgxMaskDirective {
                 this.onChange(el.value);
                 return;
             }
-            this._maskService.applyValueChanges(el.value.length, this._justPasted, this._code === "Backspace" /* MaskExpression.BACKSPACE */ || this._code === "Delete" /* MaskExpression.DELETE */);
+            this._maskService.applyValueChanges(el.value.length, this._justPasted, this._code === MaskExpression.BACKSPACE || this._code === MaskExpression.DELETE);
         }
     }
-    // IME starts
     onCompositionStart() {
         this._isComposing = true;
     }
-    // IME completes
     onCompositionEnd(e) {
         this._isComposing = false;
         this._justPasted = true;
@@ -1984,11 +1955,11 @@ class NgxMaskDirective {
                     const decimalPart = el.value.split(this._maskService.decimalMarker)[1];
                     el.value = el.value.includes(this._maskService.decimalMarker)
                         ? el.value +
-                            "0" /* MaskExpression.NUMBER_ZERO */.repeat(precision - decimalPart.length) +
+                            MaskExpression.NUMBER_ZERO.repeat(precision - decimalPart.length) +
                             this._maskService.suffix
                         : el.value +
                             this._maskService.decimalMarker +
-                            "0" /* MaskExpression.NUMBER_ZERO */.repeat(precision) +
+                            MaskExpression.NUMBER_ZERO.repeat(precision) +
                             this._maskService.suffix;
                     this._maskService.actualValue = el.value;
                 }
@@ -2011,18 +1982,14 @@ class NgxMaskDirective {
             el.selectionStart > this._maskService.prefix.length &&
             e.keyCode !== 38) {
             if (this._maskService.showMaskTyped && !this.keepCharacterPositions) {
-                // We are showing the mask in the input
                 this._maskService.maskIsShown = this._maskService.showMaskInInput();
                 if (el.setSelectionRange &&
                     this._maskService.prefix + this._maskService.maskIsShown === el.value) {
-                    // the input ONLY contains the mask, so position the cursor at the start
                     el.focus();
                     el.setSelectionRange(posStart, posEnd);
                 }
                 else {
-                    // the input contains some characters already
                     if (el.selectionStart > this._maskService.actualValue.length) {
-                        // if the user clicked beyond our value's length, position the cursor at the end of our value
                         el.setSelectionRange(this._maskService.actualValue.length, this._maskService.actualValue.length);
                     }
                 }
@@ -2032,11 +1999,9 @@ class NgxMaskDirective {
             (el.value === this._maskService.prefix
                 ? this._maskService.prefix + this._maskService.maskIsShown
                 : el.value);
-        /** Fix of cursor position jumping to end in most browsers no matter where cursor is inserted onFocus */
         if (el && el.value !== nextValue) {
             el.value = nextValue;
         }
-        /** fix of cursor position with prefix when mouse click occur */
         if (el &&
             el.type !== 'number' &&
             (el.selectionStart || el.selectionEnd) <=
@@ -2045,7 +2010,6 @@ class NgxMaskDirective {
             el.selectionStart = this._maskService.prefix.length + specialCharactersAtTheStart;
             return;
         }
-        /** select only inserted text */
         if (el && el.selectionEnd > this._getActualInputLength()) {
             el.selectionEnd = this._getActualInputLength();
         }
@@ -2055,7 +2019,6 @@ class NgxMaskDirective {
             return;
         }
         if (this._isComposing) {
-            // User finalize their choice from IME composition, so trigger onInput() for the composed text.
             if (e.key === 'Enter') {
                 this.onCompositionEnd(e);
             }
@@ -2066,17 +2029,16 @@ class NgxMaskDirective {
         this._inputValue = el.value;
         this._setMask();
         if (el.type !== 'number') {
-            if (e.key === "ArrowUp" /* MaskExpression.ARROW_UP */) {
+            if (e.key === MaskExpression.ARROW_UP) {
                 e.preventDefault();
             }
-            if (e.key === "ArrowLeft" /* MaskExpression.ARROW_LEFT */ ||
-                e.key === "Backspace" /* MaskExpression.BACKSPACE */ ||
-                e.key === "Delete" /* MaskExpression.DELETE */) {
-                if (e.key === "Backspace" /* MaskExpression.BACKSPACE */ && el.value.length === 0) {
+            if (e.key === MaskExpression.ARROW_LEFT ||
+                e.key === MaskExpression.BACKSPACE ||
+                e.key === MaskExpression.DELETE) {
+                if (e.key === MaskExpression.BACKSPACE && el.value.length === 0) {
                     el.selectionStart = el.selectionEnd;
                 }
-                if (e.key === "Backspace" /* MaskExpression.BACKSPACE */ && el.selectionStart !== 0) {
-                    // If specialChars is false, (shouldn't ever happen) then set to the defaults
+                if (e.key === MaskExpression.BACKSPACE && el.selectionStart !== 0) {
                     this.specialCharacters = this.specialCharacters?.length
                         ? this.specialCharacters
                         : this._config.specialCharacters;
@@ -2088,7 +2050,7 @@ class NgxMaskDirective {
                         if (this._inputValue.length !== el.selectionStart &&
                             el.selectionStart !== 1) {
                             while (this.specialCharacters.includes((this._inputValue[el.selectionStart - 1] ??
-                                "" /* MaskExpression.EMPTY_STRING */).toString()) &&
+                                MaskExpression.EMPTY_STRING).toString()) &&
                                 ((this.prefix.length >= 1 &&
                                     el.selectionStart > this.prefix.length) ||
                                     this.prefix.length === 0)) {
@@ -2104,7 +2066,7 @@ class NgxMaskDirective {
                     e.preventDefault();
                 }
                 const cursorStart = el.selectionStart;
-                if (e.key === "Backspace" /* MaskExpression.BACKSPACE */ &&
+                if (e.key === MaskExpression.BACKSPACE &&
                     !el.readOnly &&
                     cursorStart === 0 &&
                     el.selectionEnd === el.value.length &&
@@ -2119,8 +2081,7 @@ class NgxMaskDirective {
                 el.setSelectionRange(this._inputValue.length - this.suffix.length, this._inputValue.length);
             }
             else if ((e.code === 'KeyA' && e.ctrlKey) ||
-                (e.code === 'KeyA' && e.metaKey) // Cmd + A (Mac)
-            ) {
+                (e.code === 'KeyA' && e.metaKey)) {
                 el.setSelectionRange(0, this._getActualInputLength());
                 e.preventDefault();
             }
@@ -2128,7 +2089,6 @@ class NgxMaskDirective {
             this._maskService.selEnd = el.selectionEnd;
         }
     }
-    /** It writes the value in the input */
     async writeValue(controlValue) {
         let value = controlValue;
         if (typeof value === 'object' && value !== null && 'value' in value) {
@@ -2150,7 +2110,7 @@ class NgxMaskDirective {
             }
             let inputValue = value;
             if (typeof inputValue === 'number' ||
-                this._maskValue.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+                this._maskValue.startsWith(MaskExpression.SEPARATOR)) {
                 inputValue = String(inputValue);
                 const localeDecimalMarker = this._maskService.currentLocaleDecimalMarker();
                 if (!Array.isArray(this._maskService.decimalMarker)) {
@@ -2165,14 +2125,14 @@ class NgxMaskDirective {
                     this.dropSpecialCharacters !== false) {
                     inputValue = this._maskService._checkPrecision(this._maskService.maskExpression, inputValue);
                 }
-                if (this._maskService.decimalMarker === "," /* MaskExpression.COMMA */ ||
+                if (this._maskService.decimalMarker === MaskExpression.COMMA ||
                     (Array.isArray(this._maskService.decimalMarker) &&
-                        this._maskService.thousandSeparator === "." /* MaskExpression.DOT */)) {
+                        this._maskService.thousandSeparator === MaskExpression.DOT)) {
                     inputValue = inputValue
                         .toString()
-                        .replace("." /* MaskExpression.DOT */, "," /* MaskExpression.COMMA */);
+                        .replace(MaskExpression.DOT, MaskExpression.COMMA);
                 }
-                if (this.maskExpression?.startsWith("separator" /* MaskExpression.SEPARATOR */) && this.leadZero) {
+                if (this.maskExpression?.startsWith(MaskExpression.SEPARATOR) && this.leadZero) {
                     requestAnimationFrame(() => {
                         this._maskService.applyMask(inputValue?.toString() ?? '', this._maskService.maskExpression);
                     });
@@ -2187,7 +2147,6 @@ class NgxMaskDirective {
             if ((inputValue && this._maskService.maskExpression) ||
                 (this._maskService.maskExpression &&
                     (this._maskService.prefix || this._maskService.showMaskTyped))) {
-                // Let the service we know we are writing value so that triggering onChange function won't happen during applyMask
                 if (typeof this.inputTransformFn !== 'function') {
                     this._maskService.writingValue = true;
                 }
@@ -2195,7 +2154,6 @@ class NgxMaskDirective {
                     'value',
                     this._maskService.applyMask(inputValue, this._maskService.maskExpression),
                 ];
-                // Let the service know we've finished writing value
                 if (typeof this.inputTransformFn !== 'function') {
                     this._maskService.writingValue = false;
                 }
@@ -2206,7 +2164,6 @@ class NgxMaskDirective {
             this._inputValue = inputValue;
         }
         else {
-            // eslint-disable-next-line no-console
             console.warn('Ngx-mask writeValue work with string | number, your current value:', typeof value);
         }
     }
@@ -2229,7 +2186,6 @@ class NgxMaskDirective {
         el.selectionStart = Math.min(Math.max(this.prefix.length, el.selectionStart), this._inputValue.length - this.suffix.length);
         el.selectionEnd = Math.min(Math.max(this.prefix.length, el.selectionEnd), this._inputValue.length - this.suffix.length);
     }
-    /** It disables the input element */
     setDisabledState(isDisabled) {
         this._maskService.formElementProperty = ['disabled', isDisabled];
     }
@@ -2242,10 +2198,10 @@ class NgxMaskDirective {
     }
     _validateTime(value) {
         const rowMaskLen = this._maskValue
-            .split("" /* MaskExpression.EMPTY_STRING */)
+            .split(MaskExpression.EMPTY_STRING)
             .filter((s) => s !== ':').length;
         if (!value) {
-            return null; // Don't validate empty values to allow for optional form control
+            return null;
         }
         if ((+(value[value.length - 1] ?? -1) === 0 && value.length < rowMaskLen) ||
             value.length <= rowMaskLen - 2) {
@@ -2268,33 +2224,33 @@ class NgxMaskDirective {
     _setMask() {
         this._maskExpressionArray.some((mask) => {
             const specialChart = mask
-                .split("" /* MaskExpression.EMPTY_STRING */)
+                .split(MaskExpression.EMPTY_STRING)
                 .some((char) => this._maskService.specialCharacters.includes(char));
             if ((specialChart &&
                 this._inputValue &&
                 this._areAllCharactersInEachStringSame(this._maskExpressionArray)) ||
-                mask.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)) {
+                mask.includes(MaskExpression.CURLY_BRACKETS_LEFT)) {
                 const test = this._maskService.removeMask(this._inputValue)?.length <=
                     this._maskService.removeMask(mask)?.length;
                 if (test) {
                     this._maskValue =
                         this.maskExpression =
                             this._maskService.maskExpression =
-                                mask.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)
+                                mask.includes(MaskExpression.CURLY_BRACKETS_LEFT)
                                     ? this._maskService._repeatPatternSymbols(mask)
                                     : mask;
                     return test;
                 }
                 else {
-                    if (this._code === "Backspace" /* MaskExpression.BACKSPACE */) {
+                    if (this._code === MaskExpression.BACKSPACE) {
                         this._allowFewMaskChangeMask = true;
                     }
                     const expression = this._maskExpressionArray[this._maskExpressionArray.length - 1] ??
-                        "" /* MaskExpression.EMPTY_STRING */;
+                        MaskExpression.EMPTY_STRING;
                     this._maskValue =
                         this.maskExpression =
                             this._maskService.maskExpression =
-                                expression.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)
+                                expression.includes(MaskExpression.CURLY_BRACKETS_LEFT)
                                     ? this._maskService._repeatPatternSymbols(expression)
                                     : expression;
                 }
@@ -2302,7 +2258,7 @@ class NgxMaskDirective {
             else {
                 const check = this._maskService
                     .removeMask(this._inputValue)
-                    ?.split("" /* MaskExpression.EMPTY_STRING */)
+                    ?.split(MaskExpression.EMPTY_STRING)
                     .every((character, index) => {
                     const indexMask = mask.charAt(index);
                     return this._maskService._checkSymbolMask(character, indexMask);
@@ -2326,8 +2282,8 @@ class NgxMaskDirective {
             return uniqueCharacters.size === 1;
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: NgxMaskDirective, isStandalone: true, selector: "input[mask], textarea[mask]", inputs: { maskExpression: ["mask", "maskExpression"], specialCharacters: "specialCharacters", patterns: "patterns", prefix: "prefix", suffix: "suffix", thousandSeparator: "thousandSeparator", decimalMarker: "decimalMarker", dropSpecialCharacters: "dropSpecialCharacters", hiddenInput: "hiddenInput", showMaskTyped: "showMaskTyped", placeHolderCharacter: "placeHolderCharacter", shownMaskExpression: "shownMaskExpression", showTemplate: "showTemplate", clearIfNotMatch: "clearIfNotMatch", validation: "validation", separatorLimit: "separatorLimit", allowNegativeNumbers: "allowNegativeNumbers", leadZeroDateTime: "leadZeroDateTime", leadZero: "leadZero", triggerOnMaskChange: "triggerOnMaskChange", apm: "apm", inputTransformFn: "inputTransformFn", outputTransformFn: "outputTransformFn", keepCharacterPositions: "keepCharacterPositions" }, outputs: { maskFilled: "maskFilled" }, host: { listeners: { "paste": "onPaste()", "focus": "onFocus($event)", "ngModelChange": "onModelChange($event)", "input": "onInput($event)", "compositionstart": "onCompositionStart($event)", "compositionend": "onCompositionEnd($event)", "blur": "onBlur($event)", "click": "onClick($event)", "keydown": "onKeyDown($event)" } }, providers: [
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.0", type: NgxMaskDirective, isStandalone: true, selector: "input[mask], textarea[mask]", inputs: { maskExpression: ["mask", "maskExpression"], specialCharacters: "specialCharacters", patterns: "patterns", prefix: "prefix", suffix: "suffix", thousandSeparator: "thousandSeparator", decimalMarker: "decimalMarker", dropSpecialCharacters: "dropSpecialCharacters", hiddenInput: "hiddenInput", showMaskTyped: "showMaskTyped", placeHolderCharacter: "placeHolderCharacter", shownMaskExpression: "shownMaskExpression", showTemplate: "showTemplate", clearIfNotMatch: "clearIfNotMatch", validation: "validation", separatorLimit: "separatorLimit", allowNegativeNumbers: "allowNegativeNumbers", leadZeroDateTime: "leadZeroDateTime", leadZero: "leadZero", triggerOnMaskChange: "triggerOnMaskChange", apm: "apm", inputTransformFn: "inputTransformFn", outputTransformFn: "outputTransformFn", keepCharacterPositions: "keepCharacterPositions" }, outputs: { maskFilled: "maskFilled" }, host: { listeners: { "paste": "onPaste()", "focus": "onFocus($event)", "ngModelChange": "onModelChange($event)", "input": "onInput($event)", "compositionstart": "onCompositionStart($event)", "compositionend": "onCompositionEnd($event)", "blur": "onBlur($event)", "click": "onClick($event)", "keydown": "onKeyDown($event)" } }, providers: [
             {
                 provide: NG_VALUE_ACCESSOR,
                 useExisting: NgxMaskDirective,
@@ -2339,9 +2295,9 @@ class NgxMaskDirective {
                 multi: true,
             },
             NgxMaskService,
-        ], exportAs: ["mask", "ngxMask"], usesOnChanges: true, ngImport: i0 }); }
+        ], exportAs: ["mask", "ngxMask"], usesOnChanges: true, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: 'input[mask], textarea[mask]',
@@ -2442,12 +2398,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
             }] } });
 
 class NgxMaskPipe {
-    constructor() {
-        this.defaultOptions = inject(NGX_MASK_CONFIG);
-        this._maskService = inject(NgxMaskService);
-        this._maskExpressionArray = [];
-        this.mask = '';
-    }
+    defaultOptions = inject(NGX_MASK_CONFIG);
+    _maskService = inject(NgxMaskService);
+    _maskExpressionArray = [];
+    mask = '';
     transform(value, mask, { patterns, ...config } = {}) {
         let processedValue = value;
         const currentConfig = {
@@ -2474,10 +2428,10 @@ class NgxMaskPipe {
                 return this._maskService.applyMask(`${processedValue}`, this.mask);
             }
         }
-        if (mask.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)) {
+        if (mask.includes(MaskExpression.CURLY_BRACKETS_LEFT)) {
             return this._maskService.applyMask(`${processedValue}`, this._maskService._repeatPatternSymbols(mask));
         }
-        if (mask.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+        if (mask.startsWith(MaskExpression.SEPARATOR)) {
             if (config.decimalMarker) {
                 this._maskService.decimalMarker = config.decimalMarker;
             }
@@ -2500,8 +2454,8 @@ class NgxMaskPipe {
                 this._maskService.dropSpecialCharacters !== false) {
                 processedValue = this._maskService._checkPrecision(mask, processedValue);
             }
-            if (this._maskService.decimalMarker === "," /* MaskExpression.COMMA */) {
-                processedValue = processedValue.replace("." /* MaskExpression.DOT */, "," /* MaskExpression.COMMA */);
+            if (this._maskService.decimalMarker === MaskExpression.COMMA) {
+                processedValue = processedValue.replace(MaskExpression.DOT, MaskExpression.COMMA);
             }
             this._maskService.isNumberValue = true;
         }
@@ -2521,16 +2475,16 @@ class NgxMaskPipe {
                 }
                 else {
                     const expression = this._maskExpressionArray[this._maskExpressionArray.length - 1] ??
-                        "" /* MaskExpression.EMPTY_STRING */;
+                        MaskExpression.EMPTY_STRING;
                     this.mask = expression;
                 }
             });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskPipe, isStandalone: true, name: "mask" }); }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskPipe, isStandalone: true, name: "mask" });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NgxMaskPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: NgxMaskPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'mask',
@@ -2539,9 +2493,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
                 }]
         }] });
 
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { INITIAL_CONFIG, NEW_CONFIG, NGX_MASK_CONFIG, NgxMaskDirective, NgxMaskPipe, NgxMaskService, initialConfig, provideEnvironmentNgxMask, provideNgxMask, timeMasks, withoutValidation };
 //# sourceMappingURL=ngx-mask.mjs.map