{"version":3,"file":"vendors/vendors-main-AsYouTypeParser.js.bundle.js","mappings":"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","sources":["webpack://typescript/./node_modules/libphonenumber-js/es6/AsYouTypeParser.js"],"sourcesContent":["function _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\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport _extractCountryCallingCode from './helpers/extractCountryCallingCode.js';\nimport extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js';\nimport extractNationalNumberFromPossiblyIncompleteNumber from './helpers/extractNationalNumberFromPossiblyIncompleteNumber.js';\nimport stripIddPrefix from './helpers/stripIddPrefix.js';\nimport parseDigits from './helpers/parseDigits.js';\nimport { VALID_DIGITS, VALID_PUNCTUATION, PLUS_CHARS } from './constants.js';\nvar VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART = '[' + VALID_PUNCTUATION + VALID_DIGITS + ']+';\nvar VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN = new RegExp('^' + VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART + '$', 'i');\nvar VALID_FORMATTED_PHONE_NUMBER_PART = '(?:' + '[' + PLUS_CHARS + ']' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']*' + '|' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']+' + ')';\nvar AFTER_PHONE_NUMBER_DIGITS_END_PATTERN = new RegExp('[^' + VALID_PUNCTUATION + VALID_DIGITS + ']+' + '.*' + '$'); // Tests whether `national_prefix_for_parsing` could match\n// different national prefixes.\n// Matches anything that's not a digit or a square bracket.\n\nvar COMPLEX_NATIONAL_PREFIX = /[^\\d\\[\\]]/;\n\nvar AsYouTypeParser = /*#__PURE__*/function () {\n  function AsYouTypeParser(_ref) {\n    var defaultCountry = _ref.defaultCountry,\n        defaultCallingCode = _ref.defaultCallingCode,\n        metadata = _ref.metadata,\n        onNationalSignificantNumberChange = _ref.onNationalSignificantNumberChange;\n\n    _classCallCheck(this, AsYouTypeParser);\n\n    this.defaultCountry = defaultCountry;\n    this.defaultCallingCode = defaultCallingCode;\n    this.metadata = metadata;\n    this.onNationalSignificantNumberChange = onNationalSignificantNumberChange;\n  }\n\n  _createClass(AsYouTypeParser, [{\n    key: \"input\",\n    value: function input(text, state) {\n      var _extractFormattedDigi = extractFormattedDigitsAndPlus(text),\n          _extractFormattedDigi2 = _slicedToArray(_extractFormattedDigi, 2),\n          formattedDigits = _extractFormattedDigi2[0],\n          hasPlus = _extractFormattedDigi2[1];\n\n      var digits = parseDigits(formattedDigits); // Checks for a special case: just a leading `+` has been entered.\n\n      var justLeadingPlus;\n\n      if (hasPlus) {\n        if (!state.digits) {\n          state.startInternationalNumber();\n\n          if (!digits) {\n            justLeadingPlus = true;\n          }\n        }\n      }\n\n      if (digits) {\n        this.inputDigits(digits, state);\n      }\n\n      return {\n        digits: digits,\n        justLeadingPlus: justLeadingPlus\n      };\n    }\n    /**\r\n     * Inputs \"next\" phone number digits.\r\n     * @param  {string} digits\r\n     * @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     */\n\n  }, {\n    key: \"inputDigits\",\n    value: function inputDigits(nextDigits, state) {\n      var digits = state.digits;\n      var hasReceivedThreeLeadingDigits = digits.length < 3 && digits.length + nextDigits.length >= 3; // Append phone number digits.\n\n      state.appendDigits(nextDigits); // Attempt to extract IDD prefix:\n      // Some users input their phone number in international format,\n      // but in an \"out-of-country\" dialing format instead of using the leading `+`.\n      // https://github.com/catamphetamine/libphonenumber-js/issues/185\n      // Detect such numbers as soon as there're at least 3 digits.\n      // Google's library attempts to extract IDD prefix at 3 digits,\n      // so this library just copies that behavior.\n      // I guess that's because the most commot IDD prefixes are\n      // `00` (Europe) and `011` (US).\n      // There exist really long IDD prefixes too:\n      // for example, in Australia the default IDD prefix is `0011`,\n      // and it could even be as long as `14880011`.\n      // An IDD prefix is extracted here, and then every time when\n      // there's a new digit and the number couldn't be formatted.\n\n      if (hasReceivedThreeLeadingDigits) {\n        this.extractIddPrefix(state);\n      }\n\n      if (this.isWaitingForCountryCallingCode(state)) {\n        if (!this.extractCountryCallingCode(state)) {\n          return;\n        }\n      } else {\n        state.appendNationalSignificantNumberDigits(nextDigits);\n      } // If a phone number is being input in international format,\n      // then it's not valid for it to have a national prefix.\n      // Still, some people incorrectly input such numbers with a national prefix.\n      // In such cases, only attempt to strip a national prefix if the number becomes too long.\n      // (but that is done later, not here)\n\n\n      if (!state.international) {\n        if (!this.hasExtractedNationalSignificantNumber) {\n          this.extractNationalSignificantNumber(state.getNationalDigits(), function (stateUpdate) {\n            return state.update(stateUpdate);\n          });\n        }\n      }\n    }\n  }, {\n    key: \"isWaitingForCountryCallingCode\",\n    value: function isWaitingForCountryCallingCode(_ref2) {\n      var international = _ref2.international,\n          callingCode = _ref2.callingCode;\n      return international && !callingCode;\n    } // Extracts a country calling code from a number\n    // being entered in internatonal format.\n\n  }, {\n    key: \"extractCountryCallingCode\",\n    value: function extractCountryCallingCode(state) {\n      var _extractCountryCallin = _extractCountryCallingCode('+' + state.getDigitsWithoutInternationalPrefix(), this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),\n          countryCallingCode = _extractCountryCallin.countryCallingCode,\n          number = _extractCountryCallin.number;\n\n      if (countryCallingCode) {\n        state.setCallingCode(countryCallingCode);\n        state.update({\n          nationalSignificantNumber: number\n        });\n        return true;\n      }\n    }\n  }, {\n    key: \"reset\",\n    value: function reset(numberingPlan) {\n      if (numberingPlan) {\n        this.hasSelectedNumberingPlan = true;\n\n        var nationalPrefixForParsing = numberingPlan._nationalPrefixForParsing();\n\n        this.couldPossiblyExtractAnotherNationalSignificantNumber = nationalPrefixForParsing && COMPLEX_NATIONAL_PREFIX.test(nationalPrefixForParsing);\n      } else {\n        this.hasSelectedNumberingPlan = undefined;\n        this.couldPossiblyExtractAnotherNationalSignificantNumber = undefined;\n      }\n    }\n    /**\r\n     * Extracts a national (significant) number from user input.\r\n     * Google's library is different in that it only applies `national_prefix_for_parsing`\r\n     * and doesn't apply `national_prefix_transform_rule` after that.\r\n     * https://github.com/google/libphonenumber/blob/a3d70b0487875475e6ad659af404943211d26456/java/libphonenumber/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java#L539\r\n     * @return {boolean} [extracted]\r\n     */\n\n  }, {\n    key: \"extractNationalSignificantNumber\",\n    value: function extractNationalSignificantNumber(nationalDigits, setState) {\n      if (!this.hasSelectedNumberingPlan) {\n        return;\n      }\n\n      var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(nationalDigits, this.metadata),\n          nationalPrefix = _extractNationalNumbe.nationalPrefix,\n          nationalNumber = _extractNationalNumbe.nationalNumber,\n          carrierCode = _extractNationalNumbe.carrierCode;\n\n      if (nationalNumber === nationalDigits) {\n        return;\n      }\n\n      this.onExtractedNationalNumber(nationalPrefix, carrierCode, nationalNumber, nationalDigits, setState);\n      return true;\n    }\n    /**\r\n     * In Google's code this function is called \"attempt to extract longer NDD\".\r\n     * \"Some national prefixes are a substring of others\", they say.\r\n     * @return {boolean} [result] — Returns `true` if extracting a national prefix produced different results from what they were.\r\n     */\n\n  }, {\n    key: \"extractAnotherNationalSignificantNumber\",\n    value: function extractAnotherNationalSignificantNumber(nationalDigits, prevNationalSignificantNumber, setState) {\n      if (!this.hasExtractedNationalSignificantNumber) {\n        return this.extractNationalSignificantNumber(nationalDigits, setState);\n      }\n\n      if (!this.couldPossiblyExtractAnotherNationalSignificantNumber) {\n        return;\n      }\n\n      var _extractNationalNumbe2 = extractNationalNumberFromPossiblyIncompleteNumber(nationalDigits, this.metadata),\n          nationalPrefix = _extractNationalNumbe2.nationalPrefix,\n          nationalNumber = _extractNationalNumbe2.nationalNumber,\n          carrierCode = _extractNationalNumbe2.carrierCode; // If a national prefix has been extracted previously,\n      // then it's always extracted as additional digits are added.\n      // That's assuming `extractNationalNumberFromPossiblyIncompleteNumber()`\n      // doesn't do anything different from what it currently does.\n      // So, just in case, here's this check, though it doesn't occur.\n\n      /* istanbul ignore if */\n\n\n      if (nationalNumber === prevNationalSignificantNumber) {\n        return;\n      }\n\n      this.onExtractedNationalNumber(nationalPrefix, carrierCode, nationalNumber, nationalDigits, setState);\n      return true;\n    }\n  }, {\n    key: \"onExtractedNationalNumber\",\n    value: function onExtractedNationalNumber(nationalPrefix, carrierCode, nationalSignificantNumber, nationalDigits, setState) {\n      var complexPrefixBeforeNationalSignificantNumber;\n      var nationalSignificantNumberMatchesInput; // This check also works with empty `this.nationalSignificantNumber`.\n\n      var nationalSignificantNumberIndex = nationalDigits.lastIndexOf(nationalSignificantNumber); // If the extracted national (significant) number is the\n      // last substring of the `digits`, then it means that it hasn't been altered:\n      // no digits have been removed from the national (significant) number\n      // while applying `national_prefix_transform_rule`.\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\n\n      if (nationalSignificantNumberIndex >= 0 && nationalSignificantNumberIndex === nationalDigits.length - nationalSignificantNumber.length) {\n        nationalSignificantNumberMatchesInput = true; // If a prefix of a national (significant) number is not as simple\n        // as just a basic national prefix, then such prefix is stored in\n        // `this.complexPrefixBeforeNationalSignificantNumber` property and will be\n        // prepended \"as is\" to the national (significant) number to produce\n        // a formatted result.\n\n        var prefixBeforeNationalNumber = nationalDigits.slice(0, nationalSignificantNumberIndex); // `prefixBeforeNationalNumber` is always non-empty,\n        // because `onExtractedNationalNumber()` isn't called\n        // when a national (significant) number hasn't been actually \"extracted\":\n        // when a national (significant) number is equal to the national part of `digits`,\n        // then `onExtractedNationalNumber()` doesn't get called.\n\n        if (prefixBeforeNationalNumber !== nationalPrefix) {\n          complexPrefixBeforeNationalSignificantNumber = prefixBeforeNationalNumber;\n        }\n      }\n\n      setState({\n        nationalPrefix: nationalPrefix,\n        carrierCode: carrierCode,\n        nationalSignificantNumber: nationalSignificantNumber,\n        nationalSignificantNumberMatchesInput: nationalSignificantNumberMatchesInput,\n        complexPrefixBeforeNationalSignificantNumber: complexPrefixBeforeNationalSignificantNumber\n      }); // `onExtractedNationalNumber()` is only called when\n      // the national (significant) number actually did change.\n\n      this.hasExtractedNationalSignificantNumber = true;\n      this.onNationalSignificantNumberChange();\n    }\n  }, {\n    key: \"reExtractNationalSignificantNumber\",\n    value: function reExtractNationalSignificantNumber(state) {\n      // Attempt to extract a national prefix.\n      //\n      // Some people incorrectly input national prefix\n      // in an international phone number.\n      // For example, some people write British phone numbers as `+44(0)...`.\n      //\n      // Also, in some rare cases, it is valid for a national prefix\n      // to be a part of an international phone number.\n      // For example, mobile phone numbers in Mexico are supposed to be\n      // dialled internationally using a `1` national prefix,\n      // so the national prefix will be part of an international number.\n      //\n      // Quote from:\n      // https://www.mexperience.com/dialing-cell-phones-in-mexico/\n      //\n      // \"Dialing a Mexican cell phone from abroad\n      // When you are calling a cell phone number in Mexico from outside Mexico,\n      // it’s necessary to dial an additional “1” after Mexico’s country code\n      // (which is “52”) and before the area code.\n      // You also ignore the 045, and simply dial the area code and the\n      // cell phone’s number.\n      //\n      // If you don’t add the “1”, you’ll receive a recorded announcement\n      // asking you to redial using it.\n      //\n      // For example, if you are calling from the USA to a cell phone\n      // in Mexico City, you would dial +52 – 1 – 55 – 1234 5678.\n      // (Note that this is different to calling a land line in Mexico City\n      // from abroad, where the number dialed would be +52 – 55 – 1234 5678)\".\n      //\n      // Google's demo output:\n      // https://libphonenumber.appspot.com/phonenumberparser?number=%2b5215512345678&country=MX\n      //\n      if (this.extractAnotherNationalSignificantNumber(state.getNationalDigits(), state.nationalSignificantNumber, function (stateUpdate) {\n        return state.update(stateUpdate);\n      })) {\n        return true;\n      } // If no format matches the phone number, then it could be\n      // \"a really long IDD\" (quote from a comment in Google's library).\n      // An IDD prefix is first extracted when the user has entered at least 3 digits,\n      // and then here — every time when there's a new digit and the number\n      // couldn't be formatted.\n      // For example, in Australia the default IDD prefix is `0011`,\n      // and it could even be as long as `14880011`.\n      //\n      // Could also check `!hasReceivedThreeLeadingDigits` here\n      // to filter out the case when this check duplicates the one\n      // already performed when there're 3 leading digits,\n      // but it's not a big deal, and in most cases there\n      // will be a suitable `format` when there're 3 leading digits.\n      //\n\n\n      if (this.extractIddPrefix(state)) {\n        this.extractCallingCodeAndNationalSignificantNumber(state);\n        return true;\n      } // Google's AsYouType formatter supports sort of an \"autocorrection\" feature\n      // when it \"autocorrects\" numbers that have been input for a country\n      // with that country's calling code.\n      // Such \"autocorrection\" feature looks weird, but different people have been requesting it:\n      // https://github.com/catamphetamine/libphonenumber-js/issues/376\n      // https://github.com/catamphetamine/libphonenumber-js/issues/375\n      // https://github.com/catamphetamine/libphonenumber-js/issues/316\n\n\n      if (this.fixMissingPlus(state)) {\n        this.extractCallingCodeAndNationalSignificantNumber(state);\n        return true;\n      }\n    }\n  }, {\n    key: \"extractIddPrefix\",\n    value: function extractIddPrefix(state) {\n      // An IDD prefix can't be present in a number written with a `+`.\n      // Also, don't re-extract an IDD prefix if has already been extracted.\n      var international = state.international,\n          IDDPrefix = state.IDDPrefix,\n          digits = state.digits,\n          nationalSignificantNumber = state.nationalSignificantNumber;\n\n      if (international || IDDPrefix) {\n        return;\n      } // Some users input their phone number in \"out-of-country\"\n      // dialing format instead of using the leading `+`.\n      // https://github.com/catamphetamine/libphonenumber-js/issues/185\n      // Detect such numbers.\n\n\n      var numberWithoutIDD = stripIddPrefix(digits, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata);\n\n      if (numberWithoutIDD !== undefined && numberWithoutIDD !== digits) {\n        // If an IDD prefix was stripped then convert the IDD-prefixed number\n        // to international number for subsequent parsing.\n        state.update({\n          IDDPrefix: digits.slice(0, digits.length - numberWithoutIDD.length)\n        });\n        this.startInternationalNumber(state, {\n          country: undefined,\n          callingCode: undefined\n        });\n        return true;\n      }\n    }\n  }, {\n    key: \"fixMissingPlus\",\n    value: function fixMissingPlus(state) {\n      if (!state.international) {\n        var _extractCountryCallin2 = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(state.digits, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),\n            newCallingCode = _extractCountryCallin2.countryCallingCode,\n            number = _extractCountryCallin2.number;\n\n        if (newCallingCode) {\n          state.update({\n            missingPlus: true\n          });\n          this.startInternationalNumber(state, {\n            country: state.country,\n            callingCode: newCallingCode\n          });\n          return true;\n        }\n      }\n    }\n  }, {\n    key: \"startInternationalNumber\",\n    value: function startInternationalNumber(state, _ref3) {\n      var country = _ref3.country,\n          callingCode = _ref3.callingCode;\n      state.startInternationalNumber(country, callingCode); // If a national (significant) number has been extracted before, reset it.\n\n      if (state.nationalSignificantNumber) {\n        state.resetNationalSignificantNumber();\n        this.onNationalSignificantNumberChange();\n        this.hasExtractedNationalSignificantNumber = undefined;\n      }\n    }\n  }, {\n    key: \"extractCallingCodeAndNationalSignificantNumber\",\n    value: function extractCallingCodeAndNationalSignificantNumber(state) {\n      if (this.extractCountryCallingCode(state)) {\n        // `this.extractCallingCode()` is currently called when the number\n        // couldn't be formatted during the standard procedure.\n        // Normally, the national prefix would be re-extracted\n        // for an international number if such number couldn't be formatted,\n        // but since it's already not able to be formatted,\n        // there won't be yet another retry, so also extract national prefix here.\n        this.extractNationalSignificantNumber(state.getNationalDigits(), function (stateUpdate) {\n          return state.update(stateUpdate);\n        });\n      }\n    }\n  }]);\n\n  return AsYouTypeParser;\n}();\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 */\n\n\nexport { AsYouTypeParser as default };\n\nfunction extractFormattedPhoneNumber(text) {\n  // Attempt to extract a possible number from the string passed in.\n  var startsAt = text.search(VALID_FORMATTED_PHONE_NUMBER_PART);\n\n  if (startsAt < 0) {\n    return;\n  } // Trim everything to the left of the phone number.\n\n\n  text = text.slice(startsAt); // Trim the `+`.\n\n  var hasPlus;\n\n  if (text[0] === '+') {\n    hasPlus = true;\n    text = text.slice('+'.length);\n  } // Trim everything to the right of the phone number.\n\n\n  text = text.replace(AFTER_PHONE_NUMBER_DIGITS_END_PATTERN, ''); // Re-add the previously trimmed `+`.\n\n  if (hasPlus) {\n    text = '+' + text;\n  }\n\n  return text;\n}\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 */\n\n\nfunction _extractFormattedDigitsAndPlus(text) {\n  // Extract a formatted phone number part from text.\n  var extractedNumber = extractFormattedPhoneNumber(text) || ''; // Trim a `+`.\n\n  if (extractedNumber[0] === '+') {\n    return [extractedNumber.slice('+'.length), true];\n  }\n\n  return [extractedNumber];\n}\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 */\n\n\nexport function extractFormattedDigitsAndPlus(text) {\n  var _extractFormattedDigi3 = _extractFormattedDigitsAndPlus(text),\n      _extractFormattedDigi4 = _slicedToArray(_extractFormattedDigi3, 2),\n      formattedDigits = _extractFormattedDigi4[0],\n      hasPlus = _extractFormattedDigi4[1]; // If the extracted phone number part\n  // can possibly be a part of some valid phone number\n  // then parse phone number characters from a formatted phone number.\n\n\n  if (!VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN.test(formattedDigits)) {\n    formattedDigits = '';\n  }\n\n  return [formattedDigits, hasPlus];\n}\n//# sourceMappingURL=AsYouTypeParser.js.map"],"names":["_slicedToArray","arr","i","Array","isArray","_arrayWithHoles","_i","Symbol","iterator","_s","_e","_arr","_n","_d","call","next","done","push","value","length","err","_iterableToArrayLimit","o","minLen","_arrayLikeToArray","n","Object","prototype","toString","slice","constructor","name","from","test","_unsupportedIterableToArray","TypeError","_nonIterableRest","len","arr2","_defineProperties","target","props","descriptor","enumerable","configurable","writable","defineProperty","key","VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART","VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN","RegExp","VALID_FORMATTED_PHONE_NUMBER_PART","AFTER_PHONE_NUMBER_DIGITS_END_PATTERN","COMPLEX_NATIONAL_PREFIX","AsYouTypeParser","_ref","defaultCountry","defaultCallingCode","metadata","onNationalSignificantNumberChange","instance","Constructor","_classCallCheck","this","protoProps","text","state","justLeadingPlus","_extractFormattedDigi","_extractFormattedDigi3","extractedNumber","hasPlus","startsAt","search","replace","extractFormattedPhoneNumber","_extractFormattedDigitsAndPlus","_extractFormattedDigi4","formattedDigits","extractFormattedDigitsAndPlus","_extractFormattedDigi2","digits","startInternationalNumber","inputDigits","nextDigits","hasReceivedThreeLeadingDigits","appendDigits","extractIddPrefix","isWaitingForCountryCallingCode","extractCountryCallingCode","appendNationalSignificantNumberDigits","international","hasExtractedNationalSignificantNumber","extractNationalSignificantNumber","getNationalDigits","stateUpdate","update","_ref2","callingCode","_extractCountryCallin","getDigitsWithoutInternationalPrefix","countryCallingCode","number","setCallingCode","nationalSignificantNumber","numberingPlan","hasSelectedNumberingPlan","nationalPrefixForParsing","_nationalPrefixForParsing","couldPossiblyExtractAnotherNationalSignificantNumber","undefined","nationalDigits","setState","_extractNationalNumbe","nationalPrefix","nationalNumber","carrierCode","onExtractedNationalNumber","prevNationalSignificantNumber","_extractNationalNumbe2","complexPrefixBeforeNationalSignificantNumber","nationalSignificantNumberMatchesInput","nationalSignificantNumberIndex","lastIndexOf","prefixBeforeNationalNumber","extractAnotherNationalSignificantNumber","fixMissingPlus","extractCallingCodeAndNationalSignificantNumber","IDDPrefix","numberWithoutIDD","country","_extractCountryCallin2","newCallingCode","missingPlus","_ref3","resetNationalSignificantNumber"],"sourceRoot":""}