matcha-components 19.108.0 → 19.110.0

package/fesm2022/matcha-components.mjs

@@ -1,12 +1,11 @@
 import * as i0 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, TemplateRef, NgModule, createComponent, Pipe } from '@angular/core';
+import { EventEmitter, Output, Input, Component, ContentChildren, ElementRef, Renderer2, HostBinding, Inject, HostListener, ContentChild, Directive, forwardRef, ChangeDetectionStrategy, TemplateRef, ViewChild, Injectable, NgModule, createComponent } from '@angular/core';
 import { animation, style, animate, trigger, transition, useAnimation, state, query, stagger, animateChild, sequence, group } from '@angular/animations';
 import { Subscription, Subject, BehaviorSubject } from 'rxjs';
 import { debounceTime } from 'rxjs/operators';
 import * as i1 from '@angular/common';
-import { DOCUMENT, CommonModule } from '@angular/common';
-import * as i2 from '@angular/forms';
-import { FormControlName, NG_VALUE_ACCESSOR, NgControl, NG_VALIDATORS, FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import { FormControlName, NG_VALUE_ACCESSOR, NgControl, FormsModule, ReactiveFormsModule } from '@angular/forms';
 
 const customAnimation = animation([
     style({
@@ -2341,4030 +2340,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
                 type: Input
             }] } });
 
-// 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: false, 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: false,
-                    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 StepComponent {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.8", ngImport: i0, type: StepComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.8", type: StepComponent, isStandalone: false, selector: "step", inputs: { step: "step" }, viewQueries: [{ propertyName: "template", first: true, predicate: TemplateRef, descendants: true, static: true }], ngImport: i0, template: `<ng-template><ng-content></ng-content></ng-template>`, isInline: true }); }
@@ -8045,188 +4020,7 @@ 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: false, 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: false,
-                }]
-        }] });
-
-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, declarations: [NgxMaskDirective, NgxMaskPipe], imports: [CommonModule], 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: [{
-                    declarations: [NgxMaskDirective, NgxMaskPipe],
-                    imports: [
-                        CommonModule
-                    ],
-                    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, providers: [NgxMaskModule], 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],
-                    providers: [NgxMaskModule],
-                }]
-        }] });
-
+// import { MatchaInputPhoneModule } from './matcha-input-phone/input-phone.module';
 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,
@@ -8248,7 +4042,7 @@ class MatchaComponentsModule {
             MatchaIconModule,
             MatchaInfiniteScrollModule,
             MatchaInputModule,
-            MatchaInputPhoneModule,
+            // MatchaInputPhoneModule,
             MatchaMasonryModule,
             MatchaMenuModule,
             MatchaModalModule,
@@ -8287,7 +4081,7 @@ class MatchaComponentsModule {
             MatchaIconModule,
             MatchaInfiniteScrollModule,
             MatchaInputModule,
-            MatchaInputPhoneModule,
+            //  MatchaInputPhoneModule,
             MatchaMasonryModule,
             MatchaMenuModule,
             MatchaModalModule,
@@ -8330,7 +4124,7 @@ class MatchaComponentsModule {
             MatchaIconModule,
             MatchaInfiniteScrollModule,
             MatchaInputModule,
-            MatchaInputPhoneModule,
+            // MatchaInputPhoneModule,
             MatchaMasonryModule,
             MatchaMenuModule,
             MatchaModalModule,
@@ -8369,7 +4163,7 @@ class MatchaComponentsModule {
             MatchaIconModule,
             MatchaInfiniteScrollModule,
             MatchaInputModule,
-            MatchaInputPhoneModule,
+            //  MatchaInputPhoneModule,
             MatchaMasonryModule,
             MatchaMenuModule,
             MatchaModalModule,
@@ -8418,7 +4212,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
                         MatchaIconModule,
                         MatchaInfiniteScrollModule,
                         MatchaInputModule,
-                        MatchaInputPhoneModule,
+                        // MatchaInputPhoneModule,
                         MatchaMasonryModule,
                         MatchaMenuModule,
                         MatchaModalModule,
@@ -8459,7 +4253,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
                         MatchaIconModule,
                         MatchaInfiniteScrollModule,
                         MatchaInputModule,
-                        MatchaInputPhoneModule,
+                        //  MatchaInputPhoneModule,
                         MatchaMasonryModule,
                         MatchaMenuModule,
                         MatchaModalModule,
@@ -8518,10 +4312,21 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
 // -----------------------------------------------------------
 // COMPONENTS
 // -----------------------------------------------------------
+// -----------------------------------------------------------
+// VENDORS
+// export * from './lib/matcha-input-phone/lib/ngx-mask-applier.service';
+// export * from './lib/matcha-input-phone/lib/ngx-mask.directive';
+// export * from './lib/matcha-input-phone/lib/ngx-mask.module';
+// export * from './lib/matcha-input-phone/lib/ngx-mask.pipe';
+// export * from './lib/matcha-input-phone/lib/ngx-mask.service';
+// export * from './lib/matcha-input-phone/lib/ngx-mask.providers';
+// export * from './lib/matcha-input-phone/lib/custom-keyboard-event';
+// export * from './lib/matcha-input-phone/lib/ngx-mask.config';
+// export * from './lib/matcha-input-phone/lib/ngx-mask-expression.enum';
 
 /**
  * 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, MatchaDateComponent, MatchaDateModule, 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, MatchaStepperComponent, MatchaStepperContentComponent, MatchaStepperControllerComponent, MatchaStepperModule, MatchaTabItemComponent, MatchaTableDirective, MatchaTableModule, MatchaTabsComponent, MatchaTabsModule, MatchaTimeComponent, MatchaTimeModule, MatchaTitleComponent, MatchaTitleModule, MatchaToolbarButtonComponent, MatchaToolbarComponent, MatchaToolbarContentComponent, MatchaToolbarCustomButtonComponent, MatchaToolbarMainButtonComponent, MatchaToolbarModule, MatchaTooltipDirective, MatchaTooltipModule, MatchaTreeDirective, MatchaTreeModule, NextStepDirective, PrevStepDirective, StepComponent, StepContentDirective };
+export { MatchaAccordionComponent, MatchaAccordionContentComponent, MatchaAccordionHeaderComponent, MatchaAccordionItemComponent, MatchaAccordionModule, MatchaBadgeDirective, MatchaBadgeModule, MatchaButtonComponent, MatchaButtonModule, MatchaButtonToggleComponent, MatchaButtonToggleModule, MatchaCardComponent, MatchaCardModule, MatchaCheckboxComponent, MatchaCheckboxModule, MatchaChipsDirective, MatchaChipsModule, MatchaComponentsModule, MatchaDateComponent, MatchaDateModule, 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, MatchaStepperComponent, MatchaStepperContentComponent, MatchaStepperControllerComponent, MatchaStepperModule, MatchaTabItemComponent, MatchaTableDirective, MatchaTableModule, MatchaTabsComponent, MatchaTabsModule, MatchaTimeComponent, MatchaTimeModule, MatchaTitleComponent, MatchaTitleModule, MatchaToolbarButtonComponent, MatchaToolbarComponent, MatchaToolbarContentComponent, MatchaToolbarCustomButtonComponent, MatchaToolbarMainButtonComponent, MatchaToolbarModule, MatchaTooltipDirective, MatchaTooltipModule, MatchaTreeDirective, MatchaTreeModule, NextStepDirective, PrevStepDirective, StepComponent, StepContentDirective };
 //# sourceMappingURL=matcha-components.mjs.map