ngx-mask 14.2.3 → 14.3.0

package/fesm2015/ngx-mask.mjs

@@ -1,10 +1,10 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, EventEmitter, Injectable, Inject, forwardRef, Directive, Input, Output, HostListener, Pipe, NgModule } from '@angular/core';
-import { __awaiter } from 'tslib';
-import { NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';
+import { InjectionToken, EventEmitter, inject, Injectable, ElementRef, Renderer2, makeEnvironmentProviders, Directive, Input, Output, HostListener, Pipe } from '@angular/core';
 import { DOCUMENT } from '@angular/common';
+import { __awaiter, __rest } from 'tslib';
+import { NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';
 
-const config = new InjectionToken('ngx-mask config');
+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');
 const initialConfig = {
@@ -25,7 +25,12 @@ const initialConfig = {
     // eslint-disable-next-line @typescript-eslint/quotes
     specialCharacters: ['-', '/', '(', ')', '.', ':', ' ', '+', ',', '@', '[', ']', '"', "'"],
     leadZeroDateTime: false,
+    apm: false,
+    leadZero: false,
+    keepCharacterPositions: false,
     triggerOnMaskChange: false,
+    inputTransformFn: (value) => value,
+    outputTransformFn: (value) => value,
     maskFilled: new EventEmitter(),
     patterns: {
         '0': {
@@ -71,43 +76,70 @@ const initialConfig = {
         },
     },
 };
-const timeMasks = ['Hh:m0:s0', 'Hh:m0', 'm0:s0'];
+const timeMasks = [
+    "Hh:m0:s0" /* MaskExpression.HOURS_MINUTES_SECONDS */,
+    "Hh:m0" /* MaskExpression.HOURS_MINUTES */,
+    "m0:s0" /* MaskExpression.MINUTES_SECONDS */,
+];
 const withoutValidation = [
-    'percent',
-    'Hh',
-    's0',
-    'm0',
-    'separator',
-    'd0/M0/0000',
-    'd0/M0',
-    'd0',
-    'M0',
+    "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 */,
 ];
 
-class MaskApplierService {
-    constructor(_config) {
-        this._config = _config;
+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.maskExpression = '';
         this.actualValue = '';
+        this.showKeepCharacterExp = '';
         this.shownMaskExpression = '';
+        this.deletedSpecialCharacter = false;
         this._formatWithSeparators = (str, thousandSeparatorChar, decimalChars, precision) => {
-            var _a, _b;
+            var _a, _b, _c;
             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 = (_b = (_a = str.match(regExp)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : '';
+                decimalChar = (_b = (_a = str.match(regExp)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "" /* MaskExpression.EMPTY_STRING */;
             }
             else {
                 x = str.split(decimalChars);
                 decimalChar = decimalChars;
             }
-            const decimals = x.length > 1 ? `${decimalChar}${x[1]}` : '';
-            let res = x[0];
-            const separatorLimit = this.separatorLimit.replace(/\s/g, '');
+            const decimals = x.length > 1 ? `${decimalChar}${x[1]}` : "" /* MaskExpression.EMPTY_STRING */;
+            let res = (_c = x[0]) !== null && _c !== void 0 ? _c : "" /* MaskExpression.EMPTY_STRING */;
+            const separatorLimit = this.separatorLimit.replace(/\s/g, "" /* MaskExpression.EMPTY_STRING */);
             if (separatorLimit && +separatorLimit) {
-                if (res[0] === '-') {
+                if (res[0] === "-" /* MaskExpression.MINUS */) {
                     res = `-${res.slice(1, res.length).slice(0, separatorLimit.length)}`;
                 }
                 else {
@@ -124,30 +156,35 @@ class MaskApplierService {
             else if (precision === 0) {
                 return res;
             }
-            return res + decimals.substr(0, precision + 1);
+            return res + decimals.substring(0, precision + 1);
         };
         this.percentage = (str) => {
-            return Number(str) >= 0 && Number(str) <= 100;
+            const sanitizedStr = str.replace(',', '.');
+            const value = Number(sanitizedStr);
+            return !isNaN(value) && value >= 0 && value <= 100;
         };
         this.getPrecision = (maskExpression) => {
-            const x = maskExpression.split('.');
+            const x = maskExpression.split("." /* MaskExpression.DOT */);
             if (x.length > 1) {
                 return Number(x[x.length - 1]);
             }
             return Infinity;
         };
         this.checkAndRemoveSuffix = (inputValue) => {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             for (let i = ((_a = this.suffix) === null || _a === void 0 ? void 0 : _a.length) - 1; i >= 0; i--) {
-                const substr = this.suffix.substr(i, (_b = this.suffix) === null || _b === void 0 ? void 0 : _b.length);
+                const substr = this.suffix.substring(i, (_b = this.suffix) === null || _b === void 0 ? void 0 : _b.length);
                 if (inputValue.includes(substr) &&
-                    (i - 1 < 0 || !inputValue.includes(this.suffix.substr(i - 1, (_c = this.suffix) === null || _c === void 0 ? void 0 : _c.length)))) {
-                    return inputValue.replace(substr, '');
+                    i !== ((_c = this.suffix) === null || _c === void 0 ? void 0 : _c.length) - 1 &&
+                    (i - 1 < 0 ||
+                        !inputValue.includes(this.suffix.substring(i - 1, (_d = this.suffix) === null || _d === void 0 ? void 0 : _d.length)))) {
+                    return inputValue.replace(substr, "" /* MaskExpression.EMPTY_STRING */);
                 }
             }
             return inputValue;
         };
         this.checkInputPrecision = (inputValue, precision, decimalMarker) => {
+            var _a, _b;
             if (precision < Infinity) {
                 // TODO need think about decimalMarker
                 if (Array.isArray(decimalMarker)) {
@@ -157,8 +194,9 @@ class MaskApplierService {
                 }
                 const precisionRegEx = new RegExp(this._charToRegExpExpression(decimalMarker) + `\\d{${precision}}.*$`);
                 const precisionMatch = inputValue.match(precisionRegEx);
-                if (precisionMatch && precisionMatch[0].length - 1 > precision) {
-                    const diff = precisionMatch[0].length - 1 - precision;
+                const precisionMatchLength = (_b = (precisionMatch && ((_a = precisionMatch[0]) === null || _a === void 0 ? void 0 : _a.length))) !== null && _b !== void 0 ? _b : 0;
+                if (precisionMatchLength - 1 > precision) {
+                    const diff = precisionMatchLength - 1 - precision;
                     // eslint-disable-next-line no-param-reassign
                     inputValue = inputValue.substring(0, inputValue.length - diff);
                 }
@@ -170,32 +208,18 @@ class MaskApplierService {
             }
             return inputValue;
         };
-        this._shift = new Set();
-        this.clearIfNotMatch = this._config.clearIfNotMatch;
-        this.dropSpecialCharacters = this._config.dropSpecialCharacters;
-        this.maskSpecialCharacters = this._config.specialCharacters;
-        this.maskAvailablePatterns = this._config.patterns;
-        this.prefix = this._config.prefix;
-        this.suffix = this._config.suffix;
-        this.thousandSeparator = this._config.thousandSeparator;
-        this.decimalMarker = this._config.decimalMarker;
-        this.hiddenInput = this._config.hiddenInput;
-        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;
     }
     applyMaskWithPattern(inputValue, maskAndPattern) {
         const [mask, customPattern] = maskAndPattern;
         this.customPattern = customPattern;
         return this.applyMask(inputValue, mask);
     }
-    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, cb = () => { }) {
-        var _a, _b;
+    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-explicit-any
+    cb = () => { }) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
         if (!maskExpression || typeof inputValue !== 'string') {
-            return '';
+            return "" /* MaskExpression.EMPTY_STRING */;
         }
         let cursor = 0;
         let result = '';
@@ -203,7 +227,7 @@ class MaskApplierService {
         let backspaceShift = false;
         let shift = 1;
         let stepBack = false;
-        if (inputValue.slice(0, this.prefix.length) === this.prefix) {
+        if (inputValue.slice(0, this.prefix.length) === this.prefix && !this.showMaskTyped) {
             // eslint-disable-next-line no-param-reassign
             inputValue = inputValue.slice(this.prefix.length, inputValue.length);
         }
@@ -211,9 +235,18 @@ class MaskApplierService {
             // eslint-disable-next-line no-param-reassign
             inputValue = this.checkAndRemoveSuffix(inputValue);
         }
-        const inputArray = inputValue.toString().split('');
-        if (maskExpression === 'IP') {
-            const valuesIP = inputValue.split('.');
+        if (inputValue === '(' && this.prefix) {
+            // eslint-disable-next-line no-param-reassign
+            inputValue = '';
+        }
+        const inputArray = inputValue.toString().split("" /* MaskExpression.EMPTY_STRING */);
+        if (this.allowNegativeNumbers &&
+            inputValue.slice(cursor, cursor + 1) === "-" /* MaskExpression.MINUS */) {
+            // eslint-disable-next-line no-param-reassign
+            result += inputValue.slice(cursor, cursor + 1);
+        }
+        if (maskExpression === "IP" /* MaskExpression.IP */) {
+            const valuesIP = inputValue.split("." /* MaskExpression.DOT */);
             this.ipError = this._validIP(valuesIP);
             // eslint-disable-next-line no-param-reassign
             maskExpression = '099.099.099.099';
@@ -221,10 +254,10 @@ class MaskApplierService {
         const arr = [];
         for (let i = 0; i < inputValue.length; i++) {
             if ((_a = inputValue[i]) === null || _a === void 0 ? void 0 : _a.match('\\d')) {
-                arr.push(inputValue[i]);
+                arr.push((_b = inputValue[i]) !== null && _b !== void 0 ? _b : "" /* MaskExpression.EMPTY_STRING */);
             }
         }
-        if (maskExpression === 'CPF_CNPJ') {
+        if (maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */) {
             this.cpfCnpjError = arr.length !== 11 && arr.length !== 14;
             if (arr.length > 11) {
                 // eslint-disable-next-line no-param-reassign
@@ -235,33 +268,45 @@ class MaskApplierService {
                 maskExpression = '000.000.000-00';
             }
         }
-        if (maskExpression.startsWith('percent')) {
+        if (maskExpression.startsWith("percent" /* MaskExpression.PERCENT */)) {
             if (inputValue.match('[a-z]|[A-Z]') ||
-                inputValue.match(/[-!$%^&*()_+|~=`{}\[\]:";'<>?,\/.]/)) {
+                // eslint-disable-next-line no-useless-escape
+                (inputValue.match(/[-!$%^&*()_+|~=`{}\[\]:";'<>?,\/.]/) && !backspaced)) {
                 // eslint-disable-next-line no-param-reassign
                 inputValue = this._stripToDecimal(inputValue);
                 const precision = this.getPrecision(maskExpression);
                 // eslint-disable-next-line no-param-reassign
                 inputValue = this.checkInputPrecision(inputValue, precision, this.decimalMarker);
             }
-            if (inputValue.indexOf('.') > 0 &&
-                !this.percentage(inputValue.substring(0, inputValue.indexOf('.')))) {
-                const base = inputValue.substring(0, inputValue.indexOf('.') - 1);
+            const decimalMarker = typeof this.decimalMarker === 'string' ? this.decimalMarker : "." /* MaskExpression.DOT */;
+            if (inputValue.indexOf(decimalMarker) > 0 &&
+                !this.percentage(inputValue.substring(0, inputValue.indexOf(decimalMarker)))) {
+                let base = inputValue.substring(0, inputValue.indexOf(decimalMarker) - 1);
+                if (this.allowNegativeNumbers &&
+                    inputValue.slice(cursor, cursor + 1) === "-" /* MaskExpression.MINUS */ &&
+                    !backspaced) {
+                    base = inputValue.substring(0, inputValue.indexOf(decimalMarker));
+                }
                 // eslint-disable-next-line no-param-reassign
-                inputValue = `${base}${inputValue.substring(inputValue.indexOf('.'), inputValue.length)}`;
+                inputValue = `${base}${inputValue.substring(inputValue.indexOf(decimalMarker), inputValue.length)}`;
             }
-            if (this.percentage(inputValue)) {
-                result = inputValue;
+            let value = '';
+            this.allowNegativeNumbers &&
+                inputValue.slice(cursor, cursor + 1) === "-" /* MaskExpression.MINUS */
+                ? (value = inputValue.slice(cursor + 1, cursor + inputValue.length))
+                : (value = inputValue);
+            if (this.percentage(value)) {
+                result = this._splitPercentZero(inputValue);
             }
             else {
-                result = inputValue.substring(0, inputValue.length - 1);
+                result = this._splitPercentZero(inputValue.substring(0, inputValue.length - 1));
             }
         }
-        else if (maskExpression.startsWith('separator')) {
+        else if (maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
             if (inputValue.match('[wа-яА-Я]') ||
                 inputValue.match('[ЁёА-я]') ||
                 inputValue.match('[a-z]|[A-Z]') ||
-                inputValue.match(/[-@#!$%\\^&*()_£¬'+|~=`{}\[\]:";<>.?\/]/) ||
+                inputValue.match(/[-@#!$%\\^&*()_£¬'+|~=`{}\]:";<>.?/]/) ||
                 inputValue.match('[^A-Za-z0-9,]')) {
                 // eslint-disable-next-line no-param-reassign
                 inputValue = this._stripToDecimal(inputValue);
@@ -288,7 +333,7 @@ class MaskApplierService {
             //.replace(decimalMarkerEscaped, '');
             if (Array.isArray(this.decimalMarker)) {
                 for (const marker of this.decimalMarker) {
-                    invalidChars = invalidChars.replace(this._charToRegExpExpression(marker), '');
+                    invalidChars = invalidChars.replace(this._charToRegExpExpression(marker), "" /* MaskExpression.EMPTY_STRING */);
                 }
             }
             else {
@@ -306,9 +351,9 @@ class MaskApplierService {
             inputValue = this.checkInputPrecision(inputValue, precision, this.decimalMarker);
             const strForSep = inputValue.replace(new RegExp(thousandSeparatorCharEscaped, 'g'), '');
             result = this._formatWithSeparators(strForSep, this.thousandSeparator, this.decimalMarker, precision);
-            const commaShift = result.indexOf(',') - inputValue.indexOf(',');
+            const commaShift = result.indexOf("," /* MaskExpression.COMMA */) - inputValue.indexOf("," /* MaskExpression.COMMA */);
             const shiftStep = result.length - inputValue.length;
-            if (shiftStep > 0 && result[position] !== ',') {
+            if (shiftStep > 0 && result[position] !== this.thousandSeparator) {
                 backspaceShift = true;
                 let _shift = 0;
                 do {
@@ -316,8 +361,18 @@ class MaskApplierService {
                     _shift++;
                 } while (_shift < shiftStep);
             }
-            else if ((commaShift !== 0 && position > 0 && !(result.indexOf(',') >= position && position > 3)) ||
-                (!(result.indexOf('.') >= position && position > 3) && shiftStep <= 0)) {
+            else if (result[position - 1] === this.decimalMarker ||
+                shiftStep === -4 ||
+                shiftStep === -3 ||
+                result[position] === "," /* MaskExpression.COMMA */) {
+                this._shift.clear();
+                this._shift.add(position - 1);
+            }
+            else if ((commaShift !== 0 &&
+                position > 0 &&
+                !(result.indexOf("," /* MaskExpression.COMMA */) >= position && position > 3)) ||
+                (!(result.indexOf("." /* MaskExpression.DOT */) >= position && position > 3) &&
+                    shiftStep <= 0)) {
                 this._shift.clear();
                 backspaceShift = true;
                 shift = shiftStep;
@@ -332,35 +387,39 @@ class MaskApplierService {
         else {
             for (
             // eslint-disable-next-line
-            let i = 0, inputSymbol = inputArray[0]; i < inputArray.length; i++, inputSymbol = inputArray[i]) {
+            let i = 0, inputSymbol = inputArray[0]; i < inputArray.length; i++, inputSymbol = (_c = inputArray[i]) !== null && _c !== void 0 ? _c : "" /* MaskExpression.EMPTY_STRING */) {
                 if (cursor === maskExpression.length) {
                     break;
                 }
-                if (this._checkSymbolMask(inputSymbol, maskExpression[cursor]) &&
-                    maskExpression[cursor + 1] === '?') {
+                const symbolStarInPattern = "*" /* MaskExpression.SYMBOL_STAR */ in this.patterns;
+                if (this._checkSymbolMask(inputSymbol, (_d = maskExpression[cursor]) !== null && _d !== void 0 ? _d : "" /* MaskExpression.EMPTY_STRING */) &&
+                    maskExpression[cursor + 1] === "?" /* MaskExpression.SYMBOL_QUESTION */) {
                     result += inputSymbol;
                     cursor += 2;
                 }
-                else if (maskExpression[cursor + 1] === '*' &&
+                else if (maskExpression[cursor + 1] === "*" /* MaskExpression.SYMBOL_STAR */ &&
                     multi &&
-                    this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2])) {
+                    this._checkSymbolMask(inputSymbol, (_e = maskExpression[cursor + 2]) !== null && _e !== void 0 ? _e : "" /* MaskExpression.EMPTY_STRING */)) {
                     result += inputSymbol;
                     cursor += 3;
                     multi = false;
                 }
-                else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor]) &&
-                    maskExpression[cursor + 1] === '*') {
+                else if (this._checkSymbolMask(inputSymbol, (_f = maskExpression[cursor]) !== null && _f !== void 0 ? _f : "" /* MaskExpression.EMPTY_STRING */) &&
+                    maskExpression[cursor + 1] === "*" /* MaskExpression.SYMBOL_STAR */ &&
+                    !symbolStarInPattern) {
                     result += inputSymbol;
                     multi = true;
                 }
-                else if (maskExpression[cursor + 1] === '?' &&
-                    this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2])) {
+                else if (maskExpression[cursor + 1] === "?" /* MaskExpression.SYMBOL_QUESTION */ &&
+                    this._checkSymbolMask(inputSymbol, (_g = maskExpression[cursor + 2]) !== null && _g !== void 0 ? _g : "" /* MaskExpression.EMPTY_STRING */)) {
                     result += inputSymbol;
                     cursor += 3;
                 }
-                else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor])) {
-                    if (maskExpression[cursor] === 'H') {
-                        if (Number(inputSymbol) > 2) {
+                else if (this._checkSymbolMask(inputSymbol, (_h = maskExpression[cursor]) !== null && _h !== void 0 ? _h : "" /* MaskExpression.EMPTY_STRING */)) {
+                    if (maskExpression[cursor] === "H" /* MaskExpression.HOURS */) {
+                        if (this.apm ? Number(inputSymbol) > 9 : Number(inputSymbol) > 2) {
+                            // eslint-disable-next-line no-param-reassign
+                            position = position + 1;
                             cursor += 1;
                             this._shiftStep(maskExpression, cursor, inputArray.length);
                             i--;
@@ -370,26 +429,33 @@ class MaskApplierService {
                             continue;
                         }
                     }
-                    if (maskExpression[cursor] === 'h') {
-                        if (result === '2' && Number(inputSymbol) > 3) {
-                            cursor += 1;
-                            i--;
-                            continue;
-                        }
-                    }
-                    if (maskExpression[cursor] === 'm') {
-                        if (Number(inputSymbol) > 5) {
+                    if (maskExpression[cursor] === "h" /* MaskExpression.HOUR */) {
+                        if (this.apm
+                            ? (result.length === 1 && Number(result) > 1) ||
+                                (result === '1' && Number(inputSymbol) > 2) ||
+                                (inputValue.slice(cursor - 1, cursor).length === 1 &&
+                                    Number(inputValue.slice(cursor - 1, cursor)) > 2) ||
+                                (inputValue.slice(cursor - 1, cursor) === '1' &&
+                                    Number(inputSymbol) > 2)
+                            : (result === '2' && Number(inputSymbol) > 3) ||
+                                ((result.slice(cursor - 2, cursor) === '2' ||
+                                    result.slice(cursor - 3, cursor) === '2' ||
+                                    result.slice(cursor - 4, cursor) === '2' ||
+                                    result.slice(cursor - 1, cursor) === '2') &&
+                                    Number(inputSymbol) > 3 &&
+                                    cursor > 10)) {
+                            // eslint-disable-next-line no-param-reassign
+                            position = position + 1;
                             cursor += 1;
-                            this._shiftStep(maskExpression, cursor, inputArray.length);
                             i--;
-                            if (this.leadZeroDateTime) {
-                                result += '0';
-                            }
                             continue;
                         }
                     }
-                    if (maskExpression[cursor] === 's') {
+                    if (maskExpression[cursor] === "m" /* MaskExpression.MINUTE */ ||
+                        maskExpression[cursor] === "s" /* MaskExpression.SECOND */) {
                         if (Number(inputSymbol) > 5) {
+                            // eslint-disable-next-line no-param-reassign
+                            position = position + 1;
                             cursor += 1;
                             this._shiftStep(maskExpression, cursor, inputArray.length);
                             i--;
@@ -400,10 +466,34 @@ class MaskApplierService {
                         }
                     }
                     const daysCount = 31;
-                    if (maskExpression[cursor] === 'd') {
+                    const inputValueCursor = inputValue[cursor];
+                    const inputValueCursorPlusOne = inputValue[cursor + 1];
+                    const inputValueCursorPlusTwo = inputValue[cursor + 2];
+                    const inputValueCursorMinusOne = inputValue[cursor - 1];
+                    const inputValueCursorMinusTwo = inputValue[cursor - 2];
+                    const inputValueCursorMinusThree = inputValue[cursor - 3];
+                    const inputValueSliceMinusThreeMinusOne = inputValue.slice(cursor - 3, cursor - 1);
+                    const inputValueSliceMinusOnePlusOne = inputValue.slice(cursor - 1, cursor + 1);
+                    const inputValueSliceCursorPlusTwo = inputValue.slice(cursor, cursor + 2);
+                    const inputValueSliceMinusTwoCursor = inputValue.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 */ &&
+                            this.specialCharacters.includes(inputValueCursorMinusTwo);
                         if ((Number(inputSymbol) > 3 && this.leadZeroDateTime) ||
-                            Number(inputValue.slice(cursor, cursor + 2)) > daysCount ||
-                            inputValue[cursor + 1] === '/') {
+                            (!maskStartWithMonth &&
+                                (Number(inputValueSliceCursorPlusTwo) > daysCount ||
+                                    Number(inputValueSliceMinusOnePlusOne) > daysCount ||
+                                    this.specialCharacters.includes(inputValueCursorPlusOne))) ||
+                            (startWithMonthInput
+                                ? Number(inputValueSliceMinusOnePlusOne) > daysCount ||
+                                    (!this.specialCharacters.includes(inputValueCursor) &&
+                                        this.specialCharacters.includes(inputValueCursorPlusTwo)) ||
+                                    this.specialCharacters.includes(inputValueCursor)
+                                : Number(inputValueSliceCursorPlusTwo) > daysCount ||
+                                    this.specialCharacters.includes(inputValueCursorPlusOne))) {
+                            // eslint-disable-next-line no-param-reassign
+                            position = position + 1;
                             cursor += 1;
                             this._shiftStep(maskExpression, cursor, inputArray.length);
                             i--;
@@ -413,45 +503,53 @@ class MaskApplierService {
                             continue;
                         }
                     }
-                    if (maskExpression[cursor] === 'M') {
+                    if (maskExpression[cursor] === "M" /* MaskExpression.MONTH */) {
                         const monthsCount = 12;
                         // mask without day
                         const withoutDays = cursor === 0 &&
                             (Number(inputSymbol) > 2 ||
-                                Number(inputValue.slice(cursor, cursor + 2)) > monthsCount ||
-                                inputValue[cursor + 1] === '/');
+                                Number(inputValueSliceCursorPlusTwo) > monthsCount ||
+                                this.specialCharacters.includes(inputValueCursorPlusOne));
                         // day<10 && month<12 for input
-                        const day1monthInput = inputValue.slice(cursor - 3, cursor - 1).includes('/') &&
-                            ((inputValue[cursor - 2] === '/' &&
-                                Number(inputValue.slice(cursor - 1, cursor + 1)) > monthsCount &&
-                                inputValue[cursor] !== '/') ||
-                                inputValue[cursor] === '/' ||
-                                (inputValue[cursor - 3] === '/' &&
-                                    Number(inputValue.slice(cursor - 2, cursor)) > monthsCount &&
-                                    inputValue[cursor - 1] !== '/') ||
-                                inputValue[cursor - 1] === '/');
-                        // 10<day<31 && month<12 for input
-                        const day2monthInput = Number(inputValue.slice(cursor - 3, cursor - 1)) <= daysCount &&
-                            !inputValue.slice(cursor - 3, cursor - 1).includes('/') &&
-                            inputValue[cursor - 1] === '/' &&
-                            (Number(inputValue.slice(cursor, cursor + 2)) > monthsCount ||
-                                inputValue[cursor + 1] === '/');
-                        // day<10 && month<12 for paste whole data
-                        const day1monthPaste = Number(inputValue.slice(cursor - 3, cursor - 1)) > daysCount &&
-                            !inputValue.slice(cursor - 3, cursor - 1).includes('/') &&
-                            !inputValue.slice(cursor - 2, cursor).includes('/') &&
-                            Number(inputValue.slice(cursor - 2, cursor)) > monthsCount;
+                        const specialChart = maskExpression.slice(cursor + 2, cursor + 3);
+                        const day1monthInput = inputValueSliceMinusThreeMinusOne.includes(specialChart) &&
+                            ((this.specialCharacters.includes(inputValueCursorMinusTwo) &&
+                                Number(inputValueSliceMinusOnePlusOne) > monthsCount &&
+                                !this.specialCharacters.includes(inputValueCursor)) ||
+                                this.specialCharacters.includes(inputValueCursor) ||
+                                (this.specialCharacters.includes(inputValueCursorMinusThree) &&
+                                    Number(inputValueSliceMinusTwoCursor) > monthsCount &&
+                                    !this.specialCharacters.includes(inputValueCursorMinusOne)) ||
+                                this.specialCharacters.includes(inputValueCursorMinusOne));
+                        //  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;
                         // 10<day<31 && month<12 for paste whole data
-                        const day2monthPaste = Number(inputValue.slice(cursor - 3, cursor - 1)) <= daysCount &&
-                            !inputValue.slice(cursor - 3, cursor - 1).includes('/') &&
-                            inputValue[cursor - 1] !== '/' &&
-                            Number(inputValue.slice(cursor - 1, cursor + 1)) > monthsCount;
+                        const day2monthPaste = Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&
+                            !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
+                            !this.specialCharacters.includes(inputValueCursorMinusOne) &&
+                            Number(inputValueSliceMinusOnePlusOne) > monthsCount;
                         if ((Number(inputSymbol) > 1 && this.leadZeroDateTime) ||
                             withoutDays ||
                             day1monthInput ||
-                            day2monthInput ||
+                            day2monthPaste ||
                             day1monthPaste ||
-                            day2monthPaste) {
+                            day2monthInput ||
+                            (day2monthInputDot && !this.leadZeroDateTime)) {
+                            // eslint-disable-next-line no-param-reassign
+                            position = position + 1;
                             cursor += 1;
                             this._shiftStep(maskExpression, cursor, inputArray.length);
                             i--;
@@ -464,52 +562,64 @@ class MaskApplierService {
                     result += inputSymbol;
                     cursor++;
                 }
-                else if (inputSymbol === ' ' && maskExpression[cursor] === ' ') {
+                else if ((inputSymbol === " " /* MaskExpression.WHITE_SPACE */ &&
+                    maskExpression[cursor] === " " /* MaskExpression.WHITE_SPACE */) ||
+                    (inputSymbol === "/" /* MaskExpression.SLASH */ &&
+                        maskExpression[cursor] === "/" /* MaskExpression.SLASH */)) {
                     result += inputSymbol;
                     cursor++;
                 }
-                else if (this.maskSpecialCharacters.indexOf(maskExpression[cursor]) !== -1) {
+                else if (this.specialCharacters.indexOf((_j = maskExpression[cursor]) !== null && _j !== void 0 ? _j : "" /* MaskExpression.EMPTY_STRING */) !== -1) {
                     result += maskExpression[cursor];
                     cursor++;
                     this._shiftStep(maskExpression, cursor, inputArray.length);
                     i--;
                 }
-                else if (this.maskSpecialCharacters.indexOf(inputSymbol) > -1 &&
-                    this.maskAvailablePatterns[maskExpression[cursor]] &&
-                    ((_b = this.maskAvailablePatterns[maskExpression[cursor]]) === null || _b === void 0 ? void 0 : _b.optional)) {
+                else if (maskExpression[cursor] === "9" /* MaskExpression.NUMBER_NINE */ &&
+                    this.showMaskTyped) {
+                    this._shiftStep(maskExpression, cursor, inputArray.length);
+                }
+                else if (this.patterns[(_k = maskExpression[cursor]) !== null && _k !== void 0 ? _k : "" /* MaskExpression.EMPTY_STRING */] &&
+                    ((_m = this.patterns[(_l = maskExpression[cursor]) !== null && _l !== void 0 ? _l : "" /* MaskExpression.EMPTY_STRING */]) === null || _m === void 0 ? void 0 : _m.optional)) {
                     if (!!inputArray[cursor] &&
                         maskExpression !== '099.099.099.099' &&
                         maskExpression !== '000.000.000-00' &&
                         maskExpression !== '00.000.000/0000-00' &&
-                        !maskExpression.match(/^9+\.0+$/)) {
+                        !maskExpression.match(/^9+\.0+$/) &&
+                        !((_p = this.patterns[(_o = maskExpression[cursor]) !== null && _o !== void 0 ? _o : "" /* MaskExpression.EMPTY_STRING */]) === null || _p === void 0 ? void 0 : _p.optional)) {
                         result += inputArray[cursor];
                     }
+                    if (maskExpression.includes("9" /* MaskExpression.NUMBER_NINE */ + "*" /* MaskExpression.SYMBOL_STAR */) &&
+                        maskExpression.includes("0" /* MaskExpression.NUMBER_ZERO */ + "*" /* MaskExpression.SYMBOL_STAR */)) {
+                        cursor++;
+                    }
                     cursor++;
                     i--;
                 }
-                else if (this.maskExpression[cursor + 1] === '*' &&
-                    this._findSpecialChar(this.maskExpression[cursor + 2]) &&
+                else if (this.maskExpression[cursor + 1] === "*" /* MaskExpression.SYMBOL_STAR */ &&
+                    this._findSpecialChar((_q = this.maskExpression[cursor + 2]) !== null && _q !== void 0 ? _q : "" /* MaskExpression.EMPTY_STRING */) &&
                     this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&
                     multi) {
                     cursor += 3;
                     result += inputSymbol;
                 }
-                else if (this.maskExpression[cursor + 1] === '?' &&
-                    this._findSpecialChar(this.maskExpression[cursor + 2]) &&
+                else if (this.maskExpression[cursor + 1] === "?" /* MaskExpression.SYMBOL_QUESTION */ &&
+                    this._findSpecialChar((_r = this.maskExpression[cursor + 2]) !== null && _r !== void 0 ? _r : "" /* MaskExpression.EMPTY_STRING */) &&
                     this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&
                     multi) {
                     cursor += 3;
                     result += inputSymbol;
                 }
                 else if (this.showMaskTyped &&
-                    this.maskSpecialCharacters.indexOf(inputSymbol) < 0 &&
-                    inputSymbol !== this.placeHolderCharacter) {
+                    this.specialCharacters.indexOf(inputSymbol) < 0 &&
+                    inputSymbol !== this.placeHolderCharacter &&
+                    this.placeHolderCharacter.length === 1) {
                     stepBack = true;
                 }
             }
         }
         if (result.length + 1 === maskExpression.length &&
-            this.maskSpecialCharacters.indexOf(maskExpression[maskExpression.length - 1]) !== -1) {
+            this.specialCharacters.indexOf((_s = maskExpression[maskExpression.length - 1]) !== null && _s !== void 0 ? _s : "" /* MaskExpression.EMPTY_STRING */) !== -1) {
             result += maskExpression[maskExpression.length - 1];
         }
         let newPosition = position + 1;
@@ -517,7 +627,7 @@ class MaskApplierService {
             shift++;
             newPosition++;
         }
-        let actualShift = justPasted && !maskExpression.startsWith('separator')
+        let actualShift = justPasted && !maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)
             ? cursor
             : this._shift.has(position)
                 ? shift
@@ -531,28 +641,34 @@ class MaskApplierService {
         }
         let onlySpecial = false;
         if (backspaced) {
-            onlySpecial = inputArray.every((char) => this.maskSpecialCharacters.includes(char));
+            onlySpecial = inputArray.every((char) => this.specialCharacters.includes(char));
         }
-        let res = `${this.prefix}${onlySpecial ? '' : result}${this.suffix}`;
+        let res = `${this.prefix}${onlySpecial ? "" /* MaskExpression.EMPTY_STRING */ : result}${this.suffix}`;
         if (result.length === 0) {
-            res = `${this.prefix}${result}`;
+            res = !this.dropSpecialCharacters ? `${this.prefix}${result}` : `${result}`;
+        }
+        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}`;
         }
         return res;
     }
     _findSpecialChar(inputSymbol) {
-        return this.maskSpecialCharacters.find((val) => val === inputSymbol);
+        return this.specialCharacters.find((val) => val === inputSymbol);
     }
     _checkSymbolMask(inputSymbol, maskSymbol) {
-        this.maskAvailablePatterns = this.customPattern
-            ? this.customPattern
-            : this.maskAvailablePatterns;
-        return (this.maskAvailablePatterns[maskSymbol] &&
-            this.maskAvailablePatterns[maskSymbol].pattern &&
-            this.maskAvailablePatterns[maskSymbol].pattern.test(inputSymbol));
+        var _a, _b, _c;
+        this.patterns = this.customPattern ? this.customPattern : this.patterns;
+        return ((_c = (((_a = this.patterns[maskSymbol]) === null || _a === void 0 ? void 0 : _a.pattern) &&
+            ((_b = this.patterns[maskSymbol]) === null || _b === void 0 ? void 0 : _b.pattern.test(inputSymbol)))) !== null && _c !== void 0 ? _c : false);
     }
     _stripToDecimal(str) {
         return str
-            .split('')
+            .split("" /* MaskExpression.EMPTY_STRING */)
             .filter((i, idx) => {
             const isDecimalMarker = typeof this.decimalMarker === 'string'
                 ? i === this.decimalMarker
@@ -561,9 +677,9 @@ class MaskApplierService {
             return (i.match('^-?\\d') ||
                 i === this.thousandSeparator ||
                 isDecimalMarker ||
-                (i === '-' && idx === 0 && this.allowNegativeNumbers));
+                (i === "-" /* MaskExpression.MINUS */ && idx === 0 && this.allowNegativeNumbers));
         })
-            .join('');
+            .join("" /* MaskExpression.EMPTY_STRING */);
     }
     _charToRegExpExpression(char) {
         // if (Array.isArray(char)) {
@@ -576,7 +692,9 @@ class MaskApplierService {
         return char;
     }
     _shiftStep(maskExpression, cursor, inputLength) {
-        const shiftStep = /[*?]/g.test(maskExpression.slice(0, cursor)) ? inputLength : cursor;
+        const shiftStep = /[*?]/g.test(maskExpression.slice(0, cursor))
+            ? inputLength
+            : cursor;
         this._shift.add(shiftStep + this.prefix.length || 0);
     }
     _compareOrIncludes(value, comparedValue, excludedValue) {
@@ -588,33 +706,40 @@ class MaskApplierService {
         return !(valuesIP.length === 4 &&
             !valuesIP.some((value, index) => {
                 if (valuesIP.length !== index + 1) {
-                    return value === '' || Number(value) > 255;
+                    return value === "" /* MaskExpression.EMPTY_STRING */ || Number(value) > 255;
                 }
-                return value === '' || Number(value.substring(0, 3)) > 255;
+                return value === "" /* MaskExpression.EMPTY_STRING */ || Number(value.substring(0, 3)) > 255;
             }));
     }
+    _splitPercentZero(value) {
+        const decimalIndex = typeof this.decimalMarker === 'string'
+            ? value.indexOf(this.decimalMarker)
+            : value.indexOf("." /* MaskExpression.DOT */);
+        if (decimalIndex === -1) {
+            const parsedValue = parseInt(value, 10);
+            return isNaN(parsedValue) ? "" /* MaskExpression.EMPTY_STRING */ : parsedValue.toString();
+        }
+        else {
+            const integerPart = parseInt(value.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 */
+                : integerString + decimal + decimalPart;
+        }
+    }
 }
-MaskApplierService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskApplierService, deps: [{ token: config }], target: i0.ɵɵFactoryTarget.Injectable });
-MaskApplierService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskApplierService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskApplierService, decorators: [{
+NgxMaskApplierService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskApplierService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NgxMaskApplierService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskApplierService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskApplierService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [config]
-                    }] }];
-    } });
+        }] });
 
-class MaskService extends MaskApplierService {
-    constructor(document, _config, _elementRef, _renderer) {
-        super(_config);
-        this.document = document;
-        this._config = _config;
-        this._elementRef = _elementRef;
-        this._renderer = _renderer;
-        this.maskExpression = '';
+class NgxMaskService extends NgxMaskApplierService {
+    constructor() {
+        super(...arguments);
         this.isNumberValue = false;
-        this.placeHolderCharacter = '_';
         this.maskIsShown = '';
         this.selStart = null;
         this.selEnd = null;
@@ -624,82 +749,155 @@ class MaskService extends MaskApplierService {
          */
         this.writingValue = false;
         this.maskChanged = false;
+        this._maskExpressionArray = [];
         this.triggerOnMaskChange = false;
+        this._emitValue = false;
+        this._previousValue = '';
+        this._currentValue = '';
+        // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-explicit-any
         this.onChange = (_) => { };
+        this.document = inject(DOCUMENT);
+        this._config = inject(NGX_MASK_CONFIG);
+        this._elementRef = inject(ElementRef, { optional: true });
+        this._renderer = inject(Renderer2, { optional: true });
     }
     // eslint-disable-next-line complexity
-    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, cb = () => { }) {
+    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-explicit-any
+    cb = () => { }) {
+        var _a;
         if (!maskExpression) {
             return inputValue !== this.actualValue ? this.actualValue : inputValue;
         }
-        this.maskIsShown = this.showMaskTyped ? this.showMaskInInput() : '';
-        if (this.maskExpression === 'IP' && this.showMaskTyped) {
-            this.maskIsShown = this.showMaskInInput(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 */);
         }
-        if (this.maskExpression === 'CPF_CNPJ' && this.showMaskTyped) {
-            this.maskIsShown = this.showMaskInInput(inputValue || '#');
+        if (this.maskExpression === "CPF_CNPJ" /* 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;
         }
-        const getSymbol = !!inputValue && typeof this.selStart === 'number' ? inputValue[this.selStart] : '';
+        const getSymbol = !!inputValue && typeof this.selStart === 'number'
+            ? (_a = inputValue[this.selStart]) !== null && _a !== void 0 ? _a : "" /* MaskExpression.EMPTY_STRING */
+            : "" /* MaskExpression.EMPTY_STRING */;
         let newInputValue = '';
         if (this.hiddenInput !== undefined && !this.writingValue) {
-            let actualResult = this.actualValue.split('');
+            let actualResult = inputValue && inputValue.length === 1
+                ? inputValue.split("" /* MaskExpression.EMPTY_STRING */)
+                : this.actualValue.split("" /* MaskExpression.EMPTY_STRING */);
             // eslint-disable  @typescript-eslint/no-unused-expressions
             // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-            inputValue !== '' && actualResult.length
-                ? typeof this.selStart === 'number' && typeof this.selEnd === 'number'
-                    ? inputValue.length > actualResult.length
-                        ? actualResult.splice(this.selStart, 0, getSymbol)
-                        : inputValue.length < actualResult.length
-                            ? actualResult.length - inputValue.length === 1
-                                ? actualResult.splice(this.selStart - 1, 1)
-                                : actualResult.splice(this.selStart, this.selEnd - this.selStart)
-                            : null
-                    : null
-                : (actualResult = []);
+            if (typeof this.selStart === 'object' && typeof this.selEnd === 'object') {
+                this.selStart = Number(this.selStart);
+                this.selEnd = Number(this.selEnd);
+            }
+            else {
+                inputValue !== "" /* MaskExpression.EMPTY_STRING */ && actualResult.length
+                    ? typeof this.selStart === 'number' && typeof this.selEnd === 'number'
+                        ? inputValue.length > actualResult.length
+                            ? actualResult.splice(this.selStart, 0, getSymbol)
+                            : inputValue.length < actualResult.length
+                                ? actualResult.length - inputValue.length === 1
+                                    ? backspaced
+                                        ? actualResult.splice(this.selStart - 1, 1)
+                                        : actualResult.splice(inputValue.length - 1, 1)
+                                    : actualResult.splice(this.selStart, this.selEnd - this.selStart)
+                                : null
+                        : null
+                    : (actualResult = []);
+            }
             if (this.showMaskTyped) {
-                // eslint-disable-next-line no-param-reassign
-                inputValue = this.removeMask(inputValue);
+                if (!this.hiddenInput) {
+                    // eslint-disable-next-line no-param-reassign
+                    inputValue = this.removeMask(inputValue);
+                }
             }
             // eslint-enable  @typescript-eslint/no-unused-expressions
             newInputValue =
                 this.actualValue.length && actualResult.length <= inputValue.length
-                    ? this.shiftTypedSymbols(actualResult.join(''))
+                    ? this.shiftTypedSymbols(actualResult.join("" /* MaskExpression.EMPTY_STRING */))
                     : inputValue;
         }
-        if (this.showMaskTyped) {
+        if (justPasted && (this.hiddenInput || !this.hiddenInput)) {
+            newInputValue = inputValue;
+        }
+        if (this.deletedSpecialCharacter && position) {
+            if (this.specialCharacters.includes(this.actualValue.slice(position, position + 1))) {
+                // eslint-disable-next-line no-param-reassign
+                position = position + 1;
+            }
+            else if (maskExpression.slice(position - 1, position + 1) !== "M0" /* MaskExpression.MONTHS */) {
+                // eslint-disable-next-line no-param-reassign
+                position = position - 2;
+            }
+            // eslint-disable-next-line no-param-reassign
+            this.deletedSpecialCharacter = false;
+        }
+        if (this.showMaskTyped &&
+            this.placeHolderCharacter.length === 1 &&
+            !this.leadZeroDateTime) {
             // eslint-disable-next-line no-param-reassign
             inputValue = this.removeMask(inputValue);
         }
-        newInputValue = Boolean(newInputValue) && newInputValue.length ? newInputValue : inputValue;
+        if (this.maskChanged) {
+            newInputValue = inputValue;
+        }
+        else {
+            newInputValue =
+                Boolean(newInputValue) && newInputValue.length ? newInputValue : inputValue;
+        }
+        if (this.showMaskTyped && this.keepCharacterPositions && this.actualValue && !justPasted) {
+            const value = this.dropSpecialCharacters
+                ? this.removeMask(this.actualValue)
+                : this.actualValue;
+            this.formControlResult(value);
+            return this.actualValue
+                ? this.actualValue
+                : this.prefix + this.maskIsShown + this.suffix;
+        }
         const result = super.applyMask(newInputValue, maskExpression, position, justPasted, backspaced, cb);
         this.actualValue = this.getActualValue(result);
         // handle some separator implications:
         // a.) adjust decimalMarker default (. -> ,) if thousandSeparator is a dot
-        if (this.thousandSeparator === '.' && this.decimalMarker === '.') {
-            this.decimalMarker = ',';
+        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') && this.dropSpecialCharacters === true) {
-            this.maskSpecialCharacters = this.maskSpecialCharacters.filter((item) => !this._compareOrIncludes(item, this.decimalMarker, this.thousandSeparator));
-        }
-        this.formControlResult(result);
-        if (!this.showMaskTyped) {
+        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+            this.dropSpecialCharacters === true) {
+            this.specialCharacters = this.specialCharacters.filter((item) => !this._compareOrIncludes(item, this.decimalMarker, this.thousandSeparator) //item !== this.decimalMarker, // !
+            );
+        }
+        if (result || result === '') {
+            this._previousValue = this._currentValue;
+            this._currentValue = result;
+            this._emitValue = this._previousValue !== this._currentValue || this.maskChanged;
+        }
+        this._emitValue ? this.formControlResult(result) : '';
+        if (!this.showMaskTyped || (this.showMaskTyped && this.hiddenInput)) {
             if (this.hiddenInput) {
-                return result && result.length ? this.hideInput(result, this.maskExpression) : result;
+                if (backspaced) {
+                    return this.hideInput(result, this.maskExpression);
+                }
+                return (this.hideInput(result, this.maskExpression) +
+                    this.maskIsShown.slice(result.length));
             }
             return result;
         }
         const resLen = result.length;
         const prefNmask = this.prefix + this.maskIsShown;
-        if (this.maskExpression.includes('H')) {
+        if (this.maskExpression.includes("H" /* MaskExpression.HOURS */)) {
             const countSkipedSymbol = this._numberSkipedSymbols(result);
             return result + prefNmask.slice(resLen + countSkipedSymbol);
         }
-        else if (this.maskExpression === 'IP' || this.maskExpression === 'CPF_CNPJ') {
+        else if (this.maskExpression === "IP" /* MaskExpression.IP */ ||
+            this.maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */) {
             return result + prefNmask;
         }
         return result + prefNmask.slice(resLen);
@@ -715,8 +913,14 @@ class MaskService extends MaskApplierService {
         }
         return countSkipedSymbol;
     }
-    applyValueChanges(position, justPasted, backspaced, cb = () => { }) {
-        const formElement = this._elementRef.nativeElement;
+    applyValueChanges(position, justPasted, backspaced, 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-explicit-any
+    cb = () => { }) {
+        var _a;
+        const formElement = (_a = this._elementRef) === null || _a === void 0 ? void 0 : _a.nativeElement;
+        if (!formElement) {
+            return;
+        }
         formElement.value = this.applyMask(formElement.value, this.maskExpression, position, justPasted, backspaced, cb);
         if (formElement === this._getActiveElement()) {
             return;
@@ -725,48 +929,54 @@ class MaskService extends MaskApplierService {
     }
     hideInput(inputValue, maskExpression) {
         return inputValue
-            .split('')
+            .split("" /* MaskExpression.EMPTY_STRING */)
             .map((curr, index) => {
-            var _a, _b;
-            if (this.maskAvailablePatterns &&
-                this.maskAvailablePatterns[maskExpression[index]] &&
-                ((_a = this.maskAvailablePatterns[maskExpression[index]]) === null || _a === void 0 ? void 0 : _a.symbol)) {
-                return (_b = this.maskAvailablePatterns[maskExpression[index]]) === null || _b === void 0 ? void 0 : _b.symbol;
+            var _a, _b, _c, _d, _e;
+            if (this.patterns &&
+                this.patterns[(_a = maskExpression[index]) !== null && _a !== void 0 ? _a : "" /* MaskExpression.EMPTY_STRING */] &&
+                ((_c = this.patterns[(_b = maskExpression[index]) !== null && _b !== void 0 ? _b : "" /* MaskExpression.EMPTY_STRING */]) === null || _c === void 0 ? void 0 : _c.symbol)) {
+                return (_e = this.patterns[(_d = maskExpression[index]) !== null && _d !== void 0 ? _d : "" /* MaskExpression.EMPTY_STRING */]) === null || _e === void 0 ? void 0 : _e.symbol;
             }
             return curr;
         })
-            .join('');
+            .join("" /* MaskExpression.EMPTY_STRING */);
     }
     // this function is not necessary, it checks result against maskExpression
     getActualValue(res) {
         const compare = res
-            .split('')
-            .filter((symbol, i) => this._checkSymbolMask(symbol, this.maskExpression[i]) ||
-            (this.maskSpecialCharacters.includes(this.maskExpression[i]) &&
-                symbol === this.maskExpression[i]));
-        if (compare.join('') === res) {
-            return compare.join('');
+            .split("" /* MaskExpression.EMPTY_STRING */)
+            .filter((symbol, i) => {
+            var _a;
+            const maskChar = (_a = this.maskExpression[i]) !== null && _a !== void 0 ? _a : "" /* 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 */);
         }
         return res;
     }
     shiftTypedSymbols(inputValue) {
         let symbolToReplace = '';
         const newInputValue = (inputValue &&
-            inputValue.split('').map((currSymbol, index) => {
-                if (this.maskSpecialCharacters.includes(inputValue[index + 1]) &&
+            inputValue
+                .split("" /* MaskExpression.EMPTY_STRING */)
+                .map((currSymbol, index) => {
+                var _a;
+                if (this.specialCharacters.includes((_a = inputValue[index + 1]) !== null && _a !== void 0 ? _a : "" /* MaskExpression.EMPTY_STRING */) &&
                     inputValue[index + 1] !== this.maskExpression[index + 1]) {
                     symbolToReplace = currSymbol;
                     return inputValue[index + 1];
                 }
                 if (symbolToReplace.length) {
                     const replaceSymbol = symbolToReplace;
-                    symbolToReplace = '';
+                    symbolToReplace = "" /* MaskExpression.EMPTY_STRING */;
                     return replaceSymbol;
                 }
                 return currSymbol;
             })) ||
             [];
-        return newInputValue.join('');
+        return newInputValue.join("" /* MaskExpression.EMPTY_STRING */);
     }
     /**
      * Convert number value to string
@@ -774,13 +984,20 @@ class MaskService extends MaskApplierService {
      * 1e-7 -> '0.0000001'
      */
     numberToString(value) {
-        if (!value && value !== 0) {
+        if ((!value && value !== 0) ||
+            (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+                (this.leadZero || !this.dropSpecialCharacters)) ||
+            (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+                this.separatorLimit.length > 14 &&
+                String(value).length > 14)) {
             return String(value);
         }
-        return Number(value).toLocaleString('fullwide', {
+        return Number(value)
+            .toLocaleString('fullwide', {
             useGrouping: false,
             maximumFractionDigits: 20,
-        });
+        })
+            .replace(`/${"-" /* MaskExpression.MINUS */}/`, "-" /* MaskExpression.MINUS */);
     }
     showMaskInInput(inputVal) {
         if (this.showMaskTyped && !!this.shownMaskExpression) {
@@ -793,45 +1010,62 @@ class MaskService extends MaskApplierService {
         }
         else if (this.showMaskTyped) {
             if (inputVal) {
-                if (this.maskExpression === 'IP') {
+                if (this.maskExpression === "IP" /* MaskExpression.IP */) {
                     return this._checkForIp(inputVal);
                 }
-                if (this.maskExpression === 'CPF_CNPJ') {
+                if (this.maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */) {
                     return this._checkForCpfCnpj(inputVal);
                 }
             }
+            if (this.placeHolderCharacter.length === this.maskExpression.length) {
+                return this.placeHolderCharacter;
+            }
             return this.maskExpression.replace(/\w/g, this.placeHolderCharacter);
         }
         return '';
     }
     clearIfNotMatchFn() {
-        const formElement = this._elementRef.nativeElement;
+        var _a;
+        const formElement = (_a = this._elementRef) === null || _a === void 0 ? void 0 : _a.nativeElement;
+        if (!formElement) {
+            return;
+        }
         if (this.clearIfNotMatch &&
             this.prefix.length + this.maskExpression.length + this.suffix.length !==
-                formElement.value.replace(/_/g, '').length) {
-            this.formElementProperty = ['value', ''];
-            this.applyMask(formElement.value, this.maskExpression);
+                formElement.value.replace(this.placeHolderCharacter, "" /* MaskExpression.EMPTY_STRING */)
+                    .length) {
+            this.formElementProperty = ['value', "" /* MaskExpression.EMPTY_STRING */];
+            this.applyMask('', this.maskExpression);
         }
     }
     set formElementProperty([name, value]) {
-        Promise.resolve().then(() => this._renderer.setProperty(this._elementRef.nativeElement, name, value));
+        if (!this._renderer || !this._elementRef) {
+            return;
+        }
+        Promise.resolve().then(() => { var _a, _b; return (_a = this._renderer) === null || _a === void 0 ? void 0 : _a.setProperty((_b = this._elementRef) === null || _b === void 0 ? void 0 : _b.nativeElement, name, value); });
     }
     checkSpecialCharAmount(mask) {
-        const chars = mask.split('').filter((item) => this._findSpecialChar(item));
+        const chars = mask
+            .split("" /* MaskExpression.EMPTY_STRING */)
+            .filter((item) => this._findSpecialChar(item));
         return chars.length;
     }
     removeMask(inputValue) {
-        return this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.maskSpecialCharacters.concat('_').concat(this.placeHolderCharacter));
+        return this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.specialCharacters.concat('_').concat(this.placeHolderCharacter));
     }
     _checkForIp(inputVal) {
         var _a;
-        if (inputVal === '#') {
+        if (inputVal === "#" /* MaskExpression.HASH */) {
             return `${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}`;
         }
         const arr = [];
         for (let i = 0; i < inputVal.length; i++) {
-            if ((_a = inputVal[i]) === null || _a === void 0 ? void 0 : _a.match('\\d')) {
-                arr.push(inputVal[i]);
+            const value = (_a = inputVal[i]) !== null && _a !== void 0 ? _a : "" /* MaskExpression.EMPTY_STRING */;
+            if (!value) {
+                continue;
+            }
+            if (value.match('\\d')) {
+                arr.push(value);
             }
         }
         if (arr.length <= 3) {
@@ -859,13 +1093,17 @@ class MaskService extends MaskApplierService {
             `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
             `/${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
             `-${this.placeHolderCharacter}${this.placeHolderCharacter}`;
-        if (inputVal === '#') {
+        if (inputVal === "#" /* MaskExpression.HASH */) {
             return cpf;
         }
         const arr = [];
         for (let i = 0; i < inputVal.length; i++) {
-            if ((_a = inputVal[i]) === null || _a === void 0 ? void 0 : _a.match('\\d')) {
-                arr.push(inputVal[i]);
+            const value = (_a = inputVal[i]) !== null && _a !== void 0 ? _a : "" /* MaskExpression.EMPTY_STRING */;
+            if (!value) {
+                continue;
+            }
+            if (value.match('\\d')) {
+                arr.push(value);
             }
         }
         if (arr.length <= 3) {
@@ -916,55 +1154,88 @@ class MaskService extends MaskApplierService {
      */
     formControlResult(inputValue) {
         if (this.writingValue || (!this.triggerOnMaskChange && this.maskChanged)) {
+            this.maskChanged
+                ? this.onChange(this.outputTransformFn(this._toNumber(this._checkSymbols(this._removeSuffix(this._removePrefix(inputValue))))))
+                : '';
             this.maskChanged = false;
             return;
         }
         if (Array.isArray(this.dropSpecialCharacters)) {
-            this.onChange(this._toNumber(this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.dropSpecialCharacters)));
+            this.onChange(this.outputTransformFn(this._toNumber(this._checkSymbols(this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.dropSpecialCharacters)))));
         }
-        else if (this.dropSpecialCharacters) {
-            this.onChange(this._toNumber(this._checkSymbols(inputValue)));
+        else if (this.dropSpecialCharacters ||
+            (!this.dropSpecialCharacters && this.prefix === inputValue)) {
+            this.onChange(this.outputTransformFn(this._toNumber(this._checkSymbols(this._removeSuffix(this._removePrefix(inputValue))))));
         }
         else {
-            this.onChange(this._removeSuffix(inputValue));
+            this.onChange(this.outputTransformFn(this._toNumber(inputValue)));
         }
     }
     _toNumber(value) {
-        if (!this.isNumberValue || value === '') {
+        if (!this.isNumberValue || value === "" /* MaskExpression.EMPTY_STRING */) {
+            return value;
+        }
+        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+            (this.leadZero || !this.dropSpecialCharacters)) {
             return value;
         }
+        if (String(value).length > 16 && this.separatorLimit.length > 14) {
+            return String(value);
+        }
         const num = Number(value);
+        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) && Number.isNaN(num)) {
+            const val = String(value).replace(',', '.');
+            return Number(val);
+        }
         return Number.isNaN(num) ? value : num;
     }
     _removeMask(value, specialCharactersForRemove) {
-        return value ? value.replace(this._regExpForRemove(specialCharactersForRemove), '') : value;
+        if (this.maskExpression.startsWith("percent" /* MaskExpression.PERCENT */) &&
+            value.includes("." /* MaskExpression.DOT */)) {
+            return value;
+        }
+        return value
+            ? value.replace(this._regExpForRemove(specialCharactersForRemove), "" /* MaskExpression.EMPTY_STRING */)
+            : value;
     }
     _removePrefix(value) {
         if (!this.prefix) {
             return value;
         }
-        return value ? value.replace(this.prefix, '') : value;
+        return value ? value.replace(this.prefix, "" /* MaskExpression.EMPTY_STRING */) : value;
     }
     _removeSuffix(value) {
         if (!this.suffix) {
             return value;
         }
-        return value ? value.replace(this.suffix, '') : value;
+        return value ? value.replace(this.suffix, "" /* MaskExpression.EMPTY_STRING */) : value;
     }
     _retrieveSeparatorValue(result) {
-        return this._removeMask(this._removeSuffix(this._removePrefix(result)), this.maskSpecialCharacters);
+        const specialCharacters = Array.isArray(this.dropSpecialCharacters)
+            ? this.specialCharacters.filter((v) => {
+                return this.dropSpecialCharacters.includes(v);
+            })
+            : this.specialCharacters;
+        return this._removeMask(result, specialCharacters);
     }
     _regExpForRemove(specialCharactersForRemove) {
         return new RegExp(specialCharactersForRemove.map((item) => `\\${item}`).join('|'), 'gi');
     }
     _replaceDecimalMarkerToDot(value) {
-        const markers = Array.isArray(this.decimalMarker) ? this.decimalMarker : [this.decimalMarker];
-        return value.replace(this._regExpForRemove(markers), '.');
+        const markers = Array.isArray(this.decimalMarker)
+            ? this.decimalMarker
+            : [this.decimalMarker];
+        return value.replace(this._regExpForRemove(markers), "." /* MaskExpression.DOT */);
     }
     _checkSymbols(result) {
-        if (result === '') {
+        if (result === "" /* MaskExpression.EMPTY_STRING */) {
             return result;
         }
+        if (this.maskExpression.startsWith("percent" /* MaskExpression.PERCENT */) &&
+            this.decimalMarker === "," /* MaskExpression.COMMA */) {
+            // eslint-disable-next-line no-param-reassign
+            result = result.replace("," /* MaskExpression.COMMA */, "." /* MaskExpression.DOT */);
+        }
         const separatorPrecision = this._retrieveSeparatorPrecision(this.maskExpression);
         const separatorValue = this._replaceDecimalMarkerToDot(this._retrieveSeparatorValue(result));
         if (!this.isNumberValue) {
@@ -974,10 +1245,13 @@ class MaskService extends MaskApplierService {
             if (result === this.decimalMarker) {
                 return null;
             }
+            if (this.separatorLimit.length > 14) {
+                return String(separatorValue);
+            }
             return this._checkPrecision(this.maskExpression, separatorValue);
         }
         else {
-            return Number(separatorValue);
+            return separatorValue;
         }
     }
     // TODO should think about helpers or separting decimal precision to own property
@@ -986,31 +1260,87 @@ class MaskService extends MaskApplierService {
         return matcher ? Number(matcher[1]) : null;
     }
     _checkPrecision(separatorExpression, separatorValue) {
-        if (separatorExpression.indexOf('2') > 0) {
-            return Number(separatorValue).toFixed(2);
+        const separatorPrecision = separatorExpression.slice(10, 11);
+        if (separatorExpression.indexOf('2') > 0 ||
+            (this.leadZero && Number(separatorPrecision) > 1)) {
+            if (this.decimalMarker === "," /* MaskExpression.COMMA */ && this.leadZero) {
+                // eslint-disable-next-line no-param-reassign
+                separatorValue = separatorValue.replace(',', '.');
+            }
+            return this.leadZero
+                ? Number(separatorValue).toFixed(Number(separatorPrecision))
+                : Number(separatorValue).toFixed(2);
         }
-        return Number(separatorValue);
+        return this.numberToString(separatorValue);
+    }
+    _repeatPatternSymbols(maskExp) {
+        return ((maskExp.match(/{[0-9]+}/) &&
+            maskExp
+                .split("" /* MaskExpression.EMPTY_STRING */)
+                .reduce((accum, currVal, index) => {
+                this._start =
+                    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 */)) {
+                    const symbols = maskExp.slice(0, this._start - 1);
+                    return symbols.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)
+                        ? accum + replaceWith
+                        : symbols + accum + replaceWith;
+                }
+                else {
+                    return accum + replaceWith;
+                }
+            }, '')) ||
+            maskExp);
+    }
+    currentLocaleDecimalMarker() {
+        return (1.1).toLocaleString().substring(1, 2);
     }
 }
-MaskService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskService, deps: [{ token: DOCUMENT }, { token: config }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Injectable });
-MaskService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskService, decorators: [{
+NgxMaskService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+NgxMaskService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [DOCUMENT]
-                    }] }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [config]
-                    }] }, { type: i0.ElementRef }, { type: i0.Renderer2 }];
-    } });
+        }] });
 
-class MaskDirective {
-    constructor(document, _maskService, _config) {
-        this.document = document;
-        this._maskService = _maskService;
-        this._config = _config;
+/**
+ * @internal
+ */
+function _configFactory() {
+    const initConfig = inject(INITIAL_CONFIG);
+    const configValue = inject(NEW_CONFIG);
+    return configValue instanceof Function
+        ? Object.assign(Object.assign({}, initConfig), configValue()) : Object.assign(Object.assign({}, initConfig), configValue);
+}
+function provideNgxMask(configValue) {
+    return [
+        {
+            provide: NEW_CONFIG,
+            useValue: configValue,
+        },
+        {
+            provide: INITIAL_CONFIG,
+            useValue: initialConfig,
+        },
+        {
+            provide: NGX_MASK_CONFIG,
+            useFactory: _configFactory,
+        },
+        NgxMaskService,
+    ];
+}
+function provideEnvironmentNgxMask(configValue) {
+    return makeEnvironmentProviders(provideNgxMask(configValue));
+}
+
+class NgxMaskDirective {
+    constructor() {
         // eslint-disable-next-line @angular-eslint/no-input-rename
         this.maskExpression = '';
         this.specialCharacters = [];
@@ -1030,25 +1360,45 @@ class MaskDirective {
         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._justPasted = 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, @typescript-eslint/no-explicit-any
         this.onChange = (_) => { };
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
         this.onTouch = () => { };
     }
     ngOnChanges(changes) {
-        const { maskExpression, specialCharacters, patterns, prefix, suffix, thousandSeparator, decimalMarker, dropSpecialCharacters, hiddenInput, showMaskTyped, placeHolderCharacter, shownMaskExpression, showTemplate, clearIfNotMatch, validation, separatorLimit, allowNegativeNumbers, leadZeroDateTime, triggerOnMaskChange, } = 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) {
             if (maskExpression.currentValue !== maskExpression.previousValue &&
                 !maskExpression.firstChange) {
                 this._maskService.maskChanged = true;
             }
-            if (maskExpression.currentValue && maskExpression.currentValue.split('||').length > 1) {
+            if (allowNegativeNumbers) {
+                this._maskService.allowNegativeNumbers = allowNegativeNumbers.currentValue;
+                if (this._maskService.allowNegativeNumbers) {
+                    this._maskService.specialCharacters =
+                        this._maskService.specialCharacters.filter((c) => c !== "-" /* MaskExpression.MINUS */);
+                }
+            }
+            if (maskExpression.currentValue &&
+                maskExpression.currentValue.split("||" /* MaskExpression.OR */).length > 1) {
                 this._maskExpressionArray = maskExpression.currentValue
-                    .split('||')
+                    .split("||" /* MaskExpression.OR */)
                     .sort((a, b) => {
                     return a.length - b.length;
                 });
@@ -1056,7 +1406,7 @@ class MaskDirective {
             }
             else {
                 this._maskExpressionArray = [];
-                this._maskValue = maskExpression.currentValue || '';
+                this._maskValue = maskExpression.currentValue || "" /* MaskExpression.EMPTY_STRING */;
                 this._maskService.maskExpression = this._maskValue;
             }
         }
@@ -1065,12 +1415,15 @@ class MaskDirective {
                 return;
             }
             else {
-                this._maskService.maskSpecialCharacters = specialCharacters.currentValue || [];
+                this._maskService.specialCharacters = specialCharacters.currentValue || [];
             }
         }
         // Only overwrite the mask available patterns if a pattern has actually been passed in
         if (patterns && patterns.currentValue) {
-            this._maskService.maskAvailablePatterns = patterns.currentValue;
+            this._maskService.patterns = patterns.currentValue;
+        }
+        if (apm && apm.currentValue) {
+            this._maskService.apm = apm.currentValue;
         }
         if (prefix) {
             this._maskService.prefix = prefix.currentValue;
@@ -1111,22 +1464,29 @@ class MaskDirective {
         if (separatorLimit) {
             this._maskService.separatorLimit = separatorLimit.currentValue;
         }
-        if (allowNegativeNumbers) {
-            this._maskService.allowNegativeNumbers = allowNegativeNumbers.currentValue;
-            if (this._maskService.allowNegativeNumbers) {
-                this._maskService.maskSpecialCharacters = this._maskService.maskSpecialCharacters.filter((c) => c !== '-');
-            }
-        }
         if (leadZeroDateTime) {
             this._maskService.leadZeroDateTime = leadZeroDateTime.currentValue;
         }
+        if (leadZero) {
+            this._maskService.leadZero = leadZero.currentValue;
+        }
         if (triggerOnMaskChange) {
             this._maskService.triggerOnMaskChange = triggerOnMaskChange.currentValue;
         }
+        if (inputTransformFn) {
+            this._maskService.inputTransformFn = inputTransformFn.currentValue;
+        }
+        if (outputTransformFn) {
+            this._maskService.outputTransformFn = outputTransformFn.currentValue;
+        }
+        if (keepCharacterPositions) {
+            this._maskService.keepCharacterPositions = keepCharacterPositions.currentValue;
+        }
         this._applyMask();
     }
     // eslint-disable-next-line complexity
     validate({ value }) {
+        var _a, _b, _c;
         if (!this._maskService.validation || !this._maskValue) {
             return null;
         }
@@ -1136,7 +1496,7 @@ class MaskDirective {
         if (this._maskService.cpfCnpjError) {
             return this._createValidationError(value);
         }
-        if (this._maskValue.startsWith('separator')) {
+        if (this._maskValue.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
             return null;
         }
         if (withoutValidation.includes(this._maskValue)) {
@@ -1150,13 +1510,16 @@ class MaskDirective {
         }
         if (value && value.toString().length >= 1) {
             let counterOfOpt = 0;
-            for (const key in this._maskService.maskAvailablePatterns) {
-                if (this._maskService.maskAvailablePatterns[key].optional) {
+            if (this._maskValue.startsWith("percent" /* MaskExpression.PERCENT */)) {
+                return null;
+            }
+            for (const key in this._maskService.patterns) {
+                if ((_a = this._maskService.patterns[key]) === null || _a === void 0 ? void 0 : _a.optional) {
                     if (this._maskValue.indexOf(key) !== this._maskValue.lastIndexOf(key)) {
                         const opt = this._maskValue
-                            .split('')
+                            .split("" /* MaskExpression.EMPTY_STRING */)
                             .filter((i) => i === key)
-                            .join('');
+                            .join("" /* MaskExpression.EMPTY_STRING */);
                         counterOfOpt += opt.length;
                     }
                     else if (this._maskValue.indexOf(key) !== -1) {
@@ -1171,31 +1534,64 @@ class MaskDirective {
                     }
                 }
             }
-            if (this._maskValue.indexOf('{') === 1 &&
+            if (this._maskValue.indexOf("{" /* MaskExpression.CURLY_BRACKETS_LEFT */) === 1 &&
                 value.toString().length ===
-                    this._maskValue.length + Number(this._maskValue.split('{')[1].split('}')[0]) - 4) {
-                return null;
-            }
-            if (this._maskValue.indexOf('*') === 1 || this._maskValue.indexOf('?') === 1) {
+                    this._maskValue.length +
+                        Number(((_b = this._maskValue.split("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)[1]) !== null && _b !== void 0 ? _b : "" /* MaskExpression.EMPTY_STRING */).split("}" /* MaskExpression.CURLY_BRACKETS_RIGHT */)[0]) -
+                        4) {
                 return null;
             }
-            else if ((this._maskValue.indexOf('*') > 1 &&
-                value.toString().length < this._maskValue.indexOf('*')) ||
-                (this._maskValue.indexOf('?') > 1 &&
-                    value.toString().length < this._maskValue.indexOf('?')) ||
-                this._maskValue.indexOf('{') === 1) {
+            else if ((this._maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */) > 1 &&
+                value.toString().length <
+                    this._maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */)) ||
+                (this._maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */) > 1 &&
+                    value.toString().length <
+                        this._maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */)) ||
+                this._maskValue.indexOf("{" /* MaskExpression.CURLY_BRACKETS_LEFT */) === 1) {
                 return this._createValidationError(value);
             }
-            if (this._maskValue.indexOf('*') === -1 || this._maskValue.indexOf('?') === -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 -
                         this._maskService.checkSpecialCharAmount(this._maskValue) -
                         counterOfOpt
-                    : this._maskValue.length - counterOfOpt;
-                if (value.toString().length < length) {
-                    return this._createValidationError(value);
+                    : this.prefix
+                        ? this._maskValue.length + this.prefix.length - counterOfOpt
+                        : this._maskValue.length - counterOfOpt;
+                if (array.length === 1) {
+                    if (value.toString().length < length) {
+                        return this._createValidationError(value);
+                    }
+                }
+                if (array.length > 1) {
+                    const lastIndexArray = array[array.length - 1];
+                    if (lastIndexArray &&
+                        this._maskService.specialCharacters.includes(lastIndexArray[0]) &&
+                        String(value).includes((_c = lastIndexArray[0]) !== null && _c !== void 0 ? _c : '') &&
+                        !this.dropSpecialCharacters) {
+                        const special = value.split(lastIndexArray[0]);
+                        return special[special.length - 1].length === lastIndexArray.length - 1
+                            ? null
+                            : this._createValidationError(value);
+                    }
+                    else if (((lastIndexArray &&
+                        !this._maskService.specialCharacters.includes(lastIndexArray[0])) ||
+                        !lastIndexArray ||
+                        this._maskService.dropSpecialCharacters) &&
+                        value.length >= length - 1) {
+                        return null;
+                    }
+                    else {
+                        return this._createValidationError(value);
+                    }
                 }
             }
+            if (this._maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */) === 1 ||
+                this._maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */) === 1) {
+                return null;
+            }
         }
         if (value) {
             this.maskFilled.emit();
@@ -1208,47 +1604,215 @@ class MaskDirective {
     }
     onModelChange(value) {
         // on form reset we need to update the actualValue
-        if ((value === '' || value === null || value === undefined) && this._maskService.actualValue) {
-            this._maskService.actualValue = this._maskService.getActualValue('');
+        if ((value === "" /* MaskExpression.EMPTY_STRING */ || value === null || value === undefined) &&
+            this._maskService.actualValue) {
+            this._maskService.actualValue = this._maskService.getActualValue("" /* MaskExpression.EMPTY_STRING */);
         }
     }
     onInput(e) {
-        const el = e.target;
-        this._inputValue = el.value;
-        this._setMask();
-        if (!this._maskValue) {
-            this.onChange(el.value);
-            return;
-        }
-        const position = el.selectionStart === 1
-            ? el.selectionStart + this._maskService.prefix.length
-            : el.selectionStart;
-        let caretShift = 0;
-        let backspaceShift = false;
-        this._maskService.applyValueChanges(position, this._justPasted, this._code === 'Backspace' || this._code === 'Delete', (shift, _backspaceShift) => {
-            this._justPasted = false;
-            caretShift = shift;
-            backspaceShift = _backspaceShift;
-        });
-        // only set the selection if the element is active
-        if (this._getActiveElement() !== el) {
+        var _a, _b, _c, _d;
+        // If IME is composing text, we wait for the composed text.
+        if (this._isComposing)
             return;
+        const el = e.target;
+        const transformedValue = this._maskService.inputTransformFn(el.value);
+        if (el.type !== 'number') {
+            if (typeof transformedValue === 'string' || typeof transformedValue === 'number') {
+                el.value = transformedValue.toString();
+                this._inputValue = el.value;
+                this._setMask();
+                if (!this._maskValue) {
+                    this.onChange(el.value);
+                    return;
+                }
+                let position = el.selectionStart === 1
+                    ? el.selectionStart + this._maskService.prefix.length
+                    : el.selectionStart;
+                if (this.showMaskTyped &&
+                    this.keepCharacterPositions &&
+                    this._maskService.placeHolderCharacter.length === 1) {
+                    const inputSymbol = el.value.slice(position - 1, position);
+                    const prefixLength = this.prefix.length;
+                    const checkSymbols = this._maskService._checkSymbolMask(inputSymbol, (_a = this._maskService.maskExpression[position - 1 - prefixLength]) !== null && _a !== void 0 ? _a : "" /* MaskExpression.EMPTY_STRING */);
+                    const checkSpecialCharacter = this._maskService._checkSymbolMask(inputSymbol, (_b = this._maskService.maskExpression[position + 1 - prefixLength]) !== null && _b !== void 0 ? _b : "" /* MaskExpression.EMPTY_STRING */);
+                    const selectRangeBackspace = this._maskService.selStart === this._maskService.selEnd;
+                    const selStart = (_c = Number(this._maskService.selStart) - prefixLength) !== null && _c !== void 0 ? _c : '';
+                    const selEnd = (_d = Number(this._maskService.selEnd) - prefixLength) !== null && _d !== void 0 ? _d : '';
+                    if (this._code === "Backspace" /* MaskExpression.BACKSPACE */) {
+                        if (!selectRangeBackspace) {
+                            if (this._maskService.selStart === prefixLength) {
+                                this._maskService.actualValue =
+                                    this.prefix +
+                                        this._maskService.maskIsShown.slice(0, selEnd) +
+                                        this._inputValue.split(this.prefix).join('');
+                            }
+                            else if (this._maskService.selStart ===
+                                this._maskService.maskIsShown.length + prefixLength) {
+                                this._maskService.actualValue =
+                                    this._inputValue +
+                                        this._maskService.maskIsShown.slice(selStart, selEnd);
+                            }
+                            else {
+                                this._maskService.actualValue =
+                                    this.prefix +
+                                        this._inputValue
+                                            .split(this.prefix)
+                                            .join('')
+                                            .slice(0, selStart) +
+                                        this._maskService.maskIsShown.slice(selStart, selEnd) +
+                                        this._maskService.actualValue.slice(selEnd + prefixLength, this._maskService.maskIsShown.length + prefixLength) +
+                                        this.suffix;
+                            }
+                        }
+                        else if (!this._maskService.specialCharacters.includes(this._maskService.maskExpression.slice(position - this.prefix.length, position + 1 - this.prefix.length)) &&
+                            selectRangeBackspace) {
+                            if (selStart === 1 && this.prefix) {
+                                this._maskService.actualValue =
+                                    this.prefix +
+                                        this._maskService.placeHolderCharacter +
+                                        el.value
+                                            .split(this.prefix)
+                                            .join('')
+                                            .split(this.suffix)
+                                            .join('') +
+                                        this.suffix;
+                                position = position - 1;
+                            }
+                            else {
+                                const part1 = el.value.substring(0, position);
+                                const part2 = el.value.substring(position);
+                                this._maskService.actualValue =
+                                    part1 + this._maskService.placeHolderCharacter + part2;
+                            }
+                        }
+                    }
+                    if (this._code !== "Backspace" /* MaskExpression.BACKSPACE */) {
+                        if (!checkSymbols && !checkSpecialCharacter && selectRangeBackspace) {
+                            position = Number(el.selectionStart) - 1;
+                        }
+                        else if (this._maskService.specialCharacters.includes(el.value.slice(position, position + 1)) &&
+                            checkSpecialCharacter &&
+                            !this._maskService.specialCharacters.includes(el.value.slice(position + 1, position + 2))) {
+                            this._maskService.actualValue =
+                                el.value.slice(0, position - 1) +
+                                    el.value.slice(position, position + 1) +
+                                    inputSymbol +
+                                    el.value.slice(position + 2);
+                            position = position + 1;
+                        }
+                        else if (checkSymbols) {
+                            this._maskService.actualValue =
+                                el.value.slice(0, position - 1) +
+                                    inputSymbol +
+                                    el.value
+                                        .slice(position + 1)
+                                        .split(this.suffix)
+                                        .join('') +
+                                    this.suffix;
+                        }
+                    }
+                }
+                let caretShift = 0;
+                let backspaceShift = false;
+                if (this._code === "Delete" /* MaskExpression.DELETE */ && "separator" /* 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 */ &&
+                    position < 10) {
+                    const inputSymbol = this._inputValue.slice(position - 1, position);
+                    el.value =
+                        this._inputValue.slice(0, position - 1) +
+                            inputSymbol +
+                            this._inputValue.slice(position + 1);
+                }
+                if (this._maskService.maskExpression === "Hh:m0:s0" /* MaskExpression.HOURS_MINUTES_SECONDS */ &&
+                    this.apm) {
+                    if (this._justPasted && el.value.slice(0, 2) === "00" /* 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;
+                }
+                this._maskService.applyValueChanges(position, this._justPasted, this._code === "Backspace" /* MaskExpression.BACKSPACE */ || this._code === "Delete" /* 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;
+                }
+                // 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 */) {
+                        position = this.specialCharacters.includes(this._inputValue.slice(position - 1, position))
+                            ? position - 1
+                            : position;
+                    }
+                    else {
+                        position =
+                            el.selectionStart === 1
+                                ? el.selectionStart + this._maskService.prefix.length
+                                : el.selectionStart;
+                    }
+                }
+                this._position =
+                    this._position === 1 && this._inputValue.length === 1 ? null : this._position;
+                let positionToApply = this._position
+                    ? this._inputValue.length + position + caretShift
+                    : position +
+                        (this._code === "Backspace" /* MaskExpression.BACKSPACE */ && !backspaceShift ? 0 : caretShift);
+                if (positionToApply > this._getActualInputLength()) {
+                    positionToApply = this._getActualInputLength();
+                }
+                if (positionToApply < 0) {
+                    positionToApply = 0;
+                }
+                el.setSelectionRange(positionToApply, positionToApply);
+                this._position = null;
+            }
+            else {
+                console.warn('Ngx-mask writeValue work with string | number, your current value:', typeof transformedValue);
+            }
         }
-        this._position = this._position === 1 && this._inputValue.length === 1 ? null : this._position;
-        let positionToApply = this._position
-            ? this._inputValue.length + position + caretShift
-            : position + (this._code === 'Backspace' && !backspaceShift ? 0 : caretShift);
-        if (positionToApply > this._getActualInputLength()) {
-            positionToApply = this._getActualInputLength();
-        }
-        if (positionToApply < 0) {
-            positionToApply = 0;
+        else {
+            this._maskService.applyValueChanges(el.value.length, this._justPasted, this._code === "Backspace" /* MaskExpression.BACKSPACE */ || this._code === "Delete" /* MaskExpression.DELETE */);
         }
-        el.setSelectionRange(positionToApply, positionToApply);
-        this._position = null;
     }
-    onBlur() {
+    // IME starts
+    onCompositionStart() {
+        this._isComposing = true;
+    }
+    // IME completes
+    onCompositionEnd(e) {
+        this._isComposing = false;
+        this._justPasted = true;
+        this.onInput(e);
+    }
+    onBlur(e) {
         if (this._maskValue) {
+            const el = e.target;
+            if (this.leadZero && el.value.length > 0 && typeof this.decimalMarker === 'string') {
+                const maskExpression = this._maskService.maskExpression;
+                const precision = Number(this._maskService.maskExpression.slice(maskExpression.length - 1, maskExpression.length));
+                if (precision > 1) {
+                    el.value = this.suffix ? el.value.split(this.suffix).join('') : el.value;
+                    const decimalPart = el.value.split(this.decimalMarker)[1];
+                    el.value = el.value.includes(this.decimalMarker)
+                        ? el.value +
+                            "0" /* MaskExpression.NUMBER_ZERO */.repeat(precision - decimalPart.length) +
+                            this.suffix
+                        : el.value +
+                            this.decimalMarker +
+                            "0" /* MaskExpression.NUMBER_ZERO */.repeat(precision) +
+                            this.suffix;
+                    this._maskService.actualValue = el.value;
+                }
+            }
             this._maskService.clearIfNotMatchFn();
         }
         this.onTouch();
@@ -1266,7 +1830,7 @@ class MaskDirective {
             el.selectionStart > this._maskService.prefix.length &&
             // eslint-disable-next-line
             e.keyCode !== 38) {
-            if (this._maskService.showMaskTyped) {
+            if (this._maskService.showMaskTyped && !this.keepCharacterPositions) {
                 // We are showing the mask in the input
                 this._maskService.maskIsShown = this._maskService.showMaskInInput();
                 if (el.setSelectionRange &&
@@ -1284,132 +1848,190 @@ class MaskDirective {
                 }
             }
         }
-        const nextValue = !el.value || el.value === this._maskService.prefix
-            ? this._maskService.prefix + this._maskService.maskIsShown
-            : el.value;
+        const nextValue = el &&
+            (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.value !== nextValue) {
+        if (el && el.value !== nextValue) {
             el.value = nextValue;
         }
         /** fix of cursor position with prefix when mouse click occur */
-        if ((el.selectionStart || el.selectionEnd) <=
-            this._maskService.prefix.length) {
+        if (el &&
+            el.type !== 'number' &&
+            (el.selectionStart || el.selectionEnd) <=
+                this._maskService.prefix.length) {
             el.selectionStart = this._maskService.prefix.length;
             return;
         }
         /** select only inserted text */
-        if (el.selectionEnd > this._getActualInputLength()) {
+        if (el && el.selectionEnd > this._getActualInputLength()) {
             el.selectionEnd = this._getActualInputLength();
         }
     }
     // eslint-disable-next-line complexity
     onKeyDown(e) {
-        var _a;
+        var _a, _b;
         if (!this._maskValue) {
             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);
+            return;
+        }
         this._code = e.code ? e.code : e.key;
         const el = e.target;
         this._inputValue = el.value;
         this._setMask();
-        if (e.keyCode === 38) {
-            e.preventDefault();
-        }
-        if (e.keyCode === 37 || e.keyCode === 8 || e.keyCode === 46) {
-            if (e.keyCode === 8 && el.value.length === 0) {
-                el.selectionStart = el.selectionEnd;
-            }
-            if (e.keyCode === 8 && el.selectionStart !== 0) {
-                // If specialChars is false, (shouldn't ever happen) then set to the defaults
-                this.specialCharacters = ((_a = this.specialCharacters) === null || _a === void 0 ? void 0 : _a.length)
-                    ? this.specialCharacters
-                    : this._config.specialCharacters;
-                if (this.prefix.length > 1 && el.selectionStart <= this.prefix.length) {
-                    el.setSelectionRange(this.prefix.length, el.selectionEnd);
+        if (el.type !== 'number') {
+            if (e.key === "ArrowUp" /* 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) {
+                    el.selectionStart = el.selectionEnd;
                 }
-                else {
-                    if (this._inputValue.length !== el.selectionStart &&
-                        el.selectionStart !== 1) {
-                        while (this.specialCharacters.includes(this._inputValue[el.selectionStart - 1].toString()) &&
-                            ((this.prefix.length >= 1 && el.selectionStart > this.prefix.length) ||
-                                this.prefix.length === 0)) {
-                            el.setSelectionRange(el.selectionStart - 1, el.selectionEnd);
+                if (e.key === "Backspace" /* MaskExpression.BACKSPACE */ && el.selectionStart !== 0) {
+                    // If specialChars is false, (shouldn't ever happen) then set to the defaults
+                    this.specialCharacters = ((_a = this.specialCharacters) === null || _a === void 0 ? void 0 : _a.length)
+                        ? this.specialCharacters
+                        : this._config.specialCharacters;
+                    if (this.prefix.length > 1 &&
+                        el.selectionStart <= this.prefix.length) {
+                        el.setSelectionRange(this.prefix.length, el.selectionEnd);
+                    }
+                    else {
+                        if (this._inputValue.length !== el.selectionStart &&
+                            el.selectionStart !== 1) {
+                            while (this.specialCharacters.includes(((_b = this._inputValue[el.selectionStart - 1]) !== null && _b !== void 0 ? _b : "" /* MaskExpression.EMPTY_STRING */).toString()) &&
+                                ((this.prefix.length >= 1 &&
+                                    el.selectionStart > this.prefix.length) ||
+                                    this.prefix.length === 0)) {
+                                el.setSelectionRange(el.selectionStart - 1, el.selectionEnd);
+                            }
                         }
                     }
                 }
+                this.checkSelectionOnDeletion(el);
+                if (this._maskService.prefix.length &&
+                    el.selectionStart <= this._maskService.prefix.length &&
+                    el.selectionEnd <= this._maskService.prefix.length) {
+                    e.preventDefault();
+                }
+                const cursorStart = el.selectionStart;
+                if (e.key === "Backspace" /* MaskExpression.BACKSPACE */ &&
+                    !el.readOnly &&
+                    cursorStart === 0 &&
+                    el.selectionEnd === el.value.length &&
+                    el.value.length !== 0) {
+                    this._position = this._maskService.prefix ? this._maskService.prefix.length : 0;
+                    this._maskService.applyMask(this._maskService.prefix, this._maskService.maskExpression, this._position);
+                }
             }
-            this.checkSelectionOnDeletion(el);
-            if (this._maskService.prefix.length &&
-                el.selectionStart <= this._maskService.prefix.length &&
-                el.selectionEnd <= this._maskService.prefix.length) {
-                e.preventDefault();
+            if (!!this.suffix &&
+                this.suffix.length > 1 &&
+                this._inputValue.length - this.suffix.length < el.selectionStart) {
+                el.setSelectionRange(this._inputValue.length - this.suffix.length, this._inputValue.length);
             }
-            const cursorStart = el.selectionStart;
-            if (e.keyCode === 8 &&
-                !el.readOnly &&
-                cursorStart === 0 &&
-                el.selectionEnd === el.value.length &&
-                el.value.length !== 0) {
-                this._position = this._maskService.prefix ? this._maskService.prefix.length : 0;
-                this._maskService.applyMask(this._maskService.prefix, this._maskService.maskExpression, this._position);
+            else if ((e.code === 'KeyA' && e.ctrlKey) ||
+                (e.code === 'KeyA' && e.metaKey) // Cmd + A (Mac)
+            ) {
+                el.setSelectionRange(0, this._getActualInputLength());
+                e.preventDefault();
             }
+            this._maskService.selStart = el.selectionStart;
+            this._maskService.selEnd = el.selectionEnd;
         }
-        if (!!this.suffix &&
-            this.suffix.length > 1 &&
-            this._inputValue.length - this.suffix.length < el.selectionStart) {
-            el.setSelectionRange(this._inputValue.length - this.suffix.length, this._inputValue.length);
-        }
-        else if ((e.keyCode === 65 && e.ctrlKey) ||
-            (e.keyCode === 65 && e.metaKey) // Cmd + A (Mac)
-        ) {
-            el.setSelectionRange(0, this._getActualInputLength());
-            e.preventDefault();
-        }
-        this._maskService.selStart = el.selectionStart;
-        this._maskService.selEnd = el.selectionEnd;
     }
     /** It writes the value in the input */
-    writeValue(inputValue) {
+    writeValue(controlValue) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (typeof inputValue === 'object' && inputValue !== null && 'value' in inputValue) {
-                if ('disable' in inputValue) {
-                    this.setDisabledState(Boolean(inputValue.disable));
+            if (typeof controlValue === 'object' && controlValue !== null && 'value' in controlValue) {
+                if ('disable' in controlValue) {
+                    this.setDisabledState(Boolean(controlValue.disable));
                 }
                 // eslint-disable-next-line no-param-reassign
-                inputValue = inputValue.value;
+                controlValue = controlValue.value;
             }
-            if (typeof inputValue === 'number' || this._maskValue.startsWith('separator')) {
+            if (controlValue !== null) {
                 // eslint-disable-next-line no-param-reassign
-                inputValue = this._maskService.numberToString(inputValue);
-                if (!Array.isArray(this.decimalMarker)) {
-                    // eslint-disable-next-line no-param-reassign
-                    inputValue =
-                        this.decimalMarker !== '.' ? inputValue.replace('.', this.decimalMarker) : inputValue;
-                }
-                this._maskService.isNumberValue = true;
+                controlValue = this.inputTransformFn
+                    ? this.inputTransformFn(controlValue)
+                    : controlValue;
             }
-            if (typeof inputValue !== 'string') {
+            if (typeof controlValue === 'string' ||
+                typeof controlValue === 'number' ||
+                controlValue === null) {
                 // eslint-disable-next-line no-param-reassign
-                inputValue = '';
-            }
-            this._inputValue = inputValue;
-            this._setMask();
-            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 wont happen during applyMask
-                this._maskService.writingValue = true;
-                this._maskService.formElementProperty = [
-                    'value',
-                    this._maskService.applyMask(inputValue, this._maskService.maskExpression),
-                ];
-                // Let the service know we've finished writing value
-                this._maskService.writingValue = false;
+                let inputValue = controlValue;
+                if (typeof inputValue === 'number' ||
+                    this._maskValue.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+                    // eslint-disable-next-line no-param-reassign
+                    inputValue = String(inputValue);
+                    const localeDecimalMarker = this._maskService.currentLocaleDecimalMarker();
+                    if (!Array.isArray(this._maskService.decimalMarker)) {
+                        // eslint-disable-next-line no-param-reassign
+                        inputValue =
+                            this._maskService.decimalMarker !== localeDecimalMarker
+                                ? inputValue.replace(localeDecimalMarker, this._maskService.decimalMarker)
+                                : inputValue;
+                    }
+                    if (this._maskService.leadZero &&
+                        inputValue &&
+                        this.maskExpression &&
+                        this.dropSpecialCharacters !== false) {
+                        // eslint-disable-next-line no-param-reassign
+                        inputValue = this._maskService._checkPrecision(this._maskService.maskExpression, inputValue);
+                    }
+                    if (this._maskService.decimalMarker === "," /* MaskExpression.COMMA */) {
+                        // eslint-disable-next-line no-param-reassign
+                        inputValue = inputValue
+                            .toString()
+                            .replace("." /* MaskExpression.DOT */, "," /* MaskExpression.COMMA */);
+                    }
+                    if (((_a = this.maskExpression) === null || _a === void 0 ? void 0 : _a.startsWith("separator" /* MaskExpression.SEPARATOR */)) && this.leadZero) {
+                        requestAnimationFrame(() => {
+                            var _a;
+                            this._maskService.applyMask((_a = inputValue === null || inputValue === void 0 ? void 0 : inputValue.toString()) !== null && _a !== void 0 ? _a : '', this._maskService.maskExpression);
+                        });
+                    }
+                    this._maskService.isNumberValue = true;
+                }
+                if (typeof inputValue !== 'string') {
+                    // eslint-disable-next-line no-param-reassign
+                    inputValue = '';
+                }
+                this._inputValue = inputValue;
+                this._setMask();
+                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
+                    typeof this.inputTransformFn !== 'function'
+                        ? (this._maskService.writingValue = true)
+                        : '';
+                    this._maskService.formElementProperty = [
+                        'value',
+                        this._maskService.applyMask(inputValue, this._maskService.maskExpression),
+                    ];
+                    // Let the service know we've finished writing value
+                    typeof this.inputTransformFn !== 'function'
+                        ? (this._maskService.writingValue = false)
+                        : '';
+                }
+                else {
+                    this._maskService.formElementProperty = ['value', inputValue];
+                }
+                this._inputValue = inputValue;
             }
             else {
-                this._maskService.formElementProperty = ['value', inputValue];
+                console.warn('Ngx-mask writeValue work with string | number, your current value:', typeof controlValue);
             }
-            this._inputValue = inputValue;
         });
     }
     registerOnChange(fn) {
@@ -1436,34 +2058,23 @@ class MaskDirective {
     setDisabledState(isDisabled) {
         this._maskService.formElementProperty = ['disabled', isDisabled];
     }
-    _repeatPatternSymbols(maskExp) {
-        return ((maskExp.match(/{[0-9]+}/) &&
-            maskExp.split('').reduce((accum, currval, index) => {
-                this._start = currval === '{' ? index : this._start;
-                if (currval !== '}') {
-                    return this._maskService._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]);
-                return accum + replaceWith;
-            }, '')) ||
-            maskExp);
-    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     _applyMask() {
-        this._maskService.maskExpression = this._repeatPatternSymbols(this._maskValue || '');
+        this._maskService.maskExpression = this._maskService._repeatPatternSymbols(this._maskValue || '');
         this._maskService.formElementProperty = [
             'value',
             this._maskService.applyMask(this._inputValue, this._maskService.maskExpression),
         ];
     }
     _validateTime(value) {
-        const rowMaskLen = this._maskValue.split('').filter((s) => s !== ':').length;
+        var _a;
+        const rowMaskLen = this._maskValue
+            .split("" /* MaskExpression.EMPTY_STRING */)
+            .filter((s) => s !== ':').length;
         if (!value) {
             return null; // Don't validate empty values to allow for optional form control
         }
-        if ((+value[value.length - 1] === 0 && value.length < rowMaskLen) ||
+        if ((+((_a = value[value.length - 1]) !== null && _a !== void 0 ? _a : -1) === 0 && value.length < rowMaskLen) ||
             value.length <= rowMaskLen - 2) {
             return this._createValidationError(value);
         }
@@ -1482,69 +2093,82 @@ class MaskDirective {
         };
     }
     _setMask() {
-        if (this._maskExpressionArray.length > 0) {
-            this._maskExpressionArray.some((mask) => {
-                var _a, _b;
+        this._maskExpressionArray.some((mask) => {
+            var _a, _b, _c, _d;
+            const specialChart = mask
+                .split("" /* MaskExpression.EMPTY_STRING */)
+                .some((char) => this._maskService.specialCharacters.includes(char));
+            if ((specialChart && this._inputValue && !mask.includes("S" /* MaskExpression.LETTER_S */)) ||
+                mask.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)) {
                 const test = ((_a = this._maskService.removeMask(this._inputValue)) === null || _a === void 0 ? void 0 : _a.length) <=
                     ((_b = this._maskService.removeMask(mask)) === null || _b === void 0 ? void 0 : _b.length);
-                if (this._inputValue && test) {
-                    this._maskValue = mask;
-                    this.maskExpression = mask;
-                    this._maskService.maskExpression = mask;
+                if (test) {
+                    this._maskValue =
+                        this.maskExpression =
+                            this._maskService.maskExpression =
+                                mask.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)
+                                    ? this._maskService._repeatPatternSymbols(mask)
+                                    : mask;
                     return test;
                 }
                 else {
-                    this._maskValue = this._maskExpressionArray[this._maskExpressionArray.length - 1];
-                    this.maskExpression = this._maskExpressionArray[this._maskExpressionArray.length - 1];
-                    this._maskService.maskExpression =
-                        this._maskExpressionArray[this._maskExpressionArray.length - 1];
+                    const expression = (_c = this._maskExpressionArray[this._maskExpressionArray.length - 1]) !== null && _c !== void 0 ? _c : "" /* MaskExpression.EMPTY_STRING */;
+                    this._maskValue =
+                        this.maskExpression =
+                            this._maskService.maskExpression =
+                                expression.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)
+                                    ? this._maskService._repeatPatternSymbols(expression)
+                                    : expression;
                 }
-            });
-        }
+            }
+            else {
+                const check = (_d = this._inputValue) === null || _d === void 0 ? void 0 : _d.split("" /* MaskExpression.EMPTY_STRING */).every((character, index) => {
+                    const indexMask = mask.charAt(index);
+                    return this._maskService._checkSymbolMask(character, indexMask);
+                });
+                if (check) {
+                    this._maskValue = this.maskExpression = this._maskService.maskExpression = mask;
+                    return check;
+                }
+            }
+        });
     }
 }
-MaskDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskDirective, deps: [{ token: DOCUMENT }, { token: MaskService }, { token: config }], target: i0.ɵɵFactoryTarget.Directive });
-MaskDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.1", type: MaskDirective, 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", triggerOnMaskChange: "triggerOnMaskChange" }, outputs: { maskFilled: "maskFilled" }, host: { listeners: { "paste": "onPaste()", "ngModelChange": "onModelChange($event)", "input": "onInput($event)", "blur": "onBlur()", "click": "onClick($event)", "keydown": "onKeyDown($event)" } }, providers: [
+NgxMaskDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+NgxMaskDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", 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()", "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: forwardRef(() => MaskDirective),
+            useExisting: NgxMaskDirective,
             multi: true,
         },
         {
             provide: NG_VALIDATORS,
-            useExisting: forwardRef(() => MaskDirective),
+            useExisting: NgxMaskDirective,
             multi: true,
         },
-        MaskService,
+        NgxMaskService,
     ], exportAs: ["mask", "ngxMask"], usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: 'input[mask], textarea[mask]',
+                    standalone: true,
                     providers: [
                         {
                             provide: NG_VALUE_ACCESSOR,
-                            useExisting: forwardRef(() => MaskDirective),
+                            useExisting: NgxMaskDirective,
                             multi: true,
                         },
                         {
                             provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => MaskDirective),
+                            useExisting: NgxMaskDirective,
                             multi: true,
                         },
-                        MaskService,
+                        NgxMaskService,
                     ],
                     exportAs: 'mask,ngxMask',
                 }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [DOCUMENT]
-                    }] }, { type: MaskService }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [config]
-                    }] }];
-    }, propDecorators: { maskExpression: [{
+        }], propDecorators: { maskExpression: [{
                 type: Input,
                 args: ['mask']
             }], specialCharacters: [{
@@ -1581,8 +2205,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImpor
                 type: Input
             }], leadZeroDateTime: [{
                 type: Input
+            }], leadZero: [{
+                type: Input
             }], triggerOnMaskChange: [{
                 type: Input
+            }], apm: [{
+                type: Input
+            }], inputTransformFn: [{
+                type: Input
+            }], outputTransformFn: [{
+                type: Input
+            }], keepCharacterPositions: [{
+                type: Input
             }], maskFilled: [{
                 type: Output
             }], onPaste: [{
@@ -1594,9 +2228,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImpor
             }], onInput: [{
                 type: HostListener,
                 args: ['input', ['$event']]
+            }], onCompositionStart: [{
+                type: HostListener,
+                args: ['compositionstart', ['$event']]
+            }], onCompositionEnd: [{
+                type: HostListener,
+                args: ['compositionend', ['$event']]
             }], onBlur: [{
                 type: HostListener,
-                args: ['blur']
+                args: ['blur', ['$event']]
             }], onClick: [{
                 type: HostListener,
                 args: ['click', ['$event']]
@@ -1605,97 +2245,103 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImpor
                 args: ['keydown', ['$event']]
             }] } });
 
-class MaskPipe {
-    constructor(_maskService) {
-        this._maskService = _maskService;
+class NgxMaskPipe {
+    constructor() {
+        this.defaultOptions = {};
+        this._maskService = inject(NgxMaskService);
+        this._maskExpressionArray = [];
+        this.mask = '';
     }
-    transform(value, mask, thousandSeparator = null) {
-        if (!value && typeof value !== 'number') {
-            return '';
+    transform(value, mask, _a = {}) {
+        var { patterns } = _a, config = __rest(_a, ["patterns"]);
+        const currentConfig = Object.assign(Object.assign(Object.assign({ maskExpression: mask }, this.defaultOptions), config), { patterns: Object.assign(Object.assign({}, this._maskService.patterns), patterns) });
+        Object.entries(currentConfig).forEach(([key, value]) => {
+            //eslint-disable-next-line  @typescript-eslint/no-explicit-any
+            this._maskService[key] = value;
+        });
+        if (mask.includes('||')) {
+            if (mask.split('||').length > 1) {
+                this._maskExpressionArray = mask.split('||').sort((a, b) => {
+                    return a.length - b.length;
+                });
+                this._setMask(value);
+                return this._maskService.applyMask(`${value}`, this.mask);
+            }
+            else {
+                this._maskExpressionArray = [];
+                return this._maskService.applyMask(`${value}`, this.mask);
+            }
         }
-        if (thousandSeparator) {
-            this._maskService.thousandSeparator = thousandSeparator;
+        if (mask.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)) {
+            return this._maskService.applyMask(`${value}`, this._maskService._repeatPatternSymbols(mask));
         }
-        if (typeof mask === 'string') {
-            return this._maskService.applyMask(`${value}`, mask);
+        if (mask.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+            if (config.decimalMarker) {
+                this._maskService.decimalMarker = config.decimalMarker;
+            }
+            if (config.thousandSeparator) {
+                this._maskService.thousandSeparator = config.thousandSeparator;
+            }
+            if (config.leadZero) {
+                // eslint-disable-next-line no-param-reassign
+                this._maskService.leadZero = config.leadZero;
+            }
+            // eslint-disable-next-line no-param-reassign
+            value = String(value);
+            const localeDecimalMarker = this._maskService.currentLocaleDecimalMarker();
+            if (!Array.isArray(this._maskService.decimalMarker)) {
+                // eslint-disable-next-line no-param-reassign
+                value =
+                    this._maskService.decimalMarker !== localeDecimalMarker
+                        ? value.replace(localeDecimalMarker, this._maskService.decimalMarker)
+                        : value;
+            }
+            if (this._maskService.leadZero &&
+                value &&
+                this._maskService.dropSpecialCharacters !== false) {
+                // eslint-disable-next-line no-param-reassign
+                value = this._maskService._checkPrecision(mask, value);
+            }
+            if (this._maskService.decimalMarker === "," /* MaskExpression.COMMA */) {
+                // eslint-disable-next-line no-param-reassign
+                value = value.toString().replace("." /* MaskExpression.DOT */, "," /* MaskExpression.COMMA */);
+            }
+            this._maskService.isNumberValue = true;
+        }
+        return this._maskService.applyMask(`${value}`, mask);
+    }
+    _setMask(value) {
+        if (this._maskExpressionArray.length > 0) {
+            this._maskExpressionArray.some((mask) => {
+                var _a, _b, _c;
+                const test = ((_a = this._maskService.removeMask(value)) === null || _a === void 0 ? void 0 : _a.length) <=
+                    ((_b = this._maskService.removeMask(mask)) === null || _b === void 0 ? void 0 : _b.length);
+                if (value && test) {
+                    this.mask = mask;
+                    return test;
+                }
+                else {
+                    const expression = (_c = this._maskExpressionArray[this._maskExpressionArray.length - 1]) !== null && _c !== void 0 ? _c : "" /* MaskExpression.EMPTY_STRING */;
+                    this.mask = expression;
+                }
+            });
         }
-        return this._maskService.applyMaskWithPattern(`${value}`, mask);
     }
 }
-MaskPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskPipe, deps: [{ token: MaskApplierService }], target: i0.ɵɵFactoryTarget.Pipe });
-MaskPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.2.1", ngImport: i0, type: MaskPipe, name: "mask" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: MaskPipe, decorators: [{
+NgxMaskPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+NgxMaskPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskPipe, isStandalone: true, name: "mask" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgxMaskPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'mask',
                     pure: true,
-                }]
-        }], ctorParameters: function () { return [{ type: MaskApplierService }]; } });
-
-/**
- * @internal
- */
-function _configFactory(initConfig, configValue) {
-    return configValue instanceof Function
-        ? Object.assign(Object.assign({}, initConfig), configValue()) : Object.assign(Object.assign({}, initConfig), configValue);
-}
-class NgxMaskModule {
-    static forRoot(configValue) {
-        return {
-            ngModule: NgxMaskModule,
-            providers: [
-                {
-                    provide: NEW_CONFIG,
-                    useValue: configValue,
-                },
-                {
-                    provide: INITIAL_CONFIG,
-                    useValue: initialConfig,
-                },
-                {
-                    provide: config,
-                    useFactory: _configFactory,
-                    deps: [INITIAL_CONFIG, NEW_CONFIG],
-                },
-                MaskApplierService,
-            ],
-        };
-    }
-    static forChild() {
-        return {
-            ngModule: NgxMaskModule,
-        };
-    }
-}
-NgxMaskModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: NgxMaskModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-NgxMaskModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.1", ngImport: i0, type: NgxMaskModule, declarations: [MaskDirective, MaskPipe], exports: [MaskDirective, MaskPipe] });
-NgxMaskModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: NgxMaskModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: NgxMaskModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    exports: [MaskDirective, MaskPipe],
-                    declarations: [MaskDirective, MaskPipe],
+                    standalone: true,
                 }]
         }] });
 
-const commonjsGlobal = typeof globalThis !== 'undefined'
-    ? globalThis
-    : typeof window !== 'undefined'
-        ? window
-        : typeof global !== 'undefined'
-            ? global
-            : typeof self !== 'undefined'
-                ? self
-                : {};
-(function () {
-    if (!commonjsGlobal.KeyboardEvent) {
-        commonjsGlobal.KeyboardEvent = function (_eventType, _init) { };
-    }
-})();
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { INITIAL_CONFIG, MaskApplierService, MaskDirective, MaskPipe, MaskService, NEW_CONFIG, NgxMaskModule, _configFactory, config, initialConfig, timeMasks, withoutValidation };
+export { INITIAL_CONFIG, NEW_CONFIG, NGX_MASK_CONFIG, NgxMaskDirective, NgxMaskPipe, NgxMaskService, initialConfig, provideEnvironmentNgxMask, provideNgxMask, timeMasks, withoutValidation };
 //# sourceMappingURL=ngx-mask.mjs.map