{"version":3,"sources":["webpack:///./node_modules/libphonenumber-js/es6/tools/semver-compare.js","webpack:///./node_modules/libphonenumber-js/es6/metadata.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/matchesEntirely.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/getNumberType.js","webpack:///./node_modules/libphonenumber-js/es6/isValid.js","webpack:///./node_modules/libphonenumber-js/es6/constants.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/extension/createExtensionPattern.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/isViablePhoneNumber.js","webpack:///./node_modules/libphonenumber-js/es6/ParseError.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/extension/extractExtension.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/parseDigits.js","webpack:///./node_modules/libphonenumber-js/es6/parseIncompletePhoneNumber.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/mergeArrays.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/checkNumberLength.js","webpack:///./node_modules/libphonenumber-js/es6/isPossible.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/getPossibleCountriesForNumber.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/formatNationalNumberUsingFormat.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/applyInternationalSeparatorStyle.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js","webpack:///./node_modules/libphonenumber-js/es6/format.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/RFC3966.js","webpack:///./node_modules/libphonenumber-js/es6/PhoneNumber.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/stripIddPrefix.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/getCountryByNationalNumber.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/getCountryByCallingCode.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/extractPhoneContext.js","webpack:///./node_modules/libphonenumber-js/es6/helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js","webpack:///./node_modules/libphonenumber-js/es6/parse.js","webpack:///./node_modules/libphonenumber-js/es6/legacy/getNumberType.js","webpack:///./node_modules/libphonenumber-js/es6/legacy/isValidNumber.js","webpack:///./node_modules/libphonenumber-js/index.es6.exports/isValidNumber.js"],"names":["a","split","b","pa","pb","i","na","Number","nb","isNaN","_typeof","obj","Symbol","iterator","constructor","prototype","_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_createClass","protoProps","staticProps","DEFAULT_EXT_PREFIX","CALLING_CODE_REG_EXP","Metadata","metadata","this","Error","is_object","countries","concat","keys","join","type_of","validateMetadata","setVersion","call","value","filter","_","countryCode","v1","v2","v3","nonGeographic","nonGeographical","country","undefined","getCountryMetadata","callingCode","getCountryCodesForCallingCode","countryCodes","countryCallingCodes","selectNumberingPlan","test","hasCountry","numberingPlan","NumberingPlan","hasCallingCode","getNumberingPlanMetadata","getCountryCodeForCallingCode","IDDPrefix","defaultIDDPrefix","nationalNumberPattern","possibleLengths","formats","nationalPrefixForParsing","nationalPrefixTransformRule","leadingDigits","hasTypes","_type","type","ext","country_phone_code_to_countries","country_calling_codes","globalMetadataObject","_this","_getFormats","getDefaultCountryMetadataForRegion","map","Format","_getNationalPrefixFormattingRule","_nationalPrefixForParsing","nationalPrefix","_getNationalPrefixIsOptionalWhenFormatting","types","_type2","Type","format","_format","nationalPrefixFormattingRule","nationalPrefixIsOptionalWhenFormattingInNationalFormat","usesNationalPrefix","FIRST_GROUP_ONLY_PREFIX_PATTERN","getCountryCallingCode","countryCallingCode","version","v4","matchesEntirely","text","regular_expression","RegExp","_createForOfIteratorHelperLoose","o","allowArrayLike","it","next","bind","Array","isArray","minLen","_arrayLikeToArray","n","toString","slice","name","from","_unsupportedIterableToArray","done","arr","len","arr2","NON_FIXED_LINE_PHONE_TYPES","getNumberType","input","options","nationalNumber","phone","isNumberTypeEqualTo","pattern","_step","_iterator","indexOf","isValidNumber","VALID_DIGITS","VALID_PUNCTUATION","maxLength","createExtensionPattern","purpose","optionalExtnSuffix","possibleSeparatorsBetweenNumberAndExtLabel","possibleSeparatorsNumberExtLabelNoComma","VALID_PHONE_NUMBER","VALID_PHONE_NUMBER_START_REG_EXP","VALID_PHONE_NUMBER_WITH_EXTENSION","VALID_PHONE_NUMBER_PATTERN","isViablePhoneNumber","number","_possibleConstructorReturn","self","_assertThisInitialized","ReferenceError","_wrapNativeSuper","Class","_cache","Map","fn","Function","has","get","set","Wrapper","_construct","arguments","_getPrototypeOf","create","_setPrototypeOf","Parent","args","_isNativeReflectConstruct","Reflect","construct","push","apply","sham","Proxy","Boolean","valueOf","e","p","setPrototypeOf","__proto__","getPrototypeOf","ParseError","_Error","subClass","superClass","_inherits","Derived","hasNativeReflectConstruct","_super","result","Super","NewTarget","code","EXTN_PATTERN","DIGITS","parseDigit","character","parseIncompletePhoneNumber","string","parsePhoneNumberCharacter","prevParsedCharacters","checkNumberLength","checkNumberLengthForType","type_info","possible_lengths","mobile_type","merged","element","sort","mergeArrays","actual_length","minimum_length","isPossibleNumber","getPossibleCountriesForNumber","possibleCountries","_metadata","couldNationalNumberBelongToCountry","FIRST_GROUP_PATTERN","formatNationalNumberUsingFormat","_ref","useInternationalFormat","withNationalPrefix","formattedNumber","carrierCode","replace","internationalFormat","trim","applyInternationalSeparatorStyle","SINGLE_IDD_PREFIX_REG_EXP","ownKeys","object","enumerableOnly","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","_objectSpread","source","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","DEFAULT_OPTIONS","formatExtension","extension","formatNumber","addExtension","formatNationalNumber","formatRFC3966","fromCountry","iddPrefix","countryMetadata","getIddPrefix","formatIDD","formatAs","availableFormats","nationalNnumber","leadingDigitsPatterns","lastLeadingDigitsPattern","search","chooseFormatForNumber","PhoneNumber","countryOrCountryCallingCode","_getCountryAndCountry","metadataJson","getCountryAndCountryCallingCode","getMetadata","isNonGeographicCallingCode","phoneNumber","CAPTURING_DIGIT_PATTERN","extractNationalNumber","_extractNationalNumbe","prefixPattern","prefixMatch","exec","capturedGroupsCount","hasCapturedGroups","prefixBeforeNationalNumber","possiblePositionOfTheFirstCapturedGroup","extractNationalNumberFromPossiblyIncompleteNumber","nationalNumberBefore","nationalNumberAfter","shouldHaveExtractedNationalPrefix","isPossibleIncompleteNationalNumber","extractCountryCallingCode","isNumberWithIddPrefix","numberWithoutIDD","IDDPrefixPattern","matchedGroups","match","stripIddPrefix","_extractCountryCallin","possibleShorterNumber","possibleShorterNationalNumber","extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","shorterNumber","countryCallingCodeSource","_countryCallingCode","getCountryByCallingCode","nationalPhoneNumber","defaultCountry","matchingCountries","getCountryByNationalNumber","RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_","RFC3966_DOMAINNAME_PATTERN_","RFC3966_PREFIX_","RFC3966_PHONE_CONTEXT_","extractFormattedPhoneNumberFromPossibleRfc3966NumberUri","numberToParse","phoneNumberString","extractFormattedPhoneNumber","phoneContext","numberToExtractFrom","indexOfPhoneContext","phoneContextStart","phoneContextEnd","substring","extractPhoneContext","isPhoneContextValid","charAt","indexOfNationalNumber","indexOfRfc3966Prefix","indexOfIsdn","PHONE_NUMBER_START_PATTERN","AFTER_PHONE_NUMBER_END_PATTERN","parse","_parseInput","extract","throwOnError","startsAt","_extractFormattedPhoneNumber","isViablePhoneNumberStart","error","withExtensionStripped","start","numberWithoutExtension","matches","extractExtension","parseInput","formattedPhoneNumber","_parsePhoneNumber","defaultCallingCode","exactCountry","parsePhoneNumber","hasSelectedNumberingPlan","__countryCallingCodeSource","valid","extended","possible","_i","_s","_e","_arr","_n","_d","err","normalizeArguments","_Array$prototype$slic2","arg_1","arg_2","arg_3","arg_4","_normalizeArguments","withMetadataArgument"],"mappings":"qJAQe,gBACbA,EAAIA,EAAEC,MAAM,KACZC,EAAIA,EAAED,MAAM,KAIZ,IAHA,IAAIE,EAAKH,EAAE,GAAGC,MAAM,KAChBG,EAAKF,EAAE,GAAGD,MAAM,KAEXI,EAAI,EAAGA,EAAI,EAAGA,IAAK,CAC1B,IAAIC,EAAKC,OAAOJ,EAAGE,IACfG,EAAKD,OAAOH,EAAGC,IACnB,GAAIC,EAAKE,EAAI,OAAO,EACpB,GAAIA,EAAKF,EAAI,OAAQ,EACrB,IAAKG,MAAMH,IAAOG,MAAMD,GAAK,OAAO,EACpC,GAAIC,MAAMH,KAAQG,MAAMD,GAAK,OAAQ,EAGvC,OAAIR,EAAE,IAAME,EAAE,GACLF,EAAE,GAAKE,EAAE,GAAK,EAAIF,EAAE,GAAKE,EAAE,IAAM,EAAI,GAGtCF,EAAE,IAAME,EAAE,GAAK,EAAIF,EAAE,KAAOE,EAAE,IAAM,EAAI,GC3BlD,SAASQ,EAAQC,GAGf,OAAOD,EAAU,mBAAqBE,QAAU,iBAAmBA,OAAOC,SAAW,SAAUF,GAC7F,cAAcA,GACZ,SAAUA,GACZ,OAAOA,GAAO,mBAAqBC,QAAUD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAOG,UAAY,gBAAkBJ,GACvHD,EAAQC,GAGb,SAASK,EAAgBC,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,qCAIxB,SAASC,EAAkBC,EAAQC,GACjC,IAAK,IAAIjB,EAAI,EAAGA,EAAIiB,EAAMC,OAAQlB,IAAK,CACrC,IAAImB,EAAaF,EAAMjB,GACvBmB,EAAWC,WAAaD,EAAWC,aAAc,EACjDD,EAAWE,cAAe,EACtB,UAAWF,IAAYA,EAAWG,UAAW,GACjDC,OAAOC,eAAeR,EAAQG,EAAWM,IAAKN,IAIlD,SAASO,EAAab,EAAac,EAAYC,GAM7C,OALID,GAAYZ,EAAkBF,EAAYH,UAAWiB,GACrDC,GAAab,EAAkBF,EAAae,GAChDL,OAAOC,eAAeX,EAAa,YAAa,CAC9CS,UAAU,IAELT,EAMT,IAKIgB,EAAqB,SACrBC,EAAuB,QAKvBC,EAAwB,WAC1B,SAASA,EAASC,GAChBrB,EAAgBsB,KAAMF,GA8hBnB,SAA0BC,GAC/B,IAAKA,EACH,MAAM,IAAIE,MAAM,6EAKlB,IAAKC,EAAUH,KAAcG,EAAUH,EAASI,WAC9C,MAAM,IAAIF,MAAM,sJAAsJG,OAAOF,EAAUH,GAAY,yBAA2BT,OAAOe,KAAKN,GAAUO,KAAK,MAAQ,KAAO,KAAOC,EAAQR,GAAY,KAAOA,EAAU,MApiBpTS,CAAiBT,GACjBC,KAAKD,SAAWA,EAChBU,EAAWC,KAAKV,KAAMD,GAiPxB,OA9OAN,EAAaK,EAAU,CAAC,CACtBN,IAAK,eACLmB,MAAO,WACL,OAAOrB,OAAOe,KAAKL,KAAKD,SAASI,WAAWS,QAAO,SAAUC,GAC3D,MAAa,QAANA,OAGV,CACDrB,IAAK,qBACLmB,MAAO,SAA4BG,GACjC,OAAOd,KAAKD,SAASI,UAAUW,KAEhC,CACDtB,IAAK,gBACLmB,MAAO,WACL,KAAIX,KAAKe,IAAMf,KAAKgB,IAAMhB,KAAKiB,IAI/B,OAAOjB,KAAKD,SAASmB,eAAiBlB,KAAKD,SAASoB,kBAErD,CACD3B,IAAK,aACLmB,MAAO,SAAoBS,GACzB,YAA4CC,IAArCrB,KAAKsB,mBAAmBF,KAEhC,CACD5B,IAAK,iBACLmB,MAAO,SAAwBY,GAC7B,GAAIvB,KAAKwB,8BAA8BD,GACrC,OAAO,EAGT,GAAIvB,KAAKkB,iBACP,GAAIlB,KAAKkB,gBAAgBK,GACvB,OAAO,MAEJ,CAEL,IAAIE,EAAezB,KAAK0B,sBAAsBH,GAE9C,GAAIE,GAAwC,IAAxBA,EAAaxC,QAAoC,QAApBwC,EAAa,GAC5D,OAAO,KAIZ,CACDjC,IAAK,6BACLmB,MAAO,SAAoCY,GACzC,OAAIvB,KAAKkB,kBACAlB,KAAKkB,gBAAgBK,IAErBvB,KAAKwB,8BAA8BD,KAI7C,CACD/B,IAAK,UACLmB,MAAO,SAAiBG,GACtB,OAAOd,KAAK2B,oBAAoBb,KAEjC,CACDtB,IAAK,sBACLmB,MAAO,SAA6BG,EAAaS,GAO/C,GALIT,GAAejB,EAAqB+B,KAAKd,KAC3CS,EAAcT,EACdA,EAAc,MAGZA,GAA+B,QAAhBA,EAAuB,CACxC,IAAKd,KAAK6B,WAAWf,GACnB,MAAM,IAAIb,MAAM,oBAAoBG,OAAOU,IAG7Cd,KAAK8B,cAAgB,IAAIC,EAAc/B,KAAKsB,mBAAmBR,GAAcd,WACxE,GAAIuB,EAAa,CACtB,IAAKvB,KAAKgC,eAAeT,GACvB,MAAM,IAAItB,MAAM,yBAAyBG,OAAOmB,IAGlDvB,KAAK8B,cAAgB,IAAIC,EAAc/B,KAAKiC,yBAAyBV,GAAcvB,WAEnFA,KAAK8B,mBAAgBT,EAGvB,OAAOrB,OAER,CACDR,IAAK,gCACLmB,MAAO,SAAuCY,GAC5C,IAAIE,EAAezB,KAAK0B,sBAAsBH,GAE9C,GAAIE,EAAc,CAUhB,GAA4B,IAAxBA,EAAaxC,QAA2C,IAA3BwC,EAAa,GAAGxC,OAC/C,OAGF,OAAOwC,KAGV,CACDjC,IAAK,+BACLmB,MAAO,SAAsCY,GAC3C,IAAIE,EAAezB,KAAKwB,8BAA8BD,GAEtD,GAAIE,EACF,OAAOA,EAAa,KAGvB,CACDjC,IAAK,2BACLmB,MAAO,SAAkCY,GACvC,IAAIT,EAAcd,KAAKkC,6BAA6BX,GAEpD,GAAIT,EACF,OAAOd,KAAKsB,mBAAmBR,GAGjC,GAAId,KAAKkB,gBAAiB,CACxB,IAAInB,EAAWC,KAAKkB,gBAAgBK,GAEpC,GAAIxB,EACF,OAAOA,MAEJ,CAML,IAAI0B,EAAezB,KAAK0B,sBAAsBH,GAE9C,GAAIE,GAAwC,IAAxBA,EAAaxC,QAAoC,QAApBwC,EAAa,GAC5D,OAAOzB,KAAKD,SAASI,UAAU,UAKpC,CACDX,IAAK,qBACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcP,gBAG3B,CACD/B,IAAK,YACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcK,cAG3B,CACD3C,IAAK,mBACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcM,qBAG3B,CACD5C,IAAK,wBACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcO,0BAG3B,CACD7C,IAAK,kBACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcQ,oBAG3B,CACD9C,IAAK,UACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcS,YAG3B,CACD/C,IAAK,2BACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcU,6BAG3B,CACDhD,IAAK,8BACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcW,gCAG3B,CACDjD,IAAK,gBACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcY,kBAG3B,CACDlD,IAAK,WACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAca,aAG3B,CACDnD,IAAK,OACLmB,MAAO,SAAciC,GACnB,OAAO5C,KAAK8B,cAAce,KAAKD,KAGhC,CACDpD,IAAK,MACLmB,MAAO,WACL,OAAOX,KAAK8B,cAAcgB,QAE3B,CACDtD,IAAK,sBACLmB,MAAO,WACL,OAAIX,KAAKe,GAAWf,KAAKD,SAASgD,gCAC3B/C,KAAKD,SAASiD,wBAGtB,CACDxD,IAAK,oCACLmB,MAAO,SAA2CY,GAChD,OAAOvB,KAAK2B,oBAAoBJ,KAEjC,CACD/B,IAAK,2BACLmB,MAAO,WACL,YAA8BU,IAAvBrB,KAAK8B,kBAIThC,EAvPmB,GA4PxBiC,EAA6B,WAC/B,SAASA,EAAchC,EAAUkD,GAC/BvE,EAAgBsB,KAAM+B,GAEtB/B,KAAKiD,qBAAuBA,EAC5BjD,KAAKD,SAAWA,EAChBU,EAAWC,KAAKV,KAAMiD,EAAqBlD,UAwJ7C,OArJAN,EAAasC,EAAe,CAAC,CAC3BvC,IAAK,cACLmB,MAAO,WACL,OAAOX,KAAKD,SAAS,KAQtB,CACDP,IAAK,qCACLmB,MAAO,WACL,OAAOX,KAAKiD,qBAAqBhB,yBAAyBjC,KAAKuB,iBAGhE,CACD/B,IAAK,YACLmB,MAAO,WACL,IAAIX,KAAKe,KAAMf,KAAKgB,GACpB,OAAOhB,KAAKD,SAAS,KAGtB,CACDP,IAAK,mBACLmB,MAAO,WACL,IAAIX,KAAKe,KAAMf,KAAKgB,GACpB,OAAOhB,KAAKD,SAAS,MAEtB,CACDP,IAAK,wBACLmB,MAAO,WACL,OAAIX,KAAKe,IAAMf,KAAKgB,GAAWhB,KAAKD,SAAS,GACtCC,KAAKD,SAAS,KAGtB,CACDP,IAAK,kBACLmB,MAAO,WACL,IAAIX,KAAKe,GACT,OAAOf,KAAKD,SAASC,KAAKgB,GAAK,EAAI,KAEpC,CACDxB,IAAK,cACLmB,MAAO,SAAqBZ,GAC1B,OAAOA,EAASC,KAAKe,GAAK,EAAIf,KAAKgB,GAAK,EAAI,KAK7C,CACDxB,IAAK,UACLmB,MAAO,WACL,IAAIuC,EAAQlD,KAERuC,EAAUvC,KAAKmD,YAAYnD,KAAKD,WAAaC,KAAKmD,YAAYnD,KAAKoD,uCAAyC,GAChH,OAAOb,EAAQc,KAAI,SAAUxC,GAC3B,OAAO,IAAIyC,EAAOzC,EAAGqC,QAGxB,CACD1D,IAAK,iBACLmB,MAAO,WACL,OAAOX,KAAKD,SAASC,KAAKe,GAAK,EAAIf,KAAKgB,GAAK,EAAI,KAElD,CACDxB,IAAK,mCACLmB,MAAO,SAA0CZ,GAC/C,OAAOA,EAASC,KAAKe,GAAK,EAAIf,KAAKgB,GAAK,EAAI,KAK7C,CACDxB,IAAK,+BACLmB,MAAO,WACL,OAAOX,KAAKuD,iCAAiCvD,KAAKD,WAAaC,KAAKuD,iCAAiCvD,KAAKoD,wCAE3G,CACD5D,IAAK,4BACLmB,MAAO,WACL,OAAOX,KAAKD,SAASC,KAAKe,GAAK,EAAIf,KAAKgB,GAAK,EAAI,KAElD,CACDxB,IAAK,2BACLmB,MAAO,WAGL,OAAOX,KAAKwD,6BAA+BxD,KAAKyD,mBAEjD,CACDjE,IAAK,8BACLmB,MAAO,WACL,OAAOX,KAAKD,SAASC,KAAKe,GAAK,EAAIf,KAAKgB,GAAK,EAAI,KAElD,CACDxB,IAAK,6CACLmB,MAAO,WACL,QAASX,KAAKD,SAASC,KAAKe,GAAK,EAAIf,KAAKgB,GAAK,EAAI,KAMpD,CACDxB,IAAK,yDACLmB,MAAO,WACL,OAAOX,KAAK0D,2CAA2C1D,KAAKD,WAAaC,KAAK0D,2CAA2C1D,KAAKoD,wCAE/H,CACD5D,IAAK,gBACLmB,MAAO,WACL,OAAOX,KAAKD,SAASC,KAAKe,GAAK,EAAIf,KAAKgB,GAAK,EAAI,MAElD,CACDxB,IAAK,QACLmB,MAAO,WACL,OAAOX,KAAKD,SAASC,KAAKe,GAAK,EAAIf,KAAKgB,GAAK,GAAK,MAEnD,CACDxB,IAAK,WACLmB,MAAO,WAIL,QAAIX,KAAK2D,SAAmC,IAAxB3D,KAAK2D,QAAQ1E,WAMxBe,KAAK2D,UAEf,CACDnE,IAAK,OACLmB,MAAO,SAAciD,GACnB,GAAI5D,KAAK2C,YAAc,EAAQ3C,KAAK2D,QAASC,GAC3C,OAAO,IAAIC,EAAK,EAAQ7D,KAAK2D,QAASC,GAAS5D,QAGlD,CACDR,IAAK,MACLmB,MAAO,WACL,OAAIX,KAAKe,IAAMf,KAAKgB,GAAWpB,EACxBI,KAAKD,SAAS,KAAOH,MAIzBmC,EA9JwB,GAiK7BuB,EAAsB,WACxB,SAASA,EAAOQ,EAAQ/D,GACtBrB,EAAgBsB,KAAMsD,GAEtBtD,KAAK+D,QAAUD,EACf9D,KAAKD,SAAWA,EAwDlB,OArDAN,EAAa6D,EAAQ,CAAC,CACpB9D,IAAK,UACLmB,MAAO,WACL,OAAOX,KAAK+D,QAAQ,KAErB,CACDvE,IAAK,SACLmB,MAAO,WACL,OAAOX,KAAK+D,QAAQ,KAErB,CACDvE,IAAK,wBACLmB,MAAO,WACL,OAAOX,KAAK+D,QAAQ,IAAM,KAE3B,CACDvE,IAAK,+BACLmB,MAAO,WACL,OAAOX,KAAK+D,QAAQ,IAAM/D,KAAKD,SAASiE,iCAEzC,CACDxE,IAAK,yDACLmB,MAAO,WACL,QAASX,KAAK+D,QAAQ,IAAM/D,KAAKD,SAASkE,2DAE3C,CACDzE,IAAK,0DACLmB,MAAO,WAML,OAAOX,KAAKkE,uBAAyBlE,KAAKiE,2DAG3C,CACDzE,IAAK,qBACLmB,MAAO,WACL,SAAOX,KAAKgE,gCACXG,EAAgCvC,KAAK5B,KAAKgE,mCAM5C,CACDxE,IAAK,sBACLmB,MAAO,WACL,OAAOX,KAAK+D,QAAQ,IAAM/D,KAAK8D,aAI5BR,EA7DiB,GAsEtBa,EAAkC,cAElCN,EAAoB,WACtB,SAASA,EAAKhB,EAAM9C,GAClBrB,EAAgBsB,KAAM6D,GAEtB7D,KAAK6C,KAAOA,EACZ7C,KAAKD,SAAWA,EAiBlB,OAdAN,EAAaoE,EAAM,CAAC,CAClBrE,IAAK,UACLmB,MAAO,WACL,OAAIX,KAAKD,SAASgB,GAAWf,KAAK6C,KAC3B7C,KAAK6C,KAAK,KAElB,CACDrD,IAAK,kBACLmB,MAAO,WACL,IAAIX,KAAKD,SAASgB,GAClB,OAAOf,KAAK6C,KAAK,IAAM7C,KAAKD,SAASuC,sBAIlCuB,EAtBe,GAyBxB,SAAS,EAAQF,EAAOd,GACtB,OAAQA,GACN,IAAK,aACH,OAAOc,EAAM,GAEf,IAAK,SACH,OAAOA,EAAM,GAEf,IAAK,YACH,OAAOA,EAAM,GAEf,IAAK,eACH,OAAOA,EAAM,GAEf,IAAK,kBACH,OAAOA,EAAM,GAEf,IAAK,YACH,OAAOA,EAAM,GAEf,IAAK,MACH,OAAOA,EAAM,GAEf,IAAK,QACH,OAAOA,EAAM,GAEf,IAAK,OACH,OAAOA,EAAM,GAEf,IAAK,cACH,OAAOA,EAAM,IAmBnB,IAAIzD,EAAY,SAAmBW,GACjC,MAAsB,WAAfzC,EAAQyC,IAObN,EAAU,SAAiBM,GAC7B,OAAOzC,EAAQyC,IAiCV,SAASuD,EAAsBhD,EAASrB,GAG7C,IAFAA,EAAW,IAAID,EAASC,IAEX8B,WAAWT,GACtB,OAAOrB,EAASqB,QAAQA,GAASiD,qBAGnC,MAAM,IAAIpE,MAAM,oBAAoBG,OAAOgB,IAQ7C,SAASX,EAAWV,GAClB,IAAIuE,EAAUvE,EAASuE,QAEA,kBAAZA,GACTtE,KAAKe,GAAiB,IAAZuD,EACVtE,KAAKgB,GAAiB,IAAZsD,EACVtE,KAAKiB,GAAiB,IAAZqD,EACVtE,KAAKuE,GAAiB,IAAZD,GAELA,GAEgC,IAA1B,EAAQA,EA5nBd,SA6nBHtE,KAAKgB,IAAK,GACyB,IAA1B,EAAQsD,EA5nBd,UA6nBHtE,KAAKiB,IAAK,EAEVjB,KAAKuE,IAAK,EANVvE,KAAKe,IAAK,EC9pBD,SAASyD,EAAgBC,EAAMC,GAI5C,OADAD,EAAOA,GAAQ,GACR,IAAIE,OAAO,OAASD,EAAqB,MAAM9C,KAAK6C,GCT7D,SAASG,EAAgCC,EAAGC,GAC1C,IAAIC,EAAuB,qBAAXzG,QAA0BuG,EAAEvG,OAAOC,WAAasG,EAAE,cAClE,GAAIE,EAAI,OAAQA,EAAKA,EAAGrE,KAAKmE,IAAIG,KAAKC,KAAKF,GAE3C,GAAIG,MAAMC,QAAQN,KAAOE,EAiB3B,SAAqCF,EAAGO,GACtC,IAAKP,EAAG,OACR,GAAiB,kBAANA,EAAgB,OAAOQ,EAAkBR,EAAGO,GACvD,IAAIE,EAAIhG,OAAOb,UAAU8G,SAAS7E,KAAKmE,GAAGW,MAAM,GAAI,GAC1C,WAANF,GAAkBT,EAAErG,cAAa8G,EAAIT,EAAErG,YAAYiH,MACvD,GAAU,QAANH,GAAqB,QAANA,EAAa,OAAOJ,MAAMQ,KAAKb,GAClD,GAAU,cAANS,GAAqB,2CAA2C1D,KAAK0D,GAAI,OAAOD,EAAkBR,EAAGO,GAvB3EO,CAA4Bd,KAAOC,GAAkBD,GAAyB,kBAAbA,EAAE5F,OAAqB,CAChH8F,IAAIF,EAAIE,GACZ,IAAIhH,EAAI,EACR,OAAO,WACL,OAAIA,GAAK8G,EAAE5F,OAAe,CACxB2G,MAAM,GAED,CACLA,MAAM,EACNjF,MAAOkE,EAAE9G,OAKf,MAAM,IAAIc,UAAU,yIAYtB,SAASwG,EAAkBQ,EAAKC,IACnB,MAAPA,GAAeA,EAAMD,EAAI5G,UAAQ6G,EAAMD,EAAI5G,QAE/C,IAAK,IAAIlB,EAAI,EAAGgI,EAAO,IAAIb,MAAMY,GAAM/H,EAAI+H,EAAK/H,IAC9CgI,EAAKhI,GAAK8H,EAAI9H,GAGhB,OAAOgI,EAKT,IAAIC,EAA6B,CAAC,SAAU,eAAgB,YAAa,cAAe,OAAQ,kBAAmB,QAAS,MAAO,aAEpH,SAASC,EAAcC,EAAOC,EAASpG,GAMpD,GAHAoG,EAAUA,GAAW,GAGhBD,EAAM9E,QAAX,EAIArB,EAAW,IAAID,EAASC,IACf4B,oBAAoBuE,EAAM9E,QAAS8E,EAAM7B,oBAClD,IAAI+B,EAAiBD,EAAQnF,GAAKkF,EAAME,eAAiBF,EAAMG,MAI/D,GAAK7B,EAAgB4B,EAAgBrG,EAASsC,yBAA9C,CAKA,GAAIiE,EAAoBF,EAAgB,aAAcrG,GAKpD,OAAIA,EAAS8C,KAAK,WAAmD,KAAtC9C,EAAS8C,KAAK,UAAU0D,UAC9C,uBAUJxG,EAAS8C,KAAK,UAQfyD,EAAoBF,EAAgB,SAAUrG,GACzC,uBAGF,aAXE,uBAcX,IAAK,IAA6EyG,EAAzEC,EAAY7B,EAAgCoB,KAAsCQ,EAAQC,KAAab,MAAO,CACrH,IAAI/C,EAAO2D,EAAM7F,MAEjB,GAAI2F,EAAoBF,EAAgBvD,EAAM9C,GAC5C,OAAO8C,KAIN,SAASyD,EAAoBF,EAAgBvD,EAAM9C,GAGxD,UAFA8C,EAAO9C,EAAS8C,KAAKA,MAEPA,EAAK0D,eAUf1D,EAAKP,mBAAqBO,EAAKP,kBAAkBoE,QAAQN,EAAenH,QAAU,IAI/EuF,EAAgB4B,EAAgBvD,EAAK0D,YCnF/B,SAASI,EAAcT,EAAOC,EAASpG,GAiBpD,OAdAoG,EAAUA,GAAW,IACrBpG,EAAW,IAAID,EAASC,IAUf4B,oBAAoBuE,EAAM9E,QAAS8E,EAAM7B,oBAG9CtE,EAAS4C,gBACiDtB,IAArD4E,EAAcC,EAAOC,EAASpG,EAASA,UAMzCyE,EADc2B,EAAQnF,GAAKkF,EAAME,eAAiBF,EAAMG,MACxBtG,EAASsC,yBC7D3C,IAQIuE,EAAe,6CAafC,EAAoB,GAAGzG,OAXrB,oCAWoCA,OAVnC,WAUmDA,OATtD,WASmEA,OARtD,+BAQyEA,OAPlF,oCAOmGA,OALrG,uBCRT,EAA4B,SAAmC0G,GACjE,MAAO,KAAK1G,OAAOwG,EAAc,QAAQxG,OAAO0G,EAAW,OAW9C,SAASC,EAAuBC,GAQ7C,IAmBIC,EAAqB,KAyDzB,MAvGwB,QA2EY,EAhDH,MA4EhB,KAzBEC,iIAA8F,EAnDhF,MAmDwID,GAyBnI,KAtBlBC,2FAA+F,EAhDlF,KAgD0ID,GAsB/G,KA3CnC,QAwB8B,EAhD7B,KAgD8E,KAmBR,KAhBzEE,kDAAuG,EAzD/F,MAyDqJF,GAgB3D,KAbpGE,8CAAkF,EAzDtE,KAyD8HF,GClEjK,IAKWG,EAAqB,qBAA4CP,EAA5C,0DAAkHA,EAAlH,+CAU5BQ,EAAmC,IAAI1C,OAAO,sBAAkDkC,EAAlD,2DAAwH,KAC/JS,EAAoCF,EAC/C,MAAQL,IAA2B,KAG/BQ,EAA6B,IAAI5C,OACrC,sDACM2C,EAAoC,IAAK,KAQhC,SAASE,EAAoBC,GAC1C,OAAOA,EAAOxI,QFxDgB,GEwDgBsI,EAA2B3F,KAAK6F,GCzDhF,SAAS,EAAQpJ,GAGf,OAAO,EAAU,mBAAqBC,QAAU,iBAAmBA,OAAOC,SAAW,SAAUF,GAC7F,cAAcA,GACZ,SAAUA,GACZ,OAAOA,GAAO,mBAAqBC,QAAUD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAOG,UAAY,gBAAkBJ,GACvH,EAAQA,GAGb,SAAS,EAAkBU,EAAQC,GACjC,IAAK,IAAIjB,EAAI,EAAGA,EAAIiB,EAAMC,OAAQlB,IAAK,CACrC,IAAImB,EAAaF,EAAMjB,GACvBmB,EAAWC,WAAaD,EAAWC,aAAc,EACjDD,EAAWE,cAAe,EACtB,UAAWF,IAAYA,EAAWG,UAAW,GACjDC,OAAOC,eAAeR,EAAQG,EAAWM,IAAKN,IAwDlD,SAASwI,EAA2BC,EAAMjH,GACxC,GAAIA,IAA2B,WAAlB,EAAQA,IAAsC,oBAATA,GAChD,OAAOA,EACF,QAAa,IAATA,EACT,MAAM,IAAI7B,UAAU,4DAGtB,OAAO+I,EAAuBD,GAGhC,SAASC,EAAuBD,GAC9B,QAAa,IAATA,EACF,MAAM,IAAIE,eAAe,6DAG3B,OAAOF,EAGT,SAASG,EAAiBC,GACxB,IAAIC,EAAwB,oBAARC,IAAqB,IAAIA,SAAQ5G,EA8BrD,OA5BAyG,EAAmB,SAA0BC,GAC3C,GAAc,OAAVA,IA4DmBG,EA5DkBH,GA6DqB,IAAzDI,SAAS5C,SAAS7E,KAAKwH,GAAIxB,QAAQ,kBA7DS,OAAOqB,EA4D5D,IAA2BG,EA1DvB,GAAqB,oBAAVH,EACT,MAAM,IAAIlJ,UAAU,sDAGtB,GAAsB,qBAAXmJ,EAAwB,CACjC,GAAIA,EAAOI,IAAIL,GAAQ,OAAOC,EAAOK,IAAIN,GAEzCC,EAAOM,IAAIP,EAAOQ,GAGpB,SAASA,IACP,OAAOC,EAAWT,EAAOU,UAAWC,EAAgB1I,MAAMxB,aAW5D,OARA+J,EAAQ9J,UAAYa,OAAOqJ,OAAOZ,EAAMtJ,UAAW,CACjDD,YAAa,CACXmC,MAAO4H,EACPpJ,YAAY,EACZE,UAAU,EACVD,cAAc,KAGXwJ,EAAgBL,EAASR,IAG3BD,EAAiBC,GAG1B,SAASS,EAAWK,EAAQC,EAAMf,GAchC,OAZES,EADEO,IACWC,QAAQC,UAER,SAAoBJ,EAAQC,EAAMf,GAC7C,IAAIrK,EAAI,CAAC,MACTA,EAAEwL,KAAKC,MAAMzL,EAAGoL,GAChB,IACInK,EAAW,IADGwJ,SAASlD,KAAKkE,MAAMN,EAAQnL,IAG9C,OADIqK,GAAOa,EAAgBjK,EAAUoJ,EAAMtJ,WACpCE,GAIJ6J,EAAWW,MAAM,KAAMV,WAGhC,SAASM,IACP,GAAuB,qBAAZC,UAA4BA,QAAQC,UAAW,OAAO,EACjE,GAAID,QAAQC,UAAUG,KAAM,OAAO,EACnC,GAAqB,oBAAVC,MAAsB,OAAO,EAExC,IAEE,OADAC,QAAQ7K,UAAU8K,QAAQ7I,KAAKsI,QAAQC,UAAUK,QAAS,IAAI,iBACvD,EACP,MAAOE,GACP,OAAO,GAQX,SAASZ,EAAgB/D,EAAG4E,GAM1B,OALAb,EAAkBtJ,OAAOoK,gBAAkB,SAAyB7E,EAAG4E,GAErE,OADA5E,EAAE8E,UAAYF,EACP5E,GAGF+D,EAAgB/D,EAAG4E,GAG5B,SAASf,EAAgB7D,GAIvB,OAHA6D,EAAkBpJ,OAAOoK,eAAiBpK,OAAOsK,eAAiB,SAAyB/E,GACzF,OAAOA,EAAE8E,WAAarK,OAAOsK,eAAe/E,IAEvC6D,EAAgB7D,GAQzB,IAAIgF,EAA0B,SAAUC,IAhJxC,SAAmBC,EAAUC,GAC3B,GAA0B,oBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAInL,UAAU,sDAGtBkL,EAAStL,UAAYa,OAAOqJ,OAAOqB,GAAcA,EAAWvL,UAAW,CACrED,YAAa,CACXmC,MAAOoJ,EACP1K,UAAU,EACVD,cAAc,KAGlBE,OAAOC,eAAewK,EAAU,YAAa,CAC3C1K,UAAU,IAER2K,GAAYpB,EAAgBmB,EAAUC,GAkI1CC,CAAUJ,EAAYC,GAEtB,IAjIoBI,EAChBC,EAlCgBvL,EAAac,EAAYC,EAkKzCyK,GAjIgBF,EAiIML,EAhItBM,EAA4BpB,IAEzB,WACL,IACIsB,EADAC,EAAQ5B,EAAgBwB,GAG5B,GAAIC,EAA2B,CAC7B,IAAII,EAAY7B,EAAgB1I,MAAMxB,YAEtC6L,EAASrB,QAAQC,UAAUqB,EAAO7B,UAAW8B,QAE7CF,EAASC,EAAMnB,MAAMnJ,KAAMyI,WAG7B,OAAOf,EAA2B1H,KAAMqK,KAoH1C,SAASR,EAAWW,GAClB,IAAItH,EASJ,OArKJ,SAAyBvE,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,qCA4JpB,CAAgBmB,KAAM6J,GAEtB3G,EAAQkH,EAAO1J,KAAKV,KAAMwK,GAG1BlL,OAAOoK,eAAe9B,EAAuB1E,GAAQ2G,EAAWpL,WAChEyE,EAAMuC,KAAOvC,EAAM1E,YAAYiH,KACxBvC,EAGT,OAjLoBtE,EAiLAiL,EAhLhBnK,GAAY,EAAkBd,EAAYH,UAAWiB,GACrDC,GAAa,EAAkBf,EAAae,GAChDL,OAAOC,eAAeX,EAAa,YAAa,CAC9CS,UAAU,IAELT,EAyJqB,CAmBdkJ,EAAiB7H,QCnM7BwK,EAAe,IAAI9F,OAAO,MAAQoC,IAA2B,KAAM,KC2ChE,IAAI2D,EAAS,CAClB,EAAK,IACL,EAAK,IACL,EAAK,IACL,EAAK,IACL,EAAK,IACL,EAAK,IACL,EAAK,IACL,EAAK,IACL,EAAK,IACL,EAAK,IACL,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,IAEV,SAAU,KAGL,SAASC,EAAWC,GACzB,OAAOF,EAAOE,GCvHhB,SAAS,EAAgC/F,EAAGC,GAC1C,IAAIC,EAAuB,qBAAXzG,QAA0BuG,EAAEvG,OAAOC,WAAasG,EAAE,cAClE,GAAIE,EAAI,OAAQA,EAAKA,EAAGrE,KAAKmE,IAAIG,KAAKC,KAAKF,GAE3C,GAAIG,MAAMC,QAAQN,KAAOE,EAiB3B,SAAqCF,EAAGO,GACtC,IAAKP,EAAG,OACR,GAAiB,kBAANA,EAAgB,OAAO,EAAkBA,EAAGO,GACvD,IAAIE,EAAIhG,OAAOb,UAAU8G,SAAS7E,KAAKmE,GAAGW,MAAM,GAAI,GAC1C,WAANF,GAAkBT,EAAErG,cAAa8G,EAAIT,EAAErG,YAAYiH,MACvD,GAAU,QAANH,GAAqB,QAANA,EAAa,OAAOJ,MAAMQ,KAAKb,GAClD,GAAU,cAANS,GAAqB,2CAA2C1D,KAAK0D,GAAI,OAAO,EAAkBT,EAAGO,GAvB3E,CAA4BP,KAAOC,GAAkBD,GAAyB,kBAAbA,EAAE5F,OAAqB,CAChH8F,IAAIF,EAAIE,GACZ,IAAIhH,EAAI,EACR,OAAO,WACL,OAAIA,GAAK8G,EAAE5F,OAAe,CACxB2G,MAAM,GAED,CACLA,MAAM,EACNjF,MAAOkE,EAAE9G,OAKf,MAAM,IAAIc,UAAU,yIAYtB,SAAS,EAAkBgH,EAAKC,IACnB,MAAPA,GAAeA,EAAMD,EAAI5G,UAAQ6G,EAAMD,EAAI5G,QAE/C,IAAK,IAAIlB,EAAI,EAAGgI,EAAO,IAAIb,MAAMY,GAAM/H,EAAI+H,EAAK/H,IAC9CgI,EAAKhI,GAAK8H,EAAI9H,GAGhB,OAAOgI,EAoBM,SAAS8E,EAA2BC,GAQjD,IAPA,IAOwEtE,EAPpE6D,EAAS,GAOJ5D,EAAY,EAAgCqE,EAAOnN,MAAM,OAAe6I,EAAQC,KAAab,MAAO,CAE3GyE,GAAUU,EADMvE,EAAM7F,MACyB0J,IAAW,GAG5D,OAAOA,EAcF,SAASU,EAA0BH,EAAWI,GAEnD,GAAkB,MAAdJ,EAAmB,CAGrB,GAAII,EACF,OAGF,MAAO,IAIT,OAAOL,EAAWC,GCjGpB,SAAS,GAAgC/F,EAAGC,GAC1C,IAAIC,EAAuB,qBAAXzG,QAA0BuG,EAAEvG,OAAOC,WAAasG,EAAE,cAClE,GAAIE,EAAI,OAAQA,EAAKA,EAAGrE,KAAKmE,IAAIG,KAAKC,KAAKF,GAE3C,GAAIG,MAAMC,QAAQN,KAAOE,EAiB3B,SAAqCF,EAAGO,GACtC,IAAKP,EAAG,OACR,GAAiB,kBAANA,EAAgB,OAAO,GAAkBA,EAAGO,GACvD,IAAIE,EAAIhG,OAAOb,UAAU8G,SAAS7E,KAAKmE,GAAGW,MAAM,GAAI,GAC1C,WAANF,GAAkBT,EAAErG,cAAa8G,EAAIT,EAAErG,YAAYiH,MACvD,GAAU,QAANH,GAAqB,QAANA,EAAa,OAAOJ,MAAMQ,KAAKb,GAClD,GAAU,cAANS,GAAqB,2CAA2C1D,KAAK0D,GAAI,OAAO,GAAkBT,EAAGO,GAvB3E,CAA4BP,KAAOC,GAAkBD,GAAyB,kBAAbA,EAAE5F,OAAqB,CAChH8F,IAAIF,EAAIE,GACZ,IAAIhH,EAAI,EACR,OAAO,WACL,OAAIA,GAAK8G,EAAE5F,OAAe,CACxB2G,MAAM,GAED,CACLA,MAAM,EACNjF,MAAOkE,EAAE9G,OAKf,MAAM,IAAIc,UAAU,yIAYtB,SAAS,GAAkBgH,EAAKC,IACnB,MAAPA,GAAeA,EAAMD,EAAI5G,UAAQ6G,EAAMD,EAAI5G,QAE/C,IAAK,IAAIlB,EAAI,EAAGgI,EAAO,IAAIb,MAAMY,GAAM/H,EAAI+H,EAAK/H,IAC9CgI,EAAKhI,GAAK8H,EAAI9H,GAGhB,OAAOgI,ECpCM,SAASkF,GAAkB7E,EAAgBrG,GACxD,OAAOmL,GAAyB9E,OAAgB/E,EAAWtB,GAItD,SAASmL,GAAyB9E,EAAgBvD,EAAM9C,GAC7D,IAAIoL,EAAYpL,EAAS8C,KAAKA,GAQ1BuI,EAAmBD,GAAaA,EAAU7I,mBAAqBvC,EAASuC,kBAG5E,IAAK8I,EACH,MAAO,cAGT,GAAa,yBAATvI,EAAiC,CAInC,IAAK9C,EAAS8C,KAAK,cAGjB,OAAOqI,GAAyB9E,EAAgB,SAAUrG,GAG5D,IAAIsL,EAActL,EAAS8C,KAAK,UAE5BwI,IAMFD,EDOS,SAAqB1N,EAAGE,GAGrC,IAFA,IAEyD4I,EAFrD8E,EAAS5N,EAAE8H,QAENiB,EAAY,GAAgC7I,KAAa4I,EAAQC,KAAab,MAAO,CAC5F,IAAI2F,EAAU/E,EAAM7F,MAEhBjD,EAAEgJ,QAAQ6E,GAAW,GACvBD,EAAOpC,KAAKqC,GAIhB,OAAOD,EAAOE,MAAK,SAAU9N,EAAGE,GAC9B,OAAOF,EAAIE,KCnBU6N,CAAYL,EAAkBC,EAAY/I,yBAU5D,GAAIO,IAASsI,EAChB,MAAO,iBAGT,IAAIO,EAAgBtF,EAAenH,OAQ/B0M,EAAiBP,EAAiB,GAEtC,OAAIO,IAAmBD,EACd,cAGLC,EAAiBD,EACZ,YAGLN,EAAiBA,EAAiBnM,OAAS,GAAKyM,EAC3C,WAIFN,EAAiB1E,QAAQgF,EAAe,IAAM,EAAI,cAAgB,iBCRpE,SAASE,GAAiBxF,EAAgBrG,GAE/C,MACO,gBADCkL,GAAkB7E,EAAgBrG,GC9D7B,SAAS8L,GAA8BtK,EAAa6E,EAAgBrG,GACjF,IAEI+L,EAFY,IAAIhM,EAASC,GAEKyB,8BAA8BD,GAEhE,OAAKuK,EAIEA,EAAkBlL,QAAO,SAAUQ,GACxC,OAIJ,SAA4CgF,EAAgBhF,EAASrB,GACnE,IAAIgM,EAAY,IAAIjM,EAASC,GAI7B,GAFAgM,EAAUpK,oBAAoBP,GAE1B2K,EAAUjK,cAAcQ,kBAAkBoE,QAAQN,EAAenH,SAAW,EAC9E,OAAO,EAGT,OAAO,EAbE+M,CAAmC5F,EAAgBhF,EAASrB,MAJ5D,GCVJ,IAAIkM,GAAsB,SAClB,SAASC,GAAgCzE,EAAQ3D,EAAQqI,GACtE,IAAIC,EAAyBD,EAAKC,uBAC9BC,EAAqBF,EAAKE,mBAG1BC,GAFcH,EAAKI,YACRJ,EAAKpM,SACE0H,EAAO+E,QAAQ,IAAI7H,OAAOb,EAAOyC,WAAY6F,EAAyBtI,EAAO2I,sBAanGJ,GAAsBvI,EAAOE,+BAAiCF,EAAOA,SAAS0I,QAAQP,GAAqBnI,EAAOE,gCAAkCF,EAAOA,WAE3J,OAAIsI,ECKS,SAA0CE,GACvD,OAAOA,EAAgBE,QAAQ,IAAI7H,OAAO,IAAIvE,OAAOyG,EAAmB,MAAO,KAAM,KAAK6F,ODLjFC,CAAiCL,GAGnCA,EEnBT,IAAIM,GAA4B,yCCXhC,SAAS,GAAgC/H,EAAGC,GAC1C,IAAIC,EAAuB,qBAAXzG,QAA0BuG,EAAEvG,OAAOC,WAAasG,EAAE,cAClE,GAAIE,EAAI,OAAQA,EAAKA,EAAGrE,KAAKmE,IAAIG,KAAKC,KAAKF,GAE3C,GAAIG,MAAMC,QAAQN,KAAOE,EAiB3B,SAAqCF,EAAGO,GACtC,IAAKP,EAAG,OACR,GAAiB,kBAANA,EAAgB,OAAO,GAAkBA,EAAGO,GACvD,IAAIE,EAAIhG,OAAOb,UAAU8G,SAAS7E,KAAKmE,GAAGW,MAAM,GAAI,GAC1C,WAANF,GAAkBT,EAAErG,cAAa8G,EAAIT,EAAErG,YAAYiH,MACvD,GAAU,QAANH,GAAqB,QAANA,EAAa,OAAOJ,MAAMQ,KAAKb,GAClD,GAAU,cAANS,GAAqB,2CAA2C1D,KAAK0D,GAAI,OAAO,GAAkBT,EAAGO,GAvB3E,CAA4BP,KAAOC,GAAkBD,GAAyB,kBAAbA,EAAE5F,OAAqB,CAChH8F,IAAIF,EAAIE,GACZ,IAAIhH,EAAI,EACR,OAAO,WACL,OAAIA,GAAK8G,EAAE5F,OAAe,CACxB2G,MAAM,GAED,CACLA,MAAM,EACNjF,MAAOkE,EAAE9G,OAKf,MAAM,IAAIc,UAAU,yIAYtB,SAAS,GAAkBgH,EAAKC,IACnB,MAAPA,GAAeA,EAAMD,EAAI5G,UAAQ6G,EAAMD,EAAI5G,QAE/C,IAAK,IAAIlB,EAAI,EAAGgI,EAAO,IAAIb,MAAMY,GAAM/H,EAAI+H,EAAK/H,IAC9CgI,EAAKhI,GAAK8H,EAAI9H,GAGhB,OAAOgI,EAGT,SAAS8G,GAAQC,EAAQC,GACvB,IAAI1M,EAAOf,OAAOe,KAAKyM,GAEvB,GAAIxN,OAAO0N,sBAAuB,CAChC,IAAIC,EAAU3N,OAAO0N,sBAAsBF,GAC3CC,IAAmBE,EAAUA,EAAQrM,QAAO,SAAUsM,GACpD,OAAO5N,OAAO6N,yBAAyBL,EAAQI,GAAK/N,eACjDkB,EAAK6I,KAAKC,MAAM9I,EAAM4M,GAG7B,OAAO5M,EAGT,SAAS+M,GAAcrO,GACrB,IAAK,IAAIhB,EAAI,EAAGA,EAAI0K,UAAUxJ,OAAQlB,IAAK,CACzC,IAAIsP,EAAS,MAAQ5E,UAAU1K,GAAK0K,UAAU1K,GAAK,GACnDA,EAAI,EAAI8O,GAAQvN,OAAO+N,IAAS,GAAIC,SAAQ,SAAU9N,GACpD+N,GAAgBxO,EAAQS,EAAK6N,EAAO7N,OACjCF,OAAOkO,0BAA4BlO,OAAOmO,iBAAiB1O,EAAQO,OAAOkO,0BAA0BH,IAAWR,GAAQvN,OAAO+N,IAASC,SAAQ,SAAU9N,GAC5JF,OAAOC,eAAeR,EAAQS,EAAKF,OAAO6N,yBAAyBE,EAAQ7N,OAI/E,OAAOT,EAGT,SAASwO,GAAgBlP,EAAKmB,EAAKmB,GAYjC,OAXInB,KAAOnB,EACTiB,OAAOC,eAAelB,EAAKmB,EAAK,CAC9BmB,MAAOA,EACPxB,YAAY,EACZC,cAAc,EACdC,UAAU,IAGZhB,EAAImB,GAAOmB,EAGNtC,EAYT,IAAIqP,GAAkB,CACpBC,gBAAiB,SAAyBrB,EAAiBsB,EAAW7N,GACpE,MAAO,GAAGK,OAAOkM,GAAiBlM,OAAOL,EAAS+C,OAAO1C,OAAOwN,KAmBrD,SAASC,GAAa3H,EAAOpC,EAAQqC,EAASpG,GAU3D,GAPEoG,EADEA,EACQiH,GAAcA,GAAc,GAAIM,IAAkBvH,GAElDuH,GAGZ3N,EAAW,IAAID,EAASC,GAEpBmG,EAAM9E,SAA6B,QAAlB8E,EAAM9E,QAAmB,CAE5C,IAAKrB,EAAS8B,WAAWqE,EAAM9E,SAC7B,MAAM,IAAInB,MAAM,oBAAoBG,OAAO8F,EAAM9E,UAGnDrB,EAASqB,QAAQ8E,EAAM9E,aAClB,KAAI8E,EAAM7B,mBAEV,OAAO6B,EAAMG,OAAS,GAD3BtG,EAAS4B,oBAAoBuE,EAAM7B,oBAGrC,IAIIoD,EAJApD,EAAqBtE,EAASsE,qBAC9B+B,EAAiBD,EAAQnF,GAAKkF,EAAME,eAAiBF,EAAMG,MAK/D,OAAQvC,GACN,IAAK,WAGH,OAAKsC,EAKE0H,GADPrG,EAASsG,GAAqB3H,EAAgBF,EAAMqG,YAAa,WAAYxM,EAAUoG,GAC3DD,EAAMpD,IAAK/C,EAAUoG,EAAQwH,iBAJhD,GAMX,IAAK,gBAGH,OAAKvH,GAILqB,EAASsG,GAAqB3H,EAAgB,KAAM,gBAAiBrG,EAAUoG,GAExE2H,GADPrG,EAAS,IAAIrH,OAAOiE,EAAoB,KAAKjE,OAAOqH,GACxBvB,EAAMpD,IAAK/C,EAAUoG,EAAQwH,kBALhD,IAAIvN,OAAOiE,GAOtB,IAAK,QAEH,MAAO,IAAIjE,OAAOiE,GAAoBjE,OAAOgG,GAE/C,IAAK,UACH,OCtBC,SAAuB+F,GAC5B,IAAI1E,EAAS0E,EAAK1E,OACd3E,EAAMqJ,EAAKrJ,IAEf,IAAK2E,EACH,MAAO,GAGT,GAAkB,MAAdA,EAAO,GACT,MAAM,IAAIxH,MAAM,6DAGlB,MAAO,OAAOG,OAAOqH,GAAQrH,OAAO0C,EAAM,QAAUA,EAAM,IDU/CkL,CAAc,CACnBvG,OAAQ,IAAIrH,OAAOiE,GAAoBjE,OAAOgG,GAC9CtD,IAAKoD,EAAMpD,MAOf,IAAK,MACH,IAAKqD,EAAQ8H,YACX,OAGF,IAAI3B,EAiDV,SAAmBlG,EAAgBmG,EAAalI,EAAoB4J,EAAalO,GAG/E,GAF6BqE,EAAsB6J,EAAalO,EAASA,YAE1CsE,EAAoB,CACjD,IAAIiI,EAAkByB,GAAqB3H,EAAgBmG,EAAa,WAAYxM,GAGpF,MAA2B,MAAvBsE,EACKA,EAAqB,IAAMiI,EAY7BA,EAGT,IAAI4B,ED7OS,SAAsB9M,EAASG,EAAaxB,GACzD,IAAIoO,EAAkB,IAAIrO,EAASC,GAGnC,OAFAoO,EAAgBxM,oBAAoBP,EAASG,GAEzC4M,EAAgB/L,mBACX+L,EAAgB/L,mBAGrBwK,GAA0BhL,KAAKuM,EAAgBhM,aAC1CgM,EAAgBhM,iBADzB,ECqOgBiM,CAAaH,OAAa5M,EAAWtB,EAASA,UAE9D,GAAImO,EACF,MAAO,GAAG9N,OAAO8N,EAAW,KAAK9N,OAAOiE,EAAoB,KAAKjE,OAAO2N,GAAqB3H,EAAgB,KAAM,gBAAiBrG,IA3E5GsO,CAAUjI,EAAgBF,EAAMqG,YAAalI,EAAoB8B,EAAQ8H,YAAalO,GAC5G,OAAO+N,GAAaxB,EAAiBpG,EAAMpD,IAAK/C,EAAUoG,EAAQwH,iBAEpE,QACE,MAAM,IAAI1N,MAAM,0DAA+DG,OAAO0D,EAAQ,OAIpG,SAASiK,GAAqBtG,EAAQ8E,EAAa+B,EAAUvO,EAAUoG,GACrE,IAAIrC,EAcC,SAA+ByK,EAAkBC,GACtD,IAAK,IAAmEhI,EAA/DC,EAAY,GAAgC8H,KAA4B/H,EAAQC,KAAab,MAAO,CAC3G,IAAI9B,EAAS0C,EAAM7F,MAInB,GAAImD,EAAO2K,wBAAwBxP,OAAS,EAAG,CAE7C,IAAIyP,EAA2B5K,EAAO2K,wBAAwB3K,EAAO2K,wBAAwBxP,OAAS,GAEtG,GAAyD,IAArDuP,EAAgBG,OAAOD,GACzB,SAKJ,GAAIlK,EAAgBgK,EAAiB1K,EAAOyC,WAC1C,OAAOzC,GA/BE8K,CAAsB7O,EAASwC,UAAWkF,GAEvD,OAAK3D,EAIEoI,GAAgCzE,EAAQ3D,EAAQ,CACrDsI,uBAAqC,kBAAbkC,EACxBjC,oBAAoBvI,EAAOG,2DAA4DkC,IAAsC,IAA3BA,EAAQ1C,eAC1G8I,YAAaA,EACbxM,SAAUA,IAPH0H,EAiCX,SAASqG,GAAaxB,EAAiBxJ,EAAK/C,EAAU4N,GACpD,OAAO7K,EAAM6K,EAAgBrB,EAAiBxJ,EAAK/C,GAAYuM,EEjOjE,SAAS,GAAQQ,EAAQC,GACvB,IAAI1M,EAAOf,OAAOe,KAAKyM,GAEvB,GAAIxN,OAAO0N,sBAAuB,CAChC,IAAIC,EAAU3N,OAAO0N,sBAAsBF,GAC3CC,IAAmBE,EAAUA,EAAQrM,QAAO,SAAUsM,GACpD,OAAO5N,OAAO6N,yBAAyBL,EAAQI,GAAK/N,eACjDkB,EAAK6I,KAAKC,MAAM9I,EAAM4M,GAG7B,OAAO5M,EAGT,SAAS,GAActB,GACrB,IAAK,IAAIhB,EAAI,EAAGA,EAAI0K,UAAUxJ,OAAQlB,IAAK,CACzC,IAAIsP,EAAS,MAAQ5E,UAAU1K,GAAK0K,UAAU1K,GAAK,GACnDA,EAAI,EAAI,GAAQuB,OAAO+N,IAAS,GAAIC,SAAQ,SAAU9N,GACpD,GAAgBT,EAAQS,EAAK6N,EAAO7N,OACjCF,OAAOkO,0BAA4BlO,OAAOmO,iBAAiB1O,EAAQO,OAAOkO,0BAA0BH,IAAW,GAAQ/N,OAAO+N,IAASC,SAAQ,SAAU9N,GAC5JF,OAAOC,eAAeR,EAAQS,EAAKF,OAAO6N,yBAAyBE,EAAQ7N,OAI/E,OAAOT,EAGT,SAAS,GAAgBV,EAAKmB,EAAKmB,GAYjC,OAXInB,KAAOnB,EACTiB,OAAOC,eAAelB,EAAKmB,EAAK,CAC9BmB,MAAOA,EACPxB,YAAY,EACZC,cAAc,EACdC,UAAU,IAGZhB,EAAImB,GAAOmB,EAGNtC,EAST,SAAS,GAAkBU,EAAQC,GACjC,IAAK,IAAIjB,EAAI,EAAGA,EAAIiB,EAAMC,OAAQlB,IAAK,CACrC,IAAImB,EAAaF,EAAMjB,GACvBmB,EAAWC,WAAaD,EAAWC,aAAc,EACjDD,EAAWE,cAAe,EACtB,UAAWF,IAAYA,EAAWG,UAAW,GACjDC,OAAOC,eAAeR,EAAQG,EAAWM,IAAKN,IAoBlD,IAEI,GAA2B,WAO7B,SAAS2P,EAAYC,EAA6B1I,EAAgBrG,GAGhE,GA5CJ,SAAyBpB,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,qCAwCpB,CAAgBmB,KAAM6O,IAEjBC,EACH,MAAM,IAAIjQ,UAAU,gDAGtB,IAAKuH,EACH,MAAM,IAAIvH,UAAU,+BAGtB,IAAKkB,EACH,MAAM,IAAIlB,UAAU,yBAGtB,IAAIkQ,EAgHR,SAAyCD,EAA6BE,GACpE,IAAI5N,EACAiD,EACAtE,EAAW,IAAID,EAASkP,GAParO,EAUvBmO,EATX,aAAalN,KAAKjB,IAUvBS,EAAU0N,EACV/O,EAAS4B,oBAAoBP,GAC7BiD,EAAqBtE,EAASsE,sBAE9BA,EAAqByK,EAfL,IAAuBnO,EAyBzC,MAAO,CACLS,QAASA,EACTiD,mBAAoBA,GAvIQ4K,CAAgCH,EAA6B/O,GACrFqB,EAAU2N,EAAsB3N,QAChCiD,EAAqB0K,EAAsB1K,mBAE/CrE,KAAKoB,QAAUA,EACfpB,KAAKqE,mBAAqBA,EAC1BrE,KAAKoG,eAAiBA,EACtBpG,KAAKyH,OAAS,IAAMzH,KAAKqE,mBAAqBrE,KAAKoG,eAKnDpG,KAAKkP,YAAc,WACjB,OAAOnP,GArDb,IAAsBnB,EAAac,EAAYC,EA+I7C,OA/IoBf,EAyDPiQ,GAzDoBnP,EAyDP,CAAC,CACzBF,IAAK,SACLmB,MAAO,SAAgBmC,GACrB9C,KAAK8C,IAAMA,IAEZ,CACDtD,IAAK,uBACLmB,MAAO,WACL,OAAIX,KAAKoB,QACA,CAACpB,KAAKoB,SAGRyK,GAA8B7L,KAAKqE,mBAAoBrE,KAAKoG,eAAgBpG,KAAKkP,iBAEzF,CACD1P,IAAK,aACLmB,MAAO,WACL,OPnHS,SAA+BuF,EAAOC,EAASpG,GAQ5D,QANgBsB,IAAZ8E,IACFA,EAAU,IAGZpG,EAAW,IAAID,EAASC,GAEpBoG,EAAQnF,GAAI,CACd,IAAKkF,EAAM7B,mBACT,MAAM,IAAIpE,MAAM,sCAGlBF,EAAS4B,oBAAoBuE,EAAM7B,wBAC9B,CACL,IAAK6B,EAAMG,MACT,OAAO,EAGT,GAAIH,EAAM9E,QAAS,CACjB,IAAKrB,EAAS8B,WAAWqE,EAAM9E,SAC7B,MAAM,IAAInB,MAAM,oBAAoBG,OAAO8F,EAAM9E,UAGnDrB,EAASqB,QAAQ8E,EAAM9E,aAClB,CACL,IAAK8E,EAAM7B,mBACT,MAAM,IAAIpE,MAAM,sCAGlBF,EAAS4B,oBAAoBuE,EAAM7B,qBAKvC,GAAItE,EAASuC,kBACX,OAAOsJ,GAAiB1F,EAAMG,OAASH,EAAME,eAAgBrG,GAQ7D,GAAImG,EAAM7B,oBAAsBtE,EAASoP,2BAA2BjJ,EAAM7B,oBAGxE,OAAO,EAEP,MAAM,IAAIpE,MAAM,kGOkET,CAAiBD,KAAM,CAC5BgB,IAAI,GACHhB,KAAKkP,iBAET,CACD1P,IAAK,UACLmB,MAAO,WACL,OAAOgG,EAAc3G,KAAM,CACzBgB,IAAI,GACHhB,KAAKkP,iBAET,CACD1P,IAAK,kBACLmB,MAAO,WAEL,OADe,IAAIb,EAASE,KAAKkP,eACjBC,2BAA2BnP,KAAKqE,sBAEjD,CACD7E,IAAK,UACLmB,MAAO,SAAiByO,GACtB,OAAOpP,KAAKyH,SAAW2H,EAAY3H,QAAUzH,KAAK8C,MAAQsM,EAAYtM,MAgBvE,CACDtD,IAAK,UACLmB,MAAO,WACL,OAAOsF,EAAcjG,KAAM,CACzBgB,IAAI,GACHhB,KAAKkP,iBAET,CACD1P,IAAK,SACLmB,MAAO,SAAgBoD,EAASoC,GAC9B,OAAO0H,GAAa7N,KAAM+D,EAASoC,EAAU,GAAc,GAAc,GAAIA,GAAU,GAAI,CACzFnF,IAAI,IACD,CACHA,IAAI,GACHhB,KAAKkP,iBAET,CACD1P,IAAK,iBACLmB,MAAO,SAAwBwF,GAC7B,OAAOnG,KAAK8D,OAAO,WAAYqC,KAEhC,CACD3G,IAAK,sBACLmB,MAAO,SAA6BwF,GAClC,OAAOnG,KAAK8D,OAAO,gBAAiBqC,KAErC,CACD3G,IAAK,SACLmB,MAAO,SAAgBwF,GACrB,OAAOnG,KAAK8D,OAAO,UAAWqC,QA1IlB,GAAkBvH,EAAYH,UAAWiB,GACrDC,GAAa,GAAkBf,EAAae,GAChDL,OAAOC,eAAeX,EAAa,YAAa,CAC9CS,UAAU,IA2ILwP,EA7HsB,GCzE/B,IAAIQ,GAA0B,IAAI1K,OAAO,kDCW1B,SAAS2K,GAAsB7H,EAAQ1H,GAUpD,IAAIwP,ECVS,SAA2D9H,EAAQ1H,GAChF,GAAI0H,GAAU1H,EAAS+B,cAAcU,2BAA4B,CAI/D,IAAIgN,EAAgB,IAAI7K,OAAO,OAAS5E,EAAS+B,cAAcU,2BAA6B,KACxFiN,EAAcD,EAAcE,KAAKjI,GAErC,GAAIgI,EAAa,CACf,IAAIrJ,EACAmG,EAqDA9I,EApCAkM,EAAsBF,EAAYxQ,OAAS,EAC3C2Q,EAAoBD,EAAsB,GAAKF,EAAYE,GAE/D,GAAI5P,EAAS0C,+BAAiCmN,EAC5CxJ,EAAiBqB,EAAO+E,QAAQgD,EAAezP,EAAS0C,+BAGpDkN,EAAsB,IACxBpD,EAAckD,EAAY,QAQzB,CAMH,IAAII,EAA6BJ,EAAY,GAC7CrJ,EAAiBqB,EAAOjC,MAAMqK,EAA2B5Q,QAGrD2Q,IACFrD,EAAckD,EAAY,IAW9B,GAAIG,EAAmB,CACrB,IAAIE,EAA0CrI,EAAOf,QAAQ+I,EAAY,IAC5ChI,EAAOjC,MAAM,EAAGsK,KAOd/P,EAAS+B,cAAc2B,mBACpDA,EAAiB1D,EAAS+B,cAAc2B,uBAG1CA,EAAiBgM,EAAY,GAG/B,MAAO,CACLrJ,eAAgBA,EAChB3C,eAAgBA,EAChB8I,YAAaA,IAKnB,MAAO,CACLnG,eAAgBqB,GDhFUsI,CAAkDtI,EAAQ1H,GAClFwM,EAAcgD,EAAsBhD,YACpCnG,EAAiBmJ,EAAsBnJ,eAE3C,GAAIA,IAAmBqB,EAAQ,CAC7B,IA8CJ,SAA2CuI,EAAsBC,EAAqBlQ,GAGpF,GAAIyE,EAAgBwL,EAAsBjQ,EAASsC,2BAA6BmC,EAAgByL,EAAqBlQ,EAASsC,yBAC5H,OAAO,EAgBT,OAAO,EAlEA6N,CAAkCzI,EAAQrB,EAAgBrG,GAE7D,MAAO,CACLqG,eAAgBqB,GAMpB,GAAI1H,EAASuC,oBA4DjB,SAA4C8D,EAAgBrG,GAC1D,OAAQkL,GAAkB7E,EAAgBrG,IACxC,IAAK,YACL,IAAK,iBAIH,OAAO,EAET,QACE,OAAO,GA7DFoQ,CAAmC/J,EAAgBrG,GAEtD,MAAO,CACLqG,eAAgBqB,GAMxB,MAAO,CACLrB,eAAgBA,EAChBmG,YAAaA,GElCF,SAAS6D,GAA0B3I,EAAQrG,EAASG,EAAaxB,GAC9E,IAAK0H,EACH,MAAO,GAGT,IAAI4I,EAQJ,GAAkB,MAAd5I,EAAO,GAAY,CAGrB,IAAI6I,EHpCO,SAAwB7I,EAAQrG,EAASG,EAAaxB,GACnE,GAAKqB,EAAL,CAKA,IAAI+M,EAAkB,IAAIrO,EAASC,GACnCoO,EAAgBxM,oBAAoBP,EAASG,GAC7C,IAAIgP,EAAmB,IAAI5L,OAAOwJ,EAAgBhM,aAElD,GAAwC,IAApCsF,EAAOkH,OAAO4B,GAAlB,CAUA,IAAIC,GALJ/I,EAASA,EAAOjC,MAAMiC,EAAOgJ,MAAMF,GAAkB,GAAGtR,SAK7BwR,MAAMpB,IAEjC,KAAImB,GAAqC,MAApBA,EAAc,IAAcA,EAAc,GAAGvR,OAAS,GAChD,MAArBuR,EAAc,IAKpB,OAAO/I,IGQkBiJ,CAAejJ,EAAQrG,EAASG,EAAaxB,GAIpE,IAAIuQ,GAAoBA,IAAqB7I,EAGtC,CAKL,GAAIrG,GAAWG,EAAa,CAC1B,IAAIoP,ECrCG,SAAyElJ,EAAQrG,EAASG,EAAaxB,GACpH,IAAIsE,EAAqBjD,EAAUgD,EAAsBhD,EAASrB,GAAYwB,EAE9E,GAA2C,IAAvCkG,EAAOf,QAAQrC,GAA2B,EAC5CtE,EAAW,IAAID,EAASC,IACf4B,oBAAoBP,EAASG,GACtC,IAAIqP,EAAwBnJ,EAAOjC,MAAMnB,EAAmBpF,QAGxD4R,EADwBvB,GAAsBsB,EAAuB7Q,GACfqG,eAGtDA,EADyBkJ,GAAsB7H,EAAQ1H,GACfqG,eAU5C,IAAK5B,EAAgB4B,EAAgBrG,EAASsC,0BAA4BmC,EAAgBqM,EAA+B9Q,EAASsC,0BAA4E,aAAhD4I,GAAkB7E,EAAgBrG,GAC9L,MAAO,CACLsE,mBAAoBA,EACpBoD,OAAQmJ,GAKd,MAAO,CACLnJ,OAAQA,GDMwBqJ,CAAgErJ,EAAQrG,EAASG,EAAaxB,GACtHsE,EAAqBsM,EAAsBtM,mBAC3C0M,EAAgBJ,EAAsBlJ,OAE1C,GAAIpD,EACF,MAAO,CACL2M,yBAA0B,gCAC1B3M,mBAAoBA,EACpBoD,OAAQsJ,GAKd,MAAO,CAGLtJ,OAAQA,GAxBV4I,GAAwB,EACxB5I,EAAS,IAAM6I,EA6BnB,GAAkB,MAAd7I,EAAO,GACT,MAAO,GAGT1H,EAAW,IAAID,EAASC,GAYxB,IAFA,IAAIhC,EAAI,EAEDA,EAAI,GpBpFwB,GoBoFQA,GAAK0J,EAAOxI,QAAQ,CAC7D,IAAIgS,EAAsBxJ,EAAOjC,MAAM,EAAGzH,GAE1C,GAAIgC,EAASiC,eAAeiP,GAE1B,OADAlR,EAAS4B,oBAAoBsP,GACtB,CACLD,yBAA0BX,EAAwB,uBAAyB,6BAC3EhM,mBAAoB4M,EACpBxJ,OAAQA,EAAOjC,MAAMzH,IAIzBA,IAGF,MAAO,GEzGT,SAAS,GAAgC8G,EAAGC,GAC1C,IAAIC,EAAuB,qBAAXzG,QAA0BuG,EAAEvG,OAAOC,WAAasG,EAAE,cAClE,GAAIE,EAAI,OAAQA,EAAKA,EAAGrE,KAAKmE,IAAIG,KAAKC,KAAKF,GAE3C,GAAIG,MAAMC,QAAQN,KAAOE,EAiB3B,SAAqCF,EAAGO,GACtC,IAAKP,EAAG,OACR,GAAiB,kBAANA,EAAgB,OAAO,GAAkBA,EAAGO,GACvD,IAAIE,EAAIhG,OAAOb,UAAU8G,SAAS7E,KAAKmE,GAAGW,MAAM,GAAI,GAC1C,WAANF,GAAkBT,EAAErG,cAAa8G,EAAIT,EAAErG,YAAYiH,MACvD,GAAU,QAANH,GAAqB,QAANA,EAAa,OAAOJ,MAAMQ,KAAKb,GAClD,GAAU,cAANS,GAAqB,2CAA2C1D,KAAK0D,GAAI,OAAO,GAAkBT,EAAGO,GAvB3E,CAA4BP,KAAOC,GAAkBD,GAAyB,kBAAbA,EAAE5F,OAAqB,CAChH8F,IAAIF,EAAIE,GACZ,IAAIhH,EAAI,EACR,OAAO,WACL,OAAIA,GAAK8G,EAAE5F,OAAe,CACxB2G,MAAM,GAED,CACLA,MAAM,EACNjF,MAAOkE,EAAE9G,OAKf,MAAM,IAAIc,UAAU,yIAYtB,SAAS,GAAkBgH,EAAKC,IACnB,MAAPA,GAAeA,EAAMD,EAAI5G,UAAQ6G,EAAMD,EAAI5G,QAE/C,IAAK,IAAIlB,EAAI,EAAGgI,EAAO,IAAIb,MAAMY,GAAM/H,EAAI+H,EAAK/H,IAC9CgI,EAAKhI,GAAK8H,EAAI9H,GAGhB,OAAOgI,ECnCM,SAASmL,GAAwB3P,EAAa4K,GAC3D,IAAIgF,EAAsBhF,EAAK/F,eAC3BgL,EAAiBjF,EAAKiF,eACtBrR,EAAWoM,EAAKpM,SASpB,IAAI+L,EAAoB/L,EAASyB,8BAA8BD,GAE/D,GAAKuK,EAML,OAAiC,IAA7BA,EAAkB7M,OACb6M,EAAkB,GDmBd,SAAoCqF,EAAqBhF,GACtE,IAAIhM,EAAYgM,EAAKhM,UACjBiR,EAAiBjF,EAAKiF,eACtBrR,EAAWoM,EAAKpM,SAEpBA,EAAW,IAAID,EAASC,GAGxB,IAFA,IAEiEyG,EAF7D6K,EAAoB,GAEf5K,EAAY,GAAgCtG,KAAqBqG,EAAQC,KAAab,MAAO,CACpG,IAAIxE,EAAUoF,EAAM7F,MASpB,GARAZ,EAASqB,QAAQA,GAQbrB,EAAS2C,iBACX,GAAIyO,GAAgF,IAAzDA,EAAoBxC,OAAO5O,EAAS2C,iBAC7D,OAAOtB,OAIN,GAAI6E,EAAc,CACrBI,MAAO8K,EACP/P,QAASA,QACRC,EAAWtB,EAASA,UAAW,CAEhC,IAAIqR,EAOF,OAAOhQ,EANP,GAAIA,IAAYgQ,EACd,OAAOhQ,EAGTiQ,EAAkBnI,KAAK9H,IAQ7B,GAAIiQ,EAAkBpS,OAAS,EAC7B,OAAOoS,EAAkB,GC3DpBC,CAA2BH,EAAqB,CACrDhR,UAAW2L,EACXsF,eAAgBA,EAChBrR,SAAUA,EAASA,WCtBhB,IASHwR,GAAwC,IAAI5M,OANZ,kLAMkD,KAalF6M,GAA8B,IAAI7M,OANZ,+KAMwC,KACvD8M,GAAkB,OAClBC,GAAyB,kBCvBrB,SAASC,GAAwDC,EAAezF,GAC7F,IAOI0F,EAPAC,EAA8B3F,EAAK2F,4BACnCC,ED+BS,SAA6BC,GAC1C,IAAIC,EAAsBD,EAAoBtL,QAAQgL,IAEtD,GAAIO,EAAsB,EACxB,OAAO,KAGT,IAAIC,EAAoBD,EAAsBP,GAAuBzS,OAErE,GAAIiT,GAAqBF,EAAoB/S,OAC3C,MAAO,GAGT,IAAIkT,EAAkBH,EAAoBtL,QAAQ,IAAKwL,GAEvD,OAAIC,GAAmB,EACdH,EAAoBI,UAAUF,EAAmBC,GAEjDH,EAAoBI,UAAUF,GCjDpBG,CAAoBT,GAEvC,IDyDK,SAA6BG,GAClC,OAAqB,OAAjBA,GAIwB,IAAxBA,EAAa9S,SAKVsS,GAAsC3P,KAAKmQ,IAAiBP,GAA4B5P,KAAKmQ,ICnE/FO,CAAoBP,GACvB,MAAM,IAAIlI,EAAW,gBAKvB,GAAqB,OAAjBkI,EAGFF,EAAoBC,EAA4BF,IAAkB,OAC7D,CACLC,EAAoB,GDhBD,MCmBfE,EAAaQ,OAAO,KACtBV,GAAqBE,GAQvB,IACIS,EADAC,EAAuBb,EAAclL,QAAQ+K,IAO/Ce,EADEC,GAAwB,EACFA,EAAuBhB,GAAgBxS,OAEvC,EAG1B,IAAIgT,EAAsBL,EAAclL,QAAQgL,IAChDG,GAAqBD,EAAcQ,UAAUI,EAAuBP,GAMtE,IAAIS,EAAcb,EAAkBnL,QDtBA,UCiCpC,GATIgM,EAAc,IAChBb,EAAoBA,EAAkBO,UAAU,EAAGM,IAQ3B,KAAtBb,EACF,OAAOA,EC5CX,IAEIc,GAA6B,IAAIhO,OAAO,uDAIxCiO,GAAiC,IAAIjO,OAAO,oDA0BjC,SAASkO,GAAMpO,EAAM0B,EAASpG,GAM3C,GAHAoG,EAAUA,GAAW,GACrBpG,EAAW,IAAID,EAASC,GAEpBoG,EAAQiL,iBAAmBrR,EAAS8B,WAAWsE,EAAQiL,gBAAiB,CAC1E,GAAIjL,EAAQnF,GACV,MAAM,IAAI6I,EAAW,mBAGvB,MAAM,IAAI5J,MAAM,oBAAoBG,OAAO+F,EAAQiL,iBAIrD,IAAI0B,EAwJN,SAAoBrO,EAAMzD,EAAI+R,GAM5B,IAAItL,EAASkK,GAAwDlN,EAAM,CACzEqN,4BAA6B,SAAqCrN,GAChE,OA5CN,SAAsCA,EAAMsO,EAASC,GACnD,IAAKvO,EACH,OAGF,GAAIA,EAAKxF,OAxKmB,IAwKe,CACzC,GAAI+T,EACF,MAAM,IAAInJ,EAAW,YAGvB,OAGF,IAAgB,IAAZkJ,EACF,OAAOtO,EAIT,IAAIwO,EAAWxO,EAAKkK,OAAOgE,IAE3B,GAAIM,EAAW,EACb,OAGF,OAAOxO,EACNe,MAAMyN,GACNzG,QAAQoG,GAAgC,IAkB9BM,CAA6BzO,EAAMsO,EAAS/R,MAIvD,IAAKyG,EACH,MAAO,GAGT,IAAKD,EAAoBC,GACvB,OxB7KG,SAAkCA,GACvC,OAAOJ,EAAiCzF,KAAK6F,GwB4KvC0L,CAAyB1L,GACpB,CACL2L,MAAO,aAIJ,GAKT,IAAIC,EtBlPS,SAA0B5L,GACvC,IAAI6L,EAAQ7L,EAAOkH,OAAOlE,GAE1B,GAAI6I,EAAQ,EACV,MAAO,GAST,IAJA,IAAIC,EAAyB9L,EAAOjC,MAAM,EAAG8N,GACzCE,EAAU/L,EAAOgJ,MAAMhG,GACvB1M,EAAI,EAEDA,EAAIyV,EAAQvU,QAAQ,CACzB,GAAIuU,EAAQzV,GACV,MAAO,CACL0J,OAAQ8L,EACRzQ,IAAK0Q,EAAQzV,IAIjBA,KsB6N0B0V,CAAiBhM,GAE7C,GAAI4L,EAAsBvQ,IACxB,OAAOuQ,EAGT,MAAO,CACL5L,OAAQA,GA3LQiM,CAAWjP,EAAM0B,EAAQnF,GAAImF,EAAQ4M,SACnDY,EAAuBb,EAAYrL,OACnC3E,EAAMgQ,EAAYhQ,IAClBsQ,EAAQN,EAAYM,MAGxB,IAAKO,EAAsB,CACzB,GAAIxN,EAAQnF,GAAI,CACd,GAAc,cAAVoS,EACF,MAAM,IAAIvJ,EAAW,aAGvB,MAAM,IAAIA,EAAW,gBAGvB,MAAO,GAGT,IAAI+J,EAuMN,SAA0BD,EAAsBvC,EAAgByC,EAAoB9T,GAElF,IAMIqB,EANAuP,EAAwBP,GAA0BvF,EAA2B8I,GAAuBvC,EAAgByC,EAAoB9T,EAASA,UACjJiR,EAA2BL,EAAsBK,yBACjD3M,EAAqBsM,EAAsBtM,mBAC3CoD,EAASkJ,EAAsBlJ,OAKnC,GAAIpD,EACFtE,EAAS4B,oBAAoB0C,OAG1B,KAAIoD,IAAW2J,IAAkByC,EAe/B,MAAO,GAdZ9T,EAAS4B,oBAAoByP,EAAgByC,GAEzCzC,IACFhQ,EAAUgQ,GAUZ/M,EAAqBwP,GAAsBzP,EAAsBgN,EAAgBrR,EAASA,UAG5F,IAAK0H,EACH,MAAO,CACLuJ,yBAA0BA,EAC1B3M,mBAAoBA,GAIxB,IAAIkL,EAAwBD,GAAsBzE,EAA2BpD,GAAS1H,GAClFqG,EAAiBmJ,EAAsBnJ,eACvCmG,EAAcgD,EAAsBhD,YAYpCuH,EAAe5C,GAAwB7M,EAAoB,CAC7D+B,eAAgBA,EAChBgL,eAAgBA,EAChBrR,SAAUA,IAGR+T,IACF1S,EAAU0S,EAGW,QAAjBA,GAIF/T,EAASqB,QAAQA,IAIrB,MAAO,CACLA,QAASA,EACTiD,mBAAoBA,EACpB2M,yBAA0BA,EAC1B5K,eAAgBA,EAChBmG,YAAaA,GAlRSwH,CAAiBJ,EAAsBxN,EAAQiL,eAAgBjL,EAAQ0N,mBAAoB9T,GAC/GqB,EAAUwS,EAAkBxS,QAC5BgF,EAAiBwN,EAAkBxN,eACnC/B,EAAqBuP,EAAkBvP,mBACvC2M,EAA2B4C,EAAkB5C,yBAC7CzE,EAAcqH,EAAkBrH,YAEpC,IAAKxM,EAASiU,2BAA4B,CACxC,GAAI7N,EAAQnF,GACV,MAAM,IAAI6I,EAAW,mBAGvB,MAAO,GAIT,IAAKzD,GAAkBA,EAAenH,O1BtGR,E0BsGqC,CAIjE,GAAIkH,EAAQnF,GACV,MAAM,IAAI6I,EAAW,aAIvB,MAAO,GAYT,GAAIzD,EAAenH,O1BxHW,G0BwHkB,CAC9C,GAAIkH,EAAQnF,GACV,MAAM,IAAI6I,EAAW,YAIvB,MAAO,GAGT,GAAI1D,EAAQnF,GAAI,CACd,IAAIoO,EAAc,IAAI,GAAY/K,EAAoB+B,EAAgBrG,EAASA,UAe/E,OAbIqB,IACFgO,EAAYhO,QAAUA,GAGpBmL,IACF6C,EAAY7C,YAAcA,GAGxBzJ,IACFsM,EAAYtM,IAAMA,GAGpBsM,EAAY6E,2BAA6BjD,EAClC5B,EAMT,IAAI8E,KAAS/N,EAAQgO,SAAWpU,EAASiU,2BAA6B5S,IAAWoD,EAAgB4B,EAAgBrG,EAASsC,yBAE1H,OAAK8D,EAAQgO,SAKN,CACL/S,QAASA,EACTiD,mBAAoBA,EACpBkI,YAAaA,EACb2H,MAAOA,EACPE,WAAUF,MAAoC,IAArB/N,EAAQgO,WAAqBpU,EAASuC,oBAAqBsJ,GAAiBxF,EAAgBrG,IACrHsG,MAAOD,EACPtD,IAAKA,GAXEoR,EA0GX,SAAgB9S,EAASgF,EAAgBtD,GACvC,IAAIuH,EAAS,CACXjJ,QAASA,EACTiF,MAAOD,GAGLtD,IACFuH,EAAOvH,IAAMA,GAGf,OAAOuH,EApHU,CAAOjJ,EAASgF,EAAgBtD,GAAO,GC9J1D,SAAS,GAAQzE,GAGf,OAAO,GAAU,mBAAqBC,QAAU,iBAAmBA,OAAOC,SAAW,SAAUF,GAC7F,cAAcA,GACZ,SAAUA,GACZ,OAAOA,GAAO,mBAAqBC,QAAUD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAOG,UAAY,gBAAkBJ,GACvH,GAAQA,GAGb,SAAS,GAAewH,EAAK9H,GAC3B,OAwDF,SAAyB8H,GACvB,GAAIX,MAAMC,QAAQU,GAAM,OAAOA,EAzDxB,CAAgBA,IA0BzB,SAA+BA,EAAK9H,GAClC,IAAIsW,EAAY,MAAPxO,EAAc,KAAyB,qBAAXvH,QAA0BuH,EAAIvH,OAAOC,WAAasH,EAAI,cAE3F,GAAU,MAANwO,EAAY,OAChB,IAIIC,EAAIC,EAJJC,EAAO,GACPC,GAAK,EACLC,GAAK,EAIT,IACE,IAAKL,EAAKA,EAAG3T,KAAKmF,KAAQ4O,GAAMH,EAAKD,EAAGrP,QAAQY,QAC9C4O,EAAKtL,KAAKoL,EAAG3T,QAET5C,GAAKyW,EAAKvV,SAAWlB,GAH4B0W,GAAK,IAK5D,MAAOE,GACPD,GAAK,EACLH,EAAKI,EACL,QACA,IACOF,GAAsB,MAAhBJ,EAAW,QAAWA,EAAW,SAC5C,QACA,GAAIK,EAAI,MAAMH,GAIlB,OAAOC,EArDwB,CAAsB3O,EAAK9H,IAO5D,SAAqC8G,EAAGO,GACtC,IAAKP,EAAG,OACR,GAAiB,kBAANA,EAAgB,OAAO,GAAkBA,EAAGO,GACvD,IAAIE,EAAIhG,OAAOb,UAAU8G,SAAS7E,KAAKmE,GAAGW,MAAM,GAAI,GAC1C,WAANF,GAAkBT,EAAErG,cAAa8G,EAAIT,EAAErG,YAAYiH,MACvD,GAAU,QAANH,GAAqB,QAANA,EAAa,OAAOJ,MAAMQ,KAAKb,GAClD,GAAU,cAANS,GAAqB,2CAA2C1D,KAAK0D,GAAI,OAAO,GAAkBT,EAAGO,GAbzC,CAA4BS,EAAK9H,IAGnG,WACE,MAAM,IAAIc,UAAU,6IAJmF,GAgBzG,SAAS,GAAkBgH,EAAKC,IACnB,MAAPA,GAAeA,EAAMD,EAAI5G,UAAQ6G,EAAMD,EAAI5G,QAE/C,IAAK,IAAIlB,EAAI,EAAGgI,EAAO,IAAIb,MAAMY,GAAM/H,EAAI+H,EAAK/H,IAC9CgI,EAAKhI,GAAK8H,EAAI9H,GAGhB,OAAOgI,EAuDF,SAAS6O,GAAmB9L,GACjC,IAOI5C,EAEAnG,EARA8U,EAAyB,GADD3P,MAAMzG,UAAU+G,MAAM9E,KAAKoI,GACY,GAC/DgM,EAAQD,EAAuB,GAC/BE,EAAQF,EAAuB,GAC/BG,EAAQH,EAAuB,GAC/BI,EAAQJ,EAAuB,GAG/B1O,EAAU,GAId,GAAqB,kBAAV2O,EAIc,WAAnB,GAAQC,IACNE,GACF9O,EAAU6O,EACVjV,EAAWkV,GAEXlV,EAAWiV,EASX9O,EADEsB,EAAoBsN,GACdjC,GAAMiC,EAAO,CACnB1D,eAAgB2D,GACfhV,GAEK,KAMNiV,GACF7O,EAAU4O,EACVhV,EAAWiV,GAEXjV,EAAWgV,EASX7O,EADEsB,EAAoBsN,GACdjC,GAAMiC,OAAOzT,EAAWtB,GAExB,QAKT,KAAI,GAAU+U,GASZ,MAAM,IAAIjW,UAAU,sFARzBqH,EAAQ4O,EAEJE,GACF7O,EAAU4O,EACVhV,EAAWiV,GAEXjV,EAAWgV,EAIf,MAAO,CACL7O,MAAOA,EACPC,QAASA,EACTpG,SAAUA,GAOd,IAAI,GAAY,SAAmBc,GACjC,MAAsB,WAAf,GAAQA,ICzKF,SAAS,KACtB,IAAIqU,EAAsBN,GAAmBnM,WACzCvC,EAAQgP,EAAoBhP,MAC5BC,EAAU+O,EAAoB/O,QAC9BpG,EAAWmV,EAAoBnV,SAGnC,QAAKmG,EAAMG,OAIJ,EAAeH,EAAOC,EAASpG,GCXjC,SAAS,KACd,OAAO,OAAAoV,EAAA,GAAqB,GAAgB1M","file":"js/application~1c4d1292-b1599d93dbb741f215c2.chunk.js","sourcesContent":["// Copy-pasted from:\n// https://github.com/substack/semver-compare/blob/master/index.js\n//\n// Inlining this function because some users reported issues with\n// importing from `semver-compare` in a browser with ES6 \"native\" modules.\n//\n// Fixes `semver-compare` not being able to compare versions with alpha/beta/etc \"tags\".\n// https://github.com/catamphetamine/libphonenumber-js/issues/381\nexport default function (a, b) {\n  a = a.split('-');\n  b = b.split('-');\n  var pa = a[0].split('.');\n  var pb = b[0].split('.');\n\n  for (var i = 0; i < 3; i++) {\n    var na = Number(pa[i]);\n    var nb = Number(pb[i]);\n    if (na > nb) return 1;\n    if (nb > na) return -1;\n    if (!isNaN(na) && isNaN(nb)) return 1;\n    if (isNaN(na) && !isNaN(nb)) return -1;\n  }\n\n  if (a[1] && b[1]) {\n    return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;\n  }\n\n  return !a[1] && b[1] ? 1 : a[1] && !b[1] ? -1 : 0;\n}","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\n\nimport compare from './tools/semver-compare.js'; // Added \"possibleLengths\" and renamed\n// \"country_phone_code_to_countries\" to \"country_calling_codes\".\n\nvar V2 = '1.0.18'; // Added \"idd_prefix\" and \"default_idd_prefix\".\n\nvar V3 = '1.2.0'; // Moved `001` country code to \"nonGeographic\" section of metadata.\n\nvar V4 = '1.7.35';\nvar DEFAULT_EXT_PREFIX = ' ext. ';\nvar CALLING_CODE_REG_EXP = /^\\d+$/;\n/**\r\n * See: https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md\r\n */\n\nvar Metadata = /*#__PURE__*/function () {\n  function Metadata(metadata) {\n    _classCallCheck(this, Metadata);\n\n    validateMetadata(metadata);\n    this.metadata = metadata;\n    setVersion.call(this, metadata);\n  }\n\n  _createClass(Metadata, [{\n    key: \"getCountries\",\n    value: function getCountries() {\n      return Object.keys(this.metadata.countries).filter(function (_) {\n        return _ !== '001';\n      });\n    }\n  }, {\n    key: \"getCountryMetadata\",\n    value: function getCountryMetadata(countryCode) {\n      return this.metadata.countries[countryCode];\n    }\n  }, {\n    key: \"nonGeographic\",\n    value: function nonGeographic() {\n      if (this.v1 || this.v2 || this.v3) return; // `nonGeographical` was a typo.\n      // It's present in metadata generated from `1.7.35` to `1.7.37`.\n      // The test case could be found by searching for \"nonGeographical\".\n\n      return this.metadata.nonGeographic || this.metadata.nonGeographical;\n    }\n  }, {\n    key: \"hasCountry\",\n    value: function hasCountry(country) {\n      return this.getCountryMetadata(country) !== undefined;\n    }\n  }, {\n    key: \"hasCallingCode\",\n    value: function hasCallingCode(callingCode) {\n      if (this.getCountryCodesForCallingCode(callingCode)) {\n        return true;\n      }\n\n      if (this.nonGeographic()) {\n        if (this.nonGeographic()[callingCode]) {\n          return true;\n        }\n      } else {\n        // A hacky workaround for old custom metadata (generated before V4).\n        var countryCodes = this.countryCallingCodes()[callingCode];\n\n        if (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {\n          return true;\n        }\n      }\n    }\n  }, {\n    key: \"isNonGeographicCallingCode\",\n    value: function isNonGeographicCallingCode(callingCode) {\n      if (this.nonGeographic()) {\n        return this.nonGeographic()[callingCode] ? true : false;\n      } else {\n        return this.getCountryCodesForCallingCode(callingCode) ? false : true;\n      }\n    } // Deprecated.\n\n  }, {\n    key: \"country\",\n    value: function country(countryCode) {\n      return this.selectNumberingPlan(countryCode);\n    }\n  }, {\n    key: \"selectNumberingPlan\",\n    value: function selectNumberingPlan(countryCode, callingCode) {\n      // Supports just passing `callingCode` as the first argument.\n      if (countryCode && CALLING_CODE_REG_EXP.test(countryCode)) {\n        callingCode = countryCode;\n        countryCode = null;\n      }\n\n      if (countryCode && countryCode !== '001') {\n        if (!this.hasCountry(countryCode)) {\n          throw new Error(\"Unknown country: \".concat(countryCode));\n        }\n\n        this.numberingPlan = new NumberingPlan(this.getCountryMetadata(countryCode), this);\n      } else if (callingCode) {\n        if (!this.hasCallingCode(callingCode)) {\n          throw new Error(\"Unknown calling code: \".concat(callingCode));\n        }\n\n        this.numberingPlan = new NumberingPlan(this.getNumberingPlanMetadata(callingCode), this);\n      } else {\n        this.numberingPlan = undefined;\n      }\n\n      return this;\n    }\n  }, {\n    key: \"getCountryCodesForCallingCode\",\n    value: function getCountryCodesForCallingCode(callingCode) {\n      var countryCodes = this.countryCallingCodes()[callingCode];\n\n      if (countryCodes) {\n        // Metadata before V4 included \"non-geographic entity\" calling codes\n        // inside `country_calling_codes` (for example, `\"881\":[\"001\"]`).\n        // Now the semantics of `country_calling_codes` has changed:\n        // it's specifically for \"countries\" now.\n        // Older versions of custom metadata will simply skip parsing\n        // \"non-geographic entity\" phone numbers with new versions\n        // of this library: it's not considered a bug,\n        // because such numbers are extremely rare,\n        // and developers extremely rarely use custom metadata.\n        if (countryCodes.length === 1 && countryCodes[0].length === 3) {\n          return;\n        }\n\n        return countryCodes;\n      }\n    }\n  }, {\n    key: \"getCountryCodeForCallingCode\",\n    value: function getCountryCodeForCallingCode(callingCode) {\n      var countryCodes = this.getCountryCodesForCallingCode(callingCode);\n\n      if (countryCodes) {\n        return countryCodes[0];\n      }\n    }\n  }, {\n    key: \"getNumberingPlanMetadata\",\n    value: function getNumberingPlanMetadata(callingCode) {\n      var countryCode = this.getCountryCodeForCallingCode(callingCode);\n\n      if (countryCode) {\n        return this.getCountryMetadata(countryCode);\n      }\n\n      if (this.nonGeographic()) {\n        var metadata = this.nonGeographic()[callingCode];\n\n        if (metadata) {\n          return metadata;\n        }\n      } else {\n        // A hacky workaround for old custom metadata (generated before V4).\n        // In that metadata, there was no concept of \"non-geographic\" metadata\n        // so metadata for `001` country code was stored along with other countries.\n        // The test case can be found by searching for:\n        // \"should work around `nonGeographic` metadata not existing\".\n        var countryCodes = this.countryCallingCodes()[callingCode];\n\n        if (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {\n          return this.metadata.countries['001'];\n        }\n      }\n    } // Deprecated.\n\n  }, {\n    key: \"countryCallingCode\",\n    value: function countryCallingCode() {\n      return this.numberingPlan.callingCode();\n    } // Deprecated.\n\n  }, {\n    key: \"IDDPrefix\",\n    value: function IDDPrefix() {\n      return this.numberingPlan.IDDPrefix();\n    } // Deprecated.\n\n  }, {\n    key: \"defaultIDDPrefix\",\n    value: function defaultIDDPrefix() {\n      return this.numberingPlan.defaultIDDPrefix();\n    } // Deprecated.\n\n  }, {\n    key: \"nationalNumberPattern\",\n    value: function nationalNumberPattern() {\n      return this.numberingPlan.nationalNumberPattern();\n    } // Deprecated.\n\n  }, {\n    key: \"possibleLengths\",\n    value: function possibleLengths() {\n      return this.numberingPlan.possibleLengths();\n    } // Deprecated.\n\n  }, {\n    key: \"formats\",\n    value: function formats() {\n      return this.numberingPlan.formats();\n    } // Deprecated.\n\n  }, {\n    key: \"nationalPrefixForParsing\",\n    value: function nationalPrefixForParsing() {\n      return this.numberingPlan.nationalPrefixForParsing();\n    } // Deprecated.\n\n  }, {\n    key: \"nationalPrefixTransformRule\",\n    value: function nationalPrefixTransformRule() {\n      return this.numberingPlan.nationalPrefixTransformRule();\n    } // Deprecated.\n\n  }, {\n    key: \"leadingDigits\",\n    value: function leadingDigits() {\n      return this.numberingPlan.leadingDigits();\n    } // Deprecated.\n\n  }, {\n    key: \"hasTypes\",\n    value: function hasTypes() {\n      return this.numberingPlan.hasTypes();\n    } // Deprecated.\n\n  }, {\n    key: \"type\",\n    value: function type(_type) {\n      return this.numberingPlan.type(_type);\n    } // Deprecated.\n\n  }, {\n    key: \"ext\",\n    value: function ext() {\n      return this.numberingPlan.ext();\n    }\n  }, {\n    key: \"countryCallingCodes\",\n    value: function countryCallingCodes() {\n      if (this.v1) return this.metadata.country_phone_code_to_countries;\n      return this.metadata.country_calling_codes;\n    } // Deprecated.\n\n  }, {\n    key: \"chooseCountryByCountryCallingCode\",\n    value: function chooseCountryByCountryCallingCode(callingCode) {\n      return this.selectNumberingPlan(callingCode);\n    }\n  }, {\n    key: \"hasSelectedNumberingPlan\",\n    value: function hasSelectedNumberingPlan() {\n      return this.numberingPlan !== undefined;\n    }\n  }]);\n\n  return Metadata;\n}();\n\nexport { Metadata as default };\n\nvar NumberingPlan = /*#__PURE__*/function () {\n  function NumberingPlan(metadata, globalMetadataObject) {\n    _classCallCheck(this, NumberingPlan);\n\n    this.globalMetadataObject = globalMetadataObject;\n    this.metadata = metadata;\n    setVersion.call(this, globalMetadataObject.metadata);\n  }\n\n  _createClass(NumberingPlan, [{\n    key: \"callingCode\",\n    value: function callingCode() {\n      return this.metadata[0];\n    } // Formatting information for regions which share\n    // a country calling code is contained by only one region\n    // for performance reasons. For example, for NANPA region\n    // (\"North American Numbering Plan Administration\",\n    //  which includes USA, Canada, Cayman Islands, Bahamas, etc)\n    // it will be contained in the metadata for `US`.\n\n  }, {\n    key: \"getDefaultCountryMetadataForRegion\",\n    value: function getDefaultCountryMetadataForRegion() {\n      return this.globalMetadataObject.getNumberingPlanMetadata(this.callingCode());\n    } // Is always present.\n\n  }, {\n    key: \"IDDPrefix\",\n    value: function IDDPrefix() {\n      if (this.v1 || this.v2) return;\n      return this.metadata[1];\n    } // Is only present when a country supports multiple IDD prefixes.\n\n  }, {\n    key: \"defaultIDDPrefix\",\n    value: function defaultIDDPrefix() {\n      if (this.v1 || this.v2) return;\n      return this.metadata[12];\n    }\n  }, {\n    key: \"nationalNumberPattern\",\n    value: function nationalNumberPattern() {\n      if (this.v1 || this.v2) return this.metadata[1];\n      return this.metadata[2];\n    } // \"possible length\" data is always present in Google's metadata.\n\n  }, {\n    key: \"possibleLengths\",\n    value: function possibleLengths() {\n      if (this.v1) return;\n      return this.metadata[this.v2 ? 2 : 3];\n    }\n  }, {\n    key: \"_getFormats\",\n    value: function _getFormats(metadata) {\n      return metadata[this.v1 ? 2 : this.v2 ? 3 : 4];\n    } // For countries of the same region (e.g. NANPA)\n    // formats are all stored in the \"main\" country for that region.\n    // E.g. \"RU\" and \"KZ\", \"US\" and \"CA\".\n\n  }, {\n    key: \"formats\",\n    value: function formats() {\n      var _this = this;\n\n      var formats = this._getFormats(this.metadata) || this._getFormats(this.getDefaultCountryMetadataForRegion()) || [];\n      return formats.map(function (_) {\n        return new Format(_, _this);\n      });\n    }\n  }, {\n    key: \"nationalPrefix\",\n    value: function nationalPrefix() {\n      return this.metadata[this.v1 ? 3 : this.v2 ? 4 : 5];\n    }\n  }, {\n    key: \"_getNationalPrefixFormattingRule\",\n    value: function _getNationalPrefixFormattingRule(metadata) {\n      return metadata[this.v1 ? 4 : this.v2 ? 5 : 6];\n    } // For countries of the same region (e.g. NANPA)\n    // national prefix formatting rule is stored in the \"main\" country for that region.\n    // E.g. \"RU\" and \"KZ\", \"US\" and \"CA\".\n\n  }, {\n    key: \"nationalPrefixFormattingRule\",\n    value: function nationalPrefixFormattingRule() {\n      return this._getNationalPrefixFormattingRule(this.metadata) || this._getNationalPrefixFormattingRule(this.getDefaultCountryMetadataForRegion());\n    }\n  }, {\n    key: \"_nationalPrefixForParsing\",\n    value: function _nationalPrefixForParsing() {\n      return this.metadata[this.v1 ? 5 : this.v2 ? 6 : 7];\n    }\n  }, {\n    key: \"nationalPrefixForParsing\",\n    value: function nationalPrefixForParsing() {\n      // If `national_prefix_for_parsing` is not set explicitly,\n      // then infer it from `national_prefix` (if any)\n      return this._nationalPrefixForParsing() || this.nationalPrefix();\n    }\n  }, {\n    key: \"nationalPrefixTransformRule\",\n    value: function nationalPrefixTransformRule() {\n      return this.metadata[this.v1 ? 6 : this.v2 ? 7 : 8];\n    }\n  }, {\n    key: \"_getNationalPrefixIsOptionalWhenFormatting\",\n    value: function _getNationalPrefixIsOptionalWhenFormatting() {\n      return !!this.metadata[this.v1 ? 7 : this.v2 ? 8 : 9];\n    } // For countries of the same region (e.g. NANPA)\n    // \"national prefix is optional when formatting\" flag is\n    // stored in the \"main\" country for that region.\n    // E.g. \"RU\" and \"KZ\", \"US\" and \"CA\".\n\n  }, {\n    key: \"nationalPrefixIsOptionalWhenFormattingInNationalFormat\",\n    value: function nationalPrefixIsOptionalWhenFormattingInNationalFormat() {\n      return this._getNationalPrefixIsOptionalWhenFormatting(this.metadata) || this._getNationalPrefixIsOptionalWhenFormatting(this.getDefaultCountryMetadataForRegion());\n    }\n  }, {\n    key: \"leadingDigits\",\n    value: function leadingDigits() {\n      return this.metadata[this.v1 ? 8 : this.v2 ? 9 : 10];\n    }\n  }, {\n    key: \"types\",\n    value: function types() {\n      return this.metadata[this.v1 ? 9 : this.v2 ? 10 : 11];\n    }\n  }, {\n    key: \"hasTypes\",\n    value: function hasTypes() {\n      // Versions 1.2.0 - 1.2.4: can be `[]`.\n\n      /* istanbul ignore next */\n      if (this.types() && this.types().length === 0) {\n        return false;\n      } // Versions <= 1.2.4: can be `undefined`.\n      // Version >= 1.2.5: can be `0`.\n\n\n      return !!this.types();\n    }\n  }, {\n    key: \"type\",\n    value: function type(_type2) {\n      if (this.hasTypes() && getType(this.types(), _type2)) {\n        return new Type(getType(this.types(), _type2), this);\n      }\n    }\n  }, {\n    key: \"ext\",\n    value: function ext() {\n      if (this.v1 || this.v2) return DEFAULT_EXT_PREFIX;\n      return this.metadata[13] || DEFAULT_EXT_PREFIX;\n    }\n  }]);\n\n  return NumberingPlan;\n}();\n\nvar Format = /*#__PURE__*/function () {\n  function Format(format, metadata) {\n    _classCallCheck(this, Format);\n\n    this._format = format;\n    this.metadata = metadata;\n  }\n\n  _createClass(Format, [{\n    key: \"pattern\",\n    value: function pattern() {\n      return this._format[0];\n    }\n  }, {\n    key: \"format\",\n    value: function format() {\n      return this._format[1];\n    }\n  }, {\n    key: \"leadingDigitsPatterns\",\n    value: function leadingDigitsPatterns() {\n      return this._format[2] || [];\n    }\n  }, {\n    key: \"nationalPrefixFormattingRule\",\n    value: function nationalPrefixFormattingRule() {\n      return this._format[3] || this.metadata.nationalPrefixFormattingRule();\n    }\n  }, {\n    key: \"nationalPrefixIsOptionalWhenFormattingInNationalFormat\",\n    value: function nationalPrefixIsOptionalWhenFormattingInNationalFormat() {\n      return !!this._format[4] || this.metadata.nationalPrefixIsOptionalWhenFormattingInNationalFormat();\n    }\n  }, {\n    key: \"nationalPrefixIsMandatoryWhenFormattingInNationalFormat\",\n    value: function nationalPrefixIsMandatoryWhenFormattingInNationalFormat() {\n      // National prefix is omitted if there's no national prefix formatting rule\n      // set for this country, or when the national prefix formatting rule\n      // contains no national prefix itself, or when this rule is set but\n      // national prefix is optional for this phone number format\n      // (and it is not enforced explicitly)\n      return this.usesNationalPrefix() && !this.nationalPrefixIsOptionalWhenFormattingInNationalFormat();\n    } // Checks whether national prefix formatting rule contains national prefix.\n\n  }, {\n    key: \"usesNationalPrefix\",\n    value: function usesNationalPrefix() {\n      return this.nationalPrefixFormattingRule() && // Check that national prefix formatting rule is not a \"dummy\" one.\n      !FIRST_GROUP_ONLY_PREFIX_PATTERN.test(this.nationalPrefixFormattingRule()) // In compressed metadata, `this.nationalPrefixFormattingRule()` is `0`\n      // when `national_prefix_formatting_rule` is not present.\n      // So, `true` or `false` are returned explicitly here, so that\n      // `0` number isn't returned.\n      ? true : false;\n    }\n  }, {\n    key: \"internationalFormat\",\n    value: function internationalFormat() {\n      return this._format[5] || this.format();\n    }\n  }]);\n\n  return Format;\n}();\n/**\r\n * A pattern that is used to determine if the national prefix formatting rule\r\n * has the first group only, i.e., does not start with the national prefix.\r\n * Note that the pattern explicitly allows for unbalanced parentheses.\r\n */\n\n\nvar FIRST_GROUP_ONLY_PREFIX_PATTERN = /^\\(?\\$1\\)?$/;\n\nvar Type = /*#__PURE__*/function () {\n  function Type(type, metadata) {\n    _classCallCheck(this, Type);\n\n    this.type = type;\n    this.metadata = metadata;\n  }\n\n  _createClass(Type, [{\n    key: \"pattern\",\n    value: function pattern() {\n      if (this.metadata.v1) return this.type;\n      return this.type[0];\n    }\n  }, {\n    key: \"possibleLengths\",\n    value: function possibleLengths() {\n      if (this.metadata.v1) return;\n      return this.type[1] || this.metadata.possibleLengths();\n    }\n  }]);\n\n  return Type;\n}();\n\nfunction getType(types, type) {\n  switch (type) {\n    case 'FIXED_LINE':\n      return types[0];\n\n    case 'MOBILE':\n      return types[1];\n\n    case 'TOLL_FREE':\n      return types[2];\n\n    case 'PREMIUM_RATE':\n      return types[3];\n\n    case 'PERSONAL_NUMBER':\n      return types[4];\n\n    case 'VOICEMAIL':\n      return types[5];\n\n    case 'UAN':\n      return types[6];\n\n    case 'PAGER':\n      return types[7];\n\n    case 'VOIP':\n      return types[8];\n\n    case 'SHARED_COST':\n      return types[9];\n  }\n}\n\nexport function validateMetadata(metadata) {\n  if (!metadata) {\n    throw new Error('[libphonenumber-js] `metadata` argument not passed. Check your arguments.');\n  } // `country_phone_code_to_countries` was renamed to\n  // `country_calling_codes` in `1.0.18`.\n\n\n  if (!is_object(metadata) || !is_object(metadata.countries)) {\n    throw new Error(\"[libphonenumber-js] `metadata` argument was passed but it's not a valid metadata. Must be an object having `.countries` child object property. Got \".concat(is_object(metadata) ? 'an object of shape: { ' + Object.keys(metadata).join(', ') + ' }' : 'a ' + type_of(metadata) + ': ' + metadata, \".\"));\n  }\n} // Babel transforms `typeof` into some \"branches\"\n// so istanbul will show this as \"branch not covered\".\n\n/* istanbul ignore next */\n\nvar is_object = function is_object(_) {\n  return _typeof(_) === 'object';\n}; // Babel transforms `typeof` into some \"branches\"\n// so istanbul will show this as \"branch not covered\".\n\n/* istanbul ignore next */\n\n\nvar type_of = function type_of(_) {\n  return _typeof(_);\n};\n/**\r\n * Returns extension prefix for a country.\r\n * @param  {string} country\r\n * @param  {object} metadata\r\n * @return {string?}\r\n * @example\r\n * // Returns \" ext. \"\r\n * getExtPrefix(\"US\")\r\n */\n\n\nexport function getExtPrefix(country, metadata) {\n  metadata = new Metadata(metadata);\n\n  if (metadata.hasCountry(country)) {\n    return metadata.country(country).ext();\n  }\n\n  return DEFAULT_EXT_PREFIX;\n}\n/**\r\n * Returns \"country calling code\" for a country.\r\n * Throws an error if the country doesn't exist or isn't supported by this library.\r\n * @param  {string} country\r\n * @param  {object} metadata\r\n * @return {string}\r\n * @example\r\n * // Returns \"44\"\r\n * getCountryCallingCode(\"GB\")\r\n */\n\nexport function getCountryCallingCode(country, metadata) {\n  metadata = new Metadata(metadata);\n\n  if (metadata.hasCountry(country)) {\n    return metadata.country(country).countryCallingCode();\n  }\n\n  throw new Error(\"Unknown country: \".concat(country));\n}\nexport function isSupportedCountry(country, metadata) {\n  // metadata = new Metadata(metadata)\n  // return metadata.hasCountry(country)\n  return metadata.countries.hasOwnProperty(country);\n}\n\nfunction setVersion(metadata) {\n  var version = metadata.version;\n\n  if (typeof version === 'number') {\n    this.v1 = version === 1;\n    this.v2 = version === 2;\n    this.v3 = version === 3;\n    this.v4 = version === 4;\n  } else {\n    if (!version) {\n      this.v1 = true;\n    } else if (compare(version, V3) === -1) {\n      this.v2 = true;\n    } else if (compare(version, V4) === -1) {\n      this.v3 = true;\n    } else {\n      this.v4 = true;\n    }\n  }\n} // const ISO_COUNTRY_CODE = /^[A-Z]{2}$/\n// function isCountryCode(countryCode) {\n// \treturn ISO_COUNTRY_CODE.test(countryCodeOrCountryCallingCode)\n// }","/**\r\n * Checks whether the entire input sequence can be matched\r\n * against the regular expression.\r\n * @return {boolean}\r\n */\nexport default function matchesEntirely(text, regular_expression) {\n  // If assigning the `''` default value is moved to the arguments above,\n  // code coverage would decrease for some weird reason.\n  text = text || '';\n  return new RegExp('^(?:' + regular_expression + ')$').test(text);\n}","function _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nimport Metadata from '../metadata.js';\nimport matchesEntirely from './matchesEntirely.js';\nvar NON_FIXED_LINE_PHONE_TYPES = ['MOBILE', 'PREMIUM_RATE', 'TOLL_FREE', 'SHARED_COST', 'VOIP', 'PERSONAL_NUMBER', 'PAGER', 'UAN', 'VOICEMAIL']; // Finds out national phone number type (fixed line, mobile, etc)\n\nexport default function getNumberType(input, options, metadata) {\n  // If assigning the `{}` default value is moved to the arguments above,\n  // code coverage would decrease for some weird reason.\n  options = options || {}; // When `parse()` returned `{}`\n  // meaning that the phone number is not a valid one.\n\n  if (!input.country) {\n    return;\n  }\n\n  metadata = new Metadata(metadata);\n  metadata.selectNumberingPlan(input.country, input.countryCallingCode);\n  var nationalNumber = options.v2 ? input.nationalNumber : input.phone; // The following is copy-pasted from the original function:\n  // https://github.com/googlei18n/libphonenumber/blob/3ea547d4fbaa2d0b67588904dfa5d3f2557c27ff/javascript/i18n/phonenumbers/phonenumberutil.js#L2835\n  // Is this national number even valid for this country\n\n  if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern())) {\n    return;\n  } // Is it fixed line number\n\n\n  if (isNumberTypeEqualTo(nationalNumber, 'FIXED_LINE', metadata)) {\n    // Because duplicate regular expressions are removed\n    // to reduce metadata size, if \"mobile\" pattern is \"\"\n    // then it means it was removed due to being a duplicate of the fixed-line pattern.\n    //\n    if (metadata.type('MOBILE') && metadata.type('MOBILE').pattern() === '') {\n      return 'FIXED_LINE_OR_MOBILE';\n    } // `MOBILE` type pattern isn't included if it matched `FIXED_LINE` one.\n    // For example, for \"US\" country.\n    // Old metadata (< `1.0.18`) had a specific \"types\" data structure\n    // that happened to be `undefined` for `MOBILE` in that case.\n    // Newer metadata (>= `1.0.18`) has another data structure that is\n    // not `undefined` for `MOBILE` in that case (it's just an empty array).\n    // So this `if` is just for backwards compatibility with old metadata.\n\n\n    if (!metadata.type('MOBILE')) {\n      return 'FIXED_LINE_OR_MOBILE';\n    } // Check if the number happens to qualify as both fixed line and mobile.\n    // (no such country in the minimal metadata set)\n\n    /* istanbul ignore if */\n\n\n    if (isNumberTypeEqualTo(nationalNumber, 'MOBILE', metadata)) {\n      return 'FIXED_LINE_OR_MOBILE';\n    }\n\n    return 'FIXED_LINE';\n  }\n\n  for (var _iterator = _createForOfIteratorHelperLoose(NON_FIXED_LINE_PHONE_TYPES), _step; !(_step = _iterator()).done;) {\n    var type = _step.value;\n\n    if (isNumberTypeEqualTo(nationalNumber, type, metadata)) {\n      return type;\n    }\n  }\n}\nexport function isNumberTypeEqualTo(nationalNumber, type, metadata) {\n  type = metadata.type(type);\n\n  if (!type || !type.pattern()) {\n    return false;\n  } // Check if any possible number lengths are present;\n  // if so, we use them to avoid checking\n  // the validation pattern if they don't match.\n  // If they are absent, this means they match\n  // the general description, which we have\n  // already checked before a specific number type.\n\n\n  if (type.possibleLengths() && type.possibleLengths().indexOf(nationalNumber.length) < 0) {\n    return false;\n  }\n\n  return matchesEntirely(nationalNumber, type.pattern());\n}","import Metadata from './metadata.js';\nimport matchesEntirely from './helpers/matchesEntirely.js';\nimport getNumberType from './helpers/getNumberType.js';\n/**\r\n * Checks if a given phone number is valid.\r\n *\r\n * isValid(phoneNumberInstance, { ..., v2: true }, metadata)\r\n *\r\n * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)\r\n * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)\r\n *\r\n * If the `number` is a string, it will be parsed to an object,\r\n * but only if it contains only valid phone number characters (including punctuation).\r\n * If the `number` is an object, it is used as is.\r\n *\r\n * The optional `defaultCountry` argument is the default country.\r\n * I.e. it does not restrict to just that country,\r\n * e.g. in those cases where several countries share\r\n * the same phone numbering rules (NANPA, Britain, etc).\r\n * For example, even though the number `07624 369230`\r\n * belongs to the Isle of Man (\"IM\" country code)\r\n * calling `isValidNumber('07624369230', 'GB', metadata)`\r\n * still returns `true` because the country is not restricted to `GB`,\r\n * it's just that `GB` is the default one for the phone numbering rules.\r\n * For restricting the country see `isValidNumberForRegion()`\r\n * though restricting a country might not be a good idea.\r\n * https://github.com/googlei18n/libphonenumber/blob/master/FAQ.md#when-should-i-use-isvalidnumberforregion\r\n *\r\n * Examples:\r\n *\r\n * ```js\r\n * isValidNumber('+78005553535', metadata)\r\n * isValidNumber('8005553535', 'RU', metadata)\r\n * isValidNumber('88005553535', 'RU', metadata)\r\n * isValidNumber({ phone: '8005553535', country: 'RU' }, metadata)\r\n * ```\r\n */\n\nexport default function isValidNumber(input, options, metadata) {\n  // If assigning the `{}` default value is moved to the arguments above,\n  // code coverage would decrease for some weird reason.\n  options = options || {};\n  metadata = new Metadata(metadata);\n  /**\r\n   * Checks if a phone number is \"possible\" (basically just checks its length).\r\n   *\r\n   * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.\r\n   * @param  {object} [options]\r\n   * @param  {object} metadata\r\n   * @return {string}\r\n   */\n\n  metadata.selectNumberingPlan(input.country, input.countryCallingCode); // By default, countries only have type regexps when it's required for\n  // distinguishing different countries having the same `countryCallingCode`.\n\n  if (metadata.hasTypes()) {\n    return getNumberType(input, options, metadata.metadata) !== undefined;\n  } // If there are no type regexps for this country in metadata then use\n  // `nationalNumberPattern` as a \"better than nothing\" replacement.\n\n\n  var nationalNumber = options.v2 ? input.nationalNumber : input.phone;\n  return matchesEntirely(nationalNumber, metadata.nationalNumberPattern());\n}","// The minimum length of the national significant number.\nexport var MIN_LENGTH_FOR_NSN = 2; // The ITU says the maximum length should be 15,\n// but one can find longer numbers in Germany.\n\nexport var MAX_LENGTH_FOR_NSN = 17; // The maximum length of the country calling code.\n\nexport var MAX_LENGTH_COUNTRY_CODE = 3; // Digits accepted in phone numbers\n// (ascii, fullwidth, arabic-indic, and eastern arabic digits).\n\nexport var VALID_DIGITS = \"0-9\\uFF10-\\uFF19\\u0660-\\u0669\\u06F0-\\u06F9\"; // `DASHES` will be right after the opening square bracket of the \"character class\"\n\nvar DASHES = \"-\\u2010-\\u2015\\u2212\\u30FC\\uFF0D\";\nvar SLASHES = \"\\uFF0F/\";\nvar DOTS = \"\\uFF0E.\";\nexport var WHITESPACE = \" \\xA0\\xAD\\u200B\\u2060\\u3000\";\nvar BRACKETS = \"()\\uFF08\\uFF09\\uFF3B\\uFF3D\\\\[\\\\]\"; // export const OPENING_BRACKETS = '(\\uFF08\\uFF3B\\\\\\['\n\nvar TILDES = \"~\\u2053\\u223C\\uFF5E\"; // Regular expression of acceptable punctuation found in phone numbers. This\n// excludes punctuation found as a leading character only. This consists of dash\n// characters, white space characters, full stops, slashes, square brackets,\n// parentheses and tildes. Full-width variants are also present.\n\nexport var VALID_PUNCTUATION = \"\".concat(DASHES).concat(SLASHES).concat(DOTS).concat(WHITESPACE).concat(BRACKETS).concat(TILDES);\nexport var PLUS_CHARS = \"+\\uFF0B\"; // const LEADING_PLUS_CHARS_PATTERN = new RegExp('^[' + PLUS_CHARS + ']+')","import { VALID_DIGITS } from '../../constants.js'; // The RFC 3966 format for extensions.\n\nvar RFC3966_EXTN_PREFIX = ';ext=';\n/**\r\n * Helper method for constructing regular expressions for parsing. Creates\r\n * an expression that captures up to max_length digits.\r\n * @return {string} RegEx pattern to capture extension digits.\r\n */\n\nvar getExtensionDigitsPattern = function getExtensionDigitsPattern(maxLength) {\n  return \"([\".concat(VALID_DIGITS, \"]{1,\").concat(maxLength, \"})\");\n};\n/**\r\n * Helper initialiser method to create the regular-expression pattern to match\r\n * extensions.\r\n * Copy-pasted from Google's `libphonenumber`:\r\n * https://github.com/google/libphonenumber/blob/55b2646ec9393f4d3d6661b9c82ef9e258e8b829/javascript/i18n/phonenumbers/phonenumberutil.js#L759-L766\r\n * @return {string} RegEx pattern to capture extensions.\r\n */\n\n\nexport default function createExtensionPattern(purpose) {\n  // We cap the maximum length of an extension based on the ambiguity of the way\n  // the extension is prefixed. As per ITU, the officially allowed length for\n  // extensions is actually 40, but we don't support this since we haven't seen real\n  // examples and this introduces many false interpretations as the extension labels\n  // are not standardized.\n\n  /** @type {string} */\n  var extLimitAfterExplicitLabel = '20';\n  /** @type {string} */\n\n  var extLimitAfterLikelyLabel = '15';\n  /** @type {string} */\n\n  var extLimitAfterAmbiguousChar = '9';\n  /** @type {string} */\n\n  var extLimitWhenNotSure = '6';\n  /** @type {string} */\n\n  var possibleSeparatorsBetweenNumberAndExtLabel = \"[ \\xA0\\\\t,]*\"; // Optional full stop (.) or colon, followed by zero or more spaces/tabs/commas.\n\n  /** @type {string} */\n\n  var possibleCharsAfterExtLabel = \"[:\\\\.\\uFF0E]?[ \\xA0\\\\t,-]*\";\n  /** @type {string} */\n\n  var optionalExtnSuffix = \"#?\"; // Here the extension is called out in more explicit way, i.e mentioning it obvious\n  // patterns like \"ext.\".\n\n  /** @type {string} */\n\n  var explicitExtLabels = \"(?:e?xt(?:ensi(?:o\\u0301?|\\xF3))?n?|\\uFF45?\\uFF58\\uFF54\\uFF4E?|\\u0434\\u043E\\u0431|anexo)\"; // One-character symbols that can be used to indicate an extension, and less\n  // commonly used or more ambiguous extension labels.\n\n  /** @type {string} */\n\n  var ambiguousExtLabels = \"(?:[x\\uFF58#\\uFF03~\\uFF5E]|int|\\uFF49\\uFF4E\\uFF54)\"; // When extension is not separated clearly.\n\n  /** @type {string} */\n\n  var ambiguousSeparator = \"[- ]+\"; // This is the same as possibleSeparatorsBetweenNumberAndExtLabel, but not matching\n  // comma as extension label may have it.\n\n  /** @type {string} */\n\n  var possibleSeparatorsNumberExtLabelNoComma = \"[ \\xA0\\\\t]*\"; // \",,\" is commonly used for auto dialling the extension when connected. First\n  // comma is matched through possibleSeparatorsBetweenNumberAndExtLabel, so we do\n  // not repeat it here. Semi-colon works in Iphone and Android also to pop up a\n  // button with the extension number following.\n\n  /** @type {string} */\n\n  var autoDiallingAndExtLabelsFound = \"(?:,{2}|;)\";\n  /** @type {string} */\n\n  var rfcExtn = RFC3966_EXTN_PREFIX + getExtensionDigitsPattern(extLimitAfterExplicitLabel);\n  /** @type {string} */\n\n  var explicitExtn = possibleSeparatorsBetweenNumberAndExtLabel + explicitExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterExplicitLabel) + optionalExtnSuffix;\n  /** @type {string} */\n\n  var ambiguousExtn = possibleSeparatorsBetweenNumberAndExtLabel + ambiguousExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix;\n  /** @type {string} */\n\n  var americanStyleExtnWithSuffix = ambiguousSeparator + getExtensionDigitsPattern(extLimitWhenNotSure) + \"#\";\n  /** @type {string} */\n\n  var autoDiallingExtn = possibleSeparatorsNumberExtLabelNoComma + autoDiallingAndExtLabelsFound + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterLikelyLabel) + optionalExtnSuffix;\n  /** @type {string} */\n\n  var onlyCommasExtn = possibleSeparatorsNumberExtLabelNoComma + \"(?:,)+\" + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix; // The first regular expression covers RFC 3966 format, where the extension is added\n  // using \";ext=\". The second more generic where extension is mentioned with explicit\n  // labels like \"ext:\". In both the above cases we allow more numbers in extension than\n  // any other extension labels. The third one captures when single character extension\n  // labels or less commonly used labels are used. In such cases we capture fewer\n  // extension digits in order to reduce the chance of falsely interpreting two\n  // numbers beside each other as a number + extension. The fourth one covers the\n  // special case of American numbers where the extension is written with a hash\n  // at the end, such as \"- 503#\". The fifth one is exclusively for extension\n  // autodialling formats which are used when dialling and in this case we accept longer\n  // extensions. The last one is more liberal on the number of commas that acts as\n  // extension labels, so we have a strict cap on the number of digits in such extensions.\n\n  return rfcExtn + \"|\" + explicitExtn + \"|\" + ambiguousExtn + \"|\" + americanStyleExtnWithSuffix + \"|\" + autoDiallingExtn + \"|\" + onlyCommasExtn;\n}","import { MIN_LENGTH_FOR_NSN, VALID_DIGITS, VALID_PUNCTUATION, PLUS_CHARS } from '../constants.js';\nimport createExtensionPattern from './extension/createExtensionPattern.js'; //  Regular expression of viable phone numbers. This is location independent.\n//  Checks we have at least three leading digits, and only valid punctuation,\n//  alpha characters and digits in the phone number. Does not include extension\n//  data. The symbol 'x' is allowed here as valid punctuation since it is often\n//  used as a placeholder for carrier codes, for example in Brazilian phone\n//  numbers. We also allow multiple '+' characters at the start.\n//\n//  Corresponds to the following:\n//  [digits]{minLengthNsn}|\n//  plus_sign*\n//  (([punctuation]|[star])*[digits]){3,}([punctuation]|[star]|[digits]|[alpha])*\n//\n//  The first reg-ex is to allow short numbers (two digits long) to be parsed if\n//  they are entered as \"15\" etc, but only if there is no punctuation in them.\n//  The second expression restricts the number of digits to three or more, but\n//  then allows them to be in international form, and to have alpha-characters\n//  and punctuation. We split up the two reg-exes here and combine them when\n//  creating the reg-ex VALID_PHONE_NUMBER_PATTERN itself so we can prefix it\n//  with ^ and append $ to each branch.\n//\n//  \"Note VALID_PUNCTUATION starts with a -,\n//   so must be the first in the range\" (c) Google devs.\n//  (wtf did they mean by saying that; probably nothing)\n//\n\nvar MIN_LENGTH_PHONE_NUMBER_PATTERN = '[' + VALID_DIGITS + ']{' + MIN_LENGTH_FOR_NSN + '}'; //\n// And this is the second reg-exp:\n// (see MIN_LENGTH_PHONE_NUMBER_PATTERN for a full description of this reg-exp)\n//\n\nexport var VALID_PHONE_NUMBER = '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){3,}' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']*'; // This regular expression isn't present in Google's `libphonenumber`\n// and is only used to determine whether the phone number being input\n// is too short for it to even consider it a \"valid\" number.\n// This is just a way to differentiate between a really invalid phone\n// number like \"abcde\" and a valid phone number that a user has just\n// started inputting, like \"+1\" or \"1\": both these cases would be\n// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this\n// library can provide a more detailed error message — whether it's\n// really \"not a number\", or is it just a start of a valid phone number.\n\nvar VALID_PHONE_NUMBER_START_REG_EXP = new RegExp('^' + '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){1,2}' + '$', 'i');\nexport var VALID_PHONE_NUMBER_WITH_EXTENSION = VALID_PHONE_NUMBER + // Phone number extensions\n'(?:' + createExtensionPattern() + ')?'; // The combined regular expression for valid phone numbers:\n//\n\nvar VALID_PHONE_NUMBER_PATTERN = new RegExp( // Either a short two-digit-only phone number\n'^' + MIN_LENGTH_PHONE_NUMBER_PATTERN + '$' + '|' + // Or a longer fully parsed phone number (min 3 characters)\n'^' + VALID_PHONE_NUMBER_WITH_EXTENSION + '$', 'i'); // Checks to see if the string of characters could possibly be a phone number at\n// all. At the moment, checks to see that the string begins with at least 2\n// digits, ignoring any punctuation commonly found in phone numbers. This method\n// does not require the number to be normalized in advance - but does assume\n// that leading non-number symbols have been removed, such as by the method\n// `extract_possible_number`.\n//\n\nexport default function isViablePhoneNumber(number) {\n  return number.length >= MIN_LENGTH_FOR_NSN && VALID_PHONE_NUMBER_PATTERN.test(number);\n} // This is just a way to differentiate between a really invalid phone\n// number like \"abcde\" and a valid phone number that a user has just\n// started inputting, like \"+1\" or \"1\": both these cases would be\n// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this\n// library can provide a more detailed error message — whether it's\n// really \"not a number\", or is it just a start of a valid phone number.\n\nexport function isViablePhoneNumberStart(number) {\n  return VALID_PHONE_NUMBER_START_REG_EXP.test(number);\n}","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) _setPrototypeOf(subClass, superClass);\n}\n\nfunction _createSuper(Derived) {\n  var hasNativeReflectConstruct = _isNativeReflectConstruct();\n\n  return function _createSuperInternal() {\n    var Super = _getPrototypeOf(Derived),\n        result;\n\n    if (hasNativeReflectConstruct) {\n      var NewTarget = _getPrototypeOf(this).constructor;\n\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n\n    return _possibleConstructorReturn(this, result);\n  };\n}\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n\n  return _assertThisInitialized(self);\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nfunction _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n  _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !_isNativeFunction(Class)) return Class;\n\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n\n      _cache.set(Class, Wrapper);\n    }\n\n    function Wrapper() {\n      return _construct(Class, arguments, _getPrototypeOf(this).constructor);\n    }\n\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return _setPrototypeOf(Wrapper, Class);\n  };\n\n  return _wrapNativeSuper(Class);\n}\n\nfunction _construct(Parent, args, Class) {\n  if (_isNativeReflectConstruct()) {\n    _construct = Reflect.construct;\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) _setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n\n  return _construct.apply(null, arguments);\n}\n\nfunction _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n} // https://stackoverflow.com/a/46971044/970769\n// \"Breaking changes in Typescript 2.1\"\n// \"Extending built-ins like Error, Array, and Map may no longer work.\"\n// \"As a recommendation, you can manually adjust the prototype immediately after any super(...) calls.\"\n// https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n\n\nvar ParseError = /*#__PURE__*/function (_Error) {\n  _inherits(ParseError, _Error);\n\n  var _super = _createSuper(ParseError);\n\n  function ParseError(code) {\n    var _this;\n\n    _classCallCheck(this, ParseError);\n\n    _this = _super.call(this, code); // Set the prototype explicitly.\n    // Any subclass of FooError will have to manually set the prototype as well.\n\n    Object.setPrototypeOf(_assertThisInitialized(_this), ParseError.prototype);\n    _this.name = _this.constructor.name;\n    return _this;\n  }\n\n  return _createClass(ParseError);\n}( /*#__PURE__*/_wrapNativeSuper(Error));\n\nexport { ParseError as default };","import createExtensionPattern from './createExtensionPattern.js'; // Regexp of all known extension prefixes used by different regions followed by\n// 1 or more valid digits, for use when parsing.\n\nvar EXTN_PATTERN = new RegExp('(?:' + createExtensionPattern() + ')$', 'i'); // Strips any extension (as in, the part of the number dialled after the call is\n// connected, usually indicated with extn, ext, x or similar) from the end of\n// the number, and returns it.\n\nexport default function extractExtension(number) {\n  var start = number.search(EXTN_PATTERN);\n\n  if (start < 0) {\n    return {};\n  } // If we find a potential extension, and the number preceding this is a viable\n  // number, we assume it is an extension.\n\n\n  var numberWithoutExtension = number.slice(0, start);\n  var matches = number.match(EXTN_PATTERN);\n  var i = 1;\n\n  while (i < matches.length) {\n    if (matches[i]) {\n      return {\n        number: numberWithoutExtension,\n        ext: matches[i]\n      };\n    }\n\n    i++;\n  }\n}","function _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n} // These mappings map a character (key) to a specific digit that should\n// replace it for normalization purposes. Non-European digits that\n// may be used in phone numbers are mapped to a European equivalent.\n//\n// E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.\n//\n\n\nexport var DIGITS = {\n  '0': '0',\n  '1': '1',\n  '2': '2',\n  '3': '3',\n  '4': '4',\n  '5': '5',\n  '6': '6',\n  '7': '7',\n  '8': '8',\n  '9': '9',\n  \"\\uFF10\": '0',\n  // Fullwidth digit 0\n  \"\\uFF11\": '1',\n  // Fullwidth digit 1\n  \"\\uFF12\": '2',\n  // Fullwidth digit 2\n  \"\\uFF13\": '3',\n  // Fullwidth digit 3\n  \"\\uFF14\": '4',\n  // Fullwidth digit 4\n  \"\\uFF15\": '5',\n  // Fullwidth digit 5\n  \"\\uFF16\": '6',\n  // Fullwidth digit 6\n  \"\\uFF17\": '7',\n  // Fullwidth digit 7\n  \"\\uFF18\": '8',\n  // Fullwidth digit 8\n  \"\\uFF19\": '9',\n  // Fullwidth digit 9\n  \"\\u0660\": '0',\n  // Arabic-indic digit 0\n  \"\\u0661\": '1',\n  // Arabic-indic digit 1\n  \"\\u0662\": '2',\n  // Arabic-indic digit 2\n  \"\\u0663\": '3',\n  // Arabic-indic digit 3\n  \"\\u0664\": '4',\n  // Arabic-indic digit 4\n  \"\\u0665\": '5',\n  // Arabic-indic digit 5\n  \"\\u0666\": '6',\n  // Arabic-indic digit 6\n  \"\\u0667\": '7',\n  // Arabic-indic digit 7\n  \"\\u0668\": '8',\n  // Arabic-indic digit 8\n  \"\\u0669\": '9',\n  // Arabic-indic digit 9\n  \"\\u06F0\": '0',\n  // Eastern-Arabic digit 0\n  \"\\u06F1\": '1',\n  // Eastern-Arabic digit 1\n  \"\\u06F2\": '2',\n  // Eastern-Arabic digit 2\n  \"\\u06F3\": '3',\n  // Eastern-Arabic digit 3\n  \"\\u06F4\": '4',\n  // Eastern-Arabic digit 4\n  \"\\u06F5\": '5',\n  // Eastern-Arabic digit 5\n  \"\\u06F6\": '6',\n  // Eastern-Arabic digit 6\n  \"\\u06F7\": '7',\n  // Eastern-Arabic digit 7\n  \"\\u06F8\": '8',\n  // Eastern-Arabic digit 8\n  \"\\u06F9\": '9' // Eastern-Arabic digit 9\n\n};\nexport function parseDigit(character) {\n  return DIGITS[character];\n}\n/**\r\n * Parses phone number digits from a string.\r\n * Drops all punctuation leaving only digits.\r\n * Also converts wide-ascii and arabic-indic numerals to conventional numerals.\r\n * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.\r\n * @param  {string} string\r\n * @return {string}\r\n * @example\r\n * ```js\r\n * parseDigits('8 (800) 555')\r\n * // Outputs '8800555'.\r\n * ```\r\n */\n\nexport default function parseDigits(string) {\n  var result = ''; // Using `.split('')` here instead of normal `for ... of`\n  // because the importing application doesn't neccessarily include an ES6 polyfill.\n  // The `.split('')` approach discards \"exotic\" UTF-8 characters\n  // (the ones consisting of four bytes) but digits\n  // (including non-European ones) don't fall into that range\n  // so such \"exotic\" characters would be discarded anyway.\n\n  for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {\n    var character = _step.value;\n    var digit = parseDigit(character);\n\n    if (digit) {\n      result += digit;\n    }\n  }\n\n  return result;\n}","function _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nimport { parseDigit } from './helpers/parseDigits.js';\n/**\r\n * Parses phone number characters from a string.\r\n * Drops all punctuation leaving only digits and the leading `+` sign (if any).\r\n * Also converts wide-ascii and arabic-indic numerals to conventional numerals.\r\n * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.\r\n * @param  {string} string\r\n * @return {string}\r\n * @example\r\n * ```js\r\n * // Outputs '8800555'.\r\n * parseIncompletePhoneNumber('8 (800) 555')\r\n * // Outputs '+7800555'.\r\n * parseIncompletePhoneNumber('+7 800 555')\r\n * ```\r\n */\n\nexport default function parseIncompletePhoneNumber(string) {\n  var result = ''; // Using `.split('')` here instead of normal `for ... of`\n  // because the importing application doesn't neccessarily include an ES6 polyfill.\n  // The `.split('')` approach discards \"exotic\" UTF-8 characters\n  // (the ones consisting of four bytes) but digits\n  // (including non-European ones) don't fall into that range\n  // so such \"exotic\" characters would be discarded anyway.\n\n  for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {\n    var character = _step.value;\n    result += parsePhoneNumberCharacter(character, result) || '';\n  }\n\n  return result;\n}\n/**\r\n * Parses next character while parsing phone number digits (including a `+`)\r\n * from text: discards everything except `+` and digits, and `+` is only allowed\r\n * at the start of a phone number.\r\n * For example, is used in `react-phone-number-input` where it uses\r\n * [`input-format`](https://gitlab.com/catamphetamine/input-format).\r\n * @param  {string} character - Yet another character from raw input string.\r\n * @param  {string?} prevParsedCharacters - Previous parsed characters.\r\n * @param  {object} meta - Optional custom use-case-specific metadata.\r\n * @return {string?} The parsed character.\r\n */\n\nexport function parsePhoneNumberCharacter(character, prevParsedCharacters) {\n  // Only allow a leading `+`.\n  if (character === '+') {\n    // If this `+` is not the first parsed character\n    // then discard it.\n    if (prevParsedCharacters) {\n      return;\n    }\n\n    return '+';\n  } // Allow digits.\n\n\n  return parseDigit(character);\n}","function _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n/**\r\n * Merges two arrays.\r\n * @param  {*} a\r\n * @param  {*} b\r\n * @return {*}\r\n */\n\n\nexport default function mergeArrays(a, b) {\n  var merged = a.slice();\n\n  for (var _iterator = _createForOfIteratorHelperLoose(b), _step; !(_step = _iterator()).done;) {\n    var element = _step.value;\n\n    if (a.indexOf(element) < 0) {\n      merged.push(element);\n    }\n  }\n\n  return merged.sort(function (a, b) {\n    return a - b;\n  }); // ES6 version, requires Set polyfill.\n  // let merged = new Set(a)\n  // for (const element of b) {\n  // \tmerged.add(i)\n  // }\n  // return Array.from(merged).sort((a, b) => a - b)\n}","import mergeArrays from './mergeArrays.js';\nexport default function checkNumberLength(nationalNumber, metadata) {\n  return checkNumberLengthForType(nationalNumber, undefined, metadata);\n} // Checks whether a number is possible for the country based on its length.\n// Should only be called for the \"new\" metadata which has \"possible lengths\".\n\nexport function checkNumberLengthForType(nationalNumber, type, metadata) {\n  var type_info = metadata.type(type); // There should always be \"<possiblePengths/>\" set for every type element.\n  // This is declared in the XML schema.\n  // For size efficiency, where a sub-description (e.g. fixed-line)\n  // has the same \"<possiblePengths/>\" as the \"general description\", this is missing,\n  // so we fall back to the \"general description\". Where no numbers of the type\n  // exist at all, there is one possible length (-1) which is guaranteed\n  // not to match the length of any real phone number.\n\n  var possible_lengths = type_info && type_info.possibleLengths() || metadata.possibleLengths(); // let local_lengths    = type_info && type.possibleLengthsLocal() || metadata.possibleLengthsLocal()\n  // Metadata before version `1.0.18` didn't contain `possible_lengths`.\n\n  if (!possible_lengths) {\n    return 'IS_POSSIBLE';\n  }\n\n  if (type === 'FIXED_LINE_OR_MOBILE') {\n    // No such country in metadata.\n\n    /* istanbul ignore next */\n    if (!metadata.type('FIXED_LINE')) {\n      // The rare case has been encountered where no fixedLine data is available\n      // (true for some non-geographic entities), so we just check mobile.\n      return checkNumberLengthForType(nationalNumber, 'MOBILE', metadata);\n    }\n\n    var mobile_type = metadata.type('MOBILE');\n\n    if (mobile_type) {\n      // Merge the mobile data in if there was any. \"Concat\" creates a new\n      // array, it doesn't edit possible_lengths in place, so we don't need a copy.\n      // Note that when adding the possible lengths from mobile, we have\n      // to again check they aren't empty since if they are this indicates\n      // they are the same as the general desc and should be obtained from there.\n      possible_lengths = mergeArrays(possible_lengths, mobile_type.possibleLengths()); // The current list is sorted; we need to merge in the new list and\n      // re-sort (duplicates are okay). Sorting isn't so expensive because\n      // the lists are very small.\n      // if (local_lengths) {\n      // \tlocal_lengths = mergeArrays(local_lengths, mobile_type.possibleLengthsLocal())\n      // } else {\n      // \tlocal_lengths = mobile_type.possibleLengthsLocal()\n      // }\n    }\n  } // If the type doesn't exist then return 'INVALID_LENGTH'.\n  else if (type && !type_info) {\n    return 'INVALID_LENGTH';\n  }\n\n  var actual_length = nationalNumber.length; // In `libphonenumber-js` all \"local-only\" formats are dropped for simplicity.\n  // // This is safe because there is never an overlap beween the possible lengths\n  // // and the local-only lengths; this is checked at build time.\n  // if (local_lengths && local_lengths.indexOf(nationalNumber.length) >= 0)\n  // {\n  // \treturn 'IS_POSSIBLE_LOCAL_ONLY'\n  // }\n\n  var minimum_length = possible_lengths[0];\n\n  if (minimum_length === actual_length) {\n    return 'IS_POSSIBLE';\n  }\n\n  if (minimum_length > actual_length) {\n    return 'TOO_SHORT';\n  }\n\n  if (possible_lengths[possible_lengths.length - 1] < actual_length) {\n    return 'TOO_LONG';\n  } // We skip the first element since we've already checked it.\n\n\n  return possible_lengths.indexOf(actual_length, 1) >= 0 ? 'IS_POSSIBLE' : 'INVALID_LENGTH';\n}","import Metadata from './metadata.js';\nimport checkNumberLength from './helpers/checkNumberLength.js';\n/**\r\n * Checks if a phone number is \"possible\" (basically just checks its length).\r\n *\r\n * isPossible(phoneNumberInstance, { ..., v2: true }, metadata)\r\n *\r\n * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)\r\n * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)\r\n *\r\n * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.\r\n * @param  {object} [options]\r\n * @param  {object} metadata\r\n * @return {string}\r\n */\n\nexport default function isPossiblePhoneNumber(input, options, metadata) {\n  /* istanbul ignore if */\n  if (options === undefined) {\n    options = {};\n  }\n\n  metadata = new Metadata(metadata);\n\n  if (options.v2) {\n    if (!input.countryCallingCode) {\n      throw new Error('Invalid phone number object passed');\n    }\n\n    metadata.selectNumberingPlan(input.countryCallingCode);\n  } else {\n    if (!input.phone) {\n      return false;\n    }\n\n    if (input.country) {\n      if (!metadata.hasCountry(input.country)) {\n        throw new Error(\"Unknown country: \".concat(input.country));\n      }\n\n      metadata.country(input.country);\n    } else {\n      if (!input.countryCallingCode) {\n        throw new Error('Invalid phone number object passed');\n      }\n\n      metadata.selectNumberingPlan(input.countryCallingCode);\n    }\n  } // Old metadata (< 1.0.18) had no \"possible length\" data.\n\n\n  if (metadata.possibleLengths()) {\n    return isPossibleNumber(input.phone || input.nationalNumber, metadata);\n  } else {\n    // There was a bug between `1.7.35` and `1.7.37` where \"possible_lengths\"\n    // were missing for \"non-geographical\" numbering plans.\n    // Just assume the number is possible in such cases:\n    // it's unlikely that anyone generated their custom metadata\n    // in that short period of time (one day).\n    // This code can be removed in some future major version update.\n    if (input.countryCallingCode && metadata.isNonGeographicCallingCode(input.countryCallingCode)) {\n      // \"Non-geographic entities\" did't have `possibleLengths`\n      // due to a bug in metadata generation process.\n      return true;\n    } else {\n      throw new Error('Missing \"possibleLengths\" in metadata. Perhaps the metadata has been generated before v1.0.18.');\n    }\n  }\n}\nexport function isPossibleNumber(nationalNumber, metadata) {\n  //, isInternational) {\n  switch (checkNumberLength(nationalNumber, metadata)) {\n    case 'IS_POSSIBLE':\n      return true;\n    // This library ignores \"local-only\" phone numbers (for simplicity).\n    // See the readme for more info on what are \"local-only\" phone numbers.\n    // case 'IS_POSSIBLE_LOCAL_ONLY':\n    // \treturn !isInternational\n\n    default:\n      return false;\n  }\n}","import Metadata from '../metadata.js';\n/**\r\n * Returns a list of countries that the phone number could potentially belong to.\r\n * @param  {string} callingCode — Calling code.\r\n * @param  {string} nationalNumber — National (significant) number.\r\n * @param  {object} metadata — Metadata.\r\n * @return {string[]} A list of possible countries.\r\n */\n\nexport default function getPossibleCountriesForNumber(callingCode, nationalNumber, metadata) {\n  var _metadata = new Metadata(metadata);\n\n  var possibleCountries = _metadata.getCountryCodesForCallingCode(callingCode);\n\n  if (!possibleCountries) {\n    return [];\n  }\n\n  return possibleCountries.filter(function (country) {\n    return couldNationalNumberBelongToCountry(nationalNumber, country, metadata);\n  });\n}\n\nfunction couldNationalNumberBelongToCountry(nationalNumber, country, metadata) {\n  var _metadata = new Metadata(metadata);\n\n  _metadata.selectNumberingPlan(country);\n\n  if (_metadata.numberingPlan.possibleLengths().indexOf(nationalNumber.length) >= 0) {\n    return true;\n  }\n\n  return false;\n}","import applyInternationalSeparatorStyle from './applyInternationalSeparatorStyle.js'; // This was originally set to $1 but there are some countries for which the\n// first group is not used in the national pattern (e.g. Argentina) so the $1\n// group does not match correctly. Therefore, we use `\\d`, so that the first\n// group actually used in the pattern will be matched.\n\nexport var FIRST_GROUP_PATTERN = /(\\$\\d)/;\nexport default function formatNationalNumberUsingFormat(number, format, _ref) {\n  var useInternationalFormat = _ref.useInternationalFormat,\n      withNationalPrefix = _ref.withNationalPrefix,\n      carrierCode = _ref.carrierCode,\n      metadata = _ref.metadata;\n  var formattedNumber = number.replace(new RegExp(format.pattern()), useInternationalFormat ? format.internationalFormat() : // This library doesn't use `domestic_carrier_code_formatting_rule`,\n  // because that one is only used when formatting phone numbers\n  // for dialing from a mobile phone, and this is not a dialing library.\n  // carrierCode && format.domesticCarrierCodeFormattingRule()\n  // \t// First, replace the $CC in the formatting rule with the desired carrier code.\n  // \t// Then, replace the $FG in the formatting rule with the first group\n  // \t// and the carrier code combined in the appropriate way.\n  // \t? format.format().replace(FIRST_GROUP_PATTERN, format.domesticCarrierCodeFormattingRule().replace('$CC', carrierCode))\n  // \t: (\n  // \t\twithNationalPrefix && format.nationalPrefixFormattingRule()\n  // \t\t\t? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())\n  // \t\t\t: format.format()\n  // \t)\n  withNationalPrefix && format.nationalPrefixFormattingRule() ? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule()) : format.format());\n\n  if (useInternationalFormat) {\n    return applyInternationalSeparatorStyle(formattedNumber);\n  }\n\n  return formattedNumber;\n}","import { VALID_PUNCTUATION } from '../constants.js'; // Removes brackets and replaces dashes with spaces.\n//\n// E.g. \"(999) 111-22-33\" -> \"999 111 22 33\"\n//\n// For some reason Google's metadata contains `<intlFormat/>`s with brackets and dashes.\n// Meanwhile, there's no single opinion about using punctuation in international phone numbers.\n//\n// For example, Google's `<intlFormat/>` for USA is `+1 213-373-4253`.\n// And here's a quote from WikiPedia's \"North American Numbering Plan\" page:\n// https://en.wikipedia.org/wiki/North_American_Numbering_Plan\n//\n// \"The country calling code for all countries participating in the NANP is 1.\n// In international format, an NANP number should be listed as +1 301 555 01 00,\n// where 301 is an area code (Maryland).\"\n//\n// I personally prefer the international format without any punctuation.\n// For example, brackets are remnants of the old age, meaning that the\n// phone number part in brackets (so called \"area code\") can be omitted\n// if dialing within the same \"area\".\n// And hyphens were clearly introduced for splitting local numbers into memorizable groups.\n// For example, remembering \"5553535\" is difficult but \"555-35-35\" is much simpler.\n// Imagine a man taking a bus from home to work and seeing an ad with a phone number.\n// He has a couple of seconds to memorize that number until it passes by.\n// If it were spaces instead of hyphens the man wouldn't necessarily get it,\n// but with hyphens instead of spaces the grouping is more explicit.\n// I personally think that hyphens introduce visual clutter,\n// so I prefer replacing them with spaces in international numbers.\n// In the modern age all output is done on displays where spaces are clearly distinguishable\n// so hyphens can be safely replaced with spaces without losing any legibility.\n//\n\nexport default function applyInternationalSeparatorStyle(formattedNumber) {\n  return formattedNumber.replace(new RegExp(\"[\".concat(VALID_PUNCTUATION, \"]+\"), 'g'), ' ').trim();\n}","import Metadata from '../metadata.js';\n/**\r\n * Pattern that makes it easy to distinguish whether a region has a single\r\n * international dialing prefix or not. If a region has a single international\r\n * prefix (e.g. 011 in USA), it will be represented as a string that contains\r\n * a sequence of ASCII digits, and possibly a tilde, which signals waiting for\r\n * the tone. If there are multiple available international prefixes in a\r\n * region, they will be represented as a regex string that always contains one\r\n * or more characters that are not ASCII digits or a tilde.\r\n */\n\nvar SINGLE_IDD_PREFIX_REG_EXP = /^[\\d]+(?:[~\\u2053\\u223C\\uFF5E][\\d]+)?$/; // For regions that have multiple IDD prefixes\n// a preferred IDD prefix is returned.\n\nexport default function getIddPrefix(country, callingCode, metadata) {\n  var countryMetadata = new Metadata(metadata);\n  countryMetadata.selectNumberingPlan(country, callingCode);\n\n  if (countryMetadata.defaultIDDPrefix()) {\n    return countryMetadata.defaultIDDPrefix();\n  }\n\n  if (SINGLE_IDD_PREFIX_REG_EXP.test(countryMetadata.IDDPrefix())) {\n    return countryMetadata.IDDPrefix();\n  }\n}","function _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n\n  return target;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n} // This is a port of Google Android `libphonenumber`'s\n// `phonenumberutil.js` of December 31th, 2018.\n//\n// https://github.com/googlei18n/libphonenumber/commits/master/javascript/i18n/phonenumbers/phonenumberutil.js\n\n\nimport matchesEntirely from './helpers/matchesEntirely.js';\nimport formatNationalNumberUsingFormat from './helpers/formatNationalNumberUsingFormat.js';\nimport Metadata, { getCountryCallingCode } from './metadata.js';\nimport getIddPrefix from './helpers/getIddPrefix.js';\nimport { formatRFC3966 } from './helpers/RFC3966.js';\nvar DEFAULT_OPTIONS = {\n  formatExtension: function formatExtension(formattedNumber, extension, metadata) {\n    return \"\".concat(formattedNumber).concat(metadata.ext()).concat(extension);\n  }\n};\n/**\r\n * Formats a phone number.\r\n *\r\n * format(phoneNumberInstance, 'INTERNATIONAL', { ..., v2: true }, metadata)\r\n * format(phoneNumberInstance, 'NATIONAL', { ..., v2: true }, metadata)\r\n *\r\n * format({ phone: '8005553535', country: 'RU' }, 'INTERNATIONAL', { ... }, metadata)\r\n * format({ phone: '8005553535', country: 'RU' }, 'NATIONAL', undefined, metadata)\r\n *\r\n * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.\r\n * @param  {string} format\r\n * @param  {object} [options]\r\n * @param  {object} metadata\r\n * @return {string}\r\n */\n\nexport default function formatNumber(input, format, options, metadata) {\n  // Apply default options.\n  if (options) {\n    options = _objectSpread(_objectSpread({}, DEFAULT_OPTIONS), options);\n  } else {\n    options = DEFAULT_OPTIONS;\n  }\n\n  metadata = new Metadata(metadata);\n\n  if (input.country && input.country !== '001') {\n    // Validate `input.country`.\n    if (!metadata.hasCountry(input.country)) {\n      throw new Error(\"Unknown country: \".concat(input.country));\n    }\n\n    metadata.country(input.country);\n  } else if (input.countryCallingCode) {\n    metadata.selectNumberingPlan(input.countryCallingCode);\n  } else return input.phone || '';\n\n  var countryCallingCode = metadata.countryCallingCode();\n  var nationalNumber = options.v2 ? input.nationalNumber : input.phone; // This variable should have been declared inside `case`s\n  // but Babel has a bug and it says \"duplicate variable declaration\".\n\n  var number;\n\n  switch (format) {\n    case 'NATIONAL':\n      // Legacy argument support.\n      // (`{ country: ..., phone: '' }`)\n      if (!nationalNumber) {\n        return '';\n      }\n\n      number = formatNationalNumber(nationalNumber, input.carrierCode, 'NATIONAL', metadata, options);\n      return addExtension(number, input.ext, metadata, options.formatExtension);\n\n    case 'INTERNATIONAL':\n      // Legacy argument support.\n      // (`{ country: ..., phone: '' }`)\n      if (!nationalNumber) {\n        return \"+\".concat(countryCallingCode);\n      }\n\n      number = formatNationalNumber(nationalNumber, null, 'INTERNATIONAL', metadata, options);\n      number = \"+\".concat(countryCallingCode, \" \").concat(number);\n      return addExtension(number, input.ext, metadata, options.formatExtension);\n\n    case 'E.164':\n      // `E.164` doesn't define \"phone number extensions\".\n      return \"+\".concat(countryCallingCode).concat(nationalNumber);\n\n    case 'RFC3966':\n      return formatRFC3966({\n        number: \"+\".concat(countryCallingCode).concat(nationalNumber),\n        ext: input.ext\n      });\n    // For reference, here's Google's IDD formatter:\n    // https://github.com/google/libphonenumber/blob/32719cf74e68796788d1ca45abc85dcdc63ba5b9/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L1546\n    // Not saying that this IDD formatter replicates it 1:1, but it seems to work.\n    // Who would even need to format phone numbers in IDD format anyway?\n\n    case 'IDD':\n      if (!options.fromCountry) {\n        return; // throw new Error('`fromCountry` option not passed for IDD-prefixed formatting.')\n      }\n\n      var formattedNumber = formatIDD(nationalNumber, input.carrierCode, countryCallingCode, options.fromCountry, metadata);\n      return addExtension(formattedNumber, input.ext, metadata, options.formatExtension);\n\n    default:\n      throw new Error(\"Unknown \\\"format\\\" argument passed to \\\"formatNumber()\\\": \\\"\".concat(format, \"\\\"\"));\n  }\n}\n\nfunction formatNationalNumber(number, carrierCode, formatAs, metadata, options) {\n  var format = chooseFormatForNumber(metadata.formats(), number);\n\n  if (!format) {\n    return number;\n  }\n\n  return formatNationalNumberUsingFormat(number, format, {\n    useInternationalFormat: formatAs === 'INTERNATIONAL',\n    withNationalPrefix: format.nationalPrefixIsOptionalWhenFormattingInNationalFormat() && options && options.nationalPrefix === false ? false : true,\n    carrierCode: carrierCode,\n    metadata: metadata\n  });\n}\n\nexport function chooseFormatForNumber(availableFormats, nationalNnumber) {\n  for (var _iterator = _createForOfIteratorHelperLoose(availableFormats), _step; !(_step = _iterator()).done;) {\n    var format = _step.value; // Validate leading digits.\n    // The test case for \"else path\" could be found by searching for\n    // \"format.leadingDigitsPatterns().length === 0\".\n\n    if (format.leadingDigitsPatterns().length > 0) {\n      // The last leading_digits_pattern is used here, as it is the most detailed\n      var lastLeadingDigitsPattern = format.leadingDigitsPatterns()[format.leadingDigitsPatterns().length - 1]; // If leading digits don't match then move on to the next phone number format\n\n      if (nationalNnumber.search(lastLeadingDigitsPattern) !== 0) {\n        continue;\n      }\n    } // Check that the national number matches the phone number format regular expression\n\n\n    if (matchesEntirely(nationalNnumber, format.pattern())) {\n      return format;\n    }\n  }\n}\n\nfunction addExtension(formattedNumber, ext, metadata, formatExtension) {\n  return ext ? formatExtension(formattedNumber, ext, metadata) : formattedNumber;\n}\n\nfunction formatIDD(nationalNumber, carrierCode, countryCallingCode, fromCountry, metadata) {\n  var fromCountryCallingCode = getCountryCallingCode(fromCountry, metadata.metadata); // When calling within the same country calling code.\n\n  if (fromCountryCallingCode === countryCallingCode) {\n    var formattedNumber = formatNationalNumber(nationalNumber, carrierCode, 'NATIONAL', metadata); // For NANPA regions, return the national format for these regions\n    // but prefix it with the country calling code.\n\n    if (countryCallingCode === '1') {\n      return countryCallingCode + ' ' + formattedNumber;\n    } // If regions share a country calling code, the country calling code need\n    // not be dialled. This also applies when dialling within a region, so this\n    // if clause covers both these cases. Technically this is the case for\n    // dialling from La Reunion to other overseas departments of France (French\n    // Guiana, Martinique, Guadeloupe), but not vice versa - so we don't cover\n    // this edge case for now and for those cases return the version including\n    // country calling code. Details here:\n    // http://www.petitfute.com/voyage/225-info-pratiques-reunion\n    //\n\n\n    return formattedNumber;\n  }\n\n  var iddPrefix = getIddPrefix(fromCountry, undefined, metadata.metadata);\n\n  if (iddPrefix) {\n    return \"\".concat(iddPrefix, \" \").concat(countryCallingCode, \" \").concat(formatNationalNumber(nationalNumber, null, 'INTERNATIONAL', metadata));\n  }\n}","function _slicedToArray(arr, i) {\n  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();\n}\n\nfunction _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n\n  var _s, _e;\n\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nfunction _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nimport isViablePhoneNumber from './isViablePhoneNumber.js'; // https://www.ietf.org/rfc/rfc3966.txt\n\n/**\r\n * @param  {string} text - Phone URI (RFC 3966).\r\n * @return {object} `{ ?number, ?ext }`.\r\n */\n\nexport function parseRFC3966(text) {\n  var number;\n  var ext; // Replace \"tel:\" with \"tel=\" for parsing convenience.\n\n  text = text.replace(/^tel:/, 'tel=');\n\n  for (var _iterator = _createForOfIteratorHelperLoose(text.split(';')), _step; !(_step = _iterator()).done;) {\n    var part = _step.value;\n\n    var _part$split = part.split('='),\n        _part$split2 = _slicedToArray(_part$split, 2),\n        name = _part$split2[0],\n        value = _part$split2[1];\n\n    switch (name) {\n      case 'tel':\n        number = value;\n        break;\n\n      case 'ext':\n        ext = value;\n        break;\n\n      case 'phone-context':\n        // Only \"country contexts\" are supported.\n        // \"Domain contexts\" are ignored.\n        if (value[0] === '+') {\n          number = value + number;\n        }\n\n        break;\n    }\n  } // If the phone number is not viable, then abort.\n\n\n  if (!isViablePhoneNumber(number)) {\n    return {};\n  }\n\n  var result = {\n    number: number\n  };\n\n  if (ext) {\n    result.ext = ext;\n  }\n\n  return result;\n}\n/**\r\n * @param  {object} - `{ ?number, ?extension }`.\r\n * @return {string} Phone URI (RFC 3966).\r\n */\n\nexport function formatRFC3966(_ref) {\n  var number = _ref.number,\n      ext = _ref.ext;\n\n  if (!number) {\n    return '';\n  }\n\n  if (number[0] !== '+') {\n    throw new Error(\"\\\"formatRFC3966()\\\" expects \\\"number\\\" to be in E.164 format.\");\n  }\n\n  return \"tel:\".concat(number).concat(ext ? ';ext=' + ext : '');\n}","function ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n\n  return target;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\n\nimport Metadata from './metadata.js';\nimport isPossibleNumber from './isPossible.js';\nimport isValidNumber from './isValid.js'; // import checkNumberLength from './helpers/checkNumberLength.js'\n\nimport getNumberType from './helpers/getNumberType.js';\nimport getPossibleCountriesForNumber from './helpers/getPossibleCountriesForNumber.js';\nimport formatNumber from './format.js';\nvar USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;\n\nvar PhoneNumber = /*#__PURE__*/function () {\n  /**\r\n   * @param  {string} countryOrCountryCallingCode\r\n   * @param  {string} nationalNumber\r\n   * @param  {object} metadata — Metadata JSON\r\n   * @return {PhoneNumber}\r\n   */\n  function PhoneNumber(countryOrCountryCallingCode, nationalNumber, metadata) {\n    _classCallCheck(this, PhoneNumber);\n\n    if (!countryOrCountryCallingCode) {\n      throw new TypeError('`country` or `countryCallingCode` not passed');\n    }\n\n    if (!nationalNumber) {\n      throw new TypeError('`nationalNumber` not passed');\n    }\n\n    if (!metadata) {\n      throw new TypeError('`metadata` not passed');\n    }\n\n    var _getCountryAndCountry = getCountryAndCountryCallingCode(countryOrCountryCallingCode, metadata),\n        country = _getCountryAndCountry.country,\n        countryCallingCode = _getCountryAndCountry.countryCallingCode;\n\n    this.country = country;\n    this.countryCallingCode = countryCallingCode;\n    this.nationalNumber = nationalNumber;\n    this.number = '+' + this.countryCallingCode + this.nationalNumber; // Exclude `metadata` property output from `PhoneNumber.toString()`\n    // so that it doesn't clutter the console output of Node.js.\n    // Previously, when Node.js did `console.log(new PhoneNumber(...))`,\n    // it would output the whole internal structure of the `metadata` object.\n\n    this.getMetadata = function () {\n      return metadata;\n    };\n  }\n\n  _createClass(PhoneNumber, [{\n    key: \"setExt\",\n    value: function setExt(ext) {\n      this.ext = ext;\n    }\n  }, {\n    key: \"getPossibleCountries\",\n    value: function getPossibleCountries() {\n      if (this.country) {\n        return [this.country];\n      }\n\n      return getPossibleCountriesForNumber(this.countryCallingCode, this.nationalNumber, this.getMetadata());\n    }\n  }, {\n    key: \"isPossible\",\n    value: function isPossible() {\n      return isPossibleNumber(this, {\n        v2: true\n      }, this.getMetadata());\n    }\n  }, {\n    key: \"isValid\",\n    value: function isValid() {\n      return isValidNumber(this, {\n        v2: true\n      }, this.getMetadata());\n    }\n  }, {\n    key: \"isNonGeographic\",\n    value: function isNonGeographic() {\n      var metadata = new Metadata(this.getMetadata());\n      return metadata.isNonGeographicCallingCode(this.countryCallingCode);\n    }\n  }, {\n    key: \"isEqual\",\n    value: function isEqual(phoneNumber) {\n      return this.number === phoneNumber.number && this.ext === phoneNumber.ext;\n    } // This function was originally meant to be an equivalent for `validatePhoneNumberLength()`,\n    // but later it was found out that it doesn't include the possible `TOO_SHORT` result\n    // returned from `parsePhoneNumberWithError()` in the original `validatePhoneNumberLength()`,\n    // so eventually I simply commented out this method from the `PhoneNumber` class\n    // and just left the `validatePhoneNumberLength()` function, even though that one would require\n    // and additional step to also validate the actual country / calling code of the phone number.\n    // validateLength() {\n    // \tconst metadata = new Metadata(this.getMetadata())\n    // \tmetadata.selectNumberingPlan(this.countryCallingCode)\n    // \tconst result = checkNumberLength(this.nationalNumber, metadata)\n    // \tif (result !== 'IS_POSSIBLE') {\n    // \t\treturn result\n    // \t}\n    // }\n\n  }, {\n    key: \"getType\",\n    value: function getType() {\n      return getNumberType(this, {\n        v2: true\n      }, this.getMetadata());\n    }\n  }, {\n    key: \"format\",\n    value: function format(_format, options) {\n      return formatNumber(this, _format, options ? _objectSpread(_objectSpread({}, options), {}, {\n        v2: true\n      }) : {\n        v2: true\n      }, this.getMetadata());\n    }\n  }, {\n    key: \"formatNational\",\n    value: function formatNational(options) {\n      return this.format('NATIONAL', options);\n    }\n  }, {\n    key: \"formatInternational\",\n    value: function formatInternational(options) {\n      return this.format('INTERNATIONAL', options);\n    }\n  }, {\n    key: \"getURI\",\n    value: function getURI(options) {\n      return this.format('RFC3966', options);\n    }\n  }]);\n\n  return PhoneNumber;\n}();\n\nexport { PhoneNumber as default };\n\nvar isCountryCode = function isCountryCode(value) {\n  return /^[A-Z]{2}$/.test(value);\n};\n\nfunction getCountryAndCountryCallingCode(countryOrCountryCallingCode, metadataJson) {\n  var country;\n  var countryCallingCode;\n  var metadata = new Metadata(metadataJson); // If country code is passed then derive `countryCallingCode` from it.\n  // Also store the country code as `.country`.\n\n  if (isCountryCode(countryOrCountryCallingCode)) {\n    country = countryOrCountryCallingCode;\n    metadata.selectNumberingPlan(country);\n    countryCallingCode = metadata.countryCallingCode();\n  } else {\n    countryCallingCode = countryOrCountryCallingCode;\n    /* istanbul ignore if */\n\n    if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n      if (metadata.isNonGeographicCallingCode(countryCallingCode)) {\n        country = '001';\n      }\n    }\n  }\n\n  return {\n    country: country,\n    countryCallingCode: countryCallingCode\n  };\n}","import Metadata from '../metadata.js';\nimport { VALID_DIGITS } from '../constants.js';\nvar CAPTURING_DIGIT_PATTERN = new RegExp('([' + VALID_DIGITS + '])');\nexport default function stripIddPrefix(number, country, callingCode, metadata) {\n  if (!country) {\n    return;\n  } // Check if the number is IDD-prefixed.\n\n\n  var countryMetadata = new Metadata(metadata);\n  countryMetadata.selectNumberingPlan(country, callingCode);\n  var IDDPrefixPattern = new RegExp(countryMetadata.IDDPrefix());\n\n  if (number.search(IDDPrefixPattern) !== 0) {\n    return;\n  } // Strip IDD prefix.\n\n\n  number = number.slice(number.match(IDDPrefixPattern)[0].length); // If there're any digits after an IDD prefix,\n  // then those digits are a country calling code.\n  // Since no country code starts with a `0`,\n  // the code below validates that the next digit (if present) is not `0`.\n\n  var matchedGroups = number.match(CAPTURING_DIGIT_PATTERN);\n\n  if (matchedGroups && matchedGroups[1] != null && matchedGroups[1].length > 0) {\n    if (matchedGroups[1] === '0') {\n      return;\n    }\n  }\n\n  return number;\n}","import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport checkNumberLength from './checkNumberLength.js';\n/**\r\n * Strips national prefix and carrier code from a complete phone number.\r\n * The difference from the non-\"FromCompleteNumber\" function is that\r\n * it won't extract national prefix if the resultant number is too short\r\n * to be a complete number for the selected phone numbering plan.\r\n * @param  {string} number — Complete phone number digits.\r\n * @param  {Metadata} metadata — Metadata with a phone numbering plan selected.\r\n * @return {object} `{ nationalNumber: string, carrierCode: string? }`.\r\n */\n\nexport default function extractNationalNumber(number, metadata) {\n  // Parsing national prefixes and carrier codes\n  // is only required for local phone numbers\n  // but some people don't understand that\n  // and sometimes write international phone numbers\n  // with national prefixes (or maybe even carrier codes).\n  // http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html\n  // Google's original library forgives such mistakes\n  // and so does this library, because it has been requested:\n  // https://github.com/catamphetamine/libphonenumber-js/issues/127\n  var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(number, metadata),\n      carrierCode = _extractNationalNumbe.carrierCode,\n      nationalNumber = _extractNationalNumbe.nationalNumber;\n\n  if (nationalNumber !== number) {\n    if (!shouldHaveExtractedNationalPrefix(number, nationalNumber, metadata)) {\n      // Don't strip the national prefix.\n      return {\n        nationalNumber: number\n      };\n    } // Check the national (significant) number length after extracting national prefix and carrier code.\n    // Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature.\n\n\n    if (metadata.possibleLengths()) {\n      // The number remaining after stripping the national prefix and carrier code\n      // should be long enough to have a possible length for the country.\n      // Otherwise, don't strip the national prefix and carrier code,\n      // since the original number could be a valid number.\n      // This check has been copy-pasted \"as is\" from Google's original library:\n      // https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250\n      // It doesn't check for the \"possibility\" of the original `number`.\n      // I guess it's fine not checking that one. It works as is anyway.\n      if (!isPossibleIncompleteNationalNumber(nationalNumber, metadata)) {\n        // Don't strip the national prefix.\n        return {\n          nationalNumber: number\n        };\n      }\n    }\n  }\n\n  return {\n    nationalNumber: nationalNumber,\n    carrierCode: carrierCode\n  };\n} // In some countries, the same digit could be a national prefix\n// or a leading digit of a valid phone number.\n// For example, in Russia, national prefix is `8`,\n// and also `800 555 35 35` is a valid number\n// in which `8` is not a national prefix, but the first digit\n// of a national (significant) number.\n// Same's with Belarus:\n// `82004910060` is a valid national (significant) number,\n// but `2004910060` is not.\n// To support such cases (to prevent the code from always stripping\n// national prefix), a condition is imposed: a national prefix\n// is not extracted when the original number is \"viable\" and the\n// resultant number is not, a \"viable\" national number being the one\n// that matches `national_number_pattern`.\n\nfunction shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberAfter, metadata) {\n  // The equivalent in Google's code is:\n  // https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004\n  if (matchesEntirely(nationalNumberBefore, metadata.nationalNumberPattern()) && !matchesEntirely(nationalNumberAfter, metadata.nationalNumberPattern())) {\n    return false;\n  } // This \"is possible\" national number (length) check has been commented out\n  // because it's superceded by the (effectively) same check done in the\n  // `extractNationalNumber()` function after it calls `shouldHaveExtractedNationalPrefix()`.\n  // In other words, why run the same check twice if it could only be run once.\n  // // Check the national (significant) number length after extracting national prefix and carrier code.\n  // // Fixes a minor \"weird behavior\" bug: https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/57\n  // // (Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature).\n  // if (metadata.possibleLengths()) {\n  // \tif (isPossibleIncompleteNationalNumber(nationalNumberBefore, metadata) &&\n  // \t\t!isPossibleIncompleteNationalNumber(nationalNumberAfter, metadata)) {\n  // \t\treturn false\n  // \t}\n  // }\n\n\n  return true;\n}\n\nfunction isPossibleIncompleteNationalNumber(nationalNumber, metadata) {\n  switch (checkNumberLength(nationalNumber, metadata)) {\n    case 'TOO_SHORT':\n    case 'INVALID_LENGTH':\n      // This library ignores \"local-only\" phone numbers (for simplicity).\n      // See the readme for more info on what are \"local-only\" phone numbers.\n      // case 'IS_POSSIBLE_LOCAL_ONLY':\n      return false;\n\n    default:\n      return true;\n  }\n}","/**\r\n * Strips any national prefix (such as 0, 1) present in a\r\n * (possibly incomplete) number provided.\r\n * \"Carrier codes\" are only used  in Colombia and Brazil,\r\n * and only when dialing within those countries from a mobile phone to a fixed line number.\r\n * Sometimes it won't actually strip national prefix\r\n * and will instead prepend some digits to the `number`:\r\n * for example, when number `2345678` is passed with `VI` country selected,\r\n * it will return `{ number: \"3402345678\" }`, because `340` area code is prepended.\r\n * @param {string} number — National number digits.\r\n * @param {object} metadata — Metadata with country selected.\r\n * @return {object} `{ nationalNumber: string, nationalPrefix: string? carrierCode: string? }`. Even if a national prefix was extracted, it's not necessarily present in the returned object, so don't rely on its presence in the returned object in order to find out whether a national prefix has been extracted or not.\r\n */\nexport default function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {\n  if (number && metadata.numberingPlan.nationalPrefixForParsing()) {\n    // See METADATA.md for the description of\n    // `national_prefix_for_parsing` and `national_prefix_transform_rule`.\n    // Attempt to parse the first digits as a national prefix.\n    var prefixPattern = new RegExp('^(?:' + metadata.numberingPlan.nationalPrefixForParsing() + ')');\n    var prefixMatch = prefixPattern.exec(number);\n\n    if (prefixMatch) {\n      var nationalNumber;\n      var carrierCode; // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\n      // If a `national_prefix_for_parsing` has any \"capturing groups\"\n      // then it means that the national (significant) number is equal to\n      // those \"capturing groups\" transformed via `national_prefix_transform_rule`,\n      // and nothing could be said about the actual national prefix:\n      // what is it and was it even there.\n      // If a `national_prefix_for_parsing` doesn't have any \"capturing groups\",\n      // then everything it matches is a national prefix.\n      // To determine whether `national_prefix_for_parsing` matched any\n      // \"capturing groups\", the value of the result of calling `.exec()`\n      // is looked at, and if it has non-undefined values where there're\n      // \"capturing groups\" in the regular expression, then it means\n      // that \"capturing groups\" have been matched.\n      // It's not possible to tell whether there'll be any \"capturing gropus\"\n      // before the matching process, because a `national_prefix_for_parsing`\n      // could exhibit both behaviors.\n\n      var capturedGroupsCount = prefixMatch.length - 1;\n      var hasCapturedGroups = capturedGroupsCount > 0 && prefixMatch[capturedGroupsCount];\n\n      if (metadata.nationalPrefixTransformRule() && hasCapturedGroups) {\n        nationalNumber = number.replace(prefixPattern, metadata.nationalPrefixTransformRule()); // If there's more than one captured group,\n        // then carrier code is the second one.\n\n        if (capturedGroupsCount > 1) {\n          carrierCode = prefixMatch[1];\n        }\n      } // If there're no \"capturing groups\",\n      // or if there're \"capturing groups\" but no\n      // `national_prefix_transform_rule`,\n      // then just strip the national prefix from the number,\n      // and possibly a carrier code.\n      // Seems like there could be more.\n      else {\n        // `prefixBeforeNationalNumber` is the whole substring matched by\n        // the `national_prefix_for_parsing` regular expression.\n        // There seem to be no guarantees that it's just a national prefix.\n        // For example, if there's a carrier code, it's gonna be a\n        // part of `prefixBeforeNationalNumber` too.\n        var prefixBeforeNationalNumber = prefixMatch[0];\n        nationalNumber = number.slice(prefixBeforeNationalNumber.length); // If there's at least one captured group,\n        // then carrier code is the first one.\n\n        if (hasCapturedGroups) {\n          carrierCode = prefixMatch[1];\n        }\n      } // Tries to guess whether a national prefix was present in the input.\n      // This is not something copy-pasted from Google's library:\n      // they don't seem to have an equivalent for that.\n      // So this isn't an \"officially approved\" way of doing something like that.\n      // But since there seems no other existing method, this library uses it.\n\n\n      var nationalPrefix;\n\n      if (hasCapturedGroups) {\n        var possiblePositionOfTheFirstCapturedGroup = number.indexOf(prefixMatch[1]);\n        var possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup); // Example: an Argentinian (AR) phone number `0111523456789`.\n        // `prefixMatch[0]` is `01115`, and `$1` is `11`,\n        // and the rest of the phone number is `23456789`.\n        // The national number is transformed via `9$1` to `91123456789`.\n        // National prefix `0` is detected being present at the start.\n        // if (possibleNationalPrefix.indexOf(metadata.numberingPlan.nationalPrefix()) === 0) {\n\n        if (possibleNationalPrefix === metadata.numberingPlan.nationalPrefix()) {\n          nationalPrefix = metadata.numberingPlan.nationalPrefix();\n        }\n      } else {\n        nationalPrefix = prefixMatch[0];\n      }\n\n      return {\n        nationalNumber: nationalNumber,\n        nationalPrefix: nationalPrefix,\n        carrierCode: carrierCode\n      };\n    }\n  }\n\n  return {\n    nationalNumber: number\n  };\n}","import stripIddPrefix from './stripIddPrefix.js';\nimport extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js';\nimport Metadata from '../metadata.js';\nimport { MAX_LENGTH_COUNTRY_CODE } from '../constants.js';\n/**\r\n * Converts a phone number digits (possibly with a `+`)\r\n * into a calling code and the rest phone number digits.\r\n * The \"rest phone number digits\" could include\r\n * a national prefix, carrier code, and national\r\n * (significant) number.\r\n * @param  {string} number — Phone number digits (possibly with a `+`).\r\n * @param  {string} [country] — Default country.\r\n * @param  {string} [callingCode] — Default calling code (some phone numbering plans are non-geographic).\r\n * @param  {object} metadata\r\n * @return {object} `{ countryCallingCodeSource: string?, countryCallingCode: string?, number: string }`\r\n * @example\r\n * // Returns `{ countryCallingCode: \"1\", number: \"2133734253\" }`.\r\n * extractCountryCallingCode('2133734253', 'US', null, metadata)\r\n * extractCountryCallingCode('2133734253', null, '1', metadata)\r\n * extractCountryCallingCode('+12133734253', null, null, metadata)\r\n * extractCountryCallingCode('+12133734253', 'RU', null, metadata)\r\n */\n\nexport default function extractCountryCallingCode(number, country, callingCode, metadata) {\n  if (!number) {\n    return {};\n  }\n\n  var isNumberWithIddPrefix; // If this is not an international phone number,\n  // then either extract an \"IDD\" prefix, or extract a\n  // country calling code from a number by autocorrecting it\n  // by prepending a leading `+` in cases when it starts\n  // with the country calling code.\n  // https://wikitravel.org/en/International_dialling_prefix\n  // https://github.com/catamphetamine/libphonenumber-js/issues/376\n\n  if (number[0] !== '+') {\n    // Convert an \"out-of-country\" dialing phone number\n    // to a proper international phone number.\n    var numberWithoutIDD = stripIddPrefix(number, country, callingCode, metadata); // If an IDD prefix was stripped then\n    // convert the number to international one\n    // for subsequent parsing.\n\n    if (numberWithoutIDD && numberWithoutIDD !== number) {\n      isNumberWithIddPrefix = true;\n      number = '+' + numberWithoutIDD;\n    } else {\n      // Check to see if the number starts with the country calling code\n      // for the default country. If so, we remove the country calling code,\n      // and do some checks on the validity of the number before and after.\n      // https://github.com/catamphetamine/libphonenumber-js/issues/376\n      if (country || callingCode) {\n        var _extractCountryCallin = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, callingCode, metadata),\n            countryCallingCode = _extractCountryCallin.countryCallingCode,\n            shorterNumber = _extractCountryCallin.number;\n\n        if (countryCallingCode) {\n          return {\n            countryCallingCodeSource: 'FROM_NUMBER_WITHOUT_PLUS_SIGN',\n            countryCallingCode: countryCallingCode,\n            number: shorterNumber\n          };\n        }\n      }\n\n      return {\n        // No need to set it to `UNSPECIFIED`. It can be just `undefined`.\n        // countryCallingCodeSource: 'UNSPECIFIED',\n        number: number\n      };\n    }\n  } // Fast abortion: country codes do not begin with a '0'\n\n\n  if (number[1] === '0') {\n    return {};\n  }\n\n  metadata = new Metadata(metadata); // The thing with country phone codes\n  // is that they are orthogonal to each other\n  // i.e. there's no such country phone code A\n  // for which country phone code B exists\n  // where B starts with A.\n  // Therefore, while scanning digits,\n  // if a valid country code is found,\n  // that means that it is the country code.\n  //\n\n  var i = 2;\n\n  while (i - 1 <= MAX_LENGTH_COUNTRY_CODE && i <= number.length) {\n    var _countryCallingCode = number.slice(1, i);\n\n    if (metadata.hasCallingCode(_countryCallingCode)) {\n      metadata.selectNumberingPlan(_countryCallingCode);\n      return {\n        countryCallingCodeSource: isNumberWithIddPrefix ? 'FROM_NUMBER_WITH_IDD' : 'FROM_NUMBER_WITH_PLUS_SIGN',\n        countryCallingCode: _countryCallingCode,\n        number: number.slice(i)\n      };\n    }\n\n    i++;\n  }\n\n  return {};\n} // The possible values for the returned `countryCallingCodeSource` are:\n//\n// Copy-pasted from:\n// https://github.com/google/libphonenumber/blob/master/resources/phonenumber.proto\n//\n// // The source from which the country_code is derived. This is not set in the\n// // general parsing method, but in the method that parses and keeps raw_input.\n// // New fields could be added upon request.\n// enum CountryCodeSource {\n//  // Default value returned if this is not set, because the phone number was\n//  // created using parse, not parseAndKeepRawInput. hasCountryCodeSource will\n//  // return false if this is the case.\n//  UNSPECIFIED = 0;\n//\n//  // The country_code is derived based on a phone number with a leading \"+\",\n//  // e.g. the French number \"+33 1 42 68 53 00\".\n//  FROM_NUMBER_WITH_PLUS_SIGN = 1;\n//\n//  // The country_code is derived based on a phone number with a leading IDD,\n//  // e.g. the French number \"011 33 1 42 68 53 00\", as it is dialled from US.\n//  FROM_NUMBER_WITH_IDD = 5;\n//\n//  // The country_code is derived based on a phone number without a leading\n//  // \"+\", e.g. the French number \"33 1 42 68 53 00\" when defaultCountry is\n//  // supplied as France.\n//  FROM_NUMBER_WITHOUT_PLUS_SIGN = 10;\n//\n//  // The country_code is derived NOT based on the phone number itself, but\n//  // from the defaultCountry parameter provided in the parsing function by the\n//  // clients. This happens mostly for numbers written in the national format\n//  // (without country code). For example, this would be set when parsing the\n//  // French number \"01 42 68 53 00\", when defaultCountry is supplied as\n//  // France.\n//  FROM_DEFAULT_COUNTRY = 20;\n// }","import Metadata from '../metadata.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport extractNationalNumber from './extractNationalNumber.js';\nimport checkNumberLength from './checkNumberLength.js';\nimport getCountryCallingCode from '../getCountryCallingCode.js';\n/**\r\n * Sometimes some people incorrectly input international phone numbers\r\n * without the leading `+`. This function corrects such input.\r\n * @param  {string} number — Phone number digits.\r\n * @param  {string?} country\r\n * @param  {string?} callingCode\r\n * @param  {object} metadata\r\n * @return {object} `{ countryCallingCode: string?, number: string }`.\r\n */\n\nexport default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, callingCode, metadata) {\n  var countryCallingCode = country ? getCountryCallingCode(country, metadata) : callingCode;\n\n  if (number.indexOf(countryCallingCode) === 0) {\n    metadata = new Metadata(metadata);\n    metadata.selectNumberingPlan(country, callingCode);\n    var possibleShorterNumber = number.slice(countryCallingCode.length);\n\n    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, metadata),\n        possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;\n\n    var _extractNationalNumbe2 = extractNationalNumber(number, metadata),\n        nationalNumber = _extractNationalNumbe2.nationalNumber; // If the number was not valid before but is valid now,\n    // or if it was too long before, we consider the number\n    // with the country calling code stripped to be a better result\n    // and keep that instead.\n    // For example, in Germany (+49), `49` is a valid area code,\n    // so if a number starts with `49`, it could be both a valid\n    // national German number or an international number without\n    // a leading `+`.\n\n\n    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, metadata) === 'TOO_LONG') {\n      return {\n        countryCallingCode: countryCallingCode,\n        number: possibleShorterNumber\n      };\n    }\n  }\n\n  return {\n    number: number\n  };\n}","function _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nimport Metadata from '../metadata.js';\nimport getNumberType from './getNumberType.js';\nexport default function getCountryByNationalNumber(nationalPhoneNumber, _ref) {\n  var countries = _ref.countries,\n      defaultCountry = _ref.defaultCountry,\n      metadata = _ref.metadata; // Re-create `metadata` because it will be selecting a `country`.\n\n  metadata = new Metadata(metadata);\n  var matchingCountries = [];\n\n  for (var _iterator = _createForOfIteratorHelperLoose(countries), _step; !(_step = _iterator()).done;) {\n    var country = _step.value;\n    metadata.country(country); // \"Leading digits\" patterns are only defined for about 20% of all countries.\n    // By definition, matching \"leading digits\" is a sufficient but not a necessary\n    // condition for a phone number to belong to a country.\n    // The point of \"leading digits\" check is that it's the fastest one to get a match.\n    // https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md#leading_digits\n    // I'd suppose that \"leading digits\" patterns are mutually exclusive for different countries\n    // because of the intended use of that feature.\n\n    if (metadata.leadingDigits()) {\n      if (nationalPhoneNumber && nationalPhoneNumber.search(metadata.leadingDigits()) === 0) {\n        return country;\n      }\n    } // Else perform full validation with all of those\n    // fixed-line/mobile/etc regular expressions.\n    else if (getNumberType({\n      phone: nationalPhoneNumber,\n      country: country\n    }, undefined, metadata.metadata)) {\n      // If the `defaultCountry` is among the `matchingCountries` then return it.\n      if (defaultCountry) {\n        if (country === defaultCountry) {\n          return country;\n        }\n\n        matchingCountries.push(country);\n      } else {\n        return country;\n      }\n    }\n  } // Return the first (\"main\") one of the `matchingCountries`.\n\n\n  if (matchingCountries.length > 0) {\n    return matchingCountries[0];\n  }\n}","import getCountryByNationalNumber from './getCountryByNationalNumber.js';\nvar USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;\nexport default function getCountryByCallingCode(callingCode, _ref) {\n  var nationalPhoneNumber = _ref.nationalNumber,\n      defaultCountry = _ref.defaultCountry,\n      metadata = _ref.metadata;\n  /* istanbul ignore if */\n\n  if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n    if (metadata.isNonGeographicCallingCode(callingCode)) {\n      return '001';\n    }\n  }\n\n  var possibleCountries = metadata.getCountryCodesForCallingCode(callingCode);\n\n  if (!possibleCountries) {\n    return;\n  } // If there's just one country corresponding to the country code,\n  // then just return it, without further phone number digits validation.\n\n\n  if (possibleCountries.length === 1) {\n    return possibleCountries[0];\n  }\n\n  return getCountryByNationalNumber(nationalPhoneNumber, {\n    countries: possibleCountries,\n    defaultCountry: defaultCountry,\n    metadata: metadata.metadata\n  });\n}","// When phone numbers are written in `RFC3966` format — `\"tel:+12133734253\"` —\n// they can have their \"calling code\" part written separately in a `phone-context` parameter.\n// Example: `\"tel:12133734253;phone-context=+1\"`.\n// This function parses the full phone number from the local number and the `phone-context`\n// when the `phone-context` contains a `+` sign.\nimport { VALID_DIGITS // PLUS_CHARS\n} from '../constants.js';\nexport var PLUS_SIGN = '+';\nvar RFC3966_VISUAL_SEPARATOR_ = '[\\\\-\\\\.\\\\(\\\\)]?';\nvar RFC3966_PHONE_DIGIT_ = '(' + '[' + VALID_DIGITS + ']' + '|' + RFC3966_VISUAL_SEPARATOR_ + ')';\nvar RFC3966_GLOBAL_NUMBER_DIGITS_ = '^' + '\\\\' + PLUS_SIGN + RFC3966_PHONE_DIGIT_ + '*' + '[' + VALID_DIGITS + ']' + RFC3966_PHONE_DIGIT_ + '*' + '$';\n/**\r\n * Regular expression of valid global-number-digits for the phone-context\r\n * parameter, following the syntax defined in RFC3966.\r\n */\n\nvar RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_ = new RegExp(RFC3966_GLOBAL_NUMBER_DIGITS_, 'g'); // In this port of Google's library, we don't accept alpha characters in phone numbers.\n// const ALPHANUM_ = VALID_ALPHA_ + VALID_DIGITS\n\nvar ALPHANUM_ = VALID_DIGITS;\nvar RFC3966_DOMAINLABEL_ = '[' + ALPHANUM_ + ']+((\\\\-)*[' + ALPHANUM_ + '])*';\nvar VALID_ALPHA_ = 'a-zA-Z';\nvar RFC3966_TOPLABEL_ = '[' + VALID_ALPHA_ + ']+((\\\\-)*[' + ALPHANUM_ + '])*';\nvar RFC3966_DOMAINNAME_ = '^(' + RFC3966_DOMAINLABEL_ + '\\\\.)*' + RFC3966_TOPLABEL_ + '\\\\.?$';\n/**\r\n * Regular expression of valid domainname for the phone-context parameter,\r\n * following the syntax defined in RFC3966.\r\n */\n\nvar RFC3966_DOMAINNAME_PATTERN_ = new RegExp(RFC3966_DOMAINNAME_, 'g');\nexport var RFC3966_PREFIX_ = 'tel:';\nexport var RFC3966_PHONE_CONTEXT_ = ';phone-context=';\nexport var RFC3966_ISDN_SUBADDRESS_ = ';isub=';\n/**\r\n * Extracts the value of the phone-context parameter of `numberToExtractFrom`,\r\n * following the syntax defined in RFC3966.\r\n *\r\n * @param {string} numberToExtractFrom\r\n * @return {string|null} the extracted string (possibly empty), or `null` if no phone-context parameter is found.\r\n */\n\nexport default function extractPhoneContext(numberToExtractFrom) {\n  var indexOfPhoneContext = numberToExtractFrom.indexOf(RFC3966_PHONE_CONTEXT_); // If no phone-context parameter is present\n\n  if (indexOfPhoneContext < 0) {\n    return null;\n  }\n\n  var phoneContextStart = indexOfPhoneContext + RFC3966_PHONE_CONTEXT_.length; // If phone-context parameter is empty\n\n  if (phoneContextStart >= numberToExtractFrom.length) {\n    return '';\n  }\n\n  var phoneContextEnd = numberToExtractFrom.indexOf(';', phoneContextStart); // If phone-context is not the last parameter\n\n  if (phoneContextEnd >= 0) {\n    return numberToExtractFrom.substring(phoneContextStart, phoneContextEnd);\n  } else {\n    return numberToExtractFrom.substring(phoneContextStart);\n  }\n}\n/**\r\n * Returns whether the value of phoneContext follows the syntax defined in RFC3966.\r\n *\r\n * @param {string|null} phoneContext\r\n * @return {boolean}\r\n */\n\nexport function isPhoneContextValid(phoneContext) {\n  if (phoneContext === null) {\n    return true;\n  }\n\n  if (phoneContext.length === 0) {\n    return false;\n  } // Does phone-context value match pattern of global-number-digits or domainname.\n\n\n  return RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_.test(phoneContext) || RFC3966_DOMAINNAME_PATTERN_.test(phoneContext);\n}","import extractPhoneContext, { isPhoneContextValid, PLUS_SIGN, RFC3966_PREFIX_, RFC3966_PHONE_CONTEXT_, RFC3966_ISDN_SUBADDRESS_ } from './extractPhoneContext.js';\nimport ParseError from '../ParseError.js';\n/**\r\n * @param  {string} numberToParse\r\n * @param  {string} nationalNumber\r\n * @return {}\r\n */\n\nexport default function extractFormattedPhoneNumberFromPossibleRfc3966NumberUri(numberToParse, _ref) {\n  var extractFormattedPhoneNumber = _ref.extractFormattedPhoneNumber;\n  var phoneContext = extractPhoneContext(numberToParse);\n\n  if (!isPhoneContextValid(phoneContext)) {\n    throw new ParseError('NOT_A_NUMBER');\n  }\n\n  var phoneNumberString;\n\n  if (phoneContext === null) {\n    // Extract a possible number from the string passed in.\n    // (this strips leading characters that could not be the start of a phone number)\n    phoneNumberString = extractFormattedPhoneNumber(numberToParse) || '';\n  } else {\n    phoneNumberString = ''; // If the phone context contains a phone number prefix, we need to capture\n    // it, whereas domains will be ignored.\n\n    if (phoneContext.charAt(0) === PLUS_SIGN) {\n      phoneNumberString += phoneContext;\n    } // Now append everything between the \"tel:\" prefix and the phone-context.\n    // This should include the national number, an optional extension or\n    // isdn-subaddress component. Note we also handle the case when \"tel:\" is\n    // missing, as we have seen in some of the phone number inputs.\n    // In that case, we append everything from the beginning.\n\n\n    var indexOfRfc3966Prefix = numberToParse.indexOf(RFC3966_PREFIX_);\n    var indexOfNationalNumber; // RFC 3966 \"tel:\" prefix is preset at this stage because\n    // `isPhoneContextValid()` requires it to be present.\n\n    /* istanbul ignore else */\n\n    if (indexOfRfc3966Prefix >= 0) {\n      indexOfNationalNumber = indexOfRfc3966Prefix + RFC3966_PREFIX_.length;\n    } else {\n      indexOfNationalNumber = 0;\n    }\n\n    var indexOfPhoneContext = numberToParse.indexOf(RFC3966_PHONE_CONTEXT_);\n    phoneNumberString += numberToParse.substring(indexOfNationalNumber, indexOfPhoneContext);\n  } // Delete the isdn-subaddress and everything after it if it is present.\n  // Note extension won't appear at the same time with isdn-subaddress\n  // according to paragraph 5.3 of the RFC3966 spec.\n\n\n  var indexOfIsdn = phoneNumberString.indexOf(RFC3966_ISDN_SUBADDRESS_);\n\n  if (indexOfIsdn > 0) {\n    phoneNumberString = phoneNumberString.substring(0, indexOfIsdn);\n  } // If both phone context and isdn-subaddress are absent but other\n  // parameters are present, the parameters are left in nationalNumber.\n  // This is because we are concerned about deleting content from a potential\n  // number string when there is no strong evidence that the number is\n  // actually written in RFC3966.\n\n\n  if (phoneNumberString !== '') {\n    return phoneNumberString;\n  }\n}","// This is a port of Google Android `libphonenumber`'s\n// `phonenumberutil.js` of December 31th, 2018.\n//\n// https://github.com/googlei18n/libphonenumber/commits/master/javascript/i18n/phonenumbers/phonenumberutil.js\nimport { VALID_DIGITS, PLUS_CHARS, MIN_LENGTH_FOR_NSN, MAX_LENGTH_FOR_NSN } from './constants.js';\nimport ParseError from './ParseError.js';\nimport Metadata from './metadata.js';\nimport isViablePhoneNumber, { isViablePhoneNumberStart } from './helpers/isViablePhoneNumber.js';\nimport extractExtension from './helpers/extension/extractExtension.js';\nimport parseIncompletePhoneNumber from './parseIncompletePhoneNumber.js';\nimport getCountryCallingCode from './getCountryCallingCode.js';\nimport { isPossibleNumber } from './isPossible.js'; // import { parseRFC3966 } from './helpers/RFC3966.js'\n\nimport PhoneNumber from './PhoneNumber.js';\nimport matchesEntirely from './helpers/matchesEntirely.js';\nimport extractCountryCallingCode from './helpers/extractCountryCallingCode.js';\nimport extractNationalNumber from './helpers/extractNationalNumber.js';\nimport stripIddPrefix from './helpers/stripIddPrefix.js';\nimport getCountryByCallingCode from './helpers/getCountryByCallingCode.js';\nimport extractFormattedPhoneNumberFromPossibleRfc3966NumberUri from './helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js'; // We don't allow input strings for parsing to be longer than 250 chars.\n// This prevents malicious input from consuming CPU.\n\nvar MAX_INPUT_STRING_LENGTH = 250; // This consists of the plus symbol, digits, and arabic-indic digits.\n\nvar PHONE_NUMBER_START_PATTERN = new RegExp('[' + PLUS_CHARS + VALID_DIGITS + ']'); // Regular expression of trailing characters that we want to remove.\n// A trailing `#` is sometimes used when writing phone numbers with extensions in US.\n// Example: \"+1 (645) 123 1234-910#\" number has extension \"910\".\n\nvar AFTER_PHONE_NUMBER_END_PATTERN = new RegExp('[^' + VALID_DIGITS + '#' + ']+$');\nvar USE_NON_GEOGRAPHIC_COUNTRY_CODE = false; // Examples:\n//\n// ```js\n// parse('8 (800) 555-35-35', 'RU')\n// parse('8 (800) 555-35-35', 'RU', metadata)\n// parse('8 (800) 555-35-35', { country: { default: 'RU' } })\n// parse('8 (800) 555-35-35', { country: { default: 'RU' } }, metadata)\n// parse('+7 800 555 35 35')\n// parse('+7 800 555 35 35', metadata)\n// ```\n//\n\n/**\r\n * Parses a phone number.\r\n *\r\n * parse('123456789', { defaultCountry: 'RU', v2: true }, metadata)\r\n * parse('123456789', { defaultCountry: 'RU' }, metadata)\r\n * parse('123456789', undefined, metadata)\r\n *\r\n * @param  {string} input\r\n * @param  {object} [options]\r\n * @param  {object} metadata\r\n * @return {object|PhoneNumber?} If `options.v2: true` flag is passed, it returns a `PhoneNumber?` instance. Otherwise, returns an object of shape `{ phone: '...', country: '...' }` (or just `{}` if no phone number was parsed).\r\n */\n\nexport default function parse(text, options, metadata) {\n  // If assigning the `{}` default value is moved to the arguments above,\n  // code coverage would decrease for some weird reason.\n  options = options || {};\n  metadata = new Metadata(metadata); // Validate `defaultCountry`.\n\n  if (options.defaultCountry && !metadata.hasCountry(options.defaultCountry)) {\n    if (options.v2) {\n      throw new ParseError('INVALID_COUNTRY');\n    }\n\n    throw new Error(\"Unknown country: \".concat(options.defaultCountry));\n  } // Parse the phone number.\n\n\n  var _parseInput = parseInput(text, options.v2, options.extract),\n      formattedPhoneNumber = _parseInput.number,\n      ext = _parseInput.ext,\n      error = _parseInput.error; // If the phone number is not viable then return nothing.\n\n\n  if (!formattedPhoneNumber) {\n    if (options.v2) {\n      if (error === 'TOO_SHORT') {\n        throw new ParseError('TOO_SHORT');\n      }\n\n      throw new ParseError('NOT_A_NUMBER');\n    }\n\n    return {};\n  }\n\n  var _parsePhoneNumber = parsePhoneNumber(formattedPhoneNumber, options.defaultCountry, options.defaultCallingCode, metadata),\n      country = _parsePhoneNumber.country,\n      nationalNumber = _parsePhoneNumber.nationalNumber,\n      countryCallingCode = _parsePhoneNumber.countryCallingCode,\n      countryCallingCodeSource = _parsePhoneNumber.countryCallingCodeSource,\n      carrierCode = _parsePhoneNumber.carrierCode;\n\n  if (!metadata.hasSelectedNumberingPlan()) {\n    if (options.v2) {\n      throw new ParseError('INVALID_COUNTRY');\n    }\n\n    return {};\n  } // Validate national (significant) number length.\n\n\n  if (!nationalNumber || nationalNumber.length < MIN_LENGTH_FOR_NSN) {\n    // Won't throw here because the regexp already demands length > 1.\n\n    /* istanbul ignore if */\n    if (options.v2) {\n      throw new ParseError('TOO_SHORT');\n    } // Google's demo just throws an error in this case.\n\n\n    return {};\n  } // Validate national (significant) number length.\n  //\n  // A sidenote:\n  //\n  // They say that sometimes national (significant) numbers\n  // can be longer than `MAX_LENGTH_FOR_NSN` (e.g. in Germany).\n  // https://github.com/googlei18n/libphonenumber/blob/7e1748645552da39c4e1ba731e47969d97bdb539/resources/phonenumber.proto#L36\n  // Such numbers will just be discarded.\n  //\n\n\n  if (nationalNumber.length > MAX_LENGTH_FOR_NSN) {\n    if (options.v2) {\n      throw new ParseError('TOO_LONG');\n    } // Google's demo just throws an error in this case.\n\n\n    return {};\n  }\n\n  if (options.v2) {\n    var phoneNumber = new PhoneNumber(countryCallingCode, nationalNumber, metadata.metadata);\n\n    if (country) {\n      phoneNumber.country = country;\n    }\n\n    if (carrierCode) {\n      phoneNumber.carrierCode = carrierCode;\n    }\n\n    if (ext) {\n      phoneNumber.ext = ext;\n    }\n\n    phoneNumber.__countryCallingCodeSource = countryCallingCodeSource;\n    return phoneNumber;\n  } // Check if national phone number pattern matches the number.\n  // National number pattern is different for each country,\n  // even for those ones which are part of the \"NANPA\" group.\n\n\n  var valid = (options.extended ? metadata.hasSelectedNumberingPlan() : country) ? matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) : false;\n\n  if (!options.extended) {\n    return valid ? result(country, nationalNumber, ext) : {};\n  } // isInternational: countryCallingCode !== undefined\n\n\n  return {\n    country: country,\n    countryCallingCode: countryCallingCode,\n    carrierCode: carrierCode,\n    valid: valid,\n    possible: valid ? true : options.extended === true && metadata.possibleLengths() && isPossibleNumber(nationalNumber, metadata) ? true : false,\n    phone: nationalNumber,\n    ext: ext\n  };\n}\n/**\r\n * Extracts a formatted phone number from text.\r\n * Doesn't guarantee that the extracted phone number\r\n * is a valid phone number (for example, doesn't validate its length).\r\n * @param  {string} text\r\n * @param  {boolean} [extract] — If `false`, then will parse the entire `text` as a phone number.\r\n * @param  {boolean} [throwOnError] — By default, it won't throw if the text is too long.\r\n * @return {string}\r\n * @example\r\n * // Returns \"(213) 373-4253\".\r\n * extractFormattedPhoneNumber(\"Call (213) 373-4253 for assistance.\")\r\n */\n\nfunction _extractFormattedPhoneNumber(text, extract, throwOnError) {\n  if (!text) {\n    return;\n  }\n\n  if (text.length > MAX_INPUT_STRING_LENGTH) {\n    if (throwOnError) {\n      throw new ParseError('TOO_LONG');\n    }\n\n    return;\n  }\n\n  if (extract === false) {\n    return text;\n  } // Attempt to extract a possible number from the string passed in\n\n\n  var startsAt = text.search(PHONE_NUMBER_START_PATTERN);\n\n  if (startsAt < 0) {\n    return;\n  }\n\n  return text // Trim everything to the left of the phone number\n  .slice(startsAt) // Remove trailing non-numerical characters\n  .replace(AFTER_PHONE_NUMBER_END_PATTERN, '');\n}\n/**\r\n * @param  {string} text - Input.\r\n * @param  {boolean} v2 - Legacy API functions don't pass `v2: true` flag.\r\n * @param  {boolean} [extract] - Whether to extract a phone number from `text`, or attempt to parse the entire text as a phone number.\r\n * @return {object} `{ ?number, ?ext }`.\r\n */\n\n\nfunction parseInput(text, v2, extract) {\n  // // Parse RFC 3966 phone number URI.\n  // if (text && text.indexOf('tel:') === 0) {\n  // \treturn parseRFC3966(text)\n  // }\n  // let number = extractFormattedPhoneNumber(text, extract, v2)\n  var number = extractFormattedPhoneNumberFromPossibleRfc3966NumberUri(text, {\n    extractFormattedPhoneNumber: function extractFormattedPhoneNumber(text) {\n      return _extractFormattedPhoneNumber(text, extract, v2);\n    }\n  }); // If the phone number is not viable, then abort.\n\n  if (!number) {\n    return {};\n  }\n\n  if (!isViablePhoneNumber(number)) {\n    if (isViablePhoneNumberStart(number)) {\n      return {\n        error: 'TOO_SHORT'\n      };\n    }\n\n    return {};\n  } // Attempt to parse extension first, since it doesn't require region-specific\n  // data and we want to have the non-normalised number here.\n\n\n  var withExtensionStripped = extractExtension(number);\n\n  if (withExtensionStripped.ext) {\n    return withExtensionStripped;\n  }\n\n  return {\n    number: number\n  };\n}\n/**\r\n * Creates `parse()` result object.\r\n */\n\n\nfunction result(country, nationalNumber, ext) {\n  var result = {\n    country: country,\n    phone: nationalNumber\n  };\n\n  if (ext) {\n    result.ext = ext;\n  }\n\n  return result;\n}\n/**\r\n * Parses a viable phone number.\r\n * @param {string} formattedPhoneNumber — Example: \"(213) 373-4253\".\r\n * @param {string} [defaultCountry]\r\n * @param {string} [defaultCallingCode]\r\n * @param {Metadata} metadata\r\n * @return {object} Returns `{ country: string?, countryCallingCode: string?, nationalNumber: string? }`.\r\n */\n\n\nfunction parsePhoneNumber(formattedPhoneNumber, defaultCountry, defaultCallingCode, metadata) {\n  // Extract calling code from phone number.\n  var _extractCountryCallin = extractCountryCallingCode(parseIncompletePhoneNumber(formattedPhoneNumber), defaultCountry, defaultCallingCode, metadata.metadata),\n      countryCallingCodeSource = _extractCountryCallin.countryCallingCodeSource,\n      countryCallingCode = _extractCountryCallin.countryCallingCode,\n      number = _extractCountryCallin.number; // Choose a country by `countryCallingCode`.\n\n\n  var country;\n\n  if (countryCallingCode) {\n    metadata.selectNumberingPlan(countryCallingCode);\n  } // If `formattedPhoneNumber` is passed in \"national\" format\n  // then `number` is defined and `countryCallingCode` is `undefined`.\n  else if (number && (defaultCountry || defaultCallingCode)) {\n    metadata.selectNumberingPlan(defaultCountry, defaultCallingCode);\n\n    if (defaultCountry) {\n      country = defaultCountry;\n    } else {\n      /* istanbul ignore if */\n      if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n        if (metadata.isNonGeographicCallingCode(defaultCallingCode)) {\n          country = '001';\n        }\n      }\n    }\n\n    countryCallingCode = defaultCallingCode || getCountryCallingCode(defaultCountry, metadata.metadata);\n  } else return {};\n\n  if (!number) {\n    return {\n      countryCallingCodeSource: countryCallingCodeSource,\n      countryCallingCode: countryCallingCode\n    };\n  }\n\n  var _extractNationalNumbe = extractNationalNumber(parseIncompletePhoneNumber(number), metadata),\n      nationalNumber = _extractNationalNumbe.nationalNumber,\n      carrierCode = _extractNationalNumbe.carrierCode; // Sometimes there are several countries\n  // corresponding to the same country phone code\n  // (e.g. NANPA countries all having `1` country phone code).\n  // Therefore, to reliably determine the exact country,\n  // national (significant) number should have been parsed first.\n  //\n  // When `metadata.json` is generated, all \"ambiguous\" country phone codes\n  // get their countries populated with the full set of\n  // \"phone number type\" regular expressions.\n  //\n\n\n  var exactCountry = getCountryByCallingCode(countryCallingCode, {\n    nationalNumber: nationalNumber,\n    defaultCountry: defaultCountry,\n    metadata: metadata\n  });\n\n  if (exactCountry) {\n    country = exactCountry;\n    /* istanbul ignore if */\n\n    if (exactCountry === '001') {// Can't happen with `USE_NON_GEOGRAPHIC_COUNTRY_CODE` being `false`.\n      // If `USE_NON_GEOGRAPHIC_COUNTRY_CODE` is set to `true` for some reason,\n      // then remove the \"istanbul ignore if\".\n    } else {\n      metadata.country(country);\n    }\n  }\n\n  return {\n    country: country,\n    countryCallingCode: countryCallingCode,\n    countryCallingCodeSource: countryCallingCodeSource,\n    nationalNumber: nationalNumber,\n    carrierCode: carrierCode\n  };\n}","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}\n\nfunction _slicedToArray(arr, i) {\n  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();\n}\n\nfunction _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nfunction _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n\n  var _s, _e;\n\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nfunction _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nimport isViablePhoneNumber from '../helpers/isViablePhoneNumber.js';\nimport _getNumberType from '../helpers/getNumberType.js';\nimport parse from '../parse.js'; // Finds out national phone number type (fixed line, mobile, etc)\n\nexport default function getNumberType() {\n  var _normalizeArguments = normalizeArguments(arguments),\n      input = _normalizeArguments.input,\n      options = _normalizeArguments.options,\n      metadata = _normalizeArguments.metadata; // `parseNumber()` would return `{}` when no phone number could be parsed from the input.\n\n\n  if (!input.phone) {\n    return;\n  }\n\n  return _getNumberType(input, options, metadata);\n} // Sort out arguments\n\nexport function normalizeArguments(args) {\n  var _Array$prototype$slic = Array.prototype.slice.call(args),\n      _Array$prototype$slic2 = _slicedToArray(_Array$prototype$slic, 4),\n      arg_1 = _Array$prototype$slic2[0],\n      arg_2 = _Array$prototype$slic2[1],\n      arg_3 = _Array$prototype$slic2[2],\n      arg_4 = _Array$prototype$slic2[3];\n\n  var input;\n  var options = {};\n  var metadata; // If the phone number is passed as a string.\n  // `getNumberType('88005553535', ...)`.\n\n  if (typeof arg_1 === 'string') {\n    // If \"default country\" argument is being passed\n    // then convert it to an `options` object.\n    // `getNumberType('88005553535', 'RU', metadata)`.\n    if (_typeof(arg_2) !== 'object') {\n      if (arg_4) {\n        options = arg_3;\n        metadata = arg_4;\n      } else {\n        metadata = arg_3;\n      } // `parse` extracts phone numbers from raw text,\n      // therefore it will cut off all \"garbage\" characters,\n      // while this `validate` function needs to verify\n      // that the phone number contains no \"garbage\"\n      // therefore the explicit `isViablePhoneNumber` check.\n\n\n      if (isViablePhoneNumber(arg_1)) {\n        input = parse(arg_1, {\n          defaultCountry: arg_2\n        }, metadata);\n      } else {\n        input = {};\n      }\n    } // No \"resrict country\" argument is being passed.\n    // International phone number is passed.\n    // `getNumberType('+78005553535', metadata)`.\n    else {\n      if (arg_3) {\n        options = arg_2;\n        metadata = arg_3;\n      } else {\n        metadata = arg_2;\n      } // `parse` extracts phone numbers from raw text,\n      // therefore it will cut off all \"garbage\" characters,\n      // while this `validate` function needs to verify\n      // that the phone number contains no \"garbage\"\n      // therefore the explicit `isViablePhoneNumber` check.\n\n\n      if (isViablePhoneNumber(arg_1)) {\n        input = parse(arg_1, undefined, metadata);\n      } else {\n        input = {};\n      }\n    }\n  } // If the phone number is passed as a parsed phone number.\n  // `getNumberType({ phone: '88005553535', country: 'RU' }, ...)`.\n  else if (is_object(arg_1)) {\n    input = arg_1;\n\n    if (arg_3) {\n      options = arg_2;\n      metadata = arg_3;\n    } else {\n      metadata = arg_2;\n    }\n  } else throw new TypeError('A phone number must either be a string or an object of shape { phone, [country] }.');\n\n  return {\n    input: input,\n    options: options,\n    metadata: metadata\n  };\n} // Babel transforms `typeof` into some \"branches\"\n// so istanbul will show this as \"branch not covered\".\n\n/* istanbul ignore next */\n\nvar is_object = function is_object(_) {\n  return _typeof(_) === 'object';\n};","import _isValidNumber from '../isValid.js';\nimport { normalizeArguments } from './getNumberType.js'; // Finds out national phone number type (fixed line, mobile, etc)\n\nexport default function isValidNumber() {\n  var _normalizeArguments = normalizeArguments(arguments),\n      input = _normalizeArguments.input,\n      options = _normalizeArguments.options,\n      metadata = _normalizeArguments.metadata; // `parseNumber()` would return `{}` when no phone number could be parsed from the input.\n\n\n  if (!input.phone) {\n    return false;\n  }\n\n  return _isValidNumber(input, options, metadata);\n}","// Deprecated.\nimport withMetadataArgument from '../min/exports/withMetadataArgument.js';\nimport _isValidNumber from '../es6/legacy/isValidNumber.js';\nexport function isValidNumber() {\n  return withMetadataArgument(_isValidNumber, arguments);\n}"],"sourceRoot":""}