matcha-components 19.98.0 → 19.99.0

package/fesm2022/matcha-components.mjs

@@ -1,11 +1,12 @@
 import * as i0 from '@angular/core';
-import { EventEmitter, Output, Input, Component, ContentChildren, ElementRef, Renderer2, HostBinding, Inject, HostListener, ContentChild, Directive, forwardRef, ChangeDetectionStrategy, NgModule, createComponent, Injectable } from '@angular/core';
+import { EventEmitter, Output, Input, Component, ContentChildren, ElementRef, Renderer2, HostBinding, Inject, HostListener, ContentChild, Directive, forwardRef, ChangeDetectionStrategy, InjectionToken, inject, Injectable, input, output, signal, ViewChild, NgModule, createComponent, Pipe } from '@angular/core';
 import { animation, style, animate, trigger, transition, useAnimation, state, query, stagger, animateChild, sequence, group } from '@angular/animations';
 import { Subscription, Subject } from 'rxjs';
 import { debounceTime } from 'rxjs/operators';
 import * as i1 from '@angular/common';
-import { CommonModule } from '@angular/common';
-import { FormControlName, NG_VALUE_ACCESSOR, FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { DOCUMENT, CommonModule } from '@angular/common';
+import * as i2 from '@angular/forms';
+import { FormControlName, NG_VALUE_ACCESSOR, NG_VALIDATORS, FormsModule, ReactiveFormsModule } from '@angular/forms';
 
 const customAnimation = animation([
     style({
@@ -2151,6 +2152,4030 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
                 args: ['keydown', ['$event']]
             }] } });
 
