@kne-components/components-core 0.4.29 → 0.4.31

package/build/static/js/8481.99dda967.chunk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"static/js/8481.99dda967.chunk.js","mappings":"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","sources":["../node_modules/libphonenumber-js/source/helpers/getCountryByCallingCode.js","../node_modules/libphonenumber-js/source/AsYouTypeFormatter.util.js","../node_modules/libphonenumber-js/source/validatePhoneNumberLength.js","../node_modules/libphonenumber-js/source/helpers/applyInternationalSeparatorStyle.js","../node_modules/libphonenumber-js/source/constants.js","../node_modules/libphonenumber-js/source/findNumbers/isValidPreCandidate.js","../node_modules/libphonenumber-js/source/helpers/isObject.js","../node_modules/libphonenumber-js/source/helpers/formatNationalNumberUsingFormat.js","../node_modules/libphonenumber-js/source/isValidPhoneNumber.js","../node_modules/libphonenumber-js/source/normalizeArguments.js","../node_modules/libphonenumber-js/source/findNumbers/parsePreCandidate.js","../node_modules/libphonenumber-js/source/ParseError.js","../node_modules/libphonenumber-js/source/helpers/matchesEntirely.js","../node_modules/libphonenumber-js/source/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js","../node_modules/libphonenumber-js/source/parsePhoneNumberWithError_.js","../node_modules/libphonenumber-js/source/searchPhoneNumbersInText.js","../node_modules/libphonenumber-js/source/helpers/parseDigits.js","../node_modules/libphonenumber-js/source/findNumbers/utf-8.js","../node_modules/libphonenumber-js/source/helpers/extractCountryCallingCode.js","../node_modules/libphonenumber-js/source/helpers/getPossibleCountriesForNumber.js","../node_modules/libphonenumber-js/source/PhoneNumber.js","../node_modules/libphonenumber-js/source/helpers/extension/createExtensionPattern.js","../node_modules/libphonenumber-js/source/legacy/findNumbers.js","../node_modules/libphonenumber-js/source/parsePhoneNumberWithError.js","../node_modules/libphonenumber-js/source/helpers/stripIddPrefix.js","../node_modules/libphonenumber-js/source/helpers/extension/extractExtension.js","../node_modules/libphonenumber-js/source/helpers/extractPhoneContext.js","../node_modules/libphonenumber-js/source/helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js","../node_modules/libphonenumber-js/source/parse.js","../node_modules/libphonenumber-js/source/isPossiblePhoneNumber.js","../node_modules/libphonenumber-js/source/parsePhoneNumber.js","../node_modules/libphonenumber-js/source/helpers/checkNumberLength.js","../node_modules/libphonenumber-js/source/helpers/mergeArrays.js","../node_modules/libphonenumber-js/source/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js","../node_modules/libphonenumber-js/source/helpers/getIddPrefix.js","../node_modules/libphonenumber-js/source/format.js","../node_modules/libphonenumber-js/source/legacy/searchNumbers.js","../node_modules/libphonenumber-js/source/formatIncompletePhoneNumber.js","../node_modules/libphonenumber-js/source/findNumbers/LRUCache.js","../node_modules/libphonenumber-js/source/findNumbers/RegExpCache.js","../node_modules/libphonenumber-js/source/findNumbers/matchPhoneNumberStringAgainstPhoneNumber.js","../node_modules/libphonenumber-js/source/findNumbers/Leniency.js","../node_modules/libphonenumber-js/source/PhoneNumberMatcher.js","../node_modules/libphonenumber-js/source/isPossible.js","../node_modules/libphonenumber-js/source/findNumbers/util.js","../node_modules/libphonenumber-js/source/helpers/extractNationalNumber.js","../node_modules/libphonenumber-js/source/helpers/isViablePhoneNumber.js","../node_modules/libphonenumber-js/source/getCountries.js","../node_modules/libphonenumber-js/source/findPhoneNumbersInText.js","../node_modules/libphonenumber-js/source/parseIncompletePhoneNumber.js","../node_modules/libphonenumber-js/source/findNumbers/isValidCandidate.js","../node_modules/libphonenumber-js/source/helpers/RFC3966.js","../node_modules/libphonenumber-js/source/parsePhoneNumber_.js","../node_modules/libphonenumber-js/source/isValid.js","../node_modules/libphonenumber-js/source/tools/semver-compare.js","../node_modules/libphonenumber-js/source/metadata.js","../node_modules/libphonenumber-js/source/helpers/getCountryByNationalNumber.js","../node_modules/libphonenumber-js/source/AsYouTypeState.js","../node_modules/libphonenumber-js/source/AsYouTypeFormatter.complete.js","../node_modules/libphonenumber-js/source/AsYouTypeFormatter.PatternParser.js","../node_modules/libphonenumber-js/source/AsYouTypeFormatter.PatternMatcher.js","../node_modules/libphonenumber-js/source/AsYouTypeFormatter.js","../node_modules/libphonenumber-js/source/AsYouTypeParser.js","../node_modules/libphonenumber-js/source/AsYouType.js","../node_modules/libphonenumber-js/source/helpers/getNumberType.js","../node_modules/libphonenumber-js/source/getExampleNumber.js"],"sourcesContent":["import getCountryByNationalNumber from './getCountryByNationalNumber.js'\r\n\r\nconst USE_NON_GEOGRAPHIC_COUNTRY_CODE = false\r\n\r\n// Returns the exact country for the `nationalNumber`\r\n// that belongs to the specified \"country calling code\".\r\nexport default function getCountryByCallingCode(callingCode, {\r\n\tnationalNumber: nationalPhoneNumber,\r\n\tmetadata\r\n}) {\r\n\t/* istanbul ignore if */\r\n\tif (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\r\n\t\tif (metadata.isNonGeographicCallingCode(callingCode)) {\r\n\t\t\treturn '001'\r\n\t\t}\r\n\t}\r\n\tconst possibleCountries = metadata.getCountryCodesForCallingCode(callingCode)\r\n\tif (!possibleCountries) {\r\n\t\treturn\r\n\t}\r\n\t// If there's just one country corresponding to the country code,\r\n\t// then just return it, without further phone number digits validation.\r\n\tif (possibleCountries.length === 1) {\r\n\t\treturn possibleCountries[0]\r\n\t}\r\n\treturn getCountryByNationalNumber(nationalPhoneNumber, {\r\n\t\tcountries: possibleCountries,\r\n\t\tmetadata: metadata.metadata\r\n\t})\r\n}","// Should be the same as `DIGIT_PLACEHOLDER` in `libphonenumber-metadata-generator`.\r\nexport const DIGIT_PLACEHOLDER = 'x' // '\\u2008' (punctuation space)\r\nconst DIGIT_PLACEHOLDER_MATCHER = new RegExp(DIGIT_PLACEHOLDER)\r\n\r\n// Counts all occurences of a symbol in a string.\r\n// Unicode-unsafe (because using `.split()`).\r\nexport function countOccurences(symbol, string) {\r\n\tlet count = 0\r\n\t// Using `.split('')` to iterate through a string here\r\n\t// to avoid requiring `Symbol.iterator` polyfill.\r\n\t// `.split('')` is generally not safe for Unicode,\r\n\t// but in this particular case for counting brackets it is safe.\r\n\t// for (const character of string)\r\n\tfor (const character of string.split('')) {\r\n\t\tif (character === symbol) {\r\n\t\t\tcount++\r\n\t\t}\r\n\t}\r\n\treturn count\r\n}\r\n\r\n// Repeats a string (or a symbol) N times.\r\n// http://stackoverflow.com/questions/202605/repeat-string-javascript\r\nexport function repeat(string, times) {\r\n\tif (times < 1) {\r\n\t\treturn ''\r\n\t}\r\n\tlet result = ''\r\n\twhile (times > 1) {\r\n\t\tif (times & 1) {\r\n\t\t\tresult += string\r\n\t\t}\r\n\t\ttimes >>= 1\r\n\t\tstring += string\r\n\t}\r\n\treturn result + string\r\n}\r\n\r\nexport function cutAndStripNonPairedParens(string, cutBeforeIndex) {\r\n\tif (string[cutBeforeIndex] === ')') {\r\n\t\tcutBeforeIndex++\r\n\t}\r\n\treturn stripNonPairedParens(string.slice(0, cutBeforeIndex))\r\n}\r\n\r\nexport function closeNonPairedParens(template, cut_before) {\r\n\tconst retained_template = template.slice(0, cut_before)\r\n\tconst opening_braces = countOccurences('(', retained_template)\r\n\tconst closing_braces = countOccurences(')', retained_template)\r\n\tlet dangling_braces = opening_braces - closing_braces\r\n\twhile (dangling_braces > 0 && cut_before < template.length) {\r\n\t\tif (template[cut_before] === ')') {\r\n\t\t\tdangling_braces--\r\n\t\t}\r\n\t\tcut_before++\r\n\t}\r\n\treturn template.slice(0, cut_before)\r\n}\r\n\r\nexport function stripNonPairedParens(string) {\r\n\tconst dangling_braces =[]\r\n\tlet i = 0\r\n\twhile (i < string.length) {\r\n\t\tif (string[i] === '(') {\r\n\t\t\tdangling_braces.push(i)\r\n\t\t}\r\n\t\telse if (string[i] === ')') {\r\n\t\t\tdangling_braces.pop()\r\n\t\t}\r\n\t\ti++\r\n\t}\r\n\tlet start = 0\r\n\tlet cleared_string = ''\r\n\tdangling_braces.push(string.length)\r\n\tfor (const index of dangling_braces) {\r\n\t\tcleared_string += string.slice(start, index)\r\n\t\tstart = index + 1\r\n\t}\r\n\treturn cleared_string\r\n}\r\n\r\nexport function populateTemplateWithDigits(template, position, digits) {\r\n\t// Using `.split('')` to iterate through a string here\r\n\t// to avoid requiring `Symbol.iterator` polyfill.\r\n\t// `.split('')` is generally not safe for Unicode,\r\n\t// but in this particular case for `digits` it is safe.\r\n\t// for (const digit of digits)\r\n\tfor (const digit of digits.split('')) {\r\n\t\t// If there is room for more digits in current `template`,\r\n\t\t// then set the next digit in the `template`,\r\n\t\t// and return the formatted digits so far.\r\n\t\t// If more digits are entered than the current format could handle.\r\n\t\tif (template.slice(position + 1).search(DIGIT_PLACEHOLDER_MATCHER) < 0) {\r\n\t\t\treturn\r\n\t\t}\r\n\t\tposition = template.search(DIGIT_PLACEHOLDER_MATCHER)\r\n\t\ttemplate = template.replace(DIGIT_PLACEHOLDER_MATCHER, digit)\r\n\t}\r\n\treturn [template, position]\r\n}","import normalizeArguments from './normalizeArguments.js'\r\nimport parsePhoneNumberWithError from './parsePhoneNumberWithError_.js'\r\nimport ParseError from './ParseError.js'\r\nimport Metadata from './metadata.js'\r\nimport checkNumberLength from './helpers/checkNumberLength.js'\r\n\r\nexport default function validatePhoneNumberLength() {\r\n\tlet { text, options, metadata } = normalizeArguments(arguments)\r\n\toptions = {\r\n\t\t...options,\r\n\t\textract: false\r\n\t}\r\n\r\n\t// Parse phone number.\r\n\ttry {\r\n\t\tconst phoneNumber = parsePhoneNumberWithError(text, options, metadata)\r\n\t\tmetadata = new Metadata(metadata)\r\n\t\tmetadata.selectNumberingPlan(phoneNumber.countryCallingCode)\r\n\t\tconst result = checkNumberLength(phoneNumber.nationalNumber, phoneNumber.country, metadata)\r\n\t\tif (result !== 'IS_POSSIBLE') {\r\n\t\t\treturn result\r\n\t\t}\r\n\t} catch (error) {\r\n\t\t/* istanbul ignore else */\r\n\t\tif (error instanceof ParseError) {\r\n\t\t\treturn error.message\r\n\t\t} else {\r\n\t\t\tthrow error\r\n\t\t}\r\n\t}\r\n}","import { VALID_PUNCTUATION } from '../constants.js'\r\n\r\n// Removes brackets and replaces dashes with spaces.\r\n//\r\n// E.g. \"(999) 111-22-33\" -> \"999 111 22 33\"\r\n//\r\n// For some reason Google's metadata contains `<intlFormat/>`s with brackets and dashes.\r\n// Meanwhile, there's no single opinion about using punctuation in international phone numbers.\r\n//\r\n// For example, Google's `<intlFormat/>` for USA is `+1 213-373-4253`.\r\n// And here's a quote from WikiPedia's \"North American Numbering Plan\" page:\r\n// https://en.wikipedia.org/wiki/North_American_Numbering_Plan\r\n//\r\n// \"The country calling code for all countries participating in the NANP is 1.\r\n// In international format, an NANP number should be listed as +1 301 555 01 00,\r\n// where 301 is an area code (Maryland).\"\r\n//\r\n// I personally prefer the international format without any punctuation.\r\n// For example, brackets are remnants of the old age, meaning that the\r\n// phone number part in brackets (so called \"area code\") can be omitted\r\n// if dialing within the same \"area\".\r\n// And hyphens were clearly introduced for splitting local numbers into memorizable groups.\r\n// For example, remembering \"5553535\" is difficult but \"555-35-35\" is much simpler.\r\n// Imagine a man taking a bus from home to work and seeing an ad with a phone number.\r\n// He has a couple of seconds to memorize that number until it passes by.\r\n// If it were spaces instead of hyphens the man wouldn't necessarily get it,\r\n// but with hyphens instead of spaces the grouping is more explicit.\r\n// I personally think that hyphens introduce visual clutter,\r\n// so I prefer replacing them with spaces in international numbers.\r\n// In the modern age all output is done on displays where spaces are clearly distinguishable\r\n// so hyphens can be safely replaced with spaces without losing any legibility.\r\n//\r\nexport default function applyInternationalSeparatorStyle(formattedNumber) {\r\n\treturn formattedNumber.replace(new RegExp(`[${VALID_PUNCTUATION}]+`, 'g'), ' ').trim()\r\n}","// The minimum length of the national significant number.\r\nexport const MIN_LENGTH_FOR_NSN = 2\r\n\r\n// The ITU says the maximum length should be 15,\r\n// but one can find longer numbers in Germany.\r\nexport const MAX_LENGTH_FOR_NSN = 17\r\n\r\n// The maximum length of the country calling code.\r\nexport const MAX_LENGTH_COUNTRY_CODE = 3\r\n\r\n// Digits accepted in phone numbers\r\n// (ascii, fullwidth, arabic-indic, and eastern arabic digits).\r\nexport const VALID_DIGITS = '0-9\\uFF10-\\uFF19\\u0660-\\u0669\\u06F0-\\u06F9'\r\n\r\n// `DASHES` will be right after the opening square bracket of the \"character class\"\r\nconst DASHES = '-\\u2010-\\u2015\\u2212\\u30FC\\uFF0D'\r\nconst SLASHES = '\\uFF0F/'\r\nconst DOTS = '\\uFF0E.'\r\nexport const WHITESPACE = ' \\u00A0\\u00AD\\u200B\\u2060\\u3000'\r\nconst BRACKETS = '()\\uFF08\\uFF09\\uFF3B\\uFF3D\\\\[\\\\]'\r\n// export const OPENING_BRACKETS = '(\\uFF08\\uFF3B\\\\\\['\r\nconst TILDES = '~\\u2053\\u223C\\uFF5E'\r\n\r\n// Regular expression of acceptable punctuation found in phone numbers. This\r\n// excludes punctuation found as a leading character only. This consists of dash\r\n// characters, white space characters, full stops, slashes, square brackets,\r\n// parentheses and tildes. Full-width variants are also present.\r\nexport const VALID_PUNCTUATION = `${DASHES}${SLASHES}${DOTS}${WHITESPACE}${BRACKETS}${TILDES}`\r\n\r\nexport const PLUS_CHARS = '+\\uFF0B'\r\n// const LEADING_PLUS_CHARS_PATTERN = new RegExp('^[' + PLUS_CHARS + ']+')","// Matches strings that look like dates using \"/\" as a separator.\r\n// Examples: 3/10/2011, 31/10/96 or 08/31/95.\r\nconst SLASH_SEPARATED_DATES = /(?:(?:[0-3]?\\d\\/[01]?\\d)|(?:[01]?\\d\\/[0-3]?\\d))\\/(?:[12]\\d)?\\d{2}/\r\n\r\n// Matches timestamps.\r\n// Examples: \"2012-01-02 08:00\".\r\n// Note that the reg-ex does not include the\r\n// trailing \":\\d\\d\" -- that is covered by TIME_STAMPS_SUFFIX.\r\nconst TIME_STAMPS = /[12]\\d{3}[-/]?[01]\\d[-/]?[0-3]\\d +[0-2]\\d$/\r\nconst TIME_STAMPS_SUFFIX_LEADING = /^:[0-5]\\d/\r\n\r\nexport default function isValidPreCandidate(candidate, offset, text)\r\n{\r\n\t// Skip a match that is more likely to be a date.\r\n\tif (SLASH_SEPARATED_DATES.test(candidate)) {\r\n\t\treturn false\r\n\t}\r\n\r\n\t// Skip potential time-stamps.\r\n\tif (TIME_STAMPS.test(candidate))\r\n\t{\r\n\t\tconst followingText = text.slice(offset + candidate.length)\r\n\t\tif (TIME_STAMPS_SUFFIX_LEADING.test(followingText)) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t}\r\n\r\n\treturn true\r\n}","const objectConstructor = {}.constructor;\r\n\r\nexport default function isObject(object) {\r\n  return object !== undefined && object !== null && object.constructor === objectConstructor;\r\n}\r\n","import applyInternationalSeparatorStyle from './applyInternationalSeparatorStyle.js'\r\n\r\n// This was originally set to $1 but there are some countries for which the\r\n// first group is not used in the national pattern (e.g. Argentina) so the $1\r\n// group does not match correctly. Therefore, we use `\\d`, so that the first\r\n// group actually used in the pattern will be matched.\r\nexport const FIRST_GROUP_PATTERN = /(\\$\\d)/\r\n\r\nexport default function formatNationalNumberUsingFormat(\r\n\tnumber,\r\n\tformat,\r\n\t{\r\n\t\tuseInternationalFormat,\r\n\t\twithNationalPrefix,\r\n\t\tcarrierCode,\r\n\t\tmetadata\r\n\t}\r\n) {\r\n\tconst formattedNumber = number.replace(\r\n\t\tnew RegExp(format.pattern()),\r\n\t\tuseInternationalFormat\r\n\t\t\t? format.internationalFormat()\r\n\t\t\t: (\r\n\t\t\t\t// This library doesn't use `domestic_carrier_code_formatting_rule`,\r\n\t\t\t\t// because that one is only used when formatting phone numbers\r\n\t\t\t\t// for dialing from a mobile phone, and this is not a dialing library.\r\n\t\t\t\t// carrierCode && format.domesticCarrierCodeFormattingRule()\r\n\t\t\t\t// \t// First, replace the $CC in the formatting rule with the desired carrier code.\r\n\t\t\t\t// \t// Then, replace the $FG in the formatting rule with the first group\r\n\t\t\t\t// \t// and the carrier code combined in the appropriate way.\r\n\t\t\t\t// \t? format.format().replace(FIRST_GROUP_PATTERN, format.domesticCarrierCodeFormattingRule().replace('$CC', carrierCode))\r\n\t\t\t\t// \t: (\r\n\t\t\t\t// \t\twithNationalPrefix && format.nationalPrefixFormattingRule()\r\n\t\t\t\t// \t\t\t? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())\r\n\t\t\t\t// \t\t\t: format.format()\r\n\t\t\t\t// \t)\r\n\t\t\t\twithNationalPrefix && format.nationalPrefixFormattingRule()\r\n\t\t\t\t\t? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())\r\n\t\t\t\t\t: format.format()\r\n\t\t\t)\r\n\t)\r\n\tif (useInternationalFormat) {\r\n\t\treturn applyInternationalSeparatorStyle(formattedNumber)\r\n\t}\r\n\treturn formattedNumber\r\n}","import normalizeArguments from './normalizeArguments.js'\r\nimport parsePhoneNumber from './parsePhoneNumber_.js'\r\n\r\nexport default function isValidPhoneNumber() {\r\n\tlet { text, options, metadata } = normalizeArguments(arguments)\r\n\toptions = {\r\n\t\t...options,\r\n\t\textract: false\r\n\t}\r\n\tconst phoneNumber = parsePhoneNumber(text, options, metadata)\r\n\treturn phoneNumber && phoneNumber.isValid() || false\r\n}","import isObject from './helpers/isObject.js'\r\n\r\n// Extracts the following properties from function arguments:\r\n// * input `text`\r\n// * `options` object\r\n// * `metadata` JSON\r\nexport default function normalizeArguments(args) {\r\n\tconst [arg_1, arg_2, arg_3, arg_4] = Array.prototype.slice.call(args)\r\n\r\n\tlet text\r\n\tlet options\r\n\tlet metadata\r\n\r\n\t// If the phone number is passed as a string.\r\n\t// `parsePhoneNumber('88005553535', ...)`.\r\n\tif (typeof arg_1 === 'string') {\r\n\t\ttext = arg_1\r\n\t}\r\n\telse throw new TypeError('A text for parsing must be a string.')\r\n\r\n\t// If \"default country\" argument is being passed then move it to `options`.\r\n\t// `parsePhoneNumber('88005553535', 'RU', [options], metadata)`.\r\n\tif (!arg_2 || typeof arg_2 === 'string')\r\n\t{\r\n\t\tif (arg_4) {\r\n\t\t\toptions = arg_3\r\n\t\t\tmetadata = arg_4\r\n\t\t} else {\r\n\t\t\toptions = undefined\r\n\t\t\tmetadata = arg_3\r\n\t\t}\r\n\r\n\t\tif (arg_2) {\r\n\t\t\toptions = { defaultCountry: arg_2, ...options }\r\n\t\t}\r\n\t}\r\n\t// `defaultCountry` is not passed.\r\n\t// Example: `parsePhoneNumber('+78005553535', [options], metadata)`.\r\n\telse if (isObject(arg_2))\r\n\t{\r\n\t\tif (arg_3) {\r\n\t\t\toptions  = arg_2\r\n\t\t\tmetadata = arg_3\r\n\t\t} else {\r\n\t\t\tmetadata = arg_2\r\n\t\t}\r\n\t}\r\n\telse throw new Error(`Invalid second argument: ${arg_2}`)\r\n\r\n\treturn {\r\n\t\ttext,\r\n\t\toptions,\r\n\t\tmetadata\r\n\t}\r\n}","import { trimAfterFirstMatch } from './util.js'\r\n\r\n// Regular expression of characters typically used to start a second phone number for the purposes\r\n// of parsing. This allows us to strip off parts of the number that are actually the start of\r\n// another number, such as for: (530) 583-6985 x302/x2303 -> the second extension here makes this\r\n// actually two phone numbers, (530) 583-6985 x302 and (530) 583-6985 x2303. We remove the second\r\n// extension so that the first number is parsed correctly.\r\n//\r\n// Matches a slash (\\ or /) followed by a space followed by an `x`.\r\n//\r\nconst SECOND_NUMBER_START_PATTERN = /[\\\\/] *x/\r\n\r\nexport default function parsePreCandidate(candidate)\r\n{\r\n\t// Check for extra numbers at the end.\r\n\t// TODO: This is the place to start when trying to support extraction of multiple phone number\r\n\t// from split notations (+41 79 123 45 67 / 68).\r\n\treturn trimAfterFirstMatch(SECOND_NUMBER_START_PATTERN, candidate)\r\n}","// https://stackoverflow.com/a/46971044/970769\r\n// \"Breaking changes in Typescript 2.1\"\r\n// \"Extending built-ins like Error, Array, and Map may no longer work.\"\r\n// \"As a recommendation, you can manually adjust the prototype immediately after any super(...) calls.\"\r\n// https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\r\nexport default class ParseError extends Error {\r\n  constructor(code) {\r\n    super(code)\r\n    // Set the prototype explicitly.\r\n    // Any subclass of FooError will have to manually set the prototype as well.\r\n    Object.setPrototypeOf(this, ParseError.prototype)\r\n    this.name = this.constructor.name\r\n  }\r\n}","/**\r\n * Checks whether the entire input sequence can be matched\r\n * against the regular expression.\r\n * @return {boolean}\r\n */\r\nexport default function matchesEntirely(text, regularExpressionText) {\r\n\t// If the assigning of the `''` default value is moved to the arguments above,\r\n\t// the code coverage would decrease for some weird reason.\r\n\ttext = text || ''\r\n\treturn new RegExp('^(?:' + regularExpressionText + ')$').test(text)\r\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 */\r\nexport default function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {\r\n\tif (number && metadata.numberingPlan.nationalPrefixForParsing()) {\r\n\t\t// See METADATA.md for the description of\r\n\t\t// `national_prefix_for_parsing` and `national_prefix_transform_rule`.\r\n\t\t// Attempt to parse the first digits as a national prefix.\r\n\t\tconst prefixPattern = new RegExp('^(?:' + metadata.numberingPlan.nationalPrefixForParsing() + ')')\r\n\t\tconst prefixMatch = prefixPattern.exec(number)\r\n\t\tif (prefixMatch) {\r\n\t\t\tlet nationalNumber\r\n\t\t\tlet carrierCode\r\n\t\t\t// https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\r\n\t\t\t// If a `national_prefix_for_parsing` has any \"capturing groups\"\r\n\t\t\t// then it means that the national (significant) number is equal to\r\n\t\t\t// those \"capturing groups\" transformed via `national_prefix_transform_rule`,\r\n\t\t\t// and nothing could be said about the actual national prefix:\r\n\t\t\t// what is it and was it even there.\r\n\t\t\t// If a `national_prefix_for_parsing` doesn't have any \"capturing groups\",\r\n\t\t\t// then everything it matches is a national prefix.\r\n\t\t\t// To determine whether `national_prefix_for_parsing` matched any\r\n\t\t\t// \"capturing groups\", the value of the result of calling `.exec()`\r\n\t\t\t// is looked at, and if it has non-undefined values where there're\r\n\t\t\t// \"capturing groups\" in the regular expression, then it means\r\n\t\t\t// that \"capturing groups\" have been matched.\r\n\t\t\t// It's not possible to tell whether there'll be any \"capturing gropus\"\r\n\t\t\t// before the matching process, because a `national_prefix_for_parsing`\r\n\t\t\t// could exhibit both behaviors.\r\n\t\t\tconst capturedGroupsCount = prefixMatch.length - 1\r\n\t\t\tconst hasCapturedGroups = capturedGroupsCount > 0 && prefixMatch[capturedGroupsCount]\r\n\t\t\tif (metadata.nationalPrefixTransformRule() && hasCapturedGroups) {\r\n\t\t\t\tnationalNumber = number.replace(\r\n\t\t\t\t\tprefixPattern,\r\n\t\t\t\t\tmetadata.nationalPrefixTransformRule()\r\n\t\t\t\t)\r\n\t\t\t\t// If there's more than one captured group,\r\n\t\t\t\t// then carrier code is the second one.\r\n\t\t\t\tif (capturedGroupsCount > 1) {\r\n\t\t\t\t\tcarrierCode = prefixMatch[1]\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// If there're no \"capturing groups\",\r\n\t\t\t// or if there're \"capturing groups\" but no\r\n\t\t\t// `national_prefix_transform_rule`,\r\n\t\t\t// then just strip the national prefix from the number,\r\n\t\t\t// and possibly a carrier code.\r\n\t\t\t// Seems like there could be more.\r\n\t\t\telse {\r\n\t\t\t\t// `prefixBeforeNationalNumber` is the whole substring matched by\r\n\t\t\t\t// the `national_prefix_for_parsing` regular expression.\r\n\t\t\t\t// There seem to be no guarantees that it's just a national prefix.\r\n\t\t\t\t// For example, if there's a carrier code, it's gonna be a\r\n\t\t\t\t// part of `prefixBeforeNationalNumber` too.\r\n\t\t\t\tconst prefixBeforeNationalNumber = prefixMatch[0]\r\n\t\t\t\tnationalNumber = number.slice(prefixBeforeNationalNumber.length)\r\n\t\t\t\t// If there's at least one captured group,\r\n\t\t\t\t// then carrier code is the first one.\r\n\t\t\t\tif (hasCapturedGroups) {\r\n\t\t\t\t\tcarrierCode = prefixMatch[1]\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// Tries to guess whether a national prefix was present in the input.\r\n\t\t\t// This is not something copy-pasted from Google's library:\r\n\t\t\t// they don't seem to have an equivalent for that.\r\n\t\t\t// So this isn't an \"officially approved\" way of doing something like that.\r\n\t\t\t// But since there seems no other existing method, this library uses it.\r\n\t\t\tlet nationalPrefix\r\n\t\t\tif (hasCapturedGroups) {\r\n\t\t\t\tconst possiblePositionOfTheFirstCapturedGroup = number.indexOf(prefixMatch[1])\r\n\t\t\t\tconst possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup)\r\n\t\t\t\t// Example: an Argentinian (AR) phone number `0111523456789`.\r\n\t\t\t\t// `prefixMatch[0]` is `01115`, and `$1` is `11`,\r\n\t\t\t\t// and the rest of the phone number is `23456789`.\r\n\t\t\t\t// The national number is transformed via `9$1` to `91123456789`.\r\n\t\t\t\t// National prefix `0` is detected being present at the start.\r\n\t\t\t\t// if (possibleNationalPrefix.indexOf(metadata.numberingPlan.nationalPrefix()) === 0) {\r\n\t\t\t\tif (possibleNationalPrefix === metadata.numberingPlan.nationalPrefix()) {\r\n\t\t\t\t\tnationalPrefix = metadata.numberingPlan.nationalPrefix()\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tnationalPrefix = prefixMatch[0]\r\n\t\t\t}\r\n\t\t\treturn {\r\n\t\t\t\tnationalNumber,\r\n\t\t\t\tnationalPrefix,\r\n\t\t\t\tcarrierCode\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n   return {\r\n   \tnationalNumber: number\r\n   }\r\n}","import parse from './parse.js'\r\n\r\nexport default function parsePhoneNumberWithError(text, options, metadata) {\r\n\treturn parse(text, { ...options, v2: true }, metadata)\r\n}","import PhoneNumberMatcher from './PhoneNumberMatcher.js'\r\nimport normalizeArguments from './normalizeArguments.js'\r\n\r\nexport default function searchPhoneNumbersInText() {\r\n\tconst { text, options, metadata } = normalizeArguments(arguments)\r\n\tconst matcher = new PhoneNumberMatcher(text, { ...options, v2: true }, metadata)\r\n\treturn  {\r\n\t\t[Symbol.iterator]() {\r\n\t\t\treturn {\r\n\t    \t\tnext: () => {\r\n\t    \t\t\tif (matcher.hasNext()) {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tdone: false,\r\n\t\t\t\t\t\t\tvalue: matcher.next()\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\tdone: true\r\n\t\t\t\t\t}\r\n\t    \t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}","// These mappings map a character (key) to a specific digit that should\r\n// replace it for normalization purposes. Non-European digits that\r\n// may be used in phone numbers are mapped to a European equivalent.\r\n//\r\n// E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.\r\n//\r\nexport const DIGITS = {\r\n\t'0': '0',\r\n\t'1': '1',\r\n\t'2': '2',\r\n\t'3': '3',\r\n\t'4': '4',\r\n\t'5': '5',\r\n\t'6': '6',\r\n\t'7': '7',\r\n\t'8': '8',\r\n\t'9': '9',\r\n\t'\\uFF10': '0', // Fullwidth digit 0\r\n\t'\\uFF11': '1', // Fullwidth digit 1\r\n\t'\\uFF12': '2', // Fullwidth digit 2\r\n\t'\\uFF13': '3', // Fullwidth digit 3\r\n\t'\\uFF14': '4', // Fullwidth digit 4\r\n\t'\\uFF15': '5', // Fullwidth digit 5\r\n\t'\\uFF16': '6', // Fullwidth digit 6\r\n\t'\\uFF17': '7', // Fullwidth digit 7\r\n\t'\\uFF18': '8', // Fullwidth digit 8\r\n\t'\\uFF19': '9', // Fullwidth digit 9\r\n\t'\\u0660': '0', // Arabic-indic digit 0\r\n\t'\\u0661': '1', // Arabic-indic digit 1\r\n\t'\\u0662': '2', // Arabic-indic digit 2\r\n\t'\\u0663': '3', // Arabic-indic digit 3\r\n\t'\\u0664': '4', // Arabic-indic digit 4\r\n\t'\\u0665': '5', // Arabic-indic digit 5\r\n\t'\\u0666': '6', // Arabic-indic digit 6\r\n\t'\\u0667': '7', // Arabic-indic digit 7\r\n\t'\\u0668': '8', // Arabic-indic digit 8\r\n\t'\\u0669': '9', // Arabic-indic digit 9\r\n\t'\\u06F0': '0', // Eastern-Arabic digit 0\r\n\t'\\u06F1': '1', // Eastern-Arabic digit 1\r\n\t'\\u06F2': '2', // Eastern-Arabic digit 2\r\n\t'\\u06F3': '3', // Eastern-Arabic digit 3\r\n\t'\\u06F4': '4', // Eastern-Arabic digit 4\r\n\t'\\u06F5': '5', // Eastern-Arabic digit 5\r\n\t'\\u06F6': '6', // Eastern-Arabic digit 6\r\n\t'\\u06F7': '7', // Eastern-Arabic digit 7\r\n\t'\\u06F8': '8', // Eastern-Arabic digit 8\r\n\t'\\u06F9': '9'  // Eastern-Arabic digit 9\r\n}\r\n\r\nexport function parseDigit(character) {\r\n\treturn DIGITS[character]\r\n}\r\n\r\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 */\r\nexport default function parseDigits(string) {\r\n\tlet result = ''\r\n\t// Using `.split('')` here instead of normal `for ... of`\r\n\t// because the importing application doesn't neccessarily include an ES6 polyfill.\r\n\t// The `.split('')` approach discards \"exotic\" UTF-8 characters\r\n\t// (the ones consisting of four bytes) but digits\r\n\t// (including non-European ones) don't fall into that range\r\n\t// so such \"exotic\" characters would be discarded anyway.\r\n\tfor (const character of string.split('')) {\r\n\t\tconst digit = parseDigit(character)\r\n\t\tif (digit) {\r\n\t\t\tresult += digit\r\n\t\t}\r\n\t}\r\n\treturn result\r\n}","// Javascript doesn't support UTF-8 regular expressions.\r\n// So mimicking them here.\r\n\r\n// Copy-pasted from `PhoneNumberMatcher.js`.\r\n\r\n/**\r\n * \"\\p{Z}\" is any kind of whitespace or invisible separator (\"Separator\").\r\n * http://www.regular-expressions.info/unicode.html\r\n * \"\\P{Z}\" is the reverse of \"\\p{Z}\".\r\n * \"\\p{N}\" is any kind of numeric character in any script (\"Number\").\r\n * \"\\p{Nd}\" is a digit zero through nine in any script except \"ideographic scripts\" (\"Decimal_Digit_Number\").\r\n * \"\\p{Sc}\" is a currency symbol (\"Currency_Symbol\").\r\n * \"\\p{L}\" is any kind of letter from any language (\"Letter\").\r\n * \"\\p{Mn}\" is \"non-spacing mark\".\r\n *\r\n * Javascript doesn't support Unicode Regular Expressions\r\n * so substituting it with this explicit set of characters.\r\n *\r\n * https://stackoverflow.com/questions/13210194/javascript-regex-equivalent-of-a-za-z-using-pl\r\n * https://github.com/danielberndt/babel-plugin-utf-8-regex/blob/master/src/transformer.js\r\n */\r\n\r\nconst _pZ = '\\u0020\\u00A0\\u1680\\u180E\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000'\r\nexport const pZ = `[${_pZ}]`\r\nexport const PZ = `[^${_pZ}]`\r\n\r\nexport const _pN = '\\u0030-\\u0039\\u00B2\\u00B3\\u00B9\\u00BC-\\u00BE\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u09F4-\\u09F9\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0B72-\\u0B77\\u0BE6-\\u0BF2\\u0C66-\\u0C6F\\u0C78-\\u0C7E\\u0CE6-\\u0CEF\\u0D66-\\u0D75\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F33\\u1040-\\u1049\\u1090-\\u1099\\u1369-\\u137C\\u16EE-\\u16F0\\u17E0-\\u17E9\\u17F0-\\u17F9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19DA\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\u2070\\u2074-\\u2079\\u2080-\\u2089\\u2150-\\u2182\\u2185-\\u2189\\u2460-\\u249B\\u24EA-\\u24FF\\u2776-\\u2793\\u2CFD\\u3007\\u3021-\\u3029\\u3038-\\u303A\\u3192-\\u3195\\u3220-\\u3229\\u3248-\\u324F\\u3251-\\u325F\\u3280-\\u3289\\u32B1-\\u32BF\\uA620-\\uA629\\uA6E6-\\uA6EF\\uA830-\\uA835\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19'\r\n// const pN = `[${_pN}]`\r\n\r\nconst _pNd = '\\u0030-\\u0039\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE6-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29\\u1040-\\u1049\\u1090-\\u1099\\u17E0-\\u17E9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19D9\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\uA620-\\uA629\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19'\r\nexport const pNd = `[${_pNd}]`\r\n\r\nexport const _pL = '\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0\\u08A2-\\u08AC\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA697\\uA6A0-\\uA6E5\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA793\\uA7A0-\\uA7AA\\uA7F8-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA80-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC'\r\nconst pL = `[${_pL}]`\r\nconst pL_regexp = new RegExp(pL)\r\n\r\nconst _pSc = '\\u0024\\u00A2-\\u00A5\\u058F\\u060B\\u09F2\\u09F3\\u09FB\\u0AF1\\u0BF9\\u0E3F\\u17DB\\u20A0-\\u20B9\\uA838\\uFDFC\\uFE69\\uFF04\\uFFE0\\uFFE1\\uFFE5\\uFFE6'\r\nconst pSc = `[${_pSc}]`\r\nconst pSc_regexp = new RegExp(pSc)\r\n\r\nconst _pMn = '\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065F\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08E4-\\u08FE\\u0900-\\u0902\\u093A\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0957\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135D-\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4\\u17B5\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1BAB\\u1BE6\\u1BE8\\u1BE9\\u1BED\\u1BEF-\\u1BF1\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1CF4\\u1DC0-\\u1DE6\\u1DFC-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302D\\u3099\\u309A\\uA66F\\uA674-\\uA67D\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEC\\uAAED\\uAAF6\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26'\r\nconst pMn = `[${_pMn}]`\r\nconst pMn_regexp = new RegExp(pMn)\r\n\r\nconst _InBasic_Latin = '\\u0000-\\u007F'\r\nconst _InLatin_1_Supplement = '\\u0080-\\u00FF'\r\nconst _InLatin_Extended_A = '\\u0100-\\u017F'\r\nconst _InLatin_Extended_Additional = '\\u1E00-\\u1EFF'\r\nconst _InLatin_Extended_B = '\\u0180-\\u024F'\r\nconst _InCombining_Diacritical_Marks = '\\u0300-\\u036F'\r\n\r\nconst latinLetterRegexp = new RegExp\r\n(\r\n\t'[' +\r\n\t_InBasic_Latin +\r\n\t_InLatin_1_Supplement +\r\n\t_InLatin_Extended_A +\r\n\t_InLatin_Extended_Additional +\r\n\t_InLatin_Extended_B +\r\n\t_InCombining_Diacritical_Marks +\r\n\t']'\r\n)\r\n\r\n/**\r\n * Helper method to determine if a character is a Latin-script letter or not.\r\n * For our purposes, combining marks should also return true since we assume\r\n * they have been added to a preceding Latin character.\r\n */\r\nexport function isLatinLetter(letter)\r\n{\r\n\t// Combining marks are a subset of non-spacing-mark.\r\n\tif (!pL_regexp.test(letter) && !pMn_regexp.test(letter)) {\r\n\t\treturn false\r\n\t}\r\n\r\n\treturn latinLetterRegexp.test(letter)\r\n}\r\n\r\nexport function isInvalidPunctuationSymbol(character)\r\n{\r\n\treturn character === '%' || pSc_regexp.test(character)\r\n}","import stripIddPrefix from './stripIddPrefix.js'\r\nimport extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js'\r\nimport Metadata from '../metadata.js'\r\nimport { MAX_LENGTH_COUNTRY_CODE } from '../constants.js'\r\n\r\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] — Country.\r\n * @param  {string} [defaultCountry] — Default country.\r\n * @param  {string} [defaultCallingCode] — 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', null, 'US', null, metadata)\r\n * extractCountryCallingCode('2133734253', null, null, '1', metadata)\r\n * extractCountryCallingCode('+12133734253', null, null, null, metadata)\r\n * extractCountryCallingCode('+12133734253', null, 'RU', null, metadata)\r\n */\r\nexport default function extractCountryCallingCode(\r\n\tnumber,\r\n\tcountry,\r\n\tdefaultCountry,\r\n\tdefaultCallingCode,\r\n\tmetadata\r\n) {\r\n\tif (!number) {\r\n\t\treturn {}\r\n\t}\r\n\r\n\tlet isNumberWithIddPrefix\r\n\r\n\t// If this is not an international phone number,\r\n\t// then either extract an \"IDD\" prefix, or extract a\r\n\t// country calling code from a number by autocorrecting it\r\n\t// by prepending a leading `+` in cases when it starts\r\n\t// with the country calling code.\r\n\t// https://wikitravel.org/en/International_dialling_prefix\r\n\t// https://github.com/catamphetamine/libphonenumber-js/issues/376\r\n\tif (number[0] !== '+') {\r\n\t\t// Convert an \"out-of-country\" dialing phone number\r\n\t\t// to a proper international phone number.\r\n\t\tconst numberWithoutIDD = stripIddPrefix(number, country || defaultCountry, defaultCallingCode, metadata)\r\n\t\t// If an IDD prefix was stripped then\r\n\t\t// convert the number to international one\r\n\t\t// for subsequent parsing.\r\n\t\tif (numberWithoutIDD && numberWithoutIDD !== number) {\r\n\t\t\tisNumberWithIddPrefix = true\r\n\t\t\tnumber = '+' + numberWithoutIDD\r\n\t\t} else {\r\n\t\t\t// Check to see if the number starts with the country calling code\r\n\t\t\t// for the default country. If so, we remove the country calling code,\r\n\t\t\t// and do some checks on the validity of the number before and after.\r\n\t\t\t// https://github.com/catamphetamine/libphonenumber-js/issues/376\r\n\t\t\tif (country || defaultCountry || defaultCallingCode) {\r\n\t\t\t\tconst {\r\n\t\t\t\t\tcountryCallingCode,\r\n\t\t\t\t\tnumber: shorterNumber\r\n\t\t\t\t} = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(\r\n\t\t\t\t\tnumber,\r\n\t\t\t\t\tcountry,\r\n\t\t\t\t\tdefaultCountry,\r\n\t\t\t\t\tdefaultCallingCode,\r\n\t\t\t\t\tmetadata\r\n\t\t\t\t)\r\n\t\t\t\tif (countryCallingCode) {\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\tcountryCallingCodeSource: 'FROM_NUMBER_WITHOUT_PLUS_SIGN',\r\n\t\t\t\t\t\tcountryCallingCode,\r\n\t\t\t\t\t\tnumber: shorterNumber\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn {\r\n\t\t\t\t// No need to set it to `UNSPECIFIED`. It can be just `undefined`.\r\n\t\t\t\t// countryCallingCodeSource: 'UNSPECIFIED',\r\n\t\t\t\tnumber\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// `number` can only be international at this point.\r\n\r\n\t// Fast abortion: country codes do not begin with a '0'\r\n\tif (number[1] === '0') {\r\n\t\treturn {}\r\n\t}\r\n\r\n\tmetadata = new Metadata(metadata)\r\n\r\n\t// The thing with country phone codes\r\n\t// is that they are orthogonal to each other\r\n\t// i.e. there's no such country phone code A\r\n\t// for which country phone code B exists\r\n\t// where B starts with A.\r\n\t// Therefore, while scanning digits,\r\n\t// if a valid country code is found,\r\n\t// that means that it is the country code.\r\n\t//\r\n\tlet i = 2\r\n\twhile (i - 1 <= MAX_LENGTH_COUNTRY_CODE && i <= number.length) {\r\n\t\tconst countryCallingCode = number.slice(1, i)\r\n\t\tif (metadata.hasCallingCode(countryCallingCode)) {\r\n\t\t\tmetadata.selectNumberingPlan(countryCallingCode)\r\n\t\t\treturn {\r\n\t\t\t\tcountryCallingCodeSource: isNumberWithIddPrefix ? 'FROM_NUMBER_WITH_IDD' : 'FROM_NUMBER_WITH_PLUS_SIGN',\r\n\t\t\t\tcountryCallingCode,\r\n\t\t\t\tnumber: number.slice(i)\r\n\t\t\t}\r\n\t\t}\r\n\t\ti++\r\n\t}\r\n\r\n\treturn {}\r\n}\r\n\r\n// The possible values for the returned `countryCallingCodeSource` are:\r\n//\r\n// Copy-pasted from:\r\n// https://github.com/google/libphonenumber/blob/master/resources/phonenumber.proto\r\n//\r\n// // The source from which the country_code is derived. This is not set in the\r\n// // general parsing method, but in the method that parses and keeps raw_input.\r\n// // New fields could be added upon request.\r\n// enum CountryCodeSource {\r\n//  // Default value returned if this is not set, because the phone number was\r\n//  // created using parse, not parseAndKeepRawInput. hasCountryCodeSource will\r\n//  // return false if this is the case.\r\n//  UNSPECIFIED = 0;\r\n//\r\n//  // The country_code is derived based on a phone number with a leading \"+\",\r\n//  // e.g. the French number \"+33 1 42 68 53 00\".\r\n//  FROM_NUMBER_WITH_PLUS_SIGN = 1;\r\n//\r\n//  // The country_code is derived based on a phone number with a leading IDD,\r\n//  // e.g. the French number \"011 33 1 42 68 53 00\", as it is dialled from US.\r\n//  FROM_NUMBER_WITH_IDD = 5;\r\n//\r\n//  // The country_code is derived based on a phone number without a leading\r\n//  // \"+\", e.g. the French number \"33 1 42 68 53 00\" when defaultCountry is\r\n//  // supplied as France.\r\n//  FROM_NUMBER_WITHOUT_PLUS_SIGN = 10;\r\n//\r\n//  // The country_code is derived NOT based on the phone number itself, but\r\n//  // from the defaultCountry parameter provided in the parsing function by the\r\n//  // clients. This happens mostly for numbers written in the national format\r\n//  // (without country code). For example, this would be set when parsing the\r\n//  // French number \"01 42 68 53 00\", when defaultCountry is supplied as\r\n//  // France.\r\n//  FROM_DEFAULT_COUNTRY = 20;\r\n// }","import Metadata from '../metadata.js'\r\n\r\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 */\r\nexport default function getPossibleCountriesForNumber(callingCode, nationalNumber, metadata) {\r\n\tconst _metadata = new Metadata(metadata)\r\n\tlet possibleCountries = _metadata.getCountryCodesForCallingCode(callingCode)\r\n\tif (!possibleCountries) {\r\n\t\treturn []\r\n\t}\r\n\treturn possibleCountries.filter((country) => {\r\n\t\treturn couldNationalNumberBelongToCountry(nationalNumber, country, metadata)\r\n\t})\r\n}\r\n\r\nfunction couldNationalNumberBelongToCountry(nationalNumber, country, metadata) {\r\n\tconst _metadata = new Metadata(metadata)\r\n\t_metadata.selectNumberingPlan(country)\r\n\tif (_metadata.numberingPlan.possibleLengths().indexOf(nationalNumber.length) >= 0) {\r\n\t\treturn true\r\n\t}\r\n\treturn false\r\n}","import Metadata, { validateMetadata } from './metadata.js'\r\nimport isPossibleNumber from './isPossible.js'\r\nimport isValidNumber from './isValid.js'\r\nimport getNumberType from './helpers/getNumberType.js'\r\nimport getPossibleCountriesForNumber from './helpers/getPossibleCountriesForNumber.js'\r\nimport extractCountryCallingCode from './helpers/extractCountryCallingCode.js'\r\nimport isObject from './helpers/isObject.js'\r\nimport formatNumber from './format.js'\r\n\r\nconst USE_NON_GEOGRAPHIC_COUNTRY_CODE = false\r\n\r\nexport default class PhoneNumber {\r\n\t/**\r\n\t * @param  {string} countryOrCountryCallingCode\r\n\t * @param  {string} nationalNumber\r\n\t * @param  {object} metadata — Metadata JSON\r\n\t * @return {PhoneNumber}\r\n\t */\r\n\tconstructor(countryOrCountryCallingCode, nationalNumber, metadata) {\r\n\t\t// Validate `countryOrCountryCallingCode` argument.\r\n\t\tif (!countryOrCountryCallingCode) {\r\n\t\t\tthrow new TypeError('First argument is required')\r\n\t\t}\r\n\t\tif (typeof countryOrCountryCallingCode !== 'string') {\r\n\t\t\tthrow new TypeError('First argument must be a string')\r\n\t\t}\r\n\r\n\t\t// In case of public API use: `constructor(number, metadata)`.\r\n\t\t// Transform the arguments from `constructor(number, metadata)` to\r\n\t\t// `constructor(countryOrCountryCallingCode, nationalNumber, metadata)`.\r\n\t\tif (countryOrCountryCallingCode[0] === '+' && !nationalNumber) {\r\n\t\t\tthrow new TypeError('`metadata` argument not passed')\r\n\t\t}\r\n\t\tif (isObject(nationalNumber) && isObject(nationalNumber.countries)) {\r\n\t\t\tmetadata = nationalNumber\r\n\t\t\tconst e164Number = countryOrCountryCallingCode\r\n\t\t\tif (!E164_NUMBER_REGEXP.test(e164Number)) {\r\n\t\t\t\tthrow new Error('Invalid `number` argument passed: must consist of a \"+\" followed by digits')\r\n\t\t\t}\r\n\t\t\tconst { countryCallingCode, number } = extractCountryCallingCode(e164Number, undefined, undefined, undefined, metadata)\r\n\t\t\tnationalNumber = number\r\n\t\t\tcountryOrCountryCallingCode = countryCallingCode\r\n\t\t\tif (!nationalNumber) {\r\n\t\t\t\tthrow new Error('Invalid `number` argument passed: too short')\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Validate `nationalNumber` argument.\r\n\t\tif (!nationalNumber) {\r\n\t\t\tthrow new TypeError('`nationalNumber` argument is required')\r\n\t\t}\r\n\t\tif (typeof nationalNumber !== 'string') {\r\n\t\t\tthrow new TypeError('`nationalNumber` argument must be a string')\r\n\t\t}\r\n\r\n\t\t// Validate `metadata` argument.\r\n\t\tvalidateMetadata(metadata)\r\n\r\n\t\t// Initialize properties.\r\n\t\tconst { country, countryCallingCode } = getCountryAndCountryCallingCode(\r\n\t\t\tcountryOrCountryCallingCode,\r\n\t\t\tmetadata\r\n\t\t)\r\n\t\tthis.country = country\r\n\t\tthis.countryCallingCode = countryCallingCode\r\n\t\tthis.nationalNumber = nationalNumber\r\n\t\tthis.number = '+' + this.countryCallingCode + this.nationalNumber\r\n\t\t// Exclude `metadata` property output from `PhoneNumber.toString()`\r\n\t\t// so that it doesn't clutter the console output of Node.js.\r\n\t\t// Previously, when Node.js did `console.log(new PhoneNumber(...))`,\r\n\t\t// it would output the whole internal structure of the `metadata` object.\r\n\t\tthis.getMetadata = () => metadata\r\n\t}\r\n\r\n\tsetExt(ext) {\r\n\t\tthis.ext = ext\r\n\t}\r\n\r\n\tgetPossibleCountries() {\r\n\t\tif (this.country) {\r\n\t\t\treturn [this.country]\r\n\t\t}\r\n\t\treturn getPossibleCountriesForNumber(\r\n\t\t\tthis.countryCallingCode,\r\n\t\t\tthis.nationalNumber,\r\n\t\t\tthis.getMetadata()\r\n\t\t)\r\n\t}\r\n\r\n\tisPossible() {\r\n\t\treturn isPossibleNumber(this, { v2: true }, this.getMetadata())\r\n\t}\r\n\r\n\tisValid() {\r\n\t\treturn isValidNumber(this, { v2: true }, this.getMetadata())\r\n\t}\r\n\r\n\tisNonGeographic() {\r\n\t\tconst metadata = new Metadata(this.getMetadata())\r\n\t\treturn metadata.isNonGeographicCallingCode(this.countryCallingCode)\r\n\t}\r\n\r\n\tisEqual(phoneNumber) {\r\n\t\treturn this.number === phoneNumber.number && this.ext === phoneNumber.ext\r\n\t}\r\n\r\n\t// This function was originally meant to be an equivalent for `validatePhoneNumberLength()`,\r\n\t// but later it was found out that it doesn't include the possible `TOO_SHORT` result\r\n\t// returned from `parsePhoneNumberWithError()` in the original `validatePhoneNumberLength()`,\r\n\t// so eventually I simply commented out this method from the `PhoneNumber` class\r\n\t// and just left the `validatePhoneNumberLength()` function, even though that one would require\r\n\t// and additional step to also validate the actual country / calling code of the phone number.\r\n\t// validateLength() {\r\n\t// \tconst metadata = new Metadata(this.getMetadata())\r\n\t// \tmetadata.selectNumberingPlan(this.countryCallingCode)\r\n\t// \tconst result = checkNumberLength(this.nationalNumber, metadata)\r\n\t// \tif (result !== 'IS_POSSIBLE') {\r\n\t// \t\treturn result\r\n\t// \t}\r\n\t// }\r\n\r\n\tgetType() {\r\n\t\treturn getNumberType(this, { v2: true }, this.getMetadata())\r\n\t}\r\n\r\n\tformat(format, options) {\r\n\t\treturn formatNumber(\r\n\t\t\tthis,\r\n\t\t\tformat,\r\n\t\t\toptions ? { ...options, v2: true } : { v2: true },\r\n\t\t\tthis.getMetadata()\r\n\t\t)\r\n\t}\r\n\r\n\tformatNational(options) {\r\n\t\treturn this.format('NATIONAL', options)\r\n\t}\r\n\r\n\tformatInternational(options) {\r\n\t\treturn this.format('INTERNATIONAL', options)\r\n\t}\r\n\r\n\tgetURI(options) {\r\n\t\treturn this.format('RFC3966', options)\r\n\t}\r\n}\r\n\r\nconst isCountryCode = (value) => /^[A-Z]{2}$/.test(value)\r\n\r\nfunction getCountryAndCountryCallingCode(countryOrCountryCallingCode, metadataJson) {\r\n\tlet country\r\n\tlet countryCallingCode\r\n\r\n\tconst metadata = new Metadata(metadataJson)\r\n\t// If country code is passed then derive `countryCallingCode` from it.\r\n\t// Also store the country code as `.country`.\r\n\tif (isCountryCode(countryOrCountryCallingCode)) {\r\n\t\tcountry = countryOrCountryCallingCode\r\n\t\tmetadata.selectNumberingPlan(country)\r\n\t\tcountryCallingCode = metadata.countryCallingCode()\r\n\t} else {\r\n\t\tcountryCallingCode = countryOrCountryCallingCode\r\n\t\t/* istanbul ignore if */\r\n\t\tif (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\r\n\t\t\tif (metadata.isNonGeographicCallingCode(countryCallingCode)) {\r\n\t\t\t\tcountry = '001'\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\treturn {\r\n\t\tcountry,\r\n\t\tcountryCallingCode\r\n\t}\r\n}\r\n\r\nconst E164_NUMBER_REGEXP = /^\\+\\d+$/","import { VALID_DIGITS } from '../../constants.js'\r\n\r\n// The RFC 3966 format for extensions.\r\nconst RFC3966_EXTN_PREFIX = ';ext='\r\n\r\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 */\r\nconst getExtensionDigitsPattern = (maxLength) => `([${VALID_DIGITS}]{1,${maxLength}})`\r\n\r\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 */\r\nexport default function createExtensionPattern(purpose) {\r\n\t// We cap the maximum length of an extension based on the ambiguity of the way\r\n\t// the extension is prefixed. As per ITU, the officially allowed length for\r\n\t// extensions is actually 40, but we don't support this since we haven't seen real\r\n\t// examples and this introduces many false interpretations as the extension labels\r\n\t// are not standardized.\r\n\t/** @type {string} */\r\n\tvar extLimitAfterExplicitLabel = '20';\r\n\t/** @type {string} */\r\n\tvar extLimitAfterLikelyLabel = '15';\r\n\t/** @type {string} */\r\n\tvar extLimitAfterAmbiguousChar = '9';\r\n\t/** @type {string} */\r\n\tvar extLimitWhenNotSure = '6';\r\n\r\n\t/** @type {string} */\r\n\tvar possibleSeparatorsBetweenNumberAndExtLabel = \"[ \\u00A0\\\\t,]*\";\r\n\t// Optional full stop (.) or colon, followed by zero or more spaces/tabs/commas.\r\n\t/** @type {string} */\r\n\tvar possibleCharsAfterExtLabel = \"[:\\\\.\\uFF0E]?[ \\u00A0\\\\t,-]*\";\r\n\t/** @type {string} */\r\n\tvar optionalExtnSuffix = \"#?\";\r\n\r\n\t// Here the extension is called out in more explicit way, i.e mentioning it obvious\r\n\t// patterns like \"ext.\".\r\n\t/** @type {string} */\r\n\tvar explicitExtLabels =\r\n\t  \"(?:e?xt(?:ensi(?:o\\u0301?|\\u00F3))?n?|\\uFF45?\\uFF58\\uFF54\\uFF4E?|\\u0434\\u043E\\u0431|anexo)\";\r\n\t// One-character symbols that can be used to indicate an extension, and less\r\n\t// commonly used or more ambiguous extension labels.\r\n\t/** @type {string} */\r\n\tvar ambiguousExtLabels = \"(?:[x\\uFF58#\\uFF03~\\uFF5E]|int|\\uFF49\\uFF4E\\uFF54)\";\r\n\t// When extension is not separated clearly.\r\n\t/** @type {string} */\r\n\tvar ambiguousSeparator = \"[- ]+\";\r\n\t// This is the same as possibleSeparatorsBetweenNumberAndExtLabel, but not matching\r\n\t// comma as extension label may have it.\r\n\t/** @type {string} */\r\n\tvar possibleSeparatorsNumberExtLabelNoComma = \"[ \\u00A0\\\\t]*\";\r\n\t// \",,\" is commonly used for auto dialling the extension when connected. First\r\n\t// comma is matched through possibleSeparatorsBetweenNumberAndExtLabel, so we do\r\n\t// not repeat it here. Semi-colon works in Iphone and Android also to pop up a\r\n\t// button with the extension number following.\r\n\t/** @type {string} */\r\n\tvar autoDiallingAndExtLabelsFound = \"(?:,{2}|;)\";\r\n\r\n\t/** @type {string} */\r\n\tvar rfcExtn = RFC3966_EXTN_PREFIX\r\n\t     + getExtensionDigitsPattern(extLimitAfterExplicitLabel);\r\n\t/** @type {string} */\r\n\tvar explicitExtn = possibleSeparatorsBetweenNumberAndExtLabel + explicitExtLabels\r\n\t     + possibleCharsAfterExtLabel\r\n\t     + getExtensionDigitsPattern(extLimitAfterExplicitLabel)\r\n\t     + optionalExtnSuffix;\r\n\t/** @type {string} */\r\n\tvar ambiguousExtn = possibleSeparatorsBetweenNumberAndExtLabel + ambiguousExtLabels\r\n\t     + possibleCharsAfterExtLabel\r\n\t+ getExtensionDigitsPattern(extLimitAfterAmbiguousChar)\r\n\t+ optionalExtnSuffix;\r\n\t/** @type {string} */\r\n\tvar americanStyleExtnWithSuffix = ambiguousSeparator\r\n\t+ getExtensionDigitsPattern(extLimitWhenNotSure) + \"#\";\r\n\r\n\t/** @type {string} */\r\n\tvar autoDiallingExtn = possibleSeparatorsNumberExtLabelNoComma\r\n\t     + autoDiallingAndExtLabelsFound + possibleCharsAfterExtLabel\r\n\t     + getExtensionDigitsPattern(extLimitAfterLikelyLabel)\r\n\t+ optionalExtnSuffix;\r\n\t/** @type {string} */\r\n\tvar onlyCommasExtn = possibleSeparatorsNumberExtLabelNoComma\r\n\t    + \"(?:,)+\" + possibleCharsAfterExtLabel\r\n\t    + getExtensionDigitsPattern(extLimitAfterAmbiguousChar)\r\n\t    + optionalExtnSuffix;\r\n\r\n\t// The first regular expression covers RFC 3966 format, where the extension is added\r\n\t// using \";ext=\". The second more generic where extension is mentioned with explicit\r\n\t// labels like \"ext:\". In both the above cases we allow more numbers in extension than\r\n\t// any other extension labels. The third one captures when single character extension\r\n\t// labels or less commonly used labels are used. In such cases we capture fewer\r\n\t// extension digits in order to reduce the chance of falsely interpreting two\r\n\t// numbers beside each other as a number + extension. The fourth one covers the\r\n\t// special case of American numbers where the extension is written with a hash\r\n\t// at the end, such as \"- 503#\". The fifth one is exclusively for extension\r\n\t// autodialling formats which are used when dialling and in this case we accept longer\r\n\t// extensions. The last one is more liberal on the number of commas that acts as\r\n\t// extension labels, so we have a strict cap on the number of digits in such extensions.\r\n\treturn rfcExtn + \"|\"\r\n\t       + explicitExtn + \"|\"\r\n\t       + ambiguousExtn + \"|\"\r\n\t       + americanStyleExtnWithSuffix + \"|\"\r\n\t       + autoDiallingExtn + \"|\"\r\n\t       + onlyCommasExtn;\r\n}","import PhoneNumberMatcher from '../PhoneNumberMatcher.js'\r\nimport normalizeArguments from '../normalizeArguments.js'\r\n\r\nexport default function findNumbers() {\r\n\tconst { text, options, metadata } = normalizeArguments(arguments)\r\n\tconst matcher = new PhoneNumberMatcher(text, options, metadata)\r\n\tconst results = []\r\n\twhile (matcher.hasNext()) {\r\n\t\tresults.push(matcher.next())\r\n\t}\r\n\treturn results\r\n}","import parsePhoneNumberWithError_ from './parsePhoneNumberWithError_.js'\r\nimport normalizeArguments from './normalizeArguments.js'\r\n\r\nexport default function parsePhoneNumberWithError() {\r\n\tconst { text, options, metadata } = normalizeArguments(arguments)\r\n\treturn parsePhoneNumberWithError_(text, options, metadata)\r\n}","import Metadata from '../metadata.js'\r\nimport { VALID_DIGITS } from '../constants.js'\r\n\r\nconst CAPTURING_DIGIT_PATTERN = new RegExp('([' + VALID_DIGITS + '])')\r\n\r\nexport default function stripIddPrefix(number, country, callingCode, metadata) {\r\n\tif (!country) {\r\n\t\treturn\r\n\t}\r\n\t// Check if the number is IDD-prefixed.\r\n\tconst countryMetadata = new Metadata(metadata)\r\n\tcountryMetadata.selectNumberingPlan(country, callingCode)\r\n\tconst IDDPrefixPattern = new RegExp(countryMetadata.IDDPrefix())\r\n\tif (number.search(IDDPrefixPattern) !== 0) {\r\n\t\treturn\r\n\t}\r\n\t// Strip IDD prefix.\r\n\tnumber = number.slice(number.match(IDDPrefixPattern)[0].length)\r\n\t// If there're any digits after an IDD prefix,\r\n\t// then those digits are a country calling code.\r\n\t// Since no country code starts with a `0`,\r\n\t// the code below validates that the next digit (if present) is not `0`.\r\n\tconst matchedGroups = number.match(CAPTURING_DIGIT_PATTERN)\r\n\tif (matchedGroups && matchedGroups[1] != null && matchedGroups[1].length > 0) {\r\n\t\tif (matchedGroups[1] === '0') {\r\n\t\t\treturn\r\n\t\t}\r\n\t}\r\n\treturn number\r\n}","import createExtensionPattern from './createExtensionPattern.js'\r\n\r\n// Regexp of all known extension prefixes used by different regions followed by\r\n// 1 or more valid digits, for use when parsing.\r\nconst EXTN_PATTERN = new RegExp('(?:' + createExtensionPattern() + ')$', 'i')\r\n\r\n// Strips any extension (as in, the part of the number dialled after the call is\r\n// connected, usually indicated with extn, ext, x or similar) from the end of\r\n// the number, and returns it.\r\nexport default function extractExtension(number) {\r\n\tconst start = number.search(EXTN_PATTERN)\r\n\tif (start < 0) {\r\n\t\treturn {}\r\n\t}\r\n\t// If we find a potential extension, and the number preceding this is a viable\r\n\t// number, we assume it is an extension.\r\n\tconst numberWithoutExtension = number.slice(0, start)\r\n\tconst matches = number.match(EXTN_PATTERN)\r\n\tlet i = 1\r\n\twhile (i < matches.length) {\r\n\t\tif (matches[i]) {\r\n\t\t\treturn {\r\n\t\t\t\tnumber: numberWithoutExtension,\r\n\t\t\t\text: matches[i]\r\n\t\t\t}\r\n\t\t}\r\n\t\ti++\r\n\t}\r\n}","// When phone numbers are written in `RFC3966` format — `\"tel:+12133734253\"` —\r\n// they can have their \"calling code\" part written separately in a `phone-context` parameter.\r\n// Example: `\"tel:12133734253;phone-context=+1\"`.\r\n// This function parses the full phone number from the local number and the `phone-context`\r\n// when the `phone-context` contains a `+` sign.\r\n\r\nimport {\r\n  VALID_DIGITS,\r\n  // PLUS_CHARS\r\n} from '../constants.js'\r\n\r\nexport const PLUS_SIGN = '+'\r\n\r\nconst RFC3966_VISUAL_SEPARATOR_ = '[\\\\-\\\\.\\\\(\\\\)]?'\r\n\r\nconst RFC3966_PHONE_DIGIT_ = '(' + '[' + VALID_DIGITS + ']' + '|' + RFC3966_VISUAL_SEPARATOR_ + ')'\r\n\r\nconst RFC3966_GLOBAL_NUMBER_DIGITS_ =\r\n\t'^' +\r\n\t'\\\\' +\r\n\tPLUS_SIGN +\r\n\tRFC3966_PHONE_DIGIT_ +\r\n\t'*' +\r\n\t'[' + VALID_DIGITS +  ']' +\r\n\tRFC3966_PHONE_DIGIT_ +\r\n\t'*' +\r\n\t'$'\r\n\r\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 */\r\nconst RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_ = new RegExp(RFC3966_GLOBAL_NUMBER_DIGITS_, 'g')\r\n\r\n// In this port of Google's library, we don't accept alpha characters in phone numbers.\r\n// const ALPHANUM_ = VALID_ALPHA_ + VALID_DIGITS\r\nconst ALPHANUM_ = VALID_DIGITS\r\n\r\nconst RFC3966_DOMAINLABEL_ = '[' + ALPHANUM_ + ']+((\\\\-)*[' + ALPHANUM_ + '])*'\r\n\r\nconst VALID_ALPHA_ = 'a-zA-Z'\r\nconst RFC3966_TOPLABEL_ = '[' + VALID_ALPHA_ + ']+((\\\\-)*[' + ALPHANUM_ + '])*'\r\n\r\nconst RFC3966_DOMAINNAME_ = '^(' + RFC3966_DOMAINLABEL_ + '\\\\.)*' + RFC3966_TOPLABEL_ + '\\\\.?$'\r\n\r\n/**\r\n * Regular expression of valid domainname for the phone-context parameter,\r\n * following the syntax defined in RFC3966.\r\n */\r\nconst RFC3966_DOMAINNAME_PATTERN_ = new RegExp(RFC3966_DOMAINNAME_, 'g')\r\n\r\nexport const RFC3966_PREFIX_ = 'tel:'\r\nexport const RFC3966_PHONE_CONTEXT_ = ';phone-context='\r\nexport const RFC3966_ISDN_SUBADDRESS_ = ';isub='\r\n\r\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 */\r\nexport default function extractPhoneContext(numberToExtractFrom) {\r\n\tconst indexOfPhoneContext = numberToExtractFrom.indexOf(RFC3966_PHONE_CONTEXT_)\r\n\t// If no phone-context parameter is present\r\n\tif (indexOfPhoneContext < 0) {\r\n\t\treturn null\r\n\t}\r\n\r\n\tconst phoneContextStart = indexOfPhoneContext + RFC3966_PHONE_CONTEXT_.length\r\n\t// If phone-context parameter is empty\r\n\tif (phoneContextStart >= numberToExtractFrom.length) {\r\n\t\treturn ''\r\n\t}\r\n\r\n\tconst phoneContextEnd = numberToExtractFrom.indexOf(';', phoneContextStart)\r\n\t// If phone-context is not the last parameter\r\n\tif (phoneContextEnd >= 0) {\r\n\t\treturn numberToExtractFrom.substring(phoneContextStart, phoneContextEnd)\r\n\t} else {\r\n\t\treturn numberToExtractFrom.substring(phoneContextStart)\r\n\t}\r\n}\r\n\r\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 */\r\nexport function isPhoneContextValid(phoneContext) {\r\n\tif (phoneContext === null) {\r\n\t\treturn true\r\n\t}\r\n\r\n\tif (phoneContext.length === 0) {\r\n\t\treturn false\r\n\t}\r\n\r\n\t// Does phone-context value match pattern of global-number-digits or domainname.\r\n\treturn RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_.test(phoneContext) ||\r\n\t\tRFC3966_DOMAINNAME_PATTERN_.test(phoneContext)\r\n}","import extractPhoneContext, {\r\n\tisPhoneContextValid,\r\n\tPLUS_SIGN,\r\n\tRFC3966_PREFIX_,\r\n\tRFC3966_PHONE_CONTEXT_,\r\n\tRFC3966_ISDN_SUBADDRESS_\r\n} from './extractPhoneContext.js'\r\n\r\nimport ParseError from '../ParseError.js'\r\n\r\n/**\r\n * @param  {string} numberToParse\r\n * @param  {string} nationalNumber\r\n * @return {}\r\n */\r\nexport default function extractFormattedPhoneNumberFromPossibleRfc3966NumberUri(numberToParse, {\r\n\textractFormattedPhoneNumber\r\n}) {\r\n\tconst phoneContext = extractPhoneContext(numberToParse)\r\n\tif (!isPhoneContextValid(phoneContext)) {\r\n\t\tthrow new ParseError('NOT_A_NUMBER')\r\n\t}\r\n\r\n\tlet phoneNumberString\r\n\r\n\tif (phoneContext === null) {\r\n\t\t// Extract a possible number from the string passed in.\r\n\t\t// (this strips leading characters that could not be the start of a phone number)\r\n\t\tphoneNumberString = extractFormattedPhoneNumber(numberToParse) || ''\r\n\t} else {\r\n\t\tphoneNumberString = ''\r\n\r\n\t\t// If the phone context contains a phone number prefix, we need to capture\r\n\t\t// it, whereas domains will be ignored.\r\n\t\tif (phoneContext.charAt(0) === PLUS_SIGN) {\r\n\t\t\tphoneNumberString += phoneContext\r\n\t\t}\r\n\r\n\t\t// Now append everything between the \"tel:\" prefix and the phone-context.\r\n\t\t// This should include the national number, an optional extension or\r\n\t\t// isdn-subaddress component. Note we also handle the case when \"tel:\" is\r\n\t\t// missing, as we have seen in some of the phone number inputs.\r\n\t\t// In that case, we append everything from the beginning.\r\n\t\tconst indexOfRfc3966Prefix = numberToParse.indexOf(RFC3966_PREFIX_)\r\n\t\tlet indexOfNationalNumber\r\n\t\t// RFC 3966 \"tel:\" prefix is preset at this stage because\r\n\t\t// `isPhoneContextValid()` requires it to be present.\r\n\t\t/* istanbul ignore else */\r\n\t\tif (indexOfRfc3966Prefix >= 0) {\r\n\t\t\tindexOfNationalNumber = indexOfRfc3966Prefix + RFC3966_PREFIX_.length\r\n\t\t} else {\r\n\t\t\tindexOfNationalNumber = 0\r\n\t\t}\r\n\t\tconst indexOfPhoneContext = numberToParse.indexOf(RFC3966_PHONE_CONTEXT_)\r\n\t\tphoneNumberString += numberToParse.substring(indexOfNationalNumber, indexOfPhoneContext)\r\n\t}\r\n\r\n\t// Delete the isdn-subaddress and everything after it if it is present.\r\n\t// Note extension won't appear at the same time with isdn-subaddress\r\n\t// according to paragraph 5.3 of the RFC3966 spec.\r\n\tconst indexOfIsdn = phoneNumberString.indexOf(RFC3966_ISDN_SUBADDRESS_)\r\n\tif (indexOfIsdn > 0) {\r\n\t\tphoneNumberString = phoneNumberString.substring(0, indexOfIsdn)\r\n\t}\r\n\t// If both phone context and isdn-subaddress are absent but other\r\n\t// parameters are present, the parameters are left in nationalNumber.\r\n\t// This is because we are concerned about deleting content from a potential\r\n\t// number string when there is no strong evidence that the number is\r\n\t// actually written in RFC3966.\r\n\r\n\tif (phoneNumberString !== '') {\r\n\t\treturn phoneNumberString\r\n\t}\r\n}","// This is a port of Google Android `libphonenumber`'s\r\n// `phonenumberutil.js` of December 31th, 2018.\r\n//\r\n// https://github.com/googlei18n/libphonenumber/commits/master/javascript/i18n/phonenumbers/phonenumberutil.js\r\n\r\nimport {\r\n\tVALID_DIGITS,\r\n\tPLUS_CHARS,\r\n\tMIN_LENGTH_FOR_NSN,\r\n\tMAX_LENGTH_FOR_NSN\r\n} from './constants.js'\r\n\r\nimport ParseError from './ParseError.js'\r\nimport Metadata from './metadata.js'\r\nimport isViablePhoneNumber, { isViablePhoneNumberStart } from './helpers/isViablePhoneNumber.js'\r\nimport extractExtension from './helpers/extension/extractExtension.js'\r\nimport parseIncompletePhoneNumber from './parseIncompletePhoneNumber.js'\r\nimport getCountryCallingCode from './getCountryCallingCode.js'\r\nimport { isPossibleNumber } from './isPossible.js'\r\n// import { parseRFC3966 } from './helpers/RFC3966.js'\r\nimport PhoneNumber from './PhoneNumber.js'\r\nimport matchesEntirely from './helpers/matchesEntirely.js'\r\nimport extractCountryCallingCode from './helpers/extractCountryCallingCode.js'\r\nimport extractNationalNumber from './helpers/extractNationalNumber.js'\r\nimport stripIddPrefix from './helpers/stripIddPrefix.js'\r\nimport getCountryByCallingCode from './helpers/getCountryByCallingCode.js'\r\nimport extractFormattedPhoneNumberFromPossibleRfc3966NumberUri from './helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js'\r\n\r\n// We don't allow input strings for parsing to be longer than 250 chars.\r\n// This prevents malicious input from consuming CPU.\r\nconst MAX_INPUT_STRING_LENGTH = 250\r\n\r\n// This consists of the plus symbol, digits, and arabic-indic digits.\r\nconst PHONE_NUMBER_START_PATTERN = new RegExp('[' + PLUS_CHARS + VALID_DIGITS + ']')\r\n\r\n// Regular expression of trailing characters that we want to remove.\r\n// A trailing `#` is sometimes used when writing phone numbers with extensions in US.\r\n// Example: \"+1 (645) 123 1234-910#\" number has extension \"910\".\r\nconst AFTER_PHONE_NUMBER_END_PATTERN = new RegExp('[^' + VALID_DIGITS + '#' + ']+$')\r\n\r\nconst USE_NON_GEOGRAPHIC_COUNTRY_CODE = false\r\n\r\n// Examples:\r\n//\r\n// ```js\r\n// parse('8 (800) 555-35-35', 'RU')\r\n// parse('8 (800) 555-35-35', 'RU', metadata)\r\n// parse('8 (800) 555-35-35', { country: { default: 'RU' } })\r\n// parse('8 (800) 555-35-35', { country: { default: 'RU' } }, metadata)\r\n// parse('+7 800 555 35 35')\r\n// parse('+7 800 555 35 35', metadata)\r\n// ```\r\n//\r\n\r\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 */\r\nexport default function parse(text, options, metadata) {\r\n\t// If assigning the `{}` default value is moved to the arguments above,\r\n\t// code coverage would decrease for some weird reason.\r\n\toptions = options || {}\r\n\r\n\tmetadata = new Metadata(metadata)\r\n\r\n\t// Validate `defaultCountry`.\r\n\tif (options.defaultCountry && !metadata.hasCountry(options.defaultCountry)) {\r\n\t\tif (options.v2) {\r\n\t\t\tthrow new ParseError('INVALID_COUNTRY')\r\n\t\t}\r\n\t\tthrow new Error(`Unknown country: ${options.defaultCountry}`)\r\n\t}\r\n\r\n\t// Parse the phone number.\r\n\tconst { number: formattedPhoneNumber, ext, error } = parseInput(text, options.v2, options.extract)\r\n\r\n\t// If the phone number is not viable then return nothing.\r\n\tif (!formattedPhoneNumber) {\r\n\t\tif (options.v2) {\r\n\t\t\tif (error === 'TOO_SHORT') {\r\n\t\t\t\tthrow new ParseError('TOO_SHORT')\r\n\t\t\t}\r\n\t\t\tthrow new ParseError('NOT_A_NUMBER')\r\n\t\t}\r\n\t\treturn {}\r\n\t}\r\n\r\n\tconst {\r\n\t\tcountry,\r\n\t\tnationalNumber,\r\n\t\tcountryCallingCode,\r\n\t\tcountryCallingCodeSource,\r\n\t\tcarrierCode\r\n\t} = parsePhoneNumber(\r\n\t\tformattedPhoneNumber,\r\n\t\toptions.defaultCountry,\r\n\t\toptions.defaultCallingCode,\r\n\t\tmetadata\r\n\t)\r\n\r\n\tif (!metadata.hasSelectedNumberingPlan()) {\r\n\t\tif (options.v2) {\r\n\t\t\tthrow new ParseError('INVALID_COUNTRY')\r\n\t\t}\r\n\t\treturn {}\r\n\t}\r\n\r\n\t// Validate national (significant) number length.\r\n\tif (!nationalNumber || nationalNumber.length < MIN_LENGTH_FOR_NSN) {\r\n\t\t// Won't throw here because the regexp already demands length > 1.\r\n\t\t/* istanbul ignore if */\r\n\t\tif (options.v2) {\r\n\t\t\tthrow new ParseError('TOO_SHORT')\r\n\t\t}\r\n\t\t// Google's demo just throws an error in this case.\r\n\t\treturn {}\r\n\t}\r\n\r\n\t// Validate national (significant) number length.\r\n\t//\r\n\t// A sidenote:\r\n\t//\r\n\t// They say that sometimes national (significant) numbers\r\n\t// can be longer than `MAX_LENGTH_FOR_NSN` (e.g. in Germany).\r\n\t// https://github.com/googlei18n/libphonenumber/blob/7e1748645552da39c4e1ba731e47969d97bdb539/resources/phonenumber.proto#L36\r\n\t// Such numbers will just be discarded.\r\n\t//\r\n\tif (nationalNumber.length > MAX_LENGTH_FOR_NSN) {\r\n\t\tif (options.v2) {\r\n\t\t\tthrow new ParseError('TOO_LONG')\r\n\t\t}\r\n\t\t// Google's demo just throws an error in this case.\r\n\t\treturn {}\r\n\t}\r\n\r\n\tif (options.v2) {\r\n\t\tconst phoneNumber = new PhoneNumber(\r\n\t\t\tcountryCallingCode,\r\n\t\t\tnationalNumber,\r\n\t\t\tmetadata.metadata\r\n\t\t)\r\n\t\tif (country) {\r\n\t\t\tphoneNumber.country = country\r\n\t\t}\r\n\t\tif (carrierCode) {\r\n\t\t\tphoneNumber.carrierCode = carrierCode\r\n\t\t}\r\n\t\tif (ext) {\r\n\t\t\tphoneNumber.ext = ext\r\n\t\t}\r\n\t\tphoneNumber.__countryCallingCodeSource = countryCallingCodeSource\r\n\t\treturn phoneNumber\r\n\t}\r\n\r\n\t// Check if national phone number pattern matches the number.\r\n\t// National number pattern is different for each country,\r\n\t// even for those ones which are part of the \"NANPA\" group.\r\n\tconst valid = (options.extended ? metadata.hasSelectedNumberingPlan() : country) ?\r\n\t\tmatchesEntirely(nationalNumber, metadata.nationalNumberPattern()) :\r\n\t\tfalse\r\n\r\n\tif (!options.extended) {\r\n\t\treturn valid ? result(country, nationalNumber, ext) : {}\r\n\t}\r\n\r\n\t// isInternational: countryCallingCode !== undefined\r\n\r\n\treturn {\r\n\t\tcountry,\r\n\t\tcountryCallingCode,\r\n\t\tcarrierCode,\r\n\t\tvalid,\r\n\t\tpossible: valid ? true : (\r\n\t\t\toptions.extended === true &&\r\n\t\t\tmetadata.possibleLengths() &&\r\n\t\t\tisPossibleNumber(nationalNumber, country, metadata) ? true : false\r\n\t\t),\r\n\t\tphone: nationalNumber,\r\n\t\text\r\n\t}\r\n}\r\n\r\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 */\r\nfunction extractFormattedPhoneNumber(text, extract, throwOnError) {\r\n\tif (!text) {\r\n\t\treturn\r\n\t}\r\n\tif (text.length > MAX_INPUT_STRING_LENGTH) {\r\n\t\tif (throwOnError) {\r\n\t\t\tthrow new ParseError('TOO_LONG')\r\n\t\t}\r\n\t\treturn\r\n\t}\r\n\tif (extract === false) {\r\n\t\treturn text\r\n\t}\r\n\t// Attempt to extract a possible number from the string passed in\r\n\tconst startsAt = text.search(PHONE_NUMBER_START_PATTERN)\r\n\tif (startsAt < 0) {\r\n\t\treturn\r\n\t}\r\n\treturn text\r\n\t\t// Trim everything to the left of the phone number\r\n\t\t.slice(startsAt)\r\n\t\t// Remove trailing non-numerical characters\r\n\t\t.replace(AFTER_PHONE_NUMBER_END_PATTERN, '')\r\n}\r\n\r\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 */\r\nfunction parseInput(text, v2, extract) {\r\n\t// // Parse RFC 3966 phone number URI.\r\n\t// if (text && text.indexOf('tel:') === 0) {\r\n\t// \treturn parseRFC3966(text)\r\n\t// }\r\n\t// let number = extractFormattedPhoneNumber(text, extract, v2)\r\n\tlet number = extractFormattedPhoneNumberFromPossibleRfc3966NumberUri(text, {\r\n\t\textractFormattedPhoneNumber: (text) => extractFormattedPhoneNumber(text, extract, v2)\r\n\t})\r\n\t// If the phone number is not viable, then abort.\r\n\tif (!number) {\r\n\t\treturn {}\r\n\t}\r\n\tif (!isViablePhoneNumber(number)) {\r\n\t\tif (isViablePhoneNumberStart(number)) {\r\n\t\t\treturn { error: 'TOO_SHORT' }\r\n\t\t}\r\n\t\treturn {}\r\n\t}\r\n\t// Attempt to parse extension first, since it doesn't require region-specific\r\n\t// data and we want to have the non-normalised number here.\r\n\tconst withExtensionStripped = extractExtension(number)\r\n\tif (withExtensionStripped.ext) {\r\n\t\treturn withExtensionStripped\r\n\t}\r\n\treturn { number }\r\n}\r\n\r\n/**\r\n * Creates `parse()` result object.\r\n */\r\nfunction result(country, nationalNumber, ext) {\r\n\tconst result = {\r\n\t\tcountry,\r\n\t\tphone: nationalNumber\r\n\t}\r\n\tif (ext) {\r\n\t\tresult.ext = ext\r\n\t}\r\n\treturn result\r\n}\r\n\r\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 */\r\nfunction parsePhoneNumber(\r\n\tformattedPhoneNumber,\r\n\tdefaultCountry,\r\n\tdefaultCallingCode,\r\n\tmetadata\r\n) {\r\n\t// Extract calling code from phone number.\r\n\tlet { countryCallingCodeSource, countryCallingCode, number } = extractCountryCallingCode(\r\n\t\tparseIncompletePhoneNumber(formattedPhoneNumber),\r\n\t\tundefined,\r\n\t\tdefaultCountry,\r\n\t\tdefaultCallingCode,\r\n\t\tmetadata.metadata\r\n\t)\r\n\r\n\t// The exact country of the phone number\r\n\tlet country\r\n\r\n\t// If `formattedPhoneNumber` is passed in \"international\" format,\r\n\t// choose a country by `countryCallingCode`.\r\n\tif (countryCallingCode) {\r\n\t\tmetadata.selectNumberingPlan(countryCallingCode)\r\n\t}\r\n\t// Else, if `formattedPhoneNumber` is passed in \"national\" format,\r\n\t// then `number` is defined and `countryCallingCode` is `undefined`.\r\n\telse if (number && (defaultCountry || defaultCallingCode)) {\r\n\t\tmetadata.selectNumberingPlan(defaultCountry, defaultCallingCode)\r\n\t\tif (defaultCountry) {\r\n\t\t\tcountry = defaultCountry\r\n\t\t} else {\r\n\t\t\t/* istanbul ignore if */\r\n\t\t\tif (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\r\n\t\t\t\tif (metadata.isNonGeographicCallingCode(defaultCallingCode)) {\r\n\t\t\t\t\tcountry = '001'\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tcountryCallingCode = defaultCallingCode || getCountryCallingCode(defaultCountry, metadata.metadata)\r\n\t}\r\n\telse return {}\r\n\r\n\tif (!number) {\r\n\t\treturn {\r\n\t\t\tcountryCallingCodeSource,\r\n\t\t\tcountryCallingCode\r\n\t\t}\r\n\t}\r\n\r\n\tconst {\r\n\t\tnationalNumber,\r\n\t\tcarrierCode\r\n\t} = extractNationalNumber(\r\n\t\tparseIncompletePhoneNumber(number),\r\n\t\tcountry,\r\n\t\tmetadata\r\n\t)\r\n\r\n\t// Sometimes there are several countries\r\n\t// corresponding to the same country phone code\r\n\t// (e.g. NANPA countries all having `1` country phone code).\r\n\t// Therefore, to reliably determine the exact country,\r\n\t// national (significant) number should have been parsed first.\r\n\t//\r\n\t// When `metadata.json` is generated, all \"ambiguous\" country phone codes\r\n\t// get their countries populated with the full set of\r\n\t// \"phone number type\" regular expressions.\r\n\t//\r\n\tconst exactCountry = getCountryByCallingCode(countryCallingCode, {\r\n\t\tnationalNumber,\r\n\t\tmetadata\r\n\t})\r\n\tif (exactCountry) {\r\n\t\tcountry = exactCountry\r\n\t\t/* istanbul ignore if */\r\n\t\tif (exactCountry === '001') {\r\n\t\t\t// Can't happen with `USE_NON_GEOGRAPHIC_COUNTRY_CODE` being `false`.\r\n\t\t\t// If `USE_NON_GEOGRAPHIC_COUNTRY_CODE` is set to `true` for some reason,\r\n\t\t\t// then remove the \"istanbul ignore if\".\r\n\t\t} else {\r\n\t\t\tmetadata.selectNumberingPlan(country)\r\n\t\t}\r\n\t}\r\n\r\n\treturn {\r\n\t\tcountry,\r\n\t\tcountryCallingCode,\r\n\t\tcountryCallingCodeSource,\r\n\t\tnationalNumber,\r\n\t\tcarrierCode\r\n\t}\r\n}","import normalizeArguments from './normalizeArguments.js'\r\nimport parsePhoneNumber from './parsePhoneNumber_.js'\r\n\r\nexport default function isPossiblePhoneNumber() {\r\n\tlet { text, options, metadata } = normalizeArguments(arguments)\r\n\toptions = {\r\n\t\t...options,\r\n\t\textract: false\r\n\t}\r\n\tconst phoneNumber = parsePhoneNumber(text, options, metadata)\r\n\treturn phoneNumber && phoneNumber.isPossible() || false\r\n}","import normalizeArguments from './normalizeArguments.js'\r\nimport parsePhoneNumber_ from './parsePhoneNumber_.js'\r\n\r\nexport default function parsePhoneNumber() {\r\n\tconst { text, options, metadata } = normalizeArguments(arguments)\r\n\treturn parsePhoneNumber_(text, options, metadata)\r\n}\r\n","import Metadata from '../metadata.js'\r\nimport mergeArrays from './mergeArrays.js'\r\n\r\nexport default function checkNumberLength(nationalNumber, country, metadata) {\r\n\treturn checkNumberLengthForType(nationalNumber, country, undefined, metadata)\r\n}\r\n\r\n// Checks whether a number is possible for a certain `country` based on the number length.\r\n//\r\n// This function is not supported by metadata generated with ancient versions of\r\n// `libphonenumber-js` (before version `1.0.18`) which didn't include \"possible lengths\".\r\n//\r\n// There was also a known issue with `checkNumberLength()` function:\r\n// if a number is possible only in a certain `country` among several `countries`\r\n// that share the same \"country calling code\", that function would check\r\n// the possibility of the phone number only in the \"main\" `country` for the \"country calling code\"\r\n// and would not check if it's actually be possible in the speciifc `country`.\r\n//\r\n// For example, \"+1310xxxx\" numbers are valid in Canada.\r\n// However, they are not possible in the US due to being too short.\r\n// Since Canada and the US share the same country calling code — \"+1\" —\r\n// `checkNumberLength()` function used to return not \"IS_POSSIBLE\" for \"+1310xxxx\" numbers.\r\n//\r\n// In such cases, when using \"/max\" metadata, `isValid()` could output `true`\r\n// but at the same time `isPossible()` could output `false`, which was contradictory.\r\n//\r\n// See https://issuetracker.google.com/issues/335892662 for the discusson in Google's issues.\r\n//\r\n// The solution suggested by Google was implemented: an optional `country` argument\r\n// was added to `checkNumberLength()` function. If present, that `country` will be used\r\n// to check phone number length for that specific `country` rather than the \"main\" country\r\n// for the shared \"country calling code\".\r\n//\r\nexport function checkNumberLengthForType(nationalNumber, country, type, metadata) {\r\n\t// If the exact `country` is specified, it's no necessarily already selected in `metadata`.\r\n\t// Most likely, in cases when there're multiple countries corresponding to the same\r\n\t// \"country calling code\", the \"main\" country for that \"country calling code\" will be selected.\r\n\tif (country) {\r\n\t\tmetadata = new Metadata(metadata.metadata)\r\n\t\tmetadata.selectNumberingPlan(country)\r\n\t}\r\n\r\n\tconst type_info = metadata.type(type)\r\n\r\n\t// There should always be \"<possiblePengths/>\" set for every type element.\r\n\t// This is declared in the XML schema.\r\n\t// For size efficiency, where a sub-description (e.g. fixed-line)\r\n\t// has the same \"<possiblePengths/>\" as the \"general description\", this is missing,\r\n\t// so we fall back to the \"general description\". Where no numbers of the type\r\n\t// exist at all, there is one possible length (-1) which is guaranteed\r\n\t// not to match the length of any real phone number.\r\n\tlet possible_lengths = type_info && type_info.possibleLengths() || metadata.possibleLengths()\r\n\t// let local_lengths = type_info && type.possibleLengthsLocal() || metadata.possibleLengthsLocal()\r\n\r\n\t// Metadata before version `1.0.18` didn't contain `possible_lengths`.\r\n\tif (!possible_lengths) {\r\n\t\treturn 'IS_POSSIBLE'\r\n\t}\r\n\r\n\tif (type === 'FIXED_LINE_OR_MOBILE') {\r\n\t\t// No such country in metadata.\r\n\t\t/* istanbul ignore next */\r\n\t\tif (!metadata.type('FIXED_LINE')) {\r\n\t\t\t// The rare case has been encountered where no fixedLine data is available\r\n\t\t\t// (true for some non-geographic entities), so we just check mobile.\r\n\t\t\treturn checkNumberLengthForType(nationalNumber, country, 'MOBILE', metadata)\r\n\t\t}\r\n\r\n\t\tconst mobile_type = metadata.type('MOBILE')\r\n\t\tif (mobile_type) {\r\n\t\t\t// Merge the mobile data in if there was any. \"Concat\" creates a new\r\n\t\t\t// array, it doesn't edit possible_lengths in place, so we don't need a copy.\r\n\t\t\t// Note that when adding the possible lengths from mobile, we have\r\n\t\t\t// to again check they aren't empty since if they are this indicates\r\n\t\t\t// they are the same as the general desc and should be obtained from there.\r\n\t\t\tpossible_lengths = mergeArrays(possible_lengths, mobile_type.possibleLengths())\r\n\t\t\t// The current list is sorted; we need to merge in the new list and\r\n\t\t\t// re-sort (duplicates are okay). Sorting isn't so expensive because\r\n\t\t\t// the lists are very small.\r\n\r\n\t\t\t// if (local_lengths) {\r\n\t\t\t// \tlocal_lengths = mergeArrays(local_lengths, mobile_type.possibleLengthsLocal())\r\n\t\t\t// } else {\r\n\t\t\t// \tlocal_lengths = mobile_type.possibleLengthsLocal()\r\n\t\t\t// }\r\n\t\t}\r\n\t}\r\n\t// If the type doesn't exist then return 'INVALID_LENGTH'.\r\n\telse if (type && !type_info) {\r\n\t\treturn 'INVALID_LENGTH'\r\n\t}\r\n\r\n\tconst actual_length = nationalNumber.length\r\n\r\n\t// In `libphonenumber-js` all \"local-only\" formats are dropped for simplicity.\r\n\t// // This is safe because there is never an overlap beween the possible lengths\r\n\t// // and the local-only lengths; this is checked at build time.\r\n\t// if (local_lengths && local_lengths.indexOf(nationalNumber.length) >= 0)\r\n\t// {\r\n\t// \treturn 'IS_POSSIBLE_LOCAL_ONLY'\r\n\t// }\r\n\r\n\tconst minimum_length = possible_lengths[0]\r\n\r\n\tif (minimum_length === actual_length) {\r\n\t\treturn 'IS_POSSIBLE'\r\n\t}\r\n\r\n\tif (minimum_length > actual_length) {\r\n\t\treturn 'TOO_SHORT'\r\n\t}\r\n\r\n\tif (possible_lengths[possible_lengths.length - 1] < actual_length) {\r\n\t\treturn 'TOO_LONG'\r\n\t}\r\n\r\n\t// We skip the first element since we've already checked it.\r\n\treturn possible_lengths.indexOf(actual_length, 1) >= 0 ? 'IS_POSSIBLE' : 'INVALID_LENGTH'\r\n}","/**\r\n * Merges two arrays.\r\n * @param  {*} a\r\n * @param  {*} b\r\n * @return {*}\r\n */\r\nexport default function mergeArrays(a, b) {\r\n\tconst merged = a.slice()\r\n\r\n\tfor (const element of b) {\r\n\t\tif (a.indexOf(element) < 0) {\r\n\t\t\tmerged.push(element)\r\n\t\t}\r\n\t}\r\n\r\n\treturn merged.sort((a, b) => a - b)\r\n\r\n\t// ES6 version, requires Set polyfill.\r\n\t// let merged = new Set(a)\r\n\t// for (const element of b) {\r\n\t// \tmerged.add(i)\r\n\t// }\r\n\t// return Array.from(merged).sort((a, b) => a - b)\r\n}","import Metadata from '../metadata.js'\r\nimport matchesEntirely from './matchesEntirely.js'\r\nimport extractNationalNumber from './extractNationalNumber.js'\r\nimport checkNumberLength from './checkNumberLength.js'\r\nimport getCountryCallingCode from '../getCountryCallingCode.js'\r\n\r\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] — Exact country of the phone number.\r\n * @param  {string} [defaultCountry]\r\n * @param  {string} [defaultCallingCode]\r\n * @param  {object} metadata\r\n * @return {object} `{ countryCallingCode: string?, number: string }`.\r\n */\r\nexport default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(\r\n\tnumber,\r\n\tcountry,\r\n\tdefaultCountry,\r\n\tdefaultCallingCode,\r\n\tmetadata\r\n) {\r\n\tconst countryCallingCode = country || defaultCountry\r\n\t\t? getCountryCallingCode(country || defaultCountry, metadata)\r\n\t\t: defaultCallingCode\r\n\r\n\tif (number.indexOf(countryCallingCode) === 0) {\r\n\t\tmetadata = new Metadata(metadata)\r\n\t\tmetadata.selectNumberingPlan(country || defaultCountry, countryCallingCode)\r\n\r\n\t\tconst possibleShorterNumber = number.slice(countryCallingCode.length)\r\n\r\n\t\tconst {\r\n\t\t\tnationalNumber: possibleShorterNationalNumber,\r\n\t\t} = extractNationalNumber(\r\n\t\t\tpossibleShorterNumber,\r\n\t\t\tcountry,\r\n\t\t\tmetadata\r\n\t\t)\r\n\r\n\t\tconst {\r\n\t\t\tnationalNumber\r\n\t\t} = extractNationalNumber(\r\n\t\t\tnumber,\r\n\t\t\tcountry,\r\n\t\t\tmetadata\r\n\t\t)\r\n\r\n\t\t// If the number was not valid before but is valid now,\r\n\t\t// or if it was too long before, we consider the number\r\n\t\t// with the country calling code stripped to be a better result\r\n\t\t// and keep that instead.\r\n\t\t// For example, in Germany (+49), `49` is a valid area code,\r\n\t\t// so if a number starts with `49`, it could be both a valid\r\n\t\t// national German number or an international number without\r\n\t\t// a leading `+`.\r\n\t\tif (\r\n\t\t\t(\r\n\t\t\t\t!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) &&\r\n\t\t\t\tmatchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern())\r\n\t\t\t)\r\n\t\t\t||\r\n\t\t\tcheckNumberLength(nationalNumber, country, metadata) === 'TOO_LONG'\r\n\t\t) {\r\n\t\t\treturn {\r\n\t\t\t\tcountryCallingCode,\r\n\t\t\t\tnumber: possibleShorterNumber\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\treturn { number }\r\n}","import Metadata from '../metadata.js'\r\n\r\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 */\r\nconst SINGLE_IDD_PREFIX_REG_EXP = /^[\\d]+(?:[~\\u2053\\u223C\\uFF5E][\\d]+)?$/\r\n\r\n// For regions that have multiple IDD prefixes\r\n// a preferred IDD prefix is returned.\r\nexport default function getIddPrefix(country, callingCode, metadata) {\r\n\tconst countryMetadata = new Metadata(metadata)\r\n\tcountryMetadata.selectNumberingPlan(country, callingCode)\r\n\tif (countryMetadata.defaultIDDPrefix()) {\r\n\t\treturn countryMetadata.defaultIDDPrefix()\r\n\t}\r\n\tif (SINGLE_IDD_PREFIX_REG_EXP.test(countryMetadata.IDDPrefix())) {\r\n\t\treturn countryMetadata.IDDPrefix()\r\n\t}\r\n}\r\n","// This is a port of Google Android `libphonenumber`'s\r\n// `phonenumberutil.js` of December 31th, 2018.\r\n//\r\n// https://github.com/googlei18n/libphonenumber/commits/master/javascript/i18n/phonenumbers/phonenumberutil.js\r\n\r\nimport matchesEntirely from './helpers/matchesEntirely.js'\r\nimport formatNationalNumberUsingFormat from './helpers/formatNationalNumberUsingFormat.js'\r\nimport Metadata, { getCountryCallingCode } from './metadata.js'\r\nimport getIddPrefix from './helpers/getIddPrefix.js'\r\nimport { formatRFC3966 } from './helpers/RFC3966.js'\r\n\r\nconst DEFAULT_OPTIONS = {\r\n\tformatExtension: (formattedNumber, extension, metadata) => `${formattedNumber}${metadata.ext()}${extension}`\r\n}\r\n\r\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 */\r\nexport default function formatNumber(input, format, options, metadata) {\r\n\t// Apply default options.\r\n\tif (options) {\r\n\t\t// Using ES6 \"rest spread\" syntax here didn't work with `babel`/`istanbul`\r\n\t\t// for some weird reason: this line of code would cause the code coverage\r\n\t\t// to show as not 100%. That's because `babel`/`istanbul`, for some weird reason,\r\n\t\t// apparently doesn't know how to properly exclude Babel polyfills from code coverage.\r\n\t\t//\r\n\t\t// options = { ...DEFAULT_OPTIONS, ...options }\r\n\t\t//\r\n\t\toptions = merge({}, DEFAULT_OPTIONS, options)\r\n\t} else {\r\n\t\toptions = DEFAULT_OPTIONS\r\n\t}\r\n\r\n\tmetadata = new Metadata(metadata)\r\n\r\n\tif (input.country && input.country !== '001') {\r\n\t\t// Validate `input.country`.\r\n\t\tif (!metadata.hasCountry(input.country)) {\r\n\t\t\tthrow new Error(`Unknown country: ${input.country}`)\r\n\t\t}\r\n\t\tmetadata.selectNumberingPlan(input.country)\r\n\t}\r\n\telse if (input.countryCallingCode) {\r\n\t\tmetadata.selectNumberingPlan(input.countryCallingCode)\r\n\t}\r\n\telse return input.phone || ''\r\n\r\n\tconst countryCallingCode = metadata.countryCallingCode()\r\n\r\n\tconst nationalNumber = options.v2 ? input.nationalNumber : input.phone\r\n\r\n\t// This variable should have been declared inside `case`s\r\n\t// but Babel has a bug and it says \"duplicate variable declaration\".\r\n\tlet number\r\n\r\n\tswitch (format) {\r\n\t\tcase 'NATIONAL':\r\n\t\t\t// Legacy argument support.\r\n\t\t\t// (`{ country: ..., phone: '' }`)\r\n\t\t\tif (!nationalNumber) {\r\n\t\t\t\treturn ''\r\n\t\t\t}\r\n\t\t\tnumber = formatNationalNumber(nationalNumber, input.carrierCode, 'NATIONAL', metadata, options)\r\n\t\t\treturn addExtension(number, input.ext, metadata, options.formatExtension)\r\n\r\n\t\tcase 'INTERNATIONAL':\r\n\t\t\t// Legacy argument support.\r\n\t\t\t// (`{ country: ..., phone: '' }`)\r\n\t\t\tif (!nationalNumber) {\r\n\t\t\t\treturn `+${countryCallingCode}`\r\n\t\t\t}\r\n\t\t\tnumber = formatNationalNumber(nationalNumber, null, 'INTERNATIONAL', metadata, options)\r\n\t\t\tnumber = `+${countryCallingCode} ${number}`\r\n\t\t\treturn addExtension(number, input.ext, metadata, options.formatExtension)\r\n\r\n\t\tcase 'E.164':\r\n\t\t\t// `E.164` doesn't define \"phone number extensions\".\r\n\t\t\treturn `+${countryCallingCode}${nationalNumber}`\r\n\r\n\t\tcase 'RFC3966':\r\n\t\t\treturn formatRFC3966({\r\n\t\t\t\tnumber: `+${countryCallingCode}${nationalNumber}`,\r\n\t\t\t\text: input.ext\r\n\t\t\t})\r\n\r\n\t\t// For reference, here's Google's IDD formatter:\r\n\t\t// https://github.com/google/libphonenumber/blob/32719cf74e68796788d1ca45abc85dcdc63ba5b9/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L1546\r\n\t\t// Not saying that this IDD formatter replicates it 1:1, but it seems to work.\r\n\t\t// Who would even need to format phone numbers in IDD format anyway?\r\n\t\tcase 'IDD':\r\n\t\t\tif (!options.fromCountry) {\r\n\t\t\t\treturn\r\n\t\t\t\t// throw new Error('`fromCountry` option not passed for IDD-prefixed formatting.')\r\n\t\t\t}\r\n\t\t\tconst formattedNumber = formatIDD(\r\n\t\t\t\tnationalNumber,\r\n\t\t\t\tinput.carrierCode,\r\n\t\t\t\tcountryCallingCode,\r\n\t\t\t\toptions.fromCountry,\r\n\t\t\t\tmetadata\r\n\t\t\t)\r\n\t\t\treturn addExtension(formattedNumber, input.ext, metadata, options.formatExtension)\r\n\r\n\t\tdefault:\r\n\t\t\tthrow new Error(`Unknown \"format\" argument passed to \"formatNumber()\": \"${format}\"`)\r\n\t}\r\n}\r\n\r\nfunction formatNationalNumber(number, carrierCode, formatAs, metadata, options) {\r\n\tconst format = chooseFormatForNumber(metadata.formats(), number)\r\n\tif (!format) {\r\n\t\treturn number\r\n\t}\r\n\treturn formatNationalNumberUsingFormat(\r\n\t\tnumber,\r\n\t\tformat,\r\n\t\t{\r\n\t\t\tuseInternationalFormat: formatAs === 'INTERNATIONAL',\r\n\t\t\twithNationalPrefix: format.nationalPrefixIsOptionalWhenFormattingInNationalFormat() && (options && options.nationalPrefix === false) ? false : true,\r\n\t\t\tcarrierCode,\r\n\t\t\tmetadata\r\n\t\t}\r\n\t)\r\n}\r\n\r\nexport function chooseFormatForNumber(availableFormats, nationalNumber) {\r\n\t// Using a `for ... of` loop here didn't work with `babel`/`istanbul`:\r\n\t// for some weird reason, it showed code coverage less than 100%.\r\n\t// That's because `babel`/`istanbul`, for some weird reason,\r\n\t// apparently doesn't know how to properly exclude Babel polyfills from code coverage.\r\n\t//\r\n\t// for (const format of availableFormats) { ... }\r\n\t//\r\n\treturn pickFirstMatchingElement(availableFormats, (format) => {\r\n\t\t// Validate leading digits.\r\n\t\t// The test case for \"else path\" could be found by searching for\r\n\t\t// \"format.leadingDigitsPatterns().length === 0\".\r\n\t\tif (format.leadingDigitsPatterns().length > 0) {\r\n\t\t\t// The last leading_digits_pattern is used here, as it is the most detailed\r\n\t\t\tconst lastLeadingDigitsPattern = format.leadingDigitsPatterns()[format.leadingDigitsPatterns().length - 1]\r\n\t\t\t// If leading digits don't match then move on to the next phone number format\r\n\t\t\tif (nationalNumber.search(lastLeadingDigitsPattern) !== 0) {\r\n\t\t\t\treturn false\r\n\t\t\t}\r\n\t\t}\r\n\t\t// Check that the national number matches the phone number format regular expression\r\n\t\treturn matchesEntirely(nationalNumber, format.pattern())\r\n\t})\r\n}\r\n\r\nfunction addExtension(formattedNumber, ext, metadata, formatExtension) {\r\n\treturn ext ? formatExtension(formattedNumber, ext, metadata) : formattedNumber\r\n}\r\n\r\nfunction formatIDD(\r\n\tnationalNumber,\r\n\tcarrierCode,\r\n\tcountryCallingCode,\r\n\tfromCountry,\r\n\tmetadata\r\n) {\r\n\tconst fromCountryCallingCode = getCountryCallingCode(fromCountry, metadata.metadata)\r\n\t// When calling within the same country calling code.\r\n\tif (fromCountryCallingCode === countryCallingCode) {\r\n\t\tconst formattedNumber = formatNationalNumber(nationalNumber, carrierCode, 'NATIONAL', metadata)\r\n\t\t// For NANPA regions, return the national format for these regions\r\n\t\t// but prefix it with the country calling code.\r\n\t\tif (countryCallingCode === '1') {\r\n\t\t\treturn countryCallingCode + ' ' + formattedNumber\r\n\t\t}\r\n\t\t// If regions share a country calling code, the country calling code need\r\n\t\t// not be dialled. This also applies when dialling within a region, so this\r\n\t\t// if clause covers both these cases. Technically this is the case for\r\n\t\t// dialling from La Reunion to other overseas departments of France (French\r\n\t\t// Guiana, Martinique, Guadeloupe), but not vice versa - so we don't cover\r\n\t\t// this edge case for now and for those cases return the version including\r\n\t\t// country calling code. Details here:\r\n\t\t// http://www.petitfute.com/voyage/225-info-pratiques-reunion\r\n\t\t//\r\n\t\treturn formattedNumber\r\n\t}\r\n\tconst iddPrefix = getIddPrefix(fromCountry, undefined, metadata.metadata)\r\n\tif (iddPrefix) {\r\n\t\treturn `${iddPrefix} ${countryCallingCode} ${formatNationalNumber(nationalNumber, null, 'INTERNATIONAL', metadata)}`\r\n\t}\r\n}\r\n\r\nfunction merge(...objects) {\r\n\tlet i = 1\r\n\twhile (i < objects.length) {\r\n\t\tif (objects[i]) {\r\n\t\t\tfor (const key in objects[i]) {\r\n\t\t\t\tobjects[0][key] = objects[i][key]\r\n\t\t\t}\r\n\t\t}\r\n\t\ti++\r\n\t}\r\n\treturn objects[0]\r\n}\r\n\r\nfunction pickFirstMatchingElement(elements, testFunction) {\r\n\tlet i = 0\r\n\twhile (i < elements.length) {\r\n\t\tif (testFunction(elements[i])) {\r\n\t\t\treturn elements[i]\r\n\t\t}\r\n\t\ti++\r\n\t}\r\n}","import normalizeArguments from '../normalizeArguments.js'\r\nimport PhoneNumberMatcher from '../PhoneNumberMatcher.js'\r\n\r\n/**\r\n * @return ES6 `for ... of` iterator.\r\n */\r\nexport default function searchNumbers()\r\n{\r\n\tconst { text, options, metadata } = normalizeArguments(arguments)\r\n\r\n\tconst matcher = new PhoneNumberMatcher(text, options, metadata)\r\n\r\n\treturn  {\r\n\t\t[Symbol.iterator]() {\r\n\t\t\treturn {\r\n\t    \t\tnext: () => {\r\n\t    \t\t\tif (matcher.hasNext()) {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tdone: false,\r\n\t\t\t\t\t\t\tvalue: matcher.next()\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\tdone: true\r\n\t\t\t\t\t}\r\n\t    \t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}\r\n","import AsYouType from './AsYouType.js'\r\n\r\n/**\r\n * Formats a (possibly incomplete) phone number.\r\n * The phone number can be either in E.164 format\r\n * or in a form of national number digits.\r\n * @param {string} value - A possibly incomplete phone number. Either in E.164 format or in a form of national number digits.\r\n * @param {string|object} [optionsOrDefaultCountry] - A two-letter (\"ISO 3166-1 alpha-2\") country code, or an object of shape `{ defaultCountry?: string, defaultCallingCode?: string }`.\r\n * @return {string} Formatted (possibly incomplete) phone number.\r\n */\r\nexport default function formatIncompletePhoneNumber(value, optionsOrDefaultCountry, metadata) {\r\n\tif (!metadata) {\r\n\t\tmetadata = optionsOrDefaultCountry\r\n\t\toptionsOrDefaultCountry = undefined\r\n\t}\r\n\treturn new AsYouType(optionsOrDefaultCountry, metadata).input(value)\r\n}","// https://medium.com/dsinjs/implementing-lru-cache-in-javascript-94ba6755cda9\r\n\r\nclass Node {\r\n  constructor(key, value, next = null, prev = null) {\r\n    this.key = key;\r\n    this.value = value;\r\n    this.next = next;\r\n    this.prev = prev;\r\n  }\r\n}\r\n\r\nexport default class LRUCache {\r\n  //set default limit of 10 if limit is not passed.\r\n  constructor(limit = 10) {\r\n    this.size = 0;\r\n    this.limit = limit;\r\n    this.head = null;\r\n    this.tail = null;\r\n    this.cache = {};\r\n  }\r\n\r\n  // Write Node to head of LinkedList\r\n  // update cache with Node key and Node reference\r\n  put(key, value){\r\n    this.ensureLimit();\r\n\r\n    if(!this.head){\r\n      this.head = this.tail = new Node(key, value);\r\n    }else{\r\n      const node = new Node(key, value, this.head);\r\n      this.head.prev = node;\r\n      this.head = node;\r\n    }\r\n\r\n    //Update the cache map\r\n    this.cache[key] = this.head;\r\n    this.size++;\r\n  }\r\n\r\n  // Read from cache map and make that node as new Head of LinkedList\r\n  get(key){\r\n    if(this.cache[key]){\r\n      const value = this.cache[key].value;\r\n\r\n      // node removed from it's position and cache\r\n      this.remove(key)\r\n      // write node again to the head of LinkedList to make it most recently used\r\n      this.put(key, value);\r\n\r\n      return value;\r\n    }\r\n\r\n    console.log(`Item not available in cache for key ${key}`);\r\n  }\r\n\r\n  ensureLimit(){\r\n    if(this.size === this.limit){\r\n      this.remove(this.tail.key)\r\n    }\r\n  }\r\n\r\n  remove(key){\r\n    const node = this.cache[key];\r\n\r\n    if(node.prev !== null){\r\n      node.prev.next = node.next;\r\n    }else{\r\n      this.head = node.next;\r\n    }\r\n\r\n    if(node.next !== null){\r\n      node.next.prev = node.prev;\r\n    }else{\r\n      this.tail = node.prev\r\n    }\r\n\r\n    delete this.cache[key];\r\n    this.size--;\r\n  }\r\n\r\n  clear() {\r\n    this.head = null;\r\n    this.tail = null;\r\n    this.size = 0;\r\n    this.cache = {};\r\n  }\r\n\r\n  // // Invokes the callback function with every node of the chain and the index of the node.\r\n  // forEach(fn) {\r\n  //   let node = this.head;\r\n  //   let counter = 0;\r\n  //   while (node) {\r\n  //     fn(node, counter);\r\n  //     node = node.next;\r\n  //     counter++;\r\n  //   }\r\n  // }\r\n\r\n  // // To iterate over LRU with a 'for...of' loop\r\n  // *[Symbol.iterator]() {\r\n  //   let node = this.head;\r\n  //   while (node) {\r\n  //     yield node;\r\n  //     node = node.next;\r\n  //   }\r\n  // }\r\n}","import LRUCache from './LRUCache.js'\r\n\r\n// A cache for frequently used country-specific regular expressions. Set to 32 to cover ~2-3\r\n// countries being used for the same doc with ~10 patterns for each country. Some pages will have\r\n// a lot more countries in use, but typically fewer numbers for each so expanding the cache for\r\n// that use-case won't have a lot of benefit.\r\nexport default class RegExpCache {\r\n\tconstructor(size) {\r\n\t\tthis.cache = new LRUCache(size)\r\n\t}\r\n\r\n\tgetPatternForRegExp(pattern) {\r\n\t\tlet regExp = this.cache.get(pattern)\r\n\t\tif (!regExp) {\r\n\t\t\tregExp = new RegExp('^' + pattern)\r\n\t\t\tthis.cache.put(pattern, regExp)\r\n\t\t}\r\n\t\treturn regExp\r\n\t}\r\n}","import parsePhoneNumber from '../parsePhoneNumber.js'\r\n\r\n/**\r\n * Matches a phone number object against a phone number string.\r\n * @param  {string} phoneNumberString\r\n * @param  {PhoneNumber} phoneNumber\r\n * @param  {object} metadata — Metadata JSON\r\n * @return {'INVALID_NUMBER'|'NO_MATCH'|'SHORT_NSN_MATCH'|'NSN_MATCH'|'EXACT_MATCH'}\r\n */\r\nexport default function matchPhoneNumberStringAgainstPhoneNumber(phoneNumberString, phoneNumber, metadata) {\r\n\t// Parse `phoneNumberString`.\r\n\tlet phoneNumberStringContainsCallingCode = true\r\n\tlet parsedPhoneNumber = parsePhoneNumber(phoneNumberString, metadata)\r\n\tif (!parsedPhoneNumber) {\r\n\t\t// If `phoneNumberString` didn't contain a country calling code\r\n\t\t// then substitute it with the `phoneNumber`'s country calling code.\r\n\t\tphoneNumberStringContainsCallingCode = false\r\n\t\tparsedPhoneNumber = parsePhoneNumber(phoneNumberString, { defaultCallingCode: phoneNumber.countryCallingCode }, metadata)\r\n\t}\r\n\tif (!parsedPhoneNumber) {\r\n\t\treturn 'INVALID_NUMBER'\r\n\t}\r\n\r\n\t// Check that the extensions match.\r\n\tif (phoneNumber.ext) {\r\n\t\tif (parsedPhoneNumber.ext !== phoneNumber.ext) {\r\n\t\t\treturn 'NO_MATCH'\r\n\t\t}\r\n\t} else {\r\n\t\tif (parsedPhoneNumber.ext) {\r\n\t\t\treturn 'NO_MATCH'\r\n\t\t}\r\n\t}\r\n\r\n\t// Check that country calling codes match.\r\n\tif (phoneNumberStringContainsCallingCode) {\r\n\t\tif (phoneNumber.countryCallingCode !== parsedPhoneNumber.countryCallingCode) {\r\n\t\t\treturn 'NO_MATCH'\r\n\t\t}\r\n\t}\r\n\r\n\t// Check if the whole numbers match.\r\n\tif (phoneNumber.number === parsedPhoneNumber.number) {\r\n\t\tif (phoneNumberStringContainsCallingCode) {\r\n\t\t\treturn 'EXACT_MATCH'\r\n\t\t} else {\r\n\t\t\treturn 'NSN_MATCH'\r\n\t\t}\r\n\t}\r\n\r\n\t// Check if one national number is a \"suffix\" of the other.\r\n\tif (\r\n\t\tphoneNumber.nationalNumber.indexOf(parsedPhoneNumber.nationalNumber) === 0 ||\r\n\t\tparsedPhoneNumber.nationalNumber.indexOf(phoneNumber.nationalNumber) === 0\r\n\t) {\r\n\t\t// \"A SHORT_NSN_MATCH occurs if there is a difference because of the\r\n\t\t//  presence or absence of an 'Italian leading zero', the presence or\r\n\t\t//  absence of an extension, or one NSN being a shorter variant of the\r\n\t\t//  other.\"\r\n\t\treturn 'SHORT_NSN_MATCH'\r\n\t}\r\n\r\n\treturn 'NO_MATCH'\r\n}","import parseDigits from '../helpers/parseDigits.js'\r\nimport matchPhoneNumberStringAgainstPhoneNumber from './matchPhoneNumberStringAgainstPhoneNumber.js'\r\nimport Metadata from '../metadata.js'\r\nimport getCountryByCallingCode from '../helpers/getCountryByCallingCode.js'\r\nimport { chooseFormatForNumber } from '../format.js'\r\n\r\nimport {\r\n\tstartsWith,\r\n\tendsWith\r\n} from './util.js'\r\n\r\n/**\r\n * Leniency when finding potential phone numbers in text segments\r\n * The levels here are ordered in increasing strictness.\r\n */\r\nexport default\r\n{\r\n\t/**\r\n\t * Phone numbers accepted are \"possible\", but not necessarily \"valid\".\r\n\t */\r\n\tPOSSIBLE(phoneNumber, { candidate, metadata })\r\n\t{\r\n\t\treturn true\r\n\t},\r\n\r\n\t/**\r\n\t * Phone numbers accepted are \"possible\" and \"valid\".\r\n\t * Numbers written in national format must have their national-prefix\r\n\t * present if it is usually written for a number of this type.\r\n\t */\r\n\tVALID(phoneNumber, { candidate, defaultCountry, metadata })\r\n\t{\r\n\t\tif (\r\n\t\t\t!phoneNumber.isValid() ||\r\n\t\t\t!containsOnlyValidXChars(phoneNumber, candidate, metadata)\r\n\t\t)\r\n\t\t{\r\n\t\t\treturn false\r\n\t\t}\r\n\r\n\t\t// Skipped for simplicity.\r\n\t\t// return isNationalPrefixPresentIfRequired(phoneNumber, { defaultCountry, metadata })\r\n\t\treturn true\r\n\t},\r\n\r\n\t/**\r\n\t * Phone numbers accepted are \"valid\" and\r\n\t * are grouped in a possible way for this locale. For example, a US number written as\r\n\t * \"65 02 53 00 00\" and \"650253 0000\" are not accepted at this leniency level, whereas\r\n\t * \"650 253 0000\", \"650 2530000\" or \"6502530000\" are.\r\n\t * Numbers with more than one '/' symbol in the national significant number\r\n\t * are also dropped at this level.\r\n\t *\r\n\t * Warning: This level might result in lower coverage especially for regions outside of\r\n\t * country code \"+1\". If you are not sure about which level to use,\r\n\t * email the discussion group libphonenumber-discuss@googlegroups.com.\r\n\t */\r\n\tSTRICT_GROUPING(phoneNumber, { candidate, defaultCountry, metadata, regExpCache })\r\n\t{\r\n\t\tif (\r\n\t\t\t!phoneNumber.isValid() ||\r\n\t\t\t!containsOnlyValidXChars(phoneNumber, candidate, metadata) ||\r\n\t\t\tcontainsMoreThanOneSlashInNationalNumber(phoneNumber, candidate) ||\r\n\t\t\t!isNationalPrefixPresentIfRequired(phoneNumber, { defaultCountry, metadata })\r\n\t\t)\r\n\t\t{\r\n\t\t\treturn false\r\n\t\t}\r\n\r\n\t\treturn checkNumberGroupingIsValid\r\n\t\t(\r\n\t\t\tphoneNumber,\r\n\t\t\tcandidate,\r\n\t\t\tmetadata,\r\n\t\t\tallNumberGroupsRemainGrouped,\r\n\t\t\tregExpCache\r\n\t\t)\r\n\t},\r\n\r\n\t/**\r\n\t * Phone numbers accepted are \"valid\" and are grouped in the same way\r\n\t * that we would have formatted it, or as a single block.\r\n\t * For example, a US number written as \"650 2530000\" is not accepted\r\n\t * at this leniency level, whereas \"650 253 0000\" or \"6502530000\" are.\r\n\t * Numbers with more than one '/' symbol are also dropped at this level.\r\n\t *\r\n\t * Warning: This level might result in lower coverage especially for regions outside of\r\n\t * country code \"+1\". If you are not sure about which level to use, email the discussion group\r\n\t * libphonenumber-discuss@googlegroups.com.\r\n\t */\r\n\tEXACT_GROUPING(phoneNumber, { candidate, defaultCountry, metadata, regExpCache })\r\n\t{\r\n\t\tif (\r\n\t\t\t!phoneNumber.isValid() ||\r\n\t\t\t!containsOnlyValidXChars(phoneNumber, candidate, metadata) ||\r\n\t\t\tcontainsMoreThanOneSlashInNationalNumber(phoneNumber, candidate) ||\r\n\t\t\t!isNationalPrefixPresentIfRequired(phoneNumber, { defaultCountry, metadata })\r\n\t\t)\r\n\t\t{\r\n\t\t\treturn false\r\n\t\t}\r\n\r\n\t\treturn checkNumberGroupingIsValid\r\n\t\t(\r\n\t\t\tphoneNumber,\r\n\t\t\tcandidate,\r\n\t\t\tmetadata,\r\n\t\t\tallNumberGroupsAreExactlyPresent,\r\n\t\t\tregExpCache\r\n\t\t)\r\n\t}\r\n}\r\n\r\nfunction containsOnlyValidXChars(phoneNumber, candidate, metadata)\r\n{\r\n\t// The characters 'x' and 'X' can be (1) a carrier code, in which case they always precede the\r\n\t// national significant number or (2) an extension sign, in which case they always precede the\r\n\t// extension number. We assume a carrier code is more than 1 digit, so the first case has to\r\n\t// have more than 1 consecutive 'x' or 'X', whereas the second case can only have exactly 1 'x'\r\n\t// or 'X'. We ignore the character if it appears as the last character of the string.\r\n\tfor (let index = 0; index < candidate.length - 1; index++)\r\n\t{\r\n\t\tconst charAtIndex = candidate.charAt(index)\r\n\r\n\t\tif (charAtIndex === 'x' || charAtIndex === 'X')\r\n\t\t{\r\n\t\t\tconst charAtNextIndex = candidate.charAt(index + 1)\r\n\r\n\t\t\tif (charAtNextIndex === 'x' || charAtNextIndex === 'X')\r\n\t\t\t{\r\n\t\t\t\t// This is the carrier code case, in which the 'X's always precede the national\r\n\t\t\t\t// significant number.\r\n\t\t\t\tindex++\r\n\t\t\t\tif (matchPhoneNumberStringAgainstPhoneNumber(candidate.substring(index), phoneNumber, metadata) !== 'NSN_MATCH')\r\n\t\t\t\t{\r\n\t\t\t\t\treturn false\r\n\t\t\t\t}\r\n\t\t\t\t// This is the extension sign case, in which the 'x' or 'X' should always precede the\r\n\t\t\t\t// extension number.\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tconst ext = parseDigits(candidate.substring(index))\r\n\t\t\t\tif (ext) {\r\n\t\t\t\t\tif (phoneNumber.ext !== ext)  {\r\n\t\t\t\t\t\treturn false\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\tif (phoneNumber.ext) {\r\n\t\t\t\t\t\treturn false\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\treturn true\r\n}\r\n\r\nfunction isNationalPrefixPresentIfRequired(phoneNumber, { defaultCountry, metadata: _metadata })\r\n{\r\n\t// First, check how we deduced the country code. If it was written in international format, then\r\n\t// the national prefix is not required.\r\n\tif (phoneNumber.__countryCallingCodeSource !== 'FROM_DEFAULT_COUNTRY')\r\n\t{\r\n\t\treturn true\r\n\t}\r\n\r\n\tconst metadata = new Metadata(_metadata)\r\n\tmetadata.selectNumberingPlan(phoneNumber.countryCallingCode)\r\n\r\n\tconst phoneNumberRegion = phoneNumber.country || getCountryByCallingCode(phoneNumber.countryCallingCode, {\r\n\t\tnationalNumber: phoneNumber.nationalNumber,\r\n\t\tmetadata\r\n\t})\r\n\r\n\t// Check if a national prefix should be present when formatting this number.\r\n\tconst nationalNumber = phoneNumber.nationalNumber\r\n\tconst format = chooseFormatForNumber(metadata.numberingPlan.formats(), nationalNumber)\r\n\r\n\t// To do this, we check that a national prefix formatting rule was present\r\n\t// and that it wasn't just the first-group symbol ($1) with punctuation.\r\n\tif (format.nationalPrefixFormattingRule())\r\n\t{\r\n\t\tif (metadata.numberingPlan.nationalPrefixIsOptionalWhenFormattingInNationalFormat())\r\n\t\t{\r\n\t\t\t// The national-prefix is optional in these cases, so we don't need to check if it was present.\r\n\t\t\treturn true\r\n\t\t}\r\n\r\n\t\tif (!format.usesNationalPrefix())\r\n\t\t{\r\n\t\t\t// National Prefix not needed for this number.\r\n\t\t\treturn true\r\n\t\t}\r\n\r\n\t\treturn Boolean(phoneNumber.nationalPrefix)\r\n\t}\r\n\r\n\treturn true\r\n}\r\n\r\nexport function containsMoreThanOneSlashInNationalNumber(phoneNumber, candidate)\r\n{\r\n\tconst firstSlashInBodyIndex = candidate.indexOf('/')\r\n\tif (firstSlashInBodyIndex < 0)\r\n\t{\r\n\t\t// No slashes, this is okay.\r\n\t\treturn false\r\n\t}\r\n\r\n\t// Now look for a second one.\r\n\tconst secondSlashInBodyIndex = candidate.indexOf('/', firstSlashInBodyIndex + 1)\r\n\tif (secondSlashInBodyIndex < 0)\r\n\t{\r\n\t\t// Only one slash, this is okay.\r\n\t\treturn false\r\n\t}\r\n\r\n\t// If the first slash is after the country calling code, this is permitted.\r\n\tconst candidateHasCountryCode =\r\n\t\t\tphoneNumber.__countryCallingCodeSource === 'FROM_NUMBER_WITH_PLUS_SIGN' ||\r\n\t\t\tphoneNumber.__countryCallingCodeSource === 'FROM_NUMBER_WITHOUT_PLUS_SIGN'\r\n\r\n\tif (candidateHasCountryCode && parseDigits(candidate.substring(0, firstSlashInBodyIndex)) === phoneNumber.countryCallingCode)\r\n\t{\r\n\t\t// Any more slashes and this is illegal.\r\n\t\treturn candidate.slice(secondSlashInBodyIndex + 1).indexOf('/') >= 0\r\n\t}\r\n\r\n\treturn true\r\n}\r\n\r\nfunction checkNumberGroupingIsValid(\r\n\tnumber,\r\n\tcandidate,\r\n\tmetadata,\r\n\tcheckGroups,\r\n\tregExpCache\r\n) {\r\n\tthrow new Error('This part of code hasn\\'t been ported')\r\n\r\n\tconst normalizedCandidate = normalizeDigits(candidate, true /* keep non-digits */)\r\n\tlet formattedNumberGroups = getNationalNumberGroups(metadata, number, null)\r\n\tif (checkGroups(metadata, number, normalizedCandidate, formattedNumberGroups)) {\r\n\t\treturn true\r\n\t}\r\n\r\n\t// If this didn't pass, see if there are any alternate formats that match, and try them instead.\r\n\tconst alternateFormats = MetadataManager.getAlternateFormatsForCountry(number.getCountryCode())\r\n\tconst nationalSignificantNumber = util.getNationalSignificantNumber(number)\r\n\r\n\tif (alternateFormats) {\r\n\t\tfor (const alternateFormat of alternateFormats.numberFormats()) {\r\n\t\t\tif (alternateFormat.leadingDigitsPatterns().length > 0) {\r\n\t\t\t\t// There is only one leading digits pattern for alternate formats.\r\n\t\t\t\tconst leadingDigitsRegExp = regExpCache.getPatternForRegExp('^' + alternateFormat.leadingDigitsPatterns()[0])\r\n\t\t\t\tif (!leadingDigitsRegExp.test(nationalSignificantNumber)) {\r\n\t\t\t\t\t// Leading digits don't match; try another one.\r\n\t\t\t\t\tcontinue\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tformattedNumberGroups = getNationalNumberGroups(metadata, number, alternateFormat)\r\n\t\t\tif (checkGroups(metadata, number, normalizedCandidate, formattedNumberGroups)) {\r\n\t\t\t\treturn true\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\treturn false\r\n}\r\n\r\n/**\r\n * Helper method to get the national-number part of a number, formatted without any national\r\n * prefix, and return it as a set of digit blocks that would be formatted together following\r\n * standard formatting rules.\r\n */\r\nfunction getNationalNumberGroups(\r\n\tmetadata,\r\n\tnumber,\r\n\tformattingPattern\r\n) {\r\n\tthrow new Error('This part of code hasn\\'t been ported')\r\n\r\n\tif (formattingPattern) {\r\n\t\t// We format the NSN only, and split that according to the separator.\r\n\t\tconst nationalSignificantNumber = util.getNationalSignificantNumber(number)\r\n\t\treturn util.formatNsnUsingPattern(nationalSignificantNumber,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tformattingPattern, 'RFC3966', metadata).split('-')\r\n\t}\r\n\r\n\t// This will be in the format +CC-DG1-DG2-DGX;ext=EXT where DG1..DGX represents groups of digits.\r\n\tconst rfc3966Format = formatNumber(number, 'RFC3966', metadata)\r\n\r\n\t// We remove the extension part from the formatted string before splitting it into different\r\n\t// groups.\r\n\tlet endIndex = rfc3966Format.indexOf(';')\r\n\tif (endIndex < 0) {\r\n\t\tendIndex = rfc3966Format.length\r\n\t}\r\n\r\n\t// The country-code will have a '-' following it.\r\n\tconst startIndex = rfc3966Format.indexOf('-') + 1\r\n\treturn rfc3966Format.slice(startIndex, endIndex).split('-')\r\n}\r\n\r\nfunction allNumberGroupsAreExactlyPresent\r\n(\r\n\tmetadata,\r\n\tnumber,\r\n\tnormalizedCandidate,\r\n\tformattedNumberGroups\r\n)\r\n{\r\n\tthrow new Error('This part of code hasn\\'t been ported')\r\n\r\n\tconst candidateGroups = normalizedCandidate.split(NON_DIGITS_PATTERN)\r\n\r\n\t// Set this to the last group, skipping it if the number has an extension.\r\n\tlet candidateNumberGroupIndex =\r\n\t\t\tnumber.hasExtension() ? candidateGroups.length - 2 : candidateGroups.length - 1\r\n\r\n\t// First we check if the national significant number is formatted as a block.\r\n\t// We use contains and not equals, since the national significant number may be present with\r\n\t// a prefix such as a national number prefix, or the country code itself.\r\n\tif (candidateGroups.length == 1\r\n\t\t\t|| candidateGroups[candidateNumberGroupIndex].contains(\r\n\t\t\t\t\tutil.getNationalSignificantNumber(number)))\r\n\t{\r\n\t\treturn true\r\n\t}\r\n\r\n\t// Starting from the end, go through in reverse, excluding the first group, and check the\r\n\t// candidate and number groups are the same.\r\n\tlet formattedNumberGroupIndex = (formattedNumberGroups.length - 1)\r\n\twhile (formattedNumberGroupIndex > 0 && candidateNumberGroupIndex >= 0)\r\n\t{\r\n\t\tif (candidateGroups[candidateNumberGroupIndex] !== formattedNumberGroups[formattedNumberGroupIndex])\r\n\t\t{\r\n\t\t\treturn false\r\n\t\t}\r\n\t\tformattedNumberGroupIndex--\r\n\t\tcandidateNumberGroupIndex--\r\n\t}\r\n\r\n\t// Now check the first group. There may be a national prefix at the start, so we only check\r\n\t// that the candidate group ends with the formatted number group.\r\n\treturn (candidateNumberGroupIndex >= 0\r\n\t\t\t&& endsWith(candidateGroups[candidateNumberGroupIndex], formattedNumberGroups[0]))\r\n}\r\n\r\n\r\nfunction allNumberGroupsRemainGrouped\r\n(\r\n\tmetadata,\r\n\tnumber,\r\n\tnormalizedCandidate,\r\n\tformattedNumberGroups\r\n)\r\n{\r\n\tthrow new Error('This part of code hasn\\'t been ported')\r\n\r\n\tlet fromIndex = 0\r\n\tif (number.getCountryCodeSource() !== CountryCodeSource.FROM_DEFAULT_COUNTRY)\r\n\t{\r\n\t\t// First skip the country code if the normalized candidate contained it.\r\n\t\tconst countryCode = String(number.getCountryCode())\r\n\t\tfromIndex = normalizedCandidate.indexOf(countryCode) + countryCode.length()\r\n\t}\r\n\r\n\t// Check each group of consecutive digits are not broken into separate groupings in the\r\n\t// {@code normalizedCandidate} string.\r\n\tfor (let i = 0; i < formattedNumberGroups.length; i++)\r\n\t{\r\n\t\t// Fails if the substring of {@code normalizedCandidate} starting from {@code fromIndex}\r\n\t\t// doesn't contain the consecutive digits in formattedNumberGroups[i].\r\n\t\tfromIndex = normalizedCandidate.indexOf(formattedNumberGroups[i], fromIndex)\r\n\t\tif (fromIndex < 0) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\t// Moves {@code fromIndex} forward.\r\n\t\tfromIndex += formattedNumberGroups[i].length()\r\n\t\tif (i == 0 && fromIndex < normalizedCandidate.length())\r\n\t\t{\r\n\t\t\t// We are at the position right after the NDC. We get the region used for formatting\r\n\t\t\t// information based on the country code in the phone number, rather than the number itself,\r\n\t\t\t// as we do not need to distinguish between different countries with the same country\r\n\t\t\t// calling code and this is faster.\r\n\t\t\tconst region = util.getRegionCodeForCountryCode(number.getCountryCode())\r\n\t\t\tif (util.getNddPrefixForRegion(region, true) != null\r\n\t\t\t\t\t&& Character.isDigit(normalizedCandidate.charAt(fromIndex))) {\r\n\t\t\t\t// This means there is no formatting symbol after the NDC. In this case, we only\r\n\t\t\t\t// accept the number if there is no formatting symbol at all in the number, except\r\n\t\t\t\t// for extensions. This is only important for countries with national prefixes.\r\n\t\t\t\tconst nationalSignificantNumber = util.getNationalSignificantNumber(number)\r\n\t\t\t\treturn startsWith\r\n\t\t\t\t(\r\n\t\t\t\t\tnormalizedCandidate.slice(fromIndex - formattedNumberGroups[i].length),\r\n\t\t\t\t\t nationalSignificantNumber\r\n\t\t\t\t)\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// The check here makes sure that we haven't mistakenly already used the extension to\r\n\t// match the last group of the subscriber number. Note the extension cannot have\r\n\t// formatting in-between digits.\r\n\treturn normalizedCandidate.slice(fromIndex).contains(number.getExtension())\r\n}","/**\r\n * A port of Google's `PhoneNumberMatcher.java`.\r\n * https://github.com/googlei18n/libphonenumber/blob/master/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberMatcher.java\r\n * Date: 08.03.2018.\r\n */\r\n\r\nimport {\r\n  MAX_LENGTH_FOR_NSN,\r\n  MAX_LENGTH_COUNTRY_CODE,\r\n  VALID_PUNCTUATION\r\n} from './constants.js'\r\n\r\nimport createExtensionPattern from './helpers/extension/createExtensionPattern.js'\r\n\r\nimport RegExpCache from './findNumbers/RegExpCache.js'\r\n\r\nimport {\r\n\tlimit,\r\n\ttrimAfterFirstMatch\r\n} from './findNumbers/util.js'\r\n\r\nimport {\r\n\t_pL,\r\n\t_pN,\r\n\tpZ,\r\n\tPZ,\r\n\tpNd\r\n} from './findNumbers/utf-8.js'\r\n\r\nimport Leniency from './findNumbers/Leniency.js'\r\nimport parsePreCandidate from './findNumbers/parsePreCandidate.js'\r\nimport isValidPreCandidate from './findNumbers/isValidPreCandidate.js'\r\nimport isValidCandidate, { LEAD_CLASS } from './findNumbers/isValidCandidate.js'\r\n\r\nimport { isSupportedCountry } from './metadata.js'\r\n\r\nimport parsePhoneNumber from './parsePhoneNumber.js'\r\n\r\nconst USE_NON_GEOGRAPHIC_COUNTRY_CODE = false\r\n\r\nconst EXTN_PATTERNS_FOR_MATCHING = createExtensionPattern('matching')\r\n\r\n/**\r\n * Patterns used to extract phone numbers from a larger phone-number-like pattern. These are\r\n * ordered according to specificity. For example, white-space is last since that is frequently\r\n * used in numbers, not just to separate two numbers. We have separate patterns since we don't\r\n * want to break up the phone-number-like text on more than one different kind of symbol at one\r\n * time, although symbols of the same type (e.g. space) can be safely grouped together.\r\n *\r\n * Note that if there is a match, we will always check any text found up to the first match as\r\n * well.\r\n */\r\nconst INNER_MATCHES =\r\n[\r\n\t// Breaks on the slash - e.g. \"651-234-2345/332-445-1234\"\r\n\t'\\\\/+(.*)/',\r\n\r\n\t// Note that the bracket here is inside the capturing group, since we consider it part of the\r\n\t// phone number. Will match a pattern like \"(650) 223 3345 (754) 223 3321\".\r\n\t'(\\\\([^(]*)',\r\n\r\n\t// Breaks on a hyphen - e.g. \"12345 - 332-445-1234 is my number.\"\r\n\t// We require a space on either side of the hyphen for it to be considered a separator.\r\n\t`(?:${pZ}-|-${pZ})${pZ}*(.+)`,\r\n\r\n\t// Various types of wide hyphens. Note we have decided not to enforce a space here, since it's\r\n\t// possible that it's supposed to be used to break two numbers without spaces, and we haven't\r\n\t// seen many instances of it used within a number.\r\n\t`[\\u2012-\\u2015\\uFF0D]${pZ}*(.+)`,\r\n\r\n\t// Breaks on a full stop - e.g. \"12345. 332-445-1234 is my number.\"\r\n\t`\\\\.+${pZ}*([^.]+)`,\r\n\r\n\t// Breaks on space - e.g. \"3324451234 8002341234\"\r\n\t`${pZ}+(${PZ}+)`\r\n]\r\n\r\n// Limit on the number of leading (plus) characters.\r\nconst leadLimit = limit(0, 2)\r\n\r\n// Limit on the number of consecutive punctuation characters.\r\nconst punctuationLimit = limit(0, 4)\r\n\r\n/* The maximum number of digits allowed in a digit-separated block. As we allow all digits in a\r\n * single block, set high enough to accommodate the entire national number and the international\r\n * country code. */\r\nconst digitBlockLimit = MAX_LENGTH_FOR_NSN + MAX_LENGTH_COUNTRY_CODE\r\n\r\n// Limit on the number of blocks separated by punctuation.\r\n// Uses digitBlockLimit since some formats use spaces to separate each digit.\r\nconst blockLimit = limit(0, digitBlockLimit)\r\n\r\n/* A punctuation sequence allowing white space. */\r\nconst punctuation = `[${VALID_PUNCTUATION}]` + punctuationLimit\r\n\r\n// A digits block without punctuation.\r\nconst digitSequence = pNd + limit(1, digitBlockLimit)\r\n\r\n/**\r\n * Phone number pattern allowing optional punctuation.\r\n * The phone number pattern used by `find()`, similar to\r\n * VALID_PHONE_NUMBER, but with the following differences:\r\n * <ul>\r\n *   <li>All captures are limited in order to place an upper bound to the text matched by the\r\n *       pattern.\r\n * <ul>\r\n *   <li>Leading punctuation / plus signs are limited.\r\n *   <li>Consecutive occurrences of punctuation are limited.\r\n *   <li>Number of digits is limited.\r\n * </ul>\r\n *   <li>No whitespace is allowed at the start or end.\r\n *   <li>No alpha digits (vanity numbers such as 1-800-SIX-FLAGS) are currently supported.\r\n * </ul>\r\n */\r\nconst PATTERN = '(?:' + LEAD_CLASS + punctuation + ')' + leadLimit\r\n\t+ digitSequence + '(?:' + punctuation + digitSequence + ')' + blockLimit\r\n\t+ '(?:' + EXTN_PATTERNS_FOR_MATCHING + ')?'\r\n\r\n// Regular expression of trailing characters that we want to remove.\r\n// We remove all characters that are not alpha or numerical characters.\r\n// The hash character is retained here, as it may signify\r\n// the previous block was an extension.\r\n//\r\n// // Don't know what does '&&' mean here.\r\n// const UNWANTED_END_CHAR_PATTERN = new RegExp(`[[\\\\P{N}&&\\\\P{L}]&&[^#]]+$`)\r\n//\r\nconst UNWANTED_END_CHAR_PATTERN = new RegExp(`[^${_pN}${_pL}#]+$`)\r\n\r\n// const NON_DIGITS_PATTERN = /(\\D+)/\r\n\r\nconst MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1\r\n\r\n/**\r\n * A stateful class that finds and extracts telephone numbers from {@linkplain CharSequence text}.\r\n * Instances can be created using the {@linkplain PhoneNumberUtil#findNumbers factory methods} in\r\n * {@link PhoneNumberUtil}.\r\n *\r\n * <p>Vanity numbers (phone numbers using alphabetic digits such as <tt>1-800-SIX-FLAGS</tt> are\r\n * not found.\r\n *\r\n * <p>This class is not thread-safe.\r\n */\r\nexport default class PhoneNumberMatcher\r\n{\r\n  /**\r\n   * @param {string} text — the character sequence that we will search, null for no text.\r\n   * @param {'POSSIBLE'|'VALID'|'STRICT_GROUPING'|'EXACT_GROUPING'} [options.leniency] — The leniency to use when evaluating candidate phone numbers. See `source/findNumbers/Leniency.js` for more details.\r\n   * @param {number} [options.maxTries] — The maximum number of invalid numbers to try before giving up on the text. This is to cover degenerate cases where the text has a lot of false positives in it. Must be >= 0.\r\n   */\r\n  constructor(text = '', options = {}, metadata)\r\n  {\r\n    options = {\r\n      v2: options.v2,\r\n      defaultCallingCode: options.defaultCallingCode,\r\n      defaultCountry: options.defaultCountry && isSupportedCountry(options.defaultCountry, metadata) ? options.defaultCountry : undefined,\r\n      // Here it should've assigned a default value only if `options.leniency === undefined`.\r\n      leniency: options.leniency || (options.extended ? 'POSSIBLE' : 'VALID'),\r\n      // Here it should've assigned a default value only if `options.maxTries === undefined`.\r\n      maxTries: options.maxTries || MAX_SAFE_INTEGER\r\n    }\r\n\r\n    // Validate `leniency`.\r\n\t\t// if (!options.leniency) {\r\n\t\t// \tthrow new TypeError('`leniency` is required')\r\n\t\t// }\r\n\t\tif (!Leniency[options.leniency]) {\r\n\t\t\tthrow new TypeError(`Unknown leniency: \"${options.leniency}\"`)\r\n\t\t}\r\n    if (options.leniency !== 'POSSIBLE' && options.leniency !== 'VALID') {\r\n      throw new TypeError(`Invalid \\`leniency\\`: \"${options.leniency}\". Supported values: \"POSSIBLE\", \"VALID\".`)\r\n    }\r\n\r\n    // Validate `maxTries`.\r\n\t\tif (options.maxTries < 0) {\r\n\t\t\tthrow new TypeError('`maxTries` must be `>= 0`')\r\n\t\t}\r\n\r\n\t\tthis.text = text\r\n\t\tthis.options = options\r\n    this.metadata = metadata\r\n\r\n\t\t// The degree of phone number validation.\r\n\t\tthis.leniency = Leniency[options.leniency]\r\n\r\n\t\t/** The maximum number of retries after matching an invalid number. */\r\n\t\tthis.maxTries = options.maxTries\r\n\r\n\t\tthis.PATTERN = new RegExp(PATTERN, 'ig')\r\n\r\n    /** The iteration tristate. */\r\n    this.state = 'NOT_READY'\r\n\r\n    /** The next index to start searching at. Undefined in {@link State#DONE}. */\r\n    this.searchIndex = 0\r\n\r\n    // A cache for frequently used country-specific regular expressions. Set to 32 to cover ~2-3\r\n    // countries being used for the same doc with ~10 patterns for each country. Some pages will have\r\n    // a lot more countries in use, but typically fewer numbers for each so expanding the cache for\r\n    // that use-case won't have a lot of benefit.\r\n    this.regExpCache = new RegExpCache(32)\r\n  }\r\n\r\n  /**\r\n   * Attempts to find the next subsequence in the searched sequence on or after {@code searchIndex}\r\n   * that represents a phone number. Returns the next match, null if none was found.\r\n   *\r\n   * @param index  the search index to start searching at\r\n   * @return  the phone number match found, null if none can be found\r\n   */\r\n\tfind() {\r\n\t\t// // Reset the regular expression.\r\n\t\t// this.PATTERN.lastIndex = index\r\n\r\n\t\tlet matches\r\n\t\twhile ((this.maxTries > 0) && (matches = this.PATTERN.exec(this.text)) !== null) {\r\n\t\t\tlet candidate = matches[0]\r\n\t\t\tconst offset = matches.index\r\n\r\n\t\t\tcandidate = parsePreCandidate(candidate)\r\n\r\n\t\t\tif (isValidPreCandidate(candidate, offset, this.text)) {\r\n\t\t\t\tconst match =\r\n\t\t\t\t\t// Try to come up with a valid match given the entire candidate.\r\n\t\t\t\t\tthis.parseAndVerify(candidate, offset, this.text)\r\n\t\t\t\t\t// If that failed, try to find an \"inner match\" -\r\n\t\t\t\t\t// there might be a phone number within this candidate.\r\n\t\t\t\t\t|| this.extractInnerMatch(candidate, offset, this.text)\r\n\r\n\t\t\t\tif (match) {\r\n\t\t\t\t\tif (this.options.v2) {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tstartsAt: match.startsAt,\r\n\t\t\t\t\t\t\tendsAt: match.endsAt,\r\n\t\t\t\t\t\t\tnumber: match.phoneNumber\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n            const { phoneNumber } = match\r\n\r\n            const result = {\r\n              startsAt: match.startsAt,\r\n              endsAt: match.endsAt,\r\n              phone: phoneNumber.nationalNumber\r\n            }\r\n\r\n            if (phoneNumber.country) {\r\n              /* istanbul ignore if */\r\n              if (USE_NON_GEOGRAPHIC_COUNTRY_CODE && country === '001') {\r\n                result.countryCallingCode = phoneNumber.countryCallingCode\r\n              } else {\r\n                result.country = phoneNumber.country\r\n              }\r\n            } else {\r\n              result.countryCallingCode = phoneNumber.countryCallingCode\r\n            }\r\n\r\n            if (phoneNumber.ext) {\r\n              result.ext = phoneNumber.ext\r\n            }\r\n\r\n            return result\r\n          }\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tthis.maxTries--\r\n\t\t}\r\n\t}\r\n\r\n  /**\r\n   * Attempts to extract a match from `substring`\r\n   * if the substring itself does not qualify as a match.\r\n   */\r\n  extractInnerMatch(substring, offset, text) {\r\n    for (const innerMatchPattern of INNER_MATCHES) {\r\n      let isFirstMatch = true\r\n      let candidateMatch\r\n      const innerMatchRegExp = new RegExp(innerMatchPattern, 'g')\r\n      while (this.maxTries > 0 && (candidateMatch = innerMatchRegExp.exec(substring)) !== null) {\r\n        if (isFirstMatch) {\r\n          // We should handle any group before this one too.\r\n          const candidate = trimAfterFirstMatch(\r\n            UNWANTED_END_CHAR_PATTERN,\r\n            substring.slice(0, candidateMatch.index)\r\n          )\r\n\r\n          const match = this.parseAndVerify(candidate, offset, text)\r\n\r\n          if (match) {\r\n            return match\r\n          }\r\n\r\n          this.maxTries--\r\n          isFirstMatch = false\r\n        }\r\n\r\n        const candidate = trimAfterFirstMatch(UNWANTED_END_CHAR_PATTERN, candidateMatch[1])\r\n\r\n        // Java code does `groupMatcher.start(1)` here,\r\n        // but there's no way in javascript to get a `candidate` start index,\r\n        // therefore resort to using this kind of an approximation.\r\n        // (`groupMatcher` is called `candidateInSubstringMatch` in this javascript port)\r\n        // https://stackoverflow.com/questions/15934353/get-index-of-each-capture-in-a-javascript-regex\r\n        const candidateIndexGuess = substring.indexOf(candidate, candidateMatch.index)\r\n\r\n        const match = this.parseAndVerify(candidate, offset + candidateIndexGuess, text)\r\n        if (match) {\r\n          return match\r\n        }\r\n\r\n        this.maxTries--\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Parses a phone number from the `candidate` using `parse` and\r\n   * verifies it matches the requested `leniency`. If parsing and verification succeed,\r\n   * a corresponding `PhoneNumberMatch` is returned, otherwise this method returns `null`.\r\n   *\r\n   * @param candidate  the candidate match\r\n   * @param offset  the offset of {@code candidate} within {@link #text}\r\n   * @return  the parsed and validated phone number match, or null\r\n   */\r\n  parseAndVerify(candidate, offset, text) {\r\n    if (!isValidCandidate(candidate, offset, text, this.options.leniency)) {\r\n      return\r\n  \t}\r\n\r\n    const phoneNumber = parsePhoneNumber(\r\n      candidate,\r\n      {\r\n        extended: true,\r\n        defaultCountry: this.options.defaultCountry,\r\n        defaultCallingCode: this.options.defaultCallingCode\r\n      },\r\n      this.metadata\r\n    )\r\n\r\n    if (!phoneNumber) {\r\n      return\r\n    }\r\n\r\n    if (!phoneNumber.isPossible()) {\r\n      return\r\n    }\r\n\r\n    if (this.leniency(phoneNumber, {\r\n      candidate,\r\n      defaultCountry: this.options.defaultCountry,\r\n      metadata: this.metadata,\r\n      regExpCache: this.regExpCache\r\n    })) {\r\n      return {\r\n        startsAt: offset,\r\n        endsAt: offset + candidate.length,\r\n        phoneNumber\r\n      }\r\n    }\r\n  }\r\n\r\n  hasNext()\r\n  {\r\n    if (this.state === 'NOT_READY')\r\n    {\r\n      this.lastMatch = this.find() // (this.searchIndex)\r\n\r\n      if (this.lastMatch)\r\n      {\r\n        // this.searchIndex = this.lastMatch.endsAt\r\n        this.state = 'READY'\r\n      }\r\n      else\r\n      {\r\n        this.state = 'DONE'\r\n      }\r\n    }\r\n\r\n    return this.state === 'READY'\r\n  }\r\n\r\n  next()\r\n  {\r\n    // Check the state and find the next match as a side-effect if necessary.\r\n    if (!this.hasNext())\r\n    {\r\n      throw new Error('No next element')\r\n    }\r\n\r\n    // Don't retain that memory any longer than necessary.\r\n    const result = this.lastMatch\r\n    this.lastMatch = null\r\n    this.state = 'NOT_READY'\r\n    return result\r\n  }\r\n}","import Metadata from './metadata.js'\r\nimport checkNumberLength from './helpers/checkNumberLength.js'\r\n\r\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 */\r\nexport default function isPossiblePhoneNumber(input, options, metadata) {\r\n\t/* istanbul ignore if */\r\n\tif (options === undefined) {\r\n\t\toptions = {}\r\n\t}\r\n\r\n\tmetadata = new Metadata(metadata)\r\n\r\n\tif (options.v2) {\r\n\t\tif (!input.countryCallingCode) {\r\n\t\t\tthrow new Error('Invalid phone number object passed')\r\n\t\t}\r\n\t\tmetadata.selectNumberingPlan(input.countryCallingCode)\r\n\t} else {\r\n\t\tif (!input.phone) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\tif (input.country) {\r\n\t\t\tif (!metadata.hasCountry(input.country)) {\r\n\t\t\t\tthrow new Error(`Unknown country: ${input.country}`)\r\n\t\t\t}\r\n\t\t\tmetadata.selectNumberingPlan(input.country)\r\n\t\t} else {\r\n\t\t\tif (!input.countryCallingCode) {\r\n\t\t\t\tthrow new Error('Invalid phone number object passed')\r\n\t\t\t}\r\n\t\t\tmetadata.selectNumberingPlan(input.countryCallingCode)\r\n\t\t}\r\n\t}\r\n\r\n\t// Old metadata (< 1.0.18) had no \"possible length\" data.\r\n\tif (metadata.possibleLengths()) {\r\n\t\treturn isPossibleNumber(input.phone || input.nationalNumber, input.country, metadata)\r\n\t} else {\r\n\t\t// There was a bug between `1.7.35` and `1.7.37` where \"possible_lengths\"\r\n\t\t// were missing for \"non-geographical\" numbering plans.\r\n\t\t// Just assume the number is possible in such cases:\r\n\t\t// it's unlikely that anyone generated their custom metadata\r\n\t\t// in that short period of time (one day).\r\n\t\t// This code can be removed in some future major version update.\r\n\t\tif (input.countryCallingCode && metadata.isNonGeographicCallingCode(input.countryCallingCode)) {\r\n\t\t\t// \"Non-geographic entities\" did't have `possibleLengths`\r\n\t\t\t// due to a bug in metadata generation process.\r\n\t\t\treturn true\r\n\t\t} else {\r\n\t\t\tthrow new Error('Missing \"possibleLengths\" in metadata. Perhaps the metadata has been generated before v1.0.18.');\r\n\t\t}\r\n\t}\r\n}\r\n\r\nexport function isPossibleNumber(nationalNumber, country, metadata) { //, isInternational) {\r\n\tswitch (checkNumberLength(nationalNumber, country, metadata)) {\r\n\t\tcase 'IS_POSSIBLE':\r\n\t\t\treturn true\r\n\t\t// This library ignores \"local-only\" phone numbers (for simplicity).\r\n\t\t// See the readme for more info on what are \"local-only\" phone numbers.\r\n\t\t// case 'IS_POSSIBLE_LOCAL_ONLY':\r\n\t\t// \treturn !isInternational\r\n\t\tdefault:\r\n\t\t\treturn false\r\n\t}\r\n}","/** Returns a regular expression quantifier with an upper and lower limit. */\r\nexport function limit(lower, upper)\r\n{\r\n\tif ((lower < 0) || (upper <= 0) || (upper < lower)) {\r\n\t\tthrow new TypeError()\r\n\t}\r\n\treturn `{${lower},${upper}}`\r\n}\r\n\r\n/**\r\n * Trims away any characters after the first match of {@code pattern} in {@code candidate},\r\n * returning the trimmed version.\r\n */\r\nexport function trimAfterFirstMatch(regexp, string)\r\n{\r\n\tconst index = string.search(regexp)\r\n\r\n\tif (index >= 0) {\r\n\t\treturn string.slice(0, index)\r\n\t}\r\n\r\n\treturn string\r\n}\r\n\r\nexport function startsWith(string, substring)\r\n{\r\n\treturn string.indexOf(substring) === 0\r\n}\r\n\r\nexport function endsWith(string, substring)\r\n{\r\n\treturn string.indexOf(substring, string.length - substring.length) === string.length - substring.length\r\n}\r\n","import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber.js'\r\nimport matchesEntirely from './matchesEntirely.js'\r\nimport checkNumberLength from './checkNumberLength.js'\r\nimport getCountryByCallingCode from './getCountryByCallingCode.js'\r\n\r\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  {string?} country — Country, if known.\r\n * @param  {Metadata} metadata — Metadata with a phone numbering plan selected.\r\n * @return {object} `{ nationalNumber: string, carrierCode: string? }`.\r\n */\r\nexport default function extractNationalNumber(number, country, metadata) {\r\n\t// Parsing national prefixes and carrier codes\r\n\t// is only required for local phone numbers\r\n\t// but some people don't understand that\r\n\t// and sometimes write international phone numbers\r\n\t// with national prefixes (or maybe even carrier codes).\r\n\t// http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html\r\n\t// Google's original library forgives such mistakes\r\n\t// and so does this library, because it has been requested:\r\n\t// https://github.com/catamphetamine/libphonenumber-js/issues/127\r\n\tconst {\r\n\t\tcarrierCode,\r\n\t\tnationalNumber\r\n\t} = extractNationalNumberFromPossiblyIncompleteNumber(\r\n\t\tnumber,\r\n\t\tmetadata\r\n\t)\r\n\r\n\tif (nationalNumber !== number) {\r\n\t\tif (!shouldHaveExtractedNationalPrefix(number, nationalNumber, metadata)) {\r\n\t\t\t// Don't strip the national prefix.\r\n\t\t\treturn { nationalNumber: number }\r\n\t\t}\r\n\t\t// Check the national (significant) number length after extracting national prefix and carrier code.\r\n\t\t// Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature.\r\n\t\tif (metadata.numberingPlan.possibleLengths()) {\r\n\t\t\t// If an exact `country` is not specified, attempt to detect it from the assumed national number.\r\n\t\t\tif (!country) {\r\n\t\t\t\tcountry = getCountryByCallingCode(metadata.numberingPlan.callingCode(), {\r\n\t\t\t\t\tnationalNumber,\r\n\t\t\t\t\tmetadata\r\n\t\t\t\t})\r\n\t\t\t}\r\n\r\n\t\t\t// The number remaining after stripping the national prefix and carrier code\r\n\t\t\t// should be long enough to have a possible length for the country.\r\n\t\t\t// Otherwise, don't strip the national prefix and carrier code,\r\n\t\t\t// since the original number could be a valid number.\r\n\t\t\t// This check has been copy-pasted \"as is\" from Google's original library:\r\n\t\t\t// https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250\r\n\t\t\t// It doesn't check for the \"possibility\" of the original `number`.\r\n\t\t\t// I guess it's fine not checking that one. It works as is anyway.\r\n\t\t\tif (!isPossibleIncompleteNationalNumber(nationalNumber, country, metadata)) {\r\n\t\t\t\t// Don't strip the national prefix.\r\n\t\t\t\treturn { nationalNumber: number }\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\treturn { nationalNumber, carrierCode }\r\n}\r\n\r\n// In some countries, the same digit could be a national prefix\r\n// or a leading digit of a valid phone number.\r\n// For example, in Russia, national prefix is `8`,\r\n// and also `800 555 35 35` is a valid number\r\n// in which `8` is not a national prefix, but the first digit\r\n// of a national (significant) number.\r\n// Same's with Belarus:\r\n// `82004910060` is a valid national (significant) number,\r\n// but `2004910060` is not.\r\n// To support such cases (to prevent the code from always stripping\r\n// national prefix), a condition is imposed: a national prefix\r\n// is not extracted when the original number is \"viable\" and the\r\n// resultant number is not, a \"viable\" national number being the one\r\n// that matches `national_number_pattern`.\r\nfunction shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberAfter, metadata) {\r\n\t// The equivalent in Google's code is:\r\n\t// https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004\r\n\tif (matchesEntirely(nationalNumberBefore, metadata.nationalNumberPattern()) &&\r\n\t\t!matchesEntirely(nationalNumberAfter, metadata.nationalNumberPattern())) {\r\n\t\treturn false\r\n\t}\r\n\t// This \"is possible\" national number (length) check has been commented out\r\n\t// because it's superceded by the (effectively) same check done in the\r\n\t// `extractNationalNumber()` function after it calls `shouldHaveExtractedNationalPrefix()`.\r\n\t// In other words, why run the same check twice if it could only be run once.\r\n\t// // Check the national (significant) number length after extracting national prefix and carrier code.\r\n\t// // Fixes a minor \"weird behavior\" bug: https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/57\r\n\t// // (Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature).\r\n\t// if (metadata.possibleLengths()) {\r\n\t// \tif (isPossibleIncompleteNationalNumber(nationalNumberBefore, metadata) &&\r\n\t// \t\t!isPossibleIncompleteNationalNumber(nationalNumberAfter, metadata)) {\r\n\t// \t\treturn false\r\n\t// \t}\r\n\t// }\r\n\treturn true\r\n}\r\n\r\nfunction isPossibleIncompleteNationalNumber(nationalNumber, country, metadata) {\r\n\tswitch (checkNumberLength(nationalNumber, country, metadata)) {\r\n\t\tcase 'TOO_SHORT':\r\n\t\tcase 'INVALID_LENGTH':\r\n\t\t// This library ignores \"local-only\" phone numbers (for simplicity).\r\n\t\t// See the readme for more info on what are \"local-only\" phone numbers.\r\n\t\t// case 'IS_POSSIBLE_LOCAL_ONLY':\r\n\t\t\treturn false\r\n\t\tdefault:\r\n\t\t\treturn true\r\n\t}\r\n}","import {\r\n\tMIN_LENGTH_FOR_NSN,\r\n\tVALID_DIGITS,\r\n\tVALID_PUNCTUATION,\r\n\tPLUS_CHARS\r\n} from '../constants.js'\r\n\r\nimport createExtensionPattern from './extension/createExtensionPattern.js'\r\n\r\n//  Regular expression of viable phone numbers. This is location independent.\r\n//  Checks we have at least three leading digits, and only valid punctuation,\r\n//  alpha characters and digits in the phone number. Does not include extension\r\n//  data. The symbol 'x' is allowed here as valid punctuation since it is often\r\n//  used as a placeholder for carrier codes, for example in Brazilian phone\r\n//  numbers. We also allow multiple '+' characters at the start.\r\n//\r\n//  Corresponds to the following:\r\n//  [digits]{minLengthNsn}|\r\n//  plus_sign*\r\n//  (([punctuation]|[star])*[digits]){3,}([punctuation]|[star]|[digits]|[alpha])*\r\n//\r\n//  The first reg-ex is to allow short numbers (two digits long) to be parsed if\r\n//  they are entered as \"15\" etc, but only if there is no punctuation in them.\r\n//  The second expression restricts the number of digits to three or more, but\r\n//  then allows them to be in international form, and to have alpha-characters\r\n//  and punctuation. We split up the two reg-exes here and combine them when\r\n//  creating the reg-ex VALID_PHONE_NUMBER_PATTERN itself so we can prefix it\r\n//  with ^ and append $ to each branch.\r\n//\r\n//  \"Note VALID_PUNCTUATION starts with a -,\r\n//   so must be the first in the range\" (c) Google devs.\r\n//  (wtf did they mean by saying that; probably nothing)\r\n//\r\nconst MIN_LENGTH_PHONE_NUMBER_PATTERN = '[' + VALID_DIGITS + ']{' + MIN_LENGTH_FOR_NSN + '}'\r\n//\r\n// And this is the second reg-exp:\r\n// (see MIN_LENGTH_PHONE_NUMBER_PATTERN for a full description of this reg-exp)\r\n//\r\nexport const VALID_PHONE_NUMBER =\r\n\t'[' + PLUS_CHARS + ']{0,1}' +\r\n\t'(?:' +\r\n\t\t'[' + VALID_PUNCTUATION + ']*' +\r\n\t\t'[' + VALID_DIGITS + ']' +\r\n\t'){3,}' +\r\n\t'[' +\r\n\t\tVALID_PUNCTUATION +\r\n\t\tVALID_DIGITS +\r\n\t']*'\r\n\r\n// This regular expression isn't present in Google's `libphonenumber`\r\n// and is only used to determine whether the phone number being input\r\n// is too short for it to even consider it a \"valid\" number.\r\n// This is just a way to differentiate between a really invalid phone\r\n// number like \"abcde\" and a valid phone number that a user has just\r\n// started inputting, like \"+1\" or \"1\": both these cases would be\r\n// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this\r\n// library can provide a more detailed error message — whether it's\r\n// really \"not a number\", or is it just a start of a valid phone number.\r\nconst VALID_PHONE_NUMBER_START_REG_EXP = new RegExp(\r\n\t'^' +\r\n\t'[' + PLUS_CHARS + ']{0,1}' +\r\n\t'(?:' +\r\n\t\t'[' + VALID_PUNCTUATION + ']*' +\r\n\t\t'[' + VALID_DIGITS + ']' +\r\n\t'){1,2}' +\r\n\t'$'\r\n, 'i')\r\n\r\nexport const VALID_PHONE_NUMBER_WITH_EXTENSION =\r\n\tVALID_PHONE_NUMBER +\r\n\t// Phone number extensions\r\n\t'(?:' + createExtensionPattern() + ')?'\r\n\r\n// The combined regular expression for valid phone numbers:\r\n//\r\nconst VALID_PHONE_NUMBER_PATTERN = new RegExp(\r\n\t// Either a short two-digit-only phone number\r\n\t'^' +\r\n\t\tMIN_LENGTH_PHONE_NUMBER_PATTERN +\r\n\t'$' +\r\n\t'|' +\r\n\t// Or a longer fully parsed phone number (min 3 characters)\r\n\t'^' +\r\n\t\tVALID_PHONE_NUMBER_WITH_EXTENSION +\r\n\t'$'\r\n, 'i')\r\n\r\n// Checks to see if the string of characters could possibly be a phone number at\r\n// all. At the moment, checks to see that the string begins with at least 2\r\n// digits, ignoring any punctuation commonly found in phone numbers. This method\r\n// does not require the number to be normalized in advance - but does assume\r\n// that leading non-number symbols have been removed, such as by the method\r\n// `extract_possible_number`.\r\n//\r\nexport default function isViablePhoneNumber(number) {\r\n\treturn number.length >= MIN_LENGTH_FOR_NSN &&\r\n\t\tVALID_PHONE_NUMBER_PATTERN.test(number)\r\n}\r\n\r\n// This is just a way to differentiate between a really invalid phone\r\n// number like \"abcde\" and a valid phone number that a user has just\r\n// started inputting, like \"+1\" or \"1\": both these cases would be\r\n// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this\r\n// library can provide a more detailed error message — whether it's\r\n// really \"not a number\", or is it just a start of a valid phone number.\r\nexport function isViablePhoneNumberStart(number) {\r\n\treturn VALID_PHONE_NUMBER_START_REG_EXP.test(number)\r\n}","import Metadata from './metadata.js'\r\n\r\nexport default function getCountries(metadata) {\r\n\treturn new Metadata(metadata).getCountries()\r\n}","import PhoneNumberMatcher from './PhoneNumberMatcher.js'\r\nimport normalizeArguments from './normalizeArguments.js'\r\n\r\nexport default function findPhoneNumbersInText() {\r\n\tconst { text, options, metadata } = normalizeArguments(arguments)\r\n\tconst matcher = new PhoneNumberMatcher(text, { ...options, v2: true }, metadata)\r\n\tconst results = []\r\n\twhile (matcher.hasNext()) {\r\n\t\tresults.push(matcher.next())\r\n\t}\r\n\treturn results\r\n}","import { parseDigit } from './helpers/parseDigits.js'\r\n\r\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 */\r\nexport default function parseIncompletePhoneNumber(string) {\r\n\tlet result = ''\r\n\t// Using `.split('')` here instead of normal `for ... of`\r\n\t// because the importing application doesn't neccessarily include an ES6 polyfill.\r\n\t// The `.split('')` approach discards \"exotic\" UTF-8 characters\r\n\t// (the ones consisting of four bytes) but digits\r\n\t// (including non-European ones) don't fall into that range\r\n\t// so such \"exotic\" characters would be discarded anyway.\r\n\tfor (const character of string.split('')) {\r\n\t\tresult += parsePhoneNumberCharacter(character, result) || ''\r\n\t}\r\n\treturn result\r\n}\r\n\r\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  {function?} eventListener - An optional \"on event\" function.\r\n * @return {string?} The parsed character.\r\n */\r\nexport function parsePhoneNumberCharacter(character, prevParsedCharacters, eventListener) {\r\n\t// Only allow a leading `+`.\r\n\tif (character === '+') {\r\n\t\t// If this `+` is not the first parsed character\r\n\t\t// then discard it.\r\n\t\tif (prevParsedCharacters) {\r\n\t\t\t// `eventListener` argument was added to this `export`ed function on Dec 26th, 2023.\r\n\t\t\t// Any 3rd-party code that used to `import` and call this function before that\r\n\t\t\t// won't be passing any `eventListener` argument.\r\n\t\t\t//\r\n\t\t\t// The addition of the `eventListener` argument was to fix the slightly-weird behavior\r\n\t\t\t// of parsing an input string when the user inputs something like `\"2+7\"\r\n\t\t\t// https://github.com/catamphetamine/react-phone-number-input/issues/437\r\n\t\t\t//\r\n\t\t\t// If the parser encounters an unexpected `+` in a string being parsed\r\n\t\t\t// then it simply discards that out-of-place `+` and any following characters.\r\n\t\t\t//\r\n\t\t\tif (typeof eventListener === 'function') {\r\n\t\t\t\teventListener('end')\r\n\t\t\t}\r\n\t\t\treturn\r\n\t\t}\r\n\t\treturn '+'\r\n\t}\r\n\t// Allow digits.\r\n\treturn parseDigit(character)\r\n}","// Copy-pasted from `PhoneNumberMatcher.js`.\r\n\r\nimport { PLUS_CHARS } from '../constants.js'\r\nimport { limit } from './util.js'\r\n\r\nimport {\r\n\tisLatinLetter,\r\n\tisInvalidPunctuationSymbol\r\n} from './utf-8.js'\r\n\r\nconst OPENING_PARENS = '(\\\\[\\uFF08\\uFF3B'\r\nconst CLOSING_PARENS = ')\\\\]\\uFF09\\uFF3D'\r\nconst NON_PARENS = `[^${OPENING_PARENS}${CLOSING_PARENS}]`\r\n\r\nexport const LEAD_CLASS = `[${OPENING_PARENS}${PLUS_CHARS}]`\r\n\r\n// Punctuation that may be at the start of a phone number - brackets and plus signs.\r\nconst LEAD_CLASS_LEADING = new RegExp('^' + LEAD_CLASS)\r\n\r\n// Limit on the number of pairs of brackets in a phone number.\r\nconst BRACKET_PAIR_LIMIT = limit(0, 3)\r\n\r\n/**\r\n * Pattern to check that brackets match. Opening brackets should be closed within a phone number.\r\n * This also checks that there is something inside the brackets. Having no brackets at all is also\r\n * fine.\r\n *\r\n * An opening bracket at the beginning may not be closed, but subsequent ones should be.  It's\r\n * also possible that the leading bracket was dropped, so we shouldn't be surprised if we see a\r\n * closing bracket first. We limit the sets of brackets in a phone number to four.\r\n */\r\nconst MATCHING_BRACKETS_ENTIRE = new RegExp\r\n(\r\n\t'^'\r\n\t+ \"(?:[\" + OPENING_PARENS + \"])?\" + \"(?:\" + NON_PARENS + \"+\" + \"[\" + CLOSING_PARENS + \"])?\"\r\n\t+ NON_PARENS + \"+\"\r\n\t+ \"(?:[\" + OPENING_PARENS + \"]\" + NON_PARENS + \"+[\" + CLOSING_PARENS + \"])\" + BRACKET_PAIR_LIMIT\r\n\t+ NON_PARENS + \"*\"\r\n\t+ '$'\r\n)\r\n\r\n/**\r\n * Matches strings that look like publication pages. Example:\r\n * <pre>Computing Complete Answers to Queries in the Presence of Limited Access Patterns.\r\n * Chen Li. VLDB J. 12(3): 211-227 (2003).</pre>\r\n *\r\n * The string \"211-227 (2003)\" is not a telephone number.\r\n */\r\nconst PUB_PAGES = /\\d{1,5}-+\\d{1,5}\\s{0,4}\\(\\d{1,4}/\r\n\r\nexport default function isValidCandidate(candidate, offset, text, leniency)\r\n{\r\n\t// Check the candidate doesn't contain any formatting\r\n\t// which would indicate that it really isn't a phone number.\r\n\tif (!MATCHING_BRACKETS_ENTIRE.test(candidate) || PUB_PAGES.test(candidate)) {\r\n\t\treturn\r\n\t}\r\n\r\n\t// If leniency is set to VALID or stricter, we also want to skip numbers that are surrounded\r\n\t// by Latin alphabetic characters, to skip cases like abc8005001234 or 8005001234def.\r\n\tif (leniency !== 'POSSIBLE')\r\n\t{\r\n\t\t// If the candidate is not at the start of the text,\r\n\t\t// and does not start with phone-number punctuation,\r\n\t\t// check the previous character.\r\n\t\tif (offset > 0 && !LEAD_CLASS_LEADING.test(candidate))\r\n\t\t{\r\n\t\t\tconst previousChar = text[offset - 1]\r\n\t\t\t// We return null if it is a latin letter or an invalid punctuation symbol.\r\n\t\t\tif (isInvalidPunctuationSymbol(previousChar) || isLatinLetter(previousChar)) {\r\n\t\t\t\treturn false\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst lastCharIndex = offset + candidate.length\r\n\t\tif (lastCharIndex < text.length)\r\n\t\t{\r\n\t\t\tconst nextChar = text[lastCharIndex]\r\n\t\t\tif (isInvalidPunctuationSymbol(nextChar) || isLatinLetter(nextChar)) {\r\n\t\t\t\treturn false\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\treturn true\r\n}","import isViablePhoneNumber from './isViablePhoneNumber.js'\r\n\r\n// https://www.ietf.org/rfc/rfc3966.txt\r\n\r\n/**\r\n * @param  {string} text - Phone URI (RFC 3966).\r\n * @return {object} `{ ?number, ?ext }`.\r\n */\r\nexport function parseRFC3966(text) {\r\n\tlet number\r\n\tlet ext\r\n\r\n\t// Replace \"tel:\" with \"tel=\" for parsing convenience.\r\n\ttext = text.replace(/^tel:/, 'tel=')\r\n\r\n\tfor (const part of text.split(';')) {\r\n\t\tconst [name, value] = part.split('=')\r\n\t\tswitch (name) {\r\n\t\t\tcase 'tel':\r\n\t\t\t\tnumber = value\r\n\t\t\t\tbreak\r\n\t\t\tcase 'ext':\r\n\t\t\t\text = value\r\n\t\t\t\tbreak\r\n\t\t\tcase 'phone-context':\r\n\t\t\t\t// Only \"country contexts\" are supported.\r\n\t\t\t\t// \"Domain contexts\" are ignored.\r\n\t\t\t\tif (value[0] === '+') {\r\n\t\t\t\t\tnumber = value + number\r\n\t\t\t\t}\r\n\t\t\t\tbreak\r\n\t\t}\r\n\t}\r\n\r\n\t// If the phone number is not viable, then abort.\r\n\tif (!isViablePhoneNumber(number)) {\r\n\t\treturn {}\r\n\t}\r\n\r\n\tconst result = { number }\r\n\tif (ext) {\r\n\t\tresult.ext = ext\r\n\t}\r\n\treturn result\r\n}\r\n\r\n/**\r\n * @param  {object} - `{ ?number, ?extension }`.\r\n * @return {string} Phone URI (RFC 3966).\r\n */\r\nexport function formatRFC3966({ number, ext }) {\r\n\tif (!number) {\r\n\t\treturn ''\r\n\t}\r\n\tif (number[0] !== '+') {\r\n\t\tthrow new Error(`\"formatRFC3966()\" expects \"number\" to be in E.164 format.`)\r\n\t}\r\n\treturn `tel:${number}${ext ? ';ext=' + ext : ''}`\r\n}","import parsePhoneNumberWithError from './parsePhoneNumberWithError_.js'\r\nimport ParseError from './ParseError.js'\r\nimport { isSupportedCountry } from './metadata.js'\r\n\r\nexport default function parsePhoneNumber(text, options, metadata) {\r\n\t// Validate `defaultCountry`.\r\n\tif (options && options.defaultCountry && !isSupportedCountry(options.defaultCountry, metadata)) {\r\n\t\toptions = {\r\n\t\t\t...options,\r\n\t\t\tdefaultCountry: undefined\r\n\t\t}\r\n\t}\r\n\t// Parse phone number.\r\n\ttry {\r\n\t\treturn parsePhoneNumberWithError(text, options, metadata)\r\n\t} catch (error) {\r\n\t\t/* istanbul ignore else */\r\n\t\tif (error instanceof ParseError) {\r\n\t\t\t//\r\n\t\t} else {\r\n\t\t\tthrow error\r\n\t\t}\r\n\t}\r\n}\r\n","import Metadata from './metadata.js'\r\nimport matchesEntirely from './helpers/matchesEntirely.js'\r\nimport getNumberType from './helpers/getNumberType.js'\r\n\r\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 */\r\nexport default function isValidNumber(input, options, metadata)\r\n{\r\n\t// If assigning the `{}` default value is moved to the arguments above,\r\n\t// code coverage would decrease for some weird reason.\r\n\toptions = options || {}\r\n\r\n\tmetadata = new Metadata(metadata)\r\n\r\n\tmetadata.selectNumberingPlan(input.country, input.countryCallingCode)\r\n\r\n\t// By default, countries only have type regexps when it's required for\r\n\t// distinguishing different countries having the same `countryCallingCode`.\r\n\tif (metadata.hasTypes()) {\r\n\t\treturn getNumberType(input, options, metadata.metadata) !== undefined\r\n\t}\r\n\r\n\t// If there are no type regexps for this country in metadata then use\r\n\t// `nationalNumberPattern` as a \"better than nothing\" replacement.\r\n\tconst nationalNumber = options.v2 ? input.nationalNumber : input.phone\r\n\treturn matchesEntirely(nationalNumber, metadata.nationalNumberPattern())\r\n}","// Copy-pasted from:\r\n// https://github.com/substack/semver-compare/blob/master/index.js\r\n//\r\n// Inlining this function because some users reported issues with\r\n// importing from `semver-compare` in a browser with ES6 \"native\" modules.\r\n//\r\n// Fixes `semver-compare` not being able to compare versions with alpha/beta/etc \"tags\".\r\n// https://github.com/catamphetamine/libphonenumber-js/issues/381\r\nexport default function(a, b) {\r\n    a = a.split('-')\r\n    b = b.split('-')\r\n    var pa = a[0].split('.')\r\n    var pb = b[0].split('.')\r\n    for (var i = 0; i < 3; i++) {\r\n        var na = Number(pa[i])\r\n        var nb = Number(pb[i])\r\n        if (na > nb) return 1\r\n        if (nb > na) return -1\r\n        if (!isNaN(na) && isNaN(nb)) return 1\r\n        if (isNaN(na) && !isNaN(nb)) return -1\r\n    }\r\n    if (a[1] && b[1]) {\r\n        return a[1] > b[1] ? 1 : (a[1] < b[1] ? -1 : 0)\r\n    }\r\n    return !a[1] && b[1] ? 1 : (a[1] && !b[1] ? -1 : 0)\r\n}","import compare from './tools/semver-compare.js'\r\nimport isObject from './helpers/isObject.js'\r\n\r\n// Added \"possibleLengths\" and renamed\r\n// \"country_phone_code_to_countries\" to \"country_calling_codes\".\r\nconst V2 = '1.0.18'\r\n\r\n// Added \"idd_prefix\" and \"default_idd_prefix\".\r\nconst V3 = '1.2.0'\r\n\r\n// Moved `001` country code to \"nonGeographic\" section of metadata.\r\nconst V4 = '1.7.35'\r\n\r\nconst DEFAULT_EXT_PREFIX = ' ext. '\r\n\r\nconst CALLING_CODE_REG_EXP = /^\\d+$/\r\n\r\n/**\r\n * See: https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md\r\n */\r\nexport default class Metadata {\r\n\tconstructor(metadata) {\r\n\t\tvalidateMetadata(metadata)\r\n\t\tthis.metadata = metadata\r\n\t\tsetVersion.call(this, metadata)\r\n\t}\r\n\r\n\tgetCountries() {\r\n\t\treturn Object.keys(this.metadata.countries).filter(_ => _ !== '001')\r\n\t}\r\n\r\n\tgetCountryMetadata(countryCode) {\r\n\t\treturn this.metadata.countries[countryCode]\r\n\t}\r\n\r\n\tnonGeographic() {\r\n\t\tif (this.v1 || this.v2 || this.v3) return\r\n\t\t// `nonGeographical` was a typo.\r\n\t\t// It's present in metadata generated from `1.7.35` to `1.7.37`.\r\n\t\t// The test case could be found by searching for \"nonGeographical\".\r\n\t\treturn this.metadata.nonGeographic || this.metadata.nonGeographical\r\n\t}\r\n\r\n\thasCountry(country) {\r\n\t\treturn this.getCountryMetadata(country) !== undefined\r\n\t}\r\n\r\n\thasCallingCode(callingCode) {\r\n\t\tif (this.getCountryCodesForCallingCode(callingCode)) {\r\n\t\t\treturn true\r\n\t\t}\r\n\t\tif (this.nonGeographic()) {\r\n\t\t\tif (this.nonGeographic()[callingCode]) {\r\n\t\t\t\treturn true\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\t// A hacky workaround for old custom metadata (generated before V4).\r\n\t\t\tconst countryCodes = this.countryCallingCodes()[callingCode]\r\n\t\t\tif (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {\r\n\t\t\t\treturn true\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tisNonGeographicCallingCode(callingCode) {\r\n\t\tif (this.nonGeographic()) {\r\n\t\t\treturn this.nonGeographic()[callingCode] ? true : false\r\n\t\t} else {\r\n\t\t\treturn this.getCountryCodesForCallingCode(callingCode) ? false : true\r\n\t\t}\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tcountry(countryCode) {\r\n\t\treturn this.selectNumberingPlan(countryCode)\r\n\t}\r\n\r\n\tselectNumberingPlan(countryCode, callingCode) {\r\n\t\t// Supports just passing `callingCode` as the first argument.\r\n\t\tif (countryCode && CALLING_CODE_REG_EXP.test(countryCode)) {\r\n\t\t\tcallingCode = countryCode\r\n\t\t\tcountryCode = null\r\n\t\t}\r\n\t\tif (countryCode && countryCode !== '001') {\r\n\t\t\tif (!this.hasCountry(countryCode)) {\r\n\t\t\t\tthrow new Error(`Unknown country: ${countryCode}`)\r\n\t\t\t}\r\n\t\t\tthis.numberingPlan = new NumberingPlan(this.getCountryMetadata(countryCode), this)\r\n\t\t} else if (callingCode) {\r\n\t\t\tif (!this.hasCallingCode(callingCode)) {\r\n\t\t\t\tthrow new Error(`Unknown calling code: ${callingCode}`)\r\n\t\t\t}\r\n\t\t\tthis.numberingPlan = new NumberingPlan(this.getNumberingPlanMetadata(callingCode), this)\r\n\t\t} else {\r\n\t\t\tthis.numberingPlan = undefined\r\n\t\t}\r\n\t\treturn this\r\n\t}\r\n\r\n\tgetCountryCodesForCallingCode(callingCode) {\r\n\t\tconst countryCodes = this.countryCallingCodes()[callingCode]\r\n\t\tif (countryCodes) {\r\n\t\t\t// Metadata before V4 included \"non-geographic entity\" calling codes\r\n\t\t\t// inside `country_calling_codes` (for example, `\"881\":[\"001\"]`).\r\n\t\t\t// Now the semantics of `country_calling_codes` has changed:\r\n\t\t\t// it's specifically for \"countries\" now.\r\n\t\t\t// Older versions of custom metadata will simply skip parsing\r\n\t\t\t// \"non-geographic entity\" phone numbers with new versions\r\n\t\t\t// of this library: it's not considered a bug,\r\n\t\t\t// because such numbers are extremely rare,\r\n\t\t\t// and developers extremely rarely use custom metadata.\r\n\t\t\tif (countryCodes.length === 1 && countryCodes[0].length === 3) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\t\t\treturn countryCodes\r\n\t\t}\r\n\t}\r\n\r\n\tgetCountryCodeForCallingCode(callingCode) {\r\n\t\tconst countryCodes = this.getCountryCodesForCallingCode(callingCode)\r\n\t\tif (countryCodes) {\r\n\t\t\treturn countryCodes[0]\r\n\t\t}\r\n\t}\r\n\r\n\tgetNumberingPlanMetadata(callingCode) {\r\n\t\tconst countryCode = this.getCountryCodeForCallingCode(callingCode)\r\n\t\tif (countryCode) {\r\n\t\t\treturn this.getCountryMetadata(countryCode)\r\n\t\t}\r\n\t\tif (this.nonGeographic()) {\r\n\t\t\tconst metadata = this.nonGeographic()[callingCode]\r\n\t\t\tif (metadata) {\r\n\t\t\t\treturn metadata\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\t// A hacky workaround for old custom metadata (generated before V4).\r\n\t\t\t// In that metadata, there was no concept of \"non-geographic\" metadata\r\n\t\t\t// so metadata for `001` country code was stored along with other countries.\r\n\t\t\t// The test case can be found by searching for:\r\n\t\t\t// \"should work around `nonGeographic` metadata not existing\".\r\n\t\t\tconst countryCodes = this.countryCallingCodes()[callingCode]\r\n\t\t\tif (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {\r\n\t\t\t\treturn this.metadata.countries['001']\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tcountryCallingCode() {\r\n\t\treturn this.numberingPlan.callingCode()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tIDDPrefix() {\r\n\t\treturn this.numberingPlan.IDDPrefix()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tdefaultIDDPrefix() {\r\n\t\treturn this.numberingPlan.defaultIDDPrefix()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tnationalNumberPattern() {\r\n\t\treturn this.numberingPlan.nationalNumberPattern()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tpossibleLengths() {\r\n\t\treturn this.numberingPlan.possibleLengths()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tformats() {\r\n\t\treturn this.numberingPlan.formats()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tnationalPrefixForParsing() {\r\n\t\treturn this.numberingPlan.nationalPrefixForParsing()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tnationalPrefixTransformRule() {\r\n\t\treturn this.numberingPlan.nationalPrefixTransformRule()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tleadingDigits() {\r\n\t\treturn this.numberingPlan.leadingDigits()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\thasTypes() {\r\n\t\treturn this.numberingPlan.hasTypes()\r\n\t}\r\n\r\n\t// Deprecated.\r\n\ttype(type) {\r\n\t\treturn this.numberingPlan.type(type)\r\n\t}\r\n\r\n\t// Deprecated.\r\n\text() {\r\n\t\treturn this.numberingPlan.ext()\r\n\t}\r\n\r\n\tcountryCallingCodes() {\r\n\t\tif (this.v1) return this.metadata.country_phone_code_to_countries\r\n\t\treturn this.metadata.country_calling_codes\r\n\t}\r\n\r\n\t// Deprecated.\r\n\tchooseCountryByCountryCallingCode(callingCode) {\r\n\t\treturn this.selectNumberingPlan(callingCode)\r\n\t}\r\n\r\n\thasSelectedNumberingPlan() {\r\n\t\treturn this.numberingPlan !== undefined\r\n\t}\r\n}\r\n\r\nclass NumberingPlan {\r\n\tconstructor(metadata, globalMetadataObject) {\r\n\t\tthis.globalMetadataObject = globalMetadataObject\r\n\t\tthis.metadata = metadata\r\n\t\tsetVersion.call(this, globalMetadataObject.metadata)\r\n\t}\r\n\r\n\tcallingCode() {\r\n\t\treturn this.metadata[0]\r\n\t}\r\n\r\n\t// Formatting information for regions which share\r\n\t// a country calling code is contained by only one region\r\n\t// for performance reasons. For example, for NANPA region\r\n\t// (\"North American Numbering Plan Administration\",\r\n\t//  which includes USA, Canada, Cayman Islands, Bahamas, etc)\r\n\t// it will be contained in the metadata for `US`.\r\n\tgetDefaultCountryMetadataForRegion() {\r\n\t\treturn this.globalMetadataObject.getNumberingPlanMetadata(this.callingCode())\r\n\t}\r\n\r\n\t// Is always present.\r\n\tIDDPrefix() {\r\n\t\tif (this.v1 || this.v2) return\r\n\t\treturn this.metadata[1]\r\n\t}\r\n\r\n\t// Is only present when a country supports multiple IDD prefixes.\r\n\tdefaultIDDPrefix() {\r\n\t\tif (this.v1 || this.v2) return\r\n\t\treturn this.metadata[12]\r\n\t}\r\n\r\n\tnationalNumberPattern() {\r\n\t\tif (this.v1 || this.v2) return this.metadata[1]\r\n\t\treturn this.metadata[2]\r\n\t}\r\n\r\n\t// \"possible length\" data is always present in Google's metadata.\r\n\tpossibleLengths() {\r\n\t\tif (this.v1) return\r\n\t\treturn this.metadata[this.v2 ? 2 : 3]\r\n\t}\r\n\r\n\t_getFormats(metadata) {\r\n\t\treturn metadata[this.v1 ? 2 : this.v2 ? 3 : 4]\r\n\t}\r\n\r\n\t// For countries of the same region (e.g. NANPA)\r\n\t// formats are all stored in the \"main\" country for that region.\r\n\t// E.g. \"RU\" and \"KZ\", \"US\" and \"CA\".\r\n\tformats() {\r\n\t\tconst formats = this._getFormats(this.metadata) || this._getFormats(this.getDefaultCountryMetadataForRegion()) || []\r\n\t\treturn formats.map(_ => new Format(_, this))\r\n\t}\r\n\r\n\tnationalPrefix() {\r\n\t\treturn this.metadata[this.v1 ? 3 : this.v2 ? 4 : 5]\r\n\t}\r\n\r\n\t_getNationalPrefixFormattingRule(metadata) {\r\n\t\treturn metadata[this.v1 ? 4 : this.v2 ? 5 : 6]\r\n\t}\r\n\r\n\t// For countries of the same region (e.g. NANPA)\r\n\t// national prefix formatting rule is stored in the \"main\" country for that region.\r\n\t// E.g. \"RU\" and \"KZ\", \"US\" and \"CA\".\r\n\tnationalPrefixFormattingRule() {\r\n\t\treturn this._getNationalPrefixFormattingRule(this.metadata) || this._getNationalPrefixFormattingRule(this.getDefaultCountryMetadataForRegion())\r\n\t}\r\n\r\n\t_nationalPrefixForParsing() {\r\n\t\treturn this.metadata[this.v1 ? 5 : this.v2 ? 6 : 7]\r\n\t}\r\n\r\n\tnationalPrefixForParsing() {\r\n\t\t// If `national_prefix_for_parsing` is not set explicitly,\r\n\t\t// then infer it from `national_prefix` (if any)\r\n\t\treturn this._nationalPrefixForParsing() || this.nationalPrefix()\r\n\t}\r\n\r\n\tnationalPrefixTransformRule() {\r\n\t\treturn this.metadata[this.v1 ? 6 : this.v2 ? 7 : 8]\r\n\t}\r\n\r\n\t_getNationalPrefixIsOptionalWhenFormatting() {\r\n\t\treturn !!this.metadata[this.v1 ? 7 : this.v2 ? 8 : 9]\r\n\t}\r\n\r\n\t// For countries of the same region (e.g. NANPA)\r\n\t// \"national prefix is optional when formatting\" flag is\r\n\t// stored in the \"main\" country for that region.\r\n\t// E.g. \"RU\" and \"KZ\", \"US\" and \"CA\".\r\n\tnationalPrefixIsOptionalWhenFormattingInNationalFormat() {\r\n\t\treturn this._getNationalPrefixIsOptionalWhenFormatting(this.metadata) ||\r\n\t\t\tthis._getNationalPrefixIsOptionalWhenFormatting(this.getDefaultCountryMetadataForRegion())\r\n\t}\r\n\r\n\tleadingDigits() {\r\n\t\treturn this.metadata[this.v1 ? 8 : this.v2 ? 9 : 10]\r\n\t}\r\n\r\n\ttypes() {\r\n\t\treturn this.metadata[this.v1 ? 9 : this.v2 ? 10 : 11]\r\n\t}\r\n\r\n\thasTypes() {\r\n\t\t// Versions 1.2.0 - 1.2.4: can be `[]`.\r\n\t\t/* istanbul ignore next */\r\n\t\tif (this.types() && this.types().length === 0) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\t// Versions <= 1.2.4: can be `undefined`.\r\n\t\t// Version >= 1.2.5: can be `0`.\r\n\t\treturn !!this.types()\r\n\t}\r\n\r\n\ttype(type) {\r\n\t\tif (this.hasTypes() && getType(this.types(), type)) {\r\n\t\t\treturn new Type(getType(this.types(), type), this)\r\n\t\t}\r\n\t}\r\n\r\n\text() {\r\n\t\tif (this.v1 || this.v2) return DEFAULT_EXT_PREFIX\r\n\t\treturn this.metadata[13] || DEFAULT_EXT_PREFIX\r\n\t}\r\n}\r\n\r\nclass Format {\r\n\tconstructor(format, metadata) {\r\n\t\tthis._format = format\r\n\t\tthis.metadata = metadata\r\n\t}\r\n\r\n\tpattern() {\r\n\t\treturn this._format[0]\r\n\t}\r\n\r\n\tformat() {\r\n\t\treturn this._format[1]\r\n\t}\r\n\r\n\tleadingDigitsPatterns() {\r\n\t\treturn this._format[2] || []\r\n\t}\r\n\r\n\tnationalPrefixFormattingRule() {\r\n\t\treturn this._format[3] || this.metadata.nationalPrefixFormattingRule()\r\n\t}\r\n\r\n\tnationalPrefixIsOptionalWhenFormattingInNationalFormat() {\r\n\t\treturn !!this._format[4] || this.metadata.nationalPrefixIsOptionalWhenFormattingInNationalFormat()\r\n\t}\r\n\r\n\tnationalPrefixIsMandatoryWhenFormattingInNationalFormat() {\r\n\t\t// National prefix is omitted if there's no national prefix formatting rule\r\n\t\t// set for this country, or when the national prefix formatting rule\r\n\t\t// contains no national prefix itself, or when this rule is set but\r\n\t\t// national prefix is optional for this phone number format\r\n\t\t// (and it is not enforced explicitly)\r\n\t\treturn this.usesNationalPrefix() && !this.nationalPrefixIsOptionalWhenFormattingInNationalFormat()\r\n\t}\r\n\r\n\t// Checks whether national prefix formatting rule contains national prefix.\r\n\tusesNationalPrefix() {\r\n\t\treturn this.nationalPrefixFormattingRule() &&\r\n\t\t\t// Check that national prefix formatting rule is not a \"dummy\" one.\r\n\t\t\t!FIRST_GROUP_ONLY_PREFIX_PATTERN.test(this.nationalPrefixFormattingRule())\r\n\t\t\t// In compressed metadata, `this.nationalPrefixFormattingRule()` is `0`\r\n\t\t\t// when `national_prefix_formatting_rule` is not present.\r\n\t\t\t// So, `true` or `false` are returned explicitly here, so that\r\n\t\t\t// `0` number isn't returned.\r\n\t\t\t? true\r\n\t\t\t: false\r\n\t}\r\n\r\n\tinternationalFormat() {\r\n\t\treturn this._format[5] || this.format()\r\n\t}\r\n}\r\n\r\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 */\r\nconst FIRST_GROUP_ONLY_PREFIX_PATTERN = /^\\(?\\$1\\)?$/\r\n\r\nclass Type {\r\n\tconstructor(type, metadata) {\r\n\t\tthis.type = type\r\n\t\tthis.metadata = metadata\r\n\t}\r\n\r\n\tpattern() {\r\n\t\tif (this.metadata.v1) return this.type\r\n\t\treturn this.type[0]\r\n\t}\r\n\r\n\tpossibleLengths() {\r\n\t\tif (this.metadata.v1) return\r\n\t\treturn this.type[1] || this.metadata.possibleLengths()\r\n\t}\r\n}\r\n\r\nfunction getType(types, type) {\r\n\tswitch (type) {\r\n\t\tcase 'FIXED_LINE':\r\n\t\t\treturn types[0]\r\n\t\tcase 'MOBILE':\r\n\t\t\treturn types[1]\r\n\t\tcase 'TOLL_FREE':\r\n\t\t\treturn types[2]\r\n\t\tcase 'PREMIUM_RATE':\r\n\t\t\treturn types[3]\r\n\t\tcase 'PERSONAL_NUMBER':\r\n\t\t\treturn types[4]\r\n\t\tcase 'VOICEMAIL':\r\n\t\t\treturn types[5]\r\n\t\tcase 'UAN':\r\n\t\t\treturn types[6]\r\n\t\tcase 'PAGER':\r\n\t\t\treturn types[7]\r\n\t\tcase 'VOIP':\r\n\t\t\treturn types[8]\r\n\t\tcase 'SHARED_COST':\r\n\t\t\treturn types[9]\r\n\t}\r\n}\r\n\r\nexport function validateMetadata(metadata) {\r\n\tif (!metadata) {\r\n\t\tthrow new Error('[libphonenumber-js] `metadata` argument not passed. Check your arguments.')\r\n\t}\r\n\r\n\t// `country_phone_code_to_countries` was renamed to `country_calling_codes` in `1.0.18`.\r\n\t// For that reason, it's not used in this detection algorithm.\r\n\t// Instead, it detects by `countries: {}` property existence.\r\n\tif (!isObject(metadata) || !isObject(metadata.countries)) {\r\n\t\tthrow 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 ${isObject(metadata) ? 'an object of shape: { ' + Object.keys(metadata).join(', ') + ' }' : 'a ' + typeOf(metadata) + ': ' + metadata}.`)\r\n\t}\r\n}\r\n\r\n// Babel transforms `typeof` into some \"branches\"\r\n// so istanbul will show this as \"branch not covered\".\r\n/* istanbul ignore next */\r\nconst typeOf = _ => typeof _\r\n\r\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 */\r\nexport function getExtPrefix(country, metadata) {\r\n\tmetadata = new Metadata(metadata)\r\n\tif (metadata.hasCountry(country)) {\r\n\t\treturn metadata.selectNumberingPlan(country).ext()\r\n\t}\r\n\treturn DEFAULT_EXT_PREFIX\r\n}\r\n\r\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 */\r\nexport function getCountryCallingCode(country, metadata) {\r\n\tmetadata = new Metadata(metadata)\r\n\tif (metadata.hasCountry(country)) {\r\n\t\treturn metadata.selectNumberingPlan(country).countryCallingCode()\r\n\t}\r\n\tthrow new Error(`Unknown country: ${country}`)\r\n}\r\n\r\nexport function isSupportedCountry(country, metadata) {\r\n\t// metadata = new Metadata(metadata)\r\n\t// return metadata.hasCountry(country)\r\n\treturn metadata.countries.hasOwnProperty(country)\r\n}\r\n\r\nfunction setVersion(metadata) {\r\n\tconst { version } = metadata\r\n\tif (typeof version === 'number') {\r\n\t\tthis.v1 = version === 1\r\n\t\tthis.v2 = version === 2\r\n\t\tthis.v3 = version === 3\r\n\t\tthis.v4 = version === 4\r\n\t} else {\r\n\t\tif (!version) {\r\n\t\t\tthis.v1 = true\r\n\t\t} else if (compare(version, V3) === -1) {\r\n\t\t\tthis.v2 = true\r\n\t\t} else if (compare(version, V4) === -1) {\r\n\t\t\tthis.v3 = true\r\n\t\t} else {\r\n\t\t\tthis.v4 = true\r\n\t\t}\r\n\t}\r\n}\r\n\r\n// const ISO_COUNTRY_CODE = /^[A-Z]{2}$/\r\n// function isCountryCode(countryCode) {\r\n// \treturn ISO_COUNTRY_CODE.test(countryCodeOrCountryCallingCode)\r\n// }","import Metadata from '../metadata.js'\r\nimport getNumberType from './getNumberType.js'\r\n\r\n// Returns the exact country that the `nationalPhoneNumber` belongs to\r\n// in cases of ambiguity, i.e. when multiple countries share the same \"country calling code\".\r\nexport default function getCountryByNationalNumber(nationalPhoneNumber, {\r\n\tcountries,\r\n\tmetadata\r\n}) {\r\n\t// Re-create `metadata` because it will be selecting a `country`.\r\n\tmetadata = new Metadata(metadata)\r\n\r\n\t// const matchingCountries = []\r\n\r\n\tfor (const country of countries) {\r\n\t\tmetadata.selectNumberingPlan(country)\r\n\t\t// \"Leading digits\" patterns are only defined for about 20% of all countries.\r\n\t\t// By definition, matching \"leading digits\" is a sufficient but not a necessary\r\n\t\t// condition for a phone number to belong to a country.\r\n\t\t// The point of \"leading digits\" check is that it's the fastest one to get a match.\r\n\t\t// https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md#leading_digits\r\n\t\t// I'd suppose that \"leading digits\" patterns are mutually exclusive for different countries\r\n\t\t// because of the intended use of that feature.\r\n\t\tif (metadata.leadingDigits()) {\r\n\t\t\tif (nationalPhoneNumber &&\r\n\t\t\t\tnationalPhoneNumber.search(metadata.leadingDigits()) === 0) {\r\n\t\t\t\treturn country\r\n\t\t\t}\r\n\t\t}\r\n\t\t// Else perform full validation with all of those\r\n\t\t// fixed-line/mobile/etc regular expressions.\r\n\t\telse if (getNumberType({ phone: nationalPhoneNumber, country }, undefined, metadata.metadata)) {\r\n\t\t\t// When multiple countries share the same \"country calling code\",\r\n\t\t\t// type patterns aren't guaranteed to be unique among them.\r\n\t\t\t// For example, both `US` and `CA` have the same pattern for `toll_free` numbers.\r\n\t\t\t// https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/103#note_1417147572\r\n\t\t\t//\r\n\t\t\t// That means that this `if` condition could be `true` for multiple countries from the list.\r\n\t\t\t// Currently, it just returns the first one, which is also the \"main\" country for the \"country calling code\".\r\n\t\t\t// In an example with `toll_free` numbers above, `\"US\"` would be returned even though\r\n\t\t\t// it could as well be `\"CA\"`.\r\n\t\t\t//\r\n\t\t\t// There was also a time when this attempted to be overly smart\r\n\t\t\t// and kept track of all such multiple matching countries\r\n\t\t\t// and then picked the one that matched the `defaultCountry`, if provided.\r\n\t\t\t// For example, with `toll_free` numbers above, and with `defaultCountry: \"CA\"`,\r\n\t\t\t// it would've returned `\"CA\"` instead of `\"US\"`.\r\n\t\t\t// Later it turned out that such \"overly smart\" behavior turned out to be just confusing,\r\n\t\t\t// so this \"overly smart\" country detection was reverted to returning the \"main\" country\r\n\t\t\t// for the \"country calling code\".\r\n\t\t\t// https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/154\r\n\t\t\t//\r\n\t\t\treturn country\r\n\t\t\t//\r\n\t\t\t// The \"overly smart\" behavior code:\r\n\t\t\t//\r\n\t\t\t// if (defaultCountry) {\r\n\t\t\t// \tif (country === defaultCountry) {\r\n\t\t\t// \t\treturn country\r\n\t\t\t// \t} else {\r\n\t\t\t// \t\tmatchingCountries.push(country)\r\n\t\t\t// \t}\r\n\t\t\t// } else {\r\n\t\t\t// \treturn country\r\n\t\t\t// }\r\n\t\t}\r\n\t}\r\n\r\n\t// // Return the first (\"main\") one of the `matchingCountries`.\r\n\t// if (matchingCountries.length > 0) {\r\n\t// \treturn matchingCountries[0]\r\n\t// }\r\n}","// This \"state\" object simply holds the state of the \"AsYouType\" parser:\r\n//\r\n// * `country?: string` — The exact country of the phone number, if it could be determined.\r\n//                        When inputting a phone number in \"international\" format, it will derive the `country` from \"country calling code\" and the phone number digits.\r\n//                        When inputting a phone number in \"national\" format, it will derive the `country` from `defaultCountry` that was specified when creating the `AsYouType` formatter.\r\n//                        Sidenote: If `USE_NON_GEOGRAPHIC_COUNTRY_CODE` flag was `true`, then for \"non-geographic phone numbers\" `state.country` would've been \"001\".\r\n// * `callingCode?: string` — \"Country calling code\" that has been extracted from the input phone number.\r\n//                        When inputting a phone number in \"international\" format, it will extract the \"country calling code\" from the digits that follow the \"+\" character.\r\n//                        When inputting a phone number in \"national\" format, `callingCode` will be `undefined`.\r\n//                        Sidenote: `state.callingCode` is therefore independent from `state.country` and there could be situations when `state.country` is defined by `state.callingCode` is not — that would be when inputting a phone number not in \"international\" format.\r\n// * `digits: string` — Phone number digits that have been input so far, including the \"+\" character, if present. In case of inputting non-arabic digits, those will be converted to arabic ones.\r\n// * `international: boolean` — Whether the phone number is being input in \"international\" format, i.e. with a \"+\" character.\r\n// * `missingPlus: boolean` — Whether it's a phone number in \"international\" format that is missing the leading \"+\" character for some reason — apparently, Google thinks that it's a common mistake when inputting a phone number.\r\n// * `IDDPrefix?: string` — An \"IDD prefix\", when the phone number is being input in an \"out-of-country dialing\" format. https://wikitravel.org/en/International_dialling_prefix\r\n// * `carrierCode?: string` — A \"carrier code\", if the phone number contains it. Normally, those can only be present in Colombia or Brazil, and only when calling from mobile phones to fixed-line numbers.\r\n// * `nationalPrefix?: string` — \"National prefix\", if present in the phone number input.\r\n// * `nationalSignificantNumber?: string` — National (significant) number digits that have been input so far.\r\n// * `nationalSignificantNumberIsModified: boolean` — Tells if the parsed national (significant) number is present as-is in the input string. For example, when inputting \"0343515551212999\" Argentinian mobile number, the parsed national (significant) number is \"93435551212999\". There, one can see how it stripped \"0\" national prefix and prepended a \"9\", because that's how it is instructed to do in Argentina's metadata. So in the described example, the parsed national (significant) number is not present as-is in the input string. Instead, it's \"modified\" in the input string. https://gitlab.com/caamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\r\n// * `prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix?: string` — In some countries, a phone number could have a prefix that is not a \"national prefix\" but rather some other type of \"utility\" prefix.\r\n//                                                                             For example, when calling within Australia, one could prepend `1831` prefix to hide caller's phone number.\r\n//                                                                             https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\r\n//\r\nexport default class AsYouTypeState {\r\n\tconstructor({ onCountryChange, onCallingCodeChange }) {\r\n\t\tthis.onCountryChange = onCountryChange\r\n\t\tthis.onCallingCodeChange = onCallingCodeChange\r\n\t}\r\n\r\n\treset({ country, callingCode }) {\r\n\t\tthis.international = false\r\n\t\tthis.missingPlus = false\r\n\t\tthis.IDDPrefix = undefined\r\n\t\tthis.callingCode = undefined\r\n\t\tthis.digits = ''\r\n\t\tthis.resetNationalSignificantNumber()\r\n\t\tthis.initCountryAndCallingCode(country, callingCode)\r\n\t}\r\n\r\n\tresetNationalSignificantNumber() {\r\n\t\tthis.nationalSignificantNumber = this.getNationalDigits()\r\n\t\tthis.nationalSignificantNumberIsModified = false\r\n\t\tthis.nationalPrefix = undefined\r\n\t\tthis.carrierCode = undefined\r\n\t\tthis.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix = undefined\r\n\t}\r\n\r\n\tupdate(properties) {\r\n\t\tfor (const key of Object.keys(properties)) {\r\n\t\t\tthis[key] = properties[key]\r\n\t\t}\r\n\t}\r\n\r\n\tinitCountryAndCallingCode(country, callingCode) {\r\n\t\tthis.setCountry(country)\r\n\t\tthis.setCallingCode(callingCode)\r\n\t}\r\n\r\n\tsetCountry(country) {\r\n\t\tthis.country = country\r\n\t\tthis.onCountryChange(country)\r\n\t}\r\n\r\n\tsetCallingCode(callingCode) {\r\n\t\tthis.callingCode = callingCode\r\n\t\tthis.onCallingCodeChange(callingCode, this.country)\r\n\t}\r\n\r\n\tstartInternationalNumber(country, callingCode) {\r\n\t\t// Prepend the `+` to parsed input.\r\n\t\tthis.international = true\r\n\t\t// If a default country was set then reset it\r\n\t\t// because an explicitly international phone\r\n\t\t// number is being entered.\r\n\t\tthis.initCountryAndCallingCode(country, callingCode)\r\n\t}\r\n\r\n\tappendDigits(nextDigits) {\r\n\t\tthis.digits += nextDigits\r\n\t}\r\n\r\n\tappendNationalSignificantNumberDigits(nextDigits) {\r\n\t\tthis.nationalSignificantNumber += nextDigits\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the part of `this.digits` that corresponds to the national number.\r\n\t * Basically, all digits that have been input by the user, except for the\r\n\t * international prefix and the country calling code part\r\n\t * (if the number is an international one).\r\n\t * @return {string}\r\n\t */\r\n\tgetNationalDigits() {\r\n\t\tif (this.international) {\r\n\t\t\treturn this.digits.slice(\r\n\t\t\t\t(this.IDDPrefix ? this.IDDPrefix.length : 0) +\r\n\t\t\t\t(this.callingCode ? this.callingCode.length : 0)\r\n\t\t\t)\r\n\t\t}\r\n\t\treturn this.digits\r\n\t}\r\n\r\n\tgetDigitsWithoutInternationalPrefix() {\r\n\t\tif (this.international) {\r\n\t\t\tif (this.IDDPrefix) {\r\n\t\t\t\treturn this.digits.slice(this.IDDPrefix.length)\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn this.digits\r\n\t}\r\n}","import checkNumberLength from './helpers/checkNumberLength.js'\r\nimport parseDigits from './helpers/parseDigits.js'\r\nimport formatNationalNumberUsingFormat from './helpers/formatNationalNumberUsingFormat.js'\r\n\r\nexport default function formatCompleteNumber(state, format, {\r\n\tmetadata,\r\n\tshouldTryNationalPrefixFormattingRule,\r\n\tgetSeparatorAfterNationalPrefix\r\n}) {\r\n\tconst matcher = new RegExp(`^(?:${format.pattern()})$`)\r\n\tif (matcher.test(state.nationalSignificantNumber)) {\r\n\t\treturn formatNationalNumberWithAndWithoutNationalPrefixFormattingRule(\r\n\t\t\tstate,\r\n\t\t\tformat,\r\n\t\t\t{\r\n\t\t\t\tmetadata,\r\n\t\t\t\tshouldTryNationalPrefixFormattingRule,\r\n\t\t\t\tgetSeparatorAfterNationalPrefix\r\n\t\t\t}\r\n\t\t)\r\n\t}\r\n}\r\n\r\nexport function canFormatCompleteNumber(nationalSignificantNumber, country, metadata) {\r\n\treturn checkNumberLength(nationalSignificantNumber, country, metadata) === 'IS_POSSIBLE'\r\n}\r\n\r\nfunction formatNationalNumberWithAndWithoutNationalPrefixFormattingRule(state, format, {\r\n\tmetadata,\r\n\tshouldTryNationalPrefixFormattingRule,\r\n\tgetSeparatorAfterNationalPrefix\r\n}) {\r\n\t// `format` has already been checked for `nationalPrefix` requirement.\r\n\r\n\tconst {\r\n\t\tnationalSignificantNumber,\r\n\t\tinternational,\r\n\t\tnationalPrefix,\r\n\t\tcarrierCode\r\n\t} = state\r\n\r\n\t// Format the number with using `national_prefix_formatting_rule`.\r\n\t// If the resulting formatted number is a valid formatted number, then return it.\r\n\t//\r\n\t// Google's AsYouType formatter is different in a way that it doesn't try\r\n\t// to format using the \"national prefix formatting rule\", and instead it\r\n\t// simply prepends a national prefix followed by a \" \" character.\r\n\t// This code does that too, but as a fallback.\r\n\t// The reason is that \"national prefix formatting rule\" may use parentheses,\r\n\t// which wouldn't be included has it used the simpler Google's way.\r\n\t//\r\n\tif (shouldTryNationalPrefixFormattingRule(format)) {\r\n\t\tconst formattedNumber = formatNationalNumber(state, format, {\r\n\t\t\tuseNationalPrefixFormattingRule: true,\r\n\t\t\tgetSeparatorAfterNationalPrefix,\r\n\t\t\tmetadata\r\n\t\t})\r\n\t\tif (formattedNumber) {\r\n\t\t\treturn formattedNumber\r\n\t\t}\r\n\t}\r\n\r\n\t// Format the number without using `national_prefix_formatting_rule`.\r\n\treturn formatNationalNumber(state, format, {\r\n\t\tuseNationalPrefixFormattingRule: false,\r\n\t\tgetSeparatorAfterNationalPrefix,\r\n\t\tmetadata\r\n\t})\r\n}\r\n\r\nfunction formatNationalNumber(state, format, {\r\n\tmetadata,\r\n\tuseNationalPrefixFormattingRule,\r\n\tgetSeparatorAfterNationalPrefix\r\n}) {\r\n\tlet formattedNationalNumber = formatNationalNumberUsingFormat(\r\n\t\tstate.nationalSignificantNumber,\r\n\t\tformat,\r\n\t\t{\r\n\t\t\tcarrierCode: state.carrierCode,\r\n\t\t\tuseInternationalFormat: state.international,\r\n\t\t\twithNationalPrefix: useNationalPrefixFormattingRule,\r\n\t\t\tmetadata\r\n\t\t}\r\n\t)\r\n\tif (!useNationalPrefixFormattingRule) {\r\n\t\tif (state.nationalPrefix) {\r\n\t\t\t// If a national prefix was extracted, then just prepend it,\r\n\t\t\t// followed by a \" \" character.\r\n\t\t\tformattedNationalNumber = state.nationalPrefix +\r\n\t\t\t\tgetSeparatorAfterNationalPrefix(format) +\r\n\t\t\t\tformattedNationalNumber\r\n\t\t} else if (state.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix) {\r\n\t\t\tformattedNationalNumber = state.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix +\r\n\t\t\t\t' ' +\r\n\t\t\t\tformattedNationalNumber\r\n\t\t}\r\n\t}\r\n\tif (isValidFormattedNationalNumber(formattedNationalNumber, state)) {\r\n\t\treturn formattedNationalNumber\r\n\t}\r\n}\r\n\r\n// Check that the formatted phone number contains exactly\r\n// the same digits that have been input by the user.\r\n// For example, when \"0111523456789\" is input for `AR` country,\r\n// the extracted `this.nationalSignificantNumber` is \"91123456789\",\r\n// which means that the national part of `this.digits` isn't simply equal to\r\n// `this.nationalPrefix` + `this.nationalSignificantNumber`.\r\n//\r\n// Also, a `format` can add extra digits to the `this.nationalSignificantNumber`\r\n// being formatted via `metadata[country].national_prefix_transform_rule`.\r\n// For example, for `VI` country, it prepends `340` to the national number,\r\n// and if this check hasn't been implemented, then there would be a bug\r\n// when `340` \"area coude\" is \"duplicated\" during input for `VI` country:\r\n// https://github.com/catamphetamine/libphonenumber-js/issues/318\r\n//\r\n// So, all these \"gotchas\" are filtered out.\r\n//\r\n// In the original Google's code, the comments say:\r\n// \"Check that we didn't remove nor add any extra digits when we matched\r\n// this formatting pattern. This usually happens after we entered the last\r\n// digit during AYTF. Eg: In case of MX, we swallow mobile token (1) when\r\n// formatted but AYTF should retain all the number entered and not change\r\n// in order to match a format (of same leading digits and length) display\r\n// in that way.\"\r\n// \"If it's the same (i.e entered number and format is same), then it's\r\n// safe to return this in formatted number as nothing is lost / added.\"\r\n// Otherwise, don't use this format.\r\n// https://github.com/google/libphonenumber/commit/3e7c1f04f5e7200f87fb131e6f85c6e99d60f510#diff-9149457fa9f5d608a11bb975c6ef4bc5\r\n// https://github.com/google/libphonenumber/commit/3ac88c7106e7dcb553bcc794b15f19185928a1c6#diff-2dcb77e833422ee304da348b905cde0b\r\n//\r\nfunction isValidFormattedNationalNumber(formattedNationalNumber, state) {\r\n\treturn parseDigits(formattedNationalNumber) === state.getNationalDigits()\r\n}","export default class PatternParser {\r\n\tparse(pattern) {\r\n\t\tthis.context = [{\r\n\t\t\tor: true,\r\n\t\t\tinstructions: []\r\n\t\t}]\r\n\r\n\t\tthis.parsePattern(pattern)\r\n\r\n\t\tif (this.context.length !== 1) {\r\n\t\t\tthrow new Error('Non-finalized contexts left when pattern parse ended')\r\n\t\t}\r\n\r\n\t\tconst { branches, instructions } = this.context[0]\r\n\r\n\t\tif (branches) {\r\n\t\t\treturn {\r\n\t\t\t\top: '|',\r\n\t\t\t\targs: branches.concat([\r\n\t\t\t\t\texpandSingleElementArray(instructions)\r\n\t\t\t\t])\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/* istanbul ignore if */\r\n\t\tif (instructions.length === 0) {\r\n\t\t\tthrow new Error('Pattern is required')\r\n\t\t}\r\n\r\n\t\tif (instructions.length === 1) {\r\n\t\t\treturn instructions[0]\r\n\t\t}\r\n\r\n\t\treturn instructions\r\n\t}\r\n\r\n\tstartContext(context) {\r\n\t\tthis.context.push(context)\r\n\t}\r\n\r\n\tendContext() {\r\n\t\tthis.context.pop()\r\n\t}\r\n\r\n\tgetContext() {\r\n\t\treturn this.context[this.context.length - 1]\r\n\t}\r\n\r\n\tparsePattern(pattern) {\r\n\t\tif (!pattern) {\r\n\t\t\tthrow new Error('Pattern is required')\r\n\t\t}\r\n\r\n\t\tconst match = pattern.match(OPERATOR)\r\n\t\tif (!match) {\r\n\t\t\tif (ILLEGAL_CHARACTER_REGEXP.test(pattern)) {\r\n\t\t\t\tthrow new Error(`Illegal characters found in a pattern: ${pattern}`)\r\n\t\t\t}\r\n\t\t\tthis.getContext().instructions = this.getContext().instructions.concat(\r\n\t\t\t\tpattern.split('')\r\n\t\t\t)\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\tconst operator = match[1]\r\n\t\tconst before = pattern.slice(0, match.index)\r\n\t\tconst rightPart = pattern.slice(match.index + operator.length)\r\n\r\n\t\tswitch (operator) {\r\n\t\t\tcase '(?:':\r\n\t\t\t\tif (before) {\r\n\t\t\t\t\tthis.parsePattern(before)\r\n\t\t\t\t}\r\n\t\t\t\tthis.startContext({\r\n\t\t\t\t\tor: true,\r\n\t\t\t\t\tinstructions: [],\r\n\t\t\t\t\tbranches: []\r\n\t\t\t\t})\r\n\t\t\t\tbreak\r\n\r\n\t\t\tcase ')':\r\n\t\t\t\tif (!this.getContext().or) {\r\n\t\t\t\t\tthrow new Error('\")\" operator must be preceded by \"(?:\" operator')\r\n\t\t\t\t}\r\n\t\t\t\tif (before) {\r\n\t\t\t\t\tthis.parsePattern(before)\r\n\t\t\t\t}\r\n\t\t\t\tif (this.getContext().instructions.length === 0) {\r\n\t\t\t\t\tthrow new Error('No instructions found after \"|\" operator in an \"or\" group')\r\n\t\t\t\t}\r\n\t\t\t\tconst { branches } = this.getContext()\r\n\t\t\t\tbranches.push(\r\n\t\t\t\t\texpandSingleElementArray(\r\n\t\t\t\t\t\tthis.getContext().instructions\r\n\t\t\t\t\t)\r\n\t\t\t\t)\r\n\t\t\t\tthis.endContext()\r\n\t\t\t\tthis.getContext().instructions.push({\r\n\t\t\t\t\top: '|',\r\n\t\t\t\t\targs: branches\r\n\t\t\t\t})\r\n\t\t\t\tbreak\r\n\r\n\t\t\tcase '|':\r\n\t\t\t\tif (!this.getContext().or) {\r\n\t\t\t\t\tthrow new Error('\"|\" operator can only be used inside \"or\" groups')\r\n\t\t\t\t}\r\n\t\t\t\tif (before) {\r\n\t\t\t\t\tthis.parsePattern(before)\r\n\t\t\t\t}\r\n\t\t\t\t// The top-level is an implicit \"or\" group, if required.\r\n\t\t\t\tif (!this.getContext().branches) {\r\n\t\t\t\t\t// `branches` are not defined only for the root implicit \"or\" operator.\r\n\t\t\t\t\t/* istanbul ignore else */\r\n\t\t\t\t\tif (this.context.length === 1) {\r\n\t\t\t\t\t\tthis.getContext().branches = []\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tthrow new Error('\"branches\" not found in an \"or\" group context')\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tthis.getContext().branches.push(\r\n\t\t\t\t\texpandSingleElementArray(\r\n\t\t\t\t\t\tthis.getContext().instructions\r\n\t\t\t\t\t)\r\n\t\t\t\t)\r\n\t\t\t\tthis.getContext().instructions = []\r\n\t\t\t\tbreak\r\n\r\n\t\t\tcase '[':\r\n\t\t\t\tif (before) {\r\n\t\t\t\t\tthis.parsePattern(before)\r\n\t\t\t\t}\r\n\t\t\t\tthis.startContext({\r\n\t\t\t\t\toneOfSet: true\r\n\t\t\t\t})\r\n\t\t\t\tbreak\r\n\r\n\t\t\tcase ']':\r\n\t\t\t\tif (!this.getContext().oneOfSet) {\r\n\t\t\t\t\tthrow new Error('\"]\" operator must be preceded by \"[\" operator')\r\n\t\t\t\t}\r\n\t\t\t\tthis.endContext()\r\n\t\t\t\tthis.getContext().instructions.push({\r\n\t\t\t\t\top: '[]',\r\n\t\t\t\t\targs: parseOneOfSet(before)\r\n\t\t\t\t})\r\n\t\t\t\tbreak\r\n\r\n\t\t\t/* istanbul ignore next */\r\n\t\t\tdefault:\r\n\t\t\t\tthrow new Error(`Unknown operator: ${operator}`)\r\n\t\t}\r\n\r\n\t\tif (rightPart) {\r\n\t\t\tthis.parsePattern(rightPart)\r\n\t\t}\r\n\t}\r\n}\r\n\r\nfunction parseOneOfSet(pattern) {\r\n\tconst values = []\r\n\tlet i = 0\r\n\twhile (i < pattern.length) {\r\n\t\tif (pattern[i] === '-') {\r\n\t\t\tif (i === 0 || i === pattern.length - 1) {\r\n\t\t\t\tthrow new Error(`Couldn't parse a one-of set pattern: ${pattern}`)\r\n\t\t\t}\r\n\t\t\tconst prevValue = pattern[i - 1].charCodeAt(0) + 1\r\n\t\t\tconst nextValue = pattern[i + 1].charCodeAt(0) - 1\r\n\t\t\tlet value = prevValue\r\n\t\t\twhile (value <= nextValue) {\r\n\t\t\t\tvalues.push(String.fromCharCode(value))\r\n\t\t\t\tvalue++\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tvalues.push(pattern[i])\r\n\t\t}\r\n\t\ti++\r\n\t}\r\n\treturn values\r\n}\r\n\r\nconst ILLEGAL_CHARACTER_REGEXP = /[\\(\\)\\[\\]\\?\\:\\|]/\r\n\r\nconst OPERATOR = new RegExp(\r\n\t// any of:\r\n\t'(' +\r\n\t\t// or operator\r\n\t\t'\\\\|' +\r\n\t\t// or\r\n\t\t'|' +\r\n\t\t// or group start\r\n\t\t'\\\\(\\\\?\\\\:' +\r\n\t\t// or\r\n\t\t'|' +\r\n\t\t// or group end\r\n\t\t'\\\\)' +\r\n\t\t// or\r\n\t\t'|' +\r\n\t\t// one-of set start\r\n\t\t'\\\\[' +\r\n\t\t// or\r\n\t\t'|' +\r\n\t\t// one-of set end\r\n\t\t'\\\\]' +\r\n\t')'\r\n)\r\n\r\nfunction expandSingleElementArray(array) {\r\n\tif (array.length === 1) {\r\n\t\treturn array[0]\r\n\t}\r\n\treturn array\r\n}","import PatternParser from './AsYouTypeFormatter.PatternParser.js'\r\n\r\nexport default class PatternMatcher {\r\n\tconstructor(pattern) {\r\n\t\tthis.matchTree = new PatternParser().parse(pattern)\r\n\t}\r\n\r\n\tmatch(string, { allowOverflow } = {}) {\r\n\t\tif (!string) {\r\n\t\t\tthrow new Error('String is required')\r\n\t\t}\r\n\t\tconst result = match(string.split(''), this.matchTree, true)\r\n\t\tif (result && result.match) {\r\n\t\t\tdelete result.matchedChars\r\n\t\t}\r\n\t\tif (result && result.overflow) {\r\n\t\t\tif (!allowOverflow) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn result\r\n\t}\r\n}\r\n\r\n/**\r\n * Matches `characters` against a pattern compiled into a `tree`.\r\n * @param  {string[]} characters\r\n * @param  {Tree} tree — A pattern compiled into a `tree`. See the `*.d.ts` file for the description of the `tree` structure.\r\n * @param  {boolean} last — Whether it's the last (rightmost) subtree on its level of the match tree.\r\n * @return {object} See the `*.d.ts` file for the description of the result object.\r\n */\r\nfunction match(characters, tree, last) {\r\n\t// If `tree` is a string, then `tree` is a single character.\r\n\t// That's because when a pattern is parsed, multi-character-string parts\r\n\t// of a pattern are compiled into arrays of single characters.\r\n\t// I still wrote this piece of code for a \"general\" hypothetical case\r\n\t// when `tree` could be a string of several characters, even though\r\n\t// such case is not possible with the current implementation.\r\n\tif (typeof tree === 'string') {\r\n\t\tconst characterString = characters.join('')\r\n\t\tif (tree.indexOf(characterString) === 0) {\r\n\t\t\t// `tree` is always a single character.\r\n\t\t\t// If `tree.indexOf(characterString) === 0`\r\n\t\t\t// then `characters.length === tree.length`.\r\n\t\t\t/* istanbul ignore else */\r\n\t\t\tif (characters.length === tree.length) {\r\n\t\t\t\treturn {\r\n\t\t\t\t\tmatch: true,\r\n\t\t\t\t\tmatchedChars: characters\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// `tree` is always a single character.\r\n\t\t\t// If `tree.indexOf(characterString) === 0`\r\n\t\t\t// then `characters.length === tree.length`.\r\n\t\t\t/* istanbul ignore next */\r\n\t\t\treturn {\r\n\t\t\t\tpartialMatch: true,\r\n\t\t\t\t// matchedChars: characters\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (characterString.indexOf(tree) === 0) {\r\n\t\t\tif (last) {\r\n\t\t\t\t// The `else` path is not possible because `tree` is always a single character.\r\n\t\t\t\t// The `else` case for `characters.length > tree.length` would be\r\n\t\t\t\t// `characters.length <= tree.length` which means `characters.length <= 1`.\r\n\t\t\t\t// `characters` array can't be empty, so that means `characters === [tree]`,\r\n\t\t\t\t// which would also mean `tree.indexOf(characterString) === 0` and that'd mean\r\n\t\t\t\t// that the `if (tree.indexOf(characterString) === 0)` condition before this\r\n\t\t\t\t// `if` condition would be entered, and returned from there, not reaching this code.\r\n\t\t\t\t/* istanbul ignore else */\r\n\t\t\t\tif (characters.length > tree.length) {\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\toverflow: true\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn {\r\n\t\t\t\tmatch: true,\r\n\t\t\t\tmatchedChars: characters.slice(0, tree.length)\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn\r\n\t}\r\n\r\n\tif (Array.isArray(tree)) {\r\n\t\tlet restCharacters = characters.slice()\r\n\t\tlet i = 0\r\n\t\twhile (i < tree.length) {\r\n\t\t\tconst subtree = tree[i]\r\n\t\t\tconst result = match(restCharacters, subtree, last && (i === tree.length - 1))\r\n\t\t\tif (!result) {\r\n\t\t\t\treturn\r\n\t\t\t} else if (result.overflow) {\r\n\t\t\t\treturn result\r\n\t\t\t} else if (result.match) {\r\n\t\t\t\t// Continue with the next subtree with the rest of the characters.\r\n\t\t\t\trestCharacters = restCharacters.slice(result.matchedChars.length)\r\n\t\t\t\tif (restCharacters.length === 0) {\r\n\t\t\t\t\tif (i === tree.length - 1) {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tmatch: true,\r\n\t\t\t\t\t\t\tmatchedChars: characters\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tpartialMatch: true,\r\n\t\t\t\t\t\t\t// matchedChars: characters\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\t/* istanbul ignore else */\r\n\t\t\t\tif (result.partialMatch) {\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\tpartialMatch: true,\r\n\t\t\t\t\t\t// matchedChars: characters\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\tthrow new Error(`Unsupported match result:\\n${JSON.stringify(result, null, 2)}`)\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\ti++\r\n\t\t}\r\n\t\t// If `last` then overflow has already been checked\r\n\t\t// by the last element of the `tree` array.\r\n\t\t/* istanbul ignore if */\r\n\t\tif (last) {\r\n\t\t\treturn {\r\n\t\t\t\toverflow: true\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn {\r\n\t\t\tmatch: true,\r\n\t\t\tmatchedChars: characters.slice(0, characters.length - restCharacters.length)\r\n\t\t}\r\n\t}\r\n\r\n\tswitch (tree.op) {\r\n\t\tcase '|':\r\n\t\t\tlet partialMatch\r\n\t\t\tfor (const branch of tree.args) {\r\n\t\t\t\tconst result = match(characters, branch, last)\r\n\t\t\t\tif (result) {\r\n\t\t\t\t\tif (result.overflow) {\r\n\t\t\t\t\t\treturn result\r\n\t\t\t\t\t} else if (result.match) {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tmatch: true,\r\n\t\t\t\t\t\t\tmatchedChars: result.matchedChars\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\t/* istanbul ignore else */\r\n\t\t\t\t\t\tif (result.partialMatch) {\r\n\t\t\t\t\t\t\tpartialMatch = true\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tthrow new Error(`Unsupported match result:\\n${JSON.stringify(result, null, 2)}`)\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (partialMatch) {\r\n\t\t\t\treturn {\r\n\t\t\t\t\tpartialMatch: true,\r\n\t\t\t\t\t// matchedChars: ...\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// Not even a partial match.\r\n\t\t\treturn\r\n\r\n\t\tcase '[]':\r\n\t\t\tfor (const char of tree.args) {\r\n\t\t\t\tif (characters[0] === char) {\r\n\t\t\t\t\tif (characters.length === 1) {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tmatch: true,\r\n\t\t\t\t\t\t\tmatchedChars: characters\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (last) {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\toverflow: true\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\tmatch: true,\r\n\t\t\t\t\t\tmatchedChars: [char]\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// No character matches.\r\n\t\t\treturn\r\n\r\n\t\t/* istanbul ignore next */\r\n\t\tdefault:\r\n\t\t\tthrow new Error(`Unsupported instruction tree: ${tree}`)\r\n\t}\r\n}","import {\r\n\tDIGIT_PLACEHOLDER,\r\n\tcountOccurences,\r\n\trepeat,\r\n\tcutAndStripNonPairedParens,\r\n\tcloseNonPairedParens,\r\n\tstripNonPairedParens,\r\n\tpopulateTemplateWithDigits\r\n} from './AsYouTypeFormatter.util.js'\r\n\r\nimport formatCompleteNumber, {\r\n\tcanFormatCompleteNumber\r\n} from './AsYouTypeFormatter.complete.js'\r\n\r\nimport PatternMatcher from './AsYouTypeFormatter.PatternMatcher.js'\r\n\r\nimport parseDigits from './helpers/parseDigits.js'\r\nexport { DIGIT_PLACEHOLDER } from './AsYouTypeFormatter.util.js'\r\nimport { FIRST_GROUP_PATTERN } from './helpers/formatNationalNumberUsingFormat.js'\r\nimport { VALID_PUNCTUATION } from './constants.js'\r\nimport applyInternationalSeparatorStyle from './helpers/applyInternationalSeparatorStyle.js'\r\n\r\n// Used in phone number format template creation.\r\n// Could be any digit, I guess.\r\nconst DUMMY_DIGIT = '9'\r\n// I don't know why is it exactly `15`\r\nconst LONGEST_NATIONAL_PHONE_NUMBER_LENGTH = 15\r\n// Create a phone number consisting only of the digit 9 that matches the\r\n// `number_pattern` by applying the pattern to the \"longest phone number\" string.\r\nconst LONGEST_DUMMY_PHONE_NUMBER = repeat(DUMMY_DIGIT, LONGEST_NATIONAL_PHONE_NUMBER_LENGTH)\r\n\r\n// A set of characters that, if found in a national prefix formatting rules, are an indicator to\r\n// us that we should separate the national prefix from the number when formatting.\r\nconst NATIONAL_PREFIX_SEPARATORS_PATTERN = /[- ]/\r\n\r\n// Deprecated: Google has removed some formatting pattern related code from their repo.\r\n// https://github.com/googlei18n/libphonenumber/commit/a395b4fef3caf57c4bc5f082e1152a4d2bd0ba4c\r\n// \"We no longer have numbers in formatting matching patterns, only \\d.\"\r\n// Because this library supports generating custom metadata\r\n// some users may still be using old metadata so the relevant\r\n// code seems to stay until some next major version update.\r\nconst SUPPORT_LEGACY_FORMATTING_PATTERNS = true\r\n\r\n// A pattern that is used to match character classes in regular expressions.\r\n// An example of a character class is \"[1-4]\".\r\nconst CREATE_CHARACTER_CLASS_PATTERN = SUPPORT_LEGACY_FORMATTING_PATTERNS && (() => /\\[([^\\[\\]])*\\]/g)\r\n\r\n// Any digit in a regular expression that actually denotes a digit. For\r\n// example, in the regular expression \"80[0-2]\\d{6,10}\", the first 2 digits\r\n// (8 and 0) are standalone digits, but the rest are not.\r\n// Two look-aheads are needed because the number following \\\\d could be a\r\n// two-digit number, since the phone number can be as long as 15 digits.\r\nconst CREATE_STANDALONE_DIGIT_PATTERN = SUPPORT_LEGACY_FORMATTING_PATTERNS && (() => /\\d(?=[^,}][^,}])/g)\r\n\r\n// A regular expression that is used to determine if a `format` is\r\n// suitable to be used in the \"as you type formatter\".\r\n// A `format` is suitable when the resulting formatted number has\r\n// the same digits as the user has entered.\r\n//\r\n// In the simplest case, that would mean that the format\r\n// doesn't add any additional digits when formatting a number.\r\n// Google says that it also shouldn't add \"star\" (`*`) characters,\r\n// like it does in some Israeli formats.\r\n// Such basic format would only contain \"valid punctuation\"\r\n// and \"captured group\" identifiers ($1, $2, etc).\r\n//\r\n// An example of a format that adds additional digits:\r\n//\r\n// Country: `AR` (Argentina).\r\n// Format:\r\n// {\r\n//    \"pattern\": \"(\\\\d)(\\\\d{2})(\\\\d{4})(\\\\d{4})\",\r\n//    \"leading_digits_patterns\": [\"91\"],\r\n//    \"national_prefix_formatting_rule\": \"0$1\",\r\n//    \"format\": \"$2 15-$3-$4\",\r\n//    \"international_format\": \"$1 $2 $3-$4\"\r\n// }\r\n//\r\n// In the format above, the `format` adds `15` to the digits when formatting a number.\r\n// A sidenote: this format actually is suitable because `national_prefix_for_parsing`\r\n// has previously removed `15` from a national number, so re-adding `15` in `format`\r\n// doesn't actually result in any extra digits added to user's input.\r\n// But verifying that would be a complex procedure, so the code chooses a simpler path:\r\n// it simply filters out all `format`s that contain anything but \"captured group\" ids.\r\n//\r\n// This regular expression is called `ELIGIBLE_FORMAT_PATTERN` in Google's\r\n// `libphonenumber` code.\r\n//\r\nconst NON_ALTERING_FORMAT_REG_EXP = new RegExp(\r\n\t'[' + VALID_PUNCTUATION + ']*' +\r\n\t// Google developers say:\r\n\t// \"We require that the first matching group is present in the\r\n\t//  output pattern to ensure no data is lost while formatting.\"\r\n\t'\\\\$1' +\r\n\t'[' + VALID_PUNCTUATION + ']*' +\r\n\t'(\\\\$\\\\d[' + VALID_PUNCTUATION + ']*)*' +\r\n\t'$'\r\n)\r\n\r\n// This is the minimum length of the leading digits of a phone number\r\n// to guarantee the first \"leading digits pattern\" for a phone number format\r\n// to be preemptive.\r\nconst MIN_LEADING_DIGITS_LENGTH = 3\r\n\r\nexport default class AsYouTypeFormatter {\r\n\tconstructor({\r\n\t\tstate,\r\n\t\tmetadata\r\n\t}) {\r\n\t\tthis.metadata = metadata\r\n\t\tthis.resetFormat()\r\n\t}\r\n\r\n\tresetFormat() {\r\n\t\tthis.chosenFormat = undefined\r\n\t\tthis.template = undefined\r\n\t\tthis.nationalNumberTemplate = undefined\r\n\t\tthis.populatedNationalNumberTemplate = undefined\r\n\t\tthis.populatedNationalNumberTemplatePosition = -1\r\n\t}\r\n\r\n\treset(numberingPlan, state) {\r\n\t\tthis.resetFormat()\r\n\t\tif (numberingPlan) {\r\n\t\t\tthis.isNANP = numberingPlan.callingCode() === '1'\r\n\t\t\tthis.matchingFormats = numberingPlan.formats()\r\n\t\t\tif (state.nationalSignificantNumber) {\r\n\t\t\t\tthis.narrowDownMatchingFormats(state)\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tthis.isNANP = undefined\r\n\t\t\tthis.matchingFormats = []\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Formats an updated phone number.\r\n\t * @param  {string} nextDigits — Additional phone number digits.\r\n\t * @param  {object} state — `AsYouType` state.\r\n\t * @return {[string]} Returns undefined if the updated phone number can't be formatted using any of the available formats.\r\n\t */\r\n\tformat(nextDigits, state) {\r\n\t\t// See if the phone number digits can be formatted as a complete phone number.\r\n\t\t// If not, use the results from `formatNationalNumberWithNextDigits()`,\r\n\t\t// which formats based on the chosen formatting pattern.\r\n\t\t//\r\n\t\t// Attempting to format complete phone number first is how it's done\r\n\t\t// in Google's `libphonenumber`, so this library just follows it.\r\n\t\t// Google's `libphonenumber` code doesn't explain in detail why does it\r\n\t\t// attempt to format digits as a complete phone number\r\n\t\t// instead of just going with a previoulsy (or newly) chosen `format`:\r\n\t\t//\r\n\t\t// \"Checks to see if there is an exact pattern match for these digits.\r\n\t\t//  If so, we should use this instead of any other formatting template\r\n\t\t//  whose leadingDigitsPattern also matches the input.\"\r\n\t\t//\r\n\t\tif (canFormatCompleteNumber(state.nationalSignificantNumber, state.country, this.metadata)) {\r\n\t\t\tfor (const format of this.matchingFormats) {\r\n\t\t\t\tconst formattedCompleteNumber = formatCompleteNumber(\r\n\t\t\t\t\tstate,\r\n\t\t\t\t\tformat,\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tmetadata: this.metadata,\r\n\t\t\t\t\t\tshouldTryNationalPrefixFormattingRule: (format) => this.shouldTryNationalPrefixFormattingRule(format, {\r\n\t\t\t\t\t\t\tinternational: state.international,\r\n\t\t\t\t\t\t\tnationalPrefix: state.nationalPrefix\r\n\t\t\t\t\t\t}),\r\n\t\t\t\t\t\tgetSeparatorAfterNationalPrefix: (format) => this.getSeparatorAfterNationalPrefix(format)\r\n\t\t\t\t\t}\r\n\t\t\t\t)\r\n\t\t\t\tif (formattedCompleteNumber) {\r\n\t\t\t\t\tthis.resetFormat()\r\n\t\t\t\t\tthis.chosenFormat = format\r\n\t\t\t\t\tthis.setNationalNumberTemplate(formattedCompleteNumber.replace(/\\d/g, DIGIT_PLACEHOLDER), state)\r\n\t\t\t\t\tthis.populatedNationalNumberTemplate = formattedCompleteNumber\r\n\t\t\t\t\t// With a new formatting template, the matched position\r\n\t\t\t\t\t// using the old template needs to be reset.\r\n\t\t\t\t\tthis.populatedNationalNumberTemplatePosition = this.template.lastIndexOf(DIGIT_PLACEHOLDER)\r\n\t\t\t\t\treturn formattedCompleteNumber\r\n\t\t\t\t}\r\n\r\n\t\t\t}\r\n\t\t}\r\n\t\t// Format the digits as a partial (incomplete) phone number\r\n\t\t// using the previously chosen formatting pattern (or a newly chosen one).\r\n\t\treturn this.formatNationalNumberWithNextDigits(nextDigits, state)\r\n\t}\r\n\r\n\t// Formats the next phone number digits.\r\n\tformatNationalNumberWithNextDigits(nextDigits, state) {\r\n\t\tconst previouslyChosenFormat = this.chosenFormat\r\n\r\n\t\t// Choose a format from the list of matching ones.\r\n\t\tconst newlyChosenFormat = this.chooseFormat(state)\r\n\r\n\t\tif (newlyChosenFormat) {\r\n\t\t\tif (newlyChosenFormat === previouslyChosenFormat) {\r\n\t\t\t\t// If it can format the next (current) digits\r\n\t\t\t\t// using the previously chosen phone number format\r\n\t\t\t\t// then return the updated formatted number.\r\n\t\t\t\treturn this.formatNextNationalNumberDigits(nextDigits)\r\n\t\t\t} else {\r\n\t\t\t\t// If a more appropriate phone number format\r\n\t\t\t\t// has been chosen for these \"leading digits\",\r\n\t\t\t\t// then re-format the national phone number part\r\n\t\t\t\t// using the newly selected format.\r\n\t\t\t\treturn this.formatNextNationalNumberDigits(state.getNationalDigits())\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tnarrowDownMatchingFormats({\r\n\t\tnationalSignificantNumber,\r\n\t\tnationalPrefix,\r\n\t\tinternational\r\n\t}) {\r\n\t\tconst leadingDigits = nationalSignificantNumber\r\n\r\n\t\t// \"leading digits\" pattern list starts with a\r\n\t\t// \"leading digits\" pattern fitting a maximum of 3 leading digits.\r\n\t\t// So, after a user inputs 3 digits of a national (significant) phone number\r\n\t\t// this national (significant) number can already be formatted.\r\n\t\t// The next \"leading digits\" pattern is for 4 leading digits max,\r\n\t\t// and the \"leading digits\" pattern after it is for 5 leading digits max, etc.\r\n\r\n\t\t// This implementation is different from Google's\r\n\t\t// in that it searches for a fitting format\r\n\t\t// even if the user has entered less than\r\n\t\t// `MIN_LEADING_DIGITS_LENGTH` digits of a national number.\r\n\t\t// Because some leading digit patterns already match for a single first digit.\r\n\t\tlet leadingDigitsPatternIndex = leadingDigits.length - MIN_LEADING_DIGITS_LENGTH\r\n\t\tif (leadingDigitsPatternIndex < 0) {\r\n\t\t\tleadingDigitsPatternIndex = 0\r\n\t\t}\r\n\r\n\t\tthis.matchingFormats = this.matchingFormats.filter(\r\n\t\t\tformat => this.formatSuits(format, international, nationalPrefix)\r\n\t\t\t\t&& this.formatMatches(format, leadingDigits, leadingDigitsPatternIndex)\r\n\t\t)\r\n\r\n\t\t// If there was a phone number format chosen\r\n\t\t// and it no longer holds given the new leading digits then reset it.\r\n\t\t// The test for this `if` condition is marked as:\r\n\t\t// \"Reset a chosen format when it no longer holds given the new leading digits\".\r\n\t\t// To construct a valid test case for this one can find a country\r\n\t\t// in `PhoneNumberMetadata.xml` yielding one format for 3 `<leadingDigits>`\r\n\t\t// and yielding another format for 4 `<leadingDigits>` (Australia in this case).\r\n\t\tif (this.chosenFormat && this.matchingFormats.indexOf(this.chosenFormat) === -1) {\r\n\t\t\tthis.resetFormat()\r\n\t\t}\r\n\t}\r\n\r\n\tformatSuits(format, international, nationalPrefix) {\r\n\t\t// When a prefix before a national (significant) number is\r\n\t\t// simply a national prefix, then it's parsed as `this.nationalPrefix`.\r\n\t\t// In more complex cases, a prefix before national (significant) number\r\n\t\t// could include a national prefix as well as some \"capturing groups\",\r\n\t\t// and in that case there's no info whether a national prefix has been parsed.\r\n\t\t// If national prefix is not used when formatting a phone number\r\n\t\t// using this format, but a national prefix has been entered by the user,\r\n\t\t// and was extracted, then discard such phone number format.\r\n\t\t// In Google's \"AsYouType\" formatter code, the equivalent would be this part:\r\n\t\t// https://github.com/google/libphonenumber/blob/0a45cfd96e71cad8edb0e162a70fcc8bd9728933/java/libphonenumber/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java#L175-L184\r\n\t\tif (nationalPrefix &&\r\n\t\t\t!format.usesNationalPrefix() &&\r\n\t\t\t// !format.domesticCarrierCodeFormattingRule() &&\r\n\t\t\t!format.nationalPrefixIsOptionalWhenFormattingInNationalFormat()) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\t// If national prefix is mandatory for this phone number format\r\n\t\t// and there're no guarantees that a national prefix is present in user input\r\n\t\t// then discard this phone number format as not suitable.\r\n\t\t// In Google's \"AsYouType\" formatter code, the equivalent would be this part:\r\n\t\t// https://github.com/google/libphonenumber/blob/0a45cfd96e71cad8edb0e162a70fcc8bd9728933/java/libphonenumber/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java#L185-L193\r\n\t\tif (!international &&\r\n\t\t\t!nationalPrefix &&\r\n\t\t\tformat.nationalPrefixIsMandatoryWhenFormattingInNationalFormat()) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\treturn true\r\n\t}\r\n\r\n\tformatMatches(format, leadingDigits, leadingDigitsPatternIndex) {\r\n\t\tconst leadingDigitsPatternsCount = format.leadingDigitsPatterns().length\r\n\r\n\t\t// If this format is not restricted to a certain\r\n\t\t// leading digits pattern then it fits.\r\n\t\t// The test case could be found by searching for \"leadingDigitsPatternsCount === 0\".\r\n\t\tif (leadingDigitsPatternsCount === 0) {\r\n\t\t\treturn true\r\n\t\t}\r\n\r\n\t\t// Start narrowing down the list of possible formats based on the leading digits.\r\n\t\t// (only previously matched formats take part in the narrowing down process)\r\n\r\n\t\t// `leading_digits_patterns` start with 3 digits min\r\n\t\t// and then go up from there one digit at a time.\r\n\t\tleadingDigitsPatternIndex = Math.min(leadingDigitsPatternIndex, leadingDigitsPatternsCount - 1)\r\n\t\tconst leadingDigitsPattern = format.leadingDigitsPatterns()[leadingDigitsPatternIndex]\r\n\r\n\t\t// Google imposes a requirement on the leading digits\r\n\t\t// to be minimum 3 digits long in order to be eligible\r\n\t\t// for checking those with a leading digits pattern.\r\n\t\t//\r\n\t\t// Since `leading_digits_patterns` start with 3 digits min,\r\n\t\t// Google's original `libphonenumber` library only starts\r\n\t\t// excluding any non-matching formats only when the\r\n\t\t// national number entered so far is at least 3 digits long,\r\n\t\t// otherwise format matching would give false negatives.\r\n\t\t//\r\n\t\t// For example, when the digits entered so far are `2`\r\n\t\t// and the leading digits pattern is `21` –\r\n\t\t// it's quite obvious in this case that the format could be the one\r\n\t\t// but due to the absence of further digits it would give false negative.\r\n\t\t//\r\n\t\t// Also, `leading_digits_patterns` doesn't always correspond to a single\r\n\t\t// digits count. For example, `60|8` pattern would already match `8`\r\n\t\t// but the `60` part would require having at least two leading digits,\r\n\t\t// so the whole pattern would require inputting two digits first in order to\r\n\t\t// decide on whether it matches the input, even when the input is \"80\".\r\n\t\t//\r\n\t\t// This library — `libphonenumber-js` — allows filtering by `leading_digits_patterns`\r\n\t\t// even when there's only 1 or 2 digits of the national (significant) number.\r\n\t\t// To do that, it uses a non-strict pattern matcher written specifically for that.\r\n\t\t//\r\n\t\tif (leadingDigits.length < MIN_LEADING_DIGITS_LENGTH) {\r\n\t\t\t// Before leading digits < 3 matching was implemented:\r\n\t\t\t// return true\r\n\t\t\t//\r\n\t\t\t// After leading digits < 3 matching was implemented:\r\n\t\t\ttry {\r\n\t\t\t\treturn new PatternMatcher(leadingDigitsPattern).match(leadingDigits, { allowOverflow: true }) !== undefined\r\n\t\t\t} catch (error) /* istanbul ignore next */ {\r\n\t\t\t\t// There's a slight possibility that there could be some undiscovered bug\r\n\t\t\t\t// in the pattern matcher code. Since the \"leading digits < 3 matching\"\r\n\t\t\t\t// feature is not \"essential\" for operation, it can fall back to the old way\r\n\t\t\t\t// in case of any issues rather than halting the application's execution.\r\n\t\t\t\tconsole.error(error)\r\n\t\t\t\treturn true\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// If at least `MIN_LEADING_DIGITS_LENGTH` digits of a national number are\r\n\t\t// available then use the usual regular expression matching.\r\n\t\t//\r\n\t\t// The whole pattern is wrapped in round brackets (`()`) because\r\n\t\t// the pattern can use \"or\" operator (`|`) at the top level of the pattern.\r\n\t\t//\r\n\t\treturn new RegExp(`^(${leadingDigitsPattern})`).test(leadingDigits)\r\n\t}\r\n\r\n\tgetFormatFormat(format, international) {\r\n\t\treturn international ? format.internationalFormat() : format.format()\r\n\t}\r\n\r\n\tchooseFormat(state) {\r\n\t\t// When there are multiple available formats, the formatter uses the first\r\n\t\t// format where a formatting template could be created.\r\n\t\t//\r\n\t\t// For some weird reason, `istanbul` says \"else path not taken\"\r\n\t\t// for the `for of` line below. Supposedly that means that\r\n\t\t// the loop doesn't ever go over the last element in the list.\r\n\t\t// That's true because there always is `this.chosenFormat`\r\n\t\t// when `this.matchingFormats` is non-empty.\r\n\t\t// And, for some weird reason, it doesn't think that the case\r\n\t\t// with empty `this.matchingFormats` qualifies for a valid \"else\" path.\r\n\t\t// So simply muting this `istanbul` warning.\r\n\t\t// It doesn't skip the contents of the `for of` loop,\r\n\t\t// it just skips the `for of` line.\r\n\t\t//\r\n\t\t/* istanbul ignore next */\r\n\t\tfor (const format of this.matchingFormats.slice()) {\r\n\t\t\t// If this format is currently being used\r\n\t\t\t// and is still suitable, then stick to it.\r\n\t\t\tif (this.chosenFormat === format) {\r\n\t\t\t\tbreak\r\n\t\t\t}\r\n\t\t\t// Sometimes, a formatting rule inserts additional digits in a phone number,\r\n\t\t\t// and \"as you type\" formatter can't do that: it should only use the digits\r\n\t\t\t// that the user has input.\r\n\t\t\t//\r\n\t\t\t// For example, in Argentina, there's a format for mobile phone numbers:\r\n\t\t\t//\r\n\t\t\t// {\r\n\t\t\t//    \"pattern\": \"(\\\\d)(\\\\d{2})(\\\\d{4})(\\\\d{4})\",\r\n\t\t\t//    \"leading_digits_patterns\": [\"91\"],\r\n\t\t\t//    \"national_prefix_formatting_rule\": \"0$1\",\r\n\t\t\t//    \"format\": \"$2 15-$3-$4\",\r\n\t\t\t//    \"international_format\": \"$1 $2 $3-$4\"\r\n\t\t\t// }\r\n\t\t\t//\r\n\t\t\t// In that format, `international_format` is used instead of `format`\r\n\t\t\t// because `format` inserts `15` in the formatted number,\r\n\t\t\t// and `AsYouType` formatter should only use the digits\r\n\t\t\t// the user has actually input, without adding any extra digits.\r\n\t\t\t// In this case, it wouldn't make a difference, because the `15`\r\n\t\t\t// is first stripped when applying `national_prefix_for_parsing`\r\n\t\t\t// and then re-added when using `format`, so in reality it doesn't\r\n\t\t\t// add any new digits to the number, but to detect that, the code\r\n\t\t\t// would have to be more complex: it would have to try formatting\r\n\t\t\t// the digits using the format and then see if any digits have\r\n\t\t\t// actually been added or removed, and then, every time a new digit\r\n\t\t\t// is input, it should re-check whether the chosen format doesn't\r\n\t\t\t// alter the digits.\r\n\t\t\t//\r\n\t\t\t// Google's code doesn't go that far, and so does this library:\r\n\t\t\t// it simply requires that a `format` doesn't add any additonal\r\n\t\t\t// digits to user's input.\r\n\t\t\t//\r\n\t\t\t// Also, people in general should move from inputting phone numbers\r\n\t\t\t// in national format (possibly with national prefixes)\r\n\t\t\t// and use international phone number format instead:\r\n\t\t\t// it's a logical thing in the modern age of mobile phones,\r\n\t\t\t// globalization and the internet.\r\n\t\t\t//\r\n\t\t\t/* istanbul ignore if */\r\n\t\t\tif (!NON_ALTERING_FORMAT_REG_EXP.test(this.getFormatFormat(format, state.international))) {\r\n\t\t\t\tcontinue\r\n\t\t\t}\r\n\t\t\tif (!this.createTemplateForFormat(format, state)) {\r\n\t\t\t\t// Remove the format if it can't generate a template.\r\n\t\t\t\tthis.matchingFormats = this.matchingFormats.filter(_ => _ !== format)\r\n\t\t\t\tcontinue\r\n\t\t\t}\r\n\t\t\tthis.chosenFormat = format\r\n\t\t\tbreak\r\n\t\t}\r\n\t\tif (!this.chosenFormat) {\r\n\t\t\t// No format matches the national (significant) phone number.\r\n\t\t\tthis.resetFormat()\r\n\t\t}\r\n\t\treturn this.chosenFormat\r\n\t}\r\n\r\n\tcreateTemplateForFormat(format, state) {\r\n\t\t// The formatter doesn't format numbers when numberPattern contains '|', e.g.\r\n\t\t// (20|3)\\d{4}. In those cases we quickly return.\r\n\t\t// (Though there's no such format in current metadata)\r\n\t\t/* istanbul ignore if */\r\n\t\tif (SUPPORT_LEGACY_FORMATTING_PATTERNS && format.pattern().indexOf('|') >= 0) {\r\n\t\t\treturn\r\n\t\t}\r\n\t\t// Get formatting template for this phone number format\r\n\t\tconst template = this.getTemplateForFormat(format, state)\r\n\t\t// If the national number entered is too long\r\n\t\t// for any phone number format, then abort.\r\n\t\tif (template) {\r\n\t\t\tthis.setNationalNumberTemplate(template, state)\r\n\t\t\treturn true\r\n\t\t}\r\n\t}\r\n\r\n\tgetSeparatorAfterNationalPrefix(format) {\r\n\t\t// `US` metadata doesn't have a `national_prefix_formatting_rule`,\r\n\t\t// so the `if` condition below doesn't apply to `US`,\r\n\t\t// but in reality there shoudl be a separator\r\n\t\t// between a national prefix and a national (significant) number.\r\n\t\t// So `US` national prefix separator is a \"special\" \"hardcoded\" case.\r\n\t\tif (this.isNANP) {\r\n\t\t\treturn ' '\r\n\t\t}\r\n\t\t// If a `format` has a `national_prefix_formatting_rule`\r\n\t\t// and that rule has a separator after a national prefix,\r\n\t\t// then it means that there should be a separator\r\n\t\t// between a national prefix and a national (significant) number.\r\n\t\tif (format &&\r\n\t\t\tformat.nationalPrefixFormattingRule() &&\r\n\t\t\tNATIONAL_PREFIX_SEPARATORS_PATTERN.test(format.nationalPrefixFormattingRule())) {\r\n\t\t\treturn ' '\r\n\t\t}\r\n\t\t// At this point, there seems to be no clear evidence that\r\n\t\t// there should be a separator between a national prefix\r\n\t\t// and a national (significant) number. So don't insert one.\r\n\t\treturn ''\r\n\t}\r\n\r\n\tgetInternationalPrefixBeforeCountryCallingCode({ IDDPrefix, missingPlus }, options) {\r\n\t\tif (IDDPrefix) {\r\n\t\t\treturn options && options.spacing === false ? IDDPrefix : IDDPrefix + ' '\r\n\t\t}\r\n\t\tif (missingPlus) {\r\n\t\t\treturn ''\r\n\t\t}\r\n\t\treturn '+'\r\n\t}\r\n\r\n\tgetTemplate(state) {\r\n\t\tif (!this.template) {\r\n\t\t\treturn\r\n\t\t}\r\n\t\t// `this.template` holds the template for a \"complete\" phone number.\r\n\t\t// The currently entered phone number is most likely not \"complete\",\r\n\t\t// so trim all non-populated digits.\r\n\t\tlet index = -1\r\n\t\tlet i = 0\r\n\t\tconst internationalPrefix = state.international ? this.getInternationalPrefixBeforeCountryCallingCode(state, { spacing: false }) : ''\r\n\t\twhile (i < internationalPrefix.length + state.getDigitsWithoutInternationalPrefix().length) {\r\n\t\t\tindex = this.template.indexOf(DIGIT_PLACEHOLDER, index + 1)\r\n\t\t\ti++\r\n\t\t}\r\n\t\treturn cutAndStripNonPairedParens(this.template, index + 1)\r\n\t}\r\n\r\n\tsetNationalNumberTemplate(template, state) {\r\n\t\tthis.nationalNumberTemplate = template\r\n\t\tthis.populatedNationalNumberTemplate = template\r\n\t\t// With a new formatting template, the matched position\r\n\t\t// using the old template needs to be reset.\r\n\t\tthis.populatedNationalNumberTemplatePosition = -1\r\n\t\t// For convenience, the public `.template` property\r\n\t\t// contains the whole international number\r\n\t\t// if the phone number being input is international:\r\n\t\t// 'x' for the '+' sign, 'x'es for the country phone code,\r\n\t\t// a spacebar and then the template for the formatted national number.\r\n\t\tif (state.international) {\r\n\t\t\tthis.template =\r\n\t\t\t\tthis.getInternationalPrefixBeforeCountryCallingCode(state).replace(/[\\d\\+]/g, DIGIT_PLACEHOLDER) +\r\n\t\t\t\trepeat(DIGIT_PLACEHOLDER, state.callingCode.length) +\r\n\t\t\t\t' ' +\r\n\t\t\t\ttemplate\r\n\t\t} else {\r\n\t\t\tthis.template = template\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Generates formatting template for a national phone number,\r\n\t * optionally containing a national prefix, for a format.\r\n\t * @param  {Format} format\r\n\t * @param  {string} nationalPrefix\r\n\t * @return {string}\r\n\t */\r\n\tgetTemplateForFormat(format, {\r\n\t\tnationalSignificantNumber,\r\n\t\tinternational,\r\n\t\tnationalPrefix,\r\n\t\tprefixBeforeNationalSignificantNumberThatIsNotNationalPrefix\r\n\t}) {\r\n\t\tlet pattern = format.pattern()\r\n\r\n\t\t/* istanbul ignore else */\r\n\t\tif (SUPPORT_LEGACY_FORMATTING_PATTERNS) {\r\n\t\t\tpattern = pattern\r\n\t\t\t\t// Replace anything in the form of [..] with \\d\r\n\t\t\t\t.replace(CREATE_CHARACTER_CLASS_PATTERN(), '\\\\d')\r\n\t\t\t\t// Replace any standalone digit (not the one in `{}`) with \\d\r\n\t\t\t\t.replace(CREATE_STANDALONE_DIGIT_PATTERN(), '\\\\d')\r\n\t\t}\r\n\r\n\t\t// Generate a dummy national number (consisting of `9`s)\r\n\t\t// that fits this format's `pattern`.\r\n\t\t//\r\n\t\t// This match will always succeed,\r\n\t\t// because the \"longest dummy phone number\"\r\n\t\t// has enough length to accomodate any possible\r\n\t\t// national phone number format pattern.\r\n\t\t//\r\n\t\tlet digits = LONGEST_DUMMY_PHONE_NUMBER.match(pattern)[0]\r\n\r\n\t\t// If the national number entered is too long\r\n\t\t// for any phone number format, then abort.\r\n\t\tif (nationalSignificantNumber.length > digits.length) {\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\t// Get a formatting template which can be used to efficiently format\r\n\t\t// a partial number where digits are added one by one.\r\n\r\n\t\t// Below `strictPattern` is used for the\r\n\t\t// regular expression (with `^` and `$`).\r\n\t\t// This wasn't originally in Google's `libphonenumber`\r\n\t\t// and I guess they don't really need it\r\n\t\t// because they're not using \"templates\" to format phone numbers\r\n\t\t// but I added `strictPattern` after encountering\r\n\t\t// South Korean phone number formatting bug.\r\n\t\t//\r\n\t\t// Non-strict regular expression bug demonstration:\r\n\t\t//\r\n\t\t// this.nationalSignificantNumber : `111111111` (9 digits)\r\n\t\t//\r\n\t\t// pattern : (\\d{2})(\\d{3,4})(\\d{4})\r\n\t\t// format : `$1 $2 $3`\r\n\t\t// digits : `9999999999` (10 digits)\r\n\t\t//\r\n\t\t// '9999999999'.replace(new RegExp(/(\\d{2})(\\d{3,4})(\\d{4})/g), '$1 $2 $3') = \"99 9999 9999\"\r\n\t\t//\r\n\t\t// template : xx xxxx xxxx\r\n\t\t//\r\n\t\t// But the correct template in this case is `xx xxx xxxx`.\r\n\t\t// The template was generated incorrectly because of the\r\n\t\t// `{3,4}` variability in the `pattern`.\r\n\t\t//\r\n\t\t// The fix is, if `this.nationalSignificantNumber` has already sufficient length\r\n\t\t// to satisfy the `pattern` completely then `this.nationalSignificantNumber`\r\n\t\t// is used instead of `digits`.\r\n\r\n\t\tconst strictPattern = new RegExp('^' + pattern + '$')\r\n\t\tconst nationalNumberDummyDigits = nationalSignificantNumber.replace(/\\d/g, DUMMY_DIGIT)\r\n\r\n\t\t// If `this.nationalSignificantNumber` has already sufficient length\r\n\t\t// to satisfy the `pattern` completely then use it\r\n\t\t// instead of `digits`.\r\n\t\tif (strictPattern.test(nationalNumberDummyDigits)) {\r\n\t\t\tdigits = nationalNumberDummyDigits\r\n\t\t}\r\n\r\n\t\tlet numberFormat = this.getFormatFormat(format, international)\r\n\t\tlet nationalPrefixIncludedInTemplate\r\n\r\n\t\t// If a user did input a national prefix (and that's guaranteed),\r\n\t\t// and if a `format` does have a national prefix formatting rule,\r\n\t\t// then see if that national prefix formatting rule\r\n\t\t// prepends exactly the same national prefix the user has input.\r\n\t\t// If that's the case, then use the `format` with the national prefix formatting rule.\r\n\t\t// Otherwise, use  the `format` without the national prefix formatting rule,\r\n\t\t// and prepend a national prefix manually to it.\r\n\t\tif (this.shouldTryNationalPrefixFormattingRule(format, { international, nationalPrefix })) {\r\n\t\t\tconst numberFormatWithNationalPrefix = numberFormat.replace(\r\n\t\t\t\tFIRST_GROUP_PATTERN,\r\n\t\t\t\tformat.nationalPrefixFormattingRule()\r\n\t\t\t)\r\n\t\t\t// If `national_prefix_formatting_rule` of a `format` simply prepends\r\n\t\t\t// national prefix at the start of a national (significant) number,\r\n\t\t\t// then such formatting can be used with `AsYouType` formatter.\r\n\t\t\t// There seems to be no `else` case: everywhere in metadata,\r\n\t\t\t// national prefix formatting rule is national prefix + $1,\r\n\t\t\t// or `($1)`, in which case such format isn't even considered\r\n\t\t\t// when the user has input a national prefix.\r\n\t\t\t/* istanbul ignore else */\r\n\t\t\tif (parseDigits(format.nationalPrefixFormattingRule()) === (nationalPrefix || '') + parseDigits('$1')) {\r\n\t\t\t\tnumberFormat = numberFormatWithNationalPrefix\r\n\t\t\t\tnationalPrefixIncludedInTemplate = true\r\n\t\t\t\t// Replace all digits of the national prefix in the formatting template\r\n\t\t\t\t// with `DIGIT_PLACEHOLDER`s.\r\n\t\t\t\tif (nationalPrefix) {\r\n\t\t\t\t\tlet i = nationalPrefix.length\r\n\t\t\t\t\twhile (i > 0) {\r\n\t\t\t\t\t\tnumberFormat = numberFormat.replace(/\\d/, DIGIT_PLACEHOLDER)\r\n\t\t\t\t\t\ti--\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Generate formatting template for this phone number format.\r\n\t\tlet template = digits\r\n\t\t\t// Format the dummy phone number according to the format.\r\n\t\t\t.replace(new RegExp(pattern), numberFormat)\r\n\t\t\t// Replace each dummy digit with a DIGIT_PLACEHOLDER.\r\n\t\t\t.replace(new RegExp(DUMMY_DIGIT, 'g'), DIGIT_PLACEHOLDER)\r\n\r\n\t\t// If a prefix of a national (significant) number is not as simple\r\n\t\t// as just a basic national prefix, then just prepend such prefix\r\n\t\t// before the national (significant) number, optionally spacing\r\n\t\t// the two with a whitespace.\r\n\t\tif (!nationalPrefixIncludedInTemplate) {\r\n\t\t\tif (prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix) {\r\n\t\t\t\t// Prepend the prefix to the template manually.\r\n\t\t\t\ttemplate = repeat(DIGIT_PLACEHOLDER, prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix.length) +\r\n\t\t\t\t\t' ' +\r\n\t\t\t\t\ttemplate\r\n\t\t\t} else if (nationalPrefix) {\r\n\t\t\t\t// Prepend national prefix to the template manually.\r\n\t\t\t\ttemplate = repeat(DIGIT_PLACEHOLDER, nationalPrefix.length) +\r\n\t\t\t\t\tthis.getSeparatorAfterNationalPrefix(format) +\r\n\t\t\t\t\ttemplate\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (international) {\r\n\t\t\ttemplate = applyInternationalSeparatorStyle(template)\r\n\t\t}\r\n\r\n\t\treturn template\r\n\t}\r\n\r\n\tformatNextNationalNumberDigits(digits) {\r\n\t\tconst result = populateTemplateWithDigits(\r\n\t\t\tthis.populatedNationalNumberTemplate,\r\n\t\t\tthis.populatedNationalNumberTemplatePosition,\r\n\t\t\tdigits\r\n\t\t)\r\n\r\n\t\tif (!result) {\r\n\t\t\t// Reset the format.\r\n\t\t\tthis.resetFormat()\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\tthis.populatedNationalNumberTemplate = result[0]\r\n\t\tthis.populatedNationalNumberTemplatePosition = result[1]\r\n\r\n\t\t// Return the formatted phone number so far.\r\n\t\treturn cutAndStripNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1)\r\n\r\n\t\t// The old way which was good for `input-format` but is not so good\r\n\t\t// for `react-phone-number-input`'s default input (`InputBasic`).\r\n\t\t// return closeNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1)\r\n\t\t// \t.replace(new RegExp(DIGIT_PLACEHOLDER, 'g'), ' ')\r\n\t}\r\n\r\n\tshouldTryNationalPrefixFormattingRule(format, { international, nationalPrefix }) {\r\n\t\tif (format.nationalPrefixFormattingRule()) {\r\n\t\t\t// In some countries, `national_prefix_formatting_rule` is `($1)`,\r\n\t\t\t// so it applies even if the user hasn't input a national prefix.\r\n\t\t\t// `format.usesNationalPrefix()` detects such cases.\r\n\t\t\tconst usesNationalPrefix = format.usesNationalPrefix()\r\n\t\t\tif ((usesNationalPrefix && nationalPrefix) ||\r\n\t\t\t\t(!usesNationalPrefix && !international)) {\r\n\t\t\t\treturn true\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}","import extractCountryCallingCode from './helpers/extractCountryCallingCode.js'\r\nimport extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js'\r\nimport extractNationalNumberFromPossiblyIncompleteNumber from './helpers/extractNationalNumberFromPossiblyIncompleteNumber.js'\r\nimport stripIddPrefix from './helpers/stripIddPrefix.js'\r\nimport parseDigits from './helpers/parseDigits.js'\r\n\r\nimport {\r\n\tVALID_DIGITS,\r\n\tVALID_PUNCTUATION,\r\n\tPLUS_CHARS\r\n} from './constants.js'\r\n\r\nconst VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART =\r\n\t'[' +\r\n\t\tVALID_PUNCTUATION +\r\n\t\tVALID_DIGITS +\r\n\t']+'\r\n\r\nconst VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN = new RegExp('^' + VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART + '$', 'i')\r\n\r\nconst VALID_FORMATTED_PHONE_NUMBER_PART =\r\n\t'(?:' +\r\n\t\t'[' + PLUS_CHARS + ']' +\r\n\t\t'[' +\r\n\t\t\tVALID_PUNCTUATION +\r\n\t\t\tVALID_DIGITS +\r\n\t\t']*' +\r\n\t\t'|' +\r\n\t\t'[' +\r\n\t\t\tVALID_PUNCTUATION +\r\n\t\t\tVALID_DIGITS +\r\n\t\t']+' +\r\n\t')'\r\n\r\nconst AFTER_PHONE_NUMBER_DIGITS_END_PATTERN = new RegExp(\r\n\t'[^' +\r\n\t\tVALID_PUNCTUATION +\r\n\t\tVALID_DIGITS +\r\n\t']+' +\r\n\t'.*' +\r\n\t'$'\r\n)\r\n\r\n// Tests whether `national_prefix_for_parsing` could match\r\n// different national prefixes.\r\n// Matches anything that's not a digit or a square bracket.\r\nconst COMPLEX_NATIONAL_PREFIX = /[^\\d\\[\\]]/\r\n\r\nexport default class AsYouTypeParser {\r\n\tconstructor({\r\n\t\tdefaultCountry,\r\n\t\tdefaultCallingCode,\r\n\t\tmetadata,\r\n\t\tonNationalSignificantNumberChange\r\n\t}) {\r\n\t\tthis.defaultCountry = defaultCountry\r\n\t\tthis.defaultCallingCode = defaultCallingCode\r\n\t\tthis.metadata = metadata\r\n\t\tthis.onNationalSignificantNumberChange = onNationalSignificantNumberChange\r\n\t}\r\n\r\n\tinput(text, state) {\r\n\t\tconst [formattedDigits, hasPlus] = extractFormattedDigitsAndPlus(text)\r\n\t\tconst digits = parseDigits(formattedDigits)\r\n\t\t// Checks for a special case: just a leading `+` has been entered.\r\n\t\tlet justLeadingPlus\r\n\t\tif (hasPlus) {\r\n\t\t\tif (!state.digits) {\r\n\t\t\t\tstate.startInternationalNumber(undefined, undefined)\r\n\t\t\t\tif (!digits) {\r\n\t\t\t\t\tjustLeadingPlus = true\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (digits) {\r\n\t\t\tthis.inputDigits(digits, state)\r\n\t\t}\r\n\t\treturn {\r\n\t\t\tdigits,\r\n\t\t\tjustLeadingPlus\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Inputs \"next\" phone number digits.\r\n\t * @param  {string} digits\r\n\t * @return {string} [formattedNumber] Formatted national phone number (if it can be formatted at this stage). Returning `undefined` means \"don't format the national phone number at this stage\".\r\n\t */\r\n\tinputDigits(nextDigits, state) {\r\n\t\tconst { digits } = state\r\n\t\tconst hasReceivedThreeLeadingDigits = digits.length < 3 && digits.length + nextDigits.length >= 3\r\n\r\n\t\t// Append phone number digits.\r\n\t\tstate.appendDigits(nextDigits)\r\n\r\n\t\t// Attempt to extract IDD prefix:\r\n\t\t// Some users input their phone number in international format,\r\n\t\t// but in an \"out-of-country\" dialing format instead of using the leading `+`.\r\n\t\t// https://github.com/catamphetamine/libphonenumber-js/issues/185\r\n\t\t// Detect such numbers as soon as there're at least 3 digits.\r\n\t\t// Google's library attempts to extract IDD prefix at 3 digits,\r\n\t\t// so this library just copies that behavior.\r\n\t\t// I guess that's because the most commot IDD prefixes are\r\n\t\t// `00` (Europe) and `011` (US).\r\n\t\t// There exist really long IDD prefixes too:\r\n\t\t// for example, in Australia the default IDD prefix is `0011`,\r\n\t\t// and it could even be as long as `14880011`.\r\n\t\t// An IDD prefix is extracted here, and then every time when\r\n\t\t// there's a new digit and the number couldn't be formatted.\r\n\t\tif (hasReceivedThreeLeadingDigits) {\r\n\t\t\tthis.extractIddPrefix(state)\r\n\t\t}\r\n\r\n\t\tif (this.isWaitingForCountryCallingCode(state)) {\r\n\t\t\tif (!this.extractCountryCallingCode(state)) {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tstate.appendNationalSignificantNumberDigits(nextDigits)\r\n\t\t}\r\n\r\n\t\t// If a phone number is being input in international format,\r\n\t\t// then it's not valid for it to have a national prefix.\r\n\t\t// Still, some people incorrectly input such numbers with a national prefix.\r\n\t\t// In such cases, only attempt to strip a national prefix if the number becomes too long.\r\n\t\t// (but that is done later, not here)\r\n\t\tif (!state.international) {\r\n\t\t\tif (!this.hasExtractedNationalSignificantNumber) {\r\n\t\t\t\tthis.extractNationalSignificantNumber(\r\n\t\t\t\t\tstate.getNationalDigits(),\r\n\t\t\t\t\t(stateUpdate) => state.update(stateUpdate)\r\n\t\t\t\t)\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tisWaitingForCountryCallingCode({ international, callingCode }) {\r\n\t\treturn international && !callingCode\r\n\t}\r\n\r\n\t// Extracts a country calling code from a number\r\n\t// being entered in internatonal format.\r\n\textractCountryCallingCode(state) {\r\n\t\tconst { countryCallingCode, number } = extractCountryCallingCode(\r\n\t\t\t'+' + state.getDigitsWithoutInternationalPrefix(),\r\n\t\t\tstate.country,\r\n\t\t\tthis.defaultCountry,\r\n\t\t\tthis.defaultCallingCode,\r\n\t\t\tthis.metadata.metadata\r\n\t\t)\r\n\t\tif (countryCallingCode) {\r\n\t\t\tstate.setCallingCode(countryCallingCode)\r\n\t\t\tstate.update({\r\n\t\t\t\tnationalSignificantNumber: number\r\n\t\t\t})\r\n\t\t\treturn true\r\n\t\t}\r\n\t}\r\n\r\n\treset(numberingPlan) {\r\n\t\tif (numberingPlan) {\r\n\t\t\tthis.hasSelectedNumberingPlan = true\r\n\t\t\tconst nationalPrefixForParsing = numberingPlan._nationalPrefixForParsing()\r\n\t\t\tthis.couldPossiblyExtractAnotherNationalSignificantNumber = nationalPrefixForParsing && COMPLEX_NATIONAL_PREFIX.test(nationalPrefixForParsing)\r\n\t\t} else {\r\n\t\t\tthis.hasSelectedNumberingPlan = undefined\r\n\t\t\tthis.couldPossiblyExtractAnotherNationalSignificantNumber = undefined\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Extracts a national (significant) number from user input.\r\n\t * Google's library is different in that it only applies `national_prefix_for_parsing`\r\n\t * and doesn't apply `national_prefix_transform_rule` after that.\r\n\t * https://github.com/google/libphonenumber/blob/a3d70b0487875475e6ad659af404943211d26456/java/libphonenumber/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java#L539\r\n\t * @return {boolean} [extracted]\r\n\t */\r\n\textractNationalSignificantNumber(nationalDigits, setState) {\r\n\t\tif (!this.hasSelectedNumberingPlan) {\r\n\t\t\treturn\r\n\t\t}\r\n\t\tconst {\r\n\t\t\tnationalPrefix,\r\n\t\t\tnationalNumber,\r\n\t\t\tcarrierCode\r\n\t\t} = extractNationalNumberFromPossiblyIncompleteNumber(\r\n\t\t\tnationalDigits,\r\n\t\t\tthis.metadata\r\n\t\t)\r\n\t\tif (nationalNumber === nationalDigits) {\r\n\t\t\treturn\r\n\t\t}\r\n\t\tthis.onExtractedNationalNumber(\r\n\t\t\tnationalPrefix,\r\n\t\t\tcarrierCode,\r\n\t\t\tnationalNumber,\r\n\t\t\tnationalDigits,\r\n\t\t\tsetState\r\n\t\t)\r\n\t\treturn true\r\n\t}\r\n\r\n\t/**\r\n\t * In Google's code this function is called \"attempt to extract longer NDD\".\r\n\t * \"Some national prefixes are a substring of others\", they say.\r\n\t * @return {boolean} [result] — Returns `true` if extracting a national prefix produced different results from what they were.\r\n\t */\r\n\textractAnotherNationalSignificantNumber(nationalDigits, prevNationalSignificantNumber, setState) {\r\n\t\tif (!this.hasExtractedNationalSignificantNumber) {\r\n\t\t\treturn this.extractNationalSignificantNumber(nationalDigits, setState)\r\n\t\t}\r\n\t\tif (!this.couldPossiblyExtractAnotherNationalSignificantNumber) {\r\n\t\t\treturn\r\n\t\t}\r\n\t\tconst {\r\n\t\t\tnationalPrefix,\r\n\t\t\tnationalNumber,\r\n\t\t\tcarrierCode\r\n\t\t} = extractNationalNumberFromPossiblyIncompleteNumber(\r\n\t\t\tnationalDigits,\r\n\t\t\tthis.metadata\r\n\t\t)\r\n\t\t// If a national prefix has been extracted previously,\r\n\t\t// then it's always extracted as additional digits are added.\r\n\t\t// That's assuming `extractNationalNumberFromPossiblyIncompleteNumber()`\r\n\t\t// doesn't do anything different from what it currently does.\r\n\t\t// So, just in case, here's this check, though it doesn't occur.\r\n\t\t/* istanbul ignore if */\r\n\t\tif (nationalNumber === prevNationalSignificantNumber) {\r\n\t\t\treturn\r\n\t\t}\r\n\t\tthis.onExtractedNationalNumber(\r\n\t\t\tnationalPrefix,\r\n\t\t\tcarrierCode,\r\n\t\t\tnationalNumber,\r\n\t\t\tnationalDigits,\r\n\t\t\tsetState\r\n\t\t)\r\n\t\treturn true\r\n\t}\r\n\r\n\tonExtractedNationalNumber(\r\n\t\tnationalPrefix,\r\n\t\tcarrierCode,\r\n\t\tnationalSignificantNumber,\r\n\t\tnationalDigits,\r\n\t\tsetState\r\n\t) {\r\n\t\t// Tells if the parsed national (significant) number is present as-is in the input string.\r\n\t\t// For example, when inputting \"0343515551212999\" Argentinian mobile number,\r\n\t\t// the parsed national (significant) number is \"93435551212999\".\r\n\t\t// There, one can see how it stripped \"0\" national prefix and prepended a \"9\",\r\n\t\t// because that's how it is instructed to do in Argentina's metadata.\r\n\t\t// So in the described example, the parsed national (significant) number is not present\r\n\t\t// as-is in the input string. Instead, it's \"modified\" in the input string.\r\n\t\t// https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\r\n\t\tlet nationalSignificantNumberIsModified = false\r\n\r\n\t\t// In some countries, a phone number could have a prefix that is not a \"national prefix\"\r\n\t\t// but rather some other type of \"utility\" prefix.\r\n\t\t// For example, when calling within Australia, one could prepend `1831` prefix to hide\r\n\t\t// caller's phone number.\r\n\t\t// https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\r\n\t\tlet prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix\r\n\r\n\t\t// `nationalSignificantNumber` could be empty. In that case, `.lastIndexOf()` still works correctly.\r\n\t\tconst nationalSignificantNumberIndex = nationalDigits.lastIndexOf(nationalSignificantNumber)\r\n\r\n\t\t// If the parsed national (significant) number is the last substring of the `nationalDigits`,\r\n\t\t// then it means that it's present as-is in the input string.\r\n\t\t// In any other case, the parsed national (significant) number is \"modified\" in the input string.\r\n\t\tif (\r\n\t\t\tnationalSignificantNumberIndex < 0 ||\r\n\t\t\tnationalSignificantNumberIndex !== nationalDigits.length - nationalSignificantNumber.length\r\n\t\t) {\r\n\t\t\tnationalSignificantNumberIsModified = true\r\n\t\t} else {\r\n\t\t\tconst prefixBeforeNationalNumber = nationalDigits.slice(0, nationalSignificantNumberIndex)\r\n\t\t\t// When national (significant) number is equal to the `nationalDigits`,\r\n\t\t\t// this `onExtractedNationalNumber()` function simply doesn't get called.\r\n\t\t\t// This means that at this point, `prefixBeforeNationalNumber` is always non-empty.\r\n\t\t\t// Still, added this `if` check just to prevent potential silly bugs.\r\n\t\t\t// The `!prefixBeforeNationalNumber` case is not really testable\r\n\t\t\t// so this line is exluded from the code coverage.\r\n\t\t\t/* istanbul ignore if */\r\n\t\t\tif (prefixBeforeNationalNumber) {\r\n\t\t\t\tif (prefixBeforeNationalNumber !== nationalPrefix) {\r\n\t\t\t\t\tprefixBeforeNationalSignificantNumberThatIsNotNationalPrefix = prefixBeforeNationalNumber\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tsetState({\r\n\t\t\tnationalPrefix,\r\n\t\t\tcarrierCode,\r\n\t\t\tnationalSignificantNumber,\r\n\t\t\tnationalSignificantNumberIsModified,\r\n\t\t\tprefixBeforeNationalSignificantNumberThatIsNotNationalPrefix\r\n\t\t})\r\n\t\t// `onExtractedNationalNumber()` is only called when\r\n\t\t// the national (significant) number actually did change.\r\n\t\tthis.hasExtractedNationalSignificantNumber = true\r\n\t\tthis.onNationalSignificantNumberChange()\r\n\t}\r\n\r\n\treExtractNationalSignificantNumber(state) {\r\n\t\t// Attempt to extract a national prefix.\r\n\t\t//\r\n\t\t// Some people incorrectly input national prefix\r\n\t\t// in an international phone number.\r\n\t\t// For example, some people write British phone numbers as `+44(0)...`.\r\n\t\t//\r\n\t\t// Also, in some rare cases, it is valid for a national prefix\r\n\t\t// to be a part of an international phone number.\r\n\t\t// For example, mobile phone numbers in Mexico are supposed to be\r\n\t\t// dialled internationally using a `1` national prefix,\r\n\t\t// so the national prefix will be part of an international number.\r\n\t\t//\r\n\t\t// Quote from:\r\n\t\t// https://www.mexperience.com/dialing-cell-phones-in-mexico/\r\n\t\t//\r\n\t\t// \"Dialing a Mexican cell phone from abroad\r\n\t\t// When you are calling a cell phone number in Mexico from outside Mexico,\r\n\t\t// it’s necessary to dial an additional “1” after Mexico’s country code\r\n\t\t// (which is “52”) and before the area code.\r\n\t\t// You also ignore the 045, and simply dial the area code and the\r\n\t\t// cell phone’s number.\r\n\t\t//\r\n\t\t// If you don’t add the “1”, you’ll receive a recorded announcement\r\n\t\t// asking you to redial using it.\r\n\t\t//\r\n\t\t// For example, if you are calling from the USA to a cell phone\r\n\t\t// in Mexico City, you would dial +52 – 1 – 55 – 1234 5678.\r\n\t\t// (Note that this is different to calling a land line in Mexico City\r\n\t\t// from abroad, where the number dialed would be +52 – 55 – 1234 5678)\".\r\n\t\t//\r\n\t\t// Google's demo output:\r\n\t\t// https://libphonenumber.appspot.com/phonenumberparser?number=%2b5215512345678&country=MX\r\n\t\t//\r\n\t\tif (this.extractAnotherNationalSignificantNumber(\r\n\t\t\tstate.getNationalDigits(),\r\n\t\t\tstate.nationalSignificantNumber,\r\n\t\t\t(stateUpdate) => state.update(stateUpdate)\r\n\t\t)) {\r\n\t\t\treturn true\r\n\t\t}\r\n\t\t// If no format matches the phone number, then it could be\r\n\t\t// \"a really long IDD\" (quote from a comment in Google's library).\r\n\t\t// An IDD prefix is first extracted when the user has entered at least 3 digits,\r\n\t\t// and then here — every time when there's a new digit and the number\r\n\t\t// couldn't be formatted.\r\n\t\t// For example, in Australia the default IDD prefix is `0011`,\r\n\t\t// and it could even be as long as `14880011`.\r\n\t\t//\r\n\t\t// Could also check `!hasReceivedThreeLeadingDigits` here\r\n\t\t// to filter out the case when this check duplicates the one\r\n\t\t// already performed when there're 3 leading digits,\r\n\t\t// but it's not a big deal, and in most cases there\r\n\t\t// will be a suitable `format` when there're 3 leading digits.\r\n\t\t//\r\n\t\tif (this.extractIddPrefix(state)) {\r\n\t\t\tthis.extractCallingCodeAndNationalSignificantNumber(state)\r\n\t\t\treturn true\r\n\t\t}\r\n\t\t// Google's AsYouType formatter supports sort of an \"autocorrection\" feature\r\n\t\t// when it \"autocorrects\" numbers that have been input for a country\r\n\t\t// with that country's calling code.\r\n\t\t// Such \"autocorrection\" feature looks weird, but different people have been requesting it:\r\n\t\t// https://github.com/catamphetamine/libphonenumber-js/issues/376\r\n\t\t// https://github.com/catamphetamine/libphonenumber-js/issues/375\r\n\t\t// https://github.com/catamphetamine/libphonenumber-js/issues/316\r\n\t\tif (this.fixMissingPlus(state)) {\r\n\t\t\tthis.extractCallingCodeAndNationalSignificantNumber(state)\r\n\t\t\treturn true\r\n\t\t}\r\n\t}\r\n\r\n\textractIddPrefix(state) {\r\n\t\t// An IDD prefix can't be present in a number written with a `+`.\r\n\t\t// Also, don't re-extract an IDD prefix if has already been extracted.\r\n\t\tconst {\r\n\t\t\tinternational,\r\n\t\t\tIDDPrefix,\r\n\t\t\tdigits,\r\n\t\t\tnationalSignificantNumber\r\n\t\t} = state\r\n\t\tif (international || IDDPrefix) {\r\n\t\t\treturn\r\n\t\t}\r\n\t\t// Some users input their phone number in \"out-of-country\"\r\n\t\t// dialing format instead of using the leading `+`.\r\n\t\t// https://github.com/catamphetamine/libphonenumber-js/issues/185\r\n\t\t// Detect such numbers.\r\n\t\tconst numberWithoutIDD = stripIddPrefix(\r\n\t\t\tdigits,\r\n\t\t\tthis.defaultCountry,\r\n\t\t\tthis.defaultCallingCode,\r\n\t\t\tthis.metadata.metadata\r\n\t\t)\r\n\t\tif (numberWithoutIDD !== undefined && numberWithoutIDD !== digits) {\r\n\t\t\t// If an IDD prefix was stripped then convert the IDD-prefixed number\r\n\t\t\t// to international number for subsequent parsing.\r\n\t\t\tstate.update({\r\n\t\t\t\tIDDPrefix: digits.slice(0, digits.length - numberWithoutIDD.length)\r\n\t\t\t})\r\n\t\t\tthis.startInternationalNumber(state, {\r\n\t\t\t\tcountry: undefined,\r\n\t\t\t\tcallingCode: undefined\r\n\t\t\t})\r\n\t\t\treturn true\r\n\t\t}\r\n\t}\r\n\r\n\tfixMissingPlus(state) {\r\n\t\tif (!state.international) {\r\n\t\t\tconst {\r\n\t\t\t\tcountryCallingCode: newCallingCode\r\n\t\t\t} = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(\r\n\t\t\t\tstate.digits,\r\n\t\t\t\tstate.country,\r\n\t\t\t\tthis.defaultCountry,\r\n\t\t\t\tthis.defaultCallingCode,\r\n\t\t\t\tthis.metadata.metadata\r\n\t\t\t)\r\n\t\t\tif (newCallingCode) {\r\n\t\t\t\tstate.update({\r\n\t\t\t\t\tmissingPlus: true\r\n\t\t\t\t})\r\n\t\t\t\tthis.startInternationalNumber(state, {\r\n\t\t\t\t\tcountry: state.country,\r\n\t\t\t\t\tcallingCode: newCallingCode\r\n\t\t\t\t})\r\n\t\t\t\treturn true\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tstartInternationalNumber(state, { country, callingCode }) {\r\n\t\tstate.startInternationalNumber(country, callingCode)\r\n\t\t// If a national (significant) number has been extracted before, reset it.\r\n\t\tif (state.nationalSignificantNumber) {\r\n\t\t\tstate.resetNationalSignificantNumber()\r\n\t\t\tthis.onNationalSignificantNumberChange()\r\n\t\t\tthis.hasExtractedNationalSignificantNumber = undefined\r\n\t\t}\r\n\t}\r\n\r\n\textractCallingCodeAndNationalSignificantNumber(state) {\r\n\t\tif (this.extractCountryCallingCode(state)) {\r\n\t\t\t// `this.extractCallingCode()` is currently called when the number\r\n\t\t\t// couldn't be formatted during the standard procedure.\r\n\t\t\t// Normally, the national prefix would be re-extracted\r\n\t\t\t// for an international number if such number couldn't be formatted,\r\n\t\t\t// but since it's already not able to be formatted,\r\n\t\t\t// there won't be yet another retry, so also extract national prefix here.\r\n\t\t\tthis.extractNationalSignificantNumber(\r\n\t\t\t\tstate.getNationalDigits(),\r\n\t\t\t\t(stateUpdate) => state.update(stateUpdate)\r\n\t\t\t)\r\n\t\t}\r\n\t}\r\n}\r\n\r\n/**\r\n * Extracts formatted phone number from text (if there's any).\r\n * @param  {string} text\r\n * @return {string} [formattedPhoneNumber]\r\n */\r\nfunction extractFormattedPhoneNumber(text) {\r\n\t// Attempt to extract a possible number from the string passed in.\r\n\tconst startsAt = text.search(VALID_FORMATTED_PHONE_NUMBER_PART)\r\n\tif (startsAt < 0) {\r\n\t\treturn\r\n\t}\r\n\t// Trim everything to the left of the phone number.\r\n\ttext = text.slice(startsAt)\r\n\t// Trim the `+`.\r\n\tlet hasPlus\r\n\tif (text[0] === '+') {\r\n\t\thasPlus = true\r\n\t\ttext = text.slice('+'.length)\r\n\t}\r\n\t// Trim everything to the right of the phone number.\r\n\ttext = text.replace(AFTER_PHONE_NUMBER_DIGITS_END_PATTERN, '')\r\n\t// Re-add the previously trimmed `+`.\r\n\tif (hasPlus) {\r\n\t\ttext = '+' + text\r\n\t}\r\n\treturn text\r\n}\r\n\r\n/**\r\n * Extracts formatted phone number digits (and a `+`) from text (if there're any).\r\n * @param  {string} text\r\n * @return {any[]}\r\n */\r\nfunction _extractFormattedDigitsAndPlus(text) {\r\n\t// Extract a formatted phone number part from text.\r\n\tconst extractedNumber = extractFormattedPhoneNumber(text) || ''\r\n\t// Trim a `+`.\r\n\tif (extractedNumber[0] === '+') {\r\n\t\treturn [extractedNumber.slice('+'.length), true]\r\n\t}\r\n\treturn [extractedNumber]\r\n}\r\n\r\n/**\r\n * Extracts formatted phone number digits (and a `+`) from text (if there're any).\r\n * @param  {string} text\r\n * @return {any[]}\r\n */\r\nexport function extractFormattedDigitsAndPlus(text) {\r\n\tlet [formattedDigits, hasPlus] = _extractFormattedDigitsAndPlus(text)\r\n\t// If the extracted phone number part\r\n\t// can possibly be a part of some valid phone number\r\n\t// then parse phone number characters from a formatted phone number.\r\n\tif (!VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN.test(formattedDigits)) {\r\n\t\tformattedDigits = ''\r\n\t}\r\n\treturn [formattedDigits, hasPlus]\r\n}","import Metadata from './metadata.js'\r\nimport PhoneNumber from './PhoneNumber.js'\r\nimport AsYouTypeState from './AsYouTypeState.js'\r\nimport AsYouTypeFormatter, { DIGIT_PLACEHOLDER } from './AsYouTypeFormatter.js'\r\nimport AsYouTypeParser, { extractFormattedDigitsAndPlus } from './AsYouTypeParser.js'\r\nimport getCountryByCallingCode from './helpers/getCountryByCallingCode.js'\r\nimport getCountryByNationalNumber from './helpers/getCountryByNationalNumber.js'\r\nimport isObject from './helpers/isObject.js'\r\n\r\nconst USE_NON_GEOGRAPHIC_COUNTRY_CODE = false\r\n\r\nexport default class AsYouType {\r\n\t/**\r\n\t * @param {(string|object)?} [optionsOrDefaultCountry] - The default country used for parsing non-international phone numbers. Can also be an `options` object.\r\n\t * @param {Object} metadata\r\n\t */\r\n\tconstructor(optionsOrDefaultCountry, metadata) {\r\n\t\tthis.metadata = new Metadata(metadata)\r\n\t\tconst [defaultCountry, defaultCallingCode] = this.getCountryAndCallingCode(optionsOrDefaultCountry)\r\n\t\t// `this.defaultCountry` and `this.defaultCallingCode` aren't required to be in sync.\r\n\t\t// For example, `this.defaultCountry` could be `\"AR\"` and `this.defaultCallingCode` could be `undefined`.\r\n\t\t// So `this.defaultCountry` and `this.defaultCallingCode` are totally independent.\r\n\t\tthis.defaultCountry = defaultCountry\r\n\t\tthis.defaultCallingCode = defaultCallingCode\r\n\t\tthis.reset()\r\n\t}\r\n\r\n\tgetCountryAndCallingCode(optionsOrDefaultCountry) {\r\n\t\t// Set `defaultCountry` and `defaultCallingCode` options.\r\n\t\tlet defaultCountry\r\n\t\tlet defaultCallingCode\r\n\t\t// Turns out `null` also has type \"object\". Weird.\r\n\t\tif (optionsOrDefaultCountry) {\r\n\t\t\tif (isObject(optionsOrDefaultCountry)) {\r\n\t\t\t\tdefaultCountry = optionsOrDefaultCountry.defaultCountry\r\n\t\t\t\tdefaultCallingCode = optionsOrDefaultCountry.defaultCallingCode\r\n\t\t\t} else {\r\n\t\t\t\tdefaultCountry = optionsOrDefaultCountry\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (defaultCountry && !this.metadata.hasCountry(defaultCountry)) {\r\n\t\t\tdefaultCountry = undefined\r\n\t\t}\r\n\t\tif (defaultCallingCode) {\r\n\t\t\t/* istanbul ignore if */\r\n\t\t\tif (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\r\n\t\t\t\tif (this.metadata.isNonGeographicCallingCode(defaultCallingCode)) {\r\n\t\t\t\t\tdefaultCountry = '001'\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn [defaultCountry, defaultCallingCode]\r\n\t}\r\n\r\n\t/**\r\n\t * Inputs \"next\" phone number characters.\r\n\t * @param  {string} text\r\n\t * @return {string} Formatted phone number characters that have been input so far.\r\n\t */\r\n\tinput(text) {\r\n\t\tconst {\r\n\t\t\tdigits,\r\n\t\t\tjustLeadingPlus\r\n\t\t} = this.parser.input(text, this.state)\r\n\t\tif (justLeadingPlus) {\r\n\t\t\tthis.formattedOutput = '+'\r\n\t\t} else if (digits) {\r\n\t\t\tthis.determineTheCountryIfNeeded()\r\n\t\t\t// Match the available formats by the currently available leading digits.\r\n\t\t\tif (this.state.nationalSignificantNumber) {\r\n\t\t\t\tthis.formatter.narrowDownMatchingFormats(this.state)\r\n\t\t\t}\r\n\t\t\tlet formattedNationalNumber\r\n\t\t\tif (this.metadata.hasSelectedNumberingPlan()) {\r\n\t\t\t\tformattedNationalNumber = this.formatter.format(digits, this.state)\r\n\t\t\t}\r\n\t\t\tif (formattedNationalNumber === undefined) {\r\n\t\t\t\t// See if another national (significant) number could be re-extracted.\r\n\t\t\t\tif (this.parser.reExtractNationalSignificantNumber(this.state)) {\r\n\t\t\t\t\tthis.determineTheCountryIfNeeded()\r\n\t\t\t\t\t// If it could, then re-try formatting the new national (significant) number.\r\n\t\t\t\t\tconst nationalDigits = this.state.getNationalDigits()\r\n\t\t\t\t\tif (nationalDigits) {\r\n\t\t\t\t\t\tformattedNationalNumber = this.formatter.format(nationalDigits, this.state)\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tthis.formattedOutput = formattedNationalNumber\r\n\t\t\t\t? this.getFullNumber(formattedNationalNumber)\r\n\t\t\t\t: this.getNonFormattedNumber()\r\n\t\t}\r\n\t\treturn this.formattedOutput\r\n\t}\r\n\r\n\treset() {\r\n\t\tthis.state = new AsYouTypeState({\r\n\t\t\tonCountryChange: (country) => {\r\n\t\t\t\t// Before version `1.6.0`, the official `AsYouType` formatter API\r\n\t\t\t\t// included a `.country` property on an `AsYouType` instance.\r\n\t\t\t\t// Since that property (along with the others) have been moved to\r\n\t\t\t\t// `this.state`, `this.country` property is emulated for compatibility\r\n\t\t\t\t// with the old versions.\r\n\t\t\t\tthis.country = country\r\n\t\t\t},\r\n\t\t\tonCallingCodeChange: (callingCode, country) => {\r\n\t\t\t\tthis.metadata.selectNumberingPlan(country, callingCode)\r\n\t\t\t\tthis.formatter.reset(this.metadata.numberingPlan, this.state)\r\n\t\t\t\tthis.parser.reset(this.metadata.numberingPlan)\r\n\t\t\t}\r\n\t\t})\r\n\t\tthis.formatter = new AsYouTypeFormatter({\r\n\t\t\tstate: this.state,\r\n\t\t\tmetadata: this.metadata\r\n\t\t})\r\n\t\tthis.parser = new AsYouTypeParser({\r\n\t\t\tdefaultCountry: this.defaultCountry,\r\n\t\t\tdefaultCallingCode: this.defaultCallingCode,\r\n\t\t\tmetadata: this.metadata,\r\n\t\t\tstate: this.state,\r\n\t\t\tonNationalSignificantNumberChange: () => {\r\n\t\t\t\tthis.determineTheCountryIfNeeded()\r\n\t\t\t\tthis.formatter.reset(this.metadata.numberingPlan, this.state)\r\n\t\t\t}\r\n\t\t})\r\n\t\tthis.state.reset({\r\n\t\t\tcountry: this.defaultCountry,\r\n\t\t\tcallingCode: this.defaultCallingCode\r\n\t\t})\r\n\t\tthis.formattedOutput = ''\r\n\t\treturn this\r\n\t}\r\n\r\n\t/**\r\n\t * Returns `true` if the phone number is being input in international format.\r\n\t * In other words, returns `true` if and only if the parsed phone number starts with a `\"+\"`.\r\n\t * @return {boolean}\r\n\t */\r\n\tisInternational() {\r\n\t\treturn this.state.international\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the \"calling code\" part of the phone number when it's being input\r\n\t * in an international format.\r\n\t * If no valid calling code has been entered so far, returns `undefined`.\r\n\t * @return {string} [callingCode]\r\n\t */\r\n\tgetCallingCode() {\r\n\t\t // If the number is being input in national format and some \"default calling code\"\r\n\t\t // has been passed to `AsYouType` constructor, then `this.state.callingCode`\r\n\t\t // is equal to that \"default calling code\".\r\n\t\t //\r\n\t\t // If the number is being input in national format and no \"default calling code\"\r\n\t\t // has been passed to `AsYouType` constructor, then returns `undefined`,\r\n\t\t // even if a \"default country\" has been passed to `AsYouType` constructor.\r\n\t\t //\r\n\t\tif (this.isInternational()) {\r\n\t\t\treturn this.state.callingCode\r\n\t\t}\r\n\t}\r\n\r\n\t// A legacy alias.\r\n\tgetCountryCallingCode() {\r\n\t\treturn this.getCallingCode()\r\n\t}\r\n\r\n\t/**\r\n\t * Returns a two-letter country code of the phone number.\r\n\t * Returns `undefined` for \"non-geographic\" phone numbering plans.\r\n\t * Returns `undefined` if no phone number has been input yet.\r\n\t * @return {string} [country]\r\n\t */\r\n\tgetCountry() {\r\n\t\tconst { digits } = this.state\r\n\t\t// Return `undefined` if no digits have been input yet.\r\n\t\tif (digits) {\r\n\t\t\treturn this._getCountry()\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Returns a two-letter country code of the phone number.\r\n\t * Returns `undefined` for \"non-geographic\" phone numbering plans.\r\n\t * @return {string} [country]\r\n\t */\r\n\t_getCountry() {\r\n\t\tconst { country } = this.state\r\n\t\t/* istanbul ignore if */\r\n\t\tif (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\r\n\t\t\t// `AsYouType.getCountry()` returns `undefined`\r\n\t\t\t// for \"non-geographic\" phone numbering plans.\r\n\t\t\tif (country === '001') {\r\n\t\t\t\treturn\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn country\r\n\t}\r\n\r\n\tdetermineTheCountryIfNeeded() {\r\n\t\t// Suppose a user enters a phone number in international format,\r\n\t\t// and there're several countries corresponding to that country calling code,\r\n\t\t// and a country has been derived from the number, and then\r\n\t\t// a user enters one more digit and the number is no longer\r\n\t\t// valid for the derived country, so the country should be re-derived\r\n\t\t// on every new digit in those cases.\r\n\t\t//\r\n\t\t// If the phone number is being input in national format,\r\n\t\t// then it could be a case when `defaultCountry` wasn't specified\r\n\t\t// when creating `AsYouType` instance, and just `defaultCallingCode` was specified,\r\n\t\t// and that \"calling code\" could correspond to a \"non-geographic entity\",\r\n\t\t// or there could be several countries corresponding to that country calling code.\r\n\t\t// In those cases, `this.country` is `undefined` and should be derived\r\n\t\t// from the number. Again, if country calling code is ambiguous, then\r\n\t\t// `this.country` should be re-derived with each new digit.\r\n\t\t//\r\n\t\tif (!this.state.country || this.isCountryCallingCodeAmbiguous()) {\r\n\t\t\tthis.determineTheCountry()\r\n\t\t}\r\n\t}\r\n\r\n\t// Prepends `+CountryCode ` in case of an international phone number\r\n\tgetFullNumber(formattedNationalNumber) {\r\n\t\tif (this.isInternational()) {\r\n\t\t\tconst prefix = (text) => this.formatter.getInternationalPrefixBeforeCountryCallingCode(this.state, {\r\n\t\t\t\tspacing: text ? true : false\r\n\t\t\t}) + text\r\n\t\t\tconst { callingCode } = this.state\r\n\t\t\tif (!callingCode) {\r\n\t\t\t\treturn prefix(`${this.state.getDigitsWithoutInternationalPrefix()}`)\r\n\t\t\t}\r\n\t\t\tif (!formattedNationalNumber) {\r\n\t\t\t\treturn prefix(callingCode)\r\n\t\t\t}\r\n\t\t\treturn prefix(`${callingCode} ${formattedNationalNumber}`)\r\n\t\t}\r\n\t\treturn formattedNationalNumber\r\n\t}\r\n\r\n\tgetNonFormattedNationalNumberWithPrefix() {\r\n\t\tconst {\r\n\t\t\tnationalSignificantNumber,\r\n\t\t\tprefixBeforeNationalSignificantNumberThatIsNotNationalPrefix,\r\n\t\t\tnationalPrefix\r\n\t\t} = this.state\r\n\t\tlet number = nationalSignificantNumber\r\n\t\tconst prefix = prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix || nationalPrefix\r\n\t\tif (prefix) {\r\n\t\t\tnumber = prefix + number\r\n\t\t}\r\n\t\treturn number\r\n\t}\r\n\r\n\tgetNonFormattedNumber() {\r\n\t\tconst { nationalSignificantNumberIsModified } = this.state\r\n\t\treturn this.getFullNumber(\r\n\t\t\tnationalSignificantNumberIsModified\r\n\t\t\t\t? this.state.getNationalDigits()\r\n\t\t\t\t: this.getNonFormattedNationalNumberWithPrefix()\r\n\t\t)\r\n\t}\r\n\r\n\tgetNonFormattedTemplate() {\r\n\t\tconst number = this.getNonFormattedNumber()\r\n\t\tif (number) {\r\n\t\t\treturn number.replace(/[\\+\\d]/g, DIGIT_PLACEHOLDER)\r\n\t\t}\r\n\t}\r\n\r\n\tisCountryCallingCodeAmbiguous() {\r\n\t\tconst { callingCode } = this.state\r\n\t\tconst countryCodes = this.metadata.getCountryCodesForCallingCode(callingCode)\r\n\t\treturn countryCodes && countryCodes.length > 1\r\n\t}\r\n\r\n\t// Determines the exact country of the phone number\r\n\t// entered so far based on the country phone code\r\n\t// and the national phone number.\r\n\tdetermineTheCountry() {\r\n\t\tthis.state.setCountry(getCountryByCallingCode(\r\n\t\t\tthis.isInternational() ? this.state.callingCode : this.defaultCallingCode,\r\n\t\t\t{\r\n\t\t\t\tnationalNumber: this.state.nationalSignificantNumber,\r\n\t\t\t\tmetadata: this.metadata\r\n\t\t\t}\r\n\t\t))\r\n\t}\r\n\r\n\t/**\r\n\t * Returns a E.164 phone number value for the user's input.\r\n\t *\r\n\t * For example, for country `\"US\"` and input `\"(222) 333-4444\"`\r\n\t * it will return `\"+12223334444\"`.\r\n\t *\r\n\t * For international phone number input, it will also auto-correct\r\n\t * some minor errors such as using a national prefix when writing\r\n\t * an international phone number. For example, if the user inputs\r\n\t * `\"+44 0 7400 000000\"` then it will return an auto-corrected\r\n\t * `\"+447400000000\"` phone number value.\r\n\t *\r\n\t * Will return `undefined` if no digits have been input,\r\n\t * or when inputting a phone number in national format and no\r\n\t * default country or default \"country calling code\" have been set.\r\n\t *\r\n\t * @return {string} [value]\r\n\t */\r\n\tgetNumberValue() {\r\n\t\tconst {\r\n\t\t\tdigits,\r\n\t\t\tcallingCode,\r\n\t\t\tcountry,\r\n\t\t\tnationalSignificantNumber\r\n\t\t} = this.state\r\n\r\n\t \t// Will return `undefined` if no digits have been input.\r\n\t\tif (!digits) {\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\tif (this.isInternational()) {\r\n\t\t\tif (callingCode) {\r\n\t\t\t\treturn '+' + callingCode + nationalSignificantNumber\r\n\t\t\t} else {\r\n\t\t\t\treturn '+' + digits\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tif (country || callingCode) {\r\n\t\t\t\tconst callingCode_ = country ? this.metadata.countryCallingCode() : callingCode\r\n\t\t\t\treturn '+' + callingCode_ + nationalSignificantNumber\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Returns an instance of `PhoneNumber` class.\r\n\t * Will return `undefined` if no national (significant) number\r\n\t * digits have been entered so far, or if no `defaultCountry` has been\r\n\t * set and the user enters a phone number not in international format.\r\n\t */\r\n\tgetNumber() {\r\n\t\tconst {\r\n\t\t\tnationalSignificantNumber,\r\n\t\t\tcarrierCode,\r\n\t\t\tcallingCode\r\n\t\t} = this.state\r\n\r\n\t\t// `this._getCountry()` is basically same as `this.state.country`\r\n\t\t// with the only change that it return `undefined` in case of a\r\n\t\t// \"non-geographic\" numbering plan instead of `\"001\"` \"internal use\" value.\r\n\t\tlet country = this._getCountry()\r\n\r\n\t\tif (!nationalSignificantNumber) {\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\t// `state.country` and `state.callingCode` aren't required to be in sync.\r\n\t\t// For example, `country` could be `\"AR\"` and `callingCode` could be `undefined`.\r\n\t\t// So `country` and `callingCode` are totally independent.\r\n\r\n\t\tif (!country && !callingCode) {\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\t// By default, if `defaultCountry` parameter was passed when\r\n\t\t// creating `AsYouType` instance, `state.country` is gonna be\r\n\t\t// that `defaultCountry`, which doesn't entirely conform with\r\n\t\t// `parsePhoneNumber()`'s behavior where it attempts to determine\r\n\t\t// the country more precisely in cases when multiple countries\r\n\t\t// could correspond to the same `countryCallingCode`.\r\n\t\t// https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/103#note_1417192969\r\n\t\t//\r\n\t\t// Because `AsYouType.getNumber()` method is supposed to be a 1:1\r\n\t\t// equivalent for `parsePhoneNumber(AsYouType.getNumberValue())`,\r\n\t\t// then it should also behave accordingly in cases of `country` ambiguity.\r\n\t\t// That's how users of this library would expect it to behave anyway.\r\n\t\t//\r\n\t\tif (country) {\r\n\t\t\tif (country === this.defaultCountry) {\r\n\t\t\t\t// `state.country` and `state.callingCode` aren't required to be in sync.\r\n\t\t\t\t// For example, `state.country` could be `\"AR\"` and `state.callingCode` could be `undefined`.\r\n\t\t\t\t// So `state.country` and `state.callingCode` are totally independent.\r\n\t\t\t\tconst metadata = new Metadata(this.metadata.metadata)\r\n\t\t\t\tmetadata.selectNumberingPlan(country)\r\n\t\t\t\tconst callingCode = metadata.numberingPlan.callingCode()\r\n\t\t\t\tconst ambiguousCountries = this.metadata.getCountryCodesForCallingCode(callingCode)\r\n\t\t\t\tif (ambiguousCountries.length > 1) {\r\n\t\t\t\t\tconst exactCountry = getCountryByNationalNumber(nationalSignificantNumber, {\r\n\t\t\t\t\t\tcountries: ambiguousCountries,\r\n\t\t\t\t\t\tmetadata: this.metadata.metadata\r\n\t\t\t\t\t})\r\n\t\t\t\t\tif (exactCountry) {\r\n\t\t\t\t\t\tcountry = exactCountry\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst phoneNumber = new PhoneNumber(\r\n\t\t\tcountry || callingCode,\r\n\t\t\tnationalSignificantNumber,\r\n\t\t\tthis.metadata.metadata\r\n\t\t)\r\n\t\tif (carrierCode) {\r\n\t\t\tphoneNumber.carrierCode = carrierCode\r\n\t\t}\r\n\t\t// Phone number extensions are not supported by \"As You Type\" formatter.\r\n\t\treturn phoneNumber\r\n\t}\r\n\r\n\t/**\r\n\t * Returns `true` if the phone number is \"possible\".\r\n\t * Is just a shortcut for `PhoneNumber.isPossible()`.\r\n\t * @return {boolean}\r\n\t */\r\n\tisPossible() {\r\n\t\tconst phoneNumber = this.getNumber()\r\n\t\tif (!phoneNumber) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\treturn phoneNumber.isPossible()\r\n\t}\r\n\r\n\t/**\r\n\t * Returns `true` if the phone number is \"valid\".\r\n\t * Is just a shortcut for `PhoneNumber.isValid()`.\r\n\t * @return {boolean}\r\n\t */\r\n\tisValid() {\r\n\t\tconst phoneNumber = this.getNumber()\r\n\t\tif (!phoneNumber) {\r\n\t\t\treturn false\r\n\t\t}\r\n\t\treturn phoneNumber.isValid()\r\n\t}\r\n\r\n\t/**\r\n\t * @deprecated\r\n\t * This method is used in `react-phone-number-input/source/input-control.js`\r\n\t * in versions before `3.0.16`.\r\n\t */\r\n\tgetNationalNumber() {\r\n\t\treturn this.state.nationalSignificantNumber\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the phone number characters entered by the user.\r\n\t * @return {string}\r\n\t */\r\n\tgetChars() {\r\n\t\treturn (this.state.international ? '+' : '') + this.state.digits\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the template for the formatted phone number.\r\n\t * @return {string}\r\n\t */\r\n\tgetTemplate() {\r\n\t\treturn this.formatter.getTemplate(this.state) || this.getNonFormattedTemplate() || ''\r\n\t}\r\n}","import Metadata from '../metadata.js'\r\nimport matchesEntirely from './matchesEntirely.js'\r\n\r\nconst NON_FIXED_LINE_PHONE_TYPES = [\r\n\t'MOBILE',\r\n\t'PREMIUM_RATE',\r\n\t'TOLL_FREE',\r\n\t'SHARED_COST',\r\n\t'VOIP',\r\n\t'PERSONAL_NUMBER',\r\n\t'PAGER',\r\n\t'UAN',\r\n\t'VOICEMAIL'\r\n]\r\n\r\n// Finds out national phone number type (fixed line, mobile, etc)\r\nexport default function getNumberType(input, options, metadata)\r\n{\r\n\t// If assigning the `{}` default value is moved to the arguments above,\r\n\t// code coverage would decrease for some weird reason.\r\n\toptions = options || {}\r\n\r\n\t// When `parse()` returns an empty object — `{}` —\r\n\t// that means that the phone number is malformed,\r\n\t// so it can't possibly be valid.\r\n\tif (!input.country && !input.countryCallingCode) {\r\n\t\treturn\r\n\t}\r\n\r\n\tmetadata = new Metadata(metadata)\r\n\r\n\tmetadata.selectNumberingPlan(input.country, input.countryCallingCode)\r\n\r\n\tconst nationalNumber = options.v2 ? input.nationalNumber : input.phone\r\n\r\n\t// The following is copy-pasted from the original function:\r\n\t// https://github.com/googlei18n/libphonenumber/blob/3ea547d4fbaa2d0b67588904dfa5d3f2557c27ff/javascript/i18n/phonenumbers/phonenumberutil.js#L2835\r\n\r\n\t// Is this national number even valid for this country\r\n\tif (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern())) {\r\n\t\treturn\r\n\t}\r\n\r\n\t// Is it fixed line number\r\n\tif (isNumberTypeEqualTo(nationalNumber, 'FIXED_LINE', metadata)) {\r\n\t\t// Because duplicate regular expressions are removed\r\n\t\t// to reduce metadata size, if \"mobile\" pattern is \"\"\r\n\t\t// then it means it was removed due to being a duplicate of the fixed-line pattern.\r\n\t\t//\r\n\t\tif (metadata.type('MOBILE') && metadata.type('MOBILE').pattern() === '') {\r\n\t\t\treturn 'FIXED_LINE_OR_MOBILE'\r\n\t\t}\r\n\r\n\t\t// `MOBILE` type pattern isn't included if it matched `FIXED_LINE` one.\r\n\t\t// For example, for \"US\" country.\r\n\t\t// Old metadata (< `1.0.18`) had a specific \"types\" data structure\r\n\t\t// that happened to be `undefined` for `MOBILE` in that case.\r\n\t\t// Newer metadata (>= `1.0.18`) has another data structure that is\r\n\t\t// not `undefined` for `MOBILE` in that case (it's just an empty array).\r\n\t\t// So this `if` is just for backwards compatibility with old metadata.\r\n\t\tif (!metadata.type('MOBILE')) {\r\n\t\t\treturn 'FIXED_LINE_OR_MOBILE'\r\n\t\t}\r\n\r\n\t\t// Check if the number happens to qualify as both fixed line and mobile.\r\n\t\t// (no such country in the minimal metadata set)\r\n\t\t/* istanbul ignore if */\r\n\t\tif (isNumberTypeEqualTo(nationalNumber, 'MOBILE', metadata)) {\r\n\t\t\treturn 'FIXED_LINE_OR_MOBILE'\r\n\t\t}\r\n\r\n\t\treturn 'FIXED_LINE'\r\n\t}\r\n\r\n\tfor (const type of NON_FIXED_LINE_PHONE_TYPES) {\r\n\t\tif (isNumberTypeEqualTo(nationalNumber, type, metadata)) {\r\n\t\t\treturn type\r\n\t\t}\r\n\t}\r\n}\r\n\r\nexport function isNumberTypeEqualTo(nationalNumber, type, metadata) {\r\n\ttype = metadata.type(type)\r\n\tif (!type || !type.pattern()) {\r\n\t\treturn false\r\n\t}\r\n\t// Check if any possible number lengths are present;\r\n\t// if so, we use them to avoid checking\r\n\t// the validation pattern if they don't match.\r\n\t// If they are absent, this means they match\r\n\t// the general description, which we have\r\n\t// already checked before a specific number type.\r\n\tif (type.possibleLengths() &&\r\n\t\ttype.possibleLengths().indexOf(nationalNumber.length) < 0) {\r\n\t\treturn false\r\n\t}\r\n\treturn matchesEntirely(nationalNumber, type.pattern())\r\n}","import PhoneNumber from './PhoneNumber.js'\r\n\r\nexport default function getExampleNumber(country, examples, metadata) {\r\n\tif (examples[country]) {\r\n\t\treturn new PhoneNumber(country, examples[country], metadata)\r\n\t}\r\n}"],"names":["USE_NON_GEOGRAPHIC_COUNTRY_CODE","getCountryByCallingCode","callingCode","_ref","nationalPhoneNumber","nationalNumber","metadata","isNonGeographicCallingCode","possibleCountries","getCountryCodesForCallingCode","length","getCountryByNationalNumber","countries","DIGIT_PLACEHOLDER","DIGIT_PLACEHOLDER_MATCHER","RegExp","repeat","string","times","result","cutAndStripNonPairedParens","cutBeforeIndex","dangling_braces","i","push","pop","start","cleared_string","_i","_dangling_braces","index","slice","stripNonPairedParens","populateTemplateWithDigits","template","position","digits","_step2","_iterator2","_createForOfIteratorHelperLoose","split","done","digit","value","search","replace","validatePhoneNumberLength","_normalizeArguments","normalizeArguments","arguments","text","options","_objectSpread","extract","phoneNumber","parsePhoneNumberWithError","Metadata","selectNumberingPlan","countryCallingCode","checkNumberLength","country","error","ParseError","message","applyInternationalSeparatorStyle","formattedNumber","concat","VALID_PUNCTUATION","trim","MIN_LENGTH_FOR_NSN","MAX_LENGTH_FOR_NSN","MAX_LENGTH_COUNTRY_CODE","VALID_DIGITS","WHITESPACE","PLUS_CHARS","SLASH_SEPARATED_DATES","TIME_STAMPS","TIME_STAMPS_SUFFIX_LEADING","isValidPreCandidate","candidate","offset","test","followingText","objectConstructor","constructor","isObject","object","undefined","FIRST_GROUP_PATTERN","formatNationalNumberUsingFormat","number","format","useInternationalFormat","withNationalPrefix","carrierCode","pattern","internationalFormat","nationalPrefixFormattingRule","isValidPhoneNumber","parsePhoneNumber","isValid","args","_Array$prototype$slic2","_slicedToArray","Array","prototype","call","arg_1","arg_2","arg_3","arg_4","TypeError","Error","defaultCountry","SECOND_NUMBER_START_PATTERN","parsePreCandidate","trimAfterFirstMatch","_Error","code","_this","_classCallCheck","_callSuper","Object","setPrototypeOf","name","_inherits","_wrapNativeSuper","matchesEntirely","regularExpressionText","extractNationalNumberFromPossiblyIncompleteNumber","numberingPlan","nationalPrefixForParsing","prefixPattern","prefixMatch","exec","nationalPrefix","capturedGroupsCount","hasCapturedGroups","nationalPrefixTransformRule","prefixBeforeNationalNumber","possiblePositionOfTheFirstCapturedGroup","indexOf","parse","v2","searchPhoneNumbersInText","matcher","PhoneNumberMatcher","_defineProperty","Symbol","iterator","next","hasNext","DIGITS","parseDigit","character","parseDigits","_step","_iterator","_pZ","pZ","PZ","_pN","pNd","_pL","pL","pL_regexp","pSc","pSc_regexp","pMn","pMn_regexp","latinLetterRegexp","isLatinLetter","letter","isInvalidPunctuationSymbol","extractCountryCallingCode","defaultCallingCode","isNumberWithIddPrefix","numberWithoutIDD","stripIddPrefix","_extractCountryCallin","extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","shorterNumber","countryCallingCodeSource","_countryCallingCode","hasCallingCode","getPossibleCountriesForNumber","filter","_metadata","possibleLengths","couldNationalNumberBelongToCountry","PhoneNumber","countryOrCountryCallingCode","e164Number","E164_NUMBER_REGEXP","validateMetadata","_getCountryAndCountry","metadataJson","isCountryCode","getCountryAndCountryCallingCode","this","getMetadata","key","ext","isPossibleNumber","isValidNumber","getNumberType","_format","formatNumber","RFC3966_EXTN_PREFIX","getExtensionDigitsPattern","maxLength","createExtensionPattern","purpose","possibleSeparatorsBetweenNumberAndExtLabel","possibleCharsAfterExtLabel","optionalExtnSuffix","possibleSeparatorsNumberExtLabelNoComma","findNumbers","results","parsePhoneNumberWithError_","CAPTURING_DIGIT_PATTERN","countryMetadata","IDDPrefixPattern","IDDPrefix","matchedGroups","match","EXTN_PATTERN","PLUS_SIGN","RFC3966_PHONE_DIGIT_","RFC3966_GLOBAL_NUMBER_DIGITS_","RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_","ALPHANUM_","RFC3966_DOMAINNAME_PATTERN_","RFC3966_PREFIX_","RFC3966_PHONE_CONTEXT_","RFC3966_ISDN_SUBADDRESS_","extractFormattedPhoneNumberFromPossibleRfc3966NumberUri","numberToParse","phoneNumberString","extractFormattedPhoneNumber","phoneContext","numberToExtractFrom","indexOfPhoneContext","phoneContextStart","phoneContextEnd","substring","extractPhoneContext","isPhoneContextValid","charAt","indexOfNationalNumber","indexOfRfc3966Prefix","indexOfIsdn","MAX_INPUT_STRING_LENGTH","PHONE_NUMBER_START_PATTERN","AFTER_PHONE_NUMBER_END_PATTERN","hasCountry","_parseInput","throwOnError","startsAt","_extractFormattedPhoneNumber","isViablePhoneNumber","isViablePhoneNumberStart","withExtensionStripped","numberWithoutExtension","matches","extractExtension","parseInput","formattedPhoneNumber","_parsePhoneNumber","parseIncompletePhoneNumber","getCountryCallingCode","_extractNationalNumbe","extractNationalNumber","exactCountry","hasSelectedNumberingPlan","__countryCallingCodeSource","valid","extended","nationalNumberPattern","possible","phone","isPossiblePhoneNumber","isPossible","parsePhoneNumber_","checkNumberLengthForType","type","type_info","possible_lengths","mobile_type","a","b","merged","element","sort","mergeArrays","actual_length","minimum_length","possibleShorterNumber","possibleShorterNationalNumber","SINGLE_IDD_PREFIX_REG_EXP","DEFAULT_OPTIONS","formatExtension","extension","input","_len","objects","_key","merge","addExtension","formatNationalNumber","formatRFC3966","fromCountry","fromCountryCallingCode","iddPrefix","defaultIDDPrefix","getIddPrefix","formatIDD","formatAs","chooseFormatForNumber","formats","nationalPrefixIsOptionalWhenFormattingInNationalFormat","availableFormats","elements","testFunction","pickFirstMatchingElement","leadingDigitsPatterns","lastLeadingDigitsPattern","searchNumbers","formatIncompletePhoneNumber","optionsOrDefaultCountry","AsYouType","Node","_createClass","prev","LRUCache","limit","size","head","tail","cache","ensureLimit","node","remove","put","console","log","RegExpCache","regExp","get","matchPhoneNumberStringAgainstPhoneNumber","phoneNumberStringContainsCallingCode","parsedPhoneNumber","POSSIBLE","VALID","_ref2","containsOnlyValidXChars","STRICT_GROUPING","_ref3","regExpCache","containsMoreThanOneSlashInNationalNumber","isNationalPrefixPresentIfRequired","checkNumberGroupingIsValid","allNumberGroupsRemainGrouped","EXACT_GROUPING","_ref4","allNumberGroupsAreExactlyPresent","charAtIndex","charAtNextIndex","_ref5","usesNationalPrefix","Boolean","firstSlashInBodyIndex","secondSlashInBodyIndex","checkGroups","normalizedCandidate","formattedNumberGroups","EXTN_PATTERNS_FOR_MATCHING","INNER_MATCHES","leadLimit","punctuationLimit","digitBlockLimit","blockLimit","punctuation","digitSequence","PATTERN","LEAD_CLASS","UNWANTED_END_CHAR_PATTERN","MAX_SAFE_INTEGER","Number","Math","pow","isSupportedCountry","leniency","maxTries","Leniency","state","searchIndex","parseAndVerify","extractInnerMatch","endsAt","_INNER_MATCHES","isFirstMatch","candidateMatch","innerMatchRegExp","_candidate","_match","candidateIndexGuess","isValidCandidate","lastMatch","find","lower","upper","regexp","nationalNumberBefore","nationalNumberAfter","shouldHaveExtractedNationalPrefix","isPossibleIncompleteNationalNumber","MIN_LENGTH_PHONE_NUMBER_PATTERN","VALID_PHONE_NUMBER","VALID_PHONE_NUMBER_START_REG_EXP","VALID_PHONE_NUMBER_WITH_EXTENSION","VALID_PHONE_NUMBER_PATTERN","getCountries","findPhoneNumbersInText","parsePhoneNumberCharacter","prevParsedCharacters","eventListener","OPENING_PARENS","CLOSING_PARENS","NON_PARENS","LEAD_CLASS_LEADING","BRACKET_PAIR_LIMIT","MATCHING_BRACKETS_ENTIRE","PUB_PAGES","previousChar","lastCharIndex","nextChar","parseRFC3966","_part$split2","hasTypes","pa","pb","na","nb","isNaN","DEFAULT_EXT_PREFIX","CALLING_CODE_REG_EXP","setVersion","keys","_","countryCode","v1","v3","nonGeographic","nonGeographical","getCountryMetadata","countryCodes","countryCallingCodes","NumberingPlan","getNumberingPlanMetadata","getCountryCodeForCallingCode","leadingDigits","_type","country_phone_code_to_countries","country_calling_codes","globalMetadataObject","_getFormats","getDefaultCountryMetadataForRegion","map","Format","_getNationalPrefixFormattingRule","_nationalPrefixForParsing","_getNationalPrefixIsOptionalWhenFormatting","types","_type2","getType","Type","FIRST_GROUP_ONLY_PREFIX_PATTERN","join","typeOf","_typeof","getExtPrefix","hasOwnProperty","version","v4","compare","AsYouTypeState","onCountryChange","onCallingCodeChange","international","missingPlus","resetNationalSignificantNumber","initCountryAndCallingCode","nationalSignificantNumber","getNationalDigits","nationalSignificantNumberIsModified","prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix","properties","_Object$keys","setCountry","setCallingCode","nextDigits","formatCompleteNumber","shouldTryNationalPrefixFormattingRule","getSeparatorAfterNationalPrefix","useNationalPrefixFormattingRule","formatNationalNumberWithAndWithoutNationalPrefixFormattingRule","formattedNationalNumber","isValidFormattedNationalNumber","PatternParser","context","or","instructions","parsePattern","_this$context$","branches","op","expandSingleElementArray","OPERATOR","operator","before","rightPart","startContext","getContext","endContext","oneOfSet","parseOneOfSet","ILLEGAL_CHARACTER_REGEXP","values","prevValue","charCodeAt","nextValue","String","fromCharCode","array","PatternMatcher","matchTree","allowOverflow","matchedChars","overflow","characters","tree","last","characterString","partialMatch","isArray","restCharacters","JSON","stringify","_result","_char","LONGEST_DUMMY_PHONE_NUMBER","NATIONAL_PREFIX_SEPARATORS_PATTERN","CREATE_CHARACTER_CLASS_PATTERN","CREATE_STANDALONE_DIGIT_PATTERN","NON_ALTERING_FORMAT_REG_EXP","AsYouTypeFormatter","resetFormat","chosenFormat","nationalNumberTemplate","populatedNationalNumberTemplate","populatedNationalNumberTemplatePosition","isNANP","matchingFormats","narrowDownMatchingFormats","canFormatCompleteNumber","formattedCompleteNumber","setNationalNumberTemplate","lastIndexOf","formatNationalNumberWithNextDigits","previouslyChosenFormat","newlyChosenFormat","chooseFormat","formatNextNationalNumberDigits","_this2","leadingDigitsPatternIndex","formatSuits","formatMatches","nationalPrefixIsMandatoryWhenFormattingInNationalFormat","leadingDigitsPatternsCount","min","leadingDigitsPattern","_this3","_loop","getFormatFormat","createTemplateForFormat","getTemplateForFormat","spacing","internationalPrefix","getInternationalPrefixBeforeCountryCallingCode","getDigitsWithoutInternationalPrefix","strictPattern","nationalNumberDummyDigits","nationalPrefixIncludedInTemplate","numberFormat","numberFormatWithNationalPrefix","VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART","VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN","VALID_FORMATTED_PHONE_NUMBER_PART","AFTER_PHONE_NUMBER_DIGITS_END_PATTERN","COMPLEX_NATIONAL_PREFIX","AsYouTypeParser","onNationalSignificantNumberChange","justLeadingPlus","_extractFormattedDigi","_extractFormattedDigi3","extractedNumber","hasPlus","_extractFormattedDigitsAndPlus","_extractFormattedDigi4","formattedDigits","extractFormattedDigitsAndPlus","_extractFormattedDigi2","startInternationalNumber","inputDigits","hasReceivedThreeLeadingDigits","appendDigits","extractIddPrefix","isWaitingForCountryCallingCode","appendNationalSignificantNumberDigits","hasExtractedNationalSignificantNumber","extractNationalSignificantNumber","stateUpdate","update","_extractCountryCallingCode","couldPossiblyExtractAnotherNationalSignificantNumber","nationalDigits","setState","onExtractedNationalNumber","prevNationalSignificantNumber","_extractNationalNumbe2","nationalSignificantNumberIndex","extractAnotherNationalSignificantNumber","fixMissingPlus","extractCallingCodeAndNationalSignificantNumber","newCallingCode","_this$getCountryAndCa2","getCountryAndCallingCode","reset","_this$parser$input","parser","formattedOutput","determineTheCountryIfNeeded","formatter","reExtractNationalSignificantNumber","getFullNumber","getNonFormattedNumber","isInternational","getCallingCode","_getCountry","isCountryCallingCodeAmbiguous","determineTheCountry","prefix","_this$state","getNonFormattedNationalNumberWithPrefix","_this$state2","_this$state3","_callingCode","ambiguousCountries","getNumber","getTemplate","getNonFormattedTemplate","NON_FIXED_LINE_PHONE_TYPES","isNumberTypeEqualTo","getExampleNumber","examples"],"sourceRoot":""}