@crodriguezdominguez/ion-intl-tel-input 2.0.0

package/esm2020/lib/ion-intl-tel-input/ion-intl-tel-input.component.mjs

@@ -0,0 +1,747 @@
+import { Component, Input, forwardRef, Output, EventEmitter, ViewChild, ElementRef, HostBinding, } from '@angular/core';
+import { NG_VALUE_ACCESSOR, } from '@angular/forms';
+import { IonInput, ModalController, Platform } from '@ionic/angular';
+import { PhoneNumberFormat, PhoneNumberUtil, } from 'google-libphonenumber';
+import { IonIntlTelInputService } from '../ion-intl-tel-input.service';
+import { raf } from '../util/util';
+import { IonIntTelCodeComponent } from './ion-intl-tel-code.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "../ion-intl-tel-input.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "../pipes/country-placeholder";
+/**
+ * @ignore
+ */
+/**
+ * @author Azzam Asghar <azzam.asghar@interstellus.com>
+ * @author Steve Drew <sdrew@waitwell.ca>
+ */
+export class IonIntlTelInputComponent {
+    get hasValueCssClass() {
+        return this.hasValue();
+    }
+    get isEnabled() {
+        return !this.disabled;
+    }
+    constructor(el, platform, ionIntlTelInputService, modalCtrl) {
+        this.el = el;
+        this.platform = platform;
+        this.ionIntlTelInputService = ionIntlTelInputService;
+        this.modalCtrl = modalCtrl;
+        this.cssClass = true;
+        /**
+         * autocomplete, set to 'tel' if needed
+         *
+         * @default 'off'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.autocomplete = 'off';
+        /**
+         * required, passed onto ion-input so we can be accessiblity compliant
+         *
+         * @default false
+         * @memberof IonIntlTelInputComponent
+         */
+        this.required = false;
+        /**
+         * Iso Code of default selected Country.
+         * See more on.
+         *
+         * @default ''
+         * @memberof IonIntlTelInputComponent
+         */
+        this.defaultCountryiso = '';
+        /**
+         * Determines whether to use `00` or `+` as dial code prefix.
+         * Available attributes are '+' | '00'.
+         * See more on.
+         *
+         * @default +
+         * @memberof IonIntlTelInputComponent
+         */
+        this.dialCodePrefix = '+';
+        /**
+         * Determines whether to select automatic country based on user input.
+         * See more on.
+         *
+         * @default true
+         * @memberof IonIntlTelInputComponent
+         */
+        this.enableAutoCountrySelect = true;
+        /**
+         * Determines whether an example number will be shown as a placeholder in input.
+         * See more on.
+         *
+         * @default true
+         * @memberof IonIntlTelInputComponent
+         */
+        this.enablePlaceholder = true;
+        /**
+         * A fallaback placeholder to be used if no example number is found for a country.
+         * See more on.
+         *
+         * @default ''
+         * @memberof IonIntlTelInputComponent
+         */
+        this.fallbackPlaceholder = '';
+        /**
+         * If a custom placeholder is needed for input.
+         * If this property is set it will override `enablePlaceholder` and only this placeholder will be shown.
+         * See more on.
+         *
+         * @default ''
+         * @memberof IonIntlTelInputComponent
+         */
+        this.inputPlaceholder = '';
+        /**
+         * Instead of an example phone number, use a x pattern. Such as xxx-xxx-xxxx, this will be obtained
+         * based on the example number from the google phone lib.
+         *
+         * @default true
+         * @memberof IonIntlTelInputComponent
+         */
+        this.usePatternPlaceholder = true;
+        /**
+         * Maximum Length for input.
+         * See more on.
+         *
+         * @default '15'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.maxLength = '15';
+        /**
+         * Title of modal opened to select country dial code.
+         * See more on.
+         *
+         * @default 'Select Country'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.modalTitle = 'Select Country';
+        /**
+         * CSS class to attach to dial code selectionmodal.
+         * See more on.
+         *
+         * @default 'ion-intl-tel-modal'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.modalCssClass = 'ion-intl-tel-modal';
+        /**
+         * Placeholder for input in dial code selection modal.
+         * See more on.
+         *
+         * @default 'Enter country name'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.modalSearchPlaceholder = 'Enter country name';
+        /**
+         * Text for close button in dial code selection modal.
+         * See more on.
+         *
+         * @default 'Close'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.modalCloseText = 'Close';
+        /**
+         * Slot for close button in dial code selection modal. [Ionic slots](https://ionicframework.com/docs/api/item) are supported
+         * See more on.
+         *
+         * @default 'end'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.modalCloseButtonSlot = 'end';
+        /**
+         * Determines whether dial code selection modal should be searchable or not.
+         * See more on.
+         *
+         * @default 'true'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.modalCanSearch = true;
+        /**
+         * Determines whether dial code selection modal is closed on backdrop click.
+         * See more on.
+         *
+         * @default 'true'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.modalShouldBackdropClose = true;
+        /**
+         * Determines whether input should be focused when dial code selection modal is opened.
+         * See more on.
+         *
+         * @default 'true'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.modalShouldFocusSearchbar = true;
+        /**
+         * Message to show when no countries are found for search in dial code selection modal.
+         * See more on.
+         *
+         * @default 'true'
+         * @memberof IonIntlTelInputComponent
+         */
+        this.modalSearchFailText = 'No countries found';
+        /**
+         * List of iso codes of manually selected countries as string, which will appear in the dropdown.
+         * **Note**: `onlyCountries` should be a string array of country iso codes.
+         * See more on.
+         *
+         * @default null
+         * @memberof IonIntlTelInputComponent
+         */
+        this.onlyCountries = [];
+        /**
+         * List of iso codesn as string of  countries, which will appear at the top in dial code selection modal.
+         * **Note**: `preferredCountries` should be a string array of country iso codes.
+         * See more on.
+         *
+         * @default null
+         * @memberof IonIntlTelInputComponent
+         */
+        this.preferredCountries = [];
+        /**
+         * Determines whether first country should be selected in dial code select or not.
+         * See more on.
+         *
+         * @default true
+         * @memberof IonIntlTelInputComponent
+         */
+        this.selectFirstCountry = true;
+        /**
+         * Determines whether to visually separate dialcode into the drop down element.
+         * See more on.
+         *
+         * @default true
+         * @memberof IonIntlTelInputComponent
+         */
+        this.separateDialCode = true;
+        /**
+         * Fires when the Phone number Input is changed.
+         * See more on.
+         *
+         * @memberof IonIntlTelInputComponent
+         */
+        this.numberChange = new EventEmitter();
+        /**
+         * Fires when the Phone number Input is blurred.
+         * See more on.
+         *
+         * @memberof IonIntlTelInputComponent
+         */
+        this.numberBlur = new EventEmitter();
+        /**
+         * Fires when the Phone number Input is focused.
+         * See more on.
+         *
+         * @memberof IonIntlTelInputComponent
+         */
+        this.numberFocus = new EventEmitter();
+        /**
+         * Fires when the user is typing in Phone number Input.
+         * See more on.
+         *
+         * @memberof IonIntlTelInputComponent
+         */
+        this.numberInput = new EventEmitter();
+        /**
+         * Fires when the dial code selection is changed.
+         * See more on.
+         *
+         * @memberof IonIntlTelInputComponent
+         */
+        this.codeChange = new EventEmitter();
+        /**
+         * Fires when the dial code selection modal is opened.
+         * See more on.
+         *
+         * @memberof IonIntlTelInputComponent
+         */
+        this.codeOpen = new EventEmitter();
+        /**
+         * Fires when the dial code selection modal is closed.
+         * See more on.
+         *
+         * @memberof IonIntlTelInputComponent
+         */
+        this.codeClose = new EventEmitter();
+        /**
+         * Fires when a dial code is selected in dial code selection modal.
+         * See more on.
+         *
+         * @memberof IonIntlTelInputComponent
+         */
+        this.codeSelect = new EventEmitter();
+        // tslint:disable-next-line: variable-name
+        this._value = null;
+        this.phoneNumber = '';
+        this.countries = [];
+        this.disabled = false;
+        this.phoneUtil = PhoneNumberUtil.getInstance();
+        this.onTouched = () => { };
+        this.propagateChange = (_) => { };
+        this.startsWith = (input, search) => {
+            return input.substr(0, search.length) === search;
+        };
+        this.getClasses = (element) => {
+            const classList = element.classList;
+            const classes = [];
+            for (let i = 0; i < classList.length; i++) {
+                const item = classList.item(i);
+                if (item !== null && this.startsWith(item, 'ng-')) {
+                    classes.push(`ion-${item.substr(3)}`);
+                }
+            }
+            return classes;
+        };
+        this.setClasses = (element, classes) => {
+            const classList = element.classList;
+            [
+                'ion-valid',
+                'ion-invalid',
+                'ion-touched',
+                'ion-untouched',
+                'ion-dirty',
+                'ion-pristine',
+            ].forEach((c) => classList.remove(c));
+            classes.forEach((c) => classList.add(c));
+        };
+        this.setIonicClasses = (element) => {
+            raf(() => {
+                const input = element.nativeElement;
+                const classes = this.getClasses(input);
+                this.setClasses(input, classes);
+                const item = input.closest('ion-item');
+                if (item) {
+                    this.setClasses(item, classes);
+                }
+            });
+        };
+        this.setItemClass = (element, className, addClass) => {
+            const input = element.nativeElement;
+            const item = input.closest('ion-item');
+            if (item) {
+                const classList = item.classList;
+                if (addClass) {
+                    classList.add(className);
+                }
+                else {
+                    classList.remove(className);
+                }
+            }
+        };
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+        this.setIonicClasses(this.el);
+    }
+    emitValueChange(change) {
+        this.propagateChange(change);
+    }
+    ngOnInit() {
+        this.isIos = this.platform.is('ios');
+        this.isMD = !this.isIos;
+        this.setItemClass(this.el, 'item-interactive', true);
+        this.fetchAllCountries();
+        this.setPreferredCountries();
+        if (this.onlyCountries.length) {
+            this.countries = this.countries.filter((country) => this.onlyCountries.includes(country.isoCode));
+        }
+        if (this.selectFirstCountry) {
+            if (this.defaultCountryiso) {
+                this.setCountry(this.getCountryByIsoCode(this.defaultCountryiso));
+            }
+            else {
+                if (this.preferredCountries.length &&
+                    this.preferredCountries.includes(this.defaultCountryiso)) {
+                    this.setCountry(this.getCountryByIsoCode(this.preferredCountries[0]));
+                }
+                else {
+                    this.setCountry(this.countries[0]);
+                }
+            }
+        }
+    }
+    ngOnChanges(changes) {
+        if (this.countries &&
+            changes.defaulyCountryisoCode &&
+            changes.defaulyCountryisoCode.currentValue !==
+                changes.defaulyCountryisoCode.previousValue) {
+            this.setCountry(changes.defaulyCountryisoCode.currentValue);
+        }
+    }
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    writeValue(obj) {
+        this.fillValues(obj);
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    fillValues(value) {
+        if (value && typeof value === 'string') {
+            let googleNumber;
+            try {
+                googleNumber = this.phoneUtil.parse(value, null);
+            }
+            catch (e) {
+            }
+            if (!googleNumber) {
+                // If failed to parse, try adding a +1 and see if valid
+                if (value.length >= 10 && value.indexOf('+') === -1) {
+                    const v = '+1' + value;
+                    googleNumber = this.phoneUtil.parse(v, null);
+                }
+            }
+            if (!googleNumber) {
+                console.log('Warning: failed to parse number: ', value);
+            }
+            if (googleNumber) {
+                let isoCode = googleNumber && googleNumber.getCountryCode()
+                    ? this.getCountryIsoCode(googleNumber.getCountryCode(), googleNumber)
+                    : this.country.isoCode;
+                if (isoCode && isoCode !== this.country.isoCode) {
+                    const newCountry = this.countries.find((country) => country.isoCode === isoCode);
+                    if (newCountry) {
+                        this.country = newCountry;
+                    }
+                }
+                isoCode = isoCode ? isoCode : this.country ? this.country.isoCode : null;
+                const internationallNo = this.phoneUtil.format(googleNumber, PhoneNumberFormat.INTERNATIONAL);
+                this.phoneNumber = this.removeDialCode(internationallNo);
+                this.value = internationallNo;
+            }
+            return;
+        }
+    }
+    hasValue() {
+        return !this.isNullOrWhiteSpace(this.value);
+    }
+    onCodeOpen() {
+        this.codeOpen.emit();
+    }
+    async openModal() {
+        const modal = await this.modalCtrl.create({
+            component: IonIntTelCodeComponent,
+            cssClass: this.modalCssClass,
+            backdropDismiss: this.modalShouldBackdropClose,
+            componentProps: {
+                country: this.country,
+                canSearch: this.modalCanSearch,
+                closeButtonText: this.modalCloseText,
+                closeButtonSlot: this.modalCloseButtonSlot,
+                countries: this.countries,
+                title: this.modalTitle,
+                searchFailText: this.modalSearchFailText,
+                searchPlaceholder: this.modalSearchPlaceholder,
+                shouldFocusSearchbar: this.modalShouldFocusSearchbar,
+                dialCode: this.separateDialCode ? this.dialCodePrefix : null
+            }
+        });
+        await modal.present();
+        modal.onDidDismiss().then(data => {
+            if (data.data) {
+                this.country = data.data;
+                this.onCodeChange();
+            }
+        });
+    }
+    onCodeChange() {
+        if (this.isNullOrWhiteSpace(this.phoneNumber)) {
+            this.emitValueChange(null);
+        }
+        else {
+            let googleNumber;
+            try {
+                googleNumber = this.phoneUtil.parse(this.phoneNumber, this.country.isoCode.toUpperCase());
+            }
+            catch (e) { }
+            const internationallNo = googleNumber
+                ? this.phoneUtil.format(googleNumber, PhoneNumberFormat.INTERNATIONAL)
+                : '';
+            const nationalNo = googleNumber
+                ? this.phoneUtil.format(googleNumber, PhoneNumberFormat.NATIONAL)
+                : '';
+            if (this.separateDialCode && internationallNo) {
+                this.phoneNumber = this.removeDialCode(internationallNo);
+            }
+            this.emitValueChange(internationallNo);
+            this.codeChange.emit();
+        }
+        setTimeout(() => {
+            this.numberInputEl.setFocus();
+        }, 400);
+    }
+    onCodeClose() {
+        this.onTouched();
+        this.setIonicClasses(this.el);
+        this.hasFocus = false;
+        this.setItemClass(this.el, 'item-has-focus', false);
+        this.codeClose.emit();
+    }
+    onCodeSelect() {
+        this.codeSelect.emit();
+    }
+    onIonNumberChange(event) {
+        this.setIonicClasses(this.el);
+        this.numberChange.emit(event);
+    }
+    onIonNumberBlur() {
+        this.onTouched();
+        this.setIonicClasses(this.el);
+        this.hasFocus = false;
+        this.setItemClass(this.el, 'item-has-focus', false);
+        this.numberBlur.emit();
+    }
+    onIonNumberFocus() {
+        this.hasFocus = true;
+        this.setItemClass(this.el, 'item-has-focus', true);
+        this.numberFocus.emit();
+    }
+    onIonNumberInput(event) {
+        this.numberInput.emit(event);
+    }
+    // called via (ngModelChange)
+    onNumberChange() {
+        if (!this.phoneNumber) {
+            this.value = null;
+            this.emitValueChange(null);
+            return;
+        }
+        if (this.country) {
+            this.emitValueChange(this.dialCodePrefix + this.country.dialCode + ' ' + this.phoneNumber);
+        }
+        let googleNumber;
+        try {
+            googleNumber = this.phoneUtil.parse(this.phoneNumber, this.country.isoCode.toUpperCase());
+        }
+        catch (e) {
+            return;
+        }
+        let isoCode = this.country ? this.country.isoCode : null;
+        // auto select country based on the extension (and areaCode if needed) (e.g select Canada if number starts with +1 416)
+        if (this.enableAutoCountrySelect) {
+            isoCode =
+                googleNumber && googleNumber.getCountryCode()
+                    ? this.getCountryIsoCode(googleNumber.getCountryCode(), googleNumber)
+                    : this.country.isoCode;
+            if (isoCode && isoCode !== this.country.isoCode) {
+                const newCountry = this.countries.find((country) => country.isoCode === isoCode);
+                if (newCountry) {
+                    this.country = newCountry;
+                }
+            }
+        }
+        isoCode = isoCode ? isoCode : this.country ? this.country.isoCode : null;
+        if (!this.phoneNumber || !isoCode) {
+            this.emitValueChange(null);
+        }
+        else {
+            const internationallNo = googleNumber
+                ? this.phoneUtil.format(googleNumber, PhoneNumberFormat.INTERNATIONAL)
+                : '';
+            const nationalNo = googleNumber
+                ? this.phoneUtil.format(googleNumber, PhoneNumberFormat.NATIONAL)
+                : '';
+            if (this.separateDialCode && internationallNo) {
+                this.phoneNumber = this.removeDialCode(internationallNo);
+            }
+            this.emitValueChange(internationallNo);
+        }
+    }
+    onNumberKeyDown(event) {
+        const allowedChars = /^[0-9\+\-\ ]/;
+        const allowedCtrlChars = /[axcv]/;
+        const allowedOtherKeys = [
+            'ArrowLeft',
+            'ArrowUp',
+            'ArrowRight',
+            'ArrowDown',
+            'Home',
+            'End',
+            'Insert',
+            'Delete',
+            'Backspace',
+            'Tab',
+        ];
+        const isCtrlKey = event.ctrlKey || event.metaKey;
+        if (!allowedChars.test(event.key) &&
+            !(isCtrlKey && allowedCtrlChars.test(event.key)) &&
+            !allowedOtherKeys.includes(event.key)) {
+            event.preventDefault();
+        }
+    }
+    filterCountries(text) {
+        return this.countries.filter((country) => {
+            return (country.name.toLowerCase().indexOf(text) !== -1 ||
+                country.name.toLowerCase().indexOf(text) !== -1 ||
+                country.dialCode.toString().toLowerCase().indexOf(text) !== -1);
+        });
+    }
+    getCountryIsoCode(countryCode, googleNumber) {
+        const rawNumber = googleNumber.values_[2].toString();
+        const countries = this.countries.filter((country) => country.dialCode === countryCode.toString());
+        const mainCountry = countries.find((country) => country.areaCodes === undefined);
+        const secondaryCountries = countries.filter((country) => country.areaCodes !== undefined);
+        let matchedCountry = mainCountry ? mainCountry.isoCode : undefined;
+        secondaryCountries.forEach((country) => {
+            country.areaCodes.forEach((areaCode) => {
+                if (rawNumber.startsWith(areaCode)) {
+                    matchedCountry = country.isoCode;
+                }
+            });
+        });
+        return matchedCountry;
+    }
+    fetchAllCountries() {
+        this.countries = this.ionIntlTelInputService.getListOfCountries();
+    }
+    getCountryByIsoCode(isoCode) {
+        for (const country of this.countries) {
+            if (country.isoCode === isoCode) {
+                return country;
+            }
+        }
+        console.error('tel: unknown country iso code: ', isoCode);
+        return;
+    }
+    isNullOrWhiteSpace(value) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        if (typeof value === 'string' && value === '') {
+            return true;
+        }
+        return typeof value === 'object' && Object.keys(value).length === 0;
+    }
+    removeDialCode(phoneNumber) {
+        if (this.separateDialCode && phoneNumber) {
+            phoneNumber = phoneNumber.substr(phoneNumber.indexOf(' ') + 1);
+        }
+        return phoneNumber;
+    }
+    setCountry(country) {
+        this.country = country;
+        this.codeChange.emit(this.country);
+    }
+    setPreferredCountries() {
+        for (const preferedCountryIsoCode of this.preferredCountries) {
+            const country = this.getCountryByIsoCode(preferedCountryIsoCode);
+            country.priority = country ? 1 : country.priority;
+        }
+        this.countries.sort((a, b) => a.priority > b.priority ? -1 : a.priority < b.priority ? 1 : 0);
+    }
+}
+/** @nocollapse */ IonIntlTelInputComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IonIntlTelInputComponent, deps: [{ token: i0.ElementRef }, { token: i1.Platform }, { token: i2.IonIntlTelInputService }, { token: i1.ModalController }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ IonIntlTelInputComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: IonIntlTelInputComponent, selector: "ion-intl-tel-input", inputs: { isEnabled: "isEnabled", autocomplete: "autocomplete", required: "required", defaultCountryiso: "defaultCountryiso", dialCodePrefix: "dialCodePrefix", enableAutoCountrySelect: "enableAutoCountrySelect", enablePlaceholder: "enablePlaceholder", fallbackPlaceholder: "fallbackPlaceholder", inputPlaceholder: "inputPlaceholder", usePatternPlaceholder: "usePatternPlaceholder", maxLength: "maxLength", modalTitle: "modalTitle", modalCssClass: "modalCssClass", modalSearchPlaceholder: "modalSearchPlaceholder", modalCloseText: "modalCloseText", modalCloseButtonSlot: "modalCloseButtonSlot", modalCanSearch: "modalCanSearch", modalShouldBackdropClose: "modalShouldBackdropClose", modalShouldFocusSearchbar: "modalShouldFocusSearchbar", modalSearchFailText: "modalSearchFailText", onlyCountries: "onlyCountries", preferredCountries: "preferredCountries", selectFirstCountry: "selectFirstCountry", separateDialCode: "separateDialCode" }, outputs: { numberChange: "numberChange", numberBlur: "numberBlur", numberFocus: "numberFocus", numberInput: "numberInput", codeChange: "codeChange", codeOpen: "codeOpen", codeClose: "codeClose", codeSelect: "codeSelect" }, host: { properties: { "class.ion-intl-tel-input": "this.cssClass", "class.ion-intl-tel-input-ios": "this.isIos", "class.ion-intl-tel-input-md": "this.isMD", "class.has-focus": "this.hasFocus", "class.ion-intl-tel-input-has-value": "this.hasValueCssClass", "class.ion-intl-tel-input-is-enabled": "this.isEnabled" } }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef((() => IonIntlTelInputComponent)),
+            multi: true,
+        },
+    ], viewQueries: [{ propertyName: "numberInputEl", first: true, predicate: ["numberInput"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<ion-button\n        fill=\"clear\"\n        class=\"ion-intl-tel-input-btn\"\n        [disabled] = \"disabled\"\n        aria-label=\"country\"\n        (click)=\"openModal()\"\n>\n  <span class=\"ion-intl-tel-input-flag fi fi-{{country.flagClass}}\"></span><span class=\"ion-intl-tel-input-code\" *ngIf=\"separateDialCode\">{{dialCodePrefix}}{{country.dialCode}}</span>\n  <ion-icon style=\"font-size:14px;opacity:.5;\" name=\"caret-down\"></ion-icon>\n</ion-button>\n<div class=\"ion-intl-tel-input-number\">\n  <ion-input\n          #numberInput\n          [(ngModel)]=\"phoneNumber\"\n          [autocomplete]=\"autocomplete\"\n          [required]=\"required\"\n          [disabled] = \"disabled\"\n          [attr.maxLength]=\"maxLength\"\n          type=\"tel\"\n          (ionBlur)=\"onIonNumberBlur()\"\n          (ionChange)=\"onIonNumberChange($event)\"\n          (ionFocus)=\"onIonNumberFocus()\"\n          (ionInput)=\"onIonNumberInput($event)\"\n          (keydown)=\"onNumberKeyDown($event)\"\n          (ngModelChange)=\"onNumberChange()\"\n          placeholder=\"{{country | countryPlaceholder: inputPlaceholder:separateDialCode:fallbackPlaceholder:usePatternPlaceholder}}\" >\n  </ion-input>\n</div>\n", styles: [":host{width:100%;display:flex;align-items:center}:host ion-button{color:var(--ion-color);height:100%;margin:0}:host ion-button::part(native){padding-inline-start:0;padding-inline-end:2px;margin:0;font-size:16px;font-weight:400}:host .fi{margin-right:5px}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i1.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: i1.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: i1.IonInput, selector: "ion-input", inputs: ["accept", "autocapitalize", "autocomplete", "autocorrect", "autofocus", "clearInput", "clearOnEdit", "color", "counter", "counterFormatter", "debounce", "disabled", "enterkeyhint", "errorText", "fill", "helperText", "inputmode", "label", "labelPlacement", "legacy", "max", "maxlength", "min", "minlength", "mode", "multiple", "name", "pattern", "placeholder", "readonly", "required", "shape", "size", "spellcheck", "step", "type", "value"] }, { kind: "directive", type: i1.TextValueAccessor, selector: "ion-input:not([type=number]),ion-textarea,ion-searchbar" }, { kind: "pipe", type: i5.CountryPlaceholder, name: "countryPlaceholder" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IonIntlTelInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ion-intl-tel-input', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => IonIntlTelInputComponent)),
+                            multi: true,
+                        },
+                    ], template: "<ion-button\n        fill=\"clear\"\n        class=\"ion-intl-tel-input-btn\"\n        [disabled] = \"disabled\"\n        aria-label=\"country\"\n        (click)=\"openModal()\"\n>\n  <span class=\"ion-intl-tel-input-flag fi fi-{{country.flagClass}}\"></span><span class=\"ion-intl-tel-input-code\" *ngIf=\"separateDialCode\">{{dialCodePrefix}}{{country.dialCode}}</span>\n  <ion-icon style=\"font-size:14px;opacity:.5;\" name=\"caret-down\"></ion-icon>\n</ion-button>\n<div class=\"ion-intl-tel-input-number\">\n  <ion-input\n          #numberInput\n          [(ngModel)]=\"phoneNumber\"\n          [autocomplete]=\"autocomplete\"\n          [required]=\"required\"\n          [disabled] = \"disabled\"\n          [attr.maxLength]=\"maxLength\"\n          type=\"tel\"\n          (ionBlur)=\"onIonNumberBlur()\"\n          (ionChange)=\"onIonNumberChange($event)\"\n          (ionFocus)=\"onIonNumberFocus()\"\n          (ionInput)=\"onIonNumberInput($event)\"\n          (keydown)=\"onNumberKeyDown($event)\"\n          (ngModelChange)=\"onNumberChange()\"\n          placeholder=\"{{country | countryPlaceholder: inputPlaceholder:separateDialCode:fallbackPlaceholder:usePatternPlaceholder}}\" >\n  </ion-input>\n</div>\n", styles: [":host{width:100%;display:flex;align-items:center}:host ion-button{color:var(--ion-color);height:100%;margin:0}:host ion-button::part(native){padding-inline-start:0;padding-inline-end:2px;margin:0;font-size:16px;font-weight:400}:host .fi{margin-right:5px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Platform }, { type: i2.IonIntlTelInputService }, { type: i1.ModalController }]; }, propDecorators: { cssClass: [{
+                type: HostBinding,
+                args: ['class.ion-intl-tel-input']
+            }], isIos: [{
+                type: HostBinding,
+                args: ['class.ion-intl-tel-input-ios']
+            }], isMD: [{
+                type: HostBinding,
+                args: ['class.ion-intl-tel-input-md']
+            }], hasFocus: [{
+                type: HostBinding,
+                args: ['class.has-focus']
+            }], hasValueCssClass: [{
+                type: HostBinding,
+                args: ['class.ion-intl-tel-input-has-value']
+            }], isEnabled: [{
+                type: HostBinding,
+                args: ['class.ion-intl-tel-input-is-enabled']
+            }, {
+                type: Input,
+                args: ['isEnabled']
+            }], autocomplete: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], defaultCountryiso: [{
+                type: Input
+            }], dialCodePrefix: [{
+                type: Input
+            }], enableAutoCountrySelect: [{
+                type: Input
+            }], enablePlaceholder: [{
+                type: Input
+            }], fallbackPlaceholder: [{
+                type: Input
+            }], inputPlaceholder: [{
+                type: Input
+            }], usePatternPlaceholder: [{
+                type: Input
+            }], maxLength: [{
+                type: Input
+            }], modalTitle: [{
+                type: Input
+            }], modalCssClass: [{
+                type: Input
+            }], modalSearchPlaceholder: [{
+                type: Input
+            }], modalCloseText: [{
+                type: Input
+            }], modalCloseButtonSlot: [{
+                type: Input
+            }], modalCanSearch: [{
+                type: Input
+            }], modalShouldBackdropClose: [{
+                type: Input
+            }], modalShouldFocusSearchbar: [{
+                type: Input
+            }], modalSearchFailText: [{
+                type: Input
+            }], onlyCountries: [{
+                type: Input
+            }], preferredCountries: [{
+                type: Input
+            }], selectFirstCountry: [{
+                type: Input
+            }], separateDialCode: [{
+                type: Input
+            }], numberChange: [{
+                type: Output
+            }], numberBlur: [{
+                type: Output
+            }], numberFocus: [{
+                type: Output
+            }], numberInput: [{
+                type: Output
+            }], codeChange: [{
+                type: Output
+            }], codeOpen: [{
+                type: Output
+            }], codeClose: [{
+                type: Output
+            }], codeSelect: [{
+                type: Output
+            }], numberInputEl: [{
+                type: ViewChild,
+                args: ['numberInput', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ion-intl-tel-input.component.js","sourceRoot":"","sources":["../../../../../projects/ion-intl-tel-input/src/lib/ion-intl-tel-input/ion-intl-tel-input.component.ts","../../../../../projects/ion-intl-tel-input/src/lib/ion-intl-tel-input/ion-intl-tel-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  OnInit,\n  Input,\n  forwardRef,\n  Output,\n  EventEmitter,\n  OnChanges,\n  SimpleChanges,\n  ViewChild,\n  ElementRef,\n  HostBinding,\n} from '@angular/core';\n\nimport {\n  NG_VALUE_ACCESSOR,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n} from '@angular/forms';\n\nimport { IonInput, ModalController, Platform } from '@ionic/angular';\n\nimport {\n  PhoneNumber,\n  PhoneNumberFormat,\n  PhoneNumberUtil,\n} from 'google-libphonenumber';\n\nimport { CountryI } from '../models/country.model';\n\nimport { IonIntlTelInputService } from '../ion-intl-tel-input.service';\nimport { raf } from '../util/util';\nimport { IonIntTelCodeComponent } from './ion-intl-tel-code.component';\n\n/**\n * @ignore\n */\n@Component({\n  // tslint:disable-next-line: component-selector\n  selector: 'ion-intl-tel-input',\n  templateUrl: './ion-intl-tel-input.component.html',\n  styleUrls: ['./ion-intl-tel-input.component.scss'],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => IonIntlTelInputComponent),\n      multi: true,\n    },\n  ],\n})\n\n/**\n * @author Azzam Asghar <azzam.asghar@interstellus.com>\n * @author Steve Drew <sdrew@waitwell.ca>\n */\nexport class IonIntlTelInputComponent\n    implements ControlValueAccessor, OnInit, OnChanges {\n  @HostBinding('class.ion-intl-tel-input')\n  cssClass = true;\n  @HostBinding('class.ion-intl-tel-input-ios')\n  isIos: boolean;\n  @HostBinding('class.ion-intl-tel-input-md')\n  isMD: boolean;\n  @HostBinding('class.has-focus')\n  hasFocus;\n  @HostBinding('class.ion-intl-tel-input-has-value')\n  get hasValueCssClass(): boolean {\n    return this.hasValue();\n  }\n  @HostBinding('class.ion-intl-tel-input-is-enabled')\n  @Input('isEnabled')\n  get isEnabled(): boolean {\n    return !this.disabled;\n  }\n\n  /**\n   * autocomplete, set to 'tel' if needed\n   *\n   * @default 'off'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  autocomplete = 'off';\n\n  /**\n   * required, passed onto ion-input so we can be accessiblity compliant\n   *\n   * @default false\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  required = false;\n\n  /**\n   * Iso Code of default selected Country.\n   * See more on.\n   *\n   * @default ''\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  defaultCountryiso = '';\n\n  /**\n   * Determines whether to use `00` or `+` as dial code prefix.\n   * Available attributes are '+' | '00'.\n   * See more on.\n   *\n   * @default +\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  dialCodePrefix: '+' | '00' = '+';\n\n  /**\n   * Determines whether to select automatic country based on user input.\n   * See more on.\n   *\n   * @default true\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  enableAutoCountrySelect = true;\n\n  /**\n   * Determines whether an example number will be shown as a placeholder in input.\n   * See more on.\n   *\n   * @default true\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  enablePlaceholder = true;\n\n  /**\n   * A fallaback placeholder to be used if no example number is found for a country.\n   * See more on.\n   *\n   * @default ''\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  fallbackPlaceholder = '';\n\n  /**\n   * If a custom placeholder is needed for input.\n   * If this property is set it will override `enablePlaceholder` and only this placeholder will be shown.\n   * See more on.\n   *\n   * @default ''\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  inputPlaceholder = '';\n\n  /**\n   * Instead of an example phone number, use a x pattern. Such as xxx-xxx-xxxx, this will be obtained\n   * based on the example number from the google phone lib.\n   *\n   * @default true\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  usePatternPlaceholder = true;\n\n  /**\n   * Maximum Length for input.\n   * See more on.\n   *\n   * @default '15'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  maxLength = '15';\n\n  /**\n   * Title of modal opened to select country dial code.\n   * See more on.\n   *\n   * @default 'Select Country'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  modalTitle = 'Select Country';\n\n  /**\n   * CSS class to attach to dial code selectionmodal.\n   * See more on.\n   *\n   * @default 'ion-intl-tel-modal'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  modalCssClass = 'ion-intl-tel-modal';\n\n  /**\n   * Placeholder for input in dial code selection modal.\n   * See more on.\n   *\n   * @default 'Enter country name'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  modalSearchPlaceholder = 'Enter country name';\n\n  /**\n   * Text for close button in dial code selection modal.\n   * See more on.\n   *\n   * @default 'Close'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  modalCloseText = 'Close';\n\n  /**\n   * Slot for close button in dial code selection modal. [Ionic slots](https://ionicframework.com/docs/api/item) are supported\n   * See more on.\n   *\n   * @default 'end'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  modalCloseButtonSlot: 'start' | 'end' | 'primary' | 'secondary' = 'end';\n\n  /**\n   * Determines whether dial code selection modal should be searchable or not.\n   * See more on.\n   *\n   * @default 'true'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  modalCanSearch = true;\n\n  /**\n   * Determines whether dial code selection modal is closed on backdrop click.\n   * See more on.\n   *\n   * @default 'true'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  modalShouldBackdropClose = true;\n\n  /**\n   * Determines whether input should be focused when dial code selection modal is opened.\n   * See more on.\n   *\n   * @default 'true'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  modalShouldFocusSearchbar = true;\n\n  /**\n   * Message to show when no countries are found for search in dial code selection modal.\n   * See more on.\n   *\n   * @default 'true'\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  modalSearchFailText = 'No countries found';\n\n  /**\n   * List of iso codes of manually selected countries as string, which will appear in the dropdown.\n   * **Note**: `onlyCountries` should be a string array of country iso codes.\n   * See more on.\n   *\n   * @default null\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  onlyCountries: Array<string> = [];\n\n  /**\n   * List of iso codesn as string of  countries, which will appear at the top in dial code selection modal.\n   * **Note**: `preferredCountries` should be a string array of country iso codes.\n   * See more on.\n   *\n   * @default null\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  preferredCountries: Array<string> = [];\n\n  /**\n   * Determines whether first country should be selected in dial code select or not.\n   * See more on.\n   *\n   * @default true\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  selectFirstCountry = true;\n\n  /**\n   * Determines whether to visually separate dialcode into the drop down element.\n   * See more on.\n   *\n   * @default true\n   * @memberof IonIntlTelInputComponent\n   */\n  @Input()\n  separateDialCode = true;\n\n  /**\n   * Fires when the Phone number Input is changed.\n   * See more on.\n   *\n   * @memberof IonIntlTelInputComponent\n   */\n  @Output()\n  readonly numberChange = new EventEmitter<Event>();\n\n  /**\n   * Fires when the Phone number Input is blurred.\n   * See more on.\n   *\n   * @memberof IonIntlTelInputComponent\n   */\n  @Output()\n  readonly numberBlur = new EventEmitter<void>();\n\n  /**\n   * Fires when the Phone number Input is focused.\n   * See more on.\n   *\n   * @memberof IonIntlTelInputComponent\n   */\n  @Output()\n  readonly numberFocus = new EventEmitter<void>();\n\n  /**\n   * Fires when the user is typing in Phone number Input.\n   * See more on.\n   *\n   * @memberof IonIntlTelInputComponent\n   */\n  @Output()\n  readonly numberInput = new EventEmitter<KeyboardEvent>();\n\n  /**\n   * Fires when the dial code selection is changed.\n   * See more on.\n   *\n   * @memberof IonIntlTelInputComponent\n   */\n  @Output()\n  readonly codeChange = new EventEmitter<any>();\n\n  /**\n   * Fires when the dial code selection modal is opened.\n   * See more on.\n   *\n   * @memberof IonIntlTelInputComponent\n   */\n  @Output()\n  readonly codeOpen = new EventEmitter<any>();\n\n  /**\n   * Fires when the dial code selection modal is closed.\n   * See more on.\n   *\n   * @memberof IonIntlTelInputComponent\n   */\n  @Output()\n  readonly codeClose = new EventEmitter<any>();\n\n  /**\n   * Fires when a dial code is selected in dial code selection modal.\n   * See more on.\n   *\n   * @memberof IonIntlTelInputComponent\n   */\n  @Output()\n  readonly codeSelect = new EventEmitter<any>();\n\n  @ViewChild('numberInput', { static: false }) numberInputEl: IonInput;\n\n  // tslint:disable-next-line: variable-name\n  private _value: string = null;\n\n  country: CountryI;\n  phoneNumber = '';\n  countries: CountryI[] = [];\n  disabled = false;\n  phoneUtil: any = PhoneNumberUtil.getInstance();\n\n  onTouched: () => void = () => { };\n  propagateChange = (_: string | null) => { };\n\n  constructor(\n      private el: ElementRef,\n      private platform: Platform,\n      private ionIntlTelInputService: IonIntlTelInputService,\n      private modalCtrl: ModalController\n  ) { }\n\n  get value(): string | null {\n    return this._value;\n  }\n\n  set value(value: string | null) {\n    this._value = value;\n    this.setIonicClasses(this.el);\n  }\n\n  emitValueChange(change: string | null) {\n    this.propagateChange(change);\n  }\n\n  ngOnInit() {\n    this.isIos = this.platform.is('ios');\n    this.isMD = !this.isIos;\n    this.setItemClass(this.el, 'item-interactive', true);\n\n    this.fetchAllCountries();\n    this.setPreferredCountries();\n\n    if (this.onlyCountries.length) {\n      this.countries = this.countries.filter((country: CountryI) =>\n          this.onlyCountries.includes(country.isoCode)\n      );\n    }\n\n    if (this.selectFirstCountry) {\n      if (this.defaultCountryiso) {\n        this.setCountry(this.getCountryByIsoCode(this.defaultCountryiso));\n      } else {\n        if (\n            this.preferredCountries.length &&\n            this.preferredCountries.includes(this.defaultCountryiso)\n        ) {\n          this.setCountry(this.getCountryByIsoCode(this.preferredCountries[0]));\n        } else {\n          this.setCountry(this.countries[0]);\n        }\n      }\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (\n        this.countries &&\n        changes.defaulyCountryisoCode &&\n        changes.defaulyCountryisoCode.currentValue !==\n        changes.defaulyCountryisoCode.previousValue\n    ) {\n      this.setCountry(changes.defaulyCountryisoCode.currentValue);\n    }\n  }\n\n  registerOnChange(fn: any): void {\n    this.propagateChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  writeValue(obj: string): void {\n    this.fillValues(obj);\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  fillValues(value: string) {\n    if (value && typeof value === 'string') {\n      let googleNumber: PhoneNumber;\n      try {\n        googleNumber = this.phoneUtil.parse(value, null);\n      } catch (e) {\n      }\n      if (!googleNumber) {\n        // If failed to parse, try adding a +1 and see if valid\n        if (value.length >= 10 && value.indexOf('+') === -1) {\n          const v = '+1' + value;\n          googleNumber = this.phoneUtil.parse(v, null);\n        }\n      }\n      if (!googleNumber) {\n        console.log('Warning: failed to parse number: ', value);\n      }\n      if (googleNumber) {\n        let isoCode = googleNumber && googleNumber.getCountryCode()\n            ? this.getCountryIsoCode(googleNumber.getCountryCode(), googleNumber)\n            : this.country.isoCode;\n        if (isoCode && isoCode !== this.country.isoCode) {\n          const newCountry = this.countries.find(\n              (country: CountryI) => country.isoCode === isoCode\n          );\n          if (newCountry) {\n            this.country = newCountry;\n          }\n        }\n        isoCode = isoCode ? isoCode : this.country ? this.country.isoCode : null;\n\n        const internationallNo = this.phoneUtil.format(googleNumber, PhoneNumberFormat.INTERNATIONAL);\n        this.phoneNumber = this.removeDialCode(internationallNo);\n        this.value = internationallNo;\n      }\n      return;\n    }\n  }\n\n  hasValue(): boolean {\n    return !this.isNullOrWhiteSpace(this.value);\n  }\n\n  onCodeOpen() {\n    this.codeOpen.emit();\n  }\n\n  async openModal() {\n\n    const modal = await this.modalCtrl.create({\n      component: IonIntTelCodeComponent,\n      cssClass: this.modalCssClass,\n      backdropDismiss: this.modalShouldBackdropClose,\n      componentProps: {\n        country: this.country,\n        canSearch: this.modalCanSearch,\n        closeButtonText: this.modalCloseText,\n        closeButtonSlot: this.modalCloseButtonSlot,\n        countries: this.countries,\n        title: this.modalTitle,\n        searchFailText: this.modalSearchFailText,\n        searchPlaceholder: this.modalSearchPlaceholder,\n        shouldFocusSearchbar: this.modalShouldFocusSearchbar,\n        dialCode: this.separateDialCode ? this.dialCodePrefix : null\n      }\n    });\n    await modal.present();\n    modal.onDidDismiss().then(data => {\n      if (data.data) {\n        this.country = data.data;\n        this.onCodeChange();\n      }\n    });\n\n  }\n\n  onCodeChange(): void {\n    if (this.isNullOrWhiteSpace(this.phoneNumber)) {\n      this.emitValueChange(null);\n    } else {\n      let googleNumber: PhoneNumber;\n      try {\n        googleNumber = this.phoneUtil.parse(\n            this.phoneNumber,\n            this.country.isoCode.toUpperCase()\n        );\n      } catch (e) { }\n\n      const internationallNo = googleNumber\n          ? this.phoneUtil.format(googleNumber, PhoneNumberFormat.INTERNATIONAL)\n          : '';\n      const nationalNo = googleNumber\n          ? this.phoneUtil.format(googleNumber, PhoneNumberFormat.NATIONAL)\n          : '';\n\n      if (this.separateDialCode && internationallNo) {\n        this.phoneNumber = this.removeDialCode(internationallNo);\n      }\n      this.emitValueChange(internationallNo);\n\n      this.codeChange.emit();\n    }\n    setTimeout(() => {\n      this.numberInputEl.setFocus();\n    }, 400);\n  }\n\n  onCodeClose() {\n    this.onTouched();\n    this.setIonicClasses(this.el);\n    this.hasFocus = false;\n    this.setItemClass(this.el, 'item-has-focus', false);\n    this.codeClose.emit();\n  }\n\n  onCodeSelect() {\n    this.codeSelect.emit();\n  }\n\n  onIonNumberChange(event: Event) {\n    this.setIonicClasses(this.el);\n    this.numberChange.emit(event);\n  }\n\n  onIonNumberBlur() {\n    this.onTouched();\n    this.setIonicClasses(this.el);\n    this.hasFocus = false;\n    this.setItemClass(this.el, 'item-has-focus', false);\n    this.numberBlur.emit();\n  }\n\n  onIonNumberFocus() {\n    this.hasFocus = true;\n    this.setItemClass(this.el, 'item-has-focus', true);\n    this.numberFocus.emit();\n  }\n\n  onIonNumberInput(event: KeyboardEvent) {\n    this.numberInput.emit(event);\n  }\n\n  // called via (ngModelChange)\n  onNumberChange(): void {\n    if (!this.phoneNumber) {\n      this.value = null;\n      this.emitValueChange(null);\n      return;\n    }\n    if (this.country) {\n      this.emitValueChange(this.dialCodePrefix + this.country.dialCode + ' ' + this.phoneNumber);\n    }\n    let googleNumber: PhoneNumber;\n    try {\n      googleNumber = this.phoneUtil.parse(\n          this.phoneNumber,\n          this.country.isoCode.toUpperCase()\n      );\n    } catch (e) {\n      return;\n    }\n\n    let isoCode = this.country ? this.country.isoCode : null;\n    // auto select country based on the extension (and areaCode if needed) (e.g select Canada if number starts with +1 416)\n    if (this.enableAutoCountrySelect) {\n      isoCode =\n          googleNumber && googleNumber.getCountryCode()\n              ? this.getCountryIsoCode(googleNumber.getCountryCode(), googleNumber)\n              : this.country.isoCode;\n      if (isoCode && isoCode !== this.country.isoCode) {\n        const newCountry = this.countries.find(\n            (country: CountryI) => country.isoCode === isoCode\n        );\n        if (newCountry) {\n          this.country = newCountry;\n        }\n      }\n    }\n    isoCode = isoCode ? isoCode : this.country ? this.country.isoCode : null;\n\n    if (!this.phoneNumber || !isoCode) {\n      this.emitValueChange(null);\n    } else {\n      const internationallNo = googleNumber\n          ? this.phoneUtil.format(googleNumber, PhoneNumberFormat.INTERNATIONAL)\n          : '';\n      const nationalNo = googleNumber\n          ? this.phoneUtil.format(googleNumber, PhoneNumberFormat.NATIONAL)\n          : '';\n\n      if (this.separateDialCode && internationallNo) {\n        this.phoneNumber = this.removeDialCode(internationallNo);\n      }\n\n      this.emitValueChange(internationallNo);\n    }\n  }\n\n  onNumberKeyDown(event: KeyboardEvent) {\n    const allowedChars = /^[0-9\\+\\-\\ ]/;\n    const allowedCtrlChars = /[axcv]/;\n    const allowedOtherKeys = [\n      'ArrowLeft',\n      'ArrowUp',\n      'ArrowRight',\n      'ArrowDown',\n      'Home',\n      'End',\n      'Insert',\n      'Delete',\n      'Backspace',\n      'Tab',\n    ];\n    const isCtrlKey = event.ctrlKey || event.metaKey;\n\n    if (\n        !allowedChars.test(event.key) &&\n        !(isCtrlKey && allowedCtrlChars.test(event.key)) &&\n        !allowedOtherKeys.includes(event.key)\n    ) {\n      event.preventDefault();\n    }\n  }\n\n  private filterCountries(text: string): CountryI[] {\n    return this.countries.filter((country) => {\n      return (\n          country.name.toLowerCase().indexOf(text) !== -1 ||\n          country.name.toLowerCase().indexOf(text) !== -1 ||\n          country.dialCode.toString().toLowerCase().indexOf(text) !== -1\n      );\n    });\n  }\n\n  private getCountryIsoCode(\n      countryCode: number,\n      googleNumber: PhoneNumber\n  ): string | undefined {\n    const rawNumber = (googleNumber as any).values_[2].toString();\n\n    const countries = this.countries.filter(\n        (country: CountryI) => country.dialCode === countryCode.toString()\n    );\n    const mainCountry = countries.find(\n        (country: CountryI) => country.areaCodes === undefined\n    );\n    const secondaryCountries = countries.filter(\n        (country: CountryI) => country.areaCodes !== undefined\n    );\n\n    let matchedCountry = mainCountry ? mainCountry.isoCode : undefined;\n\n    secondaryCountries.forEach((country) => {\n      country.areaCodes.forEach((areaCode) => {\n        if (rawNumber.startsWith(areaCode)) {\n          matchedCountry = country.isoCode;\n        }\n      });\n    });\n    return matchedCountry;\n  }\n\n  private fetchAllCountries() {\n    this.countries = this.ionIntlTelInputService.getListOfCountries();\n  }\n\n  private getCountryByIsoCode(isoCode: string): CountryI {\n    for (const country of this.countries) {\n      if (country.isoCode === isoCode) {\n        return country;\n      }\n    }\n    console.error('tel: unknown country iso code: ', isoCode);\n    return;\n  }\n\n  private isNullOrWhiteSpace(value: any): boolean {\n    if (value === null || value === undefined) {\n      return true;\n    }\n    if (typeof value === 'string' && value === '') {\n      return true;\n    }\n    return typeof value === 'object' && Object.keys(value).length === 0;\n  }\n\n  private removeDialCode(phoneNumber: string): string {\n    if (this.separateDialCode && phoneNumber) {\n      phoneNumber = phoneNumber.substr(phoneNumber.indexOf(' ') + 1);\n    }\n    return phoneNumber;\n  }\n\n  private setCountry(country: CountryI): void {\n    this.country = country;\n    this.codeChange.emit(this.country);\n  }\n\n  private setPreferredCountries(): void {\n    for (const preferedCountryIsoCode of this.preferredCountries) {\n      const country = this.getCountryByIsoCode(preferedCountryIsoCode);\n      country.priority = country ? 1 : country.priority;\n    }\n    this.countries.sort((a, b) =>\n        a.priority > b.priority ? -1 : a.priority < b.priority ? 1 : 0\n    );\n  }\n\n  private startsWith = (input: string, search: string): boolean => {\n    return input.substr(0, search.length) === search;\n  }\n\n  private getClasses = (element: HTMLElement) => {\n    const classList = element.classList;\n    const classes = [];\n    for (let i = 0; i < classList.length; i++) {\n      const item = classList.item(i);\n      if (item !== null && this.startsWith(item, 'ng-')) {\n        classes.push(`ion-${item.substr(3)}`);\n      }\n    }\n    return classes;\n  }\n\n  private setClasses = (element: HTMLElement, classes: string[]) => {\n    const classList = element.classList;\n    [\n      'ion-valid',\n      'ion-invalid',\n      'ion-touched',\n      'ion-untouched',\n      'ion-dirty',\n      'ion-pristine',\n    ].forEach((c) => classList.remove(c));\n\n    classes.forEach((c) => classList.add(c));\n  }\n\n  private setIonicClasses = (element: ElementRef) => {\n    raf(() => {\n      const input = element.nativeElement as HTMLElement;\n      const classes = this.getClasses(input);\n      this.setClasses(input, classes);\n\n      const item = input.closest('ion-item');\n      if (item) {\n        this.setClasses(item, classes);\n      }\n    });\n  }\n\n  private setItemClass = (\n      element: ElementRef,\n      className: string,\n      addClass: boolean\n  ) => {\n    const input = element.nativeElement as HTMLElement;\n    const item = input.closest('ion-item');\n    if (item) {\n      const classList = item.classList;\n      if (addClass) {\n        classList.add(className);\n      } else {\n        classList.remove(className);\n      }\n    }\n  }\n}\n","<ion-button\n        fill=\"clear\"\n        class=\"ion-intl-tel-input-btn\"\n        [disabled] = \"disabled\"\n        aria-label=\"country\"\n        (click)=\"openModal()\"\n>\n  <span class=\"ion-intl-tel-input-flag fi fi-{{country.flagClass}}\"></span><span class=\"ion-intl-tel-input-code\" *ngIf=\"separateDialCode\">{{dialCodePrefix}}{{country.dialCode}}</span>\n  <ion-icon style=\"font-size:14px;opacity:.5;\" name=\"caret-down\"></ion-icon>\n</ion-button>\n<div class=\"ion-intl-tel-input-number\">\n  <ion-input\n          #numberInput\n          [(ngModel)]=\"phoneNumber\"\n          [autocomplete]=\"autocomplete\"\n          [required]=\"required\"\n          [disabled] = \"disabled\"\n          [attr.maxLength]=\"maxLength\"\n          type=\"tel\"\n          (ionBlur)=\"onIonNumberBlur()\"\n          (ionChange)=\"onIonNumberChange($event)\"\n          (ionFocus)=\"onIonNumberFocus()\"\n          (ionInput)=\"onIonNumberInput($event)\"\n          (keydown)=\"onNumberKeyDown($event)\"\n          (ngModelChange)=\"onNumberChange()\"\n          placeholder=\"{{country | countryPlaceholder: inputPlaceholder:separateDialCode:fallbackPlaceholder:usePatternPlaceholder}}\" >\n  </ion-input>\n</div>\n"]}