+// Array of country objects for the flag dropdown.
+// Here is the criteria for the plugin to support a given country/territory
+// - It has an iso2 code: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
+// - It has it's own country calling code (it is not a sub-region of another country): https://en.wikipedia.org/wiki/List_of_country_calling_codes
+// - It has a flag in the region-flags project: https://github.com/behdad/region-flags/tree/gh-pages/png
+// - It is supported by libphonenumber (it must be listed on this page): https://github.com/googlei18n/libphonenumber/blob/master/resources/ShortNumberMetadata.xml
+// Each country array has the following information:
+// [
+//    Country name,
+//    iso2 code,
+//    International dial code,
+//    Order (if >1 country with same dial code),
+//    Area codes
+// ]
+var allCountries = [
+    [
+        "Afghanistan (‫افغانستان‬‎)",
+        "af",
+        "93"
+    ],
+    [
+        "Albania (Shqipëri)",
+        "al",
+        "355"
+    ],
+    [
+        "Algeria (‫الجزائر‬‎)",
+        "dz",
+        "213"
+    ],
+    [
+        "American Samoa",
+        "as",
+        "1",
+        5,
+        ["684"]
+    ],
+    [
+        "Andorra",
+        "ad",
+        "376"
+    ],
+    [
+        "Angola",
+        "ao",
+        "244"
+    ],
+    [
+        "Anguilla",
+        "ai",
+        "1",
+        6,
+        ["264"]
+    ],
+    [
+        "Antigua and Barbuda",
+        "ag",
+        "1",
+        7,
+        ["268"]
+    ],
+    [
+        "Argentina",
+        "ar",
+        "54",
+    ],
+    [
+        "Armenia (Հայաստան)",
+        "am",
+        "374"
+    ],
+    [
+        "Aruba",
+        "aw",
+        "297"
+    ],
+    [
+        "Australia",
+        "au",
+        "61",
+        0
+    ],
+    [
+        "Austria (Österreich)",
+        "at",
+        "43"
+    ],
+    [
+        "Azerbaijan (Azərbaycan)",
+        "az",
+        "994"
+    ],
+    [
+        "Bahamas",
+        "bs",
+        "1",
+        8,
+        ["242"]
+    ],
+    [
+        "Bahrain (‫البحرين‬‎)",
+        "bh",
+        "973"
+    ],
+    [
+        "Bangladesh (বাংলাদেশ)",
+        "bd",
+        "880"
+    ],
+    [
+        "Barbados",
+        "bb",
+        "1",
+        9,
+        ["246"]
+    ],
+    [
+        "Belarus (Беларусь)",
+        "by",
+        "375"
+    ],
+    [
+        "Belgium (België)",
+        "be",
+        "32"
+    ],
+    [
+        "Belize",
+        "bz",
+        "501"
+    ],
+    [
+        "Benin (Bénin)",
+        "bj",
+        "229"
+    ],
+    [
+        "Bermuda",
+        "bm",
+        "1",
+        10,
+        ["441"]
+    ],
+    [
+        "Bhutan (འབྲུག)",
+        "bt",
+        "975"
+    ],
+    [
+        "Bolivia",
+        "bo",
+        "591"
+    ],
+    [
+        "Bosnia and Herzegovina (Босна и Херцеговина)",
+        "ba",
+        "387"
+    ],
+    [
+        "Botswana",
+        "bw",
+        "267"
+    ],
+    [
+        "Brazil (Brasil)",
+        "br",
+        "55"
+    ],
+    [
+        "British Indian Ocean Territory",
+        "io",
+        "246"
+    ],
+    [
+        "British Virgin Islands",
+        "vg",
+        "1",
+        11,
+        ["284"]
+    ],
+    [
+        "Brunei",
+        "bn",
+        "673"
+    ],
+    [
+        "Bulgaria (България)",
+        "bg",
+        "359"
+    ],
+    [
+        "Burkina Faso",
+        "bf",
+        "226"
+    ],
+    [
+        "Burundi (Uburundi)",
+        "bi",
+        "257"
+    ],
+    [
+        "Cambodia (កម្ពុជា)",
+        "kh",
+        "855"
+    ],
+    [
+        "Cameroon (Cameroun)",
+        "cm",
+        "237"
+    ],
+    [
+        "Canada",
+        "ca",
+        "1",
+        1,
+        ["204", "226", "236", "249", "250", "289", "306", "343", "365", "387", "403", "416", "418", "431", "437", "438", "450", "506", "514", "519", "548", "579", "581", "587", "604", "613", "639", "647", "672", "705", "709", "742", "778", "780", "782", "807", "819", "825", "867", "873", "902", "905"]
+    ],
+    [
+        "Cape Verde (Kabu Verdi)",
+        "cv",
+        "238"
+    ],
+    [
+        "Caribbean Netherlands",
+        "bq",
+        "599",
+        1,
+        ["3", "4", "7"]
+    ],
+    [
+        "Cayman Islands",
+        "ky",
+        "1",
+        12,
+        ["345"]
+    ],
+    [
+        "Central African Republic (République centrafricaine)",
+        "cf",
+        "236"
+    ],
+    [
+        "Chad (Tchad)",
+        "td",
+        "235"
+    ],
+    [
+        "Chile",
+        "cl",
+        "56"
+    ],
+    [
+        "China (中国)",
+        "cn",
+        "86"
+    ],
+    [
+        "Christmas Island",
+        "cx",
+        "61",
+        2
+    ],
+    [
+        "Cocos (Keeling) Islands",
+        "cc",
+        "61",
+        1
+    ],
+    [
+        "Colombia",
+        "co",
+        "57"
+    ],
+    [
+        "Comoros (‫جزر القمر‬‎)",
+        "km",
+        "269"
+    ],
+    [
+        "Congo (DRC) (Jamhuri ya Kidemokrasia ya Kongo)",
+        "cd",
+        "243"
+    ],
+    [
+        "Congo (Republic) (Congo-Brazzaville)",
+        "cg",
+        "242"
+    ],
+    [
+        "Cook Islands",
+        "ck",
+        "682"
+    ],
+    [
+        "Costa Rica",
+        "cr",
+        "506"
+    ],
+    [
+        "Côte d’Ivoire",
+        "ci",
+        "225"
+    ],
+    [
+        "Croatia (Hrvatska)",
+        "hr",
+        "385"
+    ],
+    [
+        "Cuba",
+        "cu",
+        "53"
+    ],
+    [
+        "Curaçao",
+        "cw",
+        "599",
+        0
+    ],
+    [
+        "Cyprus (Κύπρος)",
+        "cy",
+        "357"
+    ],
+    [
+        "Czech Republic (Česká republika)",
+        "cz",
+        "420"
+    ],
+    [
+        "Denmark (Danmark)",
+        "dk",
+        "45"
+    ],
+    [
+        "Djibouti",
+        "dj",
+        "253"
+    ],
+    [
+        "Dominica",
+        "dm",
+        "1",
+        13,
+        ["767"]
+    ],
+    [
+        "Dominican Republic (República Dominicana)",
+        "do",
+        "1",
+        2,
+        ["809", "829", "849"]
+    ],
+    [
+        "Ecuador",
+        "ec",
+        "593"
+    ],
+    [
+        "Egypt (‫مصر‬‎)",
+        "eg",
+        "20"
+    ],
+    [
+        "El Salvador",
+        "sv",
+        "503"
+    ],
+    [
+        "Equatorial Guinea (Guinea Ecuatorial)",
+        "gq",
+        "240"
+    ],
+    [
+        "Eritrea",
+        "er",
+        "291"
+    ],
+    [
+        "Estonia (Eesti)",
+        "ee",
+        "372"
+    ],
+    [
+        "Ethiopia",
+        "et",
+        "251"
+    ],
+    [
+        "Falkland Islands (Islas Malvinas)",
+        "fk",
+        "500"
+    ],
+    [
+        "Faroe Islands (Føroyar)",
+        "fo",
+        "298"
+    ],
+    [
+        "Fiji",
+        "fj",
+        "679"
+    ],
+    [
+        "Finland (Suomi)",
+        "fi",
+        "358",
+        0
+    ],
+    [
+        "France",
+        "fr",
+        "33"
+    ],
+    [
+        "French Guiana (Guyane française)",
+        "gf",
+        "594"
+    ],
+    [
+        "French Polynesia (Polynésie française)",
+        "pf",
+        "689"
+    ],
+    [
+        "Gabon",
+        "ga",
+        "241"
+    ],
+    [
+        "Gambia",
+        "gm",
+        "220"
+    ],
+    [
+        "Georgia (საქართველო)",
+        "ge",
+        "995"
+    ],
+    [
+        "Germany (Deutschland)",
+        "de",
+        "49"
+    ],
+    [
+        "Ghana (Gaana)",
+        "gh",
+        "233"
+    ],
+    [
+        "Gibraltar",
+        "gi",
+        "350"
+    ],
+    [
+        "Greece (Ελλάδα)",
+        "gr",
+        "30"
+    ],
+    [
+        "Greenland (Kalaallit Nunaat)",
+        "gl",
+        "299"
+    ],
+    [
+        "Grenada",
+        "gd",
+        "1",
+        14,
+        ["473"]
+    ],
+    [
+        "Guadeloupe",
+        "gp",
+        "590",
+        0
+    ],
+    [
+        "Guam",
+        "gu",
+        "1",
+        15,
+        ["671"]
+    ],
+    [
+        "Guatemala",
+        "gt",
+        "502"
+    ],
+    [
+        "Guernsey",
+        "gg",
+        "44",
+        1,
+        ["1481", "7781", "7839", "7911"]
+    ],
+    [
+        "Guinea (Guinée)",
+        "gn",
+        "224"
+    ],
+    [
+        "Guinea-Bissau (Guiné Bissau)",
+        "gw",
+        "245"
+    ],
+    [
+        "Guyana",
+        "gy",
+        "592"
+    ],
+    [
+        "Haiti",
+        "ht",
+        "509"
+    ],
+    [
+        "Honduras",
+        "hn",
+        "504"
+    ],
+    [
+        "Hong Kong (香港)",
+        "hk",
+        "852"
+    ],
+    [
+        "Hungary (Magyarország)",
+        "hu",
+        "36"
+    ],
+    [
+        "Iceland (Ísland)",
+        "is",
+        "354"
+    ],
+    [
+        "India (भारत)",
+        "in",
+        "91"
+    ],
+    [
+        "Indonesia",
+        "id",
+        "62"
+    ],
+    [
+        "Iran (‫ایران‬‎)",
+        "ir",
+        "98"
+    ],
+    [
+        "Iraq (‫العراق‬‎)",
+        "iq",
+        "964"
+    ],
+    [
+        "Ireland",
+        "ie",
+        "353"
+    ],
+    [
+        "Isle of Man",
+        "im",
+        "44",
+        2,
+        ["1624", "74576", "7524", "7924", "7624"]
+    ],
+    [
+        "Israel (‫ישראל‬‎)",
+        "il",
+        "972"
+    ],
+    [
+        "Italy (Italia)",
+        "it",
+        "39",
+        0
+    ],
+    [
+        "Jamaica",
+        "jm",
+        "1",
+        4,
+        ["876", "658"]
+    ],
+    [
+        "Japan (日本)",
+        "jp",
+        "81"
+    ],
+    [
+        "Jersey",
+        "je",
+        "44",
+        3,
+        ["1534", "7509", "7700", "7797", "7829", "7937"]
+    ],
+    [
+        "Jordan (‫الأردن‬‎)",
+        "jo",
+        "962"
+    ],
+    [
+        "Kazakhstan (Казахстан)",
+        "kz",
+        "7",
+        1,
+        ["33", "7"]
+    ],
+    [
+        "Kenya",
+        "ke",
+        "254"
+    ],
+    [
+        "Kiribati",
+        "ki",
+        "686"
+    ],
+    [
+        "Kosovo",
+        "xk",
+        "383"
+    ],
+    [
+        "Kuwait (‫الكويت‬‎)",
+        "kw",
+        "965"
+    ],
+    [
+        "Kyrgyzstan (Кыргызстан)",
+        "kg",
+        "996"
+    ],
+    [
+        "Laos (ລາວ)",
+        "la",
+        "856"
+    ],
+    [
+        "Latvia (Latvija)",
+        "lv",
+        "371"
+    ],
+    [
+        "Lebanon (‫لبنان‬‎)",
+        "lb",
+        "961"
+    ],
+    [
+        "Lesotho",
+        "ls",
+        "266"
+    ],
+    [
+        "Liberia",
+        "lr",
+        "231"
+    ],
+    [
+        "Libya (‫ليبيا‬‎)",
+        "ly",
+        "218"
+    ],
+    [
+        "Liechtenstein",
+        "li",
+        "423"
+    ],
+    [
+        "Lithuania (Lietuva)",
+        "lt",
+        "370"
+    ],
+    [
+        "Luxembourg",
+        "lu",
+        "352"
+    ],
+    [
+        "Macau (澳門)",
+        "mo",
+        "853"
+    ],
+    [
+        "Macedonia (FYROM) (Македонија)",
+        "mk",
+        "389"
+    ],
+    [
+        "Madagascar (Madagasikara)",
+        "mg",
+        "261"
+    ],
+    [
+        "Malawi",
+        "mw",
+        "265"
+    ],
+    [
+        "Malaysia",
+        "my",
+        "60"
+    ],
+    [
+        "Maldives",
+        "mv",
+        "960"
+    ],
+    [
+        "Mali",
+        "ml",
+        "223"
+    ],
+    [
+        "Malta",
+        "mt",
+        "356"
+    ],
+    [
+        "Marshall Islands",
+        "mh",
+        "692"
+    ],
+    [
+        "Martinique",
+        "mq",
+        "596"
+    ],
+    [
+        "Mauritania (‫موريتانيا‬‎)",
+        "mr",
+        "222"
+    ],
+    [
+        "Mauritius (Moris)",
+        "mu",
+        "230"
+    ],
+    [
+        "Mayotte",
+        "yt",
+        "262",
+        1,
+        ["269", "639"]
+    ],
+    [
+        "Mexico (México)",
+        "mx",
+        "52"
+    ],
+    [
+        "Micronesia",
+        "fm",
+        "691"
+    ],
+    [
+        "Moldova (Republica Moldova)",
+        "md",
+        "373"
+    ],
+    [
+        "Monaco",
+        "mc",
+        "377"
+    ],
+    [
+        "Mongolia (Монгол)",
+        "mn",
+        "976"
+    ],
+    [
+        "Montenegro (Crna Gora)",
+        "me",
+        "382"
+    ],
+    [
+        "Montserrat",
+        "ms",
+        "1",
+        16,
+        ["664"]
+    ],
+    [
+        "Morocco (‫المغرب‬‎)",
+        "ma",
+        "212",
+        0
+    ],
+    [
+        "Mozambique (Moçambique)",
+        "mz",
+        "258"
+    ],
+    [
+        "Myanmar (Burma) (မြန်မာ)",
+        "mm",
+        "95"
+    ],
+    [
+        "Namibia (Namibië)",
+        "na",
+        "264"
+    ],
+    [
+        "Nauru",
+        "nr",
+        "674"
+    ],
+    [
+        "Nepal (नेपाल)",
+        "np",
+        "977"
+    ],
+    [
+        "Netherlands (Nederland)",
+        "nl",
+        "31"
+    ],
+    [
+        "New Caledonia (Nouvelle-Calédonie)",
+        "nc",
+        "687"
+    ],
+    [
+        "New Zealand",
+        "nz",
+        "64"
+    ],
+    [
+        "Nicaragua",
+        "ni",
+        "505"
+    ],
+    [
+        "Niger (Nijar)",
+        "ne",
+        "227"
+    ],
+    [
+        "Nigeria",
+        "ng",
+        "234"
+    ],
+    [
+        "Niue",
+        "nu",
+        "683"
+    ],
+    [
+        "Norfolk Island",
+        "nf",
+        "672"
+    ],
+    [
+        "North Korea (조선 민주주의 인민 공화국)",
+        "kp",
+        "850"
+    ],
+    [
+        "Northern Mariana Islands",
+        "mp",
+        "1",
+        17,
+        ["670"]
+    ],
+    [
+        "Norway (Norge)",
+        "no",
+        "47",
+        0
+    ],
+    [
+        "Oman (‫عُمان‬‎)",
+        "om",
+        "968"
+    ],
+    [
+        "Pakistan (‫پاکستان‬‎)",
+        "pk",
+        "92"
+    ],
+    [
+        "Palau",
+        "pw",
+        "680"
+    ],
+    [
+        "Palestine (‫فلسطين‬‎)",
+        "ps",
+        "970"
+    ],
+    [
+        "Panama (Panamá)",
+        "pa",
+        "507"
+    ],
+    [
+        "Papua New Guinea",
+        "pg",
+        "675"
+    ],
+    [
+        "Paraguay",
+        "py",
+        "595"
+    ],
+    [
+        "Peru (Perú)",
+        "pe",
+        "51"
+    ],
+    [
+        "Philippines",
+        "ph",
+        "63"
+    ],
+    [
+        "Poland (Polska)",
+        "pl",
+        "48"
+    ],
+    [
+        "Portugal",
+        "pt",
+        "351"
+    ],
+    [
+        "Puerto Rico",
+        "pr",
+        "1",
+        3,
+        ["787", "939"]
+    ],
+    [
+        "Qatar (‫قطر‬‎)",
+        "qa",
+        "974"
+    ],
+    [
+        "Réunion (La Réunion)",
+        "re",
+        "262",
+        0
+    ],
+    [
+        "Romania (România)",
+        "ro",
+        "40"
+    ],
+    [
+        "Russia (Россия)",
+        "ru",
+        "7",
+        0
+    ],
+    [
+        "Rwanda",
+        "rw",
+        "250"
+    ],
+    [
+        "Saint Barthélemy",
+        "bl",
+        "590",
+        1
+    ],
+    [
+        "Saint Helena",
+        "sh",
+        "290"
+    ],
+    [
+        "Saint Kitts and Nevis",
+        "kn",
+        "1",
+        18,
+        ["869"]
+    ],
+    [
+        "Saint Lucia",
+        "lc",
+        "1",
+        19,
+        ["758"]
+    ],
+    [
+        "Saint Martin (Saint-Martin (partie française))",
+        "mf",
+        "590",
+        2
+    ],
+    [
+        "Saint Pierre and Miquelon (Saint-Pierre-et-Miquelon)",
+        "pm",
+        "508"
+    ],
+    [
+        "Saint Vincent and the Grenadines",
+        "vc",
+        "1",
+        20,
+        ["784"]
+    ],
+    [
+        "Samoa",
+        "ws",
+        "685"
+    ],
+    [
+        "San Marino",
+        "sm",
+        "378"
+    ],
+    [
+        "São Tomé and Príncipe (São Tomé e Príncipe)",
+        "st",
+        "239"
+    ],
+    [
+        "Saudi Arabia (‫المملكة العربية السعودية‬‎)",
+        "sa",
+        "966"
+    ],
+    [
+        "Senegal (Sénégal)",
+        "sn",
+        "221"
+    ],
+    [
+        "Serbia (Србија)",
+        "rs",
+        "381"
+    ],
+    [
+        "Seychelles",
+        "sc",
+        "248"
+    ],
+    [
+        "Sierra Leone",
+        "sl",
+        "232"
+    ],
+    [
+        "Singapore",
+        "sg",
+        "65"
+    ],
+    [
+        "Sint Maarten",
+        "sx",
+        "1",
+        21,
+        ["721"]
+    ],
+    [
+        "Slovakia (Slovensko)",
+        "sk",
+        "421"
+    ],
+    [
+        "Slovenia (Slovenija)",
+        "si",
+        "386"
+    ],
+    [
+        "Solomon Islands",
+        "sb",
+        "677"
+    ],
+    [
+        "Somalia (Soomaaliya)",
+        "so",
+        "252"
+    ],
+    [
+        "South Africa",
+        "za",
+        "27"
+    ],
+    [
+        "South Korea (대한민국)",
+        "kr",
+        "82"
+    ],
+    [
+        "South Sudan (‫جنوب السودان‬‎)",
+        "ss",
+        "211"
+    ],
+    [
+        "Spain (España)",
+        "es",
+        "34"
+    ],
+    [
+        "Sri Lanka (ශ්‍රී ලංකාව)",
+        "lk",
+        "94"
+    ],
+    [
+        "Sudan (‫السودان‬‎)",
+        "sd",
+        "249"
+    ],
+    [
+        "Suriname",
+        "sr",
+        "597"
+    ],
+    [
+        "Svalbard and Jan Mayen",
+        "sj",
+        "47",
+        1,
+        ["79"]
+    ],
+    [
+        "Swaziland",
+        "sz",
+        "268"
+    ],
+    [
+        "Sweden (Sverige)",
+        "se",
+        "46"
+    ],
+    [
+        "Switzerland (Schweiz)",
+        "ch",
+        "41"
+    ],
+    [
+        "Syria (‫سوريا‬‎)",
+        "sy",
+        "963"
+    ],
+    [
+        "Taiwan (台灣)",
+        "tw",
+        "886"
+    ],
+    [
+        "Tajikistan",
+        "tj",
+        "992"
+    ],
+    [
+        "Tanzania",
+        "tz",
+        "255"
+    ],
+    [
+        "Thailand (ไทย)",
+        "th",
+        "66"
+    ],
+    [
+        "Timor-Leste",
+        "tl",
+        "670"
+    ],
+    [
+        "Togo",
+        "tg",
+        "228"
+    ],
+    [
+        "Tokelau",
+        "tk",
+        "690"
+    ],
+    [
+        "Tonga",
+        "to",
+        "676"
+    ],
+    [
+        "Trinidad and Tobago",
+        "tt",
+        "1",
+        22,
+        ["868"]
+    ],
+    [
+        "Tunisia (‫تونس‬‎)",
+        "tn",
+        "216"
+    ],
+    [
+        "Turkey (Türkiye)",
+        "tr",
+        "90"
+    ],
+    [
+        "Turkmenistan",
+        "tm",
+        "993"
+    ],
+    [
+        "Turks and Caicos Islands",
+        "tc",
+        "1",
+        23,
+        ["649"]
+    ],
+    [
+        "Tuvalu",
+        "tv",
+        "688"
+    ],
+    [
+        "U.S. Virgin Islands",
+        "vi",
+        "1",
+        24,
+        ["340"]
+    ],
+    [
+        "Uganda",
+        "ug",
+        "256"
+    ],
+    [
+        "Ukraine (Україна)",
+        "ua",
+        "380"
+    ],
+    [
+        "United Arab Emirates (‫الإمارات العربية المتحدة‬‎)",
+        "ae",
+        "971"
+    ],
+    [
+        "United Kingdom",
+        "gb",
+        "44",
+        0
+    ],
+    [
+        "United States",
+        "us",
+        "1",
+        0
+    ],
+    [
+        "Uruguay",
+        "uy",
+        "598"
+    ],
+    [
+        "Uzbekistan (Oʻzbekiston)",
+        "uz",
+        "998"
+    ],
+    [
+        "Vanuatu",
+        "vu",
+        "678"
+    ],
+    [
+        "Vatican City (Città del Vaticano)",
+        "va",
+        "39",
+        1,
+        ["06698"]
+    ],
+    [
+        "Venezuela",
+        "ve",
+        "58"
+    ],
+    [
+        "Vietnam (Việt Nam)",
+        "vn",
+        "84"
+    ],
+    [
+        "Wallis and Futuna (Wallis-et-Futuna)",
+        "wf",
+        "681"
+    ],
+    [
+        "Western Sahara (‫الصحراء الغربية‬‎)",
+        "eh",
+        "212",
+        1,
+        ["5288", "5289"]
+    ],
+    [
+        "Yemen (‫اليمن‬‎)",
+        "ye",
+        "967"
+    ],
+    [
+        "Zambia",
+        "zm",
+        "260"
+    ],
+    [
+        "Zimbabwe",
+        "zw",
+        "263"
+    ],
+    [
+        "Åland Islands",
+        "ax",
+        "358",
+        1,
+        ["18"]
+    ]
+];
+// loop over all of the countries above, restructuring the data to be objects with named keys
+function getCountryISO2() {
+    let countries = [];
+    for (var i = 0; i < allCountries.length; i++) {
+        var c = allCountries[i];
+        // Garante que o array tenha pelo menos 3 elementos
+        const safeCountry = [
+            c[0],
+            c[1],
+            c[2],
+            c[3] || 0,
+            c[4] || null
+        ];
+        countries[i] = {
+            name: c[0],
+            iso2: c[1],
+            dialCode: c[2],
+            priority: c[3] || 0,
+            areaCodes: c[4] || null,
+            mask: applyPhoneMask(safeCountry)
+        };
+    }
+    return countries;
+}
+function applyPhoneMask(country) {
+    const countryCode = country[2];
+    const areaCodes = country[4] || [countryCode];
+    const masks = areaCodes.map((areaCode) => {
+        if (countryCode === "1") {
+            // North American Numbering Plan (NANP)
+            return `000 000 0000`;
+        }
+        else if (countryCode === "44" && areaCode.length === 4) {
+            // UK
+            return `000 0000 0000`;
+        }
+        else if (countryCode === "55") {
+            // Brazil
+            return `00 0000 0000`;
+        }
+        else {
+            // General international format
+            return `000 0000 0000`;
+        }
+    });
+    return masks;
+}
+
+const NGX_MASK_CONFIG = new InjectionToken('ngx-mask config');
+const NEW_CONFIG = new InjectionToken('new ngx-mask config');
+const INITIAL_CONFIG = new InjectionToken('initial ngx-mask config');
+const initialConfig = {
+    suffix: '',
+    prefix: '',
+    thousandSeparator: ' ',
+    decimalMarker: ['.', ','],
+    clearIfNotMatch: false,
+    showMaskTyped: false,
+    instantPrefix: false,
+    placeHolderCharacter: '_',
+    dropSpecialCharacters: true,
+    hiddenInput: false,
+    shownMaskExpression: '',
+    separatorLimit: '',
+    allowNegativeNumbers: false,
+    validation: true,
+    specialCharacters: ['-', '/', '(', ')', '.', ':', ' ', '+', ',', '@', '[', ']', '"', "'"],
+    leadZeroDateTime: false,
+    apm: false,
+    leadZero: false,
+    keepCharacterPositions: false,
+    triggerOnMaskChange: false,
+    inputTransformFn: (value) => value,
+    outputTransformFn: (value) => value,
+    maskFilled: new EventEmitter(),
+    patterns: {
+        '0': {
+            pattern: new RegExp('\\d'),
+        },
+        '9': {
+            pattern: new RegExp('\\d'),
+            optional: true,
+        },
+        X: {
+            pattern: new RegExp('\\d'),
+            symbol: '*',
+        },
+        A: {
+            pattern: new RegExp('[a-zA-Z0-9]'),
+        },
+        S: {
+            pattern: new RegExp('[a-zA-Z]'),
+        },
+        U: {
+            pattern: new RegExp('[A-Z]'),
+        },
+        L: {
+            pattern: new RegExp('[a-z]'),
+        },
+        d: {
+            pattern: new RegExp('\\d'),
+        },
+        m: {
+            pattern: new RegExp('\\d'),
+        },
+        M: {
+            pattern: new RegExp('\\d'),
+        },
+        H: {
+            pattern: new RegExp('\\d'),
+        },
+        h: {
+            pattern: new RegExp('\\d'),
+        },
+        s: {
+            pattern: new RegExp('\\d'),
+        },
+    },
+};
+const timeMasks = [
+    "Hh:m0:s0" /* MaskExpression.HOURS_MINUTES_SECONDS */,
+    "Hh:m0" /* MaskExpression.HOURS_MINUTES */,
+    "m0:s0" /* MaskExpression.MINUTES_SECONDS */,
+];
+const withoutValidation = [
+    "percent" /* MaskExpression.PERCENT */,
+    "Hh" /* MaskExpression.HOURS_HOUR */,
+    "s0" /* MaskExpression.SECONDS */,
+    "m0" /* MaskExpression.MINUTES */,
+    "separator" /* MaskExpression.SEPARATOR */,
+    "d0/M0/0000" /* MaskExpression.DAYS_MONTHS_YEARS */,
+    "d0/M0" /* MaskExpression.DAYS_MONTHS */,
+    "d0" /* MaskExpression.DAYS */,
+    "M0" /* MaskExpression.MONTHS */,
+];
+
+class NgxMaskApplierService {
+    constructor() {
+        this._config = inject(NGX_MASK_CONFIG);
+        this.dropSpecialCharacters = this._config.dropSpecialCharacters;
+        this.hiddenInput = this._config.hiddenInput;
+        this.clearIfNotMatch = this._config.clearIfNotMatch;
+        this.specialCharacters = this._config.specialCharacters;
+        this.patterns = this._config.patterns;
+        this.prefix = this._config.prefix || '';
+        this.suffix = this._config.suffix || '';
+        this.thousandSeparator = this._config.thousandSeparator || '';
+        this.decimalMarker = this._config.decimalMarker || '';
+        this.showMaskTyped = this._config.showMaskTyped;
+        this.placeHolderCharacter = this._config.placeHolderCharacter;
+        this.validation = this._config.validation;
+        this.separatorLimit = this._config.separatorLimit;
+        this.allowNegativeNumbers = this._config.allowNegativeNumbers;
+        this.leadZeroDateTime = this._config.leadZeroDateTime;
+        this.leadZero = this._config.leadZero;
+        this.apm = this._config.apm;
+        this.inputTransformFn = this._config.inputTransformFn;
+        this.outputTransformFn = this._config.outputTransformFn;
+        this.keepCharacterPositions = this._config.keepCharacterPositions;
+        this.instantPrefix = this._config.instantPrefix;
+        this.triggerOnMaskChange = this._config.triggerOnMaskChange;
+        this._shift = new Set();
+        this.plusOnePosition = false;
+        this.maskExpression = '';
+        this.actualValue = '';
+        this.showKeepCharacterExp = '';
+        this.shownMaskExpression = this._config.shownMaskExpression;
+        this.deletedSpecialCharacter = false;
+        this._formatWithSeparators = (str, thousandSeparatorChar, decimalChars, precision) => {
+            let x = [];
+            let decimalChar = '';
+            if (Array.isArray(decimalChars)) {
+                const regExp = new RegExp(decimalChars.map((v) => ('[\\^$.|?*+()'.indexOf(v) >= 0 ? `\\${v}` : v)).join('|'));
+                x = str.split(regExp);
+                decimalChar = str.match(regExp)?.[0] ?? "" /* MaskExpression.EMPTY_STRING */;
+            }
+            else {
+                x = str.split(decimalChars);
+                decimalChar = decimalChars;
+            }
+            const decimals = x.length > 1 ? `${decimalChar}${x[1]}` : "" /* MaskExpression.EMPTY_STRING */;
+            let res = x[0] ?? "" /* MaskExpression.EMPTY_STRING */;
+            const separatorLimit = this.separatorLimit.replace(/\s/g, "" /* MaskExpression.EMPTY_STRING */);
+            if (separatorLimit && +separatorLimit) {
+                if (res[0] === "-" /* MaskExpression.MINUS */) {
+                    res = `-${res.slice(1, res.length).slice(0, separatorLimit.length)}`;
+                }
+                else {
+                    res = res.slice(0, separatorLimit.length);
+                }
+            }
+            const rgx = /(\d+)(\d{3})/;
+            while (thousandSeparatorChar && rgx.test(res)) {
+                res = res.replace(rgx, '$1' + thousandSeparatorChar + '$2');
+            }
+            if (typeof precision === 'undefined') {
+                return res + decimals;
+            }
+            else if (precision === 0) {
+                return res;
+            }
+            return res + decimals.substring(0, precision + 1);
+        };
+        this.percentage = (str) => {
+            const sanitizedStr = str.replace(',', '.');
+            const value = Number(this.allowNegativeNumbers && str.includes("-" /* MaskExpression.MINUS */)
+                ? sanitizedStr.slice(1, str.length)
+                : sanitizedStr);
+            return !isNaN(value) && value >= 0 && value <= 100;
+        };
+        this.getPrecision = (maskExpression) => {
+            const x = maskExpression.split("." /* MaskExpression.DOT */);
+            if (x.length > 1) {
+                return Number(x[x.length - 1]);
+            }
+            return Infinity;
+        };
+        this.checkAndRemoveSuffix = (inputValue) => {
+            for (let i = this.suffix?.length - 1; i >= 0; i--) {
+                const substr = this.suffix.substring(i, this.suffix?.length);
+                if (inputValue.includes(substr) &&
+                    i !== this.suffix?.length - 1 &&
+                    (i - 1 < 0 ||
+                        !inputValue.includes(this.suffix.substring(i - 1, this.suffix?.length)))) {
+                    return inputValue.replace(substr, "" /* MaskExpression.EMPTY_STRING */);
+                }
+            }
+            return inputValue;
+        };
+        this.checkInputPrecision = (inputValue, precision, decimalMarker) => {
+            let processedInputValue = inputValue;
+            let processedDecimalMarker = decimalMarker;
+            if (precision < Infinity) {
+                // TODO need think about decimalMarker
+                if (Array.isArray(processedDecimalMarker)) {
+                    const marker = processedDecimalMarker.find((dm) => dm !== this.thousandSeparator);
+                    processedDecimalMarker = marker ? marker : processedDecimalMarker[0];
+                }
+                const precisionRegEx = new RegExp(this._charToRegExpExpression(processedDecimalMarker) + `\\d{${precision}}.*$`);
+                const precisionMatch = processedInputValue.match(precisionRegEx);
+                const precisionMatchLength = (precisionMatch && precisionMatch[0]?.length) ?? 0;
+                if (precisionMatchLength - 1 > precision) {
+                    const diff = precisionMatchLength - 1 - precision;
+                    processedInputValue = processedInputValue.substring(0, processedInputValue.length - diff);
+                }
+                if (precision === 0 &&
+                    this._compareOrIncludes(processedInputValue[processedInputValue.length - 1], processedDecimalMarker, this.thousandSeparator)) {
+                    processedInputValue = processedInputValue.substring(0, processedInputValue.length - 1);
+                }
+            }
+            return processedInputValue;
+        };
+    }
+    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    cb = () => { }) {
+        if (!maskExpression || typeof inputValue !== 'string') {
+            return "" /* MaskExpression.EMPTY_STRING */;
+        }
+        let cursor = 0;
+        let result = '';
+        let multi = false;
+        let backspaceShift = false;
+        let shift = 1;
+        let stepBack = false;
+        let processedValue = inputValue;
+        let processedPosition = position;
+        if (processedValue.slice(0, this.prefix.length) === this.prefix) {
+            processedValue = processedValue.slice(this.prefix.length, processedValue.length);
+        }
+        if (!!this.suffix && processedValue.length > 0) {
+            processedValue = this.checkAndRemoveSuffix(processedValue);
+        }
+        if (processedValue === '(' && this.prefix) {
+            processedValue = '';
+        }
+        const inputArray = processedValue.toString().split("" /* MaskExpression.EMPTY_STRING */);
+        if (this.allowNegativeNumbers &&
+            processedValue.slice(cursor, cursor + 1) === "-" /* MaskExpression.MINUS */) {
+            result += processedValue.slice(cursor, cursor + 1);
+        }
+        if (maskExpression === "IP" /* MaskExpression.IP */) {
+            const valuesIP = processedValue.split("." /* MaskExpression.DOT */);
+            this.ipError = this._validIP(valuesIP);
+            // eslint-disable-next-line no-param-reassign
+            maskExpression = '099.099.099.099';
+        }
+        const arr = [];
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let i = 0; i < processedValue.length; i++) {
+            if (processedValue[i]?.match('\\d')) {
+                arr.push(processedValue[i] ?? "" /* MaskExpression.EMPTY_STRING */);
+            }
+        }
+        if (maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */) {
+            this.cpfCnpjError = arr.length !== 11 && arr.length !== 14;
+            if (arr.length > 11) {
+                // eslint-disable-next-line no-param-reassign
+                maskExpression = '00.000.000/0000-00';
+            }
+            else {
+                // eslint-disable-next-line no-param-reassign
+                maskExpression = '000.000.000-00';
+            }
+        }
+        if (maskExpression.startsWith("percent" /* MaskExpression.PERCENT */)) {
+            if (processedValue.match('[a-z]|[A-Z]') ||
+                // eslint-disable-next-line no-useless-escape
+                (processedValue.match(/[-!$%^&*()_+|~=`{}\[\]:";'<>?,\/.]/) && !backspaced)) {
+                processedValue = this._stripToDecimal(processedValue);
+                const precision = this.getPrecision(maskExpression);
+                processedValue = this.checkInputPrecision(processedValue, precision, this.decimalMarker);
+            }
+            const decimalMarker = typeof this.decimalMarker === 'string' ? this.decimalMarker : "." /* MaskExpression.DOT */;
+            if (processedValue.indexOf(decimalMarker) > 0 &&
+                !this.percentage(processedValue.substring(0, processedValue.indexOf(decimalMarker)))) {
+                let base = processedValue.substring(0, processedValue.indexOf(decimalMarker) - 1);
+                if (this.allowNegativeNumbers &&
+                    processedValue.slice(cursor, cursor + 1) === "-" /* MaskExpression.MINUS */ &&
+                    !backspaced) {
+                    base = processedValue.substring(0, processedValue.indexOf(decimalMarker));
+                }
+                processedValue = `${base}${processedValue.substring(processedValue.indexOf(decimalMarker), processedValue.length)}`;
+            }
+            let value = '';
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            this.allowNegativeNumbers &&
+                processedValue.slice(cursor, cursor + 1) === "-" /* MaskExpression.MINUS */
+                ? (value = `${"-" /* MaskExpression.MINUS */}${processedValue.slice(cursor + 1, cursor + processedValue.length)}`)
+                : (value = processedValue);
+            if (this.percentage(value)) {
+                result = this._splitPercentZero(processedValue);
+            }
+            else {
+                result = this._splitPercentZero(processedValue.substring(0, processedValue.length - 1));
+            }
+        }
+        else if (maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+            if (processedValue.match('[wа-яА-Я]') ||
+                processedValue.match('[ЁёА-я]') ||
+                processedValue.match('[a-z]|[A-Z]') ||
+                processedValue.match(/[-@#!$%\\^&*()_£¬'+|~=`{}\]:";<>.?/]/) ||
+                processedValue.match('[^A-Za-z0-9,]')) {
+                processedValue = this._stripToDecimal(processedValue);
+            }
+            const precision = this.getPrecision(maskExpression);
+            let decimalMarker = this.decimalMarker;
+            if (Array.isArray(this.decimalMarker)) {
+                if (this.actualValue.includes(this.decimalMarker[0]) ||
+                    this.actualValue.includes(this.decimalMarker[1])) {
+                    decimalMarker = this.actualValue.includes(this.decimalMarker[0])
+                        ? this.decimalMarker[0]
+                        : this.decimalMarker[1];
+                }
+                else {
+                    decimalMarker = this.decimalMarker.find((dm) => dm !== this.thousandSeparator);
+                }
+            }
+            if (backspaced) {
+                const { decimalMarkerIndex, nonZeroIndex } = this._findFirstNonZeroAndDecimalIndex(processedValue, decimalMarker);
+                const zeroIndexMinus = processedValue[0] === "-" /* MaskExpression.MINUS */;
+                const zeroIndexNumberZero = processedValue[0] === "0" /* MaskExpression.NUMBER_ZERO */;
+                const zeroIndexDecimalMarker = processedValue[0] === decimalMarker;
+                const firstIndexDecimalMarker = processedValue[1] === decimalMarker;
+                if ((zeroIndexDecimalMarker && !nonZeroIndex) ||
+                    (zeroIndexMinus && firstIndexDecimalMarker && !nonZeroIndex) ||
+                    (zeroIndexNumberZero && !decimalMarkerIndex && !nonZeroIndex)) {
+                    processedValue = "0" /* MaskExpression.NUMBER_ZERO */;
+                }
+                if (decimalMarkerIndex &&
+                    nonZeroIndex &&
+                    zeroIndexMinus &&
+                    processedPosition === 1) {
+                    if (decimalMarkerIndex < nonZeroIndex || decimalMarkerIndex > nonZeroIndex) {
+                        processedValue = "-" /* MaskExpression.MINUS */ + processedValue.slice(nonZeroIndex);
+                    }
+                }
+                if (!decimalMarkerIndex && nonZeroIndex && processedValue.length > nonZeroIndex) {
+                    processedValue = zeroIndexMinus
+                        ? "-" /* MaskExpression.MINUS */ + processedValue.slice(nonZeroIndex)
+                        : processedValue.slice(nonZeroIndex);
+                }
+                if (decimalMarkerIndex && nonZeroIndex && processedPosition === 0) {
+                    if (decimalMarkerIndex < nonZeroIndex) {
+                        processedValue = processedValue.slice(decimalMarkerIndex - 1);
+                    }
+                    if (decimalMarkerIndex > nonZeroIndex) {
+                        processedValue = processedValue.slice(nonZeroIndex);
+                    }
+                }
+            }
+            if (precision === 0) {
+                processedValue = this.allowNegativeNumbers
+                    ? processedValue.length > 2 &&
+                        processedValue[0] === "-" /* MaskExpression.MINUS */ &&
+                        processedValue[1] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                        processedValue[2] !== this.thousandSeparator &&
+                        processedValue[2] !== "," /* MaskExpression.COMMA */ &&
+                        processedValue[2] !== "." /* MaskExpression.DOT */
+                        ? '-' + processedValue.slice(2, processedValue.length)
+                        : processedValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                            processedValue.length > 1 &&
+                            processedValue[1] !== this.thousandSeparator &&
+                            processedValue[1] !== "," /* MaskExpression.COMMA */ &&
+                            processedValue[1] !== "." /* MaskExpression.DOT */
+                            ? processedValue.slice(1, processedValue.length)
+                            : processedValue
+                    : processedValue.length > 1 &&
+                        processedValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                        processedValue[1] !== this.thousandSeparator &&
+                        processedValue[1] !== "," /* MaskExpression.COMMA */ &&
+                        processedValue[1] !== "." /* MaskExpression.DOT */
+                        ? processedValue.slice(1, processedValue.length)
+                        : processedValue;
+            }
+            else {
+                if (processedValue[0] === decimalMarker &&
+                    processedValue.length > 1 &&
+                    !backspaced) {
+                    processedValue =
+                        "0" /* MaskExpression.NUMBER_ZERO */ +
+                            processedValue.slice(0, processedValue.length + 1);
+                    this.plusOnePosition = true;
+                }
+                if (processedValue[0] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                    processedValue[1] !== decimalMarker &&
+                    processedValue[1] !== this.thousandSeparator &&
+                    !backspaced) {
+                    processedValue =
+                        processedValue.length > 1
+                            ? processedValue.slice(0, 1) +
+                                decimalMarker +
+                                processedValue.slice(1, processedValue.length + 1)
+                            : processedValue;
+                    this.plusOnePosition = true;
+                }
+                if (this.allowNegativeNumbers &&
+                    !backspaced &&
+                    processedValue[0] === "-" /* MaskExpression.MINUS */ &&
+                    (processedValue[1] === decimalMarker ||
+                        processedValue[1] === "0" /* MaskExpression.NUMBER_ZERO */)) {
+                    processedValue =
+                        processedValue[1] === decimalMarker && processedValue.length > 2
+                            ? processedValue.slice(0, 1) +
+                                "0" /* MaskExpression.NUMBER_ZERO */ +
+                                processedValue.slice(1, processedValue.length)
+                            : processedValue[1] === "0" /* MaskExpression.NUMBER_ZERO */ &&
+                                processedValue.length > 2 &&
+                                processedValue[2] !== decimalMarker
+                                ? processedValue.slice(0, 2) +
+                                    decimalMarker +
+                                    processedValue.slice(2, processedValue.length)
+                                : processedValue;
+                    this.plusOnePosition = true;
+                }
+            }
+            // TODO: we had different rexexps here for the different cases... but tests dont seam to bother - check this
+            //  separator: no COMMA, dot-sep: no SPACE, COMMA OK, comma-sep: no SPACE, COMMA OK
+            const thousandSeparatorCharEscaped = this._charToRegExpExpression(this.thousandSeparator);
+            let invalidChars = '@#!$%^&*()_+|~=`{}\\[\\]:\\s,\\.";<>?\\/'.replace(thousandSeparatorCharEscaped, '');
+            //.replace(decimalMarkerEscaped, '');
+            if (Array.isArray(this.decimalMarker)) {
+                for (const marker of this.decimalMarker) {
+                    invalidChars = invalidChars.replace(this._charToRegExpExpression(marker), "" /* MaskExpression.EMPTY_STRING */);
+                }
+            }
+            else {
+                invalidChars = invalidChars.replace(this._charToRegExpExpression(this.decimalMarker), '');
+            }
+            const invalidCharRegexp = new RegExp('[' + invalidChars + ']');
+            if (processedValue.match(invalidCharRegexp)) {
+                processedValue = processedValue.substring(0, processedValue.length - 1);
+            }
+            processedValue = this.checkInputPrecision(processedValue, precision, this.decimalMarker);
+            const strForSep = processedValue.replace(new RegExp(thousandSeparatorCharEscaped, 'g'), '');
+            result = this._formatWithSeparators(strForSep, this.thousandSeparator, this.decimalMarker, precision);
+            const commaShift = result.indexOf("," /* MaskExpression.COMMA */) - processedValue.indexOf("," /* MaskExpression.COMMA */);
+            const shiftStep = result.length - processedValue.length;
+            const backspacedDecimalMarkerWithSeparatorLimit = backspaced && result.length < inputValue.length && this.separatorLimit;
+            if ((result[processedPosition - 1] === this.thousandSeparator ||
+                result[processedPosition - this.prefix.length]) &&
+                this.prefix &&
+                backspaced) {
+                processedPosition = processedPosition - 1;
+            }
+            else if ((shiftStep > 0 && result[processedPosition] !== this.thousandSeparator) ||
+                backspacedDecimalMarkerWithSeparatorLimit) {
+                backspaceShift = true;
+                let _shift = 0;
+                do {
+                    this._shift.add(processedPosition + _shift);
+                    _shift++;
+                } while (_shift < shiftStep);
+            }
+            else if (result[processedPosition - 1] === this.thousandSeparator ||
+                shiftStep === -4 ||
+                shiftStep === -3 ||
+                result[processedPosition] === this.thousandSeparator) {
+                this._shift.clear();
+                this._shift.add(processedPosition - 1);
+            }
+            else if ((commaShift !== 0 &&
+                processedPosition > 0 &&
+                !(result.indexOf("," /* MaskExpression.COMMA */) >= processedPosition &&
+                    processedPosition > 3)) ||
+                (!(result.indexOf("." /* MaskExpression.DOT */) >= processedPosition && processedPosition > 3) &&
+                    shiftStep <= 0)) {
+                this._shift.clear();
+                backspaceShift = true;
+                shift = shiftStep;
+                processedPosition += shiftStep;
+                this._shift.add(processedPosition);
+            }
+            else {
+                this._shift.clear();
+            }
+        }
+        else {
+            for (
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            let i = 0, inputSymbol = inputArray[0]; i < inputArray.length; i++, inputSymbol = inputArray[i] ?? "" /* MaskExpression.EMPTY_STRING */) {
+                if (cursor === maskExpression.length) {
+                    break;
+                }
+                const symbolStarInPattern = "*" /* MaskExpression.SYMBOL_STAR */ in this.patterns;
+                if (this._checkSymbolMask(inputSymbol, maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */) &&
+                    maskExpression[cursor + 1] === "?" /* MaskExpression.SYMBOL_QUESTION */) {
+                    result += inputSymbol;
+                    cursor += 2;
+                }
+                else if (maskExpression[cursor + 1] === "*" /* MaskExpression.SYMBOL_STAR */ &&
+                    multi &&
+                    this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2] ?? "" /* MaskExpression.EMPTY_STRING */)) {
+                    result += inputSymbol;
+                    cursor += 3;
+                    multi = false;
+                }
+                else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */) &&
+                    maskExpression[cursor + 1] === "*" /* MaskExpression.SYMBOL_STAR */ &&
+                    !symbolStarInPattern) {
+                    result += inputSymbol;
+                    multi = true;
+                }
+                else if (maskExpression[cursor + 1] === "?" /* MaskExpression.SYMBOL_QUESTION */ &&
+                    this._checkSymbolMask(inputSymbol, maskExpression[cursor + 2] ?? "" /* MaskExpression.EMPTY_STRING */)) {
+                    result += inputSymbol;
+                    cursor += 3;
+                }
+                else if (this._checkSymbolMask(inputSymbol, maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */)) {
+                    if (maskExpression[cursor] === "H" /* MaskExpression.HOURS */) {
+                        if (this.apm ? Number(inputSymbol) > 9 : Number(inputSymbol) > 2) {
+                            processedPosition = !this.leadZeroDateTime
+                                ? processedPosition + 1
+                                : processedPosition;
+                            cursor += 1;
+                            this._shiftStep(cursor);
+                            i--;
+                            if (this.leadZeroDateTime) {
+                                result += '0';
+                            }
+                            continue;
+                        }
+                    }
+                    if (maskExpression[cursor] === "h" /* MaskExpression.HOUR */) {
+                        if (this.apm
+                            ? (result.length === 1 && Number(result) > 1) ||
+                                (result === '1' && Number(inputSymbol) > 2) ||
+                                (processedValue.slice(cursor - 1, cursor).length === 1 &&
+                                    Number(processedValue.slice(cursor - 1, cursor)) > 2) ||
+                                (processedValue.slice(cursor - 1, cursor) === '1' &&
+                                    Number(inputSymbol) > 2)
+                            : (result === '2' && Number(inputSymbol) > 3) ||
+                                ((result.slice(cursor - 2, cursor) === '2' ||
+                                    result.slice(cursor - 3, cursor) === '2' ||
+                                    result.slice(cursor - 4, cursor) === '2' ||
+                                    result.slice(cursor - 1, cursor) === '2') &&
+                                    Number(inputSymbol) > 3 &&
+                                    cursor > 10)) {
+                            processedPosition = processedPosition + 1;
+                            cursor += 1;
+                            i--;
+                            continue;
+                        }
+                    }
+                    if (maskExpression[cursor] === "m" /* MaskExpression.MINUTE */ ||
+                        maskExpression[cursor] === "s" /* MaskExpression.SECOND */) {
+                        if (Number(inputSymbol) > 5) {
+                            processedPosition = !this.leadZeroDateTime
+                                ? processedPosition + 1
+                                : processedPosition;
+                            cursor += 1;
+                            this._shiftStep(cursor);
+                            i--;
+                            if (this.leadZeroDateTime) {
+                                result += '0';
+                            }
+                            continue;
+                        }
+                    }
+                    const daysCount = 31;
+                    const inputValueCursor = processedValue[cursor];
+                    const inputValueCursorPlusOne = processedValue[cursor + 1];
+                    const inputValueCursorPlusTwo = processedValue[cursor + 2];
+                    const inputValueCursorMinusOne = processedValue[cursor - 1];
+                    const inputValueCursorMinusTwo = processedValue[cursor - 2];
+                    const inputValueSliceMinusThreeMinusOne = processedValue.slice(cursor - 3, cursor - 1);
+                    const inputValueSliceMinusOnePlusOne = processedValue.slice(cursor - 1, cursor + 1);
+                    const inputValueSliceCursorPlusTwo = processedValue.slice(cursor, cursor + 2);
+                    const inputValueSliceMinusTwoCursor = processedValue.slice(cursor - 2, cursor);
+                    if (maskExpression[cursor] === "d" /* MaskExpression.DAY */) {
+                        const maskStartWithMonth = maskExpression.slice(0, 2) === "M0" /* MaskExpression.MONTHS */;
+                        const startWithMonthInput = maskExpression.slice(0, 2) === "M0" /* MaskExpression.MONTHS */ &&
+                            this.specialCharacters.includes(inputValueCursorMinusTwo);
+                        if ((Number(inputSymbol) > 3 && this.leadZeroDateTime) ||
+                            (!maskStartWithMonth &&
+                                (Number(inputValueSliceCursorPlusTwo) > daysCount ||
+                                    Number(inputValueSliceMinusOnePlusOne) > daysCount ||
+                                    this.specialCharacters.includes(inputValueCursorPlusOne))) ||
+                            (startWithMonthInput
+                                ? Number(inputValueSliceMinusOnePlusOne) > daysCount ||
+                                    (!this.specialCharacters.includes(inputValueCursor) &&
+                                        this.specialCharacters.includes(inputValueCursorPlusTwo)) ||
+                                    this.specialCharacters.includes(inputValueCursor)
+                                : Number(inputValueSliceCursorPlusTwo) > daysCount ||
+                                    (this.specialCharacters.includes(inputValueCursorPlusOne) &&
+                                        !backspaced))) {
+                            processedPosition = !this.leadZeroDateTime
+                                ? processedPosition + 1
+                                : processedPosition;
+                            cursor += 1;
+                            this._shiftStep(cursor);
+                            i--;
+                            if (this.leadZeroDateTime) {
+                                result += '0';
+                            }
+                            continue;
+                        }
+                    }
+                    if (maskExpression[cursor] === "M" /* MaskExpression.MONTH */) {
+                        const monthsCount = 12;
+                        // mask without day
+                        const withoutDays = cursor === 0 &&
+                            (Number(inputSymbol) > 2 ||
+                                Number(inputValueSliceCursorPlusTwo) > monthsCount ||
+                                (this.specialCharacters.includes(inputValueCursorPlusOne) &&
+                                    !backspaced));
+                        // day<10 && month<12 for input
+                        const specialChart = maskExpression.slice(cursor + 2, cursor + 3);
+                        const day1monthInput = inputValueSliceMinusThreeMinusOne.includes(specialChart) &&
+                            maskExpression.includes('d0') &&
+                            ((this.specialCharacters.includes(inputValueCursorMinusTwo) &&
+                                Number(inputValueSliceMinusOnePlusOne) > monthsCount &&
+                                !this.specialCharacters.includes(inputValueCursor)) ||
+                                this.specialCharacters.includes(inputValueCursor));
+                        //  month<12 && day<10 for input
+                        const day2monthInput = Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&
+                            !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
+                            this.specialCharacters.includes(inputValueCursorMinusOne) &&
+                            (Number(inputValueSliceCursorPlusTwo) > monthsCount ||
+                                this.specialCharacters.includes(inputValueCursorPlusOne));
+                        // cursor === 5 && without days
+                        const day2monthInputDot = (Number(inputValueSliceCursorPlusTwo) > monthsCount && cursor === 5) ||
+                            (this.specialCharacters.includes(inputValueCursorPlusOne) &&
+                                cursor === 5);
+                        // // day<10 && month<12 for paste whole data
+                        const day1monthPaste = Number(inputValueSliceMinusThreeMinusOne) > daysCount &&
+                            !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
+                            !this.specialCharacters.includes(inputValueSliceMinusTwoCursor) &&
+                            Number(inputValueSliceMinusTwoCursor) > monthsCount &&
+                            maskExpression.includes('d0');
+                        // 10<day<31 && month<12 for paste whole data
+                        const day2monthPaste = Number(inputValueSliceMinusThreeMinusOne) <= daysCount &&
+                            !this.specialCharacters.includes(inputValueSliceMinusThreeMinusOne) &&
+                            !this.specialCharacters.includes(inputValueCursorMinusOne) &&
+                            Number(inputValueSliceMinusOnePlusOne) > monthsCount;
+                        if ((Number(inputSymbol) > 1 && this.leadZeroDateTime) ||
+                            withoutDays ||
+                            day1monthInput ||
+                            day2monthPaste ||
+                            day1monthPaste ||
+                            day2monthInput ||
+                            (day2monthInputDot && !this.leadZeroDateTime)) {
+                            processedPosition = !this.leadZeroDateTime
+                                ? processedPosition + 1
+                                : processedPosition;
+                            cursor += 1;
+                            this._shiftStep(cursor);
+                            i--;
+                            if (this.leadZeroDateTime) {
+                                result += '0';
+                            }
+                            continue;
+                        }
+                    }
+                    result += inputSymbol;
+                    cursor++;
+                }
+                else if (this.specialCharacters.includes(inputSymbol) &&
+                    maskExpression[cursor] === inputSymbol) {
+                    result += inputSymbol;
+                    cursor++;
+                }
+                else if (this.specialCharacters.indexOf(maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */) !== -1) {
+                    result += maskExpression[cursor];
+                    cursor++;
+                    this._shiftStep(cursor);
+                    i--;
+                }
+                else if (maskExpression[cursor] === "9" /* MaskExpression.NUMBER_NINE */ &&
+                    this.showMaskTyped) {
+                    this._shiftStep(cursor);
+                }
+                else if (this.patterns[maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */] &&
+                    this.patterns[maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */]?.optional) {
+                    if (!!inputArray[cursor] &&
+                        maskExpression !== '099.099.099.099' &&
+                        maskExpression !== '000.000.000-00' &&
+                        maskExpression !== '00.000.000/0000-00' &&
+                        !maskExpression.match(/^9+\.0+$/) &&
+                        !this.patterns[maskExpression[cursor] ?? "" /* MaskExpression.EMPTY_STRING */]
+                            ?.optional) {
+                        result += inputArray[cursor];
+                    }
+                    if (maskExpression.includes("9" /* MaskExpression.NUMBER_NINE */ + "*" /* MaskExpression.SYMBOL_STAR */) &&
+                        maskExpression.includes("0" /* MaskExpression.NUMBER_ZERO */ + "*" /* MaskExpression.SYMBOL_STAR */)) {
+                        cursor++;
+                    }
+                    cursor++;
+                    i--;
+                }
+                else if (this.maskExpression[cursor + 1] === "*" /* MaskExpression.SYMBOL_STAR */ &&
+                    this._findSpecialChar(this.maskExpression[cursor + 2] ?? "" /* MaskExpression.EMPTY_STRING */) &&
+                    this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&
+                    multi) {
+                    cursor += 3;
+                    result += inputSymbol;
+                }
+                else if (this.maskExpression[cursor + 1] === "?" /* MaskExpression.SYMBOL_QUESTION */ &&
+                    this._findSpecialChar(this.maskExpression[cursor + 2] ?? "" /* MaskExpression.EMPTY_STRING */) &&
+                    this._findSpecialChar(inputSymbol) === this.maskExpression[cursor + 2] &&
+                    multi) {
+                    cursor += 3;
+                    result += inputSymbol;
+                }
+                else if (this.showMaskTyped &&
+                    this.specialCharacters.indexOf(inputSymbol) < 0 &&
+                    inputSymbol !== this.placeHolderCharacter &&
+                    this.placeHolderCharacter.length === 1) {
+                    stepBack = true;
+                }
+            }
+        }
+        if (result[processedPosition - 1] &&
+            result.length + 1 === maskExpression.length &&
+            this.specialCharacters.indexOf(maskExpression[maskExpression.length - 1] ?? "" /* MaskExpression.EMPTY_STRING */) !== -1) {
+            result += maskExpression[maskExpression.length - 1];
+        }
+        let newPosition = processedPosition + 1;
+        while (this._shift.has(newPosition)) {
+            shift++;
+            newPosition++;
+        }
+        let actualShift = justPasted && !maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)
+            ? cursor
+            : this._shift.has(processedPosition)
+                ? shift
+                : 0;
+        if (stepBack) {
+            actualShift--;
+        }
+        cb(actualShift, backspaceShift);
+        if (shift < 0) {
+            this._shift.clear();
+        }
+        let onlySpecial = false;
+        if (backspaced) {
+            onlySpecial = inputArray.every((char) => this.specialCharacters.includes(char));
+        }
+        let res = `${this.prefix}${onlySpecial ? "" /* MaskExpression.EMPTY_STRING */ : result}${this.showMaskTyped ? '' : this.suffix}`;
+        if (result.length === 0) {
+            res = this.instantPrefix ? `${this.prefix}${result}` : `${result}`;
+        }
+        const isSpecialCharacterMaskFirstSymbol = processedValue.length === 1 &&
+            this.specialCharacters.includes(maskExpression[0]) &&
+            processedValue !== maskExpression[0];
+        if (!this._checkSymbolMask(processedValue, maskExpression[1]) &&
+            isSpecialCharacterMaskFirstSymbol) {
+            return '';
+        }
+        if (result.includes("-" /* MaskExpression.MINUS */) && this.prefix && this.allowNegativeNumbers) {
+            if (backspaced && result === "-" /* MaskExpression.MINUS */) {
+                return '';
+            }
+            res = `${"-" /* MaskExpression.MINUS */}${this.prefix}${result
+                .split("-" /* MaskExpression.MINUS */)
+                .join("" /* MaskExpression.EMPTY_STRING */)}${this.suffix}`;
+        }
+        return res;
+    }
+    _findDropSpecialChar(inputSymbol) {
+        if (Array.isArray(this.dropSpecialCharacters)) {
+            return this.dropSpecialCharacters.find((val) => val === inputSymbol);
+        }
+        return this._findSpecialChar(inputSymbol);
+    }
+    _findSpecialChar(inputSymbol) {
+        return this.specialCharacters.find((val) => val === inputSymbol);
+    }
+    _checkSymbolMask(inputSymbol, maskSymbol) {
+        this.patterns = this.customPattern ? this.customPattern : this.patterns;
+        return ((this.patterns?.[maskSymbol]?.pattern &&
+            this.patterns?.[maskSymbol]?.pattern.test(inputSymbol)) ??
+            false);
+    }
+    _stripToDecimal(str) {
+        return str
+            .split("" /* MaskExpression.EMPTY_STRING */)
+            .filter((i, idx) => {
+            const isDecimalMarker = typeof this.decimalMarker === 'string'
+                ? i === this.decimalMarker
+                : // TODO (inepipenko) use utility type
+                    this.decimalMarker.includes(i);
+            return (i.match('^-?\\d') ||
+                i === this.thousandSeparator ||
+                isDecimalMarker ||
+                (i === "-" /* MaskExpression.MINUS */ && idx === 0 && this.allowNegativeNumbers));
+        })
+            .join("" /* MaskExpression.EMPTY_STRING */);
+    }
+    _charToRegExpExpression(char) {
+        // if (Array.isArray(char)) {
+        // 	return char.map((v) => ('[\\^$.|?*+()'.indexOf(v) >= 0 ? `\\${v}` : v)).join('|');
+        // }
+        if (char) {
+            const charsToEscape = '[\\^$.|?*+()';
+            return char === ' ' ? '\\s' : charsToEscape.indexOf(char) >= 0 ? `\\${char}` : char;
+        }
+        return char;
+    }
+    _shiftStep(cursor) {
+        this._shift.add(cursor + this.prefix.length || 0);
+    }
+    _compareOrIncludes(value, comparedValue, excludedValue) {
+        return Array.isArray(comparedValue)
+            ? comparedValue.filter((v) => v !== excludedValue).includes(value)
+            : value === comparedValue;
+    }
+    _validIP(valuesIP) {
+        return !(valuesIP.length === 4 &&
+            !valuesIP.some((value, index) => {
+                if (valuesIP.length !== index + 1) {
+                    return value === "" /* MaskExpression.EMPTY_STRING */ || Number(value) > 255;
+                }
+                return value === "" /* MaskExpression.EMPTY_STRING */ || Number(value.substring(0, 3)) > 255;
+            }));
+    }
+    _splitPercentZero(value) {
+        if (value === "-" /* MaskExpression.MINUS */ && this.allowNegativeNumbers) {
+            return value;
+        }
+        const decimalIndex = typeof this.decimalMarker === 'string'
+            ? value.indexOf(this.decimalMarker)
+            : value.indexOf("." /* MaskExpression.DOT */);
+        const emptyOrMinus = this.allowNegativeNumbers && value.includes("-" /* MaskExpression.MINUS */) ? '-' : '';
+        if (decimalIndex === -1) {
+            const parsedValue = parseInt(emptyOrMinus ? value.slice(1, value.length) : value, 10);
+            return isNaN(parsedValue)
+                ? "" /* MaskExpression.EMPTY_STRING */
+                : `${emptyOrMinus}${parsedValue}`;
+        }
+        else {
+            const integerPart = parseInt(value.replace('-', '').substring(0, decimalIndex), 10);
+            const decimalPart = value.substring(decimalIndex + 1);
+            const integerString = isNaN(integerPart) ? '' : integerPart.toString();
+            const decimal = typeof this.decimalMarker === 'string' ? this.decimalMarker : "." /* MaskExpression.DOT */;
+            return integerString === "" /* MaskExpression.EMPTY_STRING */
+                ? "" /* MaskExpression.EMPTY_STRING */
+                : `${emptyOrMinus}${integerString}${decimal}${decimalPart}`;
+        }
+    }
+    _findFirstNonZeroAndDecimalIndex(inputString, decimalMarker) {
+        let decimalMarkerIndex = null;
+        let nonZeroIndex = null;
+        for (let i = 0; i < inputString.length; i++) {
+            const char = inputString[i];
+            if (char === decimalMarker && decimalMarkerIndex === null) {
+                decimalMarkerIndex = i;
+            }
+            if (char && char >= '1' && char <= '9' && nonZeroIndex === null) {
+                nonZeroIndex = i;
+            }
+            if (decimalMarkerIndex !== null && nonZeroIndex !== null) {
+                break;
+            }
+        }
+        return {
+            decimalMarkerIndex,
+            nonZeroIndex,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskApplierService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskApplierService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskApplierService, decorators: [{
+            type: Injectable
+        }] });
+
+class NgxMaskService extends NgxMaskApplierService {
+    constructor() {
+        super(...arguments);
+        this.isNumberValue = false;
+        this.maskIsShown = '';
+        this.selStart = null;
+        this.selEnd = null;
+        this.maskChanged = false;
+        this.maskExpressionArray = [];
+        this.previousValue = '';
+        this.currentValue = '';
+        /**
+         * Whether we are currently in writeValue function, in this case when applying the mask we don't want to trigger onChange function,
+         * since writeValue should be a one way only process of writing the DOM value based on the Angular model value.
+         */
+        this.writingValue = false;
+        this._emitValue = false;
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.onChange = (_) => { };
+        this._elementRef = inject(ElementRef, { optional: true });
+        this.document = inject(DOCUMENT);
+        this._config = inject(NGX_MASK_CONFIG);
+        this._renderer = inject(Renderer2, { optional: true });
+    }
+    /**
+     * Applies the mask to the input value.
+     * @param inputValue The input value to be masked.
+     * @param maskExpression The mask expression to apply.
+     * @param position The position in the input value.
+     * @param justPasted Whether the value was just pasted.
+     * @param backspaced Whether the value was backspaced.
+     * @param cb Callback function.
+     * @returns The masked value.
+     */
+    applyMask(inputValue, maskExpression, position = 0, justPasted = false, backspaced = false, 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    cb = () => { }) {
+        // If no mask expression, return the input value or the actual value
+        if (!maskExpression) {
+            return inputValue !== this.actualValue ? this.actualValue : inputValue;
+        }
+        // Show mask in input if required
+        this.maskIsShown = this.showMaskTyped
+            ? this.showMaskInInput()
+            : "" /* MaskExpression.EMPTY_STRING */;
+        // Handle specific mask expressions
+        if (this.maskExpression === "IP" /* MaskExpression.IP */ && this.showMaskTyped) {
+            this.maskIsShown = this.showMaskInInput(inputValue || "#" /* MaskExpression.HASH */);
+        }
+        if (this.maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */ && this.showMaskTyped) {
+            this.maskIsShown = this.showMaskInInput(inputValue || "#" /* MaskExpression.HASH */);
+        }
+        // Handle empty input value with mask typed
+        if (!inputValue && this.showMaskTyped) {
+            this.formControlResult(this.prefix);
+            return `${this.prefix}${this.maskIsShown}${this.suffix}`;
+        }
+        const getSymbol = !!inputValue && typeof this.selStart === 'number'
+            ? (inputValue[this.selStart] ?? "" /* MaskExpression.EMPTY_STRING */)
+            : "" /* MaskExpression.EMPTY_STRING */;
+        let newInputValue = '';
+        let newPosition = position;
+        // Handle hidden input or input with asterisk symbol
+        if ((this.hiddenInput ||
+            (inputValue && inputValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */) >= 0)) &&
+            !this.writingValue) {
+            let actualResult = inputValue && inputValue.length === 1
+                ? inputValue.split("" /* MaskExpression.EMPTY_STRING */)
+                : this.actualValue.split("" /* MaskExpression.EMPTY_STRING */);
+            // Handle backspace
+            if (backspaced) {
+                actualResult = actualResult
+                    .slice(0, position)
+                    .concat(actualResult.slice(position + 1));
+            }
+            // Remove mask if showMaskTyped is true
+            if (this.showMaskTyped) {
+                // eslint-disable-next-line no-param-reassign
+                inputValue = this.removeMask(inputValue);
+                actualResult = this.removeMask(actualResult.join('')).split("" /* MaskExpression.EMPTY_STRING */);
+            }
+            // Handle selection start and end
+            if (typeof this.selStart === 'object' && typeof this.selEnd === 'object') {
+                this.selStart = Number(this.selStart);
+                this.selEnd = Number(this.selEnd);
+            }
+            else {
+                if (inputValue !== "" /* MaskExpression.EMPTY_STRING */ && actualResult.length) {
+                    if (typeof this.selStart === 'number' && typeof this.selEnd === 'number') {
+                        if (inputValue.length > actualResult.length) {
+                            actualResult.splice(this.selStart, 0, getSymbol);
+                        }
+                        else if (inputValue.length < actualResult.length) {
+                            if (actualResult.length - inputValue.length === 1) {
+                                if (backspaced) {
+                                    actualResult.splice(this.selStart - 1, 1);
+                                }
+                                else {
+                                    actualResult.splice(inputValue.length - 1, 1);
+                                }
+                            }
+                            else {
+                                actualResult.splice(this.selStart, this.selEnd - this.selStart);
+                            }
+                        }
+                    }
+                }
+                else {
+                    actualResult = [];
+                }
+            }
+            // Remove mask if showMaskTyped is true and hiddenInput is false
+            if (this.showMaskTyped && !this.hiddenInput) {
+                newInputValue = this.removeMask(inputValue);
+            }
+            // Handle actual value length
+            if (this.actualValue.length) {
+                if (actualResult.length < inputValue.length) {
+                    newInputValue = this.shiftTypedSymbols(actualResult.join("" /* MaskExpression.EMPTY_STRING */));
+                }
+                else if (actualResult.length === inputValue.length) {
+                    newInputValue = actualResult.join("" /* MaskExpression.EMPTY_STRING */);
+                }
+                else {
+                    newInputValue = inputValue;
+                }
+            }
+            else {
+                newInputValue = inputValue;
+            }
+        }
+        // Handle just pasted input
+        if (justPasted && (this.hiddenInput || !this.hiddenInput)) {
+            newInputValue = inputValue;
+        }
+        // Handle backspace with special characters
+        if (backspaced &&
+            this.specialCharacters.indexOf(this.maskExpression[newPosition] ?? "" /* MaskExpression.EMPTY_STRING */) !== -1 &&
+            this.showMaskTyped &&
+            !this.prefix) {
+            newInputValue = this.currentValue;
+        }
+        // Handle deleted special character
+        if (this.deletedSpecialCharacter && newPosition) {
+            if (this.specialCharacters.includes(this.actualValue.slice(newPosition, newPosition + 1))) {
+                newPosition = newPosition + 1;
+            }
+            else if (maskExpression.slice(newPosition - 1, newPosition + 1) !== "M0" /* MaskExpression.MONTHS */) {
+                newPosition = newPosition - 2;
+            }
+            this.deletedSpecialCharacter = false;
+        }
+        // Remove mask if showMaskTyped is true and placeHolderCharacter length is 1
+        if (this.showMaskTyped &&
+            this.placeHolderCharacter.length === 1 &&
+            !this.leadZeroDateTime) {
+            newInputValue = this.removeMask(newInputValue);
+        }
+        // Handle mask changed
+        if (this.maskChanged) {
+            newInputValue = inputValue;
+        }
+        else {
+            newInputValue =
+                Boolean(newInputValue) && newInputValue.length ? newInputValue : inputValue;
+        }
+        // Handle showMaskTyped and keepCharacterPositions
+        if (this.showMaskTyped &&
+            this.keepCharacterPositions &&
+            this.actualValue &&
+            !justPasted &&
+            !this.writingValue) {
+            const value = this.dropSpecialCharacters
+                ? this.removeMask(this.actualValue)
+                : this.actualValue;
+            this.formControlResult(value);
+            return this.actualValue
+                ? this.actualValue
+                : `${this.prefix}${this.maskIsShown}${this.suffix}`;
+        }
+        // Apply the mask using the parent class method
+        const result = super.applyMask(newInputValue, maskExpression, newPosition, justPasted, backspaced, cb);
+        this.actualValue = this.getActualValue(result);
+        // handle some separator implications:
+        // a.) adjust decimalMarker default (. -> ,) if thousandSeparator is a dot
+        if (this.thousandSeparator === "." /* MaskExpression.DOT */ &&
+            this.decimalMarker === "." /* MaskExpression.DOT */) {
+            this.decimalMarker = "," /* MaskExpression.COMMA */;
+        }
+        // b) remove decimal marker from list of special characters to mask
+        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+            this.dropSpecialCharacters === true) {
+            this.specialCharacters = this.specialCharacters.filter((item) => !this._compareOrIncludes(item, this.decimalMarker, this.thousandSeparator) //item !== this.decimalMarker, // !
+            );
+        }
+        // Update previous and current values
+        if (result || result === '') {
+            this.previousValue = this.currentValue;
+            this.currentValue = result;
+            this._emitValue =
+                this.previousValue !== this.currentValue ||
+                    (newInputValue !== this.currentValue && this.writingValue) ||
+                    (this.previousValue === this.currentValue && justPasted);
+        }
+        // Propagate the input value back to the Angular model
+        // eslint-disable-next-line no-unused-expressions,@typescript-eslint/no-unused-expressions
+        this._emitValue ? this.formControlResult(result) : '';
+        // Handle hidden input and showMaskTyped
+        if (!this.showMaskTyped || (this.showMaskTyped && this.hiddenInput)) {
+            if (this.hiddenInput) {
+                return `${this.hideInput(result, this.maskExpression)}${this.maskIsShown.slice(result.length)}`;
+            }
+            return result;
+        }
+        const resLen = result.length;
+        const prefNmask = `${this.prefix}${this.maskIsShown}${this.suffix}`;
+        // Handle specific mask expressions
+        if (this.maskExpression.includes("H" /* MaskExpression.HOURS */)) {
+            const countSkipedSymbol = this._numberSkipedSymbols(result);
+            return `${result}${prefNmask.slice(resLen + countSkipedSymbol)}`;
+        }
+        else if (this.maskExpression === "IP" /* MaskExpression.IP */ ||
+            this.maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */) {
+            return `${result}${prefNmask}`;
+        }
+        return `${result}${prefNmask.slice(resLen)}`;
+    }
+    // get the number of characters that were shifted
+    _numberSkipedSymbols(value) {
+        const regex = /(^|\D)(\d\D)/g;
+        let match = regex.exec(value);
+        let countSkipedSymbol = 0;
+        while (match != null) {
+            countSkipedSymbol += 1;
+            match = regex.exec(value);
+        }
+        return countSkipedSymbol;
+    }
+    applyValueChanges(position, justPasted, backspaced, 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    cb = () => { }) {
+        const formElement = this._elementRef?.nativeElement;
+        if (!formElement) {
+            return;
+        }
+        formElement.value = this.applyMask(formElement.value, this.maskExpression, position, justPasted, backspaced, cb);
+        if (formElement === this._getActiveElement()) {
+            return;
+        }
+        this.clearIfNotMatchFn();
+    }
+    hideInput(inputValue, maskExpression) {
+        return inputValue
+            .split("" /* MaskExpression.EMPTY_STRING */)
+            .map((curr, index) => {
+            if (this.patterns &&
+                this.patterns[maskExpression[index] ?? "" /* MaskExpression.EMPTY_STRING */] &&
+                this.patterns[maskExpression[index] ?? "" /* MaskExpression.EMPTY_STRING */]?.symbol) {
+                return this.patterns[maskExpression[index] ?? "" /* MaskExpression.EMPTY_STRING */]
+                    ?.symbol;
+            }
+            return curr;
+        })
+            .join("" /* MaskExpression.EMPTY_STRING */);
+    }
+    // this function is not necessary, it checks result against maskExpression
+    getActualValue(res) {
+        const compare = res
+            .split("" /* MaskExpression.EMPTY_STRING */)
+            .filter((symbol, i) => {
+            const maskChar = this.maskExpression[i] ?? "" /* MaskExpression.EMPTY_STRING */;
+            return (this._checkSymbolMask(symbol, maskChar) ||
+                (this.specialCharacters.includes(maskChar) && symbol === maskChar));
+        });
+        if (compare.join("" /* MaskExpression.EMPTY_STRING */) === res) {
+            return compare.join("" /* MaskExpression.EMPTY_STRING */);
+        }
+        return res;
+    }
+    shiftTypedSymbols(inputValue) {
+        let symbolToReplace = '';
+        const newInputValue = (inputValue &&
+            inputValue
+                .split("" /* MaskExpression.EMPTY_STRING */)
+                .map((currSymbol, index) => {
+                if (this.specialCharacters.includes(inputValue[index + 1] ?? "" /* MaskExpression.EMPTY_STRING */) &&
+                    inputValue[index + 1] !== this.maskExpression[index + 1]) {
+                    symbolToReplace = currSymbol;
+                    return inputValue[index + 1];
+                }
+                if (symbolToReplace.length) {
+                    const replaceSymbol = symbolToReplace;
+                    symbolToReplace = "" /* MaskExpression.EMPTY_STRING */;
+                    return replaceSymbol;
+                }
+                return currSymbol;
+            })) ||
+            [];
+        return newInputValue.join("" /* MaskExpression.EMPTY_STRING */);
+    }
+    /**
+     * Convert number value to string
+     * 3.1415 -> '3.1415'
+     * 1e-7 -> '0.0000001'
+     */
+    numberToString(value) {
+        if ((!value && value !== 0) ||
+            (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+                (this.leadZero || !this.dropSpecialCharacters)) ||
+            (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+                this.separatorLimit.length > 14 &&
+                String(value).length > 14)) {
+            return String(value);
+        }
+        return Number(value)
+            .toLocaleString('fullwide', {
+            useGrouping: false,
+            maximumFractionDigits: 20,
+        })
+            .replace(`/${"-" /* MaskExpression.MINUS */}/`, "-" /* MaskExpression.MINUS */);
+    }
+    showMaskInInput(inputVal) {
+        if (this.showMaskTyped && !!this.shownMaskExpression) {
+            if (this.maskExpression.length !== this.shownMaskExpression.length) {
+                throw new Error('Mask expression must match mask placeholder length');
+            }
+            else {
+                return this.shownMaskExpression;
+            }
+        }
+        else if (this.showMaskTyped) {
+            if (inputVal) {
+                if (this.maskExpression === "IP" /* MaskExpression.IP */) {
+                    return this._checkForIp(inputVal);
+                }
+                if (this.maskExpression === "CPF_CNPJ" /* MaskExpression.CPF_CNPJ */) {
+                    return this._checkForCpfCnpj(inputVal);
+                }
+            }
+            if (this.placeHolderCharacter.length === this.maskExpression.length) {
+                return this.placeHolderCharacter;
+            }
+            return this.maskExpression.replace(/\w/g, this.placeHolderCharacter);
+        }
+        return '';
+    }
+    clearIfNotMatchFn() {
+        const formElement = this._elementRef?.nativeElement;
+        if (!formElement) {
+            return;
+        }
+        if (this.clearIfNotMatch &&
+            this.prefix.length + this.maskExpression.length + this.suffix.length !==
+                formElement.value.replace(this.placeHolderCharacter, "" /* MaskExpression.EMPTY_STRING */)
+                    .length) {
+            this.formElementProperty = ['value', "" /* MaskExpression.EMPTY_STRING */];
+            this.applyMask('', this.maskExpression);
+        }
+    }
+    set formElementProperty([name, value]) {
+        if (!this._renderer || !this._elementRef) {
+            return;
+        }
+        //[TODO]: andriikamaldinov1 find better solution
+        Promise.resolve().then(() => this._renderer?.setProperty(this._elementRef?.nativeElement, name, value));
+    }
+    checkDropSpecialCharAmount(mask) {
+        const chars = mask
+            .split("" /* MaskExpression.EMPTY_STRING */)
+            .filter((item) => this._findDropSpecialChar(item));
+        return chars.length;
+    }
+    removeMask(inputValue) {
+        return this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.specialCharacters.concat('_').concat(this.placeHolderCharacter));
+    }
+    _checkForIp(inputVal) {
+        if (inputVal === "#" /* MaskExpression.HASH */) {
+            return `${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}`;
+        }
+        const arr = [];
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let i = 0; i < inputVal.length; i++) {
+            const value = inputVal[i] ?? "" /* MaskExpression.EMPTY_STRING */;
+            if (!value) {
+                continue;
+            }
+            if (value.match('\\d')) {
+                arr.push(value);
+            }
+        }
+        if (arr.length <= 3) {
+            return `${this.placeHolderCharacter}.${this.placeHolderCharacter}.${this.placeHolderCharacter}`;
+        }
+        if (arr.length > 3 && arr.length <= 6) {
+            return `${this.placeHolderCharacter}.${this.placeHolderCharacter}`;
+        }
+        if (arr.length > 6 && arr.length <= 9) {
+            return this.placeHolderCharacter;
+        }
+        if (arr.length > 9 && arr.length <= 12) {
+            return '';
+        }
+        return '';
+    }
+    _checkForCpfCnpj(inputVal) {
+        const cpf = `${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
+            `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
+            `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
+            `-${this.placeHolderCharacter}${this.placeHolderCharacter}`;
+        const cnpj = `${this.placeHolderCharacter}${this.placeHolderCharacter}` +
+            `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
+            `.${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
+            `/${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}${this.placeHolderCharacter}` +
+            `-${this.placeHolderCharacter}${this.placeHolderCharacter}`;
+        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;
+            }
+            if (value.match('\\d')) {
+                arr.push(value);
+            }
+        }
+        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 '';
+        }
+        if (arr.length === 12) {
+            if (inputVal.length === 17) {
+                return cnpj.slice(16, cnpj.length);
+            }
+            return cnpj.slice(15, cnpj.length);
+        }
+        if (arr.length > 12 && arr.length <= 14) {
+            return cnpj.slice(arr.length + 4, cnpj.length);
+        }
+        return '';
+    }
+    /**
+     * Recursively determine the current active element by navigating the Shadow DOM until the Active Element is found.
+     */
+    _getActiveElement(document = this.document) {
+        const shadowRootEl = document?.activeElement?.shadowRoot;
+        if (!shadowRootEl?.activeElement) {
+            return document.activeElement;
+        }
+        else {
+            return this._getActiveElement(shadowRootEl);
+        }
+    }
+    /**
+     * Propogates the input value back to the Angular model by triggering the onChange function. It won't do this if writingValue
+     * is true. If that is true it means we are currently in the writeValue function, which is supposed to only update the actual
+     * DOM element based on the Angular model value. It should be a one way process, i.e. writeValue should not be modifying the Angular
+     * model value too. Therefore, we don't trigger onChange in this scenario.
+     * @param inputValue the current form input value
+     */
+    formControlResult(inputValue) {
+        const outputTransformFn = this.outputTransformFn
+            ? this.outputTransformFn
+            : (v) => v;
+        this.writingValue = false;
+        this.maskChanged = false;
+        if (Array.isArray(this.dropSpecialCharacters)) {
+            this.onChange(outputTransformFn(this._toNumber(this._checkSymbols(this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.dropSpecialCharacters)))));
+        }
+        else if (this.dropSpecialCharacters ||
+            (!this.dropSpecialCharacters && this.prefix === inputValue)) {
+            this.onChange(outputTransformFn(this._toNumber(this._checkSymbols(this._removeSuffix(this._removePrefix(inputValue))))));
+        }
+        else {
+            this.onChange(outputTransformFn(this._toNumber(inputValue)));
+        }
+    }
+    _toNumber(value) {
+        if (!this.isNumberValue || value === "" /* MaskExpression.EMPTY_STRING */) {
+            return value;
+        }
+        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) &&
+            (this.leadZero || !this.dropSpecialCharacters)) {
+            return value;
+        }
+        if (String(value).length > 14 && this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+            return String(value);
+        }
+        const num = Number(value);
+        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) && Number.isNaN(num)) {
+            const val = String(value).replace(',', '.');
+            return Number(val);
+        }
+        return Number.isNaN(num) ? value : num;
+    }
+    _removeMask(value, specialCharactersForRemove) {
+        if (this.maskExpression.startsWith("percent" /* MaskExpression.PERCENT */) &&
+            value.includes("." /* MaskExpression.DOT */)) {
+            return value;
+        }
+        return value
+            ? value.replace(this._regExpForRemove(specialCharactersForRemove), "" /* MaskExpression.EMPTY_STRING */)
+            : value;
+    }
+    _removePrefix(value) {
+        if (!this.prefix) {
+            return value;
+        }
+        return value ? value.replace(this.prefix, "" /* MaskExpression.EMPTY_STRING */) : value;
+    }
+    _removeSuffix(value) {
+        if (!this.suffix) {
+            return value;
+        }
+        return value ? value.replace(this.suffix, "" /* MaskExpression.EMPTY_STRING */) : value;
+    }
+    _retrieveSeparatorValue(result) {
+        let specialCharacters = Array.isArray(this.dropSpecialCharacters)
+            ? this.specialCharacters.filter((v) => {
+                return this.dropSpecialCharacters.includes(v);
+            })
+            : this.specialCharacters;
+        if (!this.deletedSpecialCharacter &&
+            this._checkPatternForSpace() &&
+            result.includes(" " /* MaskExpression.WHITE_SPACE */) &&
+            this.maskExpression.includes("*" /* MaskExpression.SYMBOL_STAR */)) {
+            specialCharacters = specialCharacters.filter((char) => char !== " " /* MaskExpression.WHITE_SPACE */);
+        }
+        return this._removeMask(result, specialCharacters);
+    }
+    _regExpForRemove(specialCharactersForRemove) {
+        return new RegExp(specialCharactersForRemove.map((item) => `\\${item}`).join('|'), 'gi');
+    }
+    _replaceDecimalMarkerToDot(value) {
+        const markers = Array.isArray(this.decimalMarker)
+            ? this.decimalMarker
+            : [this.decimalMarker];
+        return value.replace(this._regExpForRemove(markers), "." /* MaskExpression.DOT */);
+    }
+    _checkSymbols(result) {
+        let processedResult = result;
+        if (processedResult === "" /* MaskExpression.EMPTY_STRING */) {
+            return processedResult;
+        }
+        if (this.maskExpression.startsWith("percent" /* MaskExpression.PERCENT */) &&
+            this.decimalMarker === "," /* MaskExpression.COMMA */) {
+            processedResult = processedResult.replace("," /* MaskExpression.COMMA */, "." /* MaskExpression.DOT */);
+        }
+        const separatorPrecision = this._retrieveSeparatorPrecision(this.maskExpression);
+        const separatorValue = this.specialCharacters.length === 0
+            ? this._retrieveSeparatorValue(processedResult)
+            : this._replaceDecimalMarkerToDot(this._retrieveSeparatorValue(processedResult));
+        if (!this.isNumberValue) {
+            return separatorValue;
+        }
+        if (separatorPrecision) {
+            if (processedResult === this.decimalMarker) {
+                return null;
+            }
+            if (separatorValue.length > 14) {
+                return String(separatorValue);
+            }
+            return this._checkPrecision(this.maskExpression, separatorValue);
+        }
+        else {
+            return separatorValue;
+        }
+    }
+    _checkPatternForSpace() {
+        for (const key in this.patterns) {
+            // eslint-disable-next-line no-prototype-builtins
+            if (this.patterns[key] && this.patterns[key]?.hasOwnProperty('pattern')) {
+                const patternString = this.patterns[key]?.pattern.toString();
+                const pattern = this.patterns[key]?.pattern;
+                if (patternString?.includes(" " /* MaskExpression.WHITE_SPACE */) &&
+                    pattern?.test(this.maskExpression)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    // TODO should think about helpers or separting decimal precision to own property
+    _retrieveSeparatorPrecision(maskExpretion) {
+        const matcher = maskExpretion.match(new RegExp(`^separator\\.([^d]*)`));
+        return matcher ? Number(matcher[1]) : null;
+    }
+    _checkPrecision(separatorExpression, separatorValue) {
+        const separatorPrecision = this.getPrecision(separatorExpression);
+        let value = separatorValue;
+        if (separatorExpression.indexOf('2') > 0 ||
+            (this.leadZero && Number(separatorPrecision) > 0)) {
+            if (this.decimalMarker === "," /* MaskExpression.COMMA */ && this.leadZero) {
+                value = value.replace(',', '.');
+            }
+            return this.leadZero
+                ? Number(value).toFixed(Number(separatorPrecision))
+                : Number(value).toFixed(2);
+        }
+        return this.numberToString(value);
+    }
+    _repeatPatternSymbols(maskExp) {
+        return ((maskExp.match(/{[0-9]+}/) &&
+            maskExp
+                .split("" /* MaskExpression.EMPTY_STRING */)
+                .reduce((accum, currVal, index) => {
+                this._start =
+                    currVal === "{" /* MaskExpression.CURLY_BRACKETS_LEFT */ ? index : this._start;
+                if (currVal !== "}" /* MaskExpression.CURLY_BRACKETS_RIGHT */) {
+                    return this._findSpecialChar(currVal) ? accum + currVal : accum;
+                }
+                this._end = index;
+                const repeatNumber = Number(maskExp.slice(this._start + 1, this._end));
+                const replaceWith = new Array(repeatNumber + 1).join(maskExp[this._start - 1]);
+                if (maskExp.slice(0, this._start).length > 1 &&
+                    maskExp.includes("S" /* MaskExpression.LETTER_S */)) {
+                    const symbols = maskExp.slice(0, this._start - 1);
+                    return symbols.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)
+                        ? accum + replaceWith
+                        : symbols + accum + replaceWith;
+                }
+                else {
+                    return accum + replaceWith;
+                }
+            }, '')) ||
+            maskExp);
+    }
+    currentLocaleDecimalMarker() {
+        return (1.1).toLocaleString().substring(1, 2);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskService, decorators: [{
+            type: Injectable
+        }] });
+
+class NgxMaskDirective {
+    constructor() {
+        this.mask = input('');
+        this.specialCharacters = input([]);
+        this.patterns = input({});
+        this.prefix = input('');
+        this.suffix = input('');
+        this.thousandSeparator = input(' ');
+        this.decimalMarker = input('.');
+        this.dropSpecialCharacters = input(null);
+        this.hiddenInput = input(null);
+        this.showMaskTyped = input(null);
+        this.placeHolderCharacter = input(null);
+        this.shownMaskExpression = input(null);
+        this.clearIfNotMatch = input(null);
+        this.validation = input(null);
+        this.separatorLimit = input('');
+        this.allowNegativeNumbers = input(null);
+        this.leadZeroDateTime = input(null);
+        this.leadZero = input(null);
+        this.triggerOnMaskChange = input(null);
+        this.apm = input(null);
+        this.inputTransformFn = input(null);
+        this.outputTransformFn = input(null);
+        this.keepCharacterPositions = input(null);
+        this.instantPrefix = input(null);
+        this.maskFilled = output();
+        this._maskValue = signal('');
+        this._inputValue = signal('');
+        this._position = signal(null);
+        this._code = signal('');
+        this._maskExpressionArray = signal([]);
+        this._justPasted = signal(false);
+        this._isFocused = signal(false);
+        /**For IME composition event */
+        this._isComposing = signal(false);
+        this._maskService = inject(NgxMaskService, { self: true });
+        this.document = inject(DOCUMENT);
+        this._config = inject(NGX_MASK_CONFIG);
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.onChange = (_) => { };
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.onTouch = () => { };
+    }
+    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) {
+            if (mask.currentValue !== mask.previousValue && !mask.firstChange) {
+                this._maskService.maskChanged = true;
+            }
+            if (mask.currentValue && mask.currentValue.split("||" /* MaskExpression.OR */).length > 1) {
+                this._maskExpressionArray.set(mask.currentValue.split("||" /* MaskExpression.OR */).sort((a, b) => {
+                    return a.length - b.length;
+                }));
+                this._setMask();
+            }
+            else {
+                this._maskExpressionArray.set([]);
+                this._maskValue.set(mask.currentValue || "" /* MaskExpression.EMPTY_STRING */);
+                this._maskService.maskExpression = this._maskValue();
+            }
+        }
+        if (specialCharacters) {
+            if (!specialCharacters.currentValue || !Array.isArray(specialCharacters.currentValue)) {
+                return;
+            }
+            else {
+                this._maskService.specialCharacters = specialCharacters.currentValue || [];
+            }
+        }
+        if (allowNegativeNumbers) {
+            this._maskService.allowNegativeNumbers = allowNegativeNumbers.currentValue;
+            if (this._maskService.allowNegativeNumbers) {
+                this._maskService.specialCharacters = this._maskService.specialCharacters.filter((c) => c !== "-" /* MaskExpression.MINUS */);
+            }
+        }
+        // Only overwrite the mask available patterns if a pattern has actually been passed in
+        if (patterns && patterns.currentValue) {
+            this._maskService.patterns = patterns.currentValue;
+        }
+        if (apm && apm.currentValue) {
+            this._maskService.apm = apm.currentValue;
+        }
+        if (instantPrefix) {
+            this._maskService.instantPrefix = instantPrefix.currentValue;
+        }
+        if (prefix) {
+            this._maskService.prefix = prefix.currentValue;
+        }
+        if (suffix) {
+            this._maskService.suffix = suffix.currentValue;
+        }
+        if (thousandSeparator) {
+            this._maskService.thousandSeparator = thousandSeparator.currentValue;
+            if (thousandSeparator.previousValue && thousandSeparator.currentValue) {
+                const previousDecimalMarker = this._maskService.decimalMarker;
+                if (thousandSeparator.currentValue === this._maskService.decimalMarker) {
+                    this._maskService.decimalMarker =
+                        thousandSeparator.currentValue === "," /* MaskExpression.COMMA */
+                            ? "." /* MaskExpression.DOT */
+                            : "," /* MaskExpression.COMMA */;
+                }
+                if (this._maskService.dropSpecialCharacters === true) {
+                    this._maskService.specialCharacters = this._config.specialCharacters;
+                }
+                if (typeof previousDecimalMarker === 'string' &&
+                    typeof this._maskService.decimalMarker === 'string') {
+                    this._inputValue.set(this._inputValue()
+                        .split(thousandSeparator.previousValue)
+                        .join('')
+                        .replace(previousDecimalMarker, this._maskService.decimalMarker));
+                    this._maskService.actualValue = this._inputValue();
+                }
+                this._maskService.writingValue = true;
+            }
+        }
+        if (decimalMarker) {
+            this._maskService.decimalMarker = decimalMarker.currentValue;
+        }
+        if (dropSpecialCharacters) {
+            this._maskService.dropSpecialCharacters = dropSpecialCharacters.currentValue;
+        }
+        if (hiddenInput) {
+            this._maskService.hiddenInput = hiddenInput.currentValue;
+            if (hiddenInput.previousValue === true && hiddenInput.currentValue === false) {
+                this._inputValue.set(this._maskService.actualValue);
+            }
+        }
+        if (showMaskTyped) {
+            this._maskService.showMaskTyped = showMaskTyped.currentValue;
+            if (showMaskTyped.previousValue === false &&
+                showMaskTyped.currentValue === true &&
+                this._isFocused()) {
+                requestAnimationFrame(() => {
+                    this._maskService._elementRef?.nativeElement.click();
+                });
+            }
+        }
+        if (placeHolderCharacter) {
+            this._maskService.placeHolderCharacter = placeHolderCharacter.currentValue;
+        }
+        if (shownMaskExpression) {
+            this._maskService.shownMaskExpression = shownMaskExpression.currentValue;
+        }
+        if (clearIfNotMatch) {
+            this._maskService.clearIfNotMatch = clearIfNotMatch.currentValue;
+        }
+        if (validation) {
+            this._maskService.validation = validation.currentValue;
+        }
+        if (separatorLimit) {
+            this._maskService.separatorLimit = separatorLimit.currentValue;
+        }
+        if (leadZeroDateTime) {
+            this._maskService.leadZeroDateTime = leadZeroDateTime.currentValue;
+        }
+        if (leadZero) {
+            this._maskService.leadZero = leadZero.currentValue;
+        }
+        if (triggerOnMaskChange) {
+            this._maskService.triggerOnMaskChange = triggerOnMaskChange.currentValue;
+        }
+        if (inputTransformFn) {
+            this._maskService.inputTransformFn = inputTransformFn.currentValue;
+        }
+        if (outputTransformFn) {
+            this._maskService.outputTransformFn = outputTransformFn.currentValue;
+        }
+        if (keepCharacterPositions) {
+            this._maskService.keepCharacterPositions = keepCharacterPositions.currentValue;
+        }
+        this._applyMask();
+    }
+    validate({ value }) {
+        const processedValue = typeof value === 'number' ? String(value) : value;
+        const maskValue = this._maskValue();
+        if (!this._maskService.validation || !maskValue) {
+            return null;
+        }
+        if (this._maskService.ipError) {
+            return this._createValidationError(processedValue);
+        }
+        if (this._maskService.cpfCnpjError) {
+            return this._createValidationError(processedValue);
+        }
+        if (maskValue.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+            return null;
+        }
+        if (withoutValidation.includes(maskValue)) {
+            return null;
+        }
+        if (this._maskService.clearIfNotMatch) {
+            return null;
+        }
+        if (timeMasks.includes(maskValue)) {
+            return this._validateTime(processedValue);
+        }
+        if (maskValue === "A*@A*.A*" /* MaskExpression.EMAIL_MASK */) {
+            const emailPattern = /^[^@]+@[^@]+\.[^@]+$/;
+            if (!emailPattern.test(processedValue) && processedValue) {
+                return this._createValidationError(processedValue);
+            }
+            else {
+                return null;
+            }
+        }
+        if (processedValue && processedValue.length >= 1) {
+            let counterOfOpt = 0;
+            if (maskValue.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */) &&
+                maskValue.includes("}" /* MaskExpression.CURLY_BRACKETS_RIGHT */)) {
+                const lengthInsideCurlyBrackets = maskValue.slice(maskValue.indexOf("{" /* MaskExpression.CURLY_BRACKETS_LEFT */) + 1, maskValue.indexOf("}" /* MaskExpression.CURLY_BRACKETS_RIGHT */));
+                return lengthInsideCurlyBrackets === String(processedValue.length)
+                    ? null
+                    : this._createValidationError(processedValue);
+            }
+            if (maskValue.startsWith("percent" /* MaskExpression.PERCENT */)) {
+                return null;
+            }
+            for (const key in this._maskService.patterns) {
+                if (this._maskService.patterns[key]?.optional) {
+                    if (maskValue.indexOf(key) !== maskValue.lastIndexOf(key)) {
+                        const opt = maskValue
+                            .split("" /* MaskExpression.EMPTY_STRING */)
+                            .filter((i) => i === key)
+                            .join("" /* MaskExpression.EMPTY_STRING */);
+                        counterOfOpt += opt.length;
+                    }
+                    else if (maskValue.indexOf(key) !== -1) {
+                        counterOfOpt++;
+                    }
+                    if (maskValue.indexOf(key) !== -1 &&
+                        processedValue.length >= maskValue.indexOf(key)) {
+                        return null;
+                    }
+                    if (counterOfOpt === maskValue.length) {
+                        return null;
+                    }
+                }
+            }
+            if ((maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */) > 1 &&
+                processedValue.length < maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */)) ||
+                (maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */) > 1 &&
+                    processedValue.length < maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */))) {
+                return this._createValidationError(processedValue);
+            }
+            if (maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */) === -1 ||
+                maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */) === -1) {
+                const array = maskValue.split('*');
+                const length = this._maskService.dropSpecialCharacters
+                    ? maskValue.length -
+                        this._maskService.checkDropSpecialCharAmount(maskValue) -
+                        counterOfOpt
+                    : this.prefix()
+                        ? maskValue.length + this.prefix().length - counterOfOpt
+                        : maskValue.length - counterOfOpt;
+                if (array.length === 1) {
+                    if (processedValue.length < length) {
+                        return this._createValidationError(processedValue);
+                    }
+                }
+                if (array.length > 1) {
+                    const lastIndexArray = array[array.length - 1];
+                    if (lastIndexArray &&
+                        this._maskService.specialCharacters.includes(lastIndexArray[0]) &&
+                        String(processedValue).includes(lastIndexArray[0] ?? '') &&
+                        !this.dropSpecialCharacters()) {
+                        const special = value.split(lastIndexArray[0]);
+                        return special[special.length - 1].length === lastIndexArray.length - 1
+                            ? null
+                            : this._createValidationError(processedValue);
+                    }
+                    else if (((lastIndexArray &&
+                        !this._maskService.specialCharacters.includes(lastIndexArray[0])) ||
+                        !lastIndexArray ||
+                        this._maskService.dropSpecialCharacters) &&
+                        processedValue.length >= length - 1) {
+                        return null;
+                    }
+                    else {
+                        return this._createValidationError(processedValue);
+                    }
+                }
+            }
+            if (maskValue.indexOf("*" /* MaskExpression.SYMBOL_STAR */) === 1 ||
+                maskValue.indexOf("?" /* MaskExpression.SYMBOL_QUESTION */) === 1) {
+                return null;
+            }
+        }
+        if (value) {
+            this.maskFilled.emit();
+            return null;
+        }
+        return null;
+    }
+    onPaste() {
+        this._justPasted.set(true);
+    }
+    onFocus() {
+        this._isFocused.set(true);
+    }
+    onModelChange(value) {
+        // on form reset we need to update the actualValue
+        if ((value === "" /* MaskExpression.EMPTY_STRING */ ||
+            value === null ||
+            typeof value === 'undefined') &&
+            this._maskService.actualValue) {
+            this._maskService.actualValue = this._maskService.getActualValue("" /* MaskExpression.EMPTY_STRING */);
+        }
+    }
+    onInput(e) {
+        // If IME is composing text, we wait for the composed text.
+        if (this._isComposing()) {
+            return;
+        }
+        const el = e.target;
+        const transformedValue = this._maskService.inputTransformFn
+            ? this._maskService.inputTransformFn(el.value)
+            : el.value;
+        if (el.type !== 'number') {
+            if (typeof transformedValue === 'string' || typeof transformedValue === 'number') {
+                el.value = transformedValue.toString();
+                this._inputValue.set(el.value);
+                this._setMask();
+                if (!this._maskValue()) {
+                    this.onChange(el.value);
+                    return;
+                }
+                let position = el.selectionStart === 1
+                    ? el.selectionStart + this._maskService.prefix.length
+                    : el.selectionStart;
+                if (this.showMaskTyped() &&
+                    this.keepCharacterPositions() &&
+                    this._maskService.placeHolderCharacter.length === 1) {
+                    const 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 backspaceOrDelete = this._code() === "Backspace" /* MaskExpression.BACKSPACE */ ||
+                        this._code() === "Delete" /* MaskExpression.DELETE */;
+                    if (backspaceOrDelete) {
+                        if (!selectRangeBackspace) {
+                            if (this._maskService.selStart === prefixLength) {
+                                this._maskService.actualValue = `${prefix}${this._maskService.maskIsShown.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)}`;
+                            }
+                            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}`;
+                            }
+                        }
+                        else if (!this._maskService.specialCharacters.includes(this._maskService.maskExpression.slice(position - prefixLength, position + 1 - prefixLength)) &&
+                            selectRangeBackspace) {
+                            if (selStart === 1 && prefix) {
+                                this._maskService.actualValue = `${prefix}${this._maskService.placeHolderCharacter}${el.value
+                                    .split(prefix)
+                                    .join('')
+                                    .split(suffix)
+                                    .join('')}${suffix}`;
+                                position = position - 1;
+                            }
+                            else {
+                                const part1 = el.value.substring(0, position);
+                                const part2 = el.value.substring(position);
+                                this._maskService.actualValue = `${part1}${this._maskService.placeHolderCharacter}${part2}`;
+                            }
+                        }
+                        position = this._code() === "Delete" /* 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 (checkSymbols) {
+                            if (el.value.length === 1 && position === 1) {
+                                this._maskService.actualValue = `${prefix}${inputSymbol}${this._maskService.maskIsShown.slice(1, this._maskService.maskIsShown.length)}${suffix}`;
+                            }
+                            else {
+                                this._maskService.actualValue = `${el.value.slice(0, position - 1)}${inputSymbol}${el.value
+                                    .slice(position + 1)
+                                    .split(suffix)
+                                    .join('')}${suffix}`;
+                            }
+                        }
+                        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}`;
+                        }
+                    }
+                }
+                let caretShift = 0;
+                let backspaceShift = false;
+                if (this._code() === "Delete" /* MaskExpression.DELETE */ && "separator" /* MaskExpression.SEPARATOR */) {
+                    this._maskService.deletedSpecialCharacter = true;
+                }
+                if (this._inputValue().length >= this._maskService.maskExpression.length - 1 &&
+                    this._code() !== "Backspace" /* MaskExpression.BACKSPACE */ &&
+                    this._maskService.maskExpression === "d0/M0/0000" /* MaskExpression.DAYS_MONTHS_YEARS */ &&
+                    position < 10) {
+                    const inputSymbol = this._inputValue().slice(position - 1, position);
+                    el.value =
+                        this._inputValue().slice(0, position - 1) +
+                            inputSymbol +
+                            this._inputValue().slice(position + 1);
+                }
+                if (this._maskService.maskExpression === "d0/M0/0000" /* MaskExpression.DAYS_MONTHS_YEARS */ &&
+                    this.leadZeroDateTime()) {
+                    if ((position < 3 && Number(el.value) > 31 && Number(el.value) < 40) ||
+                        (position === 5 && Number(el.value.slice(3, 5)) > 12)) {
+                        position = position + 2;
+                    }
+                }
+                if (this._maskService.maskExpression === "Hh:m0:s0" /* MaskExpression.HOURS_MINUTES_SECONDS */ &&
+                    this.apm()) {
+                    if (this._justPasted() && el.value.slice(0, 2) === "00" /* MaskExpression.DOUBLE_ZERO */) {
+                        el.value = el.value.slice(1, 2) + el.value.slice(2, el.value.length);
+                    }
+                    el.value =
+                        el.value === "00" /* MaskExpression.DOUBLE_ZERO */
+                            ? "0" /* MaskExpression.NUMBER_ZERO */
+                            : el.value;
+                }
+                this._maskService.applyValueChanges(position, this._justPasted(), this._code() === "Backspace" /* MaskExpression.BACKSPACE */ ||
+                    this._code() === "Delete" /* MaskExpression.DELETE */, (shift, _backspaceShift) => {
+                    this._justPasted.set(false);
+                    caretShift = shift;
+                    backspaceShift = _backspaceShift;
+                });
+                // only set the selection if the element is active
+                if (this._getActiveElement() !== el) {
+                    return;
+                }
+                if (this._maskService.plusOnePosition) {
+                    position = position + 1;
+                    this._maskService.plusOnePosition = false;
+                }
+                // update position after applyValueChanges to prevent cursor on wrong position when it has an array of maskExpression
+                if (this._maskExpressionArray().length) {
+                    if (this._code() === "Backspace" /* MaskExpression.BACKSPACE */) {
+                        const specialChartMinusOne = this.specialCharacters().includes(this._maskService.actualValue.slice(position - 1, position));
+                        const allowFewMaskChangeMask = this._maskService.removeMask(this._inputValue())?.length ===
+                            this._maskService.removeMask(this._maskService.maskExpression)?.length;
+                        const specialChartPlusOne = this.specialCharacters().includes(this._maskService.actualValue.slice(position, position + 1));
+                        if (allowFewMaskChangeMask && !specialChartPlusOne) {
+                            position = el.selectionStart + 1;
+                        }
+                        else {
+                            position = specialChartMinusOne ? position - 1 : position;
+                        }
+                    }
+                    else {
+                        position =
+                            el.selectionStart === 1
+                                ? el.selectionStart + this._maskService.prefix.length
+                                : el.selectionStart;
+                    }
+                }
+                this._position.set(this._position() === 1 && this._inputValue().length === 1
+                    ? null
+                    : this._position());
+                let positionToApply = this._position()
+                    ? this._inputValue().length + position + caretShift
+                    : position +
+                        (this._code() === "Backspace" /* MaskExpression.BACKSPACE */ && !backspaceShift
+                            ? 0
+                            : caretShift);
+                if (positionToApply > this._getActualInputLength()) {
+                    positionToApply =
+                        el.value === this._maskService.decimalMarker && el.value.length === 1
+                            ? this._getActualInputLength() + 1
+                            : this._getActualInputLength();
+                }
+                if (positionToApply < 0) {
+                    positionToApply = 0;
+                }
+                el.setSelectionRange(positionToApply, positionToApply);
+                this._position.set(null);
+            }
+            else {
+                // eslint-disable-next-line no-console
+                console.warn('Ngx-mask writeValue work with string | number, your current value:', typeof transformedValue);
+            }
+        }
+        else {
+            if (!this._maskValue()) {
+                this.onChange(el.value);
+                return;
+            }
+            this._maskService.applyValueChanges(el.value.length, this._justPasted(), this._code() === "Backspace" /* MaskExpression.BACKSPACE */ || this._code() === "Delete" /* MaskExpression.DELETE */);
+        }
+    }
+    // IME starts
+    onCompositionStart() {
+        this._isComposing.set(true);
+    }
+    // IME completes
+    onCompositionEnd(e) {
+        this._isComposing.set(false);
+        this._justPasted.set(true);
+        this.onInput(e);
+    }
+    onBlur(e) {
+        if (this._maskValue()) {
+            const el = e.target;
+            if (this._maskService.leadZero &&
+                el.value.length > 0 &&
+                typeof this._maskService.decimalMarker === 'string') {
+                const maskExpression = this._maskService.maskExpression;
+                const decimalMarker = this._maskService.decimalMarker;
+                const suffix = this._maskService.suffix;
+                const precision = Number(this._maskService.maskExpression.slice(maskExpression.length - 1, maskExpression.length));
+                if (precision > 0) {
+                    el.value = suffix ? el.value.split(suffix).join('') : el.value;
+                    const decimalPart = el.value.split(decimalMarker)[1];
+                    el.value = el.value.includes(decimalMarker)
+                        ? el.value +
+                            "0" /* MaskExpression.NUMBER_ZERO */.repeat(precision - decimalPart.length) +
+                            suffix
+                        : el.value +
+                            decimalMarker +
+                            "0" /* MaskExpression.NUMBER_ZERO */.repeat(precision) +
+                            suffix;
+                    this._maskService.actualValue = el.value;
+                }
+            }
+            this._maskService.clearIfNotMatchFn();
+        }
+        this._isFocused.set(false);
+        this.onTouch();
+    }
+    onClick(e) {
+        if (!this._maskValue()) {
+            return;
+        }
+        const el = e.target;
+        const posStart = 0;
+        const posEnd = 0;
+        if (el !== null &&
+            el.selectionStart !== null &&
+            el.selectionStart === el.selectionEnd &&
+            el.selectionStart > this._maskService.prefix.length &&
+            e.keyCode !== 38) {
+            if (this._maskService.showMaskTyped && !this.keepCharacterPositions()) {
+                // We are showing the mask in the input
+                this._maskService.maskIsShown = this._maskService.showMaskInInput();
+                if (el.setSelectionRange &&
+                    this._maskService.prefix + this._maskService.maskIsShown === el.value) {
+                    // the input ONLY contains the mask, so position the cursor at the start
+                    el.focus();
+                    el.setSelectionRange(posStart, posEnd);
+                }
+                else {
+                    // the input contains some characters already
+                    if (el.selectionStart > this._maskService.actualValue.length) {
+                        // if the user clicked beyond our value's length, position the cursor at the end of our value
+                        el.setSelectionRange(this._maskService.actualValue.length, this._maskService.actualValue.length);
+                    }
+                }
+            }
+        }
+        const nextValue = el &&
+            (el.value === this._maskService.prefix
+                ? this._maskService.prefix + this._maskService.maskIsShown
+                : el.value);
+        /** Fix of cursor position jumping to end in most browsers no matter where cursor is inserted onFocus */
+        if (el && el.value !== nextValue) {
+            el.value = nextValue;
+        }
+        /** fix of cursor position with prefix when mouse click occur */
+        if (el &&
+            el.type !== 'number' &&
+            (el.selectionStart || el.selectionEnd) <=
+                this._maskService.prefix.length) {
+            const specialCharactersAtTheStart = this._maskService.maskExpression.match(new RegExp(`^[${this._maskService.specialCharacters.map((c) => `\\${c}`).join('')}]+`))?.[0].length || 0;
+            el.selectionStart = this._maskService.prefix.length + specialCharactersAtTheStart;
+            return;
+        }
+        /** select only inserted text */
+        if (el && el.selectionEnd > this._getActualInputLength()) {
+            el.selectionEnd = this._getActualInputLength();
+        }
+    }
+    onKeyDown(e) {
+        if (!this._maskValue()) {
+            return;
+        }
+        if (this._isComposing()) {
+            // User finalize their choice from IME composition, so trigger onInput() for the composed text.
+            if (e.key === 'Enter') {
+                this.onCompositionEnd(e);
+            }
+            return;
+        }
+        this._code.set(e.code ? e.code : e.key);
+        const el = e.target;
+        this._inputValue.set(el.value);
+        this._setMask();
+        if (el.type !== 'number') {
+            if (e.key === "ArrowUp" /* MaskExpression.ARROW_UP */) {
+                e.preventDefault();
+            }
+            if (e.key === "ArrowLeft" /* MaskExpression.ARROW_LEFT */ ||
+                e.key === "Backspace" /* MaskExpression.BACKSPACE */ ||
+                e.key === "Delete" /* MaskExpression.DELETE */) {
+                if (e.key === "Backspace" /* MaskExpression.BACKSPACE */ && el.value.length === 0) {
+                    el.selectionStart = el.selectionEnd;
+                }
+                if (e.key === "Backspace" /* 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;
+                    if (prefixLength > 1 && el.selectionStart <= prefixLength) {
+                        el.setSelectionRange(prefixLength, el.selectionEnd);
+                    }
+                    else {
+                        if (this._inputValue().length !== el.selectionStart &&
+                            el.selectionStart !== 1) {
+                            while (specialCharacters.includes((this._inputValue()[el.selectionStart - 1] ??
+                                "" /* MaskExpression.EMPTY_STRING */).toString()) &&
+                                ((prefixLength >= 1 &&
+                                    el.selectionStart > prefixLength) ||
+                                    prefixLength === 0)) {
+                                el.setSelectionRange(el.selectionStart - 1, el.selectionEnd);
+                            }
+                        }
+                    }
+                }
+                this.checkSelectionOnDeletion(el);
+                if (this._maskService.prefix.length &&
+                    el.selectionStart <= this._maskService.prefix.length &&
+                    el.selectionEnd <= this._maskService.prefix.length) {
+                    e.preventDefault();
+                }
+                const cursorStart = el.selectionStart;
+                if (e.key === "Backspace" /* MaskExpression.BACKSPACE */ &&
+                    !el.readOnly &&
+                    cursorStart === 0 &&
+                    el.selectionEnd === el.value.length &&
+                    el.value.length !== 0) {
+                    this._position.set(this._maskService.prefix ? this._maskService.prefix.length : 0);
+                    this._maskService.applyMask(this._maskService.prefix, this._maskService.maskExpression, this._position());
+                }
+            }
+            if (!!this.suffix() &&
+                this.suffix().length > 1 &&
+                this._inputValue().length - this.suffix().length < el.selectionStart) {
+                el.setSelectionRange(this._inputValue().length - this.suffix().length, this._inputValue().length);
+            }
+            else if ((e.code === 'KeyA' && e.ctrlKey) ||
+                (e.code === 'KeyA' && e.metaKey) // Cmd + A (Mac)
+            ) {
+                el.setSelectionRange(0, this._getActualInputLength());
+                e.preventDefault();
+            }
+            this._maskService.selStart = el.selectionStart;
+            this._maskService.selEnd = el.selectionEnd;
+        }
+    }
+    /** It writes the value in the input */
+    async writeValue(controlValue) {
+        let value = controlValue;
+        const inputTransformFn = this._maskService.inputTransformFn;
+        if (typeof value === 'object' && value !== null && 'value' in value) {
+            if ('disable' in value) {
+                this.setDisabledState(Boolean(value.disable));
+            }
+            value = value.value;
+        }
+        if (value !== null) {
+            value = inputTransformFn ? inputTransformFn(value) : value;
+        }
+        if (typeof value === 'string' ||
+            typeof value === 'number' ||
+            value === null ||
+            typeof value === 'undefined') {
+            if (value === null || typeof value === 'undefined' || value === '') {
+                this._maskService.currentValue = '';
+                this._maskService.previousValue = '';
+            }
+            let inputValue = value;
+            if (typeof inputValue === 'number' ||
+                this._maskValue().startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+                inputValue = String(inputValue);
+                const localeDecimalMarker = this._maskService.currentLocaleDecimalMarker();
+                if (!Array.isArray(this._maskService.decimalMarker)) {
+                    inputValue =
+                        this._maskService.decimalMarker !== localeDecimalMarker
+                            ? inputValue.replace(localeDecimalMarker, this._maskService.decimalMarker)
+                            : inputValue;
+                }
+                if (this._maskService.leadZero &&
+                    inputValue &&
+                    this.mask() &&
+                    this.dropSpecialCharacters() !== false) {
+                    inputValue = this._maskService._checkPrecision(this._maskService.maskExpression, inputValue);
+                }
+                if (this._maskService.decimalMarker === "," /* MaskExpression.COMMA */ ||
+                    (Array.isArray(this._maskService.decimalMarker) &&
+                        this._maskService.thousandSeparator === "." /* MaskExpression.DOT */)) {
+                    inputValue = inputValue
+                        .toString()
+                        .replace("." /* MaskExpression.DOT */, "," /* MaskExpression.COMMA */);
+                }
+                if (this.mask()?.startsWith("separator" /* MaskExpression.SEPARATOR */) && this.leadZero()) {
+                    requestAnimationFrame(() => {
+                        this._maskService.applyMask(inputValue?.toString() ?? '', this._maskService.maskExpression);
+                    });
+                }
+                this._maskService.isNumberValue = true;
+            }
+            if (typeof inputValue !== 'string' || value === null || typeof value === 'undefined') {
+                inputValue = '';
+            }
+            this._inputValue.set(inputValue);
+            this._setMask();
+            if ((inputValue && this._maskService.maskExpression) ||
+                (this._maskService.maskExpression &&
+                    (this._maskService.prefix || this._maskService.showMaskTyped))) {
+                // Let the service we know we are writing value so that triggering onChange function won't happen during applyMask
+                this._maskService.writingValue = true;
+                this._maskService.formElementProperty = [
+                    'value',
+                    this._maskService.applyMask(inputValue, this._maskService.maskExpression),
+                ];
+                // Let the service know we've finished writing value
+                this._maskService.writingValue = false;
+            }
+            else {
+                this._maskService.formElementProperty = ['value', inputValue];
+            }
+            this._inputValue.set(inputValue);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.warn('Ngx-mask writeValue work with string | number, your current value:', typeof value);
+        }
+    }
+    registerOnChange(fn) {
+        this._maskService.onChange = this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    _getActiveElement(document = this.document) {
+        const shadowRootEl = document?.activeElement?.shadowRoot;
+        if (!shadowRootEl?.activeElement) {
+            return document.activeElement;
+        }
+        else {
+            return this._getActiveElement(shadowRootEl);
+        }
+    }
+    checkSelectionOnDeletion(el) {
+        const prefixLength = this.prefix().length;
+        const suffixLength = this.suffix().length;
+        const inputValueLength = this._inputValue().length;
+        el.selectionStart = Math.min(Math.max(prefixLength, el.selectionStart), inputValueLength - suffixLength);
+        el.selectionEnd = Math.min(Math.max(prefixLength, el.selectionEnd), inputValueLength - suffixLength);
+    }
+    /** It disables the input element */
+    setDisabledState(isDisabled) {
+        this._maskService.formElementProperty = ['disabled', isDisabled];
+    }
+    _applyMask() {
+        this._maskService.maskExpression = this._maskService._repeatPatternSymbols(this._maskValue() || '');
+        this._maskService.formElementProperty = [
+            'value',
+            this._maskService.applyMask(this._inputValue(), this._maskService.maskExpression),
+        ];
+    }
+    _validateTime(value) {
+        const rowMaskLen = this._maskValue()
+            .split("" /* MaskExpression.EMPTY_STRING */)
+            .filter((s) => s !== ':').length;
+        if (!value) {
+            return null; // Don't validate empty values to allow for optional form control
+        }
+        if ((+(value[value.length - 1] ?? -1) === 0 && value.length < rowMaskLen) ||
+            value.length <= rowMaskLen - 2) {
+            return this._createValidationError(value);
+        }
+        return null;
+    }
+    _getActualInputLength() {
+        return (this._maskService.actualValue.length ||
+            this._maskService.actualValue.length + this._maskService.prefix.length);
+    }
+    _createValidationError(actualValue) {
+        return {
+            mask: {
+                requiredMask: this._maskValue(),
+                actualValue,
+            },
+        };
+    }
+    _setMask() {
+        this._maskExpressionArray().some((mask) => {
+            const specialChart = mask
+                .split("" /* MaskExpression.EMPTY_STRING */)
+                .some((char) => this._maskService.specialCharacters.includes(char));
+            if ((specialChart &&
+                this._inputValue() &&
+                this._areAllCharactersInEachStringSame(this._maskExpressionArray())) ||
+                mask.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)) {
+                const test = this._maskService.removeMask(this._inputValue())?.length <=
+                    this._maskService.removeMask(mask)?.length;
+                if (test) {
+                    const maskValue = mask.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)
+                        ? this._maskService._repeatPatternSymbols(mask)
+                        : mask;
+                    this._maskValue.set(maskValue);
+                    this._maskService.maskExpression = maskValue;
+                    return test;
+                }
+                else {
+                    const expression = this._maskExpressionArray()[this._maskExpressionArray().length - 1] ??
+                        "" /* MaskExpression.EMPTY_STRING */;
+                    const maskValue = expression.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)
+                        ? this._maskService._repeatPatternSymbols(expression)
+                        : expression;
+                    this._maskValue.set(maskValue);
+                    this._maskService.maskExpression = maskValue;
+                }
+            }
+            else {
+                const cleanMask = this._maskService.removeMask(mask);
+                const check = this._maskService
+                    .removeMask(this._inputValue())
+                    ?.split("" /* MaskExpression.EMPTY_STRING */)
+                    .every((character, index) => {
+                    const indexMask = cleanMask.charAt(index);
+                    return this._maskService._checkSymbolMask(character, indexMask);
+                });
+                if (check || this._justPasted()) {
+                    this._maskValue.set(mask);
+                    this._maskService.maskExpression = mask;
+                    return check;
+                }
+            }
+        });
+    }
+    _areAllCharactersInEachStringSame(array) {
+        const specialCharacters = this._maskService.specialCharacters;
+        function removeSpecialCharacters(str) {
+            const regex = new RegExp(`[${specialCharacters.map((ch) => `\\${ch}`).join('')}]`, 'g');
+            return str.replace(regex, '');
+        }
+        const processedArr = array.map(removeSpecialCharacters);
+        return processedArr.every((str) => {
+            const uniqueCharacters = new Set(str);
+            return uniqueCharacters.size === 1;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.8", 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 } }, outputs: { maskFilled: "maskFilled" }, host: { listeners: { "paste": "onPaste()", "focus": "onFocus($event)", "ngModelChange": "onModelChange($event)", "input": "onInput($event)", "compositionstart": "onCompositionStart($event)", "compositionend": "onCompositionEnd($event)", "blur": "onBlur($event)", "click": "onClick($event)", "keydown": "onKeyDown($event)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => NgxMaskDirective),
+                multi: true,
+            },
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => NgxMaskDirective),
+                multi: true,
+            },
+            NgxMaskService,
+        ], exportAs: ["mask", "ngxMask"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[mask], textarea[mask]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => NgxMaskDirective),
+                            multi: true,
+                        },
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => NgxMaskDirective),
+                            multi: true,
+                        },
+                        NgxMaskService,
+                    ],
+                    exportAs: 'mask,ngxMask',
+                }]
+        }], propDecorators: { onPaste: [{
+                type: HostListener,
+                args: ['paste']
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focus', ['$event']]
+            }], onModelChange: [{
+                type: HostListener,
+                args: ['ngModelChange', ['$event']]
+            }], onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }], onCompositionStart: [{
+                type: HostListener,
+                args: ['compositionstart', ['$event']]
+            }], onCompositionEnd: [{
+                type: HostListener,
+                args: ['compositionend', ['$event']]
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur', ['$event']]
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+
+/**
+ * Componente MatchaInputPhone
+ *
+ * Componente Angular para entrada de telefone internacional com seleção de país, máscara dinâmica e exibição de bandeira.
+ *
+ * Funcionalidades:
+ * - Seleção de país com dropdown e bandeira.
+ * - Máscara dinâmica de acordo com o país e DDD digitado.
+ * - Suporte a diferentes formatos de telefone (fixo/celular) para o Brasil.
+ * - Emissão de evento ao alterar o valor do telefone.
+ * - Inicialização automática pelo valor informado ou pelo idioma do navegador.
+ *
+ * Inputs:
+ * - fallbackMask: string - Máscara padrão caso não seja encontrada uma específica.
+ * - label: string - Rótulo do campo (padrão: 'Telefone').
+ * - value: string - Valor inicial do telefone (com ou sem DDI).
+ *
+ * Outputs:
+ * - onChange: EventEmitter<string> - Emite o valor do telefone completo (com DDI) ao alterar.
+ *
+ * ViewChild:
+ * - inputSelector: ElementRef - Referência ao container do input (usado para fechar o dropdown).
+ * - phoneRef: ElementRef - Referência ao input do telefone.
+ *
+ * Métodos principais:
+ * - ngOnInit: Inicializa o componente pelo valor ou idioma.
+ * - ngOnChanges: Atualiza o valor ao receber novo input externo.
+ * - initCountryPhone: Inicializa país e máscara pelo valor do telefone.
+ * - selectMaskForDialCode: Seleciona a máscara conforme país e DDD.
+ * - selectCountry: Troca o país selecionado e atualiza máscara.
+ * - onInput: Atualiza máscara e emite evento ao digitar.
+ * - toggleDropdown: Abre/fecha o dropdown de países.
+ */
+class MatchaInputPhoneComponent {
+    constructor(renderer, cdr) {
+        this.renderer = renderer;
+        this.cdr = cdr;
+        this.fallbackMask = '00 0000 0000';
+        this.onChange = new EventEmitter();
+        this.typeMask = '';
+        this.labelHover = 'su';
+        this.allCountries = getCountryISO2();
+        this.isOpen = false;
+        this.inputValueModel = '';
+        this.clickListener = null;
+        this.isInitialized = false;
+    }
+    ngOnInit() {
+        this.value ? this.initCountryPhone(this.value) : this.initCountrylanguageNavigator();
+        this.cdr.detectChanges();
+        this.isInitialized = true;
+    }
+    ngOnChanges(changes) {
+        if (changes['value'] && !changes['value'].firstChange) {
+            this.value = changes['value'].currentValue;
+            if (!this.value) {
+                this.inputValueModel = this.value ?? '';
+                return;
+            }
+            this.initCountryPhone(this.value);
+            this.cdr.detectChanges();
+        }
+    }
+    initCountryPhone(phone) {
+        if (!phone.startsWith('+')) {
+            this.setCountryAndInputValue('br', phone);
+            return;
+        }
+        const phoneWithoutPlus = phone.replace('+', '');
+        const countryDialCode = this.selectedCountry?.dialCode;
+        if (phoneWithoutPlus.startsWith(countryDialCode)) {
+            this.setCountryAndInputValue(this.selectedCountry.iso2, phoneWithoutPlus.replace(countryDialCode, ''));
+            this.inputValueModel = phoneWithoutPlus.replace(countryDialCode, '');
+        }
+        else {
+            this.matchCountryAndSetInputValue(phoneWithoutPlus);
+        }
+    }
+    setCountryAndInputValue(iso2, phone) {
+        this.selectedCountry = this.allCountries.find((country) => country.iso2 === iso2);
+        this.inputValueModel = phone.startsWith('0') ? phone.slice(1) : phone;
+        this.selectMaskForDialCode(this.selectedCountry.areaCodes ? this.selectedCountry.areaCodes[0] : '000', this.inputValueModel);
+    }
+    matchCountryAndSetInputValue(phoneWithoutPlus) {
+        const matchingCountry = this.getMatchingCountry(phoneWithoutPlus);
+        if (matchingCountry.length === 1) {
+            this.setCountryAndInputValue(matchingCountry[0].iso2, phoneWithoutPlus.replace(matchingCountry[0].dialCode, ''));
+        }
+        else {
+            this.matchAreaCodeAndSetInputValue(phoneWithoutPlus, matchingCountry);
+        }
+    }
+    getMatchingCountry(phoneWithoutPlus) {
+        return this.allCountries.filter((country) => {
+            const dialCode = country.dialCode;
+            return phoneWithoutPlus.startsWith(dialCode);
+        });
+    }
+    matchAreaCodeAndSetInputValue(phoneWithoutPlus, matchingCountry) {
+        const phoneWithoutDialCode = phoneWithoutPlus.replace(matchingCountry[0].dialCode, '');
+        const filterAreaCode = phoneWithoutDialCode.substring(0, 3);
+        const matchingAreaCode = matchingCountry.filter((country) => {
+            if (country.areaCodes) {
+                return country.areaCodes.includes(filterAreaCode);
+            }
+        });
+        if (matchingAreaCode.length === 1) {
+            this.setCountryAndInputValue(matchingAreaCode[0].iso2, phoneWithoutDialCode);
+        }
+        else {
+            const defaultCountry = matchingCountry.find((country) => country.priority === 0);
+            this.setCountryAndInputValue(defaultCountry.iso2, phoneWithoutDialCode);
+        }
+    }
+    selectMaskForDialCode(inputDigits, targetValuePhone) {
+        const previousMask = this.typeMask;
+        const maskArray = this.selectedCountry?.mask;
+        const maskIndex = this.selectedCountry?.areaCodes
+            ? this.selectedCountry.areaCodes.findIndex((code) => inputDigits === code)
+            : -1;
+        if (this.selectedCountry?.iso2 === 'br' && (targetValuePhone && targetValuePhone.length > 2)) {
+            const eventInput = targetValuePhone.substring(2);
+            if (eventInput && eventInput[0] === '9') {
+                this.typeMask = "00 0 0000 0000";
+                this.cdr.detectChanges();
+                return;
+            }
+        }
+        if (Array.isArray(maskArray)) {
+            if (maskIndex !== -1 && maskArray[maskIndex]) {
+                this.typeMask = maskArray[maskIndex];
+            }
+            else if (maskArray[0]) {
+                this.typeMask = maskArray[0];
+            }
+            else {
+                this.typeMask = this.fallbackMask;
+            }
+        }
+        else {
+            this.typeMask = this.fallbackMask;
+        }
+        if (previousMask !== this.typeMask)
+            this.inputValueModel = '';
+        this.cdr.detectChanges();
+    }
+    initCountrylanguageNavigator() {
+        let lang = navigator.language;
+        if (lang.includes('-')) {
+            const langParts = lang.split('-');
+            lang = langParts[1];
+        }
+        this.selectedCountry = this.allCountries.find((country) => country.iso2 === lang.toLocaleLowerCase());
+        this.selectMaskForDialCode(this.selectedCountry.areaCodes ? this.selectedCountry.areaCodes[0] : '000');
+    }
+    selectCountry(country) {
+        this.selectedCountry = country;
+        this.selectMaskForDialCode(this.selectedCountry.areaCodes ? this.selectedCountry.areaCodes[0] : '000');
+        this.isOpen = false;
+        this.onChange.emit('+' + this.selectedCountry.dialCode + this.inputValueModel);
+        this.removeClickListener();
+        this.cdr.detectChanges();
+    }
+    toggleDropdown() {
+        this.isOpen = !this.isOpen;
+        this.clickListener = this.renderer.listen('window', 'click', (event) => {
+            if (this.isOpen && !this.inputSelector.nativeElement.contains(event.target)) {
+                this.isOpen = false;
+                this.removeClickListener();
+            }
+        });
+        this.cdr.detectChanges();
+    }
+    removeClickListener() {
+        if (this.clickListener) {
+            this.clickListener();
+            this.clickListener = null;
+        }
+    }
+    onInput(event) {
+        this.phoneRef.nativeElement.value = event.target.value.replace(/[^\d\s]/g, '');
+        let targetValuePhone = event.target.value.replace(/\D/g, '');
+        this.onChange.emit('+' + this.selectedCountry.dialCode + this.inputValueModel);
+        const inputDigits = targetValuePhone.substring(0, 3);
+        if (inputDigits) {
+            this.selectMaskForDialCode(inputDigits, targetValuePhone);
+        }
+        this.cdr.detectChanges();
+    }
+    ngOnDestroy() {
+        this.removeClickListener();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: MatchaInputPhoneComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.8", type: MatchaInputPhoneComponent, isStandalone: false, selector: "matcha-input-phone", inputs: { fallbackMask: "fallbackMask", value: "value" }, outputs: { onChange: "onChange" }, viewQueries: [{ propertyName: "inputSelector", first: true, predicate: ["inputSelector"], descendants: true }, { propertyName: "phoneRef", first: true, predicate: ["phoneRef"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "\n<div class=\"flex-row position-relative px-16 gap-8\" #inputSelector>\n    <div class=\"min-h-24 radius-8 cursor-pointer d-flex gap-8 flex-align-center fs-16\" (click)=\"toggleDropdown()\">\n        <div class=\"d-flex-row flex-align-center\">\n            <img alt=\"\" [src]=\"'https://flagcdn.com/16x12/'+ selectedCountry?.iso2?.toLowerCase() + '.png'\"\n                height=\"16\">\n        </div>\n        <span class=\"w-16 fs-16\"\n            [ngClass]=\"isOpen ? 'i-matcha-action_arrow_up': 'i-matcha-action_arrow_down'\"></span>\n\n    </div>\n    <input *ngIf=\"isInitialized\" #phoneRef type=\"text\" placeholder=\"{{ typeMask }}\"\n        [(ngModel)]=\"inputValueModel\"\n        pattern=\"[0-9]*\" (keyup)=\"onInput($event)\" [mask]=\"typeMask\">\n\n    <ng-container *ngIf=\"isOpen\">\n        <div class=\"position-absolute z-index-10\">\n            <div class=\"grid-1 gap-16 radius-8 z-index-10 p-8 w-300 position-absolute background-surface elevation-z-1\"\n                style=\"top: calc(100% + 10px); overflow: hidden; height: 300px; overflow-y: auto;\">\n\n                <label *ngFor=\"let country of allCountries; let i = index\"\n                    class=\"fs-16 lh-18 cursor-pointer d-flex-align-center p-8 ts-300-l\"\n                    [ngClass]=\"labelHover === i+'bg' ? 'background-bg' : 'background-surface'\"\n                    (mouseover)=\"labelHover = i+'bg'\" (mouseout)=\"labelHover = i+'su'\"\n                    (click)=\"selectCountry(country)\">\n                    <img alt=\"\" class=\"mr-8\"\n                        [src]=\"'https://flagcdn.com/16x12/'+ country?.iso2?.toLowerCase() + '.png'\" height=\"16\">\n                    {{country.name}}\n                </label>\n            </div>\n        </div>\n    </ng-container>\n</div>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.PatternValidator, selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", inputs: ["pattern"] }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: NgxMaskDirective, selector: "input[mask], textarea[mask]", inputs: ["mask", "specialCharacters", "patterns", "prefix", "suffix", "thousandSeparator", "decimalMarker", "dropSpecialCharacters", "hiddenInput", "showMaskTyped", "placeHolderCharacter", "shownMaskExpression", "clearIfNotMatch", "validation", "separatorLimit", "allowNegativeNumbers", "leadZeroDateTime", "leadZero", "triggerOnMaskChange", "apm", "inputTransformFn", "outputTransformFn", "keepCharacterPositions", "instantPrefix"], outputs: ["maskFilled"], exportAs: ["mask", "ngxMask"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: MatchaInputPhoneComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'matcha-input-phone', standalone: false, template: "\n<div class=\"flex-row position-relative px-16 gap-8\" #inputSelector>\n    <div class=\"min-h-24 radius-8 cursor-pointer d-flex gap-8 flex-align-center fs-16\" (click)=\"toggleDropdown()\">\n        <div class=\"d-flex-row flex-align-center\">\n            <img alt=\"\" [src]=\"'https://flagcdn.com/16x12/'+ selectedCountry?.iso2?.toLowerCase() + '.png'\"\n                height=\"16\">\n        </div>\n        <span class=\"w-16 fs-16\"\n            [ngClass]=\"isOpen ? 'i-matcha-action_arrow_up': 'i-matcha-action_arrow_down'\"></span>\n\n    </div>\n    <input *ngIf=\"isInitialized\" #phoneRef type=\"text\" placeholder=\"{{ typeMask }}\"\n        [(ngModel)]=\"inputValueModel\"\n        pattern=\"[0-9]*\" (keyup)=\"onInput($event)\" [mask]=\"typeMask\">\n\n    <ng-container *ngIf=\"isOpen\">\n        <div class=\"position-absolute z-index-10\">\n            <div class=\"grid-1 gap-16 radius-8 z-index-10 p-8 w-300 position-absolute background-surface elevation-z-1\"\n                style=\"top: calc(100% + 10px); overflow: hidden; height: 300px; overflow-y: auto;\">\n\n                <label *ngFor=\"let country of allCountries; let i = index\"\n                    class=\"fs-16 lh-18 cursor-pointer d-flex-align-center p-8 ts-300-l\"\n                    [ngClass]=\"labelHover === i+'bg' ? 'background-bg' : 'background-surface'\"\n                    (mouseover)=\"labelHover = i+'bg'\" (mouseout)=\"labelHover = i+'su'\"\n                    (click)=\"selectCountry(country)\">\n                    <img alt=\"\" class=\"mr-8\"\n                        [src]=\"'https://flagcdn.com/16x12/'+ country?.iso2?.toLowerCase() + '.png'\" height=\"16\">\n                    {{country.name}}\n                </label>\n            </div>\n        </div>\n    </ng-container>\n</div>\n" }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }], propDecorators: { inputSelector: [{
+                type: ViewChild,
+                args: ['inputSelector']
+            }], phoneRef: [{
+                type: ViewChild,
+                args: ['phoneRef']
+            }], fallbackMask: [{
+                type: Input,
+                args: ['fallbackMask']
+            }], value: [{
+                type: Input,
+                args: ['value']
+            }], onChange: [{
+                type: Output
+            }] } });
+
 class MatchaTooltipDirective {
     constructor(el, renderer) {
         this.el = el;
@@ -3582,6 +7607,190 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
                 }]
         }] });
 
