{"version":3,"file":"vendors-15989550.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/libphonenumber-js/es6/normalizeArguments.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/parseIncompletePhoneNumber.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/parse.js"],"sourcesContent":["function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n// Extracts the following properties from function arguments:\n// * input `text`\n// * `options` object\n// * `metadata` JSON\nexport default function normalizeArguments(args) {\n  var _Array$prototype$slic = Array.prototype.slice.call(args),\n      _Array$prototype$slic2 = _slicedToArray(_Array$prototype$slic, 4),\n      arg_1 = _Array$prototype$slic2[0],\n      arg_2 = _Array$prototype$slic2[1],\n      arg_3 = _Array$prototype$slic2[2],\n      arg_4 = _Array$prototype$slic2[3];\n\n  var text;\n  var options;\n  var metadata; // If the phone number is passed as a string.\n  // `parsePhoneNumber('88005553535', ...)`.\n\n  if (typeof arg_1 === 'string') {\n    text = arg_1;\n  } else throw new TypeError('A text for parsing must be a string.'); // If \"default country\" argument is being passed then move it to `options`.\n  // `parsePhoneNumber('88005553535', 'RU', [options], metadata)`.\n\n\n  if (!arg_2 || typeof arg_2 === 'string') {\n    if (arg_4) {\n      options = arg_3;\n      metadata = arg_4;\n    } else {\n      options = undefined;\n      metadata = arg_3;\n    }\n\n    if (arg_2) {\n      options = _objectSpread({\n        defaultCountry: arg_2\n      }, options);\n    }\n  } // `defaultCountry` is not passed.\n  // Example: `parsePhoneNumber('+78005553535', [options], metadata)`.\n  else if (isObject(arg_2)) {\n    if (arg_3) {\n      options = arg_2;\n      metadata = arg_3;\n    } else {\n      metadata = arg_2;\n    }\n  } else throw new Error(\"Invalid second argument: \".concat(arg_2));\n\n  return {\n    text: text,\n    options: options,\n    metadata: metadata\n  };\n} // Otherwise istanbul would show this as \"branch not covered\".\n\n/* istanbul ignore next */\n\nvar isObject = function isObject(_) {\n  return _typeof(_) === 'object';\n};\n//# sourceMappingURL=normalizeArguments.js.map","function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport { parseDigit } from './helpers/parseDigits.js';\n/**\r\n * Parses phone number characters from a string.\r\n * Drops all punctuation leaving only digits and the leading `+` sign (if any).\r\n * Also converts wide-ascii and arabic-indic numerals to conventional numerals.\r\n * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.\r\n * @param  {string} string\r\n * @return {string}\r\n * @example\r\n * ```js\r\n * // Outputs '8800555'.\r\n * parseIncompletePhoneNumber('8 (800) 555')\r\n * // Outputs '+7800555'.\r\n * parseIncompletePhoneNumber('+7 800 555')\r\n * ```\r\n */\n\nexport default function parseIncompletePhoneNumber(string) {\n  var result = ''; // Using `.split('')` here instead of normal `for ... of`\n  // because the importing application doesn't neccessarily include an ES6 polyfill.\n  // The `.split('')` approach discards \"exotic\" UTF-8 characters\n  // (the ones consisting of four bytes) but digits\n  // (including non-European ones) don't fall into that range\n  // so such \"exotic\" characters would be discarded anyway.\n\n  for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {\n    var character = _step.value;\n    result += parsePhoneNumberCharacter(character, result) || '';\n  }\n\n  return result;\n}\n/**\r\n * Parses next character while parsing phone number digits (including a `+`)\r\n * from text: discards everything except `+` and digits, and `+` is only allowed\r\n * at the start of a phone number.\r\n * For example, is used in `react-phone-number-input` where it uses\r\n * [`input-format`](https://gitlab.com/catamphetamine/input-format).\r\n * @param  {string} character - Yet another character from raw input string.\r\n * @param  {string?} prevParsedCharacters - Previous parsed characters.\r\n * @param  {object} meta - Optional custom use-case-specific metadata.\r\n * @return {string?} The parsed character.\r\n */\n\nexport function parsePhoneNumberCharacter(character, prevParsedCharacters) {\n  // Only allow a leading `+`.\n  if (character === '+') {\n    // If this `+` is not the first parsed character\n    // then discard it.\n    if (prevParsedCharacters) {\n      return;\n    }\n\n    return '+';\n  } // Allow digits.\n\n\n  return parseDigit(character);\n}\n//# sourceMappingURL=parseIncompletePhoneNumber.js.map","// This is a port of Google Android `libphonenumber`'s\n// `phonenumberutil.js` of December 31th, 2018.\n//\n// https://github.com/googlei18n/libphonenumber/commits/master/javascript/i18n/phonenumbers/phonenumberutil.js\nimport { VALID_DIGITS, PLUS_CHARS, MIN_LENGTH_FOR_NSN, MAX_LENGTH_FOR_NSN } from './constants.js';\nimport ParseError from './ParseError.js';\nimport Metadata from './metadata.js';\nimport isViablePhoneNumber, { isViablePhoneNumberStart } from './helpers/isViablePhoneNumber.js';\nimport extractExtension from './helpers/extension/extractExtension.js';\nimport parseIncompletePhoneNumber from './parseIncompletePhoneNumber.js';\nimport getCountryCallingCode from './getCountryCallingCode.js';\nimport { isPossibleNumber } from './isPossible.js'; // import { parseRFC3966 } from './helpers/RFC3966.js'\n\nimport PhoneNumber from './PhoneNumber.js';\nimport matchesEntirely from './helpers/matchesEntirely.js';\nimport extractCountryCallingCode from './helpers/extractCountryCallingCode.js';\nimport extractNationalNumber from './helpers/extractNationalNumber.js';\nimport stripIddPrefix from './helpers/stripIddPrefix.js';\nimport getCountryByCallingCode from './helpers/getCountryByCallingCode.js';\nimport extractFormattedPhoneNumberFromPossibleRfc3966NumberUri from './helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js'; // We don't allow input strings for parsing to be longer than 250 chars.\n// This prevents malicious input from consuming CPU.\n\nvar MAX_INPUT_STRING_LENGTH = 250; // This consists of the plus symbol, digits, and arabic-indic digits.\n\nvar PHONE_NUMBER_START_PATTERN = new RegExp('[' + PLUS_CHARS + VALID_DIGITS + ']'); // Regular expression of trailing characters that we want to remove.\n// A trailing `#` is sometimes used when writing phone numbers with extensions in US.\n// Example: \"+1 (645) 123 1234-910#\" number has extension \"910\".\n\nvar AFTER_PHONE_NUMBER_END_PATTERN = new RegExp('[^' + VALID_DIGITS + '#' + ']+$');\nvar USE_NON_GEOGRAPHIC_COUNTRY_CODE = false; // Examples:\n//\n// ```js\n// parse('8 (800) 555-35-35', 'RU')\n// parse('8 (800) 555-35-35', 'RU', metadata)\n// parse('8 (800) 555-35-35', { country: { default: 'RU' } })\n// parse('8 (800) 555-35-35', { country: { default: 'RU' } }, metadata)\n// parse('+7 800 555 35 35')\n// parse('+7 800 555 35 35', metadata)\n// ```\n//\n\n/**\r\n * Parses a phone number.\r\n *\r\n * parse('123456789', { defaultCountry: 'RU', v2: true }, metadata)\r\n * parse('123456789', { defaultCountry: 'RU' }, metadata)\r\n * parse('123456789', undefined, metadata)\r\n *\r\n * @param  {string} input\r\n * @param  {object} [options]\r\n * @param  {object} metadata\r\n * @return {object|PhoneNumber?} If `options.v2: true` flag is passed, it returns a `PhoneNumber?` instance. Otherwise, returns an object of shape `{ phone: '...', country: '...' }` (or just `{}` if no phone number was parsed).\r\n */\n\nexport default function parse(text, options, metadata) {\n  // If assigning the `{}` default value is moved to the arguments above,\n  // code coverage would decrease for some weird reason.\n  options = options || {};\n  metadata = new Metadata(metadata); // Validate `defaultCountry`.\n\n  if (options.defaultCountry && !metadata.hasCountry(options.defaultCountry)) {\n    if (options.v2) {\n      throw new ParseError('INVALID_COUNTRY');\n    }\n\n    throw new Error(\"Unknown country: \".concat(options.defaultCountry));\n  } // Parse the phone number.\n\n\n  var _parseInput = parseInput(text, options.v2, options.extract),\n      formattedPhoneNumber = _parseInput.number,\n      ext = _parseInput.ext,\n      error = _parseInput.error; // If the phone number is not viable then return nothing.\n\n\n  if (!formattedPhoneNumber) {\n    if (options.v2) {\n      if (error === 'TOO_SHORT') {\n        throw new ParseError('TOO_SHORT');\n      }\n\n      throw new ParseError('NOT_A_NUMBER');\n    }\n\n    return {};\n  }\n\n  var _parsePhoneNumber = parsePhoneNumber(formattedPhoneNumber, options.defaultCountry, options.defaultCallingCode, metadata),\n      country = _parsePhoneNumber.country,\n      nationalNumber = _parsePhoneNumber.nationalNumber,\n      countryCallingCode = _parsePhoneNumber.countryCallingCode,\n      countryCallingCodeSource = _parsePhoneNumber.countryCallingCodeSource,\n      carrierCode = _parsePhoneNumber.carrierCode;\n\n  if (!metadata.hasSelectedNumberingPlan()) {\n    if (options.v2) {\n      throw new ParseError('INVALID_COUNTRY');\n    }\n\n    return {};\n  } // Validate national (significant) number length.\n\n\n  if (!nationalNumber || nationalNumber.length < MIN_LENGTH_FOR_NSN) {\n    // Won't throw here because the regexp already demands length > 1.\n\n    /* istanbul ignore if */\n    if (options.v2) {\n      throw new ParseError('TOO_SHORT');\n    } // Google's demo just throws an error in this case.\n\n\n    return {};\n  } // Validate national (significant) number length.\n  //\n  // A sidenote:\n  //\n  // They say that sometimes national (significant) numbers\n  // can be longer than `MAX_LENGTH_FOR_NSN` (e.g. in Germany).\n  // https://github.com/googlei18n/libphonenumber/blob/7e1748645552da39c4e1ba731e47969d97bdb539/resources/phonenumber.proto#L36\n  // Such numbers will just be discarded.\n  //\n\n\n  if (nationalNumber.length > MAX_LENGTH_FOR_NSN) {\n    if (options.v2) {\n      throw new ParseError('TOO_LONG');\n    } // Google's demo just throws an error in this case.\n\n\n    return {};\n  }\n\n  if (options.v2) {\n    var phoneNumber = new PhoneNumber(countryCallingCode, nationalNumber, metadata.metadata);\n\n    if (country) {\n      phoneNumber.country = country;\n    }\n\n    if (carrierCode) {\n      phoneNumber.carrierCode = carrierCode;\n    }\n\n    if (ext) {\n      phoneNumber.ext = ext;\n    }\n\n    phoneNumber.__countryCallingCodeSource = countryCallingCodeSource;\n    return phoneNumber;\n  } // Check if national phone number pattern matches the number.\n  // National number pattern is different for each country,\n  // even for those ones which are part of the \"NANPA\" group.\n\n\n  var valid = (options.extended ? metadata.hasSelectedNumberingPlan() : country) ? matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) : false;\n\n  if (!options.extended) {\n    return valid ? result(country, nationalNumber, ext) : {};\n  } // isInternational: countryCallingCode !== undefined\n\n\n  return {\n    country: country,\n    countryCallingCode: countryCallingCode,\n    carrierCode: carrierCode,\n    valid: valid,\n    possible: valid ? true : options.extended === true && metadata.possibleLengths() && isPossibleNumber(nationalNumber, metadata) ? true : false,\n    phone: nationalNumber,\n    ext: ext\n  };\n}\n/**\r\n * Extracts a formatted phone number from text.\r\n * Doesn't guarantee that the extracted phone number\r\n * is a valid phone number (for example, doesn't validate its length).\r\n * @param  {string} text\r\n * @param  {boolean} [extract] — If `false`, then will parse the entire `text` as a phone number.\r\n * @param  {boolean} [throwOnError] — By default, it won't throw if the text is too long.\r\n * @return {string}\r\n * @example\r\n * // Returns \"(213) 373-4253\".\r\n * extractFormattedPhoneNumber(\"Call (213) 373-4253 for assistance.\")\r\n */\n\nfunction _extractFormattedPhoneNumber(text, extract, throwOnError) {\n  if (!text) {\n    return;\n  }\n\n  if (text.length > MAX_INPUT_STRING_LENGTH) {\n    if (throwOnError) {\n      throw new ParseError('TOO_LONG');\n    }\n\n    return;\n  }\n\n  if (extract === false) {\n    return text;\n  } // Attempt to extract a possible number from the string passed in\n\n\n  var startsAt = text.search(PHONE_NUMBER_START_PATTERN);\n\n  if (startsAt < 0) {\n    return;\n  }\n\n  return text // Trim everything to the left of the phone number\n  .slice(startsAt) // Remove trailing non-numerical characters\n  .replace(AFTER_PHONE_NUMBER_END_PATTERN, '');\n}\n/**\r\n * @param  {string} text - Input.\r\n * @param  {boolean} v2 - Legacy API functions don't pass `v2: true` flag.\r\n * @param  {boolean} [extract] - Whether to extract a phone number from `text`, or attempt to parse the entire text as a phone number.\r\n * @return {object} `{ ?number, ?ext }`.\r\n */\n\n\nfunction parseInput(text, v2, extract) {\n  // // Parse RFC 3966 phone number URI.\n  // if (text && text.indexOf('tel:') === 0) {\n  // \treturn parseRFC3966(text)\n  // }\n  // let number = extractFormattedPhoneNumber(text, extract, v2)\n  var number = extractFormattedPhoneNumberFromPossibleRfc3966NumberUri(text, {\n    extractFormattedPhoneNumber: function extractFormattedPhoneNumber(text) {\n      return _extractFormattedPhoneNumber(text, extract, v2);\n    }\n  }); // If the phone number is not viable, then abort.\n\n  if (!number) {\n    return {};\n  }\n\n  if (!isViablePhoneNumber(number)) {\n    if (isViablePhoneNumberStart(number)) {\n      return {\n        error: 'TOO_SHORT'\n      };\n    }\n\n    return {};\n  } // Attempt to parse extension first, since it doesn't require region-specific\n  // data and we want to have the non-normalised number here.\n\n\n  var withExtensionStripped = extractExtension(number);\n\n  if (withExtensionStripped.ext) {\n    return withExtensionStripped;\n  }\n\n  return {\n    number: number\n  };\n}\n/**\r\n * Creates `parse()` result object.\r\n */\n\n\nfunction result(country, nationalNumber, ext) {\n  var result = {\n    country: country,\n    phone: nationalNumber\n  };\n\n  if (ext) {\n    result.ext = ext;\n  }\n\n  return result;\n}\n/**\r\n * Parses a viable phone number.\r\n * @param {string} formattedPhoneNumber — Example: \"(213) 373-4253\".\r\n * @param {string} [defaultCountry]\r\n * @param {string} [defaultCallingCode]\r\n * @param {Metadata} metadata\r\n * @return {object} Returns `{ country: string?, countryCallingCode: string?, nationalNumber: string? }`.\r\n */\n\n\nfunction parsePhoneNumber(formattedPhoneNumber, defaultCountry, defaultCallingCode, metadata) {\n  // Extract calling code from phone number.\n  var _extractCountryCallin = extractCountryCallingCode(parseIncompletePhoneNumber(formattedPhoneNumber), defaultCountry, defaultCallingCode, metadata.metadata),\n      countryCallingCodeSource = _extractCountryCallin.countryCallingCodeSource,\n      countryCallingCode = _extractCountryCallin.countryCallingCode,\n      number = _extractCountryCallin.number; // Choose a country by `countryCallingCode`.\n\n\n  var country;\n\n  if (countryCallingCode) {\n    metadata.selectNumberingPlan(countryCallingCode);\n  } // If `formattedPhoneNumber` is passed in \"national\" format\n  // then `number` is defined and `countryCallingCode` is `undefined`.\n  else if (number && (defaultCountry || defaultCallingCode)) {\n    metadata.selectNumberingPlan(defaultCountry, defaultCallingCode);\n\n    if (defaultCountry) {\n      country = defaultCountry;\n    } else {\n      /* istanbul ignore if */\n      if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n        if (metadata.isNonGeographicCallingCode(defaultCallingCode)) {\n          country = '001';\n        }\n      }\n    }\n\n    countryCallingCode = defaultCallingCode || getCountryCallingCode(defaultCountry, metadata.metadata);\n  } else return {};\n\n  if (!number) {\n    return {\n      countryCallingCodeSource: countryCallingCodeSource,\n      countryCallingCode: countryCallingCode\n    };\n  }\n\n  var _extractNationalNumbe = extractNationalNumber(parseIncompletePhoneNumber(number), metadata),\n      nationalNumber = _extractNationalNumbe.nationalNumber,\n      carrierCode = _extractNationalNumbe.carrierCode; // Sometimes there are several countries\n  // corresponding to the same country phone code\n  // (e.g. NANPA countries all having `1` country phone code).\n  // Therefore, to reliably determine the exact country,\n  // national (significant) number should have been parsed first.\n  //\n  // When `metadata.json` is generated, all \"ambiguous\" country phone codes\n  // get their countries populated with the full set of\n  // \"phone number type\" regular expressions.\n  //\n\n\n  var exactCountry = getCountryByCallingCode(countryCallingCode, {\n    nationalNumber: nationalNumber,\n    defaultCountry: defaultCountry,\n    metadata: metadata\n  });\n\n  if (exactCountry) {\n    country = exactCountry;\n    /* istanbul ignore if */\n\n    if (exactCountry === '001') {// Can't happen with `USE_NON_GEOGRAPHIC_COUNTRY_CODE` being `false`.\n      // If `USE_NON_GEOGRAPHIC_COUNTRY_CODE` is set to `true` for some reason,\n      // then remove the \"istanbul ignore if\".\n    } else {\n      metadata.country(country);\n    }\n  }\n\n  return {\n    country: country,\n    countryCallingCode: countryCallingCode,\n    countryCallingCodeSource: countryCallingCodeSource,\n    nationalNumber: nationalNumber,\n    carrierCode: carrierCode\n  };\n}\n//# sourceMappingURL=parse.js.map"],"names":["_typeof","obj","Symbol","iterator","constructor","prototype","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_defineProperty","key","value","defineProperty","configurable","writable","_arrayLikeToArray","arr","len","length","i","arr2","Array","normalizeArguments","args","text","options","metadata","_Array$prototype$slic2","slice","call","isArray","_arrayWithHoles","_i","_s","_e","_arr","_n","_d","next","done","err","_iterableToArrayLimit","o","minLen","n","toString","name","from","test","_unsupportedIterableToArray","TypeError","_nonIterableRest","arg_1","arg_2","arg_3","arg_4","isObject","Error","concat","undefined","target","arguments","source","forEach","getOwnPropertyDescriptors","defineProperties","_objectSpread","defaultCountry","_","parseIncompletePhoneNumber","string","_step","result","_iterator","allowArrayLike","it","bind","_createForOfIteratorHelperLoose","split","parsePhoneNumberCharacter","character","prevParsedCharacters","MAX_INPUT_STRING_LENGTH","PHONE_NUMBER_START_PATTERN","RegExp","AFTER_PHONE_NUMBER_END_PATTERN","USE_NON_GEOGRAPHIC_COUNTRY_CODE","parse","hasCountry","v2","ParseError","_parseInput","extract","number","extractFormattedPhoneNumberFromPossibleRfc3966NumberUri","extractFormattedPhoneNumber","throwOnError","startsAt","search","replace","_extractFormattedPhoneNumber","isViablePhoneNumber","error","withExtensionStripped","extractExtension","ext","parseInput","formattedPhoneNumber","_parsePhoneNumber","defaultCallingCode","country","_extractCountryCallin","extractCountryCallingCode","countryCallingCodeSource","countryCallingCode","selectNumberingPlan","isNonGeographicCallingCode","_extractNationalNumbe","extractNationalNumber","nationalNumber","carrierCode","exactCountry","getCountryByCallingCode","parsePhoneNumber","hasSelectedNumberingPlan","phoneNumber","PhoneNumber","__countryCallingCodeSource","valid","extended","matchesEntirely","nationalNumberPattern","possible","possibleLengths","isPossible","phone"],"sourceRoot":""}