ngx-digits-only 1.0.0

package/fesm2022/ngx-digits-only.mjs

@@ -0,0 +1,1847 @@
+import * as i0 from '@angular/core';
+import { forwardRef, HostListener, Input, Inject, Directive } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';
+
+/**
+ * digits-only.regex.ts
+ *
+ * Every regular expression used by the digitsOnly directive lives here.
+ * Each constant has a plain-English name, a detailed breakdown, and live examples
+ * so you never have to decode cryptic patterns inside the directive itself.
+ *
+ * Import what you need:
+ *   import { REGEX } from './digits-only.regex';
+ *   REGEX.SINGLE_DIGIT.test('5')   // true
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// HOW TO READ REGEX ANATOMY
+// ─────────────────────────────────────────────────────────────────────────────
+//
+//   /pattern/flags
+//    │       │
+//    │       └── modifiers:  g = global (find ALL matches, not just first)
+//    │                       i = case-insensitive
+//    │                       m = multiline
+//    │
+//    └── special characters:
+//          ^      start of string (or line with m flag)
+//          $      end of string   (or line with m flag)
+//          .      any single character except newline
+//          \d     any digit  [0-9]
+//          \D     any NON-digit
+//          \w     word character [a-zA-Z0-9_]
+//          \s     whitespace
+//          \B     NON-word boundary position
+//          [abc]  character class – matches a, b, or c
+//          [^abc] negated class  – matches anything EXCEPT a, b, c
+//          (abc)  capture group
+//          (?=x)  positive lookahead – "followed by x" (zero-width, no consume)
+//          (?!x)  negative lookahead – "NOT followed by x"
+//          {n}    exactly n repetitions
+//          {n,}   n or more repetitions
+//          +      one or more  (greedy)
+//          *      zero or more (greedy)
+//          ?      zero or one  (optional)
+//          \.     escaped dot  – a literal '.' character
+//          \\     escaped backslash – a literal '\'
+//          \-     escaped hyphen inside [] – a literal '-'
+//          $&     in replacement strings: the entire matched text
+const REGEX = {
+    // ──────────────────────────────────────────────────────────────────────────
+    // 1. SINGLE_DIGIT
+    //    Is this one keyboard character exactly a digit and nothing else?
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Pattern breakdown:
+    //    ^   – anchor: string must START here
+    //    \d  – one digit character (0, 1, 2 … 9)
+    //    $   – anchor: string must END here
+    //
+    //  The ^ and $ together mean the whole string must be exactly one digit.
+    //  Without them, /\d/ would match '5' inside 'abc5xyz' too.
+    //
+    //  Used in:  onKeyDown() — to decide if a pressed key is a digit
+    //
+    //  ✔ matches:    '0'  '5'  '9'
+    //  ✖ no match:   'a'  '-'  '.'  'Enter'  '12'  ''
+    //
+    SINGLE_DIGIT: /^\d$/,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 2. NON_DIGIT_CHARACTERS
+    //    Find (and remove) every character that is NOT a digit.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Pattern breakdown:
+    //    [^0-9]  – negated character class
+    //               ^ inside []  = NOT
+    //               0-9          = any digit
+    //             → "any character that is not 0 through 9"
+    //    g       – global flag: match ALL occurrences, not just the first
+    //
+    //  Used in:  onKeyDown (count digits), validate (count digits), onPaste
+    //
+    //  Purpose:  Calling .replace(NON_DIGIT_CHARACTERS, '') strips everything
+    //            except digits so we can measure the pure digit length,
+    //            ignoring separators, dots, minus signs, prefix/suffix.
+    //
+    //  Examples:
+    //    '$1,234.56'.replace(REGEX.NON_DIGIT_CHARACTERS, '')  →  '123456'
+    //    '-99_000'.replace(REGEX.NON_DIGIT_CHARACTERS, '')    →  '99000'
+    //    '007'.replace(REGEX.NON_DIGIT_CHARACTERS, '')        →  '007'
+    //
+    NON_DIGIT_CHARACTERS: /[^0-9]/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 3. ONLY_DIGITS_AND_MINUS
+    //    Remove everything except digits and the minus sign.
+    //    Used for integer-mode paste sanitization.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Pattern breakdown:
+    //    [^0-9\-]  – negated class that keeps digits and the literal hyphen
+    //                \-  = escaped hyphen (a bare '-' in the middle of [] is
+    //                      treated as a range operator, e.g. [a-z];
+    //                      escaping with \ makes it a literal minus character)
+    //    g         – global
+    //
+    //  Used in:  sanitizePastedText() when decimalPlaces === 0
+    //
+    //  Examples (integers only, negatives allowed):
+    //    '1,234.56'.replace(REGEX.ONLY_DIGITS_AND_MINUS, '')   →  '123456'
+    //    '-99.9%'.replace(REGEX.ONLY_DIGITS_AND_MINUS, '')     →  '-999'
+    //    '007'.replace(REGEX.ONLY_DIGITS_AND_MINUS, '')        →  '007'
+    //
+    ONLY_DIGITS_AND_MINUS: /[^0-9\-]/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 4. ONLY_DIGITS_DOT_AND_MINUS
+    //    Remove everything except digits, a decimal point, and the minus sign.
+    //    Used for decimal-number paste sanitization.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Pattern breakdown:
+    //    [^0-9.\-]  – negated class
+    //                  .  inside [] is a literal dot (no escape needed inside [])
+    //                  \- is the literal minus
+    //    g          – global
+    //
+    //  Difference from ONLY_DIGITS_AND_MINUS:
+    //    This one also KEEPS the dot '.' so decimal numbers like '12.5' survive.
+    //
+    //  Used in:  sanitizePastedText() when decimalPlaces > 0
+    //
+    //  Examples:
+    //    '$-1,234.56 USD'.replace(REGEX.ONLY_DIGITS_DOT_AND_MINUS, '')  →  '-1234.56'
+    //    '€ 99.9%'.replace(REGEX.ONLY_DIGITS_DOT_AND_MINUS, '')         →  '99.9'
+    //    'abc123def'.replace(REGEX.ONLY_DIGITS_DOT_AND_MINUS, '')       →  '123'
+    //
+    ONLY_DIGITS_DOT_AND_MINUS: /[^0-9.\-]/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 5. ONLY_DIGITS
+    //    Remove everything except bare digits.
+    //    Used for string-mode (identifiers like card numbers) where dots and
+    //    minus signs are also illegal.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Pattern breakdown:
+    //    [^0-9]  – keep only digit characters
+    //    g       – global
+    //
+    //  Used in:  sanitizePastedText() in string / pattern mode,
+    //            onPaste() in pattern mode,
+    //            _applyPattern() to extract digit string before formatting
+    //
+    //  Examples:
+    //    '4111-1111-1111-1111'.replace(REGEX.ONLY_DIGITS, '')  →  '4111111111111111'
+    //    '(555) 867-5309'.replace(REGEX.ONLY_DIGITS, '')       →  '5558675309'
+    //    '01/01/1990'.replace(REGEX.ONLY_DIGITS, '')           →  '01011990'
+    //
+    ONLY_DIGITS: /[^0-9]/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 6. ALL_DOTS
+    //    Remove every dot/period from a string.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Pattern breakdown:
+    //    \.  – escaped dot.
+    //          In regex, a bare '.' means "any character except newline".
+    //          The backslash \ escapes it to mean a LITERAL period character.
+    //          Without the backslash, /./g would erase EVERY character.
+    //    g   – global: remove all dots, not just the first
+    //
+    //  Used in:  onInput() and onPaste() when decimalPlaces === 0 or pattern is set.
+    //            If integers are expected, any dot that slips through (e.g. from paste)
+    //            must be stripped.
+    //
+    //  Examples:
+    //    '12.34'.replace(REGEX.ALL_DOTS, '')   →  '1234'
+    //    '1.2.3'.replace(REGEX.ALL_DOTS, '')   →  '123'
+    //    '100'.replace(REGEX.ALL_DOTS, '')     →  '100'   (no dot, unchanged)
+    //
+    ALL_DOTS: /\./g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 7. ALL_MINUS_SIGNS
+    //    Remove every minus / hyphen character from a string.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Pattern breakdown:
+    //    -   – a literal hyphen/minus character
+    //          (safe outside of a character class [] without escaping)
+    //    g   – global
+    //
+    //  Used in:  sanitizePastedText() to strip minus signs when allowNegative is false
+    //            or when outputType is 'string' (identifiers can't be negative).
+    //
+    //  Examples:
+    //    '-99'.replace(REGEX.ALL_MINUS_SIGNS, '')      →  '99'
+    //    '1-2-3'.replace(REGEX.ALL_MINUS_SIGNS, '')    →  '123'
+    //
+    ALL_MINUS_SIGNS: /-/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 8. THOUSANDS_SEPARATOR_POSITIONS
+    //    Find every position in the INTEGER PART of a number where a thousands
+    //    separator (comma, dot, space, underscore) should be inserted.
+    //    This is the most sophisticated regex in the codebase.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Full pattern:  /\B(?=(\d{3})+(?!\d))/g
+    //
+    //  Token-by-token breakdown:
+    //
+    //    \B          – NON-word-boundary position.
+    //                  Matches a position that is NOT at the very start of the
+    //                  string and NOT right after a non-word character.
+    //                  This prevents a separator being inserted before the first
+    //                  digit (e.g. ",1,234" would be wrong).
+    //
+    //    (?=         – POSITIVE LOOKAHEAD — zero-width assertion.
+    //                  "The following characters must match, but don't consume them."
+    //                  The regex engine peeks ahead without advancing its position.
+    //
+    //      (\d{3})+  – one or more groups of EXACTLY THREE digits.
+    //                    \d   = any digit
+    //                    {3}  = exactly 3 of them
+    //                    +    = one or more such groups (so 3, 6, 9, 12 … digits ahead)
+    //
+    //      (?!\d)    – NEGATIVE LOOKAHEAD.
+    //                  "What follows the groups of 3 is NOT another digit."
+    //                  This anchors the groups to the END of the number so the
+    //                  separator only lands at multiples of 3 from the RIGHT.
+    //
+    //    )           – close the positive lookahead
+    //    g           – global: insert at every valid position
+    //
+    //  How the engine works step-by-step on '1234567':
+    //
+    //    Position between '1' and '2'  → lookahead sees '234567' → 6 digits → 6=3×2 ✔ → INSERT
+    //    Position between '2' and '3'  → lookahead sees '34567'  → 5 digits → not ÷3 ✖
+    //    Position between '3' and '4'  → lookahead sees '4567'   → 4 digits → not ÷3 ✖
+    //    Position between '4' and '5'  → lookahead sees '567'    → 3 digits → 3=3×1 ✔ → INSERT
+    //    … and so on
+    //    Result → '1,234,567'
+    //
+    //  Works with ANY separator — just change the replacement string:
+    //    '1234567'.replace(REGEX.THOUSANDS_SEPARATOR_POSITIONS, ',')  → '1,234,567'
+    //    '1234567'.replace(REGEX.THOUSANDS_SEPARATOR_POSITIONS, '.')  → '1.234.567'
+    //    '1234567'.replace(REGEX.THOUSANDS_SEPARATOR_POSITIONS, ' ')  → '1 234 567'
+    //    '1234567'.replace(REGEX.THOUSANDS_SEPARATOR_POSITIONS, '_')  → '1_234_567'
+    //
+    //  More examples:
+    //    '1234'      → '1,234'
+    //    '100'       → '100'         (fewer than 4 digits — no separator)
+    //    '1000000'   → '1,000,000'
+    //
+    THOUSANDS_SEPARATOR_POSITIONS: /\B(?=(\d{3})+(?!\d))/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 9. REGEX_SPECIAL_CHARACTERS
+    //    Escape any character that has a special meaning inside a RegExp pattern.
+    //    Used before passing a user-supplied string into new RegExp(…).
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Why this is needed:
+    //    The thousandSeparator input can be '.', which inside a regex means
+    //    "any character", not a literal dot.  Before building
+    //    new RegExp(thousandSeparator, 'g') we must escape it to '\.'
+    //    so it matches only a literal period.
+    //
+    //  The replacement string '\\$&' means:
+    //    \\  – insert a literal backslash
+    //    $&  – followed by the matched character itself
+    //    So '.' becomes '\.' and '(' becomes '\(' etc.
+    //
+    //  Pattern breakdown (character class contents):
+    //    .      – dot
+    //    *      – asterisk
+    //    +      – plus
+    //    ?      – question mark
+    //    ^      – caret
+    //    $      – dollar sign
+    //    {  }   – curly braces
+    //    (  )   – parentheses
+    //    |      – pipe
+    //    [      – open bracket
+    //    \]     – close bracket (must be escaped to close the class correctly)
+    //    \\     – backslash (represents a single \)
+    //    g      – global
+    //
+    //  Used in:  _stripDecoration(), _stripPatternSeparators()
+    //            Anywhere a dynamic string is inserted into new RegExp(…)
+    //
+    //  Examples:
+    //    '.'.replace(REGEX.REGEX_SPECIAL_CHARACTERS, '\\$&')   →  '\\.'
+    //    ','.replace(REGEX.REGEX_SPECIAL_CHARACTERS, '\\$&')   →  ','   (no change)
+    //    '('.replace(REGEX.REGEX_SPECIAL_CHARACTERS, '\\$&')   →  '\\('
+    //    ' '.replace(REGEX.REGEX_SPECIAL_CHARACTERS, '\\$&')   →  ' '   (no change)
+    //
+    REGEX_SPECIAL_CHARACTERS: /[.*+?^${}()|[\]\\]/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 10. LEADING_ZEROS
+    //     Remove leading zeros from the integer part, keeping at least one digit.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Pattern breakdown:
+    //    ^     – anchor at the start of the string
+    //    0+    – one or more '0' characters (the leading zeros to remove)
+    //    (     – open capture group 1
+    //    \d    – one digit (the first SIGNIFICANT digit after the zeros)
+    //    )     – close capture group 1
+    //
+    //  No 'g' flag — we only care about the beginning of the string.
+    //
+    //  Replacement '$1':
+    //    $1 = capture group 1 = the first significant digit.
+    //    The entire match (zeros + that digit) is replaced by just that digit.
+    //    Any digits AFTER it in the string are left untouched.
+    //
+    //  Used in:  _stripLeadingZeros()
+    //
+    //  Examples:
+    //    '007'.replace(REGEX.LEADING_ZEROS, '$1')    →  '7'
+    //    '0042'.replace(REGEX.LEADING_ZEROS, '$1')   →  '42'
+    //    '0.5'.replace(REGEX.LEADING_ZEROS, '$1')    →  '0.5'   (no match — char after 0 is '.')
+    //    '100'.replace(REGEX.LEADING_ZEROS, '$1')    →  '100'   (no match — first char is '1')
+    //    '0'.replace(REGEX.LEADING_ZEROS, '$1')      →  '0'     (no match — no digit after the 0)
+    //
+    LEADING_ZEROS: /^0+(\d)/,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 11. ARABIC_DIGITS
+    //     Match Arabic-Indic digit characters (used across Middle East & South Asia).
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Unicode range:
+    //    \u0660  = Arabic-Indic digit zero  ٠
+    //    \u0669  = Arabic-Indic digit nine  ٩
+    //    [\u0660-\u0669] matches any of the 10 Arabic-Indic digit characters.
+    //
+    //  g flag: replace ALL occurrences in one pass.
+    //
+    //  Used in:  convertEasternDigits() in eastern-numerals.ts
+    //
+    //  Background:
+    //    Arabic keyboards and some IMEs output these instead of 0–9.
+    //    Unicode offset from Western digit: charCode - 0x0660 + 48 ('0')
+    //    e.g.  '٥'.charCodeAt(0) = 0x0665 → 0x0665 - 0x0660 = 5 → '5'
+    //
+    //  Examples:
+    //    '١٢٣'.replace(REGEX.ARABIC_DIGITS, …)   →  '123'
+    //    '٠٩'.replace(REGEX.ARABIC_DIGITS, …)    →  '09'
+    //
+    ARABIC_DIGITS: /[\u0660-\u0669]/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 12. PERSIAN_DIGITS
+    //     Match Extended Arabic-Indic digit characters used in Persian / Farsi.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Unicode range:
+    //    \u06F0  = Extended Arabic-Indic digit zero  ۰
+    //    \u06F9  = Extended Arabic-Indic digit nine  ۹
+    //
+    //  Persian digits are a DIFFERENT Unicode block from Arabic digits even though
+    //  they look similar:
+    //    Arabic zero  ٠  =  U+0660
+    //    Persian zero ۰  =  U+06F0   ← different code point!
+    //
+    //  Both blocks need separate patterns.
+    //
+    //  g flag: replace ALL occurrences.
+    //
+    //  Used in:  convertEasternDigits() in eastern-numerals.ts
+    //
+    //  Examples:
+    //    '۱۲۳'.replace(REGEX.PERSIAN_DIGITS, …)  →  '123'
+    //    '۰۹'.replace(REGEX.PERSIAN_DIGITS, …)   →  '09'
+    //
+    PERSIAN_DIGITS: /[\u06F0-\u06F9]/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 13. ARABIC_DECIMAL_COMMA
+    //     Match the Arabic decimal comma character ٫ (U+066B).
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  In Arabic locale, the decimal separator is ٫ (Arabic Decimal Separator)
+    //  not the Western period '.'.  We convert it to '.' so the rest of the
+    //  directive can process it uniformly.
+    //
+    //  Used in:  convertEasternDigits() in eastern-numerals.ts
+    //
+    //  Example:
+    //    '١٢٫٥'.replace(REGEX.ARABIC_DECIMAL_COMMA, '.')  →  '١٢.٥'
+    //    (then after digit conversion)                       →  '12.5'
+    //
+    ARABIC_DECIMAL_COMMA: /\u066B/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 14. ARABIC_THOUSANDS_SEPARATOR
+    //     Match the Arabic thousands separator ٬ (U+066C).
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Similar to the decimal comma above: the Arabic locale uses U+066C as its
+    //  thousands grouping character.  We strip it so the directive does not
+    //  mistake it for a digit.
+    //
+    //  Used in:  convertEasternDigits() in eastern-numerals.ts
+    //
+    //  Example:
+    //    '١٬٢٣٤'.replace(REGEX.ARABIC_THOUSANDS_SEPARATOR, '')  →  '١٢٣٤'
+    //
+    ARABIC_THOUSANDS_SEPARATOR: /\u066C/g,
+    // ──────────────────────────────────────────────────────────────────────────
+    // 15. ARABIC_DIGIT_RANGE
+    //     The Unicode code-point boundaries for Arabic-Indic digit characters.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Unlike ARABIC_DIGITS (which is a /g regex used with .replace()), these
+    //  are plain string constants used for a boundary COMPARISON in onKeyDown():
+    //
+    //    pressedKey >= REGEX.ARABIC_DIGIT_RANGE.FIRST &&
+    //    pressedKey <= REGEX.ARABIC_DIGIT_RANGE.LAST
+    //
+    //  Why not reuse ARABIC_DIGITS here?
+    //    ARABIC_DIGITS has the global 'g' flag and is designed for .replace()
+    //    across an entire string.  A single-character range check via >= / <=
+    //    is simpler, has no flag state to worry about, and is O(1).
+    //    JavaScript compares strings by Unicode code point, so this works
+    //    correctly for single characters.
+    //
+    //  Used in:  onKeyDown() — to allow Eastern keystrokes through before
+    //            onInput() converts them to Western digits.
+    //
+    //  Examples:
+    //    '١' >= REGEX.ARABIC_DIGIT_RANGE.FIRST  →  true   (U+0661 >= U+0660)
+    //    '١' <= REGEX.ARABIC_DIGIT_RANGE.LAST   →  true   (U+0661 <= U+0669)
+    //    'a' >= REGEX.ARABIC_DIGIT_RANGE.FIRST  →  false  (U+0061 < U+0660)
+    //
+    ARABIC_DIGIT_RANGE: {
+        FIRST: '\u0660', // ٠  Arabic-Indic digit ZERO
+        LAST: '\u0669', // ٩  Arabic-Indic digit NINE
+    },
+    // ──────────────────────────────────────────────────────────────────────────
+    // 16. PERSIAN_DIGIT_RANGE
+    //     The Unicode code-point boundaries for Persian digit characters.
+    // ──────────────────────────────────────────────────────────────────────────
+    //
+    //  Same idea as ARABIC_DIGIT_RANGE above, but for the Persian/Extended
+    //  Arabic-Indic block (U+06F0–U+06F9).
+    //
+    //  Persian digits live in a DIFFERENT Unicode block from Arabic digits
+    //  even though they look similar:
+    //    Arabic zero  ٠  =  U+0660
+    //    Persian zero ۰  =  U+06F0  ← different block, needs its own range
+    //
+    //  Used in:  onKeyDown() — same purpose as ARABIC_DIGIT_RANGE.
+    //
+    //  Examples:
+    //    '۶' >= REGEX.PERSIAN_DIGIT_RANGE.FIRST  →  true   (U+06F6 >= U+06F0)
+    //    '۶' <= REGEX.PERSIAN_DIGIT_RANGE.LAST   →  true   (U+06F6 <= U+06F9)
+    //    '١' >= REGEX.PERSIAN_DIGIT_RANGE.FIRST  →  false  (U+0661 < U+06F0)
+    //
+    PERSIAN_DIGIT_RANGE: {
+        FIRST: '\u06F0', // ۰  Persian digit ZERO
+        LAST: '\u06F9', // ۹  Persian digit NINE
+    },
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// QUICK-REFERENCE TABLE
+// ─────────────────────────────────────────────────────────────────────────────
+//
+//   Key                           Pattern                        Purpose
+//   ──────────────────────────    ─────────────────────────────  ────────────────────────────────────────
+//   SINGLE_DIGIT                  /^\d$/                         Is a keypress exactly one digit?
+//   NON_DIGIT_CHARACTERS          /[^0-9]/g                      Strip everything except digits
+//   ONLY_DIGITS_AND_MINUS         /[^0-9\-]/g                    Keep digits + minus  (integer paste)
+//   ONLY_DIGITS_DOT_AND_MINUS     /[^0-9.\-]/g                   Keep digits + dot + minus (decimal paste)
+//   ONLY_DIGITS                   /[^0-9]/g                      Keep digits only  (string/pattern paste)
+//   ALL_DOTS                      /\./g                          Remove all literal dot characters
+//   ALL_MINUS_SIGNS               /-/g                           Remove all minus/hyphen characters
+//   THOUSANDS_SEPARATOR_POSITIONS /\B(?=(\d{3})+(?!\d))/g       Find positions for thousands separator
+//   REGEX_SPECIAL_CHARACTERS      /[.*+?^${}()|[\]\\]/g         Escape chars before new RegExp(…)
+//   LEADING_ZEROS                 /^0+(\d)/                      Strip leading zeros, keep ≥ 1 digit
+//   ARABIC_DIGITS                 /[\u0660-\u0669]/g             Match Arabic-Indic digits ٠-٩
+//   PERSIAN_DIGITS                /[\u06F0-\u06F9]/g             Match Persian digits ۰-۹
+//   ARABIC_DECIMAL_COMMA          /\u066B/g                      Arabic decimal separator ٫ → '.'
+//   ARABIC_THOUSANDS_SEPARATOR    /\u066C/g                      Arabic grouping separator ٬ → strip
+//   ARABIC_DIGIT_RANGE            { FIRST: '\u0660', LAST: '\u0669' }   Boundary check for Arabic digits in keydown
+//   PERSIAN_DIGIT_RANGE           { FIRST: '\u06F0', LAST: '\u06F9' }   Boundary check for Persian digits in keydown
+
+/**
+ * eastern-numerals.ts
+ *
+ * A fully standalone, zero-dependency TypeScript utility that converts
+ * Arabic-Indic and Persian/Farsi digit characters to their Western (ASCII)
+ * equivalents.
+ *
+ * ─── Zero dependencies ────────────────────────────────────────────────────────
+ *
+ * This file has NO imports. Copy it into ANY TypeScript or JavaScript project
+ * and use it immediately — Angular, React, Vue, Node.js, plain TS, or a browser
+ * script. Nothing else is required.
+ *
+ * ─── Why this exists ──────────────────────────────────────────────────────────
+ *
+ * Arabic and Persian keyboards — and many mobile IMEs across the Middle East
+ * and South Asia — produce digit characters from a DIFFERENT Unicode block
+ * than the ASCII digits 0–9 most Western software expects:
+ *
+ *   Western / ASCII     0  1  2  3  4  5  6  7  8  9
+ *   Code points         U+0030 ── U+0039
+ *
+ *   Arabic-Indic        ٠  ١  ٢  ٣  ٤  ٥  ٦  ٧  ٨  ٩
+ *   Code points         U+0660 ── U+0669
+ *
+ *   Persian / Farsi     ۰  ۱  ۲  ۳  ۴  ۵  ۶  ۷  ۸  ۹
+ *   Code points         U+06F0 ── U+06F9
+ *
+ * When a user types ١٢٣ on an Arabic keyboard the browser sends those exact
+ * Unicode code points, NOT '123'. Without conversion:
+ *   • /^\d$/ does NOT match them (it only matches U+0030–U+0039)
+ *   • Number('١٢٣') returns NaN
+ *   • parseInt('١٢٣', 10) returns NaN
+ *
+ * ─── Safety guarantee ─────────────────────────────────────────────────────────
+ *
+ * This conversion is completely conflict-free because the Arabic and Persian
+ * digit Unicode blocks have ZERO overlap with:
+ *   • ASCII digits      (U+0030–U+0039)
+ *   • ASCII letters     (U+0041–U+007A)
+ *   • ASCII punctuation (. , - + $ € % @ # etc.)
+ *
+ * Converting ٥ → '5' can NEVER accidentally transform a separator, currency
+ * symbol, or letter into something else. The substitution is exact and
+ * unambiguous.
+ *
+ * ─── What is NOT converted ────────────────────────────────────────────────────
+ *
+ * • Arabic letters ا ب ت ث …      — no Western equivalent, left as-is
+ * • Arabic diacritics (harakat)    — no Western equivalent, left as-is
+ * • Any character outside the two digit blocks described above
+ *
+ * ─── Exports ──────────────────────────────────────────────────────────────────
+ *
+ *   convertEasternDigits(input)   Main conversion — Eastern digits → 0-9
+ *   hasEasternDigits(input)       Quick check — does the string contain any?
+ *   getDigitScript(input)         Identify which script the digits are in
+ *   EASTERN_DIGIT_MAP             Full lookup table (for testing / docs)
+ *   EASTERN_NUMERAL_REGEX         The two RegExp patterns (for advanced use)
+ *
+ * ─── Quick usage ──────────────────────────────────────────────────────────────
+ *
+ *   import { convertEasternDigits } from './eastern-numerals';
+ *
+ *   convertEasternDigits('١٢٣٫٤٥')     // '123.45'
+ *   convertEasternDigits('۶۷۸')        // '678'
+ *   convertEasternDigits('price: ١٠٠') // 'price: 100'  (non-digits untouched)
+ *   convertEasternDigits('123')         // '123'          (already Western)
+ *   convertEasternDigits(null)          // ''
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Internal regex constants
+// (Inline here so the file has zero dependencies and can be used anywhere.)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Regex patterns used internally by this module.
+ * Also exported so callers can use them directly if needed.
+ *
+ * These are the same patterns documented in digits-only.regex.ts entries
+ * ARABIC_DIGITS, PERSIAN_DIGITS, ARABIC_DECIMAL_COMMA, ARABIC_THOUSANDS_SEPARATOR
+ * but duplicated here so this file remains self-contained.
+ */
+const EASTERN_NUMERAL_REGEX = {
+    /**
+     * Matches any Arabic-Indic digit character (U+0660 – U+0669).
+     * These are the digits used on Arabic keyboards: ٠١٢٣٤٥٦٧٨٩
+     * The g flag ensures ALL occurrences in a string are replaced, not just the first.
+     */
+    ARABIC_DIGITS: /[\u0660-\u0669]/g,
+    /**
+     * Matches any Persian / Extended Arabic-Indic digit (U+06F0 – U+06F9).
+     * These are the digits used on Persian / Farsi keyboards: ۰۱۲۳۴۵۶۷۸۹
+     * Note: a DIFFERENT Unicode block from Arabic even though they look similar.
+     *   Arabic zero  ٠  =  U+0660
+     *   Persian zero ۰  =  U+06F0  ← different!
+     */
+    PERSIAN_DIGITS: /[\u06F0-\u06F9]/g,
+    /**
+     * Matches the Arabic Decimal Separator ٫ (U+066B).
+     * In Arabic locale this character plays the role of the Western period '.'
+     * as a decimal point. We normalize it to '.' so parseFloat / Number work.
+     */
+    ARABIC_DECIMAL_COMMA: /\u066B/g,
+    /**
+     * Matches the Arabic Thousands Separator ٬ (U+066C).
+     * In Arabic locale this character plays the role of the Western comma ','
+     * as a digit-group separator. We strip it so it doesn't pollute the number.
+     */
+    ARABIC_THOUSANDS_SEPARATOR: /\u066C/g,
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// Full Unicode character map (exported for testing and documentation)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Every Eastern digit character mapped to its Western ASCII equivalent.
+ *
+ * Key   = Eastern character (as it arrives from the keyboard / clipboard)
+ * Value = Western ASCII character it should become
+ *
+ * This map is exported for:
+ *   • Unit tests that want to iterate over every case
+ *   • Documentation / debugging
+ *   • Manual lookups without running a conversion
+ */
+const EASTERN_DIGIT_MAP = {
+    // ── Arabic-Indic digits (U+0660 – U+0669) ────────────────────────────────
+    // Used in: Arabic, Urdu, Sindhi, and other Arabic-script languages
+    '٠': '0', // U+0660  Arabic-Indic digit zero
+    '١': '1', // U+0661  Arabic-Indic digit one
+    '٢': '2', // U+0662  Arabic-Indic digit two
+    '٣': '3', // U+0663  Arabic-Indic digit three
+    '٤': '4', // U+0664  Arabic-Indic digit four
+    '٥': '5', // U+0665  Arabic-Indic digit five
+    '٦': '6', // U+0666  Arabic-Indic digit six
+    '٧': '7', // U+0667  Arabic-Indic digit seven
+    '٨': '8', // U+0668  Arabic-Indic digit eight
+    '٩': '9', // U+0669  Arabic-Indic digit nine
+    // ── Persian / Extended Arabic-Indic digits (U+06F0 – U+06F9) ─────────────
+    // Used in: Persian (Farsi), Pashto, Kurdish, and related languages
+    '۰': '0', // U+06F0  Extended Arabic-Indic digit zero
+    '۱': '1', // U+06F1  Extended Arabic-Indic digit one
+    '۲': '2', // U+06F2  Extended Arabic-Indic digit two
+    '۳': '3', // U+06F3  Extended Arabic-Indic digit three
+    '۴': '4', // U+06F4  Extended Arabic-Indic digit four
+    '۵': '5', // U+06F5  Extended Arabic-Indic digit five
+    '۶': '6', // U+06F6  Extended Arabic-Indic digit six
+    '۷': '7', // U+06F7  Extended Arabic-Indic digit seven
+    '۸': '8', // U+06F8  Extended Arabic-Indic digit eight
+    '۹': '9', // U+06F9  Extended Arabic-Indic digit nine
+    // ── Arabic punctuation normalized as part of number handling ─────────────
+    '٫': '.', // U+066B  Arabic Decimal Separator → Western decimal point
+    '٬': '', // U+066C  Arabic Thousands Separator → stripped (empty string)
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// Core conversion function
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Convert all Arabic-Indic and Persian digit characters in a string
+ * to their Western ASCII equivalents (0–9).
+ *
+ * The function runs four passes in order:
+ *   1. Strip Arabic thousands separator ٬ (U+066C)
+ *   2. Convert Arabic decimal comma ٫ (U+066B) → '.'
+ *   3. Convert Arabic-Indic digits ٠-٩ (U+0660–U+0669) → '0'-'9'
+ *   4. Convert Persian digits ۰-۹ (U+06F0–U+06F9) → '0'-'9'
+ *
+ * The function is PURE — it never mutates its input and has no side effects.
+ *
+ * @param input  Any string, number, null, or undefined.
+ *               Numbers are converted via String() first.
+ *               null / undefined / '' all return ''.
+ * @returns      A new string with every Eastern digit replaced by its Western
+ *               equivalent. Non-digit characters are passed through unchanged.
+ *
+ * @example
+ *   convertEasternDigits('١٢٣')           // '123'
+ *   convertEasternDigits('۶۷۸')           // '678'
+ *   convertEasternDigits('١٢٣٫٤٥')       // '123.45'   (decimal comma)
+ *   convertEasternDigits('١٬٢٣٤')        // '1234'     (thousands sep stripped)
+ *   convertEasternDigits('price: ٩٩')    // 'price: 99' (non-digits untouched)
+ *   convertEasternDigits('123')           // '123'       (already Western)
+ *   convertEasternDigits('')              // ''
+ *   convertEasternDigits(null)            // ''
+ *   convertEasternDigits(undefined)       // ''
+ *   convertEasternDigits(42)              // '42'        (number input)
+ */
+function convertEasternDigits(input) {
+    // ── Guard ─────────────────────────────────────────────────────────────────
+    // Handle null, undefined, and empty-string early so the rest of the
+    // function can assume it has a non-empty string to work with.
+    if (input === null || input === undefined || input === '') {
+        return '';
+    }
+    // Coerce numbers to strings so the function also works when called
+    // directly on a numeric value (e.g. after a model value update).
+    const text = typeof input === 'number' ? String(input) : input;
+    return text
+        // ── Step 1: Remove Arabic thousands separator ──────────────────────────
+        //
+        // ٬ (U+066C) looks like a comma but is a completely different code point.
+        // It must be stripped FIRST — before digit conversion — so it cannot
+        // accidentally become part of the number string.
+        //
+        //   '١٬٢٣٤'  →  '١٢٣٤'   (grouping character removed)
+        .replace(EASTERN_NUMERAL_REGEX.ARABIC_THOUSANDS_SEPARATOR, '')
+        // ── Step 2: Arabic decimal comma → Western decimal point ──────────────
+        //
+        // ٫ (U+066B) is the decimal separator in Arabic locale.
+        // We convert it to '.' so parseFloat / Number can parse the result.
+        //
+        //   '١٢٫٥'  →  '١٢.٥'   (decimal comma replaced, digits still Arabic)
+        .replace(EASTERN_NUMERAL_REGEX.ARABIC_DECIMAL_COMMA, '.')
+        // ── Step 3: Arabic-Indic digits → Western digits ───────────────────────
+        //
+        // The conversion formula uses the Unicode offset of the Arabic zero (0x0660):
+        //
+        //   Example with '٥':
+        //     '٥'.charCodeAt(0)       = 0x0665  (1637 decimal)
+        //     0x0665 - 0x0660         = 5        (the digit's numeric value)
+        //     5 + 0x30                = 53       (ASCII code of '5')
+        //     String.fromCharCode(53) = '5'
+        //
+        //   '٠١٢٣٤٥٦٧٨٩'  →  '0123456789'
+        .replace(EASTERN_NUMERAL_REGEX.ARABIC_DIGITS, (arabicChar) => {
+        const ARABIC_ZERO_CODE_POINT = 0x0660; // Unicode code point of Arabic ٠
+        const WESTERN_ZERO_CODE_POINT = 0x0030; // Unicode code point of ASCII  0
+        const digitValue = arabicChar.charCodeAt(0) - ARABIC_ZERO_CODE_POINT;
+        return String.fromCharCode(digitValue + WESTERN_ZERO_CODE_POINT);
+    })
+        // ── Step 4: Persian digits → Western digits ────────────────────────────
+        //
+        // Identical math to step 3 but using the Persian zero offset (0x06F0).
+        // Persian and Arabic digits look similar but are different code points —
+        // both blocks need their own replacement pass.
+        //
+        //   '۰۱۲۳۴۵۶۷۸۹'  →  '0123456789'
+        .replace(EASTERN_NUMERAL_REGEX.PERSIAN_DIGITS, (persianChar) => {
+        const PERSIAN_ZERO_CODE_POINT = 0x06F0; // Unicode code point of Persian ۰
+        const WESTERN_ZERO_CODE_POINT = 0x0030; // Unicode code point of ASCII  0
+        const digitValue = persianChar.charCodeAt(0) - PERSIAN_ZERO_CODE_POINT;
+        return String.fromCharCode(digitValue + WESTERN_ZERO_CODE_POINT);
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Helper utilities
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Returns true if the string contains at least one Arabic-Indic or
+ * Persian digit character.
+ *
+ * Useful as a cheap pre-check before calling convertEasternDigits — if this
+ * returns false the string is already all-Western and no conversion is needed.
+ *
+ * @param input  Any string to check.
+ * @returns      true if any Eastern digit is present, false otherwise.
+ *
+ * @example
+ *   hasEasternDigits('١٢٣')    // true   — Arabic
+ *   hasEasternDigits('۴۵۶')   // true   — Persian
+ *   hasEasternDigits('٥0')     // true   — mix of Arabic and Western
+ *   hasEasternDigits('123')    // false  — already Western
+ *   hasEasternDigits('hello')  // false  — no digits at all
+ *   hasEasternDigits('')       // false
+ */
+function hasEasternDigits(input) {
+    if (!input)
+        return false;
+    // We must reset lastIndex before using a /g regex with .test()
+    // because stateful regex objects remember where they left off.
+    // The simplest safe approach is to re-create a clean regex each time.
+    return /[\u0660-\u0669\u06F0-\u06F9]/.test(input);
+}
+function getDigitScript(input) {
+    if (!input)
+        return 'western';
+    const containsArabic = /[\u0660-\u0669]/.test(input);
+    const containsPersian = /[\u06F0-\u06F9]/.test(input);
+    const containsWestern = /[0-9]/.test(input);
+    // Mixed: more than one script present simultaneously
+    const scriptCount = [containsArabic, containsPersian, containsWestern]
+        .filter(Boolean).length;
+    if (scriptCount > 1)
+        return 'mixed';
+    if (containsArabic)
+        return 'arabic';
+    if (containsPersian)
+        return 'persian';
+    return 'western';
+}
+/**
+ * Convert a string that may contain Eastern digits to a JavaScript number.
+ * A convenience wrapper around convertEasternDigits + parseFloat.
+ *
+ * Returns NaN for strings that don't represent a valid number
+ * (same contract as parseFloat / Number).
+ *
+ * @param input  A string possibly containing Eastern digits.
+ * @returns      A JavaScript number, or NaN if parsing fails.
+ *
+ * @example
+ *   toWesternNumber('١٢٣')       // 123
+ *   toWesternNumber('١٢٣٫٤٥')   // 123.45
+ *   toWesternNumber('۹٩')        // 99   (mixed Arabic + Persian → still works)
+ *   toWesternNumber('abc')        // NaN
+ *   toWesternNumber('')           // NaN
+ */
+function toWesternNumber(input) {
+    const converted = convertEasternDigits(input);
+    return parseFloat(converted);
+}
+
+/**
+ * digits-only.directive.ts
+ *
+ * A self-contained Angular directive that replicates the key numeric features
+ * of ngx-mask without any external dependency.
+ *
+ * ─── Files in this module ─────────────────────────────────────────────────────
+ *
+ *   digits-only.directive.ts   ← you are here — the Angular directive
+ *   digits-only.regex.ts       ← every RegExp constant with detailed explanations
+ *   digits-only.module.ts       ← NgModule that declares and exports the directive
+ *   eastern-numerals.ts            ← standalone Arabic / Persian → Western digit converter
+ *
+ * ─── Features ─────────────────────────────────────────────────────────────────
+ *
+ *   [digitsOnly]              Selector — add to any <input> element
+ *   [decimalPlaces]           Number of decimal places allowed (default: 0 = integers)
+ *   [thousandSeparator]       Visual grouping character: ',' | '.' | ' ' | '_' | ''
+ *   [prefix]                  Visual prefix shown in input (e.g. '$') — stripped from model
+ *   [suffix]                  Visual suffix shown in input (e.g. '%') — stripped from model
+ *   [allowNegative]           Allow a leading minus sign (default: false)
+ *   [leadingZeros]            Preserve leading zeros like '007' (default: false)
+ *   [maxLength]               Maximum number of raw digits allowed
+ *   [min]                     Minimum numeric value (validation, number mode only)
+ *   [max]                     Maximum numeric value (validation, number mode only)
+ *   [outputType]              'number' (default) | 'string' — type emitted to the model
+ *   [pattern]                 Display-format mask: '0000 0000 0000 0000' or named alias
+ *   [convertEasternNumerals]  Convert Arabic/Persian digits to Western on input (default: true)
+ *
+ * ─── outputType ───────────────────────────────────────────────────────────────
+ *
+ *   'number' (default)
+ *     Model receives:  number | null
+ *     Use for:         prices, quantities, temperatures — values used in arithmetic
+ *     Note:            Leading zeros are lost (007 → 7); values beyond
+ *                      Number.MAX_SAFE_INTEGER may lose precision
+ *
+ *   'string'
+ *     Model receives:  string | null
+ *     Use for:         card numbers, phone numbers, postal codes, SSNs, OTPs —
+ *                      digit strings that are identifiers, not quantities
+ *     Note:            Leading zeros are always preserved; no precision limit
+ *
+ * ─── pattern ──────────────────────────────────────────────────────────────────
+ *
+ *   A mask string made of '0' (digit slot) and any other character (separator).
+ *   Separators are inserted in the display automatically but NEVER reach the model.
+ *   Setting a pattern forces outputType='string' and derives maxLength automatically.
+ *
+ *   Named aliases:
+ *     'card'       →  '0000 0000 0000 0000'   Visa / Mastercard (16 digits)
+ *
+ * ─── convertEasternNumerals ───────────────────────────────────────────────────
+ *
+ *   When true (default), Arabic-Indic (٠١٢٣٤٥٦٧٨٩) and Persian (۰۱۲۳۴۵۶۷۸۹)
+ *   digit characters are silently converted to their Western equivalents before
+ *   any processing.  This allows users on Arabic / Persian keyboards to type
+ *   naturally into any digitsOnly field.
+ *   Set to false only if you specifically need to block Eastern numerals.
+ *
+ * ─── Usage examples ───────────────────────────────────────────────────────────
+ *
+ *   <!-- Integer amount, $ prefix, comma thousands -->
+ *   <input digitsOnly thousandSeparator="," prefix="$" formControlName="salary" />
+ *
+ *   <!-- Decimal price, 2 places -->
+ *   <input digitsOnly [decimalPlaces]="2" thousandSeparator="," formControlName="price" />
+ *
+ *   <!-- Card number with automatic space grouping -->
+ *   <input digitsOnly pattern="card" formControlName="cardNumber" />
+ *
+ *   <!-- Custom pattern -->
+ *   <input digitsOnly pattern="000-00-0000" formControlName="ssn" />
+ *
+ *   <!-- Opt out of Eastern numeral conversion -->
+ *   <input digitsOnly [convertEasternNumerals]="false" formControlName="code" />
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Unicode directional constants
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Left-to-Right Mark (U+200E) — an invisible zero-width Unicode character.
+ *
+ * WHY IT IS NEEDED:
+ *   In RTL documents (dir="rtl"), the browser's Unicode Bidirectional Algorithm
+ *   (UBA) may try to mirror numeric content — reordering digits or misplacing
+ *   separators like commas.  For example, "1,234" can display as "234,1" in
+ *   some bidi contexts.
+ *
+ *   Prepending LRM to the input value tells the bidi algorithm:
+ *   "treat everything that follows as left-to-right text".
+ *   Numbers, thousands separators, and decimal points always read correctly.
+ *
+ * ZERO IMPACT ON MODEL:
+ *   LRM is stripped inside stripDecorationsFrom() before any value reaches
+ *   the model, so your component never sees this character.
+ *
+ * BROWSER SUPPORT:
+ *   All modern browsers respect U+200E in input values.
+ */
+const LRM = '\u200E'; // Left-to-Right Mark — invisible, prevents bidi digit mirroring
+/**
+ * Maps every NamedPattern alias to its full mask string.
+ * Typed as Record<NamedPattern, string> so TypeScript catches missing entries —
+ * add a new entry here and the type forces you to add it to NamedPattern too.
+ */
+const NAMED_PATTERNS = {
+    'card': '0000 0000 0000 0000',
+};
+/**
+ * Type guard that narrows an arbitrary string to NamedPattern.
+ *
+ * Using the `in` operator against NAMED_PATTERNS tells TypeScript:
+ * "if this key exists in the object, treat it as NamedPattern from here on".
+ * This is the only way to safely index Record<NamedPattern, string> with a
+ * value that might be a NamedPattern OR a plain custom pattern string.
+ *
+ * @example
+ *   isNamedPattern('card')     // true  → safe to use as NAMED_PATTERNS key
+ *   isNamedPattern('000-0000') // false → treat as raw custom pattern
+ */
+function isNamedPattern(value) {
+    return value in NAMED_PATTERNS;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Directive
+// ─────────────────────────────────────────────────────────────────────────────
+class digitsOnlyDirective {
+    el;
+    renderer;
+    document;
+    // ─── Public inputs ──────────────────────────────────────────────────────────
+    /** How many decimal places are allowed. 0 = integers only. Ignored when pattern is set. */
+    decimalPlaces = 0;
+    /** Visual grouping character inserted between digit groups. Ignored when pattern is set. */
+    thousandSeparator = '';
+    /** Visual text prepended to the displayed value (e.g. '$'). Never reaches the model. */
+    prefix = '';
+    /** Visual text appended to the displayed value (e.g. '%'). Never reaches the model. */
+    suffix = '';
+    /** When true, a leading minus '-' is allowed for negative numbers. */
+    allowNegative = false;
+    /** When true, leading zeros (e.g. '007') are preserved in the model value. */
+    leadingZeros = false;
+    /** Maximum number of raw digit characters the user may enter. */
+    maxLength = null;
+    /** Minimum allowed numeric value. Produces a 'min' validation error when violated. */
+    min = null;
+    /** Maximum allowed numeric value. Produces a 'max' validation error when violated. */
+    max = null;
+    /**
+     * Controls the JavaScript type emitted to the form model.
+     * 'number' (default) → number | null
+     * 'string'           → string | null
+     * Automatically overridden to 'string' when [pattern] is set.
+     */
+    outputType = 'number';
+    /**
+     * When true (default), Arabic-Indic and Persian digit characters typed or
+     * pasted by the user are automatically converted to Western digits 0-9
+     * before any processing happens.
+     *
+     * Safe to leave enabled for all use cases — the conversion only touches
+     * characters in the Unicode ranges U+0660–U+0669 and U+06F0–U+06F9,
+     * which have zero overlap with any ASCII character.
+     */
+    convertEasternNumerals = true;
+    /**
+     * Display-format mask string or a named alias (see NamedPattern type).
+     *
+     * Typed as  NamedPattern | (string & {})  so that:
+     *   • Named aliases are autocompleted in IDEs and validated at compile time.
+     *   • Custom raw patterns like '000-0000' are still accepted without error.
+     *
+     * '0' = digit slot, any other char = literal separator auto-inserted in display.
+     * Setting this forces outputType='string' and derives maxLength from slot count.
+     *
+     * @example
+     *   pattern="card"           → '0000 0000 0000 0000'
+     *   pattern="00/00/0000"     → custom date pattern
+     */
+    set pattern(value) {
+        // Type guard: check whether the value is one of the known NamedPattern keys
+        // before indexing NAMED_PATTERNS with it.
+        //
+        // Why this is needed:
+        //   NAMED_PATTERNS is typed as Record<NamedPattern, string>, meaning its
+        //   index signature only accepts NamedPattern keys — not arbitrary strings.
+        //   The @Input type is NamedPattern | (string & {}), so `value` could be
+        //   a custom raw pattern like '000-0000' that is NOT a key of NAMED_PATTERNS.
+        //   Indexing with it directly causes TS error ts(7053):
+        //   "No index signature with a parameter of type 'string' was found".
+        //
+        //   The fix: use `value in NAMED_PATTERNS` as a type guard. The `in` operator
+        //   narrows the type of `value` to NamedPattern inside the if-branch, making
+        //   NAMED_PATTERNS[value] type-safe. In the else-branch `value` is treated
+        //   as a raw custom pattern string and used directly.
+        if (isNamedPattern(value)) {
+            this._resolvedPattern = NAMED_PATTERNS[value]; // value is NamedPattern
+        }
+        else {
+            this._resolvedPattern = value; // value is a raw custom pattern
+        }
+    }
+    // ─── Internal state ──────────────────────────────────────────────────────────
+    /** Full pattern string after named-alias resolution. Empty string = no pattern. */
+    _resolvedPattern = '';
+    /**
+     * The canonical internal value: pure digits (and optional '.' and '-').
+     * No prefix, suffix, separators, or pattern characters ever live here.
+     * Every other method reads or writes this field.
+     */
+    _rawValue = '';
+    // ControlValueAccessor callbacks registered by Angular forms
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _onChange = () => { };
+    _onTouched = () => { };
+    _onValidatorChange = () => { };
+    // ─── Computed properties ────────────────────────────────────────────────────
+    /** True when a format pattern has been set on this input. */
+    get hasPattern() {
+        return this._resolvedPattern.length > 0;
+    }
+    /**
+     * The set of literal separator characters defined in the current pattern.
+     *
+     * Pattern '(000) 000-0000' → separators: {'(', ')', ' ', '-'}
+     * Pattern '0000 0000'      → separators: {' '}
+     *
+     * Used when stripping decorations back off a displayed value.
+     */
+    get patternSeparatorChars() {
+        return new Set(this._resolvedPattern.split('').filter(char => char !== '0'));
+    }
+    /**
+     * The total number of digit slots ('0' characters) in the current pattern.
+     * 'card' pattern has 16 slots; 'expiry' has 4; etc.
+     */
+    get patternDigitSlotCount() {
+        return this._resolvedPattern.split('').filter(char => char === '0').length;
+    }
+    /**
+     * The effective maximum digit length to enforce.
+     * In pattern mode, this is always the slot count (overrides any [maxLength] input).
+     * In non-pattern mode, it comes from the [maxLength] input (may be null = unlimited).
+     */
+    get effectiveMaxLength() {
+        return this.hasPattern ? this.patternDigitSlotCount : this.maxLength;
+    }
+    /**
+     * The effective output type.
+     * Pattern mode always emits strings because patterns are for identifiers.
+     * Otherwise respects the [outputType] input.
+     */
+    get effectiveOutputType() {
+        return this.hasPattern ? 'string' : this.outputType;
+    }
+    /**
+     * The decimal separator character used in the DISPLAY.
+     * If the thousands separator is '.' (European style), we must use ','
+     * as the decimal character to avoid ambiguity (1.234,56 is valid; 1,234,56 is not).
+     * Otherwise we use the standard '.'.
+     */
+    get displayDecimalChar() {
+        return this.thousandSeparator === '.' ? ',' : '.';
+    }
+    /**
+     * Returns true when the input element (or any of its ancestors) is in
+     * right-to-left mode.
+     *
+     * Detection order:
+     *   1. The input element's own computed `direction` style — this reflects
+     *      any `dir` attribute on the element itself, a CSS `direction` rule,
+     *      or inheritance from a parent element with dir="rtl".
+     *   2. Falls back to false (LTR) if the window / getComputedStyle is
+     *      unavailable (e.g. server-side rendering).
+     *
+     * This is a getter (not a cached field) so it always reflects the current
+     * DOM state, even if the direction changes dynamically at runtime.
+     */
+    get isRtl() {
+        const win = this.document.defaultView;
+        if (!win)
+            return false;
+        const dir = win.getComputedStyle(this.el.nativeElement).direction;
+        return dir === 'rtl';
+    }
+    /**
+     * In RTL mode the string stored in the input is prefixed with an LRM mark
+     * so that the bidi algorithm does not reorder digits or separators.
+     * This helper returns the prefix length including the LRM when RTL is active.
+     *
+     * Used wherever we need to know "how many characters before the editable
+     * number portion start" — cursor clamping, minus-key position check, etc.
+     */
+    get editableStartOffset() {
+        // In RTL: LRM + suffix occupies the left side of the display string.
+        // In LTR: prefix occupies the left side.
+        return this.isRtl
+            ? LRM.length + this.suffix.length // RTL: [LRM][suffix][number][prefix]
+            : this.prefix.length; // LTR: [prefix][number][suffix]
+    }
+    /**
+     * The number of characters at the RIGHT end of the display string that
+     * belong to the suffix (LTR) or prefix (RTL) — i.e. characters the cursor
+     * must never move past on the right side.
+     */
+    get editableEndPadding() {
+        return this.isRtl ? this.prefix.length : this.suffix.length;
+    }
+    constructor(el, renderer, document) {
+        this.el = el;
+        this.renderer = renderer;
+        this.document = document;
+    }
+    // ─── Angular lifecycle ────────────────────────────────────────────────────────
+    ngOnInit() {
+        // Always use numeric inputMode so mobile keyboards show the number pad
+        // regardless of document direction.
+        this.renderer.setAttribute(this.el.nativeElement, 'inputmode', 'numeric');
+        // Render the initial empty state into the input element.
+        // refreshDisplay() also sets the dir attribute on first call.
+        this.refreshDisplay();
+    }
+    ngOnChanges(changes) {
+        const { prefix, suffix, thousandSeparator, decimalPlaces, outputType, pattern } = changes;
+        // Re-render whenever any display-affecting input changes
+        const displayInputsChanged = prefix ||
+            suffix ||
+            thousandSeparator ||
+            decimalPlaces ||
+            outputType ||
+            pattern;
+        if (displayInputsChanged) {
+            this.refreshDisplay();
+        }
+    }
+    // ─── ControlValueAccessor ────────────────────────────────────────────────────
+    // These four methods are the bridge between the directive and Angular forms.
+    /** Angular calls this when the form model value changes programmatically. */
+    writeValue(value) {
+        if (value === null || value === undefined || value === '') {
+            this._rawValue = '';
+        }
+        else {
+            const stringValue = String(value);
+            if (this.hasPattern) {
+                // Strip any separators that may already be in the incoming string value
+                this._rawValue = this.stripPatternSeparatorsFrom(stringValue);
+            }
+            else {
+                // Normalize decimal separator to '.' for internal storage
+                this._rawValue = stringValue.replace(',', '.');
+            }
+        }
+        this.refreshDisplay();
+    }
+    /** Angular calls this to register the function we must call when our value changes. */
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    /** Angular calls this to register the function we must call when the field is touched. */
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    /** Angular calls this to enable or disable the input. */
+    setDisabledState(isDisabled) {
+        this.renderer.setProperty(this.el.nativeElement, 'disabled', isDisabled);
+    }
+    // ─── Validator ───────────────────────────────────────────────────────────────
+    /** Angular calls this to ask whether the current value has any errors. */
+    validate(_control) {
+        const errors = {};
+        const raw = this._rawValue;
+        // Empty or partial-minus input: let [required] handle the "is it filled?" check
+        if (raw === '' || raw === '-') {
+            return null;
+        }
+        // ── Pattern mode validation ──────────────────────────────────────────────
+        if (this.hasPattern) {
+            const filledDigitCount = raw.replace(REGEX.NON_DIGIT_CHARACTERS, '').length;
+            const requiredDigitCount = this.patternDigitSlotCount;
+            // The user must fill ALL slots before the value is considered complete
+            if (filledDigitCount < requiredDigitCount) {
+                errors['patternIncomplete'] = {
+                    required: requiredDigitCount,
+                    actual: filledDigitCount,
+                    pattern: this._resolvedPattern,
+                };
+            }
+            return Object.keys(errors).length > 0 ? errors : null;
+        }
+        // ── Non-pattern: maxLength check ─────────────────────────────────────────
+        const maxLen = this.effectiveMaxLength;
+        if (maxLen !== null) {
+            const digitCount = raw.replace(REGEX.NON_DIGIT_CHARACTERS, '').length;
+            if (digitCount > maxLen) {
+                errors['maxLength'] = { maxLength: maxLen, actual: digitCount };
+            }
+        }
+        // ── String output: no numeric range validation needed ────────────────────
+        // Identifiers (card numbers, phones) don't have a meaningful min/max.
+        if (this.effectiveOutputType === 'string') {
+            return Object.keys(errors).length > 0 ? errors : null;
+        }
+        // ── Number output: range validation ──────────────────────────────────────
+        const numericValue = parseFloat(raw);
+        if (isNaN(numericValue)) {
+            errors['digits'] = { actual: raw };
+        }
+        if (this.min !== null && numericValue < this.min) {
+            errors['min'] = { min: this.min, actual: numericValue };
+        }
+        if (this.max !== null && numericValue > this.max) {
+            errors['max'] = { max: this.max, actual: numericValue };
+        }
+        return Object.keys(errors).length > 0 ? errors : null;
+    }
+    /** Angular calls this to register the function we call when validation rules change. */
+    registerOnValidatorChange(fn) {
+        this._onValidatorChange = fn;
+    }
+    // ─── DOM event handlers ────────────────────────────────────────────────────
+    /**
+     * Intercept keydown BEFORE the character lands in the input.
+     * This is our first line of defense — blocking bad keys entirely
+     * so the input event never fires for them.
+     */
+    onKeyDown(event) {
+        // Always pass through control keys (Backspace, arrows, Ctrl+C, etc.)
+        if (this.isControlKey(event)) {
+            return;
+        }
+        const pressedKey = event.key;
+        // ── Allow minus sign (number mode only, not pattern mode) ─────────────
+        const isMinusKey = pressedKey === '-';
+        const minusIsAllowed = this.allowNegative &&
+            !this.hasPattern &&
+            this.effectiveOutputType === 'number';
+        // The "start of the editable number region" depends on direction:
+        //   LTR: cursor must be at prefix.length (characters the prefix occupies)
+        //   RTL: cursor must be at LRM.length + suffix.length (LRM + suffix on left)
+        // editableStartOffset encapsulates this logic so onKeyDown stays clean.
+        const cursorPosition = this.el.nativeElement.selectionStart ?? 0;
+        const cursorIsAtStart = cursorPosition === this.editableStartOffset;
+        const noMinusYet = !this._rawValue.startsWith('-');
+        if (isMinusKey && minusIsAllowed && cursorIsAtStart && noMinusYet) {
+            return; // allow the minus through
+        }
+        // ── Allow decimal point (number mode only, no pattern) ────────────────
+        const isDecimalKey = pressedKey === '.' || pressedKey === ',';
+        const decimalIsAllowed = this.decimalPlaces > 0 && !this.hasPattern;
+        const noDecimalYet = !this._rawValue.includes('.');
+        if (isDecimalKey && decimalIsAllowed && noDecimalYet) {
+            return; // allow the decimal separator through
+        }
+        // ── Allow digit keys (0–9 AND Eastern Arabic/Persian digits) ────────────
+        //
+        // IMPORTANT: REGEX.SINGLE_DIGIT only matches ASCII digits /^\d$/ (U+0030–U+0039).
+        // Arabic-Indic digits ٠-٩ (U+0660–U+0669) and Persian digits ۰-۹ (U+06F0–U+06F9)
+        // are NOT matched by \d, so they would fall through to the "block everything else"
+        // branch and be prevented — even when convertEasternNumerals is true.
+        //
+        // The fix: also check for Eastern digit characters here in keydown.
+        // The actual conversion from Eastern → Western happens later in onInput(),
+        // so all we need to do here is let the keystroke land in the input.
+        const isWesternDigit = REGEX.SINGLE_DIGIT.test(pressedKey);
+        const isArabicDigit = pressedKey >= REGEX.ARABIC_DIGIT_RANGE.FIRST &&
+            pressedKey <= REGEX.ARABIC_DIGIT_RANGE.LAST;
+        const isPersianDigit = pressedKey >= REGEX.PERSIAN_DIGIT_RANGE.FIRST &&
+            pressedKey <= REGEX.PERSIAN_DIGIT_RANGE.LAST;
+        const isEasternDigit = this.convertEasternNumerals && (isArabicDigit || isPersianDigit);
+        const isDigitKey = isWesternDigit || isEasternDigit;
+        if (isDigitKey) {
+            // Enforce the digit slot limit BEFORE the character is inserted.
+            // Count only the raw digits already in the value (exclude separators/prefix/suffix).
+            const maxLen = this.effectiveMaxLength;
+            if (maxLen !== null) {
+                const currentDigitCount = this._rawValue.replace(REGEX.NON_DIGIT_CHARACTERS, '').length;
+                const selectedChars = Math.abs((this.el.nativeElement.selectionEnd ?? 0) -
+                    (this.el.nativeElement.selectionStart ?? 0));
+                const nothingSelected = selectedChars === 0;
+                if (nothingSelected && currentDigitCount >= maxLen) {
+                    event.preventDefault(); // already at limit — block the digit
+                    return;
+                }
+            }
+            return; // digit is allowed — Eastern digits will be converted in onInput()
+        }
+        // ── Block everything else ─────────────────────────────────────────────
+        event.preventDefault();
+    }
+    /**
+     * Process input AFTER the character has landed in the input element.
+     * We read the new display value, strip decorations to get raw digits,
+     * apply rules (decimal limits, maxLength, leading zeros), then re-render.
+     */
+    onInput() {
+        const inputEl = this.el.nativeElement;
+        const cursorPositionBeforeReformat = inputEl.selectionStart ?? 0;
+        const displayLengthBeforeReformat = inputEl.value.length;
+        // Convert Eastern numerals FIRST, before anything else touches the value
+        if (this.convertEasternNumerals) {
+            const converted = convertEasternDigits(inputEl.value);
+            if (converted !== inputEl.value) {
+                // Write the converted value directly into the DOM so our stripping below
+                // works on clean ASCII characters
+                this.renderer.setProperty(inputEl, 'value', converted);
+            }
+        }
+        // Strip prefix, suffix, and visual separators — extract the raw digit core
+        let raw = this.stripDecorationsFrom(inputEl.value);
+        if (this.hasPattern) {
+            // Pattern mode: keep only digits, cap at slot count
+            raw = raw.replace(REGEX.ONLY_DIGITS, '');
+            raw = raw.slice(0, this.patternDigitSlotCount);
+        }
+        else {
+            // Non-pattern mode: normalize decimal separator
+            raw = raw.replace(',', '.');
+            if (this.decimalPlaces === 0 || this.effectiveOutputType === 'string') {
+                // Integer or string mode: no decimal points allowed
+                raw = raw.replace(REGEX.ALL_DOTS, '');
+            }
+            else {
+                // Decimal mode: allow exactly one dot with up to N decimal places
+                raw = this.enforceDecimalRules(raw);
+            }
+            // Strip leading zeros unless explicitly preserved
+            const shouldStripLeadingZeros = !this.leadingZeros && this.effectiveOutputType === 'number';
+            if (shouldStripLeadingZeros) {
+                raw = this.stripLeadingZeros(raw);
+            }
+        }
+        this._rawValue = raw;
+        this.refreshDisplay(cursorPositionBeforeReformat, displayLengthBeforeReformat);
+        this._onChange(this.buildModelValue());
+        this._onValidatorChange();
+    }
+    /**
+     * When the user leaves the field, mark it as touched (triggers validation
+     * display) and clean up any trailing decimal point (e.g. the user typed
+     * '12.' and then tabbed away).
+     */
+    onBlur() {
+        this._onTouched();
+        const hasTrailingDot = !this.hasPattern &&
+            this.effectiveOutputType === 'number' &&
+            this._rawValue.endsWith('.');
+        if (hasTrailingDot) {
+            this._rawValue = this._rawValue.slice(0, -1);
+            this.refreshDisplay();
+        }
+    }
+    /**
+     * Handle paste events manually so we can sanitize the pasted content
+     * before it reaches the input, just like we do for individual keystrokes.
+     */
+    onPaste(event) {
+        event.preventDefault(); // stop the browser from pasting the raw text
+        const pastedText = event.clipboardData?.getData('text') ?? '';
+        // Convert Eastern numerals in pasted content too
+        const normalized = this.convertEasternNumerals
+            ? convertEasternDigits(pastedText)
+            : pastedText;
+        // Sanitize the pasted string to only the characters our mode allows
+        const sanitized = this.hasPattern
+            ? normalized.replace(REGEX.ONLY_DIGITS, '') // pattern: digits only
+            : this.sanitizePastedText(normalized); // non-pattern: mode-aware
+        // Bail out if there's nothing usable to paste.
+        // (Previously this also tried to special-case a paste of just '0', but
+        //  comparing a value to both '' and '0' in the same check is a logical
+        //  impossibility — a string can never be both at once — so that branch
+        //  was unreachable dead code and TypeScript correctly flagged it.)
+        if (sanitized === '')
+            return;
+        const inputEl = this.el.nativeElement;
+        // Figure out where the cursor/selection is inside the RAW digit string
+        const rawInsertStart = this.hasPattern
+            ? this.mapDisplayCursorToRawIndex(inputEl.selectionStart ?? 0)
+            : (inputEl.selectionStart ?? 0);
+        const rawInsertEnd = this.hasPattern
+            ? this.mapDisplayCursorToRawIndex(inputEl.selectionEnd ?? 0)
+            : (inputEl.selectionEnd ?? 0);
+        // Insert sanitized content into the raw value at the cursor position
+        const beforeCursor = this._rawValue.slice(0, rawInsertStart);
+        const afterCursor = this._rawValue.slice(rawInsertEnd);
+        let newRaw = beforeCursor + sanitized + afterCursor;
+        if (this.hasPattern) {
+            // Pattern mode: keep digits only, cap at slot count
+            newRaw = newRaw.replace(REGEX.ONLY_DIGITS, '').slice(0, this.patternDigitSlotCount);
+        }
+        else {
+            // Non-pattern mode: apply the same rules as onInput
+            if (this.decimalPlaces === 0 || this.effectiveOutputType === 'string') {
+                newRaw = newRaw.replace(REGEX.ALL_DOTS, '');
+            }
+            else {
+                newRaw = this.enforceDecimalRules(newRaw);
+            }
+            const maxLen = this.effectiveMaxLength;
+            const rawDigitCount = newRaw.replace(REGEX.NON_DIGIT_CHARACTERS, '').length;
+            if (maxLen !== null && rawDigitCount > maxLen) {
+                return; // pasted content would exceed digit limit — discard
+            }
+            const shouldStripLeadingZeros = !this.leadingZeros && this.effectiveOutputType === 'number';
+            if (shouldStripLeadingZeros) {
+                newRaw = this.stripLeadingZeros(newRaw);
+            }
+        }
+        this._rawValue = newRaw;
+        this.refreshDisplay();
+        this._onChange(this.buildModelValue());
+        this._onValidatorChange();
+    }
+    /**
+     * Block drag-and-drop into the field.
+     * Without this a user could drag text from elsewhere and bypass our rules.
+     */
+    onDrop(event) {
+        event.preventDefault();
+    }
+    // ─── Private methods ───────────────────────────────────────────────────────
+    /**
+     * Build the value that gets emitted to the Angular form model.
+     *
+     * Pattern / string mode  →  string | null
+     *   ''    → null   (empty field)
+     *   '123' → '123'  (raw digits, leading zeros preserved, no separators)
+     *
+     * Number mode  →  number | null
+     *   ''    → null   (empty field)
+     *   '-'   → null   (user typed a minus but no digits yet)
+     *   '123' → 123
+     *   '1.5' → 1.5
+     *   '-7'  → -7
+     */
+    buildModelValue() {
+        if (this._rawValue === '') {
+            return null;
+        }
+        if (this.effectiveOutputType === 'string') {
+            return this._rawValue || null;
+        }
+        // Number mode
+        if (this._rawValue === '-') {
+            return null; // not a valid number yet
+        }
+        const num = parseFloat(this._rawValue);
+        return isNaN(num) ? null : num;
+    }
+    /**
+     * Write the formatted display string back to the <input> DOM element
+     * and try to restore the cursor to a sensible position.
+     *
+     * @param cursorBefore  Cursor position in the display string BEFORE we reformatted
+     * @param lengthBefore  Total display string length BEFORE we reformatted
+     */
+    refreshDisplay(cursorBefore, lengthBefore) {
+        // ── Step 1: format the number portion ─────────────────────────────────
+        const formattedContent = this.hasPattern
+            ? this.applyPatternFormatting(this._rawValue)
+            : this.effectiveOutputType === 'string'
+                ? this._rawValue // string mode: no formatting
+                : this.applyThousandsFormatting(this._rawValue); // number mode: comma groups
+        // ── Step 2: assemble the full display string ───────────────────────────
+        //
+        // RTL layout:  [LRM][suffix][formattedNumber][prefix]
+        // LTR layout:  [prefix][formattedNumber][suffix]
+        //
+        // WHY SWAP PREFIX AND SUFFIX IN RTL?
+        //   In RTL reading order, the "start" of a line is the right side.
+        //   A currency symbol like "﷼" (Rial) naturally sits on the RIGHT of
+        //   the number in Arabic/Persian convention, while a unit like "kg"
+        //   sits on the LEFT.  That maps to: prefix visually right, suffix left.
+        //   By swapping their positions in the string, the bidi algorithm places
+        //   them correctly without any CSS changes.
+        //
+        // WHY LRM AT THE FRONT?
+        //   Prevents the bidi algorithm from treating the numeric content as RTL
+        //   text and mirroring digit order or separator placement.
+        //   The LRM is stripped before the value reaches the model.
+        const fullDisplayValue = this.isRtl
+            ? LRM + this.suffix + formattedContent + this.prefix
+            : this.prefix + formattedContent + this.suffix;
+        this.renderer.setProperty(this.el.nativeElement, 'value', fullDisplayValue);
+        // ── Step 3: restore cursor position ───────────────────────────────────
+        if (cursorBefore !== undefined && lengthBefore !== undefined) {
+            const lengthDelta = fullDisplayValue.length - lengthBefore;
+            // Clamp cursor between the editable start and end offsets,
+            // both of which account for the RTL/LTR decoration layout.
+            const newCursorPos = Math.max(this.editableStartOffset, Math.min(cursorBefore + lengthDelta, fullDisplayValue.length - this.editableEndPadding));
+            // Defer to next animation frame so the browser has committed the new value
+            requestAnimationFrame(() => {
+                this.el.nativeElement.setSelectionRange(newCursorPos, newCursorPos);
+            });
+        }
+    }
+    /**
+     * Apply the display format pattern to the current raw digit string.
+     *
+     * Algorithm:
+     *   Walk through the pattern character by character.
+     *   On '0': consume the next raw digit and add it to the result.
+     *   On anything else: this is a separator — add it ONLY if more digits follow.
+     *   (The "more digits follow" check prevents trailing separators mid-type.)
+     *
+     * Examples:
+     *   pattern '0000 0000 0000 0000', raw '41111111'  →  '4111 1111'
+     *   pattern '(000) 000-0000',      raw '5558675'   →  '(555) 867'
+     *   pattern '00/00',               raw '122'       →  '12/2'
+     */
+    applyPatternFormatting(raw) {
+        if (!this.hasPattern || !raw) {
+            return raw;
+        }
+        const digits = raw.replace(REGEX.ONLY_DIGITS, ''); // isolated digit string
+        let digitIndex = 0;
+        let displayResult = '';
+        for (const patternChar of this._resolvedPattern) {
+            // Stop when we run out of digits to place
+            if (digitIndex >= digits.length) {
+                break;
+            }
+            if (patternChar === '0') {
+                // Digit slot: consume the next digit
+                displayResult += digits[digitIndex];
+                digitIndex++;
+            }
+            else {
+                // Separator character: insert it only when more digits are still coming
+                // so we never show a trailing space/dash after the last typed digit
+                const moreDigitsRemain = digitIndex < digits.length;
+                if (moreDigitsRemain) {
+                    displayResult += patternChar;
+                }
+            }
+        }
+        return displayResult;
+    }
+    /**
+     * Apply thousands separator grouping and decimal character to a raw number string.
+     * Only used in number output mode (not pattern, not string mode).
+     *
+     * Examples (separator=',', decimalChar='.'):
+     *   '1234567'   →  '1,234,567'
+     *   '-9876.50'  →  '-9,876.50'
+     *   '100'       →  '100'
+     */
+    applyThousandsFormatting(raw) {
+        if (raw === '' || raw === '-') {
+            return raw;
+        }
+        const isNegative = raw.startsWith('-');
+        const absValue = isNegative ? raw.slice(1) : raw;
+        const [integerPart, decimalPart] = absValue.split('.');
+        // Insert the thousands separator every 3 digits from the right
+        const formattedInteger = this.thousandSeparator
+            ? integerPart.replace(REGEX.THOUSANDS_SEPARATOR_POSITIONS, this.thousandSeparator)
+            : integerPart;
+        const formattedDecimal = decimalPart !== undefined
+            ? this.displayDecimalChar + decimalPart
+            : '';
+        return (isNegative ? '-' : '') + formattedInteger + formattedDecimal;
+    }
+    /**
+     * Remove all visual decoration from the displayed input value and return
+     * the bare digit/numeric string ready for internal storage.
+     *
+     * Steps:
+     *   1. Strip prefix from the front
+     *   2. Strip suffix from the back
+     *   3. Remove pattern separators OR thousands separators (depending on mode)
+     *   4. Normalize non-ASCII decimal separator back to '.'
+     *   5. Remove any remaining non-numeric characters
+     */
+    stripDecorationsFrom(displayValue) {
+        let raw = displayValue;
+        // ── Remove the LRM marker if present ──────────────────────────────────
+        // In RTL mode every display string starts with LRM (U+200E).
+        // Strip it first so subsequent prefix/suffix checks work correctly.
+        if (raw.startsWith(LRM)) {
+            raw = raw.slice(LRM.length);
+        }
+        if (this.isRtl) {
+            // RTL layout: [suffix][formattedNumber][prefix]
+            // Remove suffix from the LEFT (start) and prefix from the RIGHT (end).
+            if (this.suffix && raw.startsWith(this.suffix)) {
+                raw = raw.slice(this.suffix.length);
+            }
+            if (this.prefix && raw.endsWith(this.prefix)) {
+                raw = raw.slice(0, -this.prefix.length);
+            }
+        }
+        else {
+            // LTR layout: [prefix][formattedNumber][suffix]
+            // Remove prefix from the LEFT and suffix from the RIGHT.
+            if (this.prefix && raw.startsWith(this.prefix)) {
+                raw = raw.slice(this.prefix.length);
+            }
+            if (this.suffix && raw.endsWith(this.suffix)) {
+                raw = raw.slice(0, -this.suffix.length);
+            }
+        }
+        if (this.hasPattern) {
+            // Pattern mode: remove the separator characters defined by the pattern
+            raw = this.stripPatternSeparatorsFrom(raw);
+        }
+        else if (this.thousandSeparator) {
+            // Number mode with thousands grouping: remove the grouping character
+            const escapedSeparator = this.thousandSeparator.replace(REGEX.REGEX_SPECIAL_CHARACTERS, '\\$&' // prepend \ before any regex-special character
+            );
+            raw = raw.replace(new RegExp(escapedSeparator, 'g'), '');
+        }
+        // If we're using a non-standard decimal char (e.g. ',' in European mode),
+        // normalize it back to '.' for internal storage
+        if (!this.hasPattern && this.displayDecimalChar !== '.') {
+            raw = raw.replace(this.displayDecimalChar, '.');
+        }
+        // Final sweep: remove anything that still isn't a digit, '.', or '-'
+        raw = raw.replace(REGEX.ONLY_DIGITS_DOT_AND_MINUS, '');
+        return raw;
+    }
+    /**
+     * Remove every separator character that the current pattern defines.
+     * For example, pattern '(000) 000-0000' defines '(', ')', ' ', '-' as separators.
+     * This strips all four from the input string, leaving only digits.
+     */
+    stripPatternSeparatorsFrom(value) {
+        let result = value;
+        for (const separatorChar of this.patternSeparatorChars) {
+            const escapedChar = separatorChar.replace(REGEX.REGEX_SPECIAL_CHARACTERS, '\\$&');
+            result = result.replace(new RegExp(escapedChar, 'g'), '');
+        }
+        return result;
+    }
+    /**
+     * Ensure a raw numeric string has at most one decimal point
+     * and at most [decimalPlaces] digits after it.
+     *
+     * Examples (decimalPlaces=2):
+     *   '12.345'  →  '12.34'
+     *   '1.2.3'   →  '1.23'
+     *   '100'     →  '100'
+     */
+    enforceDecimalRules(raw) {
+        const parts = raw.split('.');
+        // More than one dot? Collapse everything after the first dot into one decimal part
+        if (parts.length > 2) {
+            raw = parts[0] + '.' + parts.slice(1).join('');
+        }
+        // Too many decimal digits? Truncate to the allowed count
+        const [intPart, decPart] = raw.split('.');
+        if (decPart !== undefined && decPart.length > this.decimalPlaces) {
+            raw = intPart + '.' + decPart.slice(0, this.decimalPlaces);
+        }
+        return raw;
+    }
+    /**
+     * Remove unnecessary leading zeros from the integer part of a numeric string.
+     * Always preserves at least one digit and never touches the decimal part.
+     *
+     * Examples:
+     *   '007'    →  '7'
+     *   '0042'   →  '42'
+     *   '0.5'    →  '0.5'  (leading zero before decimal is correct, don't strip)
+     *   '100'    →  '100'  (no leading zero)
+     *   '-007'   →  '-7'   (handles negative values)
+     */
+    stripLeadingZeros(raw) {
+        if (!raw) {
+            return raw;
+        }
+        const isNegative = raw.startsWith('-');
+        const absValue = isNegative ? raw.slice(1) : raw;
+        const dotPosition = absValue.indexOf('.');
+        const integerPart = dotPosition >= 0 ? absValue.slice(0, dotPosition) : absValue;
+        const decimalPart = dotPosition >= 0 ? absValue.slice(dotPosition) : '';
+        // Replace leading zeros but always keep at least one digit
+        const cleanedInteger = integerPart.replace(REGEX.LEADING_ZEROS, '$1') || integerPart;
+        return (isNegative ? '-' : '') + cleanedInteger + decimalPart;
+    }
+    /**
+     * Sanitize a pasted string for non-pattern mode.
+     * The characters we keep depend on the current mode:
+     *
+     *   string mode    →  digits only (no dot, no minus; identifiers can't be negative)
+     *   integer number →  digits + optional leading minus
+     *   decimal number →  digits + optional dot + optional leading minus
+     */
+    sanitizePastedText(text) {
+        // Normalize decimal comma first (e.g. from a European spreadsheet paste)
+        let clean = text.replace(',', '.');
+        if (this.effectiveOutputType === 'string') {
+            clean = clean.replace(REGEX.ONLY_DIGITS, ''); // string: digits only
+        }
+        else if (this.decimalPlaces === 0) {
+            clean = clean.replace(REGEX.ONLY_DIGITS_AND_MINUS, ''); // integer: digits + minus
+        }
+        else {
+            clean = clean.replace(REGEX.ONLY_DIGITS_DOT_AND_MINUS, ''); // decimal: digits + . + minus
+        }
+        // Remove minus signs unless negative values are permitted
+        if (!this.allowNegative || this.effectiveOutputType === 'string') {
+            clean = clean.replace(REGEX.ALL_MINUS_SIGNS, '');
+        }
+        return clean;
+    }
+    /**
+     * Map a cursor position in the formatted DISPLAY string back to an index
+     * in the raw digit string.
+     *
+     * This is needed during paste operations in pattern mode so we know
+     * exactly which digit position the cursor is sitting at.
+     *
+     * Example:
+     *   pattern '(000) 000-0000'
+     *   display '(555) 867'   cursor at position 8 (after '(555) 86')
+     *
+     *   Walking the pattern:
+     *     '('  pos 0 → sep  (adjusted pos 0, raw index still 0)
+     *     '0'  pos 1 → digit (raw index 0)  digit consumed → raw index 1
+     *     '0'  pos 2 → digit (raw index 1)  digit consumed → raw index 2
+     *     '0'  pos 3 → digit (raw index 2)  digit consumed → raw index 3
+     *     ')'  pos 4 → sep
+     *     ' '  pos 5 → sep
+     *     '0'  pos 6 → digit (raw index 3)  digit consumed → raw index 4
+     *     '0'  pos 7 → digit (raw index 4)  digit consumed → raw index 5
+     *   We reached position 8, so raw index = 5  ✔
+     */
+    mapDisplayCursorToRawIndex(displayCursorPos) {
+        if (!this.hasPattern) {
+            return displayCursorPos;
+        }
+        // Adjust for prefix length so we walk the pattern relative to its own start
+        const positionInPattern = displayCursorPos - this.prefix.length;
+        let rawDigitIndex = 0;
+        let patternPosition = 0;
+        for (const patternChar of this._resolvedPattern) {
+            if (patternPosition >= positionInPattern) {
+                break;
+            }
+            if (patternChar === '0') {
+                rawDigitIndex++; // this position consumed a digit
+            }
+            patternPosition++;
+        }
+        return rawDigitIndex;
+    }
+    /**
+     * Decide whether a keyboard event is a "control" key that should always
+     * be allowed through without interception.
+     *
+     * Includes:
+     *   - Modifier keys held (Ctrl, Meta/Cmd, Alt) — so Ctrl+C, Ctrl+V, etc. work
+     *   - Navigation keys (arrows, Home, End)
+     *   - Editing keys (Backspace, Delete, Tab, Escape, Enter)
+     */
+    isControlKey(event) {
+        const isModifierHeld = event.ctrlKey || event.metaKey || event.altKey;
+        const isNavigationOrEditKey = [
+            'Backspace', 'Delete',
+            'Tab', 'Escape', 'Enter',
+            'ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown',
+            'Home', 'End',
+        ].includes(event.key);
+        return isModifierHeld || isNavigationOrEditKey;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: digitsOnlyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.6", type: digitsOnlyDirective, isStandalone: true, selector: "[digitsOnly]", inputs: { decimalPlaces: "decimalPlaces", thousandSeparator: "thousandSeparator", prefix: "prefix", suffix: "suffix", allowNegative: "allowNegative", leadingZeros: "leadingZeros", maxLength: "maxLength", min: "min", max: "max", outputType: "outputType", convertEasternNumerals: "convertEasternNumerals", pattern: "pattern" }, host: { listeners: { "keydown": "onKeyDown($event)", "input": "onInput()", "blur": "onBlur()", "paste": "onPaste($event)", "drop": "onDrop($event)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => digitsOnlyDirective),
+                multi: true,
+            },
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => digitsOnlyDirective),
+                multi: true,
+            },
+        ], usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: digitsOnlyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[digitsOnly]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => digitsOnlyDirective),
+                            multi: true,
+                        },
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => digitsOnlyDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }], propDecorators: { decimalPlaces: [{
+                type: Input
+            }], thousandSeparator: [{
+                type: Input
+            }], prefix: [{
+                type: Input
+            }], suffix: [{
+                type: Input
+            }], allowNegative: [{
+                type: Input
+            }], leadingZeros: [{
+                type: Input
+            }], maxLength: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], outputType: [{
+                type: Input
+            }], convertEasternNumerals: [{
+                type: Input
+            }], pattern: [{
+                type: Input
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onInput: [{
+                type: HostListener,
+                args: ['input']
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }], onPaste: [{
+                type: HostListener,
+                args: ['paste', ['$event']]
+            }], onDrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }] } });
+
+/*
+ * Public API Surface of digits-only
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { EASTERN_DIGIT_MAP, EASTERN_NUMERAL_REGEX, convertEasternDigits, digitsOnlyDirective, getDigitScript, hasEasternDigits, toWesternNumber };
+//# sourceMappingURL=ngx-digits-only.mjs.map