+class NgxMaskPipe {
+    constructor() {
+        this.defaultOptions = inject(NGX_MASK_CONFIG);
+        this._maskService = inject(NgxMaskService);
+        this._maskExpressionArray = [];
+        this.mask = '';
+    }
+    transform(value, mask, { patterns, ...config } = {}) {
+        let processedValue = value;
+        const currentConfig = {
+            maskExpression: mask,
+            ...this.defaultOptions,
+            ...config,
+            patterns: {
+                ...this._maskService.patterns,
+                ...patterns,
+            },
+        };
+        Object.entries(currentConfig).forEach(([key, val]) => {
+            this._maskService[key] = val;
+        });
+        if (mask.includes('||')) {
+            const maskParts = mask.split('||');
+            if (maskParts.length > 1) {
+                this._maskExpressionArray = maskParts.sort((a, b) => a.length - b.length);
+                this._setMask(`${processedValue}`);
+                return this._maskService.applyMask(`${processedValue}`, this.mask);
+            }
+            else {
+                this._maskExpressionArray = [];
+                return this._maskService.applyMask(`${processedValue}`, this.mask);
+            }
+        }
+        if (mask.includes("{" /* MaskExpression.CURLY_BRACKETS_LEFT */)) {
+            return this._maskService.applyMask(`${processedValue}`, this._maskService._repeatPatternSymbols(mask));
+        }
+        if (mask.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+            if (config.decimalMarker) {
+                this._maskService.decimalMarker = config.decimalMarker;
+            }
+            if (config.thousandSeparator) {
+                this._maskService.thousandSeparator = config.thousandSeparator;
+            }
+            if (config.leadZero) {
+                this._maskService.leadZero = config.leadZero;
+            }
+            processedValue = String(processedValue);
+            const localeDecimalMarker = this._maskService.currentLocaleDecimalMarker();
+            if (!Array.isArray(this._maskService.decimalMarker)) {
+                processedValue =
+                    this._maskService.decimalMarker !== localeDecimalMarker
+                        ? processedValue.replace(localeDecimalMarker, this._maskService.decimalMarker)
+                        : processedValue;
+            }
+            if (this._maskService.leadZero &&
+                processedValue &&
+                this._maskService.dropSpecialCharacters !== false) {
+                processedValue = this._maskService._checkPrecision(mask, processedValue);
+            }
+            if (this._maskService.decimalMarker === "," /* MaskExpression.COMMA */) {
+                processedValue = processedValue.replace("." /* MaskExpression.DOT */, "," /* MaskExpression.COMMA */);
+            }
+            this._maskService.isNumberValue = true;
+        }
+        if (processedValue === null || typeof processedValue === 'undefined') {
+            return this._maskService.applyMask('', mask);
+        }
+        return this._maskService.applyMask(`${processedValue}`, mask);
+    }
+    _setMask(value) {
+        if (this._maskExpressionArray.length > 0) {
+            this._maskExpressionArray.some((mask) => {
+                const test = this._maskService.removeMask(value)?.length <=
+                    this._maskService.removeMask(mask)?.length;
+                if (value && test) {
+                    this.mask = mask;
+                    return test;
+                }
+                else {
+                    this.mask =
+                        this._maskExpressionArray[this._maskExpressionArray.length - 1] ??
+                            "" /* MaskExpression.EMPTY_STRING */;
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskPipe, isStandalone: true, name: "mask" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'mask',
+                    pure: true,
+                    standalone: true,
+                }]
+        }] });
+
+const options = {
+    specialCharacters: ['/', '(', ')', '.', ':', '-', ' ', '+', ',', '@', '[', ']', '"', "'", '*'],
+    patterns: {
+        '0': { pattern: /\d/ },
+        '9': { pattern: /\d/, optional: true },
+        'A': { pattern: /[a-zA-Z0-9]/ },
+        'S': { pattern: /[a-zA-Z]/ }
+    },
+    prefix: '',
+    suffix: '',
+    thousandSeparator: '',
+    decimalMarker: '.',
+    clearIfNotMatch: false,
+    showMaskTyped: false,
+    placeHolderCharacter: '_',
+    shownMaskExpression: '',
+    dropSpecialCharacters: true,
+    hiddenInput: false,
+    validation: true,
+    instantPrefix: false,
+    separatorLimit: '',
+    apm: false,
+    allowNegativeNumbers: false,
+    leadZeroDateTime: false,
+    leadZero: false,
+    triggerOnMaskChange: false,
+    keepCharacterPositions: false,
+    inputTransformFn: (v) => v,
+    outputTransformFn: (v) => v,
+    maskFilled: { emit: () => { } } // mock para EventEmitter
+};
+class NgxMaskModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskModule, imports: [CommonModule,
+            NgxMaskDirective,
+            NgxMaskPipe], exports: [NgxMaskDirective,
+            NgxMaskPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskModule, providers: [
+            NgxMaskService,
+            { provide: NGX_MASK_CONFIG, useValue: options }
+        ], imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: NgxMaskModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        NgxMaskDirective,
+                        NgxMaskPipe
+                    ],
+                    exports: [
+                        NgxMaskDirective,
+                        NgxMaskPipe
+                    ],
+                    providers: [
+                        NgxMaskService,
+                        { provide: NGX_MASK_CONFIG, useValue: options }
+                    ]
+                }]
+        }] });
+
+class MatchaInputPhoneModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: MatchaInputPhoneModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.8", ngImport: i0, type: MatchaInputPhoneModule, declarations: [MatchaInputPhoneComponent], imports: [CommonModule,
+            MatchaFormFieldModule,
+            FormsModule,
+            NgxMaskModule], exports: [MatchaInputPhoneComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: MatchaInputPhoneModule, imports: [CommonModule,
+            MatchaFormFieldModule,
+            FormsModule,
+            NgxMaskModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: MatchaInputPhoneModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MatchaInputPhoneComponent],
+                    imports: [
+                        CommonModule,
+                        MatchaFormFieldModule,
+                        FormsModule,
+                        NgxMaskModule
+                    ],
+                    exports: [MatchaInputPhoneComponent]
+                }]
+        }] });
+
 class MatchaComponentsModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: MatchaComponentsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.8", ngImport: i0, type: MatchaComponentsModule, declarations: [MatchaOverflowDraggableComponent], imports: [CommonModule,
