https://www.beibeihair.com/wp-content/plugins/mystickyelements/int…/build/js/intlTelInput.js?ver=2.2.5

124h because
125            // of IE11
126            var forEachProp = function forEachProp(obj, callback)
127            {
128                var keys = Object.keys(obj);
129                for (var i = 0; i < keys.length; i++) {
130                    callback(keys[i], obj[keys[i]]);
131                }
132            };
133            // run a method on each instance of the plugin
134            var forEachInstance = function forEachInstance(method)
135            {
136                forEachProp(
137                    window.intlTelInputGlobals.instances, function (key) {
138                        window.intlTelInputGlobals.instances[key][method]();
139                    }
140                );
141            };
142            // this is our plugin class that we will create an instance of
143            // eslint-disable-next-line no-unused-vars
144            var Iti = /*#__PURE__*/
145            function () {
146                function Iti(input, options)
147                {
148                    var _this = this;
149                    _classCallCheck(this, Iti);
150                    this.id = id++;
151                    this.telInput = input;
152                    this.activeItem = null;
153                    this.highlightedItem = null;
154                    // process specified options / defaults
155                    // alternative to Object.assign, which isn't supported by IE11
156                    var customOptions = options || {};
157                    this.options = {};
158                    forEachProp(
159                        defaults, function (key, value) {
160                            _this.options[key] = customOptions.hasOwnProperty(key) ? customOptions[key] : value;
161                        }
162                    );
163                    this.hadInitialPlaceholder = Boolean(input.getAttribute("placeholder"));
164                }
165                _createClass(
166                    Iti, [ {
167                        key: "_init",
168                        value: function _init()
169                        {
170                            var _this2 = this;
171                            // if in nationalMode, disable options relating to dial codes
172                            if (this.options.nationalMode) { this.options.autoHideDialCode = false;
173                            }
174                            // if separateDialCode then doesn't make sense to A) insert dial code into input
175                            // (autoHideDialCode), and B) display national numbers (because we're displaying the country
176                            // dial code next to them)
177                            if (this.options.separateDialCode) {
178                                this.options.autoHideDialCode = this.options.nationalMode = false;
179                            }
180                            // we cannot just test screen size as some smartphones/website meta tags will report desktop
181                            // resolutions
182                            // Note: for some reason jasmine breaks if you put this in the main Plugin function with the
183                            // rest of these declarations
184                            // Note: to target Android Mobiles (and not Tablets), we must find 'Android' and 'Mobile'
185                            this.isMobile = /Android.+Mobile|webOS|iPhone|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
186                            if (this.isMobile) {
187                                // trigger the mobile dropdown css
188                                document.body.classList.add("iti-mobile");
189                                // on mobile, we want a full screen dropdown, so we must append it to the body
190                                if (!this.options.dropdownContainer) { this.options.dropdownContainer = document.body;
191                                }
192                            }
193                            // these promises get resolved when their individual requests complete
194                            // this way the dev can do something like iti.promise.then(...) to know when all requests are
195                            // complete
196                            if (typeof Promise !== "undefined") {
197                                var autoCountryPromise = new Promise(
198                                    function (resolve, reject) {
199                                        _this2.resolveAutoCountryPromise = resolve;
200                                        _this2.rejectAutoCountryPromise = reject;
201                                    }
202                                );
203                                var utilsScriptPromise = new Promise(
204                                    function (resolve, reject) {
205                                        _this2.resolveUtilsScriptPromise = resolve;
206                                        _this2.rejectUtilsScriptPromise = reject;
207                                    }
208                                );
209                                this.promise = Promise.all([ autoCountryPromise, utilsScriptPromise ]);
210                            } else {
211                                // prevent errors when Promise doesn't exist
212                                this.resolveAutoCountryPromise = this.rejectAutoCountryPromise = function () {};
213                                this.resolveUtilsScriptPromise = this.rejectUtilsScriptPromise = function () {};
214                            }
215                            // in various situations there could be no country selected initially, but we need to be able
216                            // to assume this variable exists
217                            this.selectedCountryData = {};
218                            // process all the data: onlyCountries, excludeCountries, preferredCountries etc
219                            this._processCountryData();
220                            // generate the markup
221                            this._generateMarkup();
222                            // set the initial state of the input value and the selected flag
223                            this._setInitialState();
224                            // start all of the event listeners: autoHideDialCode, input keydown, selectedFlag click
225                            this._initListeners();
226                            // utils script, and auto country
227                            this._initRequests();
228                        }
229                    }, {
230                        key: "_processCountryData",
231                        value: function _processCountryData()
232                        {
233                            // process onlyCountries or excludeCountries array if present
234                            this._processAllCountries();
235                            // process the countryCodes map
236                            this._processCountryCodes();
237                            // process the preferredCountries
238                            this._processPreferredCountries();
239                            // translate countries according to localizedCountries option
240                            if (this.options.localizedCountries) { this._translateCountriesByLocale();
241                            }
242                            // sort countries by name
243                            if (this.options.onlyCountries.length || this.options.localizedCountries) {
244                                this.countries.sort(this._countryNameSort);
245                            }
246                        }
247                    }, {
248                        key: "_addCountryCode",
249                        value: function _addCountryCode(iso2, countryCode, priority)
250                        {
251                            if (countryCode.length > this.countryCodeMaxLen) {
252                                this.countryCodeMaxLen = countryCode.length;
253                            }
254                            if (!this.countryCodes.hasOwnProperty(countryCode)) {
255                                this.countryCodes[countryCode] = [];
256                            }
257                            // bail if we already have this country for this countryCode
258                            for (var i = 0; i < this.countryCodes[countryCode].length; i++) {
259                                if (this.countryCodes[countryCode][i] === iso2) { return;
260                                }
261                            }
262                            // check for undefined as 0 is falsy
263                            var index = priority !== undefined ? priority : this.countryCodes[countryCode].length;
264                            this.countryCodes[countryCode][index] = iso2;
265                        }
266                    }, {
267                        key: "_processAllCountries",
268                        value: function _processAllCountries()
269                        {
270                            if (this.options.onlyCountries.length) {
271                                var lowerCaseOnlyCountries = this.options.onlyCountries.map(
272                                    function (country) {
273                                        return country.toLowerCase();
274                                    }
275                                );
276                                this.countries = allCountries.filter(
277                                    function (country) {
278                                        return lowerCaseOnlyCountries.indexOf(country.iso2) > -1;
279                                    }
280                                );
281                            } else if (this.options.excludeCountries.length) {
282                                var lowerCaseExcludeCountries = this.options.excludeCountries.map(
283                                    function (country) {
284                                        return country.toLowerCase();
285                                    }
286                                );
287                                this.countries = allCountries.filter(
288                                    function (country) {
289                                        return lowerCaseExcludeCountries.indexOf(country.iso2) === -1;
290                                    }
291                                );
292                            } else {
293                                this.countries = allCountries;
294                            }
295                        }
296                    }, {
297                        key: "_translateCountriesByLocale",
298                        value: function _translateCountriesByLocale()
299                        {
300                            for (var i = 0; i < this.countries.length; i++) {
301                                var iso = this.countries[i].iso2.toLowerCase();
302                                if (this.options.localizedCountries.hasOwnProperty(iso)) {
303                                    this.countries[i].name = this.options.localizedCountries[iso];
304                                }
305                            }
306                        }
307                    }, {
308                        key: "_countryNameSort",
309                        value: function _countryNameSort(a, b)
310                        {
311                            return a.name.localeCompare(b.name);
312                        }
313                    }, {
314                        key: "_processCountryCodes",
315                        value: function _processCountryCodes()
316                        {
317                            this.countryCodeMaxLen = 0;
318                            // here we store just dial codes
319                            this.dialCodes = {};
320                            // here we store "country codes" (both dial codes and their area codes)
321                            this.countryCodes = {};
322                            // first: add dial codes
323                            for (var i = 0; i < this.countries.length; i++) {
324                                var c = this.countries[i];
325                                if (!this.dialCodes[c.dialCode]) { this.dialCodes[c.dialCode] = true;
326                                }
327                                this._addCountryCode(c.iso2, c.dialCode, c.priority);
328                            }
329                            // next: add area codes
330                            // this is a second loop over countries, to make sure we have all of the "root" countries
331                            // already in the map, so that we can access them, as each time we add an area code substring
332                            // to the map, we also need to include the "root" country's code, as that also matches
333                            for (var _i = 0; _i < this.countries.length; _i++) {
334                                var _c = this.countries[_i];
335                                // area codes
336                                if (_c.areaCodes) {
337                                    var rootCountryCode = this.countryCodes[_c.dialCode][0];
338                                    // for each area code
339                                    for (var j = 0; j < _c.areaCodes.length; j++) {
340                                        var areaCode = _c.areaCodes[j];
341                                        // for each digit in the area code to add all partial matches as well
342                                        for (var k = 1; k < areaCode.length; k++) {
343                                            var partialDialCode = _c.dialCode + areaCode.substr(0, k);
344                                            // start with the root country, as that also matches this dial code
345                                            this._addCountryCode(rootCountryCode, partialDialCode);
346                                            this._addCountryCode(_c.iso2, partialDialCode);
347                                        }
348                                        // add the full area code
349                                        this._addCountryCode(_c.iso2, _c.dialCode + areaCode);
350                                    }
351                                }
352                            }
353                        }
354                    }, {
355                        key: "_processPreferredCountries",
356                        value: function _processPreferredCountries()
357                        {
358                            this.preferredCountries = [];
359                            for (var i = 0; i < this.options.preferredCountries.length; i++) {
360                                var countryCode = this.options.preferredCountries[i].toLowerCase();
361                                var countryData = this._getCountryData(countryCode, false, true);
362                                if (countryData) { this.preferredCountries.push(countryData);
363                                }
364                            }
365                        }
366                    }, {
367                        key: "_createEl",
368                        value: function _createEl(name, attrs, container)
369                        {
370                            var el = document.createElement(name);

505                                var idSuffix = preferred ? "-preferred" : "";
506                                // open the list item
507                                tmp += "<li class='iti__country ".concat(className, "' tabIndex='-1' id='iti-").concat(this.id, "__item-").concat(c.iso2).concat(idSuffix, "' role='option' data-dial-code='").concat(c.dialCode, "' data-country-code='").concat(c.iso2, "' aria-selected='false'>");
508                                // add the flag
509                                tmp += "<div class='iti__flag-box'><div class='iti__flag iti__".concat(c.iso2, "'></div></div>");
510                                // and the country name and dial code
511                                tmp += "<span class='iti__country-name'>".concat(c.name, "</span>");
512                                tmp += "<span class='iti__dial-code'>+".concat(c.dialCode, "</span>");
513                                // close the list item
514                                tmp += "</li>";
515                            }
516                            this.countryList.insertAdjacentHTML("beforeend", tmp);
517                        }
518                    }, {
519                        key: "_setInitialState",
520                        value: function _setInitialState()
521                        {
522                            // fix firefox bug: when first load page (with input with value set to number with intl dial
523                            // code) and initialising plugin removes the dial code from the input, then refresh page,
524                            // and we try to init plugin again but this time on number without dial code so get grey flag
525                            var attributeValue = this.telInput.getAttribute("value");
526                            var inputValue = this.telInput.value;
527                            var useAttribute = attributeValue && attributeValue.charAt(0) === "+" && (!inputValue || inputValue.charAt(0) !== "+");
528                            var val = useAttribute ? attributeValue : inputValue;
529                            var dialCode = this._getDialCode(val);
530                            var isRegionlessNanp = this._isRegionlessNanp(val);
531                            var _this$options = this.options, initialCountry = _this$options.initialCountry, nationalMode = _this$options.nationalMode, autoHideDialCode = _this$options.autoHideDialCode, separateDialCode = _this$options.separateDialCode;
532                            // if we already have a dial code, and it's not a regionlessNanp, we can go ahead and set the
533                            // flag, else fall back to the default country
534                            if (dialCode && !isRegionlessNanp) {
535                                this._updateFlagFromNumber(val);
536                            } else if (initialCountry !== "auto") {
537                                // see if we should select a flag
538                                if (initialCountry) {
539                                    this._setFlag(initialCountry.toLowerCase());
540                                } else {
541                                    if (dialCode && isRegionlessNanp) {
542                                        // has intl dial code, is regionless nanp, and no initialCountry, so default to US
543                                        this._setFlag("us");
544                                    } else {
545                                        // no dial code and no initialCountry, so default to first in list
546                                        this.defaultCountry = this.preferredCountries.length ? this.preferredCountries[0].iso2 : this.countries[0].iso2;
547                                        if (!val) {
548                                            this._setFlag(this.defaultCountry);
549                                        }
550                                    }
551                                }
552                                // if empty and no nationalMode and no autoHideDialCode then insert the default dial code
553                                if (!val && !nationalMode && !autoHideDialCode && !separateDialCode) {
554                                    this.telInput.value = "+".concat(this.selectedCountryData.dialCode);
555                                }
556                            }
557                            // NOTE: if initialCountry is set to auto, that will be handled separately
558                            // format - note this wont be run after _updateDialCode as that's only called if no val
559                            if (val) { this._updateValFromNumber(val);
560                            }
561                        }
562                    }, {
563                        key: "_initListeners",
564                        value: function _initListeners()
565                        {
566                            this._initKeyListeners();
567                            if (this.options.autoHideDialCode) { this._initBlurListeners();
568                            }
569                            if (this.options.allowDropdown) { this._initDropdownListeners();
570                            }
571                            if (this.hiddenInput) { this._initHiddenInputListener();
572                            }
573                        }
574                    }, {
575                        key: "_initHiddenInputListener",
576                        value: function _initHiddenInputListener()
577                        {
578                            var _this3 = this;
579                            this._handleHiddenInputSubmit = function () {
580                                _this3.hiddenInput.value = _this3.getNumber();
581                            };
582                            if (this.telInput.form) { this.telInput.form.addEventListener("submit", this._handleHiddenInputSubmit);
583                            }
584                        }
585                    }, {
586                        key: "_getClosestLabel",
587                        value: function _getClosestLabel()
588                        {
589                            var el = this.telInput;
590                            while (el && el.tagName !== "LABEL") {
591                                el = el.parentNode;
592                            }
593                            return el;
594                        }
595                    }, {
596                        key: "_initDropdownListeners",
597                        value: function _initDropdownListeners()
598                        {
599                            var _this4 = this;
600                            // hack for input nested inside label (which is valid markup): clicking the selected-flag to
601                            // open the dropdown would then automatically trigger a 2nd click on the input which would
602                            // close it again
603                            this._handleLabelClick = function (e) {
604                                // if the dropdown is closed, then focus the input, else ignore the click
605                                if (_this4.countryList.classList.contains("iti__hide")) { _this4.telInput.focus(); } else { e.preventDefault();
606                                }
607                            };
608                            var label = this._getClosestLabel();
609                            if (label) { label.addEventListener("click", this._handleLabelClick);
610                            }
611                            // toggle country dropdown on click
612                            this._handleClickSelectedFlag = function () {
613                                // only intercept this event if we're opening the dropdown
614                                // else let it bubble up to the top ("click-off-to-close" listener)
615                                // we cannot just stopPropagation as it may be needed to close another instance
616                                if (_this4.countryList.classList.contains("iti__hide") && !_this4.telInput.disabled && !_this4.telInput.readOnly) {
617                                    _this4._showDropdown();
618                                }
619                            };
620                            this.selectedFlag.addEventListener("click", this._handleClickSelectedFlag);
621                            // open dropdown list if currently focused
622                            this._handleFlagsContainerKeydown = function (e) {
623                                var isDropdownHidden = _this4.countryList.classList.contains("iti__hide");
624                                if (isDropdownHidden && [ "ArrowUp", "Up", "ArrowDown", "Down", " ", "Enter" ].indexOf(e.key) !== -1) {
625                                    // prevent form from being submitted if "ENTER" was pressed
626                                    e.preventDefault();
627                                    // prevent event from being handled again by document
628                                    e.stopPropagation();
629                                    _this4._showDropdown();
630                                }
631                                // allow navigation from dropdown to input on TAB
632                                if (e.key === "Tab") { _this4._closeDropdown();
633                                }
634                            };
635                            this.flagsContainer.addEventListener("keydown", this._handleFlagsContainerKeydown);
636                        }
637                    }, {
638                        key: "_initRequests",
639                        value: function _initRequests()
640                        {
641                            var _this5 = this;
642                            // if the user has specified the path to the utils script, fetch it on window.load, else resolve
643                            if (this.options.utilsScript && !window.intlTelInputUtils) {
644                                // if the plugin is being initialised after the window.load event has already been fired
645                                if (window.intlTelInputGlobals.documentReady()) {
646                                    window.intlTelInputGlobals.loadUtils(this.options.utilsScript);
647                                } else {
648                                    // wait until the load event so we don't block any other requests e.g. the flags image
649                                    window.addEventListener(
650                                        "load", function () {
651                                            window.intlTelInputGlobals.loadUtils(_this5.options.utilsScript);
652                                        }
653                                    );
654                                }
655                            } else { this.resolveUtilsScriptPromise();
656                            }
657                            if (this.options.initialCountry === "auto") { this._loadAutoCountry(); } else { this.resolveAutoCountryPromise();
658                            }
659                        }
660                    }, {
661                        key: "_loadAutoCountry",
662                        value: function _loadAutoCountry()
663                        {
664                            // 3 options:
665                            // 1) already loaded (we're done)
666                            // 2) not already started loading (start)
667                            // 3) already started loading (do nothing - just wait for loading callback to fire)
668                            if (window.intlTelInputGlobals.autoCountry) {
669                                this.handleAutoCountry();
670                            } else if (!window.intlTelInputGlobals.startedLoadingAutoCountry) {
671                                // don't do this twice!
672                                window.intlTelInputGlobals.startedLoadingAutoCountry = true;
673                                if (typeof this.options.geoIpLookup === "function") {
674                                    this.options.geoIpLookup(
675                                        function (countryCode) {
676                                            window.intlTelInputGlobals.autoCountry = countryCode.toLowerCase();
677                                            // tell all instances the auto country is ready
678                                            // TODO: this should just be the current instances
679                                            // UPDATE: use setTimeout in case their geoIpLookup function calls this callback straight
680                                            // away (e.g. if they have already done the geo ip lookup somewhere else). Using
681                                            // setTimeout means that the current thread of execution will finish before executing
682                                            // this, which allows the plugin to finish initialising.
683                                            setTimeout(
684                                                function () {
685                                                    return forEachInstance("handleAutoCountry");
686                                                }
687                                            );
688                                        }, function () {
689                                            return forEachInstance("rejectAutoCountryPromise");
690                                        }
691                                    );
692                                }
693                            }
694                        }
695                    }, {
696                        key: "_initKeyListeners",
697                        value: function _initKeyListeners()
698                        {
699                            var _this6 = this;
700                            // update flag on keyup
701                            this._handleKeyupEvent = function () {
702                                if (_this6._updateFlagFromNumber(_this6.telInput.value)) {
703                                    _this6._triggerCountryChange();
704                                }
705                            };
706                            this.telInput.addEventListener("keyup", this._handleKeyupEvent);
707                            // update flag on cut/paste events (now supported in all major browsers)
708                            this._handleClipboardEvent = function () {
709                                // hack because "paste" event is fired before input is updated
710                                setTimeout(_this6._handleKeyupEvent);
711                            };
712                            this.telInput.addEventListener("cut", this._handleClipboardEvent);
713                            this.telInput.addEventListener("paste", this._handleClipboardEvent);
714                        }
715                    }, {
716                        key: "_cap",
717                        value: function _cap(number)
718                        {
719                            var max = this.telInput.getAttribute("maxlength");
720                            return max && number.length > max ? number.substr(0, max) : number;
721                        }
722                    }, {
723                        key: "_initBlurListeners",
724                        value: function _initBlurListeners()
725                        {
726                            var _this7 = this;
727                            // on blur or form submit: if just a dial code then remove it
728                            this._handleSubmitOrBlurEvent = function () {
729                                _this7._removeEmptyDialCode();
730                            };
731                            if (this.telInput.form) { this.telInput.form.addEventListener("submit", this._handleSubmitOrBlurEvent);
732                            }
733                            this.telInput.addEventListener("blur", this._handleSubmitOrBlurEvent);
734                        }
735                    }, {
736                        key: "_removeEmptyDialCode",
737                        value: function _removeEmptyDialCode()
738                        {
739                            if (this.telInput.value.charAt(0) === "+") {
740                                var numeric = this._getNumeric(this.telInput.value);
741                                // if just a plus, or if just a dial code
742                                if (!numeric || this.selectedCountryData.dialCode === numeric) {
743                                    this.telInput.value = "";
744                                }
745                            }
746                        }
747                    }, {
748                        key: "_getNumeric",
749                        value: function _getNumeric(s)
750                        {
751                            return s.replace(/\D/g, "");
752                        }
753                    }, {
754                        key: "_trigger",
755                        value: function _trigger(name)
756                        {
757                            // have to use old school document.createEvent as IE11 doesn't support `new Event()` syntax
758                            var e = document.createEvent("Event");
759                            e.initEvent(name, true, true);
760                            // can bubble, and is cancellable
761                            this.telInput.dispatchEvent(e);
762                        }
763                    }, {
764                        key: "_showDropdown",
765                        value: function _showDropdown()
766                        {
767                            this.countryList.classList.remove("iti__hide");
768                            this.selectedFlag.setAttribute("aria-expanded", "true");
769                            this._setDropdownPosition();
770                            // update highlighting and scroll to active list item
771                            if (this.activeItem) {
772                                this._highlightListItem(this.activeItem, false);
773                                this._scrollTo(this.activeItem, true);
774                            }
775                            // bind all the dropdown-related listeners: mouseover, click, click-off, keydown
776                            this._bindDropdownListeners();
777                            // update the arrow
778                            this.dropdownArrow.classList.add("iti__arrow--up");
779                            this._trigger("open:countrydropdown");
780                        }
781                    }, {
782                        key: "_toggleClass",
783                        value: function _toggleClass(el, className, shouldHaveClass)
784                        {
785                            if (shouldHaveClass && !el.classList.contains(className)) { el.classList.add(className); } else if (!shouldHaveClass && el.classList.contains(className)) { el.classList.remove(className);
786                            }
787                        }
788                    }, {
789                        key: "_setDropdownPosition",
790                        value: function _setDropdownPosition()
791                        {
792                            var _this8 = this;
793                            if (this.options.dropdownContainer) {
794                                this.options.dropdownContainer.appendChild(this.dropdown);
795                            }
796                            if (!this.isMobile) {
797                                var pos = this.telInput.getBoundingClientRect();
798                                // windowTop from https://stackoverflow.com/a/14384091/217866
799                                var windowTop = window.pageYOffset || document.documentElement.scrollTop;
800                                var inputTop = pos.top + windowTop;
801                                var dropdownHeight = this.countryList.offsetHeight;
802                                // dropdownFitsBelow = (dropdownBottom < windowBottom)
803                                var dropdownFitsBelow = inputTop + this.telInput.offsetHeight + dropdownHeight < windowTop + window.innerHeight;
804                                var dropdownFitsAbove = inputTop - dropdownHeight > windowTop;
805                                // by default, the dropdown will be below the input. If we want to position it above the
806                                // input, we add the dropup class.
807                                this._toggleClass(this.countryList, "iti__country-list--dropup", !dropdownFitsBelow && dropdownFitsAbove);
808                                // if dropdownContainer is enabled, calculate postion
809                                if (this.options.dropdownContainer) {
810                                    // by default the dropdown will be directly over the input because it's not in the flow.
811                                    // If we want to position it below, we need to add some extra top value.
812                                    var extraTop = !dropdownFitsBelow && dropdownFitsAbove ? 0 : this.telInput.offsetHeight;
813                                    // calculate placement
814                                    this.dropdown.style.top = "".concat(inputTop + extraTop, "px");
815                                    this.dropdown.style.left = "".concat(pos.left + document.body.scrollLeft, "px");
816                                    // close menu on window scroll
817                                    this._handleWindowScroll = function () {
818                                        return _this8._closeDropdown();
819                                    };
820                                    window.addEventListener("scroll", this._handleWindowScroll);
821                                }
822                            }
823                        }
824                    }, {
825                        key: "_getClosestListItem",
826                        value: function _getClosestListItem(target)
827                        {
828                            var el = target;
829                            while (el && el !== this.countryList && !el.classList.contains("iti__country")) {
830                                el = el.parentNode;
831                            }
832                            // if we reached the countryList element, then return null
833                            return el === this.countryList ? null : el;
834                        }
835                    }, {
836                        key: "_bindDropdownListeners",
837                        value: function _bindDropdownListeners()
838                        {
839                            var _this9 = this;
840                            // when mouse over a list item, just highlight that one
841                            // we add the class "highlight", so if they hit "enter" we know which one to select
842                            this._handleMouseoverCountryList = function (e) {
843                                // handle event delegation, as we're listening for this event on the countryList
844                                var listItem = _this9._getClosestListItem(e.target);
845                                if (listItem) { _this9._highlightListItem(listItem, false);
846                                }
847                            };
848                            this.countryList.addEventListener("mouseover", this._handleMouseoverCountryList);
849                            // listen for country selection
850                            this._handleClickCountryList = function (e) {
851                                var listItem = _this9._getClosestListItem(e.target);
852                                if (listItem) { _this9._selectListItem(listItem);
853                                }
854                            };
855                            this.countryList.addEventListener("click", this._handleClickCountryList);
856                            // click off to close
857                            // (except when this initial opening click is bubbling up)
858                            // we cannot just stopPropagation as it may be needed to close another instance
859                            var isOpening = true;
860                            this._handleClickOffToClose = function () {
861                                if (!isOpening) { _this9._closeDropdown();
862                                }
863                                isOpening = false;
864                            };
865                            document.documentElement.addEventListener("click", this._handleClickOffToClose);
866                            // listen for up/down scrolling, enter to select, or letters to jump to country name.
867                            // use keydown as keypress doesn't fire for non-char keys and we want to catch if they
868                            // just hit down and hold it to scroll down (no keyup event).
869                            // listen on the document because that's where key events are triggered if no input has focus
870                            var query = "";
871                            var queryTimer = null;
872                            this._handleKeydownOnDropdown = function (e) {
873                                // prevent down key from scrolling the whole page,
874                                // and enter key from submitting a form etc
875                                e.preventDefault();
876                                // up and down to navigate
877                                if (e.key === "ArrowUp" || e.key === "Up" || e.key === "ArrowDown" || e.key === "Down") { _this9._handleUpDownKey(e.key); } else if (e.key === "Enter") { _this9._handleEnterKey(); } else if (e.key === "Escape") { _this9._closeDropdown(); } else if (/^[a-zA-ZÀ-ÿа-яА-Я ]$/.test(e.key)) {
878                                    // jump to countries that start with the query string
879                                    if (queryTimer) { clearTimeout(queryTimer);
880                                    }
881                                    query += e.key.toLowerCase();
882                                    _this9._searchForCountry(query);
883                                    // if the timer hits 1 second, reset the query
884                                    queryTimer = setTimeout(
885                                        function () {
886                                            query = "";
887                                        }, 1e3
888                                    );
889                                }
890                            };
891                            document.addEventListener("keydown", this._handleKeydownOnDropdown);
892                        }
893                    }, {
894                        key: "_handleUpDownKey",
895                        value: function _handleUpDownKey(key)
896                        {
897                            var next = key === "ArrowUp" || key === "Up" ? this.highlightedItem.previousElementSibling : this.highlightedItem.nextElementSibling;
898                            if (next) {
899                                // skip the divider
900                                if (next.classList.contains("iti__divider")) {
901                                    next = key === "ArrowUp" || key === "Up" ? next.previousElementSibling : next.nextElementSibling;
902                                }
903                                this._highlightListItem(next, true);
904                            }
905                        }
906                    }, {
907                        key: "_handleEnterKey",
908                        value: function _handleEnterKey()
909                        {
910                            if (this.highlightedItem) { this._selectListItem(this.highlightedItem);
911                            }
912                        }
913                    }, {
914                        key: "_searchForCountry",
915                        value: function _searchForCountry(query)
916                        {
917                            for (var i = 0; i < this.countries.length; i++) {
918                                if (this._startsWith(this.countries[i].name, query)) {
919                                    var listItem = this.countryList.querySelector("#iti-".concat(this.id, "__item-").concat(this.countries[i].iso2));
920                                    // update highlighting and scroll
921                                    this._highlightListItem(listItem, false);
922                                    this._scrollTo(listItem, true);
923                                    break;
924                                }
925                            }
926                        }
927                    }, {
928                        key: "_startsWith",
929                        value: function _startsWith(a, b)
930                        {
931                            return a.substr(0, b.length).toLowerCase() === b;
932                        }
933                    }, {
934                        key: "_updateValFromNumber",
935                        value: function _updateValFromNumber(originalNumber)
936                        {
937                            var number = originalNumber;
938                            if (this.options.formatOnDisplay && window.intlTelInputUtils && this.selectedCountryData) {
939                                var useNational = !this.options.separateDialCode && (this.options.nationalMode || number.charAt(0) !== "+");
940                                var _intlTelInputUtils$nu = intlTelInputUtils.numberFormat, NATIONAL = _intlTelInputUtils$nu.NATIONAL, INTERNATIONAL = _intlTelInputUtils$nu.INTERNATIONAL;
941                                var format = useNational ? NATIONAL : INTERNATIONAL;
942                                number = intlTelInputUtils.formatNumber(number, this.selectedCountryData.iso2, format);
943                            }
944                            number = this._beforeSetNumber(number);
945                            this.telInput.value = number;
946                        }
947                    }, {
948                        key: "_updateFlagFromNumber",
949                        value: function _updateFlagFromNumber(originalNumber)
950                        {
951                            // if we're in nationalMode and we already have US/Canada selected, make sure the number starts
952                            // with a +1 so _getDialCode will be able to extract the area code
953                            // update: if we dont yet have selectedCountryData, but we're here (trying to update the flag
954                            // from the number), that means we're initialising the plugin with a number that already has a
955                            // dial code, so fine to ignore this bit
956                            var number = originalNumber;
957                            var selectedDialCode = this.selectedCountryData.dialCode;
958                            var isNanp = selectedDialCode === "1";
959                            if (number && this.options.nationalMode && isNanp && number.charAt(0) !== "+") {
960                                if (number.charAt(0) !== "1") { number = "1".concat(number);
961                                }
962                                number = "+".concat(number);
963                            }
964                            // update flag if user types area code for another country
965                            if (this.options.separateDialCode && selectedDialCode && number.charAt(0) !== "+") {
966                                number = "+".concat(selectedDialCode).concat(number);
967                            }
968                            // try and extract valid dial code from input
969                            var dialCode = this._getDialCode(number, true);
970                            var numeric = this._getNumeric(number);
971                            var countryCode = null;
972                            if (dialCode) {
973                                var countryCodes = this.countryCodes[this._getNumeric(dialCode)];
974                                // check if the right country is already selected. this should be false if the number is
975                                // longer than the matched dial code because in this case we need to make sure that if
976                                // there are multiple country matches, that the first one is selected (note: we could
977                                // just check that here, but it requires the same loop that we already have later)
978                                var alreadySelected = countryCodes.indexOf(this.selectedCountryData.iso2) !== -1 && numeric.length <= dialCode.length - 1;
979                                var isRegionlessNanpNumber = selectedDialCode === "1" && this._isRegionlessNanp(numeric);
980                                // only update the flag if:
981                                // A) NOT (we currently have a NANP flag selected, and the number is a regionlessNanp)
982                                // AND
983                                // B) the right country is not already selected
984                                if (!isRegionlessNanpNumber && !alreadySelected) {
985                                    // if using onlyCountries option, countryCodes[0] may be empty, so we must find the first
986                                    // non-empty index
987                                    for (var j = 0; j < countryCodes.length; j++) {
988                                        if (countryCodes[j]) {
989                                            countryCode = countryCodes[j];
990                                            break;
991                                        }
992                                    }
993                                }
994                            } else if (number.charAt(0) === "+" && numeric.length) {
995                                // invalid dial code, so empty
996                                // Note: use getNumeric here because the number has not been formatted yet, so could contain
997                                // bad chars
998                                countryCode = "";
999                            } else if (!number || number === "+") {
1000                                // empty, or just a plus, so default
1001                                countryCode = this.defaultCountry;
1002                            }
1003                            if (countryCode !== null) {
1004                                return this._setFlag(countryCode);
1005                            }
1006                            return false;
1007                        }
1008                    }, {
1009                        key: "_isRegionlessNanp",
1010                        value: function _isRegionlessNanp(number)
1011                        {
1012                            var numeric = this._getNumeric(number);
1013                            if (numeric.charAt(0) === "1") {
1014                                var areaCode = numeric.substr(1, 3);
1015                                return regionlessNanpNumbers.indexOf(areaCode) !== -1;
1016                            }
1017                            return false;
1018                        }
1019                    }, {
1020                        key: "_highlightListItem",
1021                        value: function _highlightListItem(listItem, shouldFocus)
1022                        {
1023                            var prevItem = this.highlightedItem;
1024                            if (prevItem) { prevItem.classList.remove("iti__highlight");
1025                            }
1026                            this.highlightedItem = listItem;
1027                            this.highlightedItem.classList.add("iti__highlight");
1028                            if (shouldFocus) { this.highlightedItem.focus();
1029                            }
1030                        }
1031                    }, {
1032                        key: "_getCountryData",
1033                        value: function _getCountryData(countryCode, ignoreOnlyCountriesOption, allowFail)
1034                        {
1035                            var countryList = ignoreOnlyCountriesOption ? allCountries : this.countries;
1036                            for (var i = 0; i < countryList.length; i++) {
1037                                if (countryList[i].iso2 === countryCode) {
1038                                    return countryList[i];
1039                                }
1040                            }
1041                            if (allowFail) {
1042                                return null;
1043                            }
1044                            throw new Error("No country data for '".concat(countryCode, "'"));
1045                        }
1046                    }, {
1047                        key: "_setFlag",
1048                        value: function _setFlag(countryCode)
1049                        {
1050                            var prevCountry = this.selectedCountryData.iso2 ? this.selectedCountryData : {};
1051                            // do this first as it will throw an error and stop if countryCode is invalid
1052                            this.selectedCountryData = countryCode ? this._getCountryData(countryCode, false, false) : {};
1053                            // update the defaultCountry - we only need the iso2 from now on, so just store that
1054                            if (this.selectedCountryData.iso2) {
1055                                this.defaultCountry = this.selectedCountryData.iso2;
1056                            }
1057                            this.selectedFlagInner.setAttribute("class", "iti__flag iti__".concat(countryCode));
1058                            // update the selected country's title attribute
1059                            var title = countryCode ? "".concat(this.selectedCountryData.name, ": +").concat(this.selectedCountryData.dialCode) : "Unknown";
1060                            this.selectedFlag.setAttribute("title", title);
1061                            if (this.options.separateDialCode) {
1062                                var dialCode = this.selectedCountryData.dialCode ? "+".concat(this.selectedCountryData.dialCode) : "";
1063                                this.selectedDialCode.innerHTML = dialCode;
1064                                // offsetWidth is zero if input is in a hidden container during initialisation
1065                                var selectedFlagWidth = this.selectedFlag.offsetWidth || this._getHiddenSelectedFlagWidth();
1066                                // add 6px of padding after the grey selected-dial-code box, as this is what we use in the css
1067                                this.telInput.style.paddingLeft = "".concat(selectedFlagWidth + 6, "px");
1068                            }
1069                            // and the input's placeholder
1070                            this._updatePlaceholder();
1071                            // update the active list item
1072                            if (this.options.allowDropdown) {
1073                                var prevItem = this.activeItem;
1074                                if (prevItem) {
1075                                    prevItem.classList.remove("iti__active");
1076                                    prevItem.setAttribute("aria-selected", "false");
1077                                }
1078                                if (countryCode) {
1079                                    // check if there is a preferred item first, else fall back to standard
1080                                    var nextItem = this.countryList.querySelector("#iti-".concat(this.id, "__item-").concat(countryCode, "-preferred")) || this.countryList.querySelector("#iti-".concat(this.id, "__item-").concat(countryCode));
1081                                    nextItem.setAttribute("aria-selected", "true");
1082                                    nextItem.classList.add("iti__active");
1083                                    this.activeItem = nextItem;
1084                                    this.selectedFlag.setAttribute("aria-activedescendant", nextItem.getAttribute("id"));
1085                                }
1086                            }
1087                            // return if the flag has changed or not
1088                            return prevCountry.iso2 !== countryCode;
1089                        }
1090                    }, {
1091                        key: "_getHiddenSelectedFlagWidth",
1092                        value: function _getHiddenSelectedFlagWidth()
1093                        {
1094                            // to get the right styling to apply, all we need is a shallow clone of the container,
1095                            // and then to inject a deep clone of the selectedFlag element
1096                            var containerClone = this.telInput.parentNode.cloneNode();
1097                            containerClone.style.visibility = "hidden";
1098                            document.body.appendChild(containerClone);
1099                            var flagsContainerClone = this.flagsContainer.cloneNode();
1100                            containerClone.appendChild(flagsContainerClone);
1101                            var selectedFlagClone = this.selectedFlag.cloneNode(true);
1102                            flagsContainerClone.appendChild(selectedFlagClone);
1103                            var width = selectedFlagClone.offsetWidth;
1104                            containerClone.parentNode.removeChild(containerClone);
1105                            return width;
1106                        }
1107                    }, {
1108                        key: "_updatePlaceholder",
1109                        value: function _updatePlaceholder()
1110                        {
1111                            var shouldSetPlaceholder = this.options.autoPlaceholder === "aggressive" || !this.hadInitialPlaceholder && this.options.autoPlaceholder === "polite";
1112                            if (window.intlTelInputUtils && shouldSetPlaceholder) {
1113                                var numberType = intlTelInputUtils.numberType[this.options.placeholderNumberType];
1114                                var placeholder = this.selectedCountryData.iso2 ? intlTelInputUtils.getExampleNumber(this.selectedCountryData.iso2, this.options.nationalMode, numberType) : "";
1115                                placeholder = this._beforeSetNumber(placeholder);
1116                                if (typeof this.options.customPlaceholder === "function") {
1117                                    placeholder = this.options.customPlaceholder(placeholder, this.selectedCountryData);
1118                                }
1119                                this.telInput.setAttribute("placeholder", placeholder);
1120                            }
1121                        }
1122                    }, {
1123                        key: "_selectListItem",
1124                        value: function _selectListItem(listItem)
1125                        {
1126                            // update selected flag and active list item
1127                            var flagChanged = this._setFlag(listItem.getAttribute("data-country-code"));
1128                            this._closeDropdown();
1129                            this._updateDialCode(listItem.getAttribute("data-dial-code"), true);
1130                            // focus the input
1131                            this.telInput.focus();
1132                            // put cursor at end - this fix is required for FF and IE11 (with nationalMode=false i.e. auto
1133                            // inserting dial code), who try to put the cursor at the beginning the first time
1134                            var len = this.telInput.value.length;
1135                            this.telInput.setSelectionRange(len, len);
1136                            if (flagChanged) {
1137                                this._triggerCountryChange();
1138                            }
1139                        }
1140                    }, {
1141                        key: "_closeDropdown",
1142                        value: function _closeDropdown()
1143                        {
1144                            this.countryList.classList.add("iti__hide");
1145                            this.selectedFlag.setAttribute("aria-expanded", "false");
1146                            // update the arrow
1147                            this.dropdownArrow.classList.remove("iti__arrow--up");
1148                            // unbind key events
1149                            document.removeEventListener("keydown", this._handleKeydownOnDropdown);
1150                            document.documentElement.removeEventListener("click", this._handleClickOffToClose);
1151                            this.countryList.removeEventListener("mouseover", this._handleMouseoverCountryList);
1152                            this.countryList.removeEventListener("click", this._handleClickCountryList);
1153                            // remove menu from container
1154                            if (this.options.dropdownContainer) {
1155                                if (!this.isMobile) { window.removeEventListener("scroll", this._handleWindowScroll);
1156                                }
1157                                if (this.dropdown.parentNode) { this.dropdown.parentNode.removeChild(this.dropdown);
1158                                }
1159                            }
1160                            this._trigger("close:countrydropdown");
1161                        }
1162                    }, {
1163                        key: "_scrollTo",
1164                        value: function _scrollTo(element, middle)
1165                        {
1166                            var container = this.countryList;
1167                            // windowTop from https://stackoverflow.com/a/14384091/2

1241                                        // if current numericChars make a valid dial code
1242                                        if (includeAreaCode) {
1243                                            if (this.countryCodes[numericChars]) {
1244                                                // store the actual raw string (useful for matching later)
1245                                                dialCode = number.substr(0, i + 1);
1246                                            }
1247                                        } else {
1248                                            if (this.dialCodes[numericChars]) {
1249                                                dialCode = number.substr(0, i + 1);
1250                                                // if we're just looking for a dial code, we can break as soon as we find one
1251                                                break;
1252                                            }
1253                                        }
1254                                        // stop searching as soon as we can - in this case when we hit max len
1255                                        if (numericChars.length === this.countryCodeMaxLen) {
1256                                            break;
1257                                        }
1258                                    }
1259                                }
1260                            }
1261                            return dialCode;
1262                        }
1263                    }, {
1264                        key: "_getFullNumber",
1265                        value: function _getFullNumber()
1266                        {
1267                            var val = this.telInput.value.trim();
1268                            var dialCode = this.selectedCountryData.dialCode;
1269                            var prefix;
1270                            var numericVal = this._getNumeric(val);
1271                            if (this.options.separateDialCode && val.charAt(0) !== "+" && dialCode && numericVal) {
1272                                // when using separateDialCode, it is visible so is effectively part of the typed number
1273                                prefix = "+".concat(dialCode);
1274                            } else {
1275                                prefix = "";
1276                            }
1277                            return prefix + val;
1278                        }
1279                    }, {
1280                        key: "_beforeSetNumber",
1281                        value: function _beforeSetNumber(originalNumber)
1282                        {
1283                            var number = originalNumber;
1284                            if (this.options.separateDialCode) {
1285                                var dialCode = this._getDialCode(number);
1286                                // if there is a valid dial code
1287                                if (dialCode) {
1288                                    // in case _getDialCode returned an area code as well
1289                                    dialCode = "+".concat(this.selectedCountryData.dialCode);
1290                                    // a lot of numbers will have a space separating the dial code and the main number, and
1291                                    // some NANP numbers will have a hyphen e.g. +1 684-733-1234 - in both cases we want to get
1292                                    // rid of it
1293                                    // NOTE: don't just trim all non-numerics as may want to preserve an open parenthesis etc
1294                                    var start = number[dialCode.length] === " " || number[dialCode.length] === "-" ? dialCode.length + 1 : dialCode.length;
1295                                    number = number.substr(start);
1296                                }
1297                            }
1298                            return this._cap(number);
1299                        }
1300                    }, {
1301                        key: "_triggerCountryChange",
1302                        value: function _triggerCountryChange()
1303                        {
1304                            this._trigger("countrychange");
1305                        }
1306                    }, {
1307                        key: "handleAutoCountry",
1308                        value: function handleAutoCountry()
1309                        {
1310                            if (this.options.initialCountry === "auto") {
1311                                // we must set this even if there is an initial val in the input: in case the initial val is
1312                                // invalid and they delete it - they should see their auto country
1313                                this.defaultCountry = window.intlTelInputGlobals.autoCountry;
1314                                // if there's no initial value in the input, then update the flag
1315                                if (!this.telInput.value) {
1316                                    this.setCountry(this.defaultCountry);
1317                                }
1318                                this.resolveAutoCountryPromise();
1319                            }
1320                        }
1321                    }, {
1322                        key: "handleUtils",
1323                        value: function handleUtils()
1324                        {
1325                            // if the request was successful
1326                            if (window.intlTelInputUtils) {
1327                                // if there's an initial value in the input, then format it
1328                                if (this.telInput.value) {

1442                            this._updateValFromNumber(number);
1443                            if (flagChanged) {
1444                                this._triggerCountryChange();
1445                            }
1446                        }
1447                    }, {
1448                        key: "setPlaceholderNumberType",
1449                        value: function setPlaceholderNumberType(type)
1450                        {
1451                            this.options.placeholderNumberType = type;
1452                            this._updatePlaceholder();
1453                        }
1454                    } ]
1455                );
1456                return Iti;
1457            }();
1458            /********************
1459        *  STATIC METHODS
1460        ********************/
1461            // get the country data object
1462            intlTelInputGlobals.getCountryData = function () {
1463                return allCountries;
1464            };
1465            // inject a <script> element to load utils.js
1466            var injectScript = function injectScript(path, handleSuccess, handleFailure)
1467            {
1468                // inject a new script element into the page
1469                var script = document.createElement("script");
1470                script.onload = function () {
1471                    forEachInstance("handleUtils");
1472                    if (handleSuccess) { handleSuccess();
1473                    }
1474                };
1475                script.onerror = function () {
1476                    forEachInstance("rejectUtilsScriptPromise");
1477                    if (handleFailure) { handleFailure();
1478                    }
1479                };
1480                script.className = "iti-load-utils";
1481                script.async = true;
1482                script.src = path;
1483                document.body.appendChild(script);
1484            };
1485            // load the utils script
1486            intlTelInputGlobals.loadUtils = function (path) {
1487                // 2 options:
1488                // 1) not already started loading (start)
1489                // 2) already started loading (do nothing - just wait for the onload callback to fire, which will
1490                // trigger handleUtils on all instances, invoking their resolveUtilsScriptPromise functions)
1491                if (!window.intlTelInputUtils && !window.intlTelInputGlobals.startedLoadingUtilsScript) {
1492                    // only do this once
1493                    window.intlTelInputGlobals.startedLoadingUtilsScript = true;
1494                    // if we have promises, then return a promise
1495                    if (typeof Promise !== "undefined") {
1496                        return new Promise(
1497                            function (resolve, reject) {
1498                                return injectScript(path, resolve, reject);
1499                            }
1500                        );
1501                    }
1502                    injectScript(path);
1503                }
1504                return null;
1505            };
1506            // default options
1507            intlTelInputGlobals.defaults = defaults;
1508            // version
1509            intlTelInputGlobals.version = "17.0.16";
1510            // convenience wrapper
1511            return function (input, options) {
1512                var iti = new Iti(input, options);
1513                iti._init();
1514                input.setAttribute("data-intl-tel-input-id", iti.id);
1515                window.intlTelInputGlobals.instances[iti.id] = iti;
1516                return iti;
1517            };
1518        }();
1519    }
1520);