ngx-mask 21.0.0 → 21.1.0

package/fesm2022/ngx-mask.mjs

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, EventEmitter, inject, Injectable, ElementRef, Renderer2, makeEnvironmentProviders, input, model, output, signal, effect, untracked, HostListener, Directive, Pipe } from '@angular/core';
+import { InjectionToken, EventEmitter, inject, Injectable, signal, ElementRef, Renderer2, makeEnvironmentProviders, input, model, booleanAttribute, output, ChangeDetectorRef, Injector, effect, untracked, HostListener, Directive, Pipe } from '@angular/core';
 import { DOCUMENT } from '@angular/common';
-import { NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';
+import { NgControl, NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';
 
 var MaskExpression;
 (function (MaskExpression) {
@@ -9,6 +9,7 @@ var MaskExpression;
     MaskExpression["PERCENT"] = "percent";
     MaskExpression["IP"] = "IP";
     MaskExpression["CPF_CNPJ"] = "CPF_CNPJ";
+    MaskExpression["CPF_CNPJ_ALPHA"] = "CPF_CNPJ_ALPHA";
     MaskExpression["MONTH"] = "M";
     MaskExpression["MONTHS"] = "M0";
     MaskExpression["MINUTE"] = "m";
@@ -168,6 +169,11 @@ class NgxMaskApplierService {
     showKeepCharacterExp = '';
     shownMaskExpression = this._config.shownMaskExpression;
     deletedSpecialCharacter = false;
+    /**
+     * Whether we are currently in writeValue function, in this case when applying the mask we don't want to trigger onChange function,
+     * since writeValue should be a one way only process of writing the DOM value based on the Angular model value.
+     */
+    writingValue = false;
     ipError;
     cpfCnpjError;
     applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, 
@@ -185,9 +191,16 @@ class NgxMaskApplierService {
         let processedValue = inputValue;
         let processedPosition = position;
         const startsWithPrefix = processedValue.slice(0, this.prefix.length) === this.prefix;
-        const pastedFullWithPrefix = justPasted && processedValue.length === this.prefix.length + maskExpression.length;
-        const looksLikeFullPrefixPaste = processedValue === this.prefix + processedValue.slice(this.prefix.length);
-        if (startsWithPrefix && (pastedFullWithPrefix || looksLikeFullPrefixPaste)) {
+        // On paste with showMaskTyped, NgxMaskService.applyMask has already removed the
+        // prefix via removeMask() before delegating here (unless the value consisted of
+        // the prefix alone, in which case the raw value falls through). Stripping again
+        // would eat leading characters that merely look like the prefix (#1551).
+        const prefixAlreadyRemovedByCaller = justPasted &&
+            this.showMaskTyped &&
+            this.placeHolderCharacter.length === 1 &&
+            !this.leadZeroDateTime &&
+            processedValue !== this.prefix;
+        if (startsWithPrefix && !prefixAlreadyRemovedByCaller) {
             processedValue = processedValue.slice(this.prefix.length);
         }
         if (!!this.suffix && processedValue.length > 0) {
@@ -214,11 +227,17 @@ class NgxMaskApplierService {
                 arr.push(processedValue[i] ?? MaskExpression.EMPTY_STRING);
             }
         }
-        if (maskExpression === MaskExpression.CPF_CNPJ) {
+        const isCpfCnpjAlpha = maskExpression === MaskExpression.CPF_CNPJ_ALPHA;
+        if (maskExpression === MaskExpression.CPF_CNPJ || isCpfCnpjAlpha) {
             this.cpfCnpjError = arr.length !== 11 && arr.length !== 14;
-            if (arr.length > 11) {
+            const valueHasAnyLetter = /[a-zA-Z]/.test(processedValue);
+            if (valueHasAnyLetter && isCpfCnpjAlpha) {
                 // eslint-disable-next-line no-param-reassign
-                maskExpression = '00.000.000/0000-00';
+                maskExpression = 'AA.AAA.AAA/AAAA-00';
+            }
+            else if (arr.length > 11) {
+                // eslint-disable-next-line no-param-reassign
+                maskExpression = isCpfCnpjAlpha ? 'AA.AAA.AAA/AAAA-00' : '00.000.000/0000-00';
             }
             else {
                 // eslint-disable-next-line no-param-reassign
@@ -278,15 +297,38 @@ class NgxMaskApplierService {
                     decimalMarker = this.decimalMarker.find((dm) => dm !== this.thousandSeparator);
                 }
             }
+            // Issue #1547: a pasted value may contain grouping separators that are
+            // also configured decimal markers (default decimalMarker is ['.', ',']),
+            // e.g. '1,234.56'. Only the last marker character can actually be the
+            // decimal marker — treat the earlier ones as thousand separators and
+            // strip them, otherwise formatting cuts the value off at the first one.
+            if (justPasted && Array.isArray(this.decimalMarker)) {
+                const markerPositions = [];
+                for (let i = 0; i < processedValue.length; i++) {
+                    const char = processedValue[i];
+                    if (char !== this.thousandSeparator &&
+                        this.decimalMarker.includes(char)) {
+                        markerPositions.push(i);
+                    }
+                }
+                if (markerPositions.length > 1) {
+                    const lastMarkerPosition = markerPositions[markerPositions.length - 1];
+                    processedValue = processedValue
+                        .split(MaskExpression.EMPTY_STRING)
+                        .filter((_, index) => index === lastMarkerPosition || !markerPositions.includes(index))
+                        .join(MaskExpression.EMPTY_STRING);
+                }
+            }
             if (backspaced) {
                 const { decimalMarkerIndex, nonZeroIndex } = this._findFirstNonZeroAndDecimalIndex(processedValue, decimalMarker);
                 const zeroIndexMinus = processedValue[0] === MaskExpression.MINUS;
-                const zeroIndexNumberZero = processedValue[0] === MaskExpression.NUMBER_ZERO;
                 const zeroIndexDecimalMarker = processedValue[0] === decimalMarker;
                 const firstIndexDecimalMarker = processedValue[1] === decimalMarker;
+                // Issues #1355/#1578: an all-zero remainder (e.g. '00' from '500', '00,000'
+                // from '100,000') must keep its zeros, matching the ',000,000' case.
+                // Only collapse when nothing but a bare decimal marker (or '-.') remains.
                 if ((zeroIndexDecimalMarker && !nonZeroIndex) ||
-                    (zeroIndexMinus && firstIndexDecimalMarker && !nonZeroIndex) ||
-                    (zeroIndexNumberZero && !decimalMarkerIndex && !nonZeroIndex)) {
+                    (zeroIndexMinus && firstIndexDecimalMarker && !nonZeroIndex)) {
                     processedValue = MaskExpression.NUMBER_ZERO;
                 }
                 if (decimalMarkerIndex &&
@@ -297,7 +339,12 @@ class NgxMaskApplierService {
                         processedValue = MaskExpression.MINUS + processedValue.slice(nonZeroIndex);
                     }
                 }
-                if (!decimalMarkerIndex && nonZeroIndex && processedValue.length > nonZeroIndex) {
+                // Issue #1516: decimalMarkerIndex is 0 when the remainder starts with
+                // the decimal marker (',34' after deleting the integer part) — a truthy
+                // check would treat it as "no decimal marker" and slice the marker off.
+                if (decimalMarkerIndex === null &&
+                    nonZeroIndex &&
+                    processedValue.length > nonZeroIndex) {
                     processedValue = zeroIndexMinus
                         ? MaskExpression.MINUS + processedValue.slice(nonZeroIndex)
                         : processedValue.slice(nonZeroIndex);
@@ -311,7 +358,10 @@ class NgxMaskApplierService {
                     }
                 }
             }
-            if (precision === 0) {
+            // Leading-zero stripping is a typing-time rule ('05' -> '5'). When backspaced,
+            // leading zeros before a non-zero digit were already removed above, and an
+            // all-zero remainder must keep its zeros (issues #1355/#1578).
+            if (precision === 0 && !backspaced) {
                 processedValue = this.allowNegativeNumbers
                     ? processedValue.length > 2 &&
                         processedValue[0] === MaskExpression.MINUS &&
@@ -531,23 +581,39 @@ class NgxMaskApplierService {
                     const inputValueSliceMinusOnePlusOne = processedValue.slice(cursor - 1, cursor + 1);
                     const inputValueSliceCursorPlusTwo = processedValue.slice(cursor, cursor + 2);
                     const inputValueSliceMinusTwoCursor = processedValue.slice(cursor - 2, cursor);
+                    // Issue #1523: when the date token directly abuts a plain digit
+                    // token (year-first masks without separators like 00M0d0 or
+                    // 0000M0d0), the backward-looking windows below read the previous
+                    // field's digits (year) as day/month digits and skip valid input.
+                    // Disable only those backward heuristics in that layout.
+                    const tokenAbutsDigitField = maskExpression[cursor - 1] === MaskExpression.NUMBER_ZERO;
                     if (maskExpression[cursor] === MaskExpression.DAY) {
                         const maskStartWithMonth = maskExpression.slice(0, 2) === MaskExpression.MONTHS;
                         const startWithMonthInput = maskExpression.slice(0, 2) === MaskExpression.MONTHS &&
                             this.specialCharacters.includes(inputValueCursorMinusTwo);
+                        // Issue #1611: `cursor` indexes the mask, `i` indexes the input.
+                        // On paste/writeValue of a bare digit string the cursor runs
+                        // ahead of the input by every emitted separator, so cursor-based
+                        // slices read year digits instead of the day — anchor the day
+                        // window on the input index in those flows. Keystroke flows keep
+                        // the historical cursor anchor (with showMaskTyped the value also
+                        // carries placeholder chars, where the input anchor misreads).
+                        const dayWindowStart = justPasted || this.writingValue ? i : cursor;
+                        const dayWindowSlice = processedValue.slice(dayWindowStart, dayWindowStart + 2);
+                        const dayWindowNext = processedValue[dayWindowStart + 1];
                         if ((Number(inputSymbol) > 3 && this.leadZeroDateTime) ||
                             (!maskStartWithMonth &&
                                 (Number(inputValueSliceCursorPlusTwo) > daysCount ||
-                                    Number(inputValueSliceMinusOnePlusOne) > daysCount ||
+                                    (!tokenAbutsDigitField &&
+                                        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) &&
-                                        !backspaced))) {
+                                : Number(dayWindowSlice) > daysCount ||
+                                    (this.specialCharacters.includes(dayWindowNext) && !backspaced))) {
                             processedPosition = !this.leadZeroDateTime
                                 ? processedPosition + 1
                                 : processedPosition;
@@ -577,7 +643,8 @@ class NgxMaskApplierService {
                                 !this.specialCharacters.includes(inputValueCursor)) ||
                                 this.specialCharacters.includes(inputValueCursor));
                         //  month<12 && day<10 for input
-                        const day2monthInput = Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&
+                        const day2monthInput = !tokenAbutsDigitField &&
+                            Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&
                             !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
                             this.specialCharacters.includes(inputValueCursorMinusOne) &&
                             (Number(inputValueSliceCursorPlusTwo) > monthsCount ||
@@ -587,13 +654,15 @@ class NgxMaskApplierService {
                             (this.specialCharacters.includes(inputValueCursorPlusOne) &&
                                 cursor === 5);
                         // // day<10 && month<12 for paste whole data
-                        const day1monthPaste = Number(inputValueSliceMinusThreeMinusOne) > daysCount &&
+                        const day1monthPaste = !tokenAbutsDigitField &&
+                            Number(inputValueSliceMinusThreeMinusOne) > daysCount &&
                             !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
                             !this.specialCharacters.includes(inputValueSliceMinusTwoCursor) &&
                             Number(inputValueSliceMinusTwoCursor) > monthsCount &&
                             maskExpression.includes('d0');
                         // 10<day<31 && month<12 for paste whole data
-                        const day2monthPaste = Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&
+                        const day2monthPaste = !tokenAbutsDigitField &&
+                            Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&
                             !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
                             !this.specialCharacters.includes(inputValueCursorMinusOne) &&
                             Number(inputValueSliceMinusOnePlusOne) > monthsCount;
@@ -636,6 +705,12 @@ class NgxMaskApplierService {
                 }
                 else if (this.patterns[maskExpression[cursor] ?? MaskExpression.EMPTY_STRING] &&
                     this.patterns[maskExpression[cursor] ?? MaskExpression.EMPTY_STRING]?.optional) {
+                    // If the input symbol is whitespace or doesn't match the pattern,
+                    // skip it without consuming the mask position
+                    if (inputSymbol.trim() === MaskExpression.EMPTY_STRING) {
+                        // Skip whitespace input, don't advance mask cursor
+                        continue;
+                    }
                     if (!!inputArray[cursor] &&
                         maskExpression !== '099.099.099.099' &&
                         maskExpression !== '000.000.000-00' &&
@@ -653,15 +728,22 @@ class NgxMaskApplierService {
                     i--;
                 }
                 else if (this.maskExpression[cursor + 1] === MaskExpression.SYMBOL_STAR &&
-                    this._findSpecialChar(this.maskExpression[cursor + 2] ?? MaskExpression.EMPTY_STRING) &&
-                    this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&
+                    // A typed char that exactly matches the mask's literal char at cursor+2
+                    // (e.g. the '@' in 'A*@A*.A*') always terminates the 'A*' run, regardless
+                    // of whether that literal is registered in `specialCharacters` — an
+                    // explicitly empty `specialCharacters` list must not make mask literals
+                    // unmatchable (#1512).
+                    (this._findSpecialChar(this.maskExpression[cursor + 2] ?? MaskExpression.EMPTY_STRING)
+                        ? this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2]
+                        : inputSymbol === this.maskExpression[cursor + 2]) &&
                     multi) {
                     cursor += 3;
                     result += inputSymbol;
                 }
                 else if (this.maskExpression[cursor + 1] === MaskExpression.SYMBOL_QUESTION &&
-                    this._findSpecialChar(this.maskExpression[cursor + 2] ?? MaskExpression.EMPTY_STRING) &&
-                    this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&
+                    (this._findSpecialChar(this.maskExpression[cursor + 2] ?? MaskExpression.EMPTY_STRING)
+                        ? this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2]
+                        : inputSymbol === this.maskExpression[cursor + 2]) &&
                     multi) {
                     cursor += 3;
                     result += inputSymbol;
@@ -707,9 +789,20 @@ class NgxMaskApplierService {
         const isSpecialCharacterMaskFirstSymbol = processedValue.length === 1 &&
             this.specialCharacters.includes(maskExpression[0]) &&
             processedValue !== maskExpression[0];
-        if (!this._checkSymbolMask(processedValue, maskExpression[1]) &&
-            isSpecialCharacterMaskFirstSymbol) {
-            return '';
+        if (isSpecialCharacterMaskFirstSymbol) {
+            // The mask may start with several literal special characters in a row
+            // (e.g. '+(000) 000-0000'). A single typed character must be checked
+            // against the first PATTERN position of the mask, not literally against
+            // index 1 — otherwise a valid digit is rejected and the leading literals
+            // are never auto-filled (#1498).
+            let firstPatternIndex = 1;
+            while (firstPatternIndex < maskExpression.length &&
+                this.specialCharacters.includes(maskExpression[firstPatternIndex])) {
+                firstPatternIndex++;
+            }
+            if (!this._checkSymbolMask(processedValue, maskExpression[firstPatternIndex] ?? MaskExpression.EMPTY_STRING)) {
+                return '';
+            }
         }
         if (result.includes(MaskExpression.MINUS) && this.prefix && this.allowNegativeNumbers) {
             if (backspaced && result === MaskExpression.MINUS) {
@@ -788,11 +881,21 @@ class NgxMaskApplierService {
     checkAndRemoveSuffix = (inputValue) => {
         for (let i = this.suffix?.length - 1; i >= 0; i--) {
             const substr = this.suffix.substring(i, this.suffix?.length);
-            if (inputValue.includes(substr) &&
+            if (inputValue.endsWith(substr) &&
                 i !== this.suffix?.length - 1 &&
+                // A partial suffix tail (i > 0) that makes up the WHOLE value is a
+                // leftover of the displayed suffix only when the previous rendered
+                // value ended with the suffix AND the edit shrank the value to (or
+                // below) the old value-part length, i.e. it was a deletion of the
+                // suffix head. Otherwise it is fresh user input that merely collides
+                // with the suffix text and must be kept (#1495).
+                (i === 0 ||
+                    inputValue.length > substr.length ||
+                    (this.actualValue.endsWith(this.suffix) &&
+                        inputValue.length <= this.actualValue.length - this.suffix.length)) &&
                 (i - 1 < 0 ||
-                    !inputValue.includes(this.suffix.substring(i - 1, this.suffix?.length)))) {
-                return inputValue.replace(substr, MaskExpression.EMPTY_STRING);
+                    !inputValue.endsWith(this.suffix.substring(i - 1, this.suffix?.length)))) {
+                return inputValue.slice(0, inputValue.length - substr.length);
             }
         }
         return inputValue;
@@ -906,10 +1009,10 @@ class NgxMaskApplierService {
             nonZeroIndex,
         };
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskApplierService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskApplierService });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskApplierService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskApplierService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskApplierService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskApplierService, decorators: [{
             type: Injectable
         }] });
 
@@ -922,12 +1025,20 @@ class NgxMaskService extends NgxMaskApplierService {
     maskExpressionArray = [];
     previousValue = '';
     currentValue = '';
+    // `writingValue` is declared on NgxMaskApplierService: applyMask needs it to
+    // distinguish the writeValue flow from keystroke flows (#1611).
+    isInitialized = false;
     /**
-     * Whether we are currently in writeValue function, in this case when applying the mask we don't want to trigger onChange function,
-     * since writeValue should be a one way only process of writing the DOM value based on the Angular model value.
+     * Set by the directive's keepCharacterPositions handling for the current edit:
+     * true — the directive fully resolved the resulting display value into actualValue,
+     * so applyMask must short-circuit and render actualValue as-is;
+     * false — the edit must flow through regular masking (no short-circuit);
+     * null — the directive was not involved in this applyMask call (legacy behavior).
+     * Consumed and reset by applyMask. This lets keepCharacterPositions work without
+     * showMaskTyped (#1545, #1543).
      */
-    writingValue = false;
-    isInitialized = false;
+    keepCharacterPositionsHandled = null;
+    _isFocused = signal(false, ...(ngDevMode ? [{ debugName: "_isFocused" }] : /* istanbul ignore next */ []));
     _emitValue = false;
     _start;
     _end;
@@ -950,10 +1061,35 @@ class NgxMaskService extends NgxMaskApplierService {
     applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, 
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     cb = () => { }) {
+        // Consume the directive's keepCharacterPositions verdict for this edit (see the
+        // keepCharacterPositionsHandled doc). Reset immediately so it never leaks into
+        // applyMask calls that do not originate from the directive's input handling.
+        const kcpHandled = this.keepCharacterPositionsHandled;
+        this.keepCharacterPositionsHandled = null;
         // If no mask expression, return the input value or the actual value
         if (!maskExpression) {
             return inputValue !== this.actualValue ? this.actualValue : inputValue;
         }
+        // #1492: a numeric FormControl value like 0.0000007 or 1e21 stringifies to
+        // exponential notation ('7e-7'); separator masking would strip the 'e'/'-' and
+        // render garbage ('77'). Expand scientific notation to plain decimal form before
+        // masking. Covers writeValue-driven flows and the pipe; a keystroke value can
+        // never match, since separator masking never lets a letter through.
+        if (maskExpression.startsWith(MaskExpression.SEPARATOR) &&
+            inputValue &&
+            /\d[eE][+-]?\d/.test(inputValue)) {
+            const expandedNumber = Number(this._replaceDecimalMarkerToDot(inputValue));
+            if (!Number.isNaN(expandedNumber)) {
+                // eslint-disable-next-line no-param-reassign
+                inputValue = this._toPlainDecimalString(expandedNumber);
+                if (this.decimalMarker === MaskExpression.COMMA ||
+                    (Array.isArray(this.decimalMarker) &&
+                        this.thousandSeparator === MaskExpression.DOT)) {
+                    // eslint-disable-next-line no-param-reassign
+                    inputValue = inputValue.replace(MaskExpression.DOT, MaskExpression.COMMA);
+                }
+            }
+        }
         // Show mask in input if required
         this.maskIsShown = this.showMaskTyped
             ? this.showMaskInInput()
@@ -962,7 +1098,9 @@ class NgxMaskService extends NgxMaskApplierService {
         if (this.maskExpression === MaskExpression.IP && this.showMaskTyped) {
             this.maskIsShown = this.showMaskInInput(inputValue || MaskExpression.HASH);
         }
-        if (this.maskExpression === MaskExpression.CPF_CNPJ && this.showMaskTyped) {
+        const isCpfCnpjMask = this.maskExpression === MaskExpression.CPF_CNPJ ||
+            this.maskExpression === MaskExpression.CPF_CNPJ_ALPHA;
+        if (isCpfCnpjMask && this.showMaskTyped) {
             this.maskIsShown = this.showMaskInInput(inputValue || MaskExpression.HASH);
         }
         // Handle empty input value with mask typed
@@ -979,7 +1117,11 @@ class NgxMaskService extends NgxMaskApplierService {
         if ((this.hiddenInput ||
             (inputValue && inputValue.indexOf(MaskExpression.SYMBOL_STAR) >= 0)) &&
             !this.writingValue) {
-            let actualResult = inputValue && inputValue.length === 1
+            // Seed from the raw input only when the user typed the FIRST character (the
+            // single char is the raw symbol, actualValue is empty/stale). On backspace a
+            // length-1 value is the remaining masked display (e.g. '*'), so the hidden
+            // characters must come from actualValue or the deletion destroys both (#1612).
+            let actualResult = inputValue && inputValue.length === 1 && !backspaced
                 ? inputValue.split(MaskExpression.EMPTY_STRING)
                 : this.actualValue.split(MaskExpression.EMPTY_STRING);
             // Handle backspace
@@ -1079,8 +1221,10 @@ class NgxMaskService extends NgxMaskApplierService {
             newInputValue =
                 Boolean(newInputValue) && newInputValue.length ? newInputValue : inputValue;
         }
-        // Handle showMaskTyped and keepCharacterPositions
-        if (this.showMaskTyped &&
+        // Handle keepCharacterPositions: when the directive resolved the display for this
+        // edit (kcpHandled === true), or legacily whenever showMaskTyped is on and the
+        // directive gave no explicit verdict, render actualValue as-is.
+        if ((kcpHandled ?? this.showMaskTyped) &&
             this.keepCharacterPositions &&
             this.actualValue &&
             !justPasted &&
@@ -1095,6 +1239,27 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         // Apply the mask using the parent class method
         const result = super.applyMask(newInputValue, maskExpression, newPosition, justPasted, backspaced, cb);
+        // #1615: a value the mask cannot process AT ALL (masking leaves nothing of it) is
+        // rendered verbatim instead of being destroyed, and must not reach formControlResult
+        // — the empty remnant would clobber the model that holds the sentinel (e.g.
+        // setValue('ONGOING') on a digits mask). Values that PARTIALLY match keep regular
+        // masking. Two cases reach this:
+        // 1. this.writingValue: the originating writeValue() call itself.
+        // 2. currentValue === inputValue (and the mask didn't just change): a LATER re-render
+        //    replaying the exact same already-verbatim value outside of writeValue (e.g.
+        //    ngOnChanges re-running applyMask via the directive's _applyMask() when an
+        //    UNRELATED input like `disabled` changes) — without this, that pass would fall
+        //    through to regular masking, emit the empty result via onChange, and clobber the
+        //    model even though the DOM would still show the sentinel correctly.
+        if ((this.writingValue || (!this.maskChanged && inputValue === this.currentValue)) &&
+            inputValue &&
+            !result &&
+            this.removeMask(inputValue)) {
+            this.actualValue = inputValue;
+            this.previousValue = this.currentValue;
+            this.currentValue = inputValue;
+            return inputValue;
+        }
         this.actualValue = this.getActualValue(result);
         // handle some separator implications:
         // a.) adjust decimalMarker default (. -> ,) if thousandSeparator is a dot
@@ -1138,14 +1303,19 @@ class NgxMaskService extends NgxMaskApplierService {
         const resLen = result.length;
         const prefNmask = `${this.prefix}${this.maskIsShown}${this.suffix}`;
         // Handle specific mask expressions
-        if (this.maskExpression.includes(MaskExpression.HOURS)) {
+        // NOTE: IP/CPF_CNPJ/CPF_CNPJ_ALPHA are checked via exact equality BEFORE the HOURS
+        // substring check below, because MaskExpression.HOURS is the single character 'H' and
+        // 'CPF_CNPJ_ALPHA' contains 'H' (from "ALPHA"), which previously caused CPF_CNPJ_ALPHA
+        // to be misrouted into the HOURS branch instead of its own branch.
+        if (this.maskExpression === MaskExpression.IP ||
+            this.maskExpression === MaskExpression.CPF_CNPJ ||
+            this.maskExpression === MaskExpression.CPF_CNPJ_ALPHA) {
+            return `${result}${prefNmask}`;
+        }
+        else if (this.maskExpression.includes(MaskExpression.HOURS)) {
             const countSkipedSymbol = this._numberSkipedSymbols(result);
             return `${result}${prefNmask.slice(resLen + countSkipedSymbol)}`;
         }
-        else if (this.maskExpression === MaskExpression.IP ||
-            this.maskExpression === MaskExpression.CPF_CNPJ) {
-            return `${result}${prefNmask}`;
-        }
         return `${result}${prefNmask.slice(resLen)}`;
     }
     // get the number of characters that were shifted
@@ -1235,12 +1405,34 @@ class NgxMaskService extends NgxMaskApplierService {
                 String(value).length > 14)) {
             return String(value);
         }
-        return Number(value)
-            .toLocaleString('fullwide', {
-            useGrouping: false,
-            maximumFractionDigits: 20,
-        })
-            .replace(`/${MaskExpression.MINUS}/`, MaskExpression.MINUS);
+        // #1573: toLocaleString('fullwide', ...) is NOT locale-independent — 'fullwide' is
+        // not a real locale tag, so Intl silently falls back to the runtime DEFAULT locale
+        // (e.g. de-AT on Edge with Austrian regional format emits '0,5'). Expand exponential
+        // notation with pure string math instead; the decimal marker is always '.'.
+        return this._toPlainDecimalString(Number(value));
+    }
+    /**
+     * Locale-independent replacement for toLocaleString('fullwide', { useGrouping: false,
+     * maximumFractionDigits: 20 }) (#1573): expands exponential notation ('7e-7', '1e+21')
+     * to plain decimal form using '.' as decimal marker, regardless of the runtime locale.
+     */
+    _toPlainDecimalString(value) {
+        const stringValue = String(value);
+        const match = /^(-?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(stringValue);
+        if (!match) {
+            return stringValue;
+        }
+        const [, sign, integerPart, fractionPart = '', exponentPart] = match;
+        const exponent = Number(exponentPart);
+        const digits = `${integerPart}${fractionPart}`;
+        const pointIndex = integerPart.length + exponent;
+        if (pointIndex <= 0) {
+            return `${sign}0.${'0'.repeat(-pointIndex)}${digits}`;
+        }
+        if (pointIndex >= digits.length) {
+            return `${sign}${digits}${'0'.repeat(pointIndex - digits.length)}`;
+        }
+        return `${sign}${digits.slice(0, pointIndex)}.${digits.slice(pointIndex)}`;
     }
     showMaskInInput(inputVal) {
         if (this.showMaskTyped && !!this.shownMaskExpression) {
@@ -1256,7 +1448,8 @@ class NgxMaskService extends NgxMaskApplierService {
                 if (this.maskExpression === MaskExpression.IP) {
                     return this._checkForIp(inputVal);
                 }
-                if (this.maskExpression === MaskExpression.CPF_CNPJ) {
+                if (this.maskExpression === MaskExpression.CPF_CNPJ ||
+                    this.maskExpression === MaskExpression.CPF_CNPJ_ALPHA) {
                     return this._checkForCpfCnpj(inputVal);
                 }
             }
@@ -1342,28 +1535,41 @@ class NgxMaskService extends NgxMaskApplierService {
         if (inputVal === MaskExpression.HASH) {
             return cpf;
         }
-        const arr = [];
-        // eslint-disable-next-line @typescript-eslint/prefer-for-of
-        for (let i = 0; i < inputVal.length; i++) {
-            const value = inputVal[i] ?? MaskExpression.EMPTY_STRING;
-            if (!value) {
-                continue;
+        const isCpfCnpjAlpha = this.maskExpression === MaskExpression.CPF_CNPJ_ALPHA;
+        const hasAnyLetter = /[a-zA-Z]/.test(inputVal);
+        const arr = this._countCpfCnpjTypedChars(inputVal, isCpfCnpjAlpha);
+        if (isCpfCnpjAlpha && hasAnyLetter) {
+            // CNPJ_ALPHA shape is "AA.AAA.AAA/AAAA-00": separators fall after the 2nd, 5th,
+            // 8th and 12th typed character, so the placeholder slice offset must account for
+            // however many separators `result` has already passed through, mirroring the
+            // numeric CPF/CNPJ bucketed offsets below.
+            if (arr.length <= 2) {
+                return cnpj.slice(arr.length, cnpj.length);
             }
-            if (value.match('\\d')) {
-                arr.push(value);
+            if (arr.length > 2 && arr.length <= 5) {
+                return cnpj.slice(arr.length + 1, cnpj.length);
             }
+            if (arr.length > 5 && arr.length <= 8) {
+                return cnpj.slice(arr.length + 2, cnpj.length);
+            }
+            if (arr.length > 8 && arr.length <= 12) {
+                return cnpj.slice(arr.length + 3, cnpj.length);
+            }
+            return cnpj.slice(arr.length + 4, cnpj.length);
         }
-        if (arr.length <= 3) {
-            return cpf.slice(arr.length, cpf.length);
-        }
-        if (arr.length > 3 && arr.length <= 6) {
-            return cpf.slice(arr.length + 1, cpf.length);
-        }
-        if (arr.length > 6 && arr.length <= 9) {
-            return cpf.slice(arr.length + 2, cpf.length);
-        }
-        if (arr.length > 9 && arr.length < 11) {
-            return cpf.slice(arr.length + 3, cpf.length);
+        else {
+            if (arr.length <= 3) {
+                return cpf.slice(arr.length, cpf.length);
+            }
+            if (arr.length > 3 && arr.length <= 6) {
+                return cpf.slice(arr.length + 1, cpf.length);
+            }
+            if (arr.length > 6 && arr.length <= 9) {
+                return cpf.slice(arr.length + 2, cpf.length);
+            }
+            if (arr.length > 9 && arr.length < 11) {
+                return cpf.slice(arr.length + 3, cpf.length);
+            }
         }
         if (arr.length === 11) {
             return '';
@@ -1379,6 +1585,22 @@ class NgxMaskService extends NgxMaskApplierService {
         }
         return '';
     }
+    /** Collects the characters counted as "typed" for CPF/CNPJ progress tracking: digits only
+     *  for the numeric mask, alphanumerics for CPF_CNPJ_ALPHA. */
+    _countCpfCnpjTypedChars(inputVal, isCpfCnpjAlpha) {
+        const arr = [];
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let i = 0; i < inputVal.length; i++) {
+            const value = inputVal[i] ?? MaskExpression.EMPTY_STRING;
+            if (!value) {
+                continue;
+            }
+            if (isCpfCnpjAlpha ? value.match('[a-zA-Z0-9]') : value.match('\\d')) {
+                arr.push(value);
+            }
+        }
+        return arr;
+    }
     /**
      * Recursively determine the current active element by navigating the Shadow DOM until the Active Element is found.
      */
@@ -1407,6 +1629,20 @@ class NgxMaskService extends NgxMaskApplierService {
         if (!this.isInitialized && this._emitValue) {
             return;
         }
+        // #1519: a non-special placeHolderCharacter (e.g. 'X') is never something the user
+        // typed — it's the showMaskTyped fill character for unfilled slots — so it must never
+        // reach the model, regardless of dropSpecialCharacters. The default '_' placeholder is
+        // already covered by specialCharacters/removeMask; a custom single-char placeholder
+        // that isn't a special character is not, since none of the branches below include it
+        // in their removal set.
+        if (this.showMaskTyped &&
+            this.placeHolderCharacter.length === 1 &&
+            this.specialCharacters.indexOf(this.placeHolderCharacter) === -1) {
+            // eslint-disable-next-line no-param-reassign
+            inputValue = inputValue
+                .split(this.placeHolderCharacter)
+                .join(MaskExpression.EMPTY_STRING);
+        }
         if (Array.isArray(this.dropSpecialCharacters)) {
             this.onChange(outputTransformFn(this._toNumber(this._checkSymbols(this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.dropSpecialCharacters)))));
         }
@@ -1539,17 +1775,59 @@ class NgxMaskService extends NgxMaskApplierService {
     _checkPrecision(separatorExpression, separatorValue) {
         const separatorPrecision = this.getPrecision(separatorExpression);
         let value = separatorValue;
-        if (separatorExpression.indexOf('2') > 0 ||
-            (this.leadZero && Number(separatorPrecision) > 0 && Number.isFinite(separatorPrecision))) {
+        if ((separatorExpression.indexOf('2') > 0 && !this._isFocused()) ||
+            (this.leadZero &&
+                !this._isFocused() &&
+                Number(separatorPrecision) > 0 &&
+                Number.isFinite(separatorPrecision))) {
             if (this.decimalMarker === MaskExpression.COMMA && this.leadZero) {
                 value = value.replace(',', '.');
             }
-            return this.leadZero
-                ? Number(value).toFixed(Number(separatorPrecision))
-                : Number(value).toFixed(2);
+            const precision = this.leadZero ? Number(separatorPrecision) : 2;
+            // #1567: Number(value).toFixed() corrupts values with more significant digits
+            // than an IEEE-754 double can hold (e.g. '999999999999999.99' becomes
+            // '1000000000000000.00'). Round such values textually instead; safe-range
+            // values keep the original toFixed() semantics.
+            if (this._exceedsDoublePrecision(value)) {
+                return this._stringToFixed(value, precision);
+            }
+            return Number(value).toFixed(precision);
         }
         return this.numberToString(value);
     }
+    /**
+     * True when the plain decimal string carries more significant digits than an IEEE-754
+     * double can represent exactly (15 is the guaranteed round-trip digit count), meaning a
+     * Number() round-trip would corrupt it (#1567).
+     */
+    _exceedsDoublePrecision(value) {
+        if (!/^-?\d+(\.\d+)?$/.test(value)) {
+            return false;
+        }
+        const significantDigits = value.replace(/\D/g, '').replace(/^0+/, '');
+        return significantDigits.length > 15;
+    }
+    /**
+     * Exact string-based equivalent of Number.prototype.toFixed (round half away from zero)
+     * for plain decimal strings beyond double precision (#1567).
+     */
+    _stringToFixed(value, precision) {
+        const isNegative = value.startsWith(MaskExpression.MINUS);
+        const absValue = isNegative ? value.slice(1) : value;
+        const [integerPart = '0', fractionPart = ''] = absValue.split(MaskExpression.DOT);
+        const paddedFraction = fractionPart.padEnd(precision + 1, '0');
+        const keptFraction = paddedFraction.slice(0, precision);
+        const shouldRoundUp = (paddedFraction.charCodeAt(precision) || 0) >= 53; // '5'
+        let scaled = BigInt(integerPart + keptFraction);
+        if (shouldRoundUp) {
+            scaled += 1n;
+        }
+        const digits = scaled.toString().padStart(precision + 1, '0');
+        const sign = isNegative && scaled > 0n ? MaskExpression.MINUS : '';
+        return precision > 0
+            ? `${sign}${digits.slice(0, -precision)}.${digits.slice(-precision)}`
+            : `${sign}${digits}`;
+    }
     _repeatPatternSymbols(maskExp) {
         return ((maskExp.match(/{[0-9]+}/) &&
             maskExp
@@ -1576,13 +1854,25 @@ class NgxMaskService extends NgxMaskApplierService {
             }, '')) ||
             maskExp);
     }
+    /**
+     * Decimal marker of the value being normalized in writeValue/pipe flows.
+     *
+     * #1573: this used to return the RUNTIME default locale's decimal marker
+     * ((1.1).toLocaleString().substring(1, 2)), which made mask behavior depend on the
+     * OS/browser regional format: under a comma-decimal locale (e.g. Edge + Austrian
+     * regional settings) a preformatted value like '10,000' (thousandSeparator ',')
+     * had its ',' replaced by the configured '.' decimalMarker, corrupting the value
+     * 1000x. JS number stringification (String(n)) always uses '.', and string values
+     * are expected to use the configured markers — the runtime locale is never the
+     * right source, so this is always '.'.
+     */
     currentLocaleDecimalMarker() {
-        return (1.1).toLocaleString().substring(1, 2);
+        return MaskExpression.DOT;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskService });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskService, decorators: [{
             type: Injectable
         }] });
 
@@ -1619,82 +1909,160 @@ function provideEnvironmentNgxMask(configValue) {
 
 class NgxMaskDirective {
     // ===== Mask Configuration Inputs =====
-    mask = input('', ...(ngDevMode ? [{ debugName: "mask" }] : []));
-    specialCharacters = input([], ...(ngDevMode ? [{ debugName: "specialCharacters" }] : []));
-    patterns = input({}, ...(ngDevMode ? [{ debugName: "patterns" }] : []));
-    prefix = input('', ...(ngDevMode ? [{ debugName: "prefix" }] : []));
-    suffix = input('', ...(ngDevMode ? [{ debugName: "suffix" }] : []));
-    thousandSeparator = input(' ', ...(ngDevMode ? [{ debugName: "thousandSeparator" }] : []));
-    decimalMarker = input('.', ...(ngDevMode ? [{ debugName: "decimalMarker" }] : []));
-    dropSpecialCharacters = input(null, ...(ngDevMode ? [{ debugName: "dropSpecialCharacters" }] : []));
-    hiddenInput = input(null, ...(ngDevMode ? [{ debugName: "hiddenInput" }] : []));
-    showMaskTyped = input(null, ...(ngDevMode ? [{ debugName: "showMaskTyped" }] : []));
-    placeHolderCharacter = input(null, ...(ngDevMode ? [{ debugName: "placeHolderCharacter" }] : []));
-    shownMaskExpression = input(null, ...(ngDevMode ? [{ debugName: "shownMaskExpression" }] : []));
-    clearIfNotMatch = input(null, ...(ngDevMode ? [{ debugName: "clearIfNotMatch" }] : []));
-    validation = input(null, ...(ngDevMode ? [{ debugName: "validation" }] : []));
-    separatorLimit = input('', ...(ngDevMode ? [{ debugName: "separatorLimit" }] : []));
-    allowNegativeNumbers = input(null, ...(ngDevMode ? [{ debugName: "allowNegativeNumbers" }] : []));
-    leadZeroDateTime = input(null, ...(ngDevMode ? [{ debugName: "leadZeroDateTime" }] : []));
-    leadZero = input(null, ...(ngDevMode ? [{ debugName: "leadZero" }] : []));
-    triggerOnMaskChange = input(null, ...(ngDevMode ? [{ debugName: "triggerOnMaskChange" }] : []));
-    apm = input(null, ...(ngDevMode ? [{ debugName: "apm" }] : []));
-    inputTransformFn = input(null, ...(ngDevMode ? [{ debugName: "inputTransformFn" }] : []));
-    outputTransformFn = input(null, ...(ngDevMode ? [{ debugName: "outputTransformFn" }] : []));
-    keepCharacterPositions = input(null, ...(ngDevMode ? [{ debugName: "keepCharacterPositions" }] : []));
-    instantPrefix = input(null, ...(ngDevMode ? [{ debugName: "instantPrefix" }] : []));
-    value = model('', ...(ngDevMode ? [{ debugName: "value" }] : []));
-    errors = input([], ...(ngDevMode ? [{ debugName: "errors" }] : []));
-    disabled = input(false, ...(ngDevMode ? [{ debugName: "disabled" }] : []));
-    touched = model(false, ...(ngDevMode ? [{ debugName: "touched" }] : []));
-    dirty = input(false, ...(ngDevMode ? [{ debugName: "dirty" }] : []));
-    invalid = input(false, ...(ngDevMode ? [{ debugName: "invalid" }] : []));
-    pending = input(false, ...(ngDevMode ? [{ debugName: "pending" }] : []));
-    readonly = input(false, ...(ngDevMode ? [{ debugName: "readonly" }] : []));
-    required = input(false, ...(ngDevMode ? [{ debugName: "required" }] : []));
-    name = input('', ...(ngDevMode ? [{ debugName: "name" }] : []));
+    mask = input('', ...(ngDevMode ? [{ debugName: "mask" }] : /* istanbul ignore next */ []));
+    specialCharacters = input([], ...(ngDevMode ? [{ debugName: "specialCharacters" }] : /* istanbul ignore next */ []));
+    patterns = input({}, ...(ngDevMode ? [{ debugName: "patterns" }] : /* istanbul ignore next */ []));
+    prefix = input('', ...(ngDevMode ? [{ debugName: "prefix" }] : /* istanbul ignore next */ []));
+    suffix = input('', ...(ngDevMode ? [{ debugName: "suffix" }] : /* istanbul ignore next */ []));
+    thousandSeparator = input(' ', ...(ngDevMode ? [{ debugName: "thousandSeparator" }] : /* istanbul ignore next */ []));
+    decimalMarker = input('.', ...(ngDevMode ? [{ debugName: "decimalMarker" }] : /* istanbul ignore next */ []));
+    dropSpecialCharacters = input(null, ...(ngDevMode ? [{ debugName: "dropSpecialCharacters" }] : /* istanbul ignore next */ []));
+    hiddenInput = input(null, ...(ngDevMode ? [{ debugName: "hiddenInput" }] : /* istanbul ignore next */ []));
+    showMaskTyped = input(null, ...(ngDevMode ? [{ debugName: "showMaskTyped" }] : /* istanbul ignore next */ []));
+    placeHolderCharacter = input(null, ...(ngDevMode ? [{ debugName: "placeHolderCharacter" }] : /* istanbul ignore next */ []));
+    shownMaskExpression = input(null, ...(ngDevMode ? [{ debugName: "shownMaskExpression" }] : /* istanbul ignore next */ []));
+    clearIfNotMatch = input(null, ...(ngDevMode ? [{ debugName: "clearIfNotMatch" }] : /* istanbul ignore next */ []));
+    validation = input(null, ...(ngDevMode ? [{ debugName: "validation" }] : /* istanbul ignore next */ []));
+    separatorLimit = input('', ...(ngDevMode ? [{ debugName: "separatorLimit" }] : /* istanbul ignore next */ []));
+    allowNegativeNumbers = input(null, ...(ngDevMode ? [{ debugName: "allowNegativeNumbers" }] : /* istanbul ignore next */ []));
+    leadZeroDateTime = input(null, ...(ngDevMode ? [{ debugName: "leadZeroDateTime" }] : /* istanbul ignore next */ []));
+    leadZero = input(null, ...(ngDevMode ? [{ debugName: "leadZero" }] : /* istanbul ignore next */ []));
+    triggerOnMaskChange = input(null, ...(ngDevMode ? [{ debugName: "triggerOnMaskChange" }] : /* istanbul ignore next */ []));
+    apm = input(null, ...(ngDevMode ? [{ debugName: "apm" }] : /* istanbul ignore next */ []));
+    inputTransformFn = input(null, ...(ngDevMode ? [{ debugName: "inputTransformFn" }] : /* istanbul ignore next */ []));
+    outputTransformFn = input(null, ...(ngDevMode ? [{ debugName: "outputTransformFn" }] : /* istanbul ignore next */ []));
+    keepCharacterPositions = input(null, ...(ngDevMode ? [{ debugName: "keepCharacterPositions" }] : /* istanbul ignore next */ []));
+    instantPrefix = input(null, ...(ngDevMode ? [{ debugName: "instantPrefix" }] : /* istanbul ignore next */ []));
+    value = model('', ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+    disabled = input(false, { ...(ngDevMode ? { debugName: "disabled" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    touched = model(false, ...(ngDevMode ? [{ debugName: "touched" }] : /* istanbul ignore next */ []));
     maskFilled = output();
-    _maskValue = signal('', ...(ngDevMode ? [{ debugName: "_maskValue" }] : []));
-    _inputValue = signal('', ...(ngDevMode ? [{ debugName: "_inputValue" }] : []));
-    _position = signal(null, ...(ngDevMode ? [{ debugName: "_position" }] : []));
-    _code = signal('', ...(ngDevMode ? [{ debugName: "_code" }] : []));
-    _maskExpressionArray = signal([], ...(ngDevMode ? [{ debugName: "_maskExpressionArray" }] : []));
-    _justPasted = signal(false, ...(ngDevMode ? [{ debugName: "_justPasted" }] : []));
-    _isFocused = signal(false, ...(ngDevMode ? [{ debugName: "_isFocused" }] : []));
+    _maskValue = signal('', ...(ngDevMode ? [{ debugName: "_maskValue" }] : /* istanbul ignore next */ []));
+    _inputValue = signal('', ...(ngDevMode ? [{ debugName: "_inputValue" }] : /* istanbul ignore next */ []));
+    _position = signal(null, ...(ngDevMode ? [{ debugName: "_position" }] : /* istanbul ignore next */ []));
+    _code = signal('', ...(ngDevMode ? [{ debugName: "_code" }] : /* istanbul ignore next */ []));
+    _maskExpressionArray = signal([], ...(ngDevMode ? [{ debugName: "_maskExpressionArray" }] : /* istanbul ignore next */ []));
+    _justPasted = signal(false, ...(ngDevMode ? [{ debugName: "_justPasted" }] : /* istanbul ignore next */ []));
+    _isFocused = signal(false, ...(ngDevMode ? [{ debugName: "_isFocused" }] : /* istanbul ignore next */ []));
     /** For IME composition event */
-    _isComposing = signal(false, ...(ngDevMode ? [{ debugName: "_isComposing" }] : []));
-    /** Track if we're using Signal Forms mode */
-    _isSignalFormsMode = signal(false, ...(ngDevMode ? [{ debugName: "_isSignalFormsMode" }] : []));
+    _isComposing = signal(false, ...(ngDevMode ? [{ debugName: "_isComposing" }] : /* istanbul ignore next */ []));
+    /**
+     * True once Angular has driven this directive through the `ControlValueAccessor` contract
+     * (`registerOnChange`). NOTE: Signal Forms' `FormField` ALSO takes this path — it prefers a
+     * host-provided `NG_VALUE_ACCESSOR` over the custom-control `value` model binding (see
+     * `FormField.ɵngControlCreate`), so it calls `registerOnChange`/`writeValue` too and this
+     * flag is `true` in both modes. That is fine: with the flag set, the `value`-model effect
+     * below is a no-op and all rendering goes through `writeValue()`. The `value` model is only
+     * driven directly (flag stays `false`) when the directive is used standalone with a
+     * `[(value)]` binding and no forms integration.
+     */
+    _isCvaMode = signal(false, ...(ngDevMode ? [{ debugName: "_isCvaMode" }] : /* istanbul ignore next */ []));
+    /** Guards against the value effect echoing back a value we just propagated ourselves. */
+    _skipNextValueEffect = signal(false, ...(ngDevMode ? [{ debugName: "_skipNextValueEffect" }] : /* istanbul ignore next */ []));
+    /**
+     * The exact stringified value last pushed through `onChange` (view → model). Signal Forms'
+     * `FormField` echoes every model update back through `writeValue()` — including updates that
+     * originated from the view. Re-masking that unmasked echo is at best a redundant re-render
+     * and at worst destructive for masks whose unmasked form is ambiguous (e.g. IP:
+     * '192168178' cannot reconstruct the typed dots of '192.168.1.78'). `writeValue()` consumes
+     * this marker to skip exactly that echo. `null` = no pending propagation.
+     */
+    _lastPropagatedValue = null;
+    /**
+     * True once the first `ngOnChanges` pass has applied the mask configuration to the service.
+     * Signal Forms' `FormField` syncs its field value through the template `ɵɵcontrol` update
+     * instruction, which runs BEFORE the sibling directives' first `ngOnChanges` on the same
+     * element — so the very first `writeValue()` would otherwise see an unconfigured service
+     * (empty `maskExpression`, default `leadZero`/`thousandSeparator`/...) and render the raw
+     * value. Until this flag is set, `writeValue()` stashes the incoming value and `ngOnChanges`
+     * replays it once the configuration is in place.
+     */
+    _configApplied = false;
+    _pendingInitialValue;
+    _hasPendingInitialValue = false;
+    /**
+     * True once the `disabled` input has ever delivered `true`. The disabled effect's very
+     * first run fires with the input's default `false` even when nothing binds `[disabled]`.
+     * Because effects run after Angular Forms' `setUpControl` (which calls
+     * `setDisabledState(true)` for initially-disabled controls) and both DOM writes are
+     * queueMicrotask-deferred in FIFO order, forwarding that default `false` would land last
+     * and re-enable an initially-disabled control (#1607, #1614). An initial `false` write is
+     * never needed — inputs are enabled by default — so `false` is only forwarded after the
+     * input has explicitly driven the state to `true` at least once.
+     */
+    _disabledEverSet = false;
+    /** Ensures the multi-character placeHolderCharacter warning (#1347) is emitted only once. */
+    _warnedAboutMultiCharPlaceholder = false;
     _maskService = inject(NgxMaskService, { self: true });
     document = inject(DOCUMENT);
     _config = inject(NGX_MASK_CONFIG);
+    /**
+     * Under zoneless change detection, writing to the underlying FormControl programmatically
+     * (e.g. `setValue`/`patchValue` from outside a signal/effect context, or from a callback
+     * zone.js used to auto-flush like `requestAnimationFrame`/`queueMicrotask`) does not itself
+     * trigger a CD run. Bindings that read `form.pristine`/`form.dirty`/`form.value` on the host
+     * template need an explicit `markForCheck()` once the directive finishes reacting to a
+     * programmatic value write, otherwise the view stays stale until something else schedules CD.
+     */
+    _changeDetectorRef = inject(ChangeDetectorRef);
+    _elementRef = inject(ElementRef);
+    _renderer = inject(Renderer2);
+    // Injector is used to lazily resolve NgControl. NgControl cannot be injected directly:
+    // this directive is registered as the control's NG_VALUE_ACCESSOR, so a direct
+    // inject(NgControl) would form a circular dependency. Resolving it lazily on first use
+    // (after the control graph is wired) sidesteps the cycle.
+    _injector = inject(Injector);
+    _ngControl;
+    _resolveNgControl() {
+        if (typeof this._ngControl === 'undefined') {
+            this._ngControl = this._injector.get(NgControl, null);
+        }
+        return this._ngControl;
+    }
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     onChange = (_) => { };
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     onTouch = () => { };
     constructor() {
+        // Default onChange used in Signal Forms mode, where Angular never calls registerOnChange.
+        // It pushes the unmasked value into the `value` model so the `valueChange` output fires.
+        // registerOnChange() overrides this to additionally invoke Angular's CVA callback.
+        this._maskService.onChange = this.onChange = (value) => {
+            this._propagateToValueModel(value);
+        };
+        // Signal Forms drives the `value` model input directly (custom-control mode).
+        // In classic CVA mode `writeValue` handles rendering instead, so this effect is a no-op
+        // there. We skip the pass immediately following our own onChange propagation to avoid
+        // clobbering the raw `_inputValue` with the masked value echoed back from the model.
         effect(() => {
             const signalValue = this.value();
-            if (this._isSignalFormsMode() && signalValue !== untracked(() => this._inputValue())) {
-                untracked(() => {
+            untracked(() => {
+                if (this._isCvaMode()) {
+                    return;
+                }
+                if (this._skipNextValueEffect()) {
+                    this._skipNextValueEffect.set(false);
+                    return;
+                }
+                if (String(signalValue) !== String(this._inputValue())) {
                     this.writeValue(signalValue);
-                });
-            }
+                }
+            });
         });
         effect(() => {
             const isDisabled = this.disabled();
             untracked(() => {
+                // Never force-enable on the default `false`: it would clobber Angular Forms'
+                // own setDisabledState(true) for initially-disabled controls (see
+                // _disabledEverSet). `false` is forwarded only after an explicit `true`.
+                if (!isDisabled && !this._disabledEverSet) {
+                    return;
+                }
+                this._disabledEverSet = true;
                 this.setDisabledState(isDisabled);
             });
         });
     }
-    ngOnInit() {
-        // Detect if we're being used with Signal Forms
-        // Signal Forms will set the value model from outside
-        if (this.value() !== '') {
-            this._isSignalFormsMode.set(true);
-        }
-    }
     ngOnChanges(changes) {
         const { mask, specialCharacters, patterns, prefix, suffix, thousandSeparator, decimalMarker, dropSpecialCharacters, hiddenInput, showMaskTyped, placeHolderCharacter, shownMaskExpression, clearIfNotMatch, validation, separatorLimit, allowNegativeNumbers, leadZeroDateTime, leadZero, triggerOnMaskChange, apm, inputTransformFn, outputTransformFn, keepCharacterPositions, instantPrefix, } = changes;
         if (mask) {
@@ -1714,12 +2082,12 @@ class NgxMaskDirective {
             }
         }
         if (specialCharacters) {
-            if (!specialCharacters.currentValue || !Array.isArray(specialCharacters.currentValue)) {
-                return;
-            }
-            else {
-                this._maskService.specialCharacters = specialCharacters.currentValue || [];
+            if (Array.isArray(specialCharacters.currentValue)) {
+                this._maskService.specialCharacters = specialCharacters.currentValue;
             }
+            // A non-array value (e.g. null from an unset dynamic config) keeps the current
+            // service value (config defaults) and must not abort the whole ngOnChanges pass,
+            // otherwise sibling inputs changed in the same cycle would be silently ignored (#1512).
         }
         if (allowNegativeNumbers) {
             this._maskService.allowNegativeNumbers = allowNegativeNumbers.currentValue;
@@ -1791,6 +2159,13 @@ class NgxMaskDirective {
         }
         if (placeHolderCharacter) {
             this._maskService.placeHolderCharacter = placeHolderCharacter.currentValue;
+            if (typeof placeHolderCharacter.currentValue === 'string' &&
+                placeHolderCharacter.currentValue.length > 1 &&
+                !this._warnedAboutMultiCharPlaceholder) {
+                this._warnedAboutMultiCharPlaceholder = true;
+                // eslint-disable-next-line no-console
+                console.warn('Ngx-mask: placeHolderCharacter should be a single character; behavior with multi-character values is undefined (e.g. keepCharacterPositions will not work). Current value:', placeHolderCharacter.currentValue);
+            }
         }
         if (shownMaskExpression) {
             this._maskService.shownMaskExpression = shownMaskExpression.currentValue;
@@ -1823,6 +2198,17 @@ class NgxMaskDirective {
             this._maskService.keepCharacterPositions = keepCharacterPositions.currentValue;
         }
         this._applyMask();
+        if (!this._configApplied) {
+            this._configApplied = true;
+            if (this._hasPendingInitialValue) {
+                // Replay the writeValue() call that arrived before this first ngOnChanges pass
+                // (see _configApplied) now that the mask configuration is applied.
+                this._hasPendingInitialValue = false;
+                const pendingValue = this._pendingInitialValue;
+                this._pendingInitialValue = null;
+                void this.writeValue(pendingValue);
+            }
+        }
     }
     validate({ value }) {
         const processedValue = typeof value === 'number' ? String(value) : value;
@@ -1881,9 +2267,31 @@ class NgxMaskDirective {
                     else if (maskValue.indexOf(key) !== -1) {
                         counterOfOpt++;
                     }
-                    if (maskValue.indexOf(key) !== -1 &&
-                        processedValue.length >= maskValue.indexOf(key)) {
-                        return null;
+                    const firstOptionalIndex = maskValue.indexOf(key);
+                    if (firstOptionalIndex !== -1 && processedValue.length >= firstOptionalIndex) {
+                        // #1515: the early "everything before the first optional token is
+                        // filled" return is only sound for trailing-optional layouts. When a
+                        // mandatory token follows the first optional one (e.g. `999SSS`,
+                        // indexOf === 0) it used to mark EVERY value as valid.
+                        const hasMandatoryAfterOptional = maskValue
+                            .slice(firstOptionalIndex)
+                            .split(MaskExpression.EMPTY_STRING)
+                            .some((symbol) => !!this._maskService.patterns[symbol] &&
+                            !this._maskService.patterns[symbol]?.optional);
+                        if (!hasMandatoryAfterOptional) {
+                            return null;
+                        }
+                        if (!this.prefix() && !this.suffix() && this._isPlainTokenMask(maskValue)) {
+                            // Position-aware check: match the value against the mask allowing
+                            // optional tokens to be skipped; every mandatory token must be
+                            // consumed (catches `12a` for `999SSS`, which a pure length
+                            // check cannot).
+                            return this._matchesMaskWithOptionalSkip(processedValue, maskValue)
+                                ? null
+                                : this._createValidationError(processedValue);
+                        }
+                        // Non-plain masks (prefix/suffix, exotic symbols) fall through to the
+                        // legacy length check below (`maskValue.length - counterOfOpt`).
                     }
                     if (counterOfOpt === maskValue.length) {
                         return null;
@@ -1908,6 +2316,13 @@ class NgxMaskDirective {
                         : maskValue.length - counterOfOpt;
                 if (array.length === 1) {
                     if (processedValue.length < length) {
+                        // #1583: for `||` multi-masks, a value shorter than the selected
+                        // alternative can still be complete: it must stop exactly at a
+                        // special-character boundary of the selected alternative and satisfy
+                        // the length requirement of another (shorter) alternative.
+                        if (this._isCompleteAlternativeBoundary(processedValue)) {
+                            return null;
+                        }
                         return this._createValidationError(processedValue);
                     }
                 }
@@ -1950,6 +2365,7 @@ class NgxMaskDirective {
     }
     onFocus() {
         this._isFocused.set(true);
+        this._maskService._isFocused.set(true);
     }
     onModelChange(value) {
         // on form reset we need to update the actualValue
@@ -1962,8 +2378,30 @@ class NgxMaskDirective {
     }
     onInput(e) {
         this._maskService.isInitialized = true;
-        // If IME is composing text, we wait for the composed text.
-        if (this._isComposing()) {
+        // Android IMEs report every keydown as key 'Unidentified' / keyCode 229, so a
+        // backspace is undetectable from keydown alone and all _code()-based deletion
+        // branches misfire (cursor jumps, "stuck" backspace — #1497). The input event's
+        // inputType is the reliable source: derive the deletion code from it.
+        const inputType = e.inputType;
+        if (inputType === 'deleteContentBackward') {
+            this._code.set(MaskExpression.BACKSPACE);
+        }
+        else if (inputType === 'deleteContentForward') {
+            this._code.set(MaskExpression.DELETE);
+        }
+        else if (inputType &&
+            (this._code() === MaskExpression.BACKSPACE || this._code() === MaskExpression.DELETE)) {
+            // A non-delete edit that produced no meaningful keydown (IME insertion,
+            // context-menu paste): clear the stale deletion code so the edit is not
+            // processed as a backspace.
+            this._code.set(inputType);
+        }
+        // If IME is composing text, we wait for the composed text — but only when the mask
+        // can actually accept letters. Purely numeric masks gain nothing from composition,
+        // and some Android IMEs (Samsung Keyboard) deliver every keystroke as
+        // insertCompositionText without firing compositionend until blur, which would leave
+        // the FormControl stale for the whole edit (#1293).
+        if (this._isComposing() && this._maskAcceptsLetterInput()) {
             return;
         }
         const el = e.target;
@@ -1972,51 +2410,90 @@ class NgxMaskDirective {
             : el.value;
         if (el.type !== 'number') {
             if (typeof transformedValue === 'string' || typeof transformedValue === 'number') {
-                el.value = transformedValue.toString();
+                const transformedString = transformedValue.toString();
+                // Only rewrite el.value when the transform actually changed it: any
+                // programmatic `.value =` assignment clears the browser's "last changed
+                // by a user edit" flag, which silently disables native constraint
+                // validation (minlength -> validity.tooShort) even when the mask is a
+                // no-op (#1379). With an empty mask the directive must stay a pure
+                // passthrough for the native input.
+                if (el.value !== transformedString) {
+                    el.value = transformedString;
+                }
                 this._inputValue.set(el.value);
                 this._setMask();
                 if (!this._maskValue()) {
                     this.onChange(el.value);
                     return;
                 }
+                // On paste of a raw value that does not yet carry the prefix, the caret
+                // position reported by the element is prefix.length short of where it must
+                // land once applyMask prepends the prefix (#1571). Captured here because the
+                // applyValueChanges callback below resets the _justPasted flag.
+                const pastedValueWithoutPrefix = this._justPasted() &&
+                    !!this._maskService.prefix &&
+                    !el.value.startsWith(this._maskService.prefix);
                 let position = el.selectionStart === 1
                     ? el.selectionStart + this._maskService.prefix.length
                     : el.selectionStart;
-                if (this.showMaskTyped() &&
-                    this.keepCharacterPositions() &&
-                    this._maskService.placeHolderCharacter.length === 1) {
+                if (this.keepCharacterPositions() &&
+                    this._maskService.placeHolderCharacter.length === 1 &&
+                    !this._justPasted()) {
                     const suffix = this.suffix();
                     const prefix = this.prefix();
                     const inputSymbol = el.value.slice(position - 1, position);
                     const prefixLength = prefix.length;
-                    const checkSymbols = this._maskService._checkSymbolMask(inputSymbol, this._maskService.maskExpression[position - 1 - prefixLength] ??
-                        MaskExpression.EMPTY_STRING);
-                    const checkSpecialCharacter = this._maskService._checkSymbolMask(inputSymbol, this._maskService.maskExpression[position + 1 - prefixLength] ??
-                        MaskExpression.EMPTY_STRING);
-                    const selectRangeBackspace = this._maskService.selStart === this._maskService.selEnd;
-                    const selStart = Number(this._maskService.selStart) - prefixLength;
-                    const selEnd = Number(this._maskService.selEnd) - prefixLength;
+                    const showMaskTyped = this.showMaskTyped();
+                    const maskExpression = this._maskService.maskExpression;
+                    // Placeholder skeleton of the mask (special chars kept, fillable slots
+                    // replaced by the placeholder character). With showMaskTyped the service
+                    // renders it as maskIsShown; without showMaskTyped it is derived locally so
+                    // keepCharacterPositions works on its own (#1545, #1543).
+                    const maskSkeleton = this._maskService.maskIsShown.length
+                        ? this._maskService.maskIsShown
+                        : maskExpression.replace(/\w/g, this._maskService.placeHolderCharacter);
+                    const hasSelection = this._maskService.selStart !== this._maskService.selEnd;
+                    const selStartAbs = Number(this._maskService.selStart);
+                    const selEndAbs = Number(this._maskService.selEnd);
+                    const selStart = selStartAbs - prefixLength;
+                    const selEnd = selEndAbs - prefixLength;
                     const backspaceOrDelete = this._code() === MaskExpression.BACKSPACE ||
                         this._code() === MaskExpression.DELETE;
+                    // Whether this block fully resolved the resulting display value into
+                    // this._maskService.actualValue. When true, applyMask short-circuits and
+                    // renders actualValue as-is; when false the edit flows through regular
+                    // masking (e.g. appending at the end, or clearing the whole value).
+                    let kcpHandled = true;
                     if (backspaceOrDelete) {
-                        if (!selectRangeBackspace) {
-                            if (this._maskService.selStart === prefixLength) {
-                                this._maskService.actualValue = `${prefix}${this._maskService.maskIsShown.slice(0, selEnd)}${this._inputValue().split(prefix).join('')}`;
+                        if (hasSelection) {
+                            const preEditLength = el.value.length + (selEndAbs - selStartAbs);
+                            if (!showMaskTyped &&
+                                selStartAbs <= prefixLength &&
+                                selEndAbs >= preEditLength) {
+                                // The whole value was selected and deleted: clear through the
+                                // regular path instead of showing a placeholder skeleton.
+                                kcpHandled = false;
+                            }
+                            else if (this._maskService.selStart === prefixLength) {
+                                this._maskService.actualValue = `${prefix}${maskSkeleton.slice(0, selEnd)}${this._inputValue().split(prefix).join('')}`;
                             }
                             else if (this._maskService.selStart ===
-                                this._maskService.maskIsShown.length + prefixLength) {
-                                this._maskService.actualValue = `${this._inputValue()}${this._maskService.maskIsShown.slice(selStart, selEnd)}`;
+                                maskSkeleton.length + prefixLength) {
+                                this._maskService.actualValue = `${this._inputValue()}${maskSkeleton.slice(selStart, selEnd)}`;
                             }
                             else {
                                 this._maskService.actualValue = `${prefix}${this._inputValue()
                                     .split(prefix)
                                     .join('')
-                                    .slice(0, selStart)}${this._maskService.maskIsShown.slice(selStart, selEnd)}${this._maskService.actualValue.slice(selEnd + prefixLength, this._maskService.maskIsShown.length + prefixLength)}${suffix}`;
+                                    .slice(0, selStart)}${maskSkeleton.slice(selStart, selEnd)}${this._maskService.actualValue.slice(selEnd + prefixLength, maskSkeleton.length + prefixLength)}${suffix}`;
                             }
                         }
-                        else if (!this._maskService.specialCharacters.includes(this._maskService.maskExpression.slice(position - prefixLength, position + 1 - prefixLength)) &&
-                            selectRangeBackspace) {
-                            if (selStart === 1 && prefix) {
+                        else if (!this._maskService.specialCharacters.includes(maskExpression.slice(position - prefixLength, position + 1 - prefixLength))) {
+                            if (!showMaskTyped && position >= el.value.length) {
+                                // Deleting the last character: no gap needs to be kept.
+                                kcpHandled = false;
+                            }
+                            else if (selStart === 1 && prefix) {
                                 this._maskService.actualValue = `${prefix}${this._maskService.placeHolderCharacter}${el.value
                                     .split(prefix)
                                     .join('')
@@ -2032,35 +2509,90 @@ class NgxMaskDirective {
                         }
                         position = this._code() === MaskExpression.DELETE ? position + 1 : position;
                     }
-                    if (!backspaceOrDelete) {
-                        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 (hasSelection) {
+                        // A selected range was replaced by the typed symbol. Keep the layout:
+                        // blank the selection to the mask skeleton and put the typed symbol
+                        // into the first fillable slot of the selection (#1527, #1489).
+                        const preEditLength = el.value.length - 1 + (selEndAbs - selStartAbs);
+                        if (!showMaskTyped &&
+                            selStartAbs <= prefixLength &&
+                            selEndAbs >= preEditLength) {
+                            // The whole value was replaced: mask it through the regular path.
+                            kcpHandled = false;
                         }
-                        else if (checkSymbols) {
-                            if (el.value.length === 1 && position === 1) {
-                                this._maskService.actualValue = `${prefix}${inputSymbol}${this._maskService.maskIsShown.slice(1, this._maskService.maskIsShown.length)}${suffix}`;
+                        else {
+                            let maskIdx = Math.max(selStart, 0);
+                            while (maskIdx < maskExpression.length &&
+                                this._maskService.specialCharacters.includes(maskExpression[maskIdx] ?? MaskExpression.EMPTY_STRING)) {
+                                maskIdx += 1;
+                            }
+                            const blanked = `${el.value.slice(0, selStartAbs)}${maskSkeleton.slice(Math.max(selStart, 0), selEnd)}${el.value.slice(selStartAbs + 1)}`;
+                            const targetAbs = maskIdx + prefixLength;
+                            if (targetAbs < blanked.length - suffix.length &&
+                                this._maskService._checkSymbolMask(inputSymbol, maskExpression[maskIdx] ?? MaskExpression.EMPTY_STRING)) {
+                                this._maskService.actualValue = `${blanked.slice(0, targetAbs)}${inputSymbol}${blanked.slice(targetAbs + 1)}`;
+                                position = targetAbs + 1;
                             }
                             else {
-                                this._maskService.actualValue = `${el.value.slice(0, position - 1)}${inputSymbol}${el.value
-                                    .slice(position + 1)
-                                    .split(suffix)
-                                    .join('')}${suffix}`;
+                                this._maskService.actualValue = blanked;
+                                position = selStartAbs;
                             }
                         }
-                        else if (prefix &&
-                            el.value.length === 1 &&
-                            position - prefixLength === 1 &&
-                            this._maskService._checkSymbolMask(el.value, this._maskService.maskExpression[position - 1 - prefixLength] ??
-                                MaskExpression.EMPTY_STRING)) {
-                            this._maskService.actualValue = `${prefix}${el.value}${this._maskService.maskIsShown.slice(1, this._maskService.maskIsShown.length)}${suffix}`;
+                    }
+                    else {
+                        // Single-caret insert (overwrite mode): the typed symbol lands in the
+                        // first fillable mask slot at or after the caret, skipping any number
+                        // of special characters (#1544, #1489).
+                        const oldDisplay = `${el.value.slice(0, position - 1)}${el.value.slice(position)}`;
+                        const oldDisplayNoSuffix = suffix
+                            ? oldDisplay.split(suffix).join('')
+                            : oldDisplay;
+                        let maskIdx = position - 1 - prefixLength;
+                        if (maskIdx < 0) {
+                            // Typed inside the prefix: reject the symbol.
+                            position = position - 1;
+                        }
+                        else {
+                            while (maskIdx < maskExpression.length &&
+                                this._maskService.specialCharacters.includes(maskExpression[maskIdx] ?? MaskExpression.EMPTY_STRING)) {
+                                maskIdx += 1;
+                            }
+                            const targetAbs = maskIdx + prefixLength;
+                            if (targetAbs >= oldDisplayNoSuffix.length) {
+                                if (oldDisplayNoSuffix.length <= prefixLength || !showMaskTyped) {
+                                    // First symbol, or appending at the end without
+                                    // showMaskTyped: regular masking handles it (including
+                                    // leadZeroDateTime insertions).
+                                    kcpHandled = false;
+                                }
+                                else {
+                                    // All slots of the rendered mask are already consumed.
+                                    position = position - 1;
+                                }
+                            }
+                            else if (this._maskService._checkSymbolMask(inputSymbol, maskExpression[maskIdx] ?? MaskExpression.EMPTY_STRING)) {
+                                this._maskService.actualValue = `${oldDisplayNoSuffix.slice(0, targetAbs)}${inputSymbol}${oldDisplayNoSuffix.slice(targetAbs + 1)}${suffix}`;
+                                position = targetAbs + 1;
+                            }
+                            else {
+                                // Rejected symbol: keep the current display.
+                                position = position - 1;
+                            }
                         }
                     }
+                    this._maskService.keepCharacterPositionsHandled = kcpHandled;
+                }
+                // A literal '*' typed into the VALUE (custom pattern allowing asterisks) makes
+                // the service's applyMask take its hiddenInput shadow-value branch, whose
+                // equal/shorter-length cases restore the stale pre-edit actualValue and discard
+                // a selection replacement (#1504). Without hiddenInput there is no shadow state
+                // to preserve, so drop it and let the edited value flow through regular masking.
+                if (!this._maskService.hiddenInput &&
+                    !this._maskService.showMaskTyped &&
+                    !this.keepCharacterPositions() &&
+                    this._maskService.selStart !== this._maskService.selEnd &&
+                    el.value.includes(MaskExpression.SYMBOL_STAR)) {
+                    this._maskService.actualValue = MaskExpression.EMPTY_STRING;
                 }
                 let caretShift = 0;
                 let backspaceShift = false;
@@ -2138,11 +2670,30 @@ class NgxMaskDirective {
                         (this._code() === MaskExpression.BACKSPACE && !backspaceShift
                             ? 0
                             : caretShift);
+                // For separator masks the applier's caret shift is computed on the raw
+                // (prefix-less) value, so account for the prefix the mask just added (#1571).
+                if (pastedValueWithoutPrefix &&
+                    this._maskValue().startsWith(MaskExpression.SEPARATOR)) {
+                    positionToApply += this._maskService.prefix.length;
+                }
                 if (positionToApply > this._getActualInputLength()) {
-                    positionToApply =
-                        el.value === this._maskService.decimalMarker && el.value.length === 1
-                            ? this._getActualInputLength() + 1
-                            : this._getActualInputLength();
+                    // A bare decimal marker ('.' or, with a prefix, '$.') is not a number:
+                    // formControlResult has just emitted null for it, which the ngModelChange
+                    // reset handler treats as a form reset and clears actualValue. The plain
+                    // length clamp would then land the caret BEFORE the marker — keep it right
+                    // after the marker instead (#1572).
+                    const decimalMarker = this._maskService.decimalMarker;
+                    const prefix = this._maskService.prefix;
+                    const valueWithoutPrefix = el.value.startsWith(prefix)
+                        ? el.value.slice(prefix.length)
+                        : el.value;
+                    const isBareDecimalMarker = valueWithoutPrefix.length === 1 &&
+                        (Array.isArray(decimalMarker)
+                            ? decimalMarker.includes(valueWithoutPrefix)
+                            : valueWithoutPrefix === decimalMarker);
+                    positionToApply = isBareDecimalMarker
+                        ? this._getActualInputLength() + 1
+                        : this._getActualInputLength();
                 }
                 if (positionToApply < 0) {
                     positionToApply = 0;
@@ -2163,6 +2714,29 @@ class NgxMaskDirective {
             this._maskService.applyValueChanges(el.value.length, this._justPasted(), this._code() === MaskExpression.BACKSPACE || this._code() === MaskExpression.DELETE);
         }
     }
+    /**
+     * Whether any pattern slot of the current mask expression can accept a letter.
+     * IME composition is only meaningful for such masks; for purely numeric masks
+     * (digit patterns, separator, date/time, IP, CPF_CNPJ) waiting for compositionend
+     * only delays the model sync — and Samsung Keyboard may never fire it until blur
+     * (#1293). Unknown/letterless probe failures fall back to `false` (process live).
+     */
+    _maskAcceptsLetterInput() {
+        const patterns = this._maskService.patterns;
+        const maskExpression = this._maskService.maskExpression;
+        for (const symbol of maskExpression) {
+            const pattern = patterns[symbol]?.pattern;
+            if (!pattern) {
+                continue;
+            }
+            // Re-create without sticky/global flags: test() on those is stateful.
+            const probe = new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, ''));
+            if (probe.test('a') || probe.test('A')) {
+                return true;
+            }
+        }
+        return false;
+    }
     // IME starts
     onCompositionStart() {
         this._isComposing.set(true);
@@ -2170,6 +2744,12 @@ class NgxMaskDirective {
     // IME completes
     onCompositionEnd(e) {
         this._isComposing.set(false);
+        if (!this._maskAcceptsLetterInput()) {
+            // For letterless masks every edit was already processed live in onInput
+            // (#1293); reprocessing the same value through the paste path would
+            // double-apply the mask.
+            return;
+        }
         this._justPasted.set(true);
         this.onInput(e);
     }
@@ -2188,18 +2768,20 @@ class NgxMaskDirective {
                     const decimalPart = el.value.split(decimalMarker)[1];
                     el.value = el.value.includes(decimalMarker)
                         ? el.value +
-                            MaskExpression.NUMBER_ZERO.repeat(precision - decimalPart.length) +
+                            MaskExpression.NUMBER_ZERO.repeat(precision - (decimalPart?.length || 0)) +
                             suffix
                         : el.value +
                             decimalMarker +
                             MaskExpression.NUMBER_ZERO.repeat(precision) +
                             suffix;
                     this._maskService.actualValue = el.value;
+                    this.onChange(this._maskService.actualValue);
                 }
             }
             this._maskService.clearIfNotMatchFn();
         }
         this._isFocused.set(false);
+        this._maskService._isFocused.set(false);
         this.onTouch();
     }
     onClick(e) {
@@ -2263,7 +2845,15 @@ class NgxMaskDirective {
             // User finalize their choice from IME composition, so trigger onInput() for the composed text.
             if (e.key === 'Enter') {
                 this.onCompositionEnd(event);
+                return;
             }
+            // Android IMEs can keep a single composition open across many keystrokes
+            // (#1293): still capture the pre-edit value and selection that onInput
+            // relies on when it processes edits during composition.
+            const composingEl = e.target;
+            this._inputValue.set(composingEl.value);
+            this._maskService.selStart = composingEl.selectionStart;
+            this._maskService.selEnd = composingEl.selectionEnd;
             return;
         }
         this._code.set(e.code ? e.code : e.key);
@@ -2283,10 +2873,10 @@ class NgxMaskDirective {
                 }
                 if (e.key === MaskExpression.BACKSPACE && el.selectionStart !== 0) {
                     const prefixLength = this.prefix().length;
-                    // If specialChars is false, (shouldn't ever happen) then set to the defaults
-                    const specialCharacters = this.specialCharacters().length
-                        ? this.specialCharacters()
-                        : this._config.specialCharacters;
+                    // Use the service value: it holds the config defaults when the input is not
+                    // bound and the bound value otherwise, so an explicitly bound empty array is
+                    // respected instead of silently falling back to the defaults (#1512).
+                    const specialCharacters = this._maskService.specialCharacters;
                     if (prefixLength > 1 && el.selectionStart <= prefixLength) {
                         el.setSelectionRange(prefixLength, el.selectionEnd);
                     }
@@ -2315,8 +2905,17 @@ class NgxMaskDirective {
                     cursorStart === 0 &&
                     el.selectionEnd === el.value.length &&
                     el.value.length !== 0) {
-                    this._position.set(this._maskService.prefix ? this._maskService.prefix.length : 0);
-                    this._maskService.applyMask(this._maskService.prefix, this._maskService.maskExpression, this._position());
+                    // Handle the clear fully here instead of emitting the model change and
+                    // relying on the browser's default deletion + input event to update the
+                    // view: Firefox can drop the default action after the emission below
+                    // triggers change detection (DOM churn around the input), leaving the
+                    // model empty but the view untouched until a second Backspace (#1350).
+                    e.preventDefault();
+                    const displayValue = this._maskService.applyMask(MaskExpression.EMPTY_STRING, this._maskService.maskExpression, 0, false, true);
+                    el.value = displayValue;
+                    this._inputValue.set(displayValue);
+                    const caret = Math.min(this._maskService.prefix.length, displayValue.length);
+                    el.setSelectionRange(caret, caret);
                 }
             }
             if (!!this.suffix() &&
@@ -2334,8 +2933,53 @@ class NgxMaskDirective {
             this._maskService.selEnd = el.selectionEnd;
         }
     }
+    /**
+     * Restores the control's pristine/untouched state after a writeValue-driven emission.
+     *
+     * writeValue is a one-way model->view sync. When the mask normalizes the written value
+     * (e.g. leadZero '10.2' -> '10.20'), the directive must still emit the corrected value so
+     * the model adopts it — but that emission runs through Angular's view-change pipeline, which
+     * calls markAsDirty()/markAsTouched(). A programmatic setValue/patchValue must leave the
+     * control pristine, so we undo that side effect here when the control was pristine before
+     * the write. `onlySelf: true` keeps parent group state untouched.
+     */
+    _restoreControlStateAfterWrite(wasPristine, wasUntouched) {
+        const ngControl = this._resolveNgControl();
+        const control = ngControl?.control;
+        if (!control) {
+            return;
+        }
+        if (wasPristine && ngControl.dirty && typeof control.markAsPristine === 'function') {
+            control.markAsPristine({ onlySelf: true });
+        }
+        if (wasUntouched && ngControl.touched && typeof control.markAsUntouched === 'function') {
+            control.markAsUntouched({ onlySelf: true });
+        }
+    }
     /** It writes the value in the input */
     async writeValue(controlValue) {
+        if (!this._configApplied && this.mask()) {
+            // Called before the first ngOnChanges pass configured the mask service (happens with
+            // Signal Forms' [formField], whose control-sync instruction runs before sibling
+            // directives' ngOnChanges). Defer and replay once the configuration is applied.
+            this._pendingInitialValue = controlValue;
+            this._hasPendingInitialValue = true;
+            return;
+        }
+        // Skip the model echo of a value we just propagated ourselves (see the
+        // _lastPropagatedValue doc). Empty writes are never skipped: form reset('') must
+        // always clear the display and the currentValue/previousValue service state below.
+        const lastPropagated = this._lastPropagatedValue;
+        this._lastPropagatedValue = null;
+        if (lastPropagated !== null &&
+            lastPropagated !== '' &&
+            (typeof controlValue === 'string' || typeof controlValue === 'number') &&
+            String(controlValue) === lastPropagated) {
+            return;
+        }
+        const ngControl = this._resolveNgControl();
+        const wasPristine = ngControl ? Boolean(ngControl.pristine) : true;
+        const wasUntouched = ngControl ? Boolean(ngControl.untouched) : true;
         let value = controlValue;
         const inputTransformFn = this._maskService.inputTransformFn;
         if (typeof value === 'object' && value !== null && 'value' in value) {
@@ -2380,8 +3024,30 @@ class NgxMaskDirective {
                         .replace(MaskExpression.DOT, MaskExpression.COMMA);
                 }
                 if (this.mask()?.startsWith(MaskExpression.SEPARATOR) && this.leadZero()) {
+                    const isFirstWrite = !this._maskService.isInitialized;
                     requestAnimationFrame(() => {
+                        // On initial load, temporarily set isInitialized to false
+                        // so formControlResult returns early and doesn't mark form as dirty.
+                        // On later writeValue-driven writes, leave isInitialized as-is: this pass
+                        // may legitimately need to push a leadZero-normalized value (e.g.
+                        // '10.2' -> '10.20') back to the FormControl, which Angular's forms
+                        // pipeline can only do via the same onChange callback used for real user
+                        // edits — see the `should change formValue` unit tests, which assert the
+                        // normalized value lands in `form.value` after a programmatic setValue.
+                        if (isFirstWrite) {
+                            this._maskService.isInitialized = false;
+                        }
                         this._maskService.applyMask(inputValue?.toString() ?? '', this._maskService.maskExpression);
+                        if (isFirstWrite) {
+                            this._maskService.isInitialized = true;
+                        }
+                        // The leadZero normalization above emits the corrected value through the
+                        // view-change pipeline, which dirties/touches the control. Undo that so a
+                        // programmatic write stays pristine.
+                        this._restoreControlStateAfterWrite(wasPristine, wasUntouched);
+                        // Zoneless CD does not auto-flush after requestAnimationFrame; request
+                        // a check so form.pristine/form.value bindings reflect the new state.
+                        this._changeDetectorRef.markForCheck();
                     });
                 }
                 this._maskService.isNumberValue = true;
@@ -2396,48 +3062,87 @@ class NgxMaskDirective {
                     (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
                 this._maskService.writingValue = true;
-                this._maskService.formElementProperty = [
-                    'value',
-                    this._maskService.applyMask(inputValue, this._maskService.maskExpression),
-                ];
+                const displayValue = this._maskedOrVerbatim(inputValue);
+                this._maskService.formElementProperty = ['value', displayValue];
+                this._writeElementValueSync(displayValue);
                 // Let the service know we've finished writing value
                 this._maskService.writingValue = false;
                 this._maskService.isInitialized = true;
             }
             else {
                 this._maskService.formElementProperty = ['value', inputValue];
+                this._writeElementValueSync(inputValue);
                 this._maskService.isInitialized = true;
             }
-            this._inputValue.set(inputValue);
+            // A writeValue-driven emission may have dirtied/touched the control via the
+            // view-change pipeline; undo that so programmatic writes stay pristine.
+            this._restoreControlStateAfterWrite(wasPristine, wasUntouched);
+            // Programmatic writes (setValue/patchValue called outside a signal/effect context)
+            // don't schedule CD under zoneless change detection. Request a check so bindings
+            // reading form.pristine/form.dirty/form.value on the host template stay in sync.
+            this._changeDetectorRef.markForCheck();
         }
         else {
             // eslint-disable-next-line no-console
             console.warn('Ngx-mask writeValue work with string | number, your current value:', typeof value);
         }
     }
+    /**
+     * Mirrors a writeValue-driven render into the DOM synchronously, in the same
+     * change-detection pass (#1305). The service's `formElementProperty` setter defers all
+     * writes via queueMicrotask (to keep FIFO ordering with config-driven re-renders and
+     * dodge ExpressionChanged issues), but consumers that read `nativeElement.value` DURING
+     * the CD pass — Angular Material's floating label (`MatInput.empty`), CDK autofill —
+     * never see a value that only lands in a later microtask. The deferred write still runs
+     * afterwards and re-applies the same final value, so ordering guarantees are preserved.
+     *
+     * Skipped while a mask reconfiguration is pending (`mask()` input changed but
+     * `ngOnChanges` has not applied it yet — e.g. `mask.set(...)` + `setValue(...)` before
+     * the next CD pass): the value just computed used the STALE mask config, and rendering
+     * it synchronously would expose an intermediate state that the deferred pipeline is
+     * about to supersede. Multi-masks (`||`) resolve `_maskValue` to one alternative and
+     * therefore also fall back to the deferred-only path.
+     */
+    _writeElementValueSync(value) {
+        if ((this.mask() ?? MaskExpression.EMPTY_STRING) !== this._maskValue()) {
+            return;
+        }
+        this._renderer.setProperty(this._elementRef.nativeElement, 'value', value);
+    }
     registerOnChange(fn) {
-        // Wrap the original onChange to also update Signal Forms value
+        // Angular only calls this in classic ControlValueAccessor mode (reactive/template forms).
+        // Its invocation is therefore our reliable signal that we are NOT in Signal Forms mode.
+        this._isCvaMode.set(true);
         const originalFn = fn;
         this._maskService.onChange = this.onChange = (value) => {
             originalFn(value);
-            // Update Signal Forms value model if in use
-            if (this._isSignalFormsMode()) {
-                const stringValue = value === null || typeof value === 'undefined' ? '' : String(value);
-                if (this.value() !== stringValue) {
-                    this.value.set(stringValue);
-                }
-            }
+            this._propagateToValueModel(value);
         };
     }
     registerOnTouched(fn) {
         this.onTouch = () => {
             fn();
-            // Update Signal Forms touched state
-            if (this._isSignalFormsMode() && !this.touched()) {
+            if (!this.touched()) {
                 this.touched.set(true);
             }
         };
     }
+    /**
+     * Pushes the current unmasked value into the `value` model input. In Signal Forms mode this
+     * fires the `valueChange` output that Angular listens to; in CVA mode it is a harmless write
+     * to a model nobody reads. We flag `_skipNextValueEffect` so the resulting model change does
+     * not bounce back through the value effect and overwrite the raw `_inputValue`.
+     */
+    _propagateToValueModel(value) {
+        const stringValue = value === null || typeof value === 'undefined' ? '' : String(value);
+        this._lastPropagatedValue = stringValue;
+        untracked(() => {
+            if (String(this.value()) !== stringValue) {
+                this._skipNextValueEffect.set(true);
+                this.value.set(stringValue);
+            }
+        });
+    }
     /**
      * Focus the input element.
      * Required by FormValueControl interface for Signal Forms.
@@ -2469,9 +3174,37 @@ class NgxMaskDirective {
         this._maskService.maskExpression = this._maskService._repeatPatternSymbols(this._maskValue() || '');
         this._maskService.formElementProperty = [
             'value',
-            this._maskService.applyMask(this._inputValue(), this._maskService.maskExpression),
+            this._maskedOrVerbatim(this._inputValue()),
         ];
     }
+    /**
+     * Renders `inputValue` through the mask, falling back to the raw value verbatim when the
+     * mask cannot process ANY of it (#1615, e.g. a sentinel like 'ONGOING' written into a
+     * digits-only control). Values that PARTIALLY match keep regular masking.
+     *
+     * Shared by writeValue() and _applyMask() (called from every ngOnChanges pass, including
+     * ones triggered by an UNRELATED input like `disabled`) so the verbatim verdict for a
+     * value written once via writeValue() is not lost on a later re-render that replays the
+     * same raw `inputValue` outside of writeValue — which would otherwise re-run regular
+     * masking, produce an empty result, and emit it through onChange, clobbering the model.
+     *
+     * Excludes an actual mask RECONFIGURATION (`maskChanged`): when the mask itself just
+     * changed, a value that no longer matches must clear through the regular path (see
+     * trigger-on-mask-change.spec.ts) — verbatim passthrough only covers re-renders of the
+     * SAME mask.
+     */
+    _maskedOrVerbatim(inputValue) {
+        // Snapshot before applyMask(): it resets maskChanged internally as part of emitting
+        // (or skipping) the change, so it must be read before the call, not after.
+        const wasMaskChanged = this._maskService.maskChanged;
+        const maskedResult = this._maskService.applyMask(inputValue, this._maskService.maskExpression);
+        return !maskedResult &&
+            inputValue &&
+            !wasMaskChanged &&
+            this._maskService.removeMask(inputValue)
+            ? inputValue
+            : maskedResult;
+    }
     _validateTime(value) {
         const rowMaskLen = this._maskValue()
             .split(MaskExpression.EMPTY_STRING)
@@ -2489,6 +3222,98 @@ class NgxMaskDirective {
         return (this._maskService.actualValue.length ||
             this._maskService.actualValue.length + this._maskService.prefix.length);
     }
+    /**
+     * For `||` multi-masks only (#1583): a value shorter than the currently selected
+     * alternative is still valid when it is a pattern-valid prefix of that alternative
+     * ending exactly at a special-character boundary (e.g. `0` for `0,N`) and it meets
+     * the length requirement of at least one alternative (e.g. `1`). Values stopping
+     * mid-pattern-block (e.g. `112A` for `000SS`) remain invalid.
+     */
+    _isCompleteAlternativeBoundary(processedValue) {
+        const alternatives = this._maskExpressionArray();
+        if (!alternatives.length) {
+            return false;
+        }
+        const maskValue = this._maskValue();
+        const cleanValue = this._maskService.removeMask(processedValue);
+        const cleanMask = this._maskService.removeMask(maskValue);
+        const isPatternPrefix = cleanValue
+            .split(MaskExpression.EMPTY_STRING)
+            .every((character, index) => this._maskService._checkSymbolMask(character, cleanMask.charAt(index)));
+        if (!isPatternPrefix) {
+            return false;
+        }
+        let patternCount = 0;
+        let boundaryCharacter = MaskExpression.EMPTY_STRING;
+        for (const maskCharacter of maskValue) {
+            if (patternCount === cleanValue.length) {
+                boundaryCharacter = maskCharacter;
+                break;
+            }
+            if (!this._maskService.specialCharacters.includes(maskCharacter)) {
+                patternCount++;
+            }
+        }
+        if (!boundaryCharacter ||
+            !this._maskService.specialCharacters.includes(boundaryCharacter)) {
+            return false;
+        }
+        return alternatives.some((alternative) => {
+            const requiredLength = this._maskService.dropSpecialCharacters
+                ? alternative.length - this._maskService.checkDropSpecialCharAmount(alternative)
+                : this.prefix()
+                    ? alternative.length + this.prefix().length
+                    : alternative.length;
+            return processedValue.length >= requiredLength;
+        });
+    }
+    /**
+     * True when every character of the mask expression is either a pattern token or a
+     * special character — i.e. the mask has no quantifiers (`*`, `?`), curly-bracket
+     * repetitions or other constructs the position-aware matcher does not model.
+     */
+    _isPlainTokenMask(mask) {
+        return mask
+            .split(MaskExpression.EMPTY_STRING)
+            .every((symbol) => !!this._maskService.patterns[symbol] ||
+            this._maskService.specialCharacters.includes(symbol));
+    }
+    /**
+     * Backtracking match of a value against a mask mixing optional and mandatory pattern
+     * tokens (#1515, e.g. `999SSS`). Optional tokens may be left unfilled; special
+     * characters may be absent from the value (dropSpecialCharacters). The value is valid
+     * when it is fully consumed and every remaining mask token is optional or special.
+     */
+    _matchesMaskWithOptionalSkip(value, mask) {
+        const patterns = this._maskService.patterns;
+        const match = (maskIndex, valueIndex) => {
+            if (valueIndex === value.length) {
+                return mask
+                    .slice(maskIndex)
+                    .split(MaskExpression.EMPTY_STRING)
+                    .every((symbol) => !patterns[symbol] || !!patterns[symbol]?.optional);
+            }
+            if (maskIndex === mask.length) {
+                return false;
+            }
+            const maskSymbol = mask[maskIndex];
+            const valueSymbol = value[valueIndex];
+            const pattern = patterns[maskSymbol];
+            if (pattern) {
+                if (pattern.pattern.test(valueSymbol) && match(maskIndex + 1, valueIndex + 1)) {
+                    return true;
+                }
+                return !!pattern.optional && match(maskIndex + 1, valueIndex);
+            }
+            // Special character: consume it when present in the value, otherwise treat it
+            // as dropped (dropSpecialCharacters).
+            if (valueSymbol === maskSymbol && match(maskIndex + 1, valueIndex + 1)) {
+                return true;
+            }
+            return match(maskIndex + 1, valueIndex);
+        };
+        return match(0, 0);
+    }
     _createValidationError(actualValue) {
         return {
             mask: {
@@ -2555,8 +3380,8 @@ class NgxMaskDirective {
             return uniqueCharacters.size === 1;
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.1.1", type: NgxMaskDirective, isStandalone: true, selector: "input[mask], textarea[mask]", inputs: { mask: { classPropertyName: "mask", publicName: "mask", isSignal: true, isRequired: false, transformFunction: null }, specialCharacters: { classPropertyName: "specialCharacters", publicName: "specialCharacters", isSignal: true, isRequired: false, transformFunction: null }, patterns: { classPropertyName: "patterns", publicName: "patterns", isSignal: true, isRequired: false, transformFunction: null }, prefix: { classPropertyName: "prefix", publicName: "prefix", isSignal: true, isRequired: false, transformFunction: null }, suffix: { classPropertyName: "suffix", publicName: "suffix", isSignal: true, isRequired: false, transformFunction: null }, thousandSeparator: { classPropertyName: "thousandSeparator", publicName: "thousandSeparator", isSignal: true, isRequired: false, transformFunction: null }, decimalMarker: { classPropertyName: "decimalMarker", publicName: "decimalMarker", isSignal: true, isRequired: false, transformFunction: null }, dropSpecialCharacters: { classPropertyName: "dropSpecialCharacters", publicName: "dropSpecialCharacters", isSignal: true, isRequired: false, transformFunction: null }, hiddenInput: { classPropertyName: "hiddenInput", publicName: "hiddenInput", isSignal: true, isRequired: false, transformFunction: null }, showMaskTyped: { classPropertyName: "showMaskTyped", publicName: "showMaskTyped", isSignal: true, isRequired: false, transformFunction: null }, placeHolderCharacter: { classPropertyName: "placeHolderCharacter", publicName: "placeHolderCharacter", isSignal: true, isRequired: false, transformFunction: null }, shownMaskExpression: { classPropertyName: "shownMaskExpression", publicName: "shownMaskExpression", isSignal: true, isRequired: false, transformFunction: null }, clearIfNotMatch: { classPropertyName: "clearIfNotMatch", publicName: "clearIfNotMatch", isSignal: true, isRequired: false, transformFunction: null }, validation: { classPropertyName: "validation", publicName: "validation", isSignal: true, isRequired: false, transformFunction: null }, separatorLimit: { classPropertyName: "separatorLimit", publicName: "separatorLimit", isSignal: true, isRequired: false, transformFunction: null }, allowNegativeNumbers: { classPropertyName: "allowNegativeNumbers", publicName: "allowNegativeNumbers", isSignal: true, isRequired: false, transformFunction: null }, leadZeroDateTime: { classPropertyName: "leadZeroDateTime", publicName: "leadZeroDateTime", isSignal: true, isRequired: false, transformFunction: null }, leadZero: { classPropertyName: "leadZero", publicName: "leadZero", isSignal: true, isRequired: false, transformFunction: null }, triggerOnMaskChange: { classPropertyName: "triggerOnMaskChange", publicName: "triggerOnMaskChange", isSignal: true, isRequired: false, transformFunction: null }, apm: { classPropertyName: "apm", publicName: "apm", isSignal: true, isRequired: false, transformFunction: null }, inputTransformFn: { classPropertyName: "inputTransformFn", publicName: "inputTransformFn", isSignal: true, isRequired: false, transformFunction: null }, outputTransformFn: { classPropertyName: "outputTransformFn", publicName: "outputTransformFn", isSignal: true, isRequired: false, transformFunction: null }, keepCharacterPositions: { classPropertyName: "keepCharacterPositions", publicName: "keepCharacterPositions", isSignal: true, isRequired: false, transformFunction: null }, instantPrefix: { classPropertyName: "instantPrefix", publicName: "instantPrefix", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, errors: { classPropertyName: "errors", publicName: "errors", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, touched: { classPropertyName: "touched", publicName: "touched", isSignal: true, isRequired: false, transformFunction: null }, dirty: { classPropertyName: "dirty", publicName: "dirty", isSignal: true, isRequired: false, transformFunction: null }, invalid: { classPropertyName: "invalid", publicName: "invalid", isSignal: true, isRequired: false, transformFunction: null }, pending: { classPropertyName: "pending", publicName: "pending", isSignal: true, isRequired: false, transformFunction: null }, readonly: { classPropertyName: "readonly", publicName: "readonly", isSignal: true, isRequired: false, transformFunction: null }, required: { classPropertyName: "required", publicName: "required", isSignal: true, isRequired: false, transformFunction: null }, name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", touched: "touchedChange", maskFilled: "maskFilled" }, host: { listeners: { "paste": "onPaste()", "focus": "onFocus()", "ngModelChange": "onModelChange($event)", "input": "onInput($event)", "compositionstart": "onCompositionStart()", "compositionend": "onCompositionEnd($event)", "blur": "onBlur($event)", "click": "onClick($event)", "keydown": "onKeyDown($event)" } }, providers: [
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.17", type: NgxMaskDirective, isStandalone: true, selector: "input[mask], textarea[mask]", inputs: { mask: { classPropertyName: "mask", publicName: "mask", isSignal: true, isRequired: false, transformFunction: null }, specialCharacters: { classPropertyName: "specialCharacters", publicName: "specialCharacters", isSignal: true, isRequired: false, transformFunction: null }, patterns: { classPropertyName: "patterns", publicName: "patterns", isSignal: true, isRequired: false, transformFunction: null }, prefix: { classPropertyName: "prefix", publicName: "prefix", isSignal: true, isRequired: false, transformFunction: null }, suffix: { classPropertyName: "suffix", publicName: "suffix", isSignal: true, isRequired: false, transformFunction: null }, thousandSeparator: { classPropertyName: "thousandSeparator", publicName: "thousandSeparator", isSignal: true, isRequired: false, transformFunction: null }, decimalMarker: { classPropertyName: "decimalMarker", publicName: "decimalMarker", isSignal: true, isRequired: false, transformFunction: null }, dropSpecialCharacters: { classPropertyName: "dropSpecialCharacters", publicName: "dropSpecialCharacters", isSignal: true, isRequired: false, transformFunction: null }, hiddenInput: { classPropertyName: "hiddenInput", publicName: "hiddenInput", isSignal: true, isRequired: false, transformFunction: null }, showMaskTyped: { classPropertyName: "showMaskTyped", publicName: "showMaskTyped", isSignal: true, isRequired: false, transformFunction: null }, placeHolderCharacter: { classPropertyName: "placeHolderCharacter", publicName: "placeHolderCharacter", isSignal: true, isRequired: false, transformFunction: null }, shownMaskExpression: { classPropertyName: "shownMaskExpression", publicName: "shownMaskExpression", isSignal: true, isRequired: false, transformFunction: null }, clearIfNotMatch: { classPropertyName: "clearIfNotMatch", publicName: "clearIfNotMatch", isSignal: true, isRequired: false, transformFunction: null }, validation: { classPropertyName: "validation", publicName: "validation", isSignal: true, isRequired: false, transformFunction: null }, separatorLimit: { classPropertyName: "separatorLimit", publicName: "separatorLimit", isSignal: true, isRequired: false, transformFunction: null }, allowNegativeNumbers: { classPropertyName: "allowNegativeNumbers", publicName: "allowNegativeNumbers", isSignal: true, isRequired: false, transformFunction: null }, leadZeroDateTime: { classPropertyName: "leadZeroDateTime", publicName: "leadZeroDateTime", isSignal: true, isRequired: false, transformFunction: null }, leadZero: { classPropertyName: "leadZero", publicName: "leadZero", isSignal: true, isRequired: false, transformFunction: null }, triggerOnMaskChange: { classPropertyName: "triggerOnMaskChange", publicName: "triggerOnMaskChange", isSignal: true, isRequired: false, transformFunction: null }, apm: { classPropertyName: "apm", publicName: "apm", isSignal: true, isRequired: false, transformFunction: null }, inputTransformFn: { classPropertyName: "inputTransformFn", publicName: "inputTransformFn", isSignal: true, isRequired: false, transformFunction: null }, outputTransformFn: { classPropertyName: "outputTransformFn", publicName: "outputTransformFn", isSignal: true, isRequired: false, transformFunction: null }, keepCharacterPositions: { classPropertyName: "keepCharacterPositions", publicName: "keepCharacterPositions", isSignal: true, isRequired: false, transformFunction: null }, instantPrefix: { classPropertyName: "instantPrefix", publicName: "instantPrefix", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, touched: { classPropertyName: "touched", publicName: "touched", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", touched: "touchedChange", maskFilled: "maskFilled" }, host: { listeners: { "paste": "onPaste()", "focus": "onFocus()", "ngModelChange": "onModelChange($event)", "input": "onInput($event)", "compositionstart": "onCompositionStart()", "compositionend": "onCompositionEnd($event)", "blur": "onBlur($event)", "click": "onClick($event)", "keydown": "onKeyDown($event)" } }, providers: [
             {
                 provide: NG_VALUE_ACCESSOR,
                 useExisting: NgxMaskDirective,
@@ -2570,7 +3395,7 @@ class NgxMaskDirective {
             NgxMaskService,
         ], exportAs: ["mask", "ngxMask"], usesOnChanges: true, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: 'input[mask], textarea[mask]',
@@ -2590,7 +3415,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImpor
                     ],
                     exportAs: 'mask,ngxMask',
                 }]
-        }], ctorParameters: () => [], propDecorators: { mask: [{ type: i0.Input, args: [{ isSignal: true, alias: "mask", required: false }] }], specialCharacters: [{ type: i0.Input, args: [{ isSignal: true, alias: "specialCharacters", required: false }] }], patterns: [{ type: i0.Input, args: [{ isSignal: true, alias: "patterns", required: false }] }], prefix: [{ type: i0.Input, args: [{ isSignal: true, alias: "prefix", required: false }] }], suffix: [{ type: i0.Input, args: [{ isSignal: true, alias: "suffix", required: false }] }], thousandSeparator: [{ type: i0.Input, args: [{ isSignal: true, alias: "thousandSeparator", required: false }] }], decimalMarker: [{ type: i0.Input, args: [{ isSignal: true, alias: "decimalMarker", required: false }] }], dropSpecialCharacters: [{ type: i0.Input, args: [{ isSignal: true, alias: "dropSpecialCharacters", required: false }] }], hiddenInput: [{ type: i0.Input, args: [{ isSignal: true, alias: "hiddenInput", required: false }] }], showMaskTyped: [{ type: i0.Input, args: [{ isSignal: true, alias: "showMaskTyped", required: false }] }], placeHolderCharacter: [{ type: i0.Input, args: [{ isSignal: true, alias: "placeHolderCharacter", required: false }] }], shownMaskExpression: [{ type: i0.Input, args: [{ isSignal: true, alias: "shownMaskExpression", required: false }] }], clearIfNotMatch: [{ type: i0.Input, args: [{ isSignal: true, alias: "clearIfNotMatch", required: false }] }], validation: [{ type: i0.Input, args: [{ isSignal: true, alias: "validation", required: false }] }], separatorLimit: [{ type: i0.Input, args: [{ isSignal: true, alias: "separatorLimit", required: false }] }], allowNegativeNumbers: [{ type: i0.Input, args: [{ isSignal: true, alias: "allowNegativeNumbers", required: false }] }], leadZeroDateTime: [{ type: i0.Input, args: [{ isSignal: true, alias: "leadZeroDateTime", required: false }] }], leadZero: [{ type: i0.Input, args: [{ isSignal: true, alias: "leadZero", required: false }] }], triggerOnMaskChange: [{ type: i0.Input, args: [{ isSignal: true, alias: "triggerOnMaskChange", required: false }] }], apm: [{ type: i0.Input, args: [{ isSignal: true, alias: "apm", required: false }] }], inputTransformFn: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputTransformFn", required: false }] }], outputTransformFn: [{ type: i0.Input, args: [{ isSignal: true, alias: "outputTransformFn", required: false }] }], keepCharacterPositions: [{ type: i0.Input, args: [{ isSignal: true, alias: "keepCharacterPositions", required: false }] }], instantPrefix: [{ type: i0.Input, args: [{ isSignal: true, alias: "instantPrefix", required: false }] }], value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }, { type: i0.Output, args: ["valueChange"] }], errors: [{ type: i0.Input, args: [{ isSignal: true, alias: "errors", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], touched: [{ type: i0.Input, args: [{ isSignal: true, alias: "touched", required: false }] }, { type: i0.Output, args: ["touchedChange"] }], dirty: [{ type: i0.Input, args: [{ isSignal: true, alias: "dirty", required: false }] }], invalid: [{ type: i0.Input, args: [{ isSignal: true, alias: "invalid", required: false }] }], pending: [{ type: i0.Input, args: [{ isSignal: true, alias: "pending", required: false }] }], readonly: [{ type: i0.Input, args: [{ isSignal: true, alias: "readonly", required: false }] }], required: [{ type: i0.Input, args: [{ isSignal: true, alias: "required", required: false }] }], name: [{ type: i0.Input, args: [{ isSignal: true, alias: "name", required: false }] }], maskFilled: [{ type: i0.Output, args: ["maskFilled"] }], onPaste: [{
+        }], ctorParameters: () => [], propDecorators: { mask: [{ type: i0.Input, args: [{ isSignal: true, alias: "mask", required: false }] }], specialCharacters: [{ type: i0.Input, args: [{ isSignal: true, alias: "specialCharacters", required: false }] }], patterns: [{ type: i0.Input, args: [{ isSignal: true, alias: "patterns", required: false }] }], prefix: [{ type: i0.Input, args: [{ isSignal: true, alias: "prefix", required: false }] }], suffix: [{ type: i0.Input, args: [{ isSignal: true, alias: "suffix", required: false }] }], thousandSeparator: [{ type: i0.Input, args: [{ isSignal: true, alias: "thousandSeparator", required: false }] }], decimalMarker: [{ type: i0.Input, args: [{ isSignal: true, alias: "decimalMarker", required: false }] }], dropSpecialCharacters: [{ type: i0.Input, args: [{ isSignal: true, alias: "dropSpecialCharacters", required: false }] }], hiddenInput: [{ type: i0.Input, args: [{ isSignal: true, alias: "hiddenInput", required: false }] }], showMaskTyped: [{ type: i0.Input, args: [{ isSignal: true, alias: "showMaskTyped", required: false }] }], placeHolderCharacter: [{ type: i0.Input, args: [{ isSignal: true, alias: "placeHolderCharacter", required: false }] }], shownMaskExpression: [{ type: i0.Input, args: [{ isSignal: true, alias: "shownMaskExpression", required: false }] }], clearIfNotMatch: [{ type: i0.Input, args: [{ isSignal: true, alias: "clearIfNotMatch", required: false }] }], validation: [{ type: i0.Input, args: [{ isSignal: true, alias: "validation", required: false }] }], separatorLimit: [{ type: i0.Input, args: [{ isSignal: true, alias: "separatorLimit", required: false }] }], allowNegativeNumbers: [{ type: i0.Input, args: [{ isSignal: true, alias: "allowNegativeNumbers", required: false }] }], leadZeroDateTime: [{ type: i0.Input, args: [{ isSignal: true, alias: "leadZeroDateTime", required: false }] }], leadZero: [{ type: i0.Input, args: [{ isSignal: true, alias: "leadZero", required: false }] }], triggerOnMaskChange: [{ type: i0.Input, args: [{ isSignal: true, alias: "triggerOnMaskChange", required: false }] }], apm: [{ type: i0.Input, args: [{ isSignal: true, alias: "apm", required: false }] }], inputTransformFn: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputTransformFn", required: false }] }], outputTransformFn: [{ type: i0.Input, args: [{ isSignal: true, alias: "outputTransformFn", required: false }] }], keepCharacterPositions: [{ type: i0.Input, args: [{ isSignal: true, alias: "keepCharacterPositions", required: false }] }], instantPrefix: [{ type: i0.Input, args: [{ isSignal: true, alias: "instantPrefix", required: false }] }], value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }, { type: i0.Output, args: ["valueChange"] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], touched: [{ type: i0.Input, args: [{ isSignal: true, alias: "touched", required: false }] }, { type: i0.Output, args: ["touchedChange"] }], maskFilled: [{ type: i0.Output, args: ["maskFilled"] }], onPaste: [{
                 type: HostListener,
                 args: ['paste']
             }], onFocus: [{
@@ -2703,10 +3528,10 @@ class NgxMaskPipe {
             });
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskPipe, isStandalone: true, name: "mask" });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskPipe, isStandalone: true, name: "mask" });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: NgxMaskPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: NgxMaskPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'mask',