@@ -3603,6 +7812,7 @@ class MatchaComponentsModule {
             MatchaIconModule,
             MatchaInfiniteScrollModule,
             MatchaInputModule,
+            MatchaInputPhoneModule,
             MatchaMasonryModule,
             MatchaMenuModule,
             MatchaModalModule,
@@ -3638,6 +7848,7 @@ class MatchaComponentsModule {
             MatchaIconModule,
             MatchaInfiniteScrollModule,
             MatchaInputModule,
+            MatchaInputPhoneModule,
             MatchaMasonryModule,
             MatchaMenuModule,
             MatchaModalModule,
@@ -3677,6 +7888,7 @@ class MatchaComponentsModule {
             MatchaIconModule,
             MatchaInfiniteScrollModule,
             MatchaInputModule,
+            MatchaInputPhoneModule,
             MatchaMasonryModule,
             MatchaMenuModule,
             MatchaModalModule,
@@ -3712,6 +7924,7 @@ class MatchaComponentsModule {
             MatchaIconModule,
             MatchaInfiniteScrollModule,
             MatchaInputModule,
+            MatchaInputPhoneModule,
             MatchaMasonryModule,
             MatchaMenuModule,
             MatchaModalModule,
@@ -3757,6 +7970,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
                         MatchaIconModule,
                         MatchaInfiniteScrollModule,
                         MatchaInputModule,
+                        MatchaInputPhoneModule,
                         MatchaMasonryModule,
                         MatchaMenuModule,
                         MatchaModalModule,
@@ -3794,6 +8008,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
                         MatchaIconModule,
                         MatchaInfiniteScrollModule,
                         MatchaInputModule,
+                        MatchaInputPhoneModule,
                         MatchaMasonryModule,
                         MatchaMenuModule,
                         MatchaModalModule,
@@ -3837,5 +8052,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { MatchaAccordionComponent, MatchaAccordionContentComponent, MatchaAccordionHeaderComponent, MatchaAccordionItemComponent, MatchaAccordionModule, MatchaBadgeDirective, MatchaBadgeModule, MatchaButtonComponent, MatchaButtonModule, MatchaButtonToggleComponent, MatchaButtonToggleModule, MatchaCardComponent, MatchaCardModule, MatchaCheckboxComponent, MatchaCheckboxModule, MatchaChipsDirective, MatchaChipsModule, MatchaComponentsModule, MatchaDatepickerDirective, MatchaDatepickerModule, MatchaDividerComponent, MatchaDividerModule, MatchaElevationDirective, MatchaElevationModule, MatchaErrorComponent, MatchaFormFieldComponent, MatchaFormFieldModule, MatchaGridComponent, MatchaGridModule, MatchaHintTextComponent, MatchaHintTextModule, MatchaIconComponent, MatchaIconModule, MatchaInfiniteScrollComponent, MatchaInfiniteScrollDataComponent, MatchaInfiniteScrollModule, MatchaInputDirective, MatchaInputModule, MatchaLabelComponent, MatchaMasonryComponent, MatchaMasonryModule, MatchaMenuComponent, MatchaMenuModule, MatchaMenuTriggerForDirective, MatchaModalComponent, MatchaModalContentComponent, MatchaModalFooterComponent, MatchaModalHeaderComponent, MatchaModalModule, MatchaModalOptionsComponent, MatchaModalService, MatchaOverlayService, MatchaPaginatorDirective, MatchaPaginatorModule, MatchaProgressBarDirective, MatchaProgressBarModule, MatchaRadioButtonDirective, MatchaRadioButtonModule, MatchaRippleDirective, MatchaRippleModule, MatchaSelectDirective, MatchaSelectModule, MatchaSidenavDirective, MatchaSidenavModule, MatchaSlideToggleComponent, MatchaSlideToggleModule, MatchaSliderDirective, MatchaSliderModule, MatchaSnackBarDirective, MatchaSnackBarModule, MatchaSortHeaderDirective, MatchaSortHeaderModule, MatchaSpinComponent, MatchaSpinModule, MatchaTabItemComponent, MatchaTableDirective, MatchaTableModule, MatchaTabsComponent, MatchaTabsModule, MatchaTitleComponent, MatchaTitleModule, MatchaToolbarButtonComponent, MatchaToolbarComponent, MatchaToolbarContentComponent, MatchaToolbarCustomButtonComponent, MatchaToolbarMainButtonComponent, MatchaToolbarModule, MatchaTooltipDirective, MatchaTooltipModule, MatchaTreeDirective, MatchaTreeModule };
+export { MatchaAccordionComponent, MatchaAccordionContentComponent, MatchaAccordionHeaderComponent, MatchaAccordionItemComponent, MatchaAccordionModule, MatchaBadgeDirective, MatchaBadgeModule, MatchaButtonComponent, MatchaButtonModule, MatchaButtonToggleComponent, MatchaButtonToggleModule, MatchaCardComponent, MatchaCardModule, MatchaCheckboxComponent, MatchaCheckboxModule, MatchaChipsDirective, MatchaChipsModule, MatchaComponentsModule, MatchaDatepickerDirective, MatchaDatepickerModule, MatchaDividerComponent, MatchaDividerModule, MatchaElevationDirective, MatchaElevationModule, MatchaErrorComponent, MatchaFormFieldComponent, MatchaFormFieldModule, MatchaGridComponent, MatchaGridModule, MatchaHintTextComponent, MatchaHintTextModule, MatchaIconComponent, MatchaIconModule, MatchaInfiniteScrollComponent, MatchaInfiniteScrollDataComponent, MatchaInfiniteScrollModule, MatchaInputDirective, MatchaInputModule, MatchaInputPhoneComponent, MatchaInputPhoneModule, MatchaLabelComponent, MatchaMasonryComponent, MatchaMasonryModule, MatchaMenuComponent, MatchaMenuModule, MatchaMenuTriggerForDirective, MatchaModalComponent, MatchaModalContentComponent, MatchaModalFooterComponent, MatchaModalHeaderComponent, MatchaModalModule, MatchaModalOptionsComponent, MatchaModalService, MatchaOverlayService, MatchaPaginatorDirective, MatchaPaginatorModule, MatchaProgressBarDirective, MatchaProgressBarModule, MatchaRadioButtonDirective, MatchaRadioButtonModule, MatchaRippleDirective, MatchaRippleModule, MatchaSelectDirective, MatchaSelectModule, MatchaSidenavDirective, MatchaSidenavModule, MatchaSlideToggleComponent, MatchaSlideToggleModule, MatchaSliderDirective, MatchaSliderModule, MatchaSnackBarDirective, MatchaSnackBarModule, MatchaSortHeaderDirective, MatchaSortHeaderModule, MatchaSpinComponent, MatchaSpinModule, MatchaTabItemComponent, MatchaTableDirective, MatchaTableModule, MatchaTabsComponent, MatchaTabsModule, MatchaTitleComponent, MatchaTitleModule, MatchaToolbarButtonComponent, MatchaToolbarComponent, MatchaToolbarContentComponent, MatchaToolbarCustomButtonComponent, MatchaToolbarMainButtonComponent, MatchaToolbarModule, MatchaTooltipDirective, MatchaTooltipModule, MatchaTreeDirective, MatchaTreeModule };
 //# sourceMappingURL=matcha-components.mjs.map