{"version":3,"file":"vendors-56c11dbb.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/libphonenumber-js/es6/AsYouTypeState.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/AsYouTypeFormatter.util.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/AsYouTypeFormatter.complete.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/AsYouTypeFormatter.PatternParser.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/AsYouTypeFormatter.PatternMatcher.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/AsYouTypeFormatter.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/AsYouTypeParser.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/AsYouType.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/ParseError.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/PhoneNumber.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/constants.js","webpack://iadviser/./node_modules/libphonenumber-js/es6/format.js"],"sourcesContent":["function _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\n// This \"state\" object simply holds the state of the \"AsYouType\" parser:\n//\n// * `country?: string`\n// * `callingCode?: string`\n// * `digits: string`\n// * `international: boolean`\n// * `missingPlus: boolean`\n// * `IDDPrefix?: string`\n// * `carrierCode?: string`\n// * `nationalPrefix?: string`\n// * `nationalSignificantNumber?: string`\n// * `nationalSignificantNumberMatchesInput: boolean`\n// * `complexPrefixBeforeNationalSignificantNumber?: string`\n//\n// `state.country` and `state.callingCode` aren't required to be in sync.\n// For example, `state.country` could be `\"AR\"` and `state.callingCode` could be `undefined`.\n// So `state.country` and `state.callingCode` are totally independent.\n//\nvar AsYouTypeState = /*#__PURE__*/function () {\n  function AsYouTypeState(_ref) {\n    var onCountryChange = _ref.onCountryChange,\n        onCallingCodeChange = _ref.onCallingCodeChange;\n\n    _classCallCheck(this, AsYouTypeState);\n\n    this.onCountryChange = onCountryChange;\n    this.onCallingCodeChange = onCallingCodeChange;\n  }\n\n  _createClass(AsYouTypeState, [{\n    key: \"reset\",\n    value: function reset(_ref2) {\n      var country = _ref2.country,\n          callingCode = _ref2.callingCode;\n      this.international = false;\n      this.missingPlus = false;\n      this.IDDPrefix = undefined;\n      this.callingCode = undefined;\n      this.digits = '';\n      this.resetNationalSignificantNumber();\n      this.initCountryAndCallingCode(country, callingCode);\n    }\n  }, {\n    key: \"resetNationalSignificantNumber\",\n    value: function resetNationalSignificantNumber() {\n      this.nationalSignificantNumber = this.getNationalDigits();\n      this.nationalSignificantNumberMatchesInput = true;\n      this.nationalPrefix = undefined;\n      this.carrierCode = undefined;\n      this.complexPrefixBeforeNationalSignificantNumber = undefined;\n    }\n  }, {\n    key: \"update\",\n    value: function update(properties) {\n      for (var _i = 0, _Object$keys = Object.keys(properties); _i < _Object$keys.length; _i++) {\n        var key = _Object$keys[_i];\n        this[key] = properties[key];\n      }\n    }\n  }, {\n    key: \"initCountryAndCallingCode\",\n    value: function initCountryAndCallingCode(country, callingCode) {\n      this.setCountry(country);\n      this.setCallingCode(callingCode);\n    }\n  }, {\n    key: \"setCountry\",\n    value: function setCountry(country) {\n      this.country = country;\n      this.onCountryChange(country);\n    }\n  }, {\n    key: \"setCallingCode\",\n    value: function setCallingCode(callingCode) {\n      this.callingCode = callingCode;\n      this.onCallingCodeChange(callingCode, this.country);\n    }\n  }, {\n    key: \"startInternationalNumber\",\n    value: function startInternationalNumber(country, callingCode) {\n      // Prepend the `+` to parsed input.\n      this.international = true; // If a default country was set then reset it\n      // because an explicitly international phone\n      // number is being entered.\n\n      this.initCountryAndCallingCode(country, callingCode);\n    }\n  }, {\n    key: \"appendDigits\",\n    value: function appendDigits(nextDigits) {\n      this.digits += nextDigits;\n    }\n  }, {\n    key: \"appendNationalSignificantNumberDigits\",\n    value: function appendNationalSignificantNumberDigits(nextDigits) {\n      this.nationalSignificantNumber += nextDigits;\n    }\n    /**\r\n     * Returns the part of `this.digits` that corresponds to the national number.\r\n     * Basically, all digits that have been input by the user, except for the\r\n     * international prefix and the country calling code part\r\n     * (if the number is an international one).\r\n     * @return {string}\r\n     */\n\n  }, {\n    key: \"getNationalDigits\",\n    value: function getNationalDigits() {\n      if (this.international) {\n        return this.digits.slice((this.IDDPrefix ? this.IDDPrefix.length : 0) + (this.callingCode ? this.callingCode.length : 0));\n      }\n\n      return this.digits;\n    }\n  }, {\n    key: \"getDigitsWithoutInternationalPrefix\",\n    value: function getDigitsWithoutInternationalPrefix() {\n      if (this.international) {\n        if (this.IDDPrefix) {\n          return this.digits.slice(this.IDDPrefix.length);\n        }\n      }\n\n      return this.digits;\n    }\n  }]);\n\n  return AsYouTypeState;\n}();\n\nexport { AsYouTypeState as default };\n//# sourceMappingURL=AsYouTypeState.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\n// Should be the same as `DIGIT_PLACEHOLDER` in `libphonenumber-metadata-generator`.\nexport var DIGIT_PLACEHOLDER = 'x'; // '\\u2008' (punctuation space)\n\nvar DIGIT_PLACEHOLDER_MATCHER = new RegExp(DIGIT_PLACEHOLDER); // Counts all occurences of a symbol in a string.\n// Unicode-unsafe (because using `.split()`).\n\nexport function countOccurences(symbol, string) {\n  var count = 0; // Using `.split('')` to iterate through a string here\n  // to avoid requiring `Symbol.iterator` polyfill.\n  // `.split('')` is generally not safe for Unicode,\n  // but in this particular case for counting brackets it is safe.\n  // for (const character of string)\n\n  for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {\n    var character = _step.value;\n\n    if (character === symbol) {\n      count++;\n    }\n  }\n\n  return count;\n} // Repeats a string (or a symbol) N times.\n// http://stackoverflow.com/questions/202605/repeat-string-javascript\n\nexport function repeat(string, times) {\n  if (times < 1) {\n    return '';\n  }\n\n  var result = '';\n\n  while (times > 1) {\n    if (times & 1) {\n      result += string;\n    }\n\n    times >>= 1;\n    string += string;\n  }\n\n  return result + string;\n}\nexport function cutAndStripNonPairedParens(string, cutBeforeIndex) {\n  if (string[cutBeforeIndex] === ')') {\n    cutBeforeIndex++;\n  }\n\n  return stripNonPairedParens(string.slice(0, cutBeforeIndex));\n}\nexport function closeNonPairedParens(template, cut_before) {\n  var retained_template = template.slice(0, cut_before);\n  var opening_braces = countOccurences('(', retained_template);\n  var closing_braces = countOccurences(')', retained_template);\n  var dangling_braces = opening_braces - closing_braces;\n\n  while (dangling_braces > 0 && cut_before < template.length) {\n    if (template[cut_before] === ')') {\n      dangling_braces--;\n    }\n\n    cut_before++;\n  }\n\n  return template.slice(0, cut_before);\n}\nexport function stripNonPairedParens(string) {\n  var dangling_braces = [];\n  var i = 0;\n\n  while (i < string.length) {\n    if (string[i] === '(') {\n      dangling_braces.push(i);\n    } else if (string[i] === ')') {\n      dangling_braces.pop();\n    }\n\n    i++;\n  }\n\n  var start = 0;\n  var cleared_string = '';\n  dangling_braces.push(string.length);\n\n  for (var _i = 0, _dangling_braces = dangling_braces; _i < _dangling_braces.length; _i++) {\n    var index = _dangling_braces[_i];\n    cleared_string += string.slice(start, index);\n    start = index + 1;\n  }\n\n  return cleared_string;\n}\nexport function populateTemplateWithDigits(template, position, digits) {\n  // Using `.split('')` to iterate through a string here\n  // to avoid requiring `Symbol.iterator` polyfill.\n  // `.split('')` is generally not safe for Unicode,\n  // but in this particular case for `digits` it is safe.\n  // for (const digit of digits)\n  for (var _iterator2 = _createForOfIteratorHelperLoose(digits.split('')), _step2; !(_step2 = _iterator2()).done;) {\n    var digit = _step2.value;\n\n    // If there is room for more digits in current `template`,\n    // then set the next digit in the `template`,\n    // and return the formatted digits so far.\n    // If more digits are entered than the current format could handle.\n    if (template.slice(position + 1).search(DIGIT_PLACEHOLDER_MATCHER) < 0) {\n      return;\n    }\n\n    position = template.search(DIGIT_PLACEHOLDER_MATCHER);\n    template = template.replace(DIGIT_PLACEHOLDER_MATCHER, digit);\n  }\n\n  return [template, position];\n}\n//# sourceMappingURL=AsYouTypeFormatter.util.js.map","import checkNumberLength from './helpers/checkNumberLength.js';\nimport parseDigits from './helpers/parseDigits.js';\nimport formatNationalNumberUsingFormat from './helpers/formatNationalNumberUsingFormat.js';\nexport default function formatCompleteNumber(state, format, _ref) {\n  var metadata = _ref.metadata,\n      shouldTryNationalPrefixFormattingRule = _ref.shouldTryNationalPrefixFormattingRule,\n      getSeparatorAfterNationalPrefix = _ref.getSeparatorAfterNationalPrefix;\n  var matcher = new RegExp(\"^(?:\".concat(format.pattern(), \")$\"));\n\n  if (matcher.test(state.nationalSignificantNumber)) {\n    return formatNationalNumberWithAndWithoutNationalPrefixFormattingRule(state, format, {\n      metadata: metadata,\n      shouldTryNationalPrefixFormattingRule: shouldTryNationalPrefixFormattingRule,\n      getSeparatorAfterNationalPrefix: getSeparatorAfterNationalPrefix\n    });\n  }\n}\nexport function canFormatCompleteNumber(nationalSignificantNumber, metadata) {\n  return checkNumberLength(nationalSignificantNumber, metadata) === 'IS_POSSIBLE';\n}\n\nfunction formatNationalNumberWithAndWithoutNationalPrefixFormattingRule(state, format, _ref2) {\n  var metadata = _ref2.metadata,\n      shouldTryNationalPrefixFormattingRule = _ref2.shouldTryNationalPrefixFormattingRule,\n      getSeparatorAfterNationalPrefix = _ref2.getSeparatorAfterNationalPrefix;\n  // `format` has already been checked for `nationalPrefix` requirement.\n  var nationalSignificantNumber = state.nationalSignificantNumber,\n      international = state.international,\n      nationalPrefix = state.nationalPrefix,\n      carrierCode = state.carrierCode; // Format the number with using `national_prefix_formatting_rule`.\n  // If the resulting formatted number is a valid formatted number, then return it.\n  //\n  // Google's AsYouType formatter is different in a way that it doesn't try\n  // to format using the \"national prefix formatting rule\", and instead it\n  // simply prepends a national prefix followed by a \" \" character.\n  // This code does that too, but as a fallback.\n  // The reason is that \"national prefix formatting rule\" may use parentheses,\n  // which wouldn't be included has it used the simpler Google's way.\n  //\n\n  if (shouldTryNationalPrefixFormattingRule(format)) {\n    var formattedNumber = formatNationalNumber(state, format, {\n      useNationalPrefixFormattingRule: true,\n      getSeparatorAfterNationalPrefix: getSeparatorAfterNationalPrefix,\n      metadata: metadata\n    });\n\n    if (formattedNumber) {\n      return formattedNumber;\n    }\n  } // Format the number without using `national_prefix_formatting_rule`.\n\n\n  return formatNationalNumber(state, format, {\n    useNationalPrefixFormattingRule: false,\n    getSeparatorAfterNationalPrefix: getSeparatorAfterNationalPrefix,\n    metadata: metadata\n  });\n}\n\nfunction formatNationalNumber(state, format, _ref3) {\n  var metadata = _ref3.metadata,\n      useNationalPrefixFormattingRule = _ref3.useNationalPrefixFormattingRule,\n      getSeparatorAfterNationalPrefix = _ref3.getSeparatorAfterNationalPrefix;\n  var formattedNationalNumber = formatNationalNumberUsingFormat(state.nationalSignificantNumber, format, {\n    carrierCode: state.carrierCode,\n    useInternationalFormat: state.international,\n    withNationalPrefix: useNationalPrefixFormattingRule,\n    metadata: metadata\n  });\n\n  if (!useNationalPrefixFormattingRule) {\n    if (state.nationalPrefix) {\n      // If a national prefix was extracted, then just prepend it,\n      // followed by a \" \" character.\n      formattedNationalNumber = state.nationalPrefix + getSeparatorAfterNationalPrefix(format) + formattedNationalNumber;\n    } else if (state.complexPrefixBeforeNationalSignificantNumber) {\n      formattedNationalNumber = state.complexPrefixBeforeNationalSignificantNumber + ' ' + formattedNationalNumber;\n    }\n  }\n\n  if (isValidFormattedNationalNumber(formattedNationalNumber, state)) {\n    return formattedNationalNumber;\n  }\n} // Check that the formatted phone number contains exactly\n// the same digits that have been input by the user.\n// For example, when \"0111523456789\" is input for `AR` country,\n// the extracted `this.nationalSignificantNumber` is \"91123456789\",\n// which means that the national part of `this.digits` isn't simply equal to\n// `this.nationalPrefix` + `this.nationalSignificantNumber`.\n//\n// Also, a `format` can add extra digits to the `this.nationalSignificantNumber`\n// being formatted via `metadata[country].national_prefix_transform_rule`.\n// For example, for `VI` country, it prepends `340` to the national number,\n// and if this check hasn't been implemented, then there would be a bug\n// when `340` \"area coude\" is \"duplicated\" during input for `VI` country:\n// https://github.com/catamphetamine/libphonenumber-js/issues/318\n//\n// So, all these \"gotchas\" are filtered out.\n//\n// In the original Google's code, the comments say:\n// \"Check that we didn't remove nor add any extra digits when we matched\n// this formatting pattern. This usually happens after we entered the last\n// digit during AYTF. Eg: In case of MX, we swallow mobile token (1) when\n// formatted but AYTF should retain all the number entered and not change\n// in order to match a format (of same leading digits and length) display\n// in that way.\"\n// \"If it's the same (i.e entered number and format is same), then it's\n// safe to return this in formatted number as nothing is lost / added.\"\n// Otherwise, don't use this format.\n// https://github.com/google/libphonenumber/commit/3e7c1f04f5e7200f87fb131e6f85c6e99d60f510#diff-9149457fa9f5d608a11bb975c6ef4bc5\n// https://github.com/google/libphonenumber/commit/3ac88c7106e7dcb553bcc794b15f19185928a1c6#diff-2dcb77e833422ee304da348b905cde0b\n//\n\n\nfunction isValidFormattedNationalNumber(formattedNationalNumber, state) {\n  return parseDigits(formattedNationalNumber) === state.getNationalDigits();\n}\n//# sourceMappingURL=AsYouTypeFormatter.complete.js.map","function _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\nvar PatternParser = /*#__PURE__*/function () {\n  function PatternParser() {\n    _classCallCheck(this, PatternParser);\n  }\n\n  _createClass(PatternParser, [{\n    key: \"parse\",\n    value: function parse(pattern) {\n      this.context = [{\n        or: true,\n        instructions: []\n      }];\n      this.parsePattern(pattern);\n\n      if (this.context.length !== 1) {\n        throw new Error('Non-finalized contexts left when pattern parse ended');\n      }\n\n      var _this$context$ = this.context[0],\n          branches = _this$context$.branches,\n          instructions = _this$context$.instructions;\n\n      if (branches) {\n        return {\n          op: '|',\n          args: branches.concat([expandSingleElementArray(instructions)])\n        };\n      }\n      /* istanbul ignore if */\n\n\n      if (instructions.length === 0) {\n        throw new Error('Pattern is required');\n      }\n\n      if (instructions.length === 1) {\n        return instructions[0];\n      }\n\n      return instructions;\n    }\n  }, {\n    key: \"startContext\",\n    value: function startContext(context) {\n      this.context.push(context);\n    }\n  }, {\n    key: \"endContext\",\n    value: function endContext() {\n      this.context.pop();\n    }\n  }, {\n    key: \"getContext\",\n    value: function getContext() {\n      return this.context[this.context.length - 1];\n    }\n  }, {\n    key: \"parsePattern\",\n    value: function parsePattern(pattern) {\n      if (!pattern) {\n        throw new Error('Pattern is required');\n      }\n\n      var match = pattern.match(OPERATOR);\n\n      if (!match) {\n        if (ILLEGAL_CHARACTER_REGEXP.test(pattern)) {\n          throw new Error(\"Illegal characters found in a pattern: \".concat(pattern));\n        }\n\n        this.getContext().instructions = this.getContext().instructions.concat(pattern.split(''));\n        return;\n      }\n\n      var operator = match[1];\n      var before = pattern.slice(0, match.index);\n      var rightPart = pattern.slice(match.index + operator.length);\n\n      switch (operator) {\n        case '(?:':\n          if (before) {\n            this.parsePattern(before);\n          }\n\n          this.startContext({\n            or: true,\n            instructions: [],\n            branches: []\n          });\n          break;\n\n        case ')':\n          if (!this.getContext().or) {\n            throw new Error('\")\" operator must be preceded by \"(?:\" operator');\n          }\n\n          if (before) {\n            this.parsePattern(before);\n          }\n\n          if (this.getContext().instructions.length === 0) {\n            throw new Error('No instructions found after \"|\" operator in an \"or\" group');\n          }\n\n          var _this$getContext = this.getContext(),\n              branches = _this$getContext.branches;\n\n          branches.push(expandSingleElementArray(this.getContext().instructions));\n          this.endContext();\n          this.getContext().instructions.push({\n            op: '|',\n            args: branches\n          });\n          break;\n\n        case '|':\n          if (!this.getContext().or) {\n            throw new Error('\"|\" operator can only be used inside \"or\" groups');\n          }\n\n          if (before) {\n            this.parsePattern(before);\n          } // The top-level is an implicit \"or\" group, if required.\n\n\n          if (!this.getContext().branches) {\n            // `branches` are not defined only for the root implicit \"or\" operator.\n\n            /* istanbul ignore else */\n            if (this.context.length === 1) {\n              this.getContext().branches = [];\n            } else {\n              throw new Error('\"branches\" not found in an \"or\" group context');\n            }\n          }\n\n          this.getContext().branches.push(expandSingleElementArray(this.getContext().instructions));\n          this.getContext().instructions = [];\n          break;\n\n        case '[':\n          if (before) {\n            this.parsePattern(before);\n          }\n\n          this.startContext({\n            oneOfSet: true\n          });\n          break;\n\n        case ']':\n          if (!this.getContext().oneOfSet) {\n            throw new Error('\"]\" operator must be preceded by \"[\" operator');\n          }\n\n          this.endContext();\n          this.getContext().instructions.push({\n            op: '[]',\n            args: parseOneOfSet(before)\n          });\n          break;\n\n        /* istanbul ignore next */\n\n        default:\n          throw new Error(\"Unknown operator: \".concat(operator));\n      }\n\n      if (rightPart) {\n        this.parsePattern(rightPart);\n      }\n    }\n  }]);\n\n  return PatternParser;\n}();\n\nexport { PatternParser as default };\n\nfunction parseOneOfSet(pattern) {\n  var values = [];\n  var i = 0;\n\n  while (i < pattern.length) {\n    if (pattern[i] === '-') {\n      if (i === 0 || i === pattern.length - 1) {\n        throw new Error(\"Couldn't parse a one-of set pattern: \".concat(pattern));\n      }\n\n      var prevValue = pattern[i - 1].charCodeAt(0) + 1;\n      var nextValue = pattern[i + 1].charCodeAt(0) - 1;\n      var value = prevValue;\n\n      while (value <= nextValue) {\n        values.push(String.fromCharCode(value));\n        value++;\n      }\n    } else {\n      values.push(pattern[i]);\n    }\n\n    i++;\n  }\n\n  return values;\n}\n\nvar ILLEGAL_CHARACTER_REGEXP = /[\\(\\)\\[\\]\\?\\:\\|]/;\nvar OPERATOR = new RegExp( // any of:\n'(' + // or operator\n'\\\\|' + // or\n'|' + // or group start\n'\\\\(\\\\?\\\\:' + // or\n'|' + // or group end\n'\\\\)' + // or\n'|' + // one-of set start\n'\\\\[' + // or\n'|' + // one-of set end\n'\\\\]' + ')');\n\nfunction expandSingleElementArray(array) {\n  if (array.length === 1) {\n    return array[0];\n  }\n\n  return array;\n}\n//# sourceMappingURL=AsYouTypeFormatter.PatternParser.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\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 PatternParser from './AsYouTypeFormatter.PatternParser.js';\n\nvar PatternMatcher = /*#__PURE__*/function () {\n  function PatternMatcher(pattern) {\n    _classCallCheck(this, PatternMatcher);\n\n    this.matchTree = new PatternParser().parse(pattern);\n  }\n\n  _createClass(PatternMatcher, [{\n    key: \"match\",\n    value: function match(string) {\n      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n          allowOverflow = _ref.allowOverflow;\n\n      if (!string) {\n        throw new Error('String is required');\n      }\n\n      var result = _match(string.split(''), this.matchTree, true);\n\n      if (result && result.match) {\n        delete result.matchedChars;\n      }\n\n      if (result && result.overflow) {\n        if (!allowOverflow) {\n          return;\n        }\n      }\n\n      return result;\n    }\n  }]);\n\n  return PatternMatcher;\n}();\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 */\n\n\nexport { PatternMatcher as default };\n\nfunction _match(characters, tree, last) {\n  // If `tree` is a string, then `tree` is a single character.\n  // That's because when a pattern is parsed, multi-character-string parts\n  // of a pattern are compiled into arrays of single characters.\n  // I still wrote this piece of code for a \"general\" hypothetical case\n  // when `tree` could be a string of several characters, even though\n  // such case is not possible with the current implementation.\n  if (typeof tree === 'string') {\n    var characterString = characters.join('');\n\n    if (tree.indexOf(characterString) === 0) {\n      // `tree` is always a single character.\n      // If `tree.indexOf(characterString) === 0`\n      // then `characters.length === tree.length`.\n\n      /* istanbul ignore else */\n      if (characters.length === tree.length) {\n        return {\n          match: true,\n          matchedChars: characters\n        };\n      } // `tree` is always a single character.\n      // If `tree.indexOf(characterString) === 0`\n      // then `characters.length === tree.length`.\n\n      /* istanbul ignore next */\n\n\n      return {\n        partialMatch: true // matchedChars: characters\n\n      };\n    }\n\n    if (characterString.indexOf(tree) === 0) {\n      if (last) {\n        // The `else` path is not possible because `tree` is always a single character.\n        // The `else` case for `characters.length > tree.length` would be\n        // `characters.length <= tree.length` which means `characters.length <= 1`.\n        // `characters` array can't be empty, so that means `characters === [tree]`,\n        // which would also mean `tree.indexOf(characterString) === 0` and that'd mean\n        // that the `if (tree.indexOf(characterString) === 0)` condition before this\n        // `if` condition would be entered, and returned from there, not reaching this code.\n\n        /* istanbul ignore else */\n        if (characters.length > tree.length) {\n          return {\n            overflow: true\n          };\n        }\n      }\n\n      return {\n        match: true,\n        matchedChars: characters.slice(0, tree.length)\n      };\n    }\n\n    return;\n  }\n\n  if (Array.isArray(tree)) {\n    var restCharacters = characters.slice();\n    var i = 0;\n\n    while (i < tree.length) {\n      var subtree = tree[i];\n\n      var result = _match(restCharacters, subtree, last && i === tree.length - 1);\n\n      if (!result) {\n        return;\n      } else if (result.overflow) {\n        return result;\n      } else if (result.match) {\n        // Continue with the next subtree with the rest of the characters.\n        restCharacters = restCharacters.slice(result.matchedChars.length);\n\n        if (restCharacters.length === 0) {\n          if (i === tree.length - 1) {\n            return {\n              match: true,\n              matchedChars: characters\n            };\n          } else {\n            return {\n              partialMatch: true // matchedChars: characters\n\n            };\n          }\n        }\n      } else {\n        /* istanbul ignore else */\n        if (result.partialMatch) {\n          return {\n            partialMatch: true // matchedChars: characters\n\n          };\n        } else {\n          throw new Error(\"Unsupported match result:\\n\".concat(JSON.stringify(result, null, 2)));\n        }\n      }\n\n      i++;\n    } // If `last` then overflow has already been checked\n    // by the last element of the `tree` array.\n\n    /* istanbul ignore if */\n\n\n    if (last) {\n      return {\n        overflow: true\n      };\n    }\n\n    return {\n      match: true,\n      matchedChars: characters.slice(0, characters.length - restCharacters.length)\n    };\n  }\n\n  switch (tree.op) {\n    case '|':\n      var partialMatch;\n\n      for (var _iterator = _createForOfIteratorHelperLoose(tree.args), _step; !(_step = _iterator()).done;) {\n        var branch = _step.value;\n\n        var _result = _match(characters, branch, last);\n\n        if (_result) {\n          if (_result.overflow) {\n            return _result;\n          } else if (_result.match) {\n            return {\n              match: true,\n              matchedChars: _result.matchedChars\n            };\n          } else {\n            /* istanbul ignore else */\n            if (_result.partialMatch) {\n              partialMatch = true;\n            } else {\n              throw new Error(\"Unsupported match result:\\n\".concat(JSON.stringify(_result, null, 2)));\n            }\n          }\n        }\n      }\n\n      if (partialMatch) {\n        return {\n          partialMatch: true // matchedChars: ...\n\n        };\n      } // Not even a partial match.\n\n\n      return;\n\n    case '[]':\n      for (var _iterator2 = _createForOfIteratorHelperLoose(tree.args), _step2; !(_step2 = _iterator2()).done;) {\n        var _char = _step2.value;\n\n        if (characters[0] === _char) {\n          if (characters.length === 1) {\n            return {\n              match: true,\n              matchedChars: characters\n            };\n          }\n\n          if (last) {\n            return {\n              overflow: true\n            };\n          }\n\n          return {\n            match: true,\n            matchedChars: [_char]\n          };\n        }\n      } // No character matches.\n\n\n      return;\n\n    /* istanbul ignore next */\n\n    default:\n      throw new Error(\"Unsupported instruction tree: \".concat(tree));\n  }\n}\n//# sourceMappingURL=AsYouTypeFormatter.PatternMatcher.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\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 { DIGIT_PLACEHOLDER, countOccurences, repeat, cutAndStripNonPairedParens, closeNonPairedParens, stripNonPairedParens, populateTemplateWithDigits } from './AsYouTypeFormatter.util.js';\nimport formatCompleteNumber, { canFormatCompleteNumber } from './AsYouTypeFormatter.complete.js';\nimport PatternMatcher from './AsYouTypeFormatter.PatternMatcher.js';\nimport parseDigits from './helpers/parseDigits.js';\nexport { DIGIT_PLACEHOLDER } from './AsYouTypeFormatter.util.js';\nimport { FIRST_GROUP_PATTERN } from './helpers/formatNationalNumberUsingFormat.js';\nimport { VALID_PUNCTUATION } from './constants.js';\nimport applyInternationalSeparatorStyle from './helpers/applyInternationalSeparatorStyle.js'; // Used in phone number format template creation.\n// Could be any digit, I guess.\n\nvar DUMMY_DIGIT = '9'; // I don't know why is it exactly `15`\n\nvar LONGEST_NATIONAL_PHONE_NUMBER_LENGTH = 15; // Create a phone number consisting only of the digit 9 that matches the\n// `number_pattern` by applying the pattern to the \"longest phone number\" string.\n\nvar LONGEST_DUMMY_PHONE_NUMBER = repeat(DUMMY_DIGIT, LONGEST_NATIONAL_PHONE_NUMBER_LENGTH); // A set of characters that, if found in a national prefix formatting rules, are an indicator to\n// us that we should separate the national prefix from the number when formatting.\n\nvar NATIONAL_PREFIX_SEPARATORS_PATTERN = /[- ]/; // Deprecated: Google has removed some formatting pattern related code from their repo.\n// https://github.com/googlei18n/libphonenumber/commit/a395b4fef3caf57c4bc5f082e1152a4d2bd0ba4c\n// \"We no longer have numbers in formatting matching patterns, only \\d.\"\n// Because this library supports generating custom metadata\n// some users may still be using old metadata so the relevant\n// code seems to stay until some next major version update.\n\nvar SUPPORT_LEGACY_FORMATTING_PATTERNS = true; // A pattern that is used to match character classes in regular expressions.\n// An example of a character class is \"[1-4]\".\n\nvar CREATE_CHARACTER_CLASS_PATTERN = SUPPORT_LEGACY_FORMATTING_PATTERNS && function () {\n  return /\\[([^\\[\\]])*\\]/g;\n}; // Any digit in a regular expression that actually denotes a digit. For\n// example, in the regular expression \"80[0-2]\\d{6,10}\", the first 2 digits\n// (8 and 0) are standalone digits, but the rest are not.\n// Two look-aheads are needed because the number following \\\\d could be a\n// two-digit number, since the phone number can be as long as 15 digits.\n\n\nvar CREATE_STANDALONE_DIGIT_PATTERN = SUPPORT_LEGACY_FORMATTING_PATTERNS && function () {\n  return /\\d(?=[^,}][^,}])/g;\n}; // A regular expression that is used to determine if a `format` is\n// suitable to be used in the \"as you type formatter\".\n// A `format` is suitable when the resulting formatted number has\n// the same digits as the user has entered.\n//\n// In the simplest case, that would mean that the format\n// doesn't add any additional digits when formatting a number.\n// Google says that it also shouldn't add \"star\" (`*`) characters,\n// like it does in some Israeli formats.\n// Such basic format would only contain \"valid punctuation\"\n// and \"captured group\" identifiers ($1, $2, etc).\n//\n// An example of a format that adds additional digits:\n//\n// Country: `AR` (Argentina).\n// Format:\n// {\n//    \"pattern\": \"(\\\\d)(\\\\d{2})(\\\\d{4})(\\\\d{4})\",\n//    \"leading_digits_patterns\": [\"91\"],\n//    \"national_prefix_formatting_rule\": \"0$1\",\n//    \"format\": \"$2 15-$3-$4\",\n//    \"international_format\": \"$1 $2 $3-$4\"\n// }\n//\n// In the format above, the `format` adds `15` to the digits when formatting a number.\n// A sidenote: this format actually is suitable because `national_prefix_for_parsing`\n// has previously removed `15` from a national number, so re-adding `15` in `format`\n// doesn't actually result in any extra digits added to user's input.\n// But verifying that would be a complex procedure, so the code chooses a simpler path:\n// it simply filters out all `format`s that contain anything but \"captured group\" ids.\n//\n// This regular expression is called `ELIGIBLE_FORMAT_PATTERN` in Google's\n// `libphonenumber` code.\n//\n\n\nvar NON_ALTERING_FORMAT_REG_EXP = new RegExp('[' + VALID_PUNCTUATION + ']*' + // Google developers say:\n// \"We require that the first matching group is present in the\n//  output pattern to ensure no data is lost while formatting.\"\n'\\\\$1' + '[' + VALID_PUNCTUATION + ']*' + '(\\\\$\\\\d[' + VALID_PUNCTUATION + ']*)*' + '$'); // This is the minimum length of the leading digits of a phone number\n// to guarantee the first \"leading digits pattern\" for a phone number format\n// to be preemptive.\n\nvar MIN_LEADING_DIGITS_LENGTH = 3;\n\nvar AsYouTypeFormatter = /*#__PURE__*/function () {\n  function AsYouTypeFormatter(_ref) {\n    var state = _ref.state,\n        metadata = _ref.metadata;\n\n    _classCallCheck(this, AsYouTypeFormatter);\n\n    this.metadata = metadata;\n    this.resetFormat();\n  }\n\n  _createClass(AsYouTypeFormatter, [{\n    key: \"resetFormat\",\n    value: function resetFormat() {\n      this.chosenFormat = undefined;\n      this.template = undefined;\n      this.nationalNumberTemplate = undefined;\n      this.populatedNationalNumberTemplate = undefined;\n      this.populatedNationalNumberTemplatePosition = -1;\n    }\n  }, {\n    key: \"reset\",\n    value: function reset(numberingPlan, state) {\n      this.resetFormat();\n\n      if (numberingPlan) {\n        this.isNANP = numberingPlan.callingCode() === '1';\n        this.matchingFormats = numberingPlan.formats();\n\n        if (state.nationalSignificantNumber) {\n          this.narrowDownMatchingFormats(state);\n        }\n      } else {\n        this.isNANP = undefined;\n        this.matchingFormats = [];\n      }\n    }\n    /**\r\n     * Formats an updated phone number.\r\n     * @param  {string} nextDigits — Additional phone number digits.\r\n     * @param  {object} state — `AsYouType` state.\r\n     * @return {[string]} Returns undefined if the updated phone number can't be formatted using any of the available formats.\r\n     */\n\n  }, {\n    key: \"format\",\n    value: function format(nextDigits, state) {\n      var _this = this;\n\n      // See if the phone number digits can be formatted as a complete phone number.\n      // If not, use the results from `formatNationalNumberWithNextDigits()`,\n      // which formats based on the chosen formatting pattern.\n      //\n      // Attempting to format complete phone number first is how it's done\n      // in Google's `libphonenumber`, so this library just follows it.\n      // Google's `libphonenumber` code doesn't explain in detail why does it\n      // attempt to format digits as a complete phone number\n      // instead of just going with a previoulsy (or newly) chosen `format`:\n      //\n      // \"Checks to see if there is an exact pattern match for these digits.\n      //  If so, we should use this instead of any other formatting template\n      //  whose leadingDigitsPattern also matches the input.\"\n      //\n      if (canFormatCompleteNumber(state.nationalSignificantNumber, this.metadata)) {\n        for (var _iterator = _createForOfIteratorHelperLoose(this.matchingFormats), _step; !(_step = _iterator()).done;) {\n          var format = _step.value;\n          var formattedCompleteNumber = formatCompleteNumber(state, format, {\n            metadata: this.metadata,\n            shouldTryNationalPrefixFormattingRule: function shouldTryNationalPrefixFormattingRule(format) {\n              return _this.shouldTryNationalPrefixFormattingRule(format, {\n                international: state.international,\n                nationalPrefix: state.nationalPrefix\n              });\n            },\n            getSeparatorAfterNationalPrefix: function getSeparatorAfterNationalPrefix(format) {\n              return _this.getSeparatorAfterNationalPrefix(format);\n            }\n          });\n\n          if (formattedCompleteNumber) {\n            this.resetFormat();\n            this.chosenFormat = format;\n            this.setNationalNumberTemplate(formattedCompleteNumber.replace(/\\d/g, DIGIT_PLACEHOLDER), state);\n            this.populatedNationalNumberTemplate = formattedCompleteNumber; // With a new formatting template, the matched position\n            // using the old template needs to be reset.\n\n            this.populatedNationalNumberTemplatePosition = this.template.lastIndexOf(DIGIT_PLACEHOLDER);\n            return formattedCompleteNumber;\n          }\n        }\n      } // Format the digits as a partial (incomplete) phone number\n      // using the previously chosen formatting pattern (or a newly chosen one).\n\n\n      return this.formatNationalNumberWithNextDigits(nextDigits, state);\n    } // Formats the next phone number digits.\n\n  }, {\n    key: \"formatNationalNumberWithNextDigits\",\n    value: function formatNationalNumberWithNextDigits(nextDigits, state) {\n      var previouslyChosenFormat = this.chosenFormat; // Choose a format from the list of matching ones.\n\n      var newlyChosenFormat = this.chooseFormat(state);\n\n      if (newlyChosenFormat) {\n        if (newlyChosenFormat === previouslyChosenFormat) {\n          // If it can format the next (current) digits\n          // using the previously chosen phone number format\n          // then return the updated formatted number.\n          return this.formatNextNationalNumberDigits(nextDigits);\n        } else {\n          // If a more appropriate phone number format\n          // has been chosen for these \"leading digits\",\n          // then re-format the national phone number part\n          // using the newly selected format.\n          return this.formatNextNationalNumberDigits(state.getNationalDigits());\n        }\n      }\n    }\n  }, {\n    key: \"narrowDownMatchingFormats\",\n    value: function narrowDownMatchingFormats(_ref2) {\n      var _this2 = this;\n\n      var nationalSignificantNumber = _ref2.nationalSignificantNumber,\n          nationalPrefix = _ref2.nationalPrefix,\n          international = _ref2.international;\n      var leadingDigits = nationalSignificantNumber; // \"leading digits\" pattern list starts with a\n      // \"leading digits\" pattern fitting a maximum of 3 leading digits.\n      // So, after a user inputs 3 digits of a national (significant) phone number\n      // this national (significant) number can already be formatted.\n      // The next \"leading digits\" pattern is for 4 leading digits max,\n      // and the \"leading digits\" pattern after it is for 5 leading digits max, etc.\n      // This implementation is different from Google's\n      // in that it searches for a fitting format\n      // even if the user has entered less than\n      // `MIN_LEADING_DIGITS_LENGTH` digits of a national number.\n      // Because some leading digit patterns already match for a single first digit.\n\n      var leadingDigitsPatternIndex = leadingDigits.length - MIN_LEADING_DIGITS_LENGTH;\n\n      if (leadingDigitsPatternIndex < 0) {\n        leadingDigitsPatternIndex = 0;\n      }\n\n      this.matchingFormats = this.matchingFormats.filter(function (format) {\n        return _this2.formatSuits(format, international, nationalPrefix) && _this2.formatMatches(format, leadingDigits, leadingDigitsPatternIndex);\n      }); // If there was a phone number format chosen\n      // and it no longer holds given the new leading digits then reset it.\n      // The test for this `if` condition is marked as:\n      // \"Reset a chosen format when it no longer holds given the new leading digits\".\n      // To construct a valid test case for this one can find a country\n      // in `PhoneNumberMetadata.xml` yielding one format for 3 `<leadingDigits>`\n      // and yielding another format for 4 `<leadingDigits>` (Australia in this case).\n\n      if (this.chosenFormat && this.matchingFormats.indexOf(this.chosenFormat) === -1) {\n        this.resetFormat();\n      }\n    }\n  }, {\n    key: \"formatSuits\",\n    value: function formatSuits(format, international, nationalPrefix) {\n      // When a prefix before a national (significant) number is\n      // simply a national prefix, then it's parsed as `this.nationalPrefix`.\n      // In more complex cases, a prefix before national (significant) number\n      // could include a national prefix as well as some \"capturing groups\",\n      // and in that case there's no info whether a national prefix has been parsed.\n      // If national prefix is not used when formatting a phone number\n      // using this format, but a national prefix has been entered by the user,\n      // and was extracted, then discard such phone number format.\n      // In Google's \"AsYouType\" formatter code, the equivalent would be this part:\n      // https://github.com/google/libphonenumber/blob/0a45cfd96e71cad8edb0e162a70fcc8bd9728933/java/libphonenumber/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java#L175-L184\n      if (nationalPrefix && !format.usesNationalPrefix() && // !format.domesticCarrierCodeFormattingRule() &&\n      !format.nationalPrefixIsOptionalWhenFormattingInNationalFormat()) {\n        return false;\n      } // If national prefix is mandatory for this phone number format\n      // and there're no guarantees that a national prefix is present in user input\n      // then discard this phone number format as not suitable.\n      // In Google's \"AsYouType\" formatter code, the equivalent would be this part:\n      // https://github.com/google/libphonenumber/blob/0a45cfd96e71cad8edb0e162a70fcc8bd9728933/java/libphonenumber/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java#L185-L193\n\n\n      if (!international && !nationalPrefix && format.nationalPrefixIsMandatoryWhenFormattingInNationalFormat()) {\n        return false;\n      }\n\n      return true;\n    }\n  }, {\n    key: \"formatMatches\",\n    value: function formatMatches(format, leadingDigits, leadingDigitsPatternIndex) {\n      var leadingDigitsPatternsCount = format.leadingDigitsPatterns().length; // If this format is not restricted to a certain\n      // leading digits pattern then it fits.\n      // The test case could be found by searching for \"leadingDigitsPatternsCount === 0\".\n\n      if (leadingDigitsPatternsCount === 0) {\n        return true;\n      } // Start narrowing down the list of possible formats based on the leading digits.\n      // (only previously matched formats take part in the narrowing down process)\n      // `leading_digits_patterns` start with 3 digits min\n      // and then go up from there one digit at a time.\n\n\n      leadingDigitsPatternIndex = Math.min(leadingDigitsPatternIndex, leadingDigitsPatternsCount - 1);\n      var leadingDigitsPattern = format.leadingDigitsPatterns()[leadingDigitsPatternIndex]; // Google imposes a requirement on the leading digits\n      // to be minimum 3 digits long in order to be eligible\n      // for checking those with a leading digits pattern.\n      //\n      // Since `leading_digits_patterns` start with 3 digits min,\n      // Google's original `libphonenumber` library only starts\n      // excluding any non-matching formats only when the\n      // national number entered so far is at least 3 digits long,\n      // otherwise format matching would give false negatives.\n      //\n      // For example, when the digits entered so far are `2`\n      // and the leading digits pattern is `21` –\n      // it's quite obvious in this case that the format could be the one\n      // but due to the absence of further digits it would give false negative.\n      //\n      // Also, `leading_digits_patterns` doesn't always correspond to a single\n      // digits count. For example, `60|8` pattern would already match `8`\n      // but the `60` part would require having at least two leading digits,\n      // so the whole pattern would require inputting two digits first in order to\n      // decide on whether it matches the input, even when the input is \"80\".\n      //\n      // This library — `libphonenumber-js` — allows filtering by `leading_digits_patterns`\n      // even when there's only 1 or 2 digits of the national (significant) number.\n      // To do that, it uses a non-strict pattern matcher written specifically for that.\n      //\n\n      if (leadingDigits.length < MIN_LEADING_DIGITS_LENGTH) {\n        // Before leading digits < 3 matching was implemented:\n        // return true\n        //\n        // After leading digits < 3 matching was implemented:\n        try {\n          return new PatternMatcher(leadingDigitsPattern).match(leadingDigits, {\n            allowOverflow: true\n          }) !== undefined;\n        } catch (error)\n        /* istanbul ignore next */\n        {\n          // There's a slight possibility that there could be some undiscovered bug\n          // in the pattern matcher code. Since the \"leading digits < 3 matching\"\n          // feature is not \"essential\" for operation, it can fall back to the old way\n          // in case of any issues rather than halting the application's execution.\n          console.error(error);\n          return true;\n        }\n      } // If at least `MIN_LEADING_DIGITS_LENGTH` digits of a national number are\n      // available then use the usual regular expression matching.\n      //\n      // The whole pattern is wrapped in round brackets (`()`) because\n      // the pattern can use \"or\" operator (`|`) at the top level of the pattern.\n      //\n\n\n      return new RegExp(\"^(\".concat(leadingDigitsPattern, \")\")).test(leadingDigits);\n    }\n  }, {\n    key: \"getFormatFormat\",\n    value: function getFormatFormat(format, international) {\n      return international ? format.internationalFormat() : format.format();\n    }\n  }, {\n    key: \"chooseFormat\",\n    value: function chooseFormat(state) {\n      var _this3 = this;\n\n      var _loop = function _loop() {\n        var format = _step2.value;\n\n        // If this format is currently being used\n        // and is still suitable, then stick to it.\n        if (_this3.chosenFormat === format) {\n          return \"break\";\n        } // Sometimes, a formatting rule inserts additional digits in a phone number,\n        // and \"as you type\" formatter can't do that: it should only use the digits\n        // that the user has input.\n        //\n        // For example, in Argentina, there's a format for mobile phone numbers:\n        //\n        // {\n        //    \"pattern\": \"(\\\\d)(\\\\d{2})(\\\\d{4})(\\\\d{4})\",\n        //    \"leading_digits_patterns\": [\"91\"],\n        //    \"national_prefix_formatting_rule\": \"0$1\",\n        //    \"format\": \"$2 15-$3-$4\",\n        //    \"international_format\": \"$1 $2 $3-$4\"\n        // }\n        //\n        // In that format, `international_format` is used instead of `format`\n        // because `format` inserts `15` in the formatted number,\n        // and `AsYouType` formatter should only use the digits\n        // the user has actually input, without adding any extra digits.\n        // In this case, it wouldn't make a difference, because the `15`\n        // is first stripped when applying `national_prefix_for_parsing`\n        // and then re-added when using `format`, so in reality it doesn't\n        // add any new digits to the number, but to detect that, the code\n        // would have to be more complex: it would have to try formatting\n        // the digits using the format and then see if any digits have\n        // actually been added or removed, and then, every time a new digit\n        // is input, it should re-check whether the chosen format doesn't\n        // alter the digits.\n        //\n        // Google's code doesn't go that far, and so does this library:\n        // it simply requires that a `format` doesn't add any additonal\n        // digits to user's input.\n        //\n        // Also, people in general should move from inputting phone numbers\n        // in national format (possibly with national prefixes)\n        // and use international phone number format instead:\n        // it's a logical thing in the modern age of mobile phones,\n        // globalization and the internet.\n        //\n\n        /* istanbul ignore if */\n\n\n        if (!NON_ALTERING_FORMAT_REG_EXP.test(_this3.getFormatFormat(format, state.international))) {\n          return \"continue\";\n        }\n\n        if (!_this3.createTemplateForFormat(format, state)) {\n          // Remove the format if it can't generate a template.\n          _this3.matchingFormats = _this3.matchingFormats.filter(function (_) {\n            return _ !== format;\n          });\n          return \"continue\";\n        }\n\n        _this3.chosenFormat = format;\n        return \"break\";\n      };\n\n      // When there are multiple available formats, the formatter uses the first\n      // format where a formatting template could be created.\n      //\n      // For some weird reason, `istanbul` says \"else path not taken\"\n      // for the `for of` line below. Supposedly that means that\n      // the loop doesn't ever go over the last element in the list.\n      // That's true because there always is `this.chosenFormat`\n      // when `this.matchingFormats` is non-empty.\n      // And, for some weird reason, it doesn't think that the case\n      // with empty `this.matchingFormats` qualifies for a valid \"else\" path.\n      // So simply muting this `istanbul` warning.\n      // It doesn't skip the contents of the `for of` loop,\n      // it just skips the `for of` line.\n      //\n\n      /* istanbul ignore next */\n      for (var _iterator2 = _createForOfIteratorHelperLoose(this.matchingFormats.slice()), _step2; !(_step2 = _iterator2()).done;) {\n        var _ret = _loop();\n\n        if (_ret === \"break\") break;\n        if (_ret === \"continue\") continue;\n      }\n\n      if (!this.chosenFormat) {\n        // No format matches the national (significant) phone number.\n        this.resetFormat();\n      }\n\n      return this.chosenFormat;\n    }\n  }, {\n    key: \"createTemplateForFormat\",\n    value: function createTemplateForFormat(format, state) {\n      // The formatter doesn't format numbers when numberPattern contains '|', e.g.\n      // (20|3)\\d{4}. In those cases we quickly return.\n      // (Though there's no such format in current metadata)\n\n      /* istanbul ignore if */\n      if (SUPPORT_LEGACY_FORMATTING_PATTERNS && format.pattern().indexOf('|') >= 0) {\n        return;\n      } // Get formatting template for this phone number format\n\n\n      var template = this.getTemplateForFormat(format, state); // If the national number entered is too long\n      // for any phone number format, then abort.\n\n      if (template) {\n        this.setNationalNumberTemplate(template, state);\n        return true;\n      }\n    }\n  }, {\n    key: \"getSeparatorAfterNationalPrefix\",\n    value: function getSeparatorAfterNationalPrefix(format) {\n      // `US` metadata doesn't have a `national_prefix_formatting_rule`,\n      // so the `if` condition below doesn't apply to `US`,\n      // but in reality there shoudl be a separator\n      // between a national prefix and a national (significant) number.\n      // So `US` national prefix separator is a \"special\" \"hardcoded\" case.\n      if (this.isNANP) {\n        return ' ';\n      } // If a `format` has a `national_prefix_formatting_rule`\n      // and that rule has a separator after a national prefix,\n      // then it means that there should be a separator\n      // between a national prefix and a national (significant) number.\n\n\n      if (format && format.nationalPrefixFormattingRule() && NATIONAL_PREFIX_SEPARATORS_PATTERN.test(format.nationalPrefixFormattingRule())) {\n        return ' ';\n      } // At this point, there seems to be no clear evidence that\n      // there should be a separator between a national prefix\n      // and a national (significant) number. So don't insert one.\n\n\n      return '';\n    }\n  }, {\n    key: \"getInternationalPrefixBeforeCountryCallingCode\",\n    value: function getInternationalPrefixBeforeCountryCallingCode(_ref3, options) {\n      var IDDPrefix = _ref3.IDDPrefix,\n          missingPlus = _ref3.missingPlus;\n\n      if (IDDPrefix) {\n        return options && options.spacing === false ? IDDPrefix : IDDPrefix + ' ';\n      }\n\n      if (missingPlus) {\n        return '';\n      }\n\n      return '+';\n    }\n  }, {\n    key: \"getTemplate\",\n    value: function getTemplate(state) {\n      if (!this.template) {\n        return;\n      } // `this.template` holds the template for a \"complete\" phone number.\n      // The currently entered phone number is most likely not \"complete\",\n      // so trim all non-populated digits.\n\n\n      var index = -1;\n      var i = 0;\n      var internationalPrefix = state.international ? this.getInternationalPrefixBeforeCountryCallingCode(state, {\n        spacing: false\n      }) : '';\n\n      while (i < internationalPrefix.length + state.getDigitsWithoutInternationalPrefix().length) {\n        index = this.template.indexOf(DIGIT_PLACEHOLDER, index + 1);\n        i++;\n      }\n\n      return cutAndStripNonPairedParens(this.template, index + 1);\n    }\n  }, {\n    key: \"setNationalNumberTemplate\",\n    value: function setNationalNumberTemplate(template, state) {\n      this.nationalNumberTemplate = template;\n      this.populatedNationalNumberTemplate = template; // With a new formatting template, the matched position\n      // using the old template needs to be reset.\n\n      this.populatedNationalNumberTemplatePosition = -1; // For convenience, the public `.template` property\n      // contains the whole international number\n      // if the phone number being input is international:\n      // 'x' for the '+' sign, 'x'es for the country phone code,\n      // a spacebar and then the template for the formatted national number.\n\n      if (state.international) {\n        this.template = this.getInternationalPrefixBeforeCountryCallingCode(state).replace(/[\\d\\+]/g, DIGIT_PLACEHOLDER) + repeat(DIGIT_PLACEHOLDER, state.callingCode.length) + ' ' + template;\n      } else {\n        this.template = template;\n      }\n    }\n    /**\r\n     * Generates formatting template for a national phone number,\r\n     * optionally containing a national prefix, for a format.\r\n     * @param  {Format} format\r\n     * @param  {string} nationalPrefix\r\n     * @return {string}\r\n     */\n\n  }, {\n    key: \"getTemplateForFormat\",\n    value: function getTemplateForFormat(format, _ref4) {\n      var nationalSignificantNumber = _ref4.nationalSignificantNumber,\n          international = _ref4.international,\n          nationalPrefix = _ref4.nationalPrefix,\n          complexPrefixBeforeNationalSignificantNumber = _ref4.complexPrefixBeforeNationalSignificantNumber;\n      var pattern = format.pattern();\n      /* istanbul ignore else */\n\n      if (SUPPORT_LEGACY_FORMATTING_PATTERNS) {\n        pattern = pattern // Replace anything in the form of [..] with \\d\n        .replace(CREATE_CHARACTER_CLASS_PATTERN(), '\\\\d') // Replace any standalone digit (not the one in `{}`) with \\d\n        .replace(CREATE_STANDALONE_DIGIT_PATTERN(), '\\\\d');\n      } // Generate a dummy national number (consisting of `9`s)\n      // that fits this format's `pattern`.\n      //\n      // This match will always succeed,\n      // because the \"longest dummy phone number\"\n      // has enough length to accomodate any possible\n      // national phone number format pattern.\n      //\n\n\n      var digits = LONGEST_DUMMY_PHONE_NUMBER.match(pattern)[0]; // If the national number entered is too long\n      // for any phone number format, then abort.\n\n      if (nationalSignificantNumber.length > digits.length) {\n        return;\n      } // Get a formatting template which can be used to efficiently format\n      // a partial number where digits are added one by one.\n      // Below `strictPattern` is used for the\n      // regular expression (with `^` and `$`).\n      // This wasn't originally in Google's `libphonenumber`\n      // and I guess they don't really need it\n      // because they're not using \"templates\" to format phone numbers\n      // but I added `strictPattern` after encountering\n      // South Korean phone number formatting bug.\n      //\n      // Non-strict regular expression bug demonstration:\n      //\n      // this.nationalSignificantNumber : `111111111` (9 digits)\n      //\n      // pattern : (\\d{2})(\\d{3,4})(\\d{4})\n      // format : `$1 $2 $3`\n      // digits : `9999999999` (10 digits)\n      //\n      // '9999999999'.replace(new RegExp(/(\\d{2})(\\d{3,4})(\\d{4})/g), '$1 $2 $3') = \"99 9999 9999\"\n      //\n      // template : xx xxxx xxxx\n      //\n      // But the correct template in this case is `xx xxx xxxx`.\n      // The template was generated incorrectly because of the\n      // `{3,4}` variability in the `pattern`.\n      //\n      // The fix is, if `this.nationalSignificantNumber` has already sufficient length\n      // to satisfy the `pattern` completely then `this.nationalSignificantNumber`\n      // is used instead of `digits`.\n\n\n      var strictPattern = new RegExp('^' + pattern + '$');\n      var nationalNumberDummyDigits = nationalSignificantNumber.replace(/\\d/g, DUMMY_DIGIT); // If `this.nationalSignificantNumber` has already sufficient length\n      // to satisfy the `pattern` completely then use it\n      // instead of `digits`.\n\n      if (strictPattern.test(nationalNumberDummyDigits)) {\n        digits = nationalNumberDummyDigits;\n      }\n\n      var numberFormat = this.getFormatFormat(format, international);\n      var nationalPrefixIncludedInTemplate; // If a user did input a national prefix (and that's guaranteed),\n      // and if a `format` does have a national prefix formatting rule,\n      // then see if that national prefix formatting rule\n      // prepends exactly the same national prefix the user has input.\n      // If that's the case, then use the `format` with the national prefix formatting rule.\n      // Otherwise, use  the `format` without the national prefix formatting rule,\n      // and prepend a national prefix manually to it.\n\n      if (this.shouldTryNationalPrefixFormattingRule(format, {\n        international: international,\n        nationalPrefix: nationalPrefix\n      })) {\n        var numberFormatWithNationalPrefix = numberFormat.replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule()); // If `national_prefix_formatting_rule` of a `format` simply prepends\n        // national prefix at the start of a national (significant) number,\n        // then such formatting can be used with `AsYouType` formatter.\n        // There seems to be no `else` case: everywhere in metadata,\n        // national prefix formatting rule is national prefix + $1,\n        // or `($1)`, in which case such format isn't even considered\n        // when the user has input a national prefix.\n\n        /* istanbul ignore else */\n\n        if (parseDigits(format.nationalPrefixFormattingRule()) === (nationalPrefix || '') + parseDigits('$1')) {\n          numberFormat = numberFormatWithNationalPrefix;\n          nationalPrefixIncludedInTemplate = true; // Replace all digits of the national prefix in the formatting template\n          // with `DIGIT_PLACEHOLDER`s.\n\n          if (nationalPrefix) {\n            var i = nationalPrefix.length;\n\n            while (i > 0) {\n              numberFormat = numberFormat.replace(/\\d/, DIGIT_PLACEHOLDER);\n              i--;\n            }\n          }\n        }\n      } // Generate formatting template for this phone number format.\n\n\n      var template = digits // Format the dummy phone number according to the format.\n      .replace(new RegExp(pattern), numberFormat) // Replace each dummy digit with a DIGIT_PLACEHOLDER.\n      .replace(new RegExp(DUMMY_DIGIT, 'g'), DIGIT_PLACEHOLDER); // If a prefix of a national (significant) number is not as simple\n      // as just a basic national prefix, then just prepend such prefix\n      // before the national (significant) number, optionally spacing\n      // the two with a whitespace.\n\n      if (!nationalPrefixIncludedInTemplate) {\n        if (complexPrefixBeforeNationalSignificantNumber) {\n          // Prepend the prefix to the template manually.\n          template = repeat(DIGIT_PLACEHOLDER, complexPrefixBeforeNationalSignificantNumber.length) + ' ' + template;\n        } else if (nationalPrefix) {\n          // Prepend national prefix to the template manually.\n          template = repeat(DIGIT_PLACEHOLDER, nationalPrefix.length) + this.getSeparatorAfterNationalPrefix(format) + template;\n        }\n      }\n\n      if (international) {\n        template = applyInternationalSeparatorStyle(template);\n      }\n\n      return template;\n    }\n  }, {\n    key: \"formatNextNationalNumberDigits\",\n    value: function formatNextNationalNumberDigits(digits) {\n      var result = populateTemplateWithDigits(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition, digits);\n\n      if (!result) {\n        // Reset the format.\n        this.resetFormat();\n        return;\n      }\n\n      this.populatedNationalNumberTemplate = result[0];\n      this.populatedNationalNumberTemplatePosition = result[1]; // Return the formatted phone number so far.\n\n      return cutAndStripNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1); // The old way which was good for `input-format` but is not so good\n      // for `react-phone-number-input`'s default input (`InputBasic`).\n      // return closeNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1)\n      // \t.replace(new RegExp(DIGIT_PLACEHOLDER, 'g'), ' ')\n    }\n  }, {\n    key: \"shouldTryNationalPrefixFormattingRule\",\n    value: function shouldTryNationalPrefixFormattingRule(format, _ref5) {\n      var international = _ref5.international,\n          nationalPrefix = _ref5.nationalPrefix;\n\n      if (format.nationalPrefixFormattingRule()) {\n        // In some countries, `national_prefix_formatting_rule` is `($1)`,\n        // so it applies even if the user hasn't input a national prefix.\n        // `format.usesNationalPrefix()` detects such cases.\n        var usesNationalPrefix = format.usesNationalPrefix();\n\n        if (usesNationalPrefix && nationalPrefix || !usesNationalPrefix && !international) {\n          return true;\n        }\n      }\n    }\n  }]);\n\n  return AsYouTypeFormatter;\n}();\n\nexport { AsYouTypeFormatter as default };\n//# sourceMappingURL=AsYouTypeFormatter.js.map","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","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 _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 Metadata from './metadata.js';\nimport PhoneNumber from './PhoneNumber.js';\nimport AsYouTypeState from './AsYouTypeState.js';\nimport AsYouTypeFormatter, { DIGIT_PLACEHOLDER } from './AsYouTypeFormatter.js';\nimport AsYouTypeParser, { extractFormattedDigitsAndPlus } from './AsYouTypeParser.js';\nimport getCountryByCallingCode from './helpers/getCountryByCallingCode.js';\nimport getCountryByNationalNumber from './helpers/getCountryByNationalNumber.js';\nvar USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;\n\nvar AsYouType = /*#__PURE__*/function () {\n  /**\r\n   * @param {(string|object)?} [optionsOrDefaultCountry] - The default country used for parsing non-international phone numbers. Can also be an `options` object.\r\n   * @param {Object} metadata\r\n   */\n  function AsYouType(optionsOrDefaultCountry, metadata) {\n    _classCallCheck(this, AsYouType);\n\n    this.metadata = new Metadata(metadata);\n\n    var _this$getCountryAndCa = this.getCountryAndCallingCode(optionsOrDefaultCountry),\n        _this$getCountryAndCa2 = _slicedToArray(_this$getCountryAndCa, 2),\n        defaultCountry = _this$getCountryAndCa2[0],\n        defaultCallingCode = _this$getCountryAndCa2[1]; // `this.defaultCountry` and `this.defaultCallingCode` aren't required to be in sync.\n    // For example, `this.defaultCountry` could be `\"AR\"` and `this.defaultCallingCode` could be `undefined`.\n    // So `this.defaultCountry` and `this.defaultCallingCode` are totally independent.\n\n\n    this.defaultCountry = defaultCountry;\n    this.defaultCallingCode = defaultCallingCode;\n    this.reset();\n  }\n\n  _createClass(AsYouType, [{\n    key: \"getCountryAndCallingCode\",\n    value: function getCountryAndCallingCode(optionsOrDefaultCountry) {\n      // Set `defaultCountry` and `defaultCallingCode` options.\n      var defaultCountry;\n      var defaultCallingCode; // Turns out `null` also has type \"object\". Weird.\n\n      if (optionsOrDefaultCountry) {\n        if (_typeof(optionsOrDefaultCountry) === 'object') {\n          defaultCountry = optionsOrDefaultCountry.defaultCountry;\n          defaultCallingCode = optionsOrDefaultCountry.defaultCallingCode;\n        } else {\n          defaultCountry = optionsOrDefaultCountry;\n        }\n      }\n\n      if (defaultCountry && !this.metadata.hasCountry(defaultCountry)) {\n        defaultCountry = undefined;\n      }\n\n      if (defaultCallingCode) {\n        /* istanbul ignore if */\n        if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n          if (this.metadata.isNonGeographicCallingCode(defaultCallingCode)) {\n            defaultCountry = '001';\n          }\n        }\n      }\n\n      return [defaultCountry, defaultCallingCode];\n    }\n    /**\r\n     * Inputs \"next\" phone number characters.\r\n     * @param  {string} text\r\n     * @return {string} Formatted phone number characters that have been input so far.\r\n     */\n\n  }, {\n    key: \"input\",\n    value: function input(text) {\n      var _this$parser$input = this.parser.input(text, this.state),\n          digits = _this$parser$input.digits,\n          justLeadingPlus = _this$parser$input.justLeadingPlus;\n\n      if (justLeadingPlus) {\n        this.formattedOutput = '+';\n      } else if (digits) {\n        this.determineTheCountryIfNeeded(); // Match the available formats by the currently available leading digits.\n\n        if (this.state.nationalSignificantNumber) {\n          this.formatter.narrowDownMatchingFormats(this.state);\n        }\n\n        var formattedNationalNumber;\n\n        if (this.metadata.hasSelectedNumberingPlan()) {\n          formattedNationalNumber = this.formatter.format(digits, this.state);\n        }\n\n        if (formattedNationalNumber === undefined) {\n          // See if another national (significant) number could be re-extracted.\n          if (this.parser.reExtractNationalSignificantNumber(this.state)) {\n            this.determineTheCountryIfNeeded(); // If it could, then re-try formatting the new national (significant) number.\n\n            var nationalDigits = this.state.getNationalDigits();\n\n            if (nationalDigits) {\n              formattedNationalNumber = this.formatter.format(nationalDigits, this.state);\n            }\n          }\n        }\n\n        this.formattedOutput = formattedNationalNumber ? this.getFullNumber(formattedNationalNumber) : this.getNonFormattedNumber();\n      }\n\n      return this.formattedOutput;\n    }\n  }, {\n    key: \"reset\",\n    value: function reset() {\n      var _this = this;\n\n      this.state = new AsYouTypeState({\n        onCountryChange: function onCountryChange(country) {\n          // Before version `1.6.0`, the official `AsYouType` formatter API\n          // included the `.country` property of an `AsYouType` instance.\n          // Since that property (along with the others) have been moved to\n          // `this.state`, `this.country` property is emulated for compatibility\n          // with the old versions.\n          _this.country = country;\n        },\n        onCallingCodeChange: function onCallingCodeChange(callingCode, country) {\n          _this.metadata.selectNumberingPlan(country, callingCode);\n\n          _this.formatter.reset(_this.metadata.numberingPlan, _this.state);\n\n          _this.parser.reset(_this.metadata.numberingPlan);\n        }\n      });\n      this.formatter = new AsYouTypeFormatter({\n        state: this.state,\n        metadata: this.metadata\n      });\n      this.parser = new AsYouTypeParser({\n        defaultCountry: this.defaultCountry,\n        defaultCallingCode: this.defaultCallingCode,\n        metadata: this.metadata,\n        state: this.state,\n        onNationalSignificantNumberChange: function onNationalSignificantNumberChange() {\n          _this.determineTheCountryIfNeeded();\n\n          _this.formatter.reset(_this.metadata.numberingPlan, _this.state);\n        }\n      });\n      this.state.reset({\n        country: this.defaultCountry,\n        callingCode: this.defaultCallingCode\n      });\n      this.formattedOutput = '';\n      return this;\n    }\n    /**\r\n     * Returns `true` if the phone number is being input in international format.\r\n     * In other words, returns `true` if and only if the parsed phone number starts with a `\"+\"`.\r\n     * @return {boolean}\r\n     */\n\n  }, {\n    key: \"isInternational\",\n    value: function isInternational() {\n      return this.state.international;\n    }\n    /**\r\n     * Returns the \"calling code\" part of the phone number when it's being input\r\n     * in an international format.\r\n     * If no valid calling code has been entered so far, returns `undefined`.\r\n     * @return {string} [callingCode]\r\n     */\n\n  }, {\n    key: \"getCallingCode\",\n    value: function getCallingCode() {\n      // If the number is being input in national format and some \"default calling code\"\n      // has been passed to `AsYouType` constructor, then `this.state.callingCode`\n      // is equal to that \"default calling code\".\n      //\n      // If the number is being input in national format and no \"default calling code\"\n      // has been passed to `AsYouType` constructor, then returns `undefined`,\n      // even if a \"default country\" has been passed to `AsYouType` constructor.\n      //\n      if (this.isInternational()) {\n        return this.state.callingCode;\n      }\n    } // A legacy alias.\n\n  }, {\n    key: \"getCountryCallingCode\",\n    value: function getCountryCallingCode() {\n      return this.getCallingCode();\n    }\n    /**\r\n     * Returns a two-letter country code of the phone number.\r\n     * Returns `undefined` for \"non-geographic\" phone numbering plans.\r\n     * Returns `undefined` if no phone number has been input yet.\r\n     * @return {string} [country]\r\n     */\n\n  }, {\n    key: \"getCountry\",\n    value: function getCountry() {\n      var digits = this.state.digits; // Return `undefined` if no digits have been input yet.\n\n      if (digits) {\n        return this._getCountry();\n      }\n    }\n    /**\r\n     * Returns a two-letter country code of the phone number.\r\n     * Returns `undefined` for \"non-geographic\" phone numbering plans.\r\n     * @return {string} [country]\r\n     */\n\n  }, {\n    key: \"_getCountry\",\n    value: function _getCountry() {\n      var country = this.state.country;\n      /* istanbul ignore if */\n\n      if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n        // `AsYouType.getCountry()` returns `undefined`\n        // for \"non-geographic\" phone numbering plans.\n        if (country === '001') {\n          return;\n        }\n      }\n\n      return country;\n    }\n  }, {\n    key: \"determineTheCountryIfNeeded\",\n    value: function determineTheCountryIfNeeded() {\n      // Suppose a user enters a phone number in international format,\n      // and there're several countries corresponding to that country calling code,\n      // and a country has been derived from the number, and then\n      // a user enters one more digit and the number is no longer\n      // valid for the derived country, so the country should be re-derived\n      // on every new digit in those cases.\n      //\n      // If the phone number is being input in national format,\n      // then it could be a case when `defaultCountry` wasn't specified\n      // when creating `AsYouType` instance, and just `defaultCallingCode` was specified,\n      // and that \"calling code\" could correspond to a \"non-geographic entity\",\n      // or there could be several countries corresponding to that country calling code.\n      // In those cases, `this.country` is `undefined` and should be derived\n      // from the number. Again, if country calling code is ambiguous, then\n      // `this.country` should be re-derived with each new digit.\n      //\n      if (!this.state.country || this.isCountryCallingCodeAmbiguous()) {\n        this.determineTheCountry();\n      }\n    } // Prepends `+CountryCode ` in case of an international phone number\n\n  }, {\n    key: \"getFullNumber\",\n    value: function getFullNumber(formattedNationalNumber) {\n      var _this2 = this;\n\n      if (this.isInternational()) {\n        var prefix = function prefix(text) {\n          return _this2.formatter.getInternationalPrefixBeforeCountryCallingCode(_this2.state, {\n            spacing: text ? true : false\n          }) + text;\n        };\n\n        var callingCode = this.state.callingCode;\n\n        if (!callingCode) {\n          return prefix(\"\".concat(this.state.getDigitsWithoutInternationalPrefix()));\n        }\n\n        if (!formattedNationalNumber) {\n          return prefix(callingCode);\n        }\n\n        return prefix(\"\".concat(callingCode, \" \").concat(formattedNationalNumber));\n      }\n\n      return formattedNationalNumber;\n    }\n  }, {\n    key: \"getNonFormattedNationalNumberWithPrefix\",\n    value: function getNonFormattedNationalNumberWithPrefix() {\n      var _this$state = this.state,\n          nationalSignificantNumber = _this$state.nationalSignificantNumber,\n          complexPrefixBeforeNationalSignificantNumber = _this$state.complexPrefixBeforeNationalSignificantNumber,\n          nationalPrefix = _this$state.nationalPrefix;\n      var number = nationalSignificantNumber;\n      var prefix = complexPrefixBeforeNationalSignificantNumber || nationalPrefix;\n\n      if (prefix) {\n        number = prefix + number;\n      }\n\n      return number;\n    }\n  }, {\n    key: \"getNonFormattedNumber\",\n    value: function getNonFormattedNumber() {\n      var nationalSignificantNumberMatchesInput = this.state.nationalSignificantNumberMatchesInput;\n      return this.getFullNumber(nationalSignificantNumberMatchesInput ? this.getNonFormattedNationalNumberWithPrefix() : this.state.getNationalDigits());\n    }\n  }, {\n    key: \"getNonFormattedTemplate\",\n    value: function getNonFormattedTemplate() {\n      var number = this.getNonFormattedNumber();\n\n      if (number) {\n        return number.replace(/[\\+\\d]/g, DIGIT_PLACEHOLDER);\n      }\n    }\n  }, {\n    key: \"isCountryCallingCodeAmbiguous\",\n    value: function isCountryCallingCodeAmbiguous() {\n      var callingCode = this.state.callingCode;\n      var countryCodes = this.metadata.getCountryCodesForCallingCode(callingCode);\n      return countryCodes && countryCodes.length > 1;\n    } // Determines the country of the phone number\n    // entered so far based on the country phone code\n    // and the national phone number.\n\n  }, {\n    key: \"determineTheCountry\",\n    value: function determineTheCountry() {\n      this.state.setCountry(getCountryByCallingCode(this.isInternational() ? this.state.callingCode : this.defaultCallingCode, {\n        nationalNumber: this.state.nationalSignificantNumber,\n        defaultCountry: this.defaultCountry,\n        metadata: this.metadata\n      }));\n    }\n    /**\r\n     * Returns a E.164 phone number value for the user's input.\r\n     *\r\n     * For example, for country `\"US\"` and input `\"(222) 333-4444\"`\r\n     * it will return `\"+12223334444\"`.\r\n     *\r\n     * For international phone number input, it will also auto-correct\r\n     * some minor errors such as using a national prefix when writing\r\n     * an international phone number. For example, if the user inputs\r\n     * `\"+44 0 7400 000000\"` then it will return an auto-corrected\r\n     * `\"+447400000000\"` phone number value.\r\n     *\r\n     * Will return `undefined` if no digits have been input,\r\n     * or when inputting a phone number in national format and no\r\n     * default country or default \"country calling code\" have been set.\r\n     *\r\n     * @return {string} [value]\r\n     */\n\n  }, {\n    key: \"getNumberValue\",\n    value: function getNumberValue() {\n      var _this$state2 = this.state,\n          digits = _this$state2.digits,\n          callingCode = _this$state2.callingCode,\n          country = _this$state2.country,\n          nationalSignificantNumber = _this$state2.nationalSignificantNumber; // Will return `undefined` if no digits have been input.\n\n      if (!digits) {\n        return;\n      }\n\n      if (this.isInternational()) {\n        if (callingCode) {\n          return '+' + callingCode + nationalSignificantNumber;\n        } else {\n          return '+' + digits;\n        }\n      } else {\n        if (country || callingCode) {\n          var callingCode_ = country ? this.metadata.countryCallingCode() : callingCode;\n          return '+' + callingCode_ + nationalSignificantNumber;\n        }\n      }\n    }\n    /**\r\n     * Returns an instance of `PhoneNumber` class.\r\n     * Will return `undefined` if no national (significant) number\r\n     * digits have been entered so far, or if no `defaultCountry` has been\r\n     * set and the user enters a phone number not in international format.\r\n     */\n\n  }, {\n    key: \"getNumber\",\n    value: function getNumber() {\n      var _this$state3 = this.state,\n          nationalSignificantNumber = _this$state3.nationalSignificantNumber,\n          carrierCode = _this$state3.carrierCode,\n          callingCode = _this$state3.callingCode; // `this._getCountry()` is basically same as `this.state.country`\n      // with the only change that it return `undefined` in case of a\n      // \"non-geographic\" numbering plan instead of `\"001\"` \"internal use\" value.\n\n      var country = this._getCountry();\n\n      if (!nationalSignificantNumber) {\n        return;\n      } // `state.country` and `state.callingCode` aren't required to be in sync.\n      // For example, `country` could be `\"AR\"` and `callingCode` could be `undefined`.\n      // So `country` and `callingCode` are totally independent.\n\n\n      if (!country && !callingCode) {\n        return;\n      } // By default, if `defaultCountry` parameter was passed when\n      // creating `AsYouType` instance, `state.country` is gonna be\n      // that `defaultCountry`, which doesn't entirely conform with\n      // `parsePhoneNumber()`'s behavior where it attempts to determine\n      // the country more precisely in cases when multiple countries\n      // could correspond to the same `countryCallingCode`.\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/103#note_1417192969\n      //\n      // Because `AsYouType.getNumber()` method is supposed to be a 1:1\n      // equivalent for `parsePhoneNumber(AsYouType.getNumberValue())`,\n      // then it should also behave accordingly in cases of `country` ambiguity.\n      // That's how users of this library would expect it to behave anyway.\n      //\n\n\n      if (country) {\n        if (country === this.defaultCountry) {\n          // `state.country` and `state.callingCode` aren't required to be in sync.\n          // For example, `state.country` could be `\"AR\"` and `state.callingCode` could be `undefined`.\n          // So `state.country` and `state.callingCode` are totally independent.\n          var metadata = new Metadata(this.metadata.metadata);\n          metadata.selectNumberingPlan(country);\n\n          var _callingCode = metadata.numberingPlan.callingCode();\n\n          var ambiguousCountries = this.metadata.getCountryCodesForCallingCode(_callingCode);\n\n          if (ambiguousCountries.length > 1) {\n            var exactCountry = getCountryByNationalNumber(nationalSignificantNumber, {\n              countries: ambiguousCountries,\n              defaultCountry: this.defaultCountry,\n              metadata: this.metadata.metadata\n            });\n\n            if (exactCountry) {\n              country = exactCountry;\n            }\n          }\n        }\n      }\n\n      var phoneNumber = new PhoneNumber(country || callingCode, nationalSignificantNumber, this.metadata.metadata);\n\n      if (carrierCode) {\n        phoneNumber.carrierCode = carrierCode;\n      } // Phone number extensions are not supported by \"As You Type\" formatter.\n\n\n      return phoneNumber;\n    }\n    /**\r\n     * Returns `true` if the phone number is \"possible\".\r\n     * Is just a shortcut for `PhoneNumber.isPossible()`.\r\n     * @return {boolean}\r\n     */\n\n  }, {\n    key: \"isPossible\",\n    value: function isPossible() {\n      var phoneNumber = this.getNumber();\n\n      if (!phoneNumber) {\n        return false;\n      }\n\n      return phoneNumber.isPossible();\n    }\n    /**\r\n     * Returns `true` if the phone number is \"valid\".\r\n     * Is just a shortcut for `PhoneNumber.isValid()`.\r\n     * @return {boolean}\r\n     */\n\n  }, {\n    key: \"isValid\",\n    value: function isValid() {\n      var phoneNumber = this.getNumber();\n\n      if (!phoneNumber) {\n        return false;\n      }\n\n      return phoneNumber.isValid();\n    }\n    /**\r\n     * @deprecated\r\n     * This method is used in `react-phone-number-input/source/input-control.js`\r\n     * in versions before `3.0.16`.\r\n     */\n\n  }, {\n    key: \"getNationalNumber\",\n    value: function getNationalNumber() {\n      return this.state.nationalSignificantNumber;\n    }\n    /**\r\n     * Returns the phone number characters entered by the user.\r\n     * @return {string}\r\n     */\n\n  }, {\n    key: \"getChars\",\n    value: function getChars() {\n      return (this.state.international ? '+' : '') + this.state.digits;\n    }\n    /**\r\n     * Returns the template for the formatted phone number.\r\n     * @return {string}\r\n     */\n\n  }, {\n    key: \"getTemplate\",\n    value: function getTemplate() {\n      return this.formatter.getTemplate(this.state) || this.getNonFormattedTemplate() || '';\n    }\n  }]);\n\n  return AsYouType;\n}();\n\nexport { AsYouType as default };\n//# sourceMappingURL=AsYouType.js.map","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 _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\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n// https://stackoverflow.com/a/46971044/970769\n// \"Breaking changes in Typescript 2.1\"\n// \"Extending built-ins like Error, Array, and Map may no longer work.\"\n// \"As a recommendation, you can manually adjust the prototype immediately after any super(...) calls.\"\n// https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\nvar ParseError = /*#__PURE__*/function (_Error) {\n  _inherits(ParseError, _Error);\n\n  var _super = _createSuper(ParseError);\n\n  function ParseError(code) {\n    var _this;\n\n    _classCallCheck(this, ParseError);\n\n    _this = _super.call(this, code); // Set the prototype explicitly.\n    // Any subclass of FooError will have to manually set the prototype as well.\n\n    Object.setPrototypeOf(_assertThisInitialized(_this), ParseError.prototype);\n    _this.name = _this.constructor.name;\n    return _this;\n  }\n\n  return _createClass(ParseError);\n}( /*#__PURE__*/_wrapNativeSuper(Error));\n\nexport { ParseError as default };\n//# sourceMappingURL=ParseError.js.map","function 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 _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 Metadata from './metadata.js';\nimport isPossibleNumber from './isPossible.js';\nimport isValidNumber from './isValid.js'; // import checkNumberLength from './helpers/checkNumberLength.js'\n\nimport getNumberType from './helpers/getNumberType.js';\nimport getPossibleCountriesForNumber from './helpers/getPossibleCountriesForNumber.js';\nimport formatNumber from './format.js';\nvar USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;\n\nvar PhoneNumber = /*#__PURE__*/function () {\n  /**\r\n   * @param  {string} countryOrCountryCallingCode\r\n   * @param  {string} nationalNumber\r\n   * @param  {object} metadata — Metadata JSON\r\n   * @return {PhoneNumber}\r\n   */\n  function PhoneNumber(countryOrCountryCallingCode, nationalNumber, metadata) {\n    _classCallCheck(this, PhoneNumber);\n\n    if (!countryOrCountryCallingCode) {\n      throw new TypeError('`country` or `countryCallingCode` not passed');\n    }\n\n    if (!nationalNumber) {\n      throw new TypeError('`nationalNumber` not passed');\n    }\n\n    if (!metadata) {\n      throw new TypeError('`metadata` not passed');\n    }\n\n    var _getCountryAndCountry = getCountryAndCountryCallingCode(countryOrCountryCallingCode, metadata),\n        country = _getCountryAndCountry.country,\n        countryCallingCode = _getCountryAndCountry.countryCallingCode;\n\n    this.country = country;\n    this.countryCallingCode = countryCallingCode;\n    this.nationalNumber = nationalNumber;\n    this.number = '+' + this.countryCallingCode + this.nationalNumber; // Exclude `metadata` property output from `PhoneNumber.toString()`\n    // so that it doesn't clutter the console output of Node.js.\n    // Previously, when Node.js did `console.log(new PhoneNumber(...))`,\n    // it would output the whole internal structure of the `metadata` object.\n\n    this.getMetadata = function () {\n      return metadata;\n    };\n  }\n\n  _createClass(PhoneNumber, [{\n    key: \"setExt\",\n    value: function setExt(ext) {\n      this.ext = ext;\n    }\n  }, {\n    key: \"getPossibleCountries\",\n    value: function getPossibleCountries() {\n      if (this.country) {\n        return [this.country];\n      }\n\n      return getPossibleCountriesForNumber(this.countryCallingCode, this.nationalNumber, this.getMetadata());\n    }\n  }, {\n    key: \"isPossible\",\n    value: function isPossible() {\n      return isPossibleNumber(this, {\n        v2: true\n      }, this.getMetadata());\n    }\n  }, {\n    key: \"isValid\",\n    value: function isValid() {\n      return isValidNumber(this, {\n        v2: true\n      }, this.getMetadata());\n    }\n  }, {\n    key: \"isNonGeographic\",\n    value: function isNonGeographic() {\n      var metadata = new Metadata(this.getMetadata());\n      return metadata.isNonGeographicCallingCode(this.countryCallingCode);\n    }\n  }, {\n    key: \"isEqual\",\n    value: function isEqual(phoneNumber) {\n      return this.number === phoneNumber.number && this.ext === phoneNumber.ext;\n    } // This function was originally meant to be an equivalent for `validatePhoneNumberLength()`,\n    // but later it was found out that it doesn't include the possible `TOO_SHORT` result\n    // returned from `parsePhoneNumberWithError()` in the original `validatePhoneNumberLength()`,\n    // so eventually I simply commented out this method from the `PhoneNumber` class\n    // and just left the `validatePhoneNumberLength()` function, even though that one would require\n    // and additional step to also validate the actual country / calling code of the phone number.\n    // validateLength() {\n    // \tconst metadata = new Metadata(this.getMetadata())\n    // \tmetadata.selectNumberingPlan(this.countryCallingCode)\n    // \tconst result = checkNumberLength(this.nationalNumber, metadata)\n    // \tif (result !== 'IS_POSSIBLE') {\n    // \t\treturn result\n    // \t}\n    // }\n\n  }, {\n    key: \"getType\",\n    value: function getType() {\n      return getNumberType(this, {\n        v2: true\n      }, this.getMetadata());\n    }\n  }, {\n    key: \"format\",\n    value: function format(_format, options) {\n      return formatNumber(this, _format, options ? _objectSpread(_objectSpread({}, options), {}, {\n        v2: true\n      }) : {\n        v2: true\n      }, this.getMetadata());\n    }\n  }, {\n    key: \"formatNational\",\n    value: function formatNational(options) {\n      return this.format('NATIONAL', options);\n    }\n  }, {\n    key: \"formatInternational\",\n    value: function formatInternational(options) {\n      return this.format('INTERNATIONAL', options);\n    }\n  }, {\n    key: \"getURI\",\n    value: function getURI(options) {\n      return this.format('RFC3966', options);\n    }\n  }]);\n\n  return PhoneNumber;\n}();\n\nexport { PhoneNumber as default };\n\nvar isCountryCode = function isCountryCode(value) {\n  return /^[A-Z]{2}$/.test(value);\n};\n\nfunction getCountryAndCountryCallingCode(countryOrCountryCallingCode, metadataJson) {\n  var country;\n  var countryCallingCode;\n  var metadata = new Metadata(metadataJson); // If country code is passed then derive `countryCallingCode` from it.\n  // Also store the country code as `.country`.\n\n  if (isCountryCode(countryOrCountryCallingCode)) {\n    country = countryOrCountryCallingCode;\n    metadata.selectNumberingPlan(country);\n    countryCallingCode = metadata.countryCallingCode();\n  } else {\n    countryCallingCode = countryOrCountryCallingCode;\n    /* istanbul ignore if */\n\n    if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n      if (metadata.isNonGeographicCallingCode(countryCallingCode)) {\n        country = '001';\n      }\n    }\n  }\n\n  return {\n    country: country,\n    countryCallingCode: countryCallingCode\n  };\n}\n//# sourceMappingURL=PhoneNumber.js.map","// The minimum length of the national significant number.\nexport var MIN_LENGTH_FOR_NSN = 2; // The ITU says the maximum length should be 15,\n// but one can find longer numbers in Germany.\n\nexport var MAX_LENGTH_FOR_NSN = 17; // The maximum length of the country calling code.\n\nexport var MAX_LENGTH_COUNTRY_CODE = 3; // Digits accepted in phone numbers\n// (ascii, fullwidth, arabic-indic, and eastern arabic digits).\n\nexport var VALID_DIGITS = \"0-9\\uFF10-\\uFF19\\u0660-\\u0669\\u06F0-\\u06F9\"; // `DASHES` will be right after the opening square bracket of the \"character class\"\n\nvar DASHES = \"-\\u2010-\\u2015\\u2212\\u30FC\\uFF0D\";\nvar SLASHES = \"\\uFF0F/\";\nvar DOTS = \"\\uFF0E.\";\nexport var WHITESPACE = \" \\xA0\\xAD\\u200B\\u2060\\u3000\";\nvar BRACKETS = \"()\\uFF08\\uFF09\\uFF3B\\uFF3D\\\\[\\\\]\"; // export const OPENING_BRACKETS = '(\\uFF08\\uFF3B\\\\\\['\n\nvar TILDES = \"~\\u2053\\u223C\\uFF5E\"; // Regular expression of acceptable punctuation found in phone numbers. This\n// excludes punctuation found as a leading character only. This consists of dash\n// characters, white space characters, full stops, slashes, square brackets,\n// parentheses and tildes. Full-width variants are also present.\n\nexport var VALID_PUNCTUATION = \"\".concat(DASHES).concat(SLASHES).concat(DOTS).concat(WHITESPACE).concat(BRACKETS).concat(TILDES);\nexport var PLUS_CHARS = \"+\\uFF0B\"; // const LEADING_PLUS_CHARS_PATTERN = new RegExp('^[' + PLUS_CHARS + ']+')\n//# sourceMappingURL=constants.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\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\n// This is a port of Google Android `libphonenumber`'s\n// `phonenumberutil.js` of December 31th, 2018.\n//\n// https://github.com/googlei18n/libphonenumber/commits/master/javascript/i18n/phonenumbers/phonenumberutil.js\nimport matchesEntirely from './helpers/matchesEntirely.js';\nimport formatNationalNumberUsingFormat from './helpers/formatNationalNumberUsingFormat.js';\nimport Metadata, { getCountryCallingCode } from './metadata.js';\nimport getIddPrefix from './helpers/getIddPrefix.js';\nimport { formatRFC3966 } from './helpers/RFC3966.js';\nvar DEFAULT_OPTIONS = {\n  formatExtension: function formatExtension(formattedNumber, extension, metadata) {\n    return \"\".concat(formattedNumber).concat(metadata.ext()).concat(extension);\n  }\n};\n/**\r\n * Formats a phone number.\r\n *\r\n * format(phoneNumberInstance, 'INTERNATIONAL', { ..., v2: true }, metadata)\r\n * format(phoneNumberInstance, 'NATIONAL', { ..., v2: true }, metadata)\r\n *\r\n * format({ phone: '8005553535', country: 'RU' }, 'INTERNATIONAL', { ... }, metadata)\r\n * format({ phone: '8005553535', country: 'RU' }, 'NATIONAL', undefined, metadata)\r\n *\r\n * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.\r\n * @param  {string} format\r\n * @param  {object} [options]\r\n * @param  {object} metadata\r\n * @return {string}\r\n */\n\nexport default function formatNumber(input, format, options, metadata) {\n  // Apply default options.\n  if (options) {\n    options = _objectSpread(_objectSpread({}, DEFAULT_OPTIONS), options);\n  } else {\n    options = DEFAULT_OPTIONS;\n  }\n\n  metadata = new Metadata(metadata);\n\n  if (input.country && input.country !== '001') {\n    // Validate `input.country`.\n    if (!metadata.hasCountry(input.country)) {\n      throw new Error(\"Unknown country: \".concat(input.country));\n    }\n\n    metadata.country(input.country);\n  } else if (input.countryCallingCode) {\n    metadata.selectNumberingPlan(input.countryCallingCode);\n  } else return input.phone || '';\n\n  var countryCallingCode = metadata.countryCallingCode();\n  var nationalNumber = options.v2 ? input.nationalNumber : input.phone; // This variable should have been declared inside `case`s\n  // but Babel has a bug and it says \"duplicate variable declaration\".\n\n  var number;\n\n  switch (format) {\n    case 'NATIONAL':\n      // Legacy argument support.\n      // (`{ country: ..., phone: '' }`)\n      if (!nationalNumber) {\n        return '';\n      }\n\n      number = formatNationalNumber(nationalNumber, input.carrierCode, 'NATIONAL', metadata, options);\n      return addExtension(number, input.ext, metadata, options.formatExtension);\n\n    case 'INTERNATIONAL':\n      // Legacy argument support.\n      // (`{ country: ..., phone: '' }`)\n      if (!nationalNumber) {\n        return \"+\".concat(countryCallingCode);\n      }\n\n      number = formatNationalNumber(nationalNumber, null, 'INTERNATIONAL', metadata, options);\n      number = \"+\".concat(countryCallingCode, \" \").concat(number);\n      return addExtension(number, input.ext, metadata, options.formatExtension);\n\n    case 'E.164':\n      // `E.164` doesn't define \"phone number extensions\".\n      return \"+\".concat(countryCallingCode).concat(nationalNumber);\n\n    case 'RFC3966':\n      return formatRFC3966({\n        number: \"+\".concat(countryCallingCode).concat(nationalNumber),\n        ext: input.ext\n      });\n    // For reference, here's Google's IDD formatter:\n    // https://github.com/google/libphonenumber/blob/32719cf74e68796788d1ca45abc85dcdc63ba5b9/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L1546\n    // Not saying that this IDD formatter replicates it 1:1, but it seems to work.\n    // Who would even need to format phone numbers in IDD format anyway?\n\n    case 'IDD':\n      if (!options.fromCountry) {\n        return; // throw new Error('`fromCountry` option not passed for IDD-prefixed formatting.')\n      }\n\n      var formattedNumber = formatIDD(nationalNumber, input.carrierCode, countryCallingCode, options.fromCountry, metadata);\n      return addExtension(formattedNumber, input.ext, metadata, options.formatExtension);\n\n    default:\n      throw new Error(\"Unknown \\\"format\\\" argument passed to \\\"formatNumber()\\\": \\\"\".concat(format, \"\\\"\"));\n  }\n}\n\nfunction formatNationalNumber(number, carrierCode, formatAs, metadata, options) {\n  var format = chooseFormatForNumber(metadata.formats(), number);\n\n  if (!format) {\n    return number;\n  }\n\n  return formatNationalNumberUsingFormat(number, format, {\n    useInternationalFormat: formatAs === 'INTERNATIONAL',\n    withNationalPrefix: format.nationalPrefixIsOptionalWhenFormattingInNationalFormat() && options && options.nationalPrefix === false ? false : true,\n    carrierCode: carrierCode,\n    metadata: metadata\n  });\n}\n\nexport function chooseFormatForNumber(availableFormats, nationalNnumber) {\n  for (var _iterator = _createForOfIteratorHelperLoose(availableFormats), _step; !(_step = _iterator()).done;) {\n    var format = _step.value;\n\n    // Validate leading digits.\n    // The test case for \"else path\" could be found by searching for\n    // \"format.leadingDigitsPatterns().length === 0\".\n    if (format.leadingDigitsPatterns().length > 0) {\n      // The last leading_digits_pattern is used here, as it is the most detailed\n      var lastLeadingDigitsPattern = format.leadingDigitsPatterns()[format.leadingDigitsPatterns().length - 1]; // If leading digits don't match then move on to the next phone number format\n\n      if (nationalNnumber.search(lastLeadingDigitsPattern) !== 0) {\n        continue;\n      }\n    } // Check that the national number matches the phone number format regular expression\n\n\n    if (matchesEntirely(nationalNnumber, format.pattern())) {\n      return format;\n    }\n  }\n}\n\nfunction addExtension(formattedNumber, ext, metadata, formatExtension) {\n  return ext ? formatExtension(formattedNumber, ext, metadata) : formattedNumber;\n}\n\nfunction formatIDD(nationalNumber, carrierCode, countryCallingCode, fromCountry, metadata) {\n  var fromCountryCallingCode = getCountryCallingCode(fromCountry, metadata.metadata); // When calling within the same country calling code.\n\n  if (fromCountryCallingCode === countryCallingCode) {\n    var formattedNumber = formatNationalNumber(nationalNumber, carrierCode, 'NATIONAL', metadata); // For NANPA regions, return the national format for these regions\n    // but prefix it with the country calling code.\n\n    if (countryCallingCode === '1') {\n      return countryCallingCode + ' ' + formattedNumber;\n    } // If regions share a country calling code, the country calling code need\n    // not be dialled. This also applies when dialling within a region, so this\n    // if clause covers both these cases. Technically this is the case for\n    // dialling from La Reunion to other overseas departments of France (French\n    // Guiana, Martinique, Guadeloupe), but not vice versa - so we don't cover\n    // this edge case for now and for those cases return the version including\n    // country calling code. Details here:\n    // http://www.petitfute.com/voyage/225-info-pratiques-reunion\n    //\n\n\n    return formattedNumber;\n  }\n\n  var iddPrefix = getIddPrefix(fromCountry, undefined, metadata.metadata);\n\n  if (iddPrefix) {\n    return \"\".concat(iddPrefix, \" \").concat(countryCallingCode, \" \").concat(formatNationalNumber(nationalNumber, null, 'INTERNATIONAL', metadata));\n  }\n}\n//# sourceMappingURL=format.js.map"],"names":["_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","AsYouTypeState","_ref","onCountryChange","onCallingCodeChange","instance","Constructor","TypeError","_classCallCheck","this","protoProps","value","_ref2","country","callingCode","international","missingPlus","IDDPrefix","undefined","digits","resetNationalSignificantNumber","initCountryAndCallingCode","nationalSignificantNumber","getNationalDigits","nationalSignificantNumberMatchesInput","nationalPrefix","carrierCode","complexPrefixBeforeNationalSignificantNumber","properties","_i","_Object$keys","keys","setCountry","setCallingCode","nextDigits","slice","prototype","_arrayLikeToArray","arr","len","arr2","Array","DIGIT_PLACEHOLDER","DIGIT_PLACEHOLDER_MATCHER","RegExp","repeat","string","times","result","cutAndStripNonPairedParens","cutBeforeIndex","dangling_braces","push","pop","start","cleared_string","_dangling_braces","index","stripNonPairedParens","formatCompleteNumber","state","format","metadata","shouldTryNationalPrefixFormattingRule","getSeparatorAfterNationalPrefix","concat","pattern","test","formattedNumber","formatNationalNumber","useNationalPrefixFormattingRule","formatNationalNumberWithAndWithoutNationalPrefixFormattingRule","_ref3","formattedNationalNumber","formatNationalNumberUsingFormat","useInternationalFormat","withNationalPrefix","parseDigits","isValidFormattedNationalNumber","PatternParser","context","or","instructions","parsePattern","Error","_this$context$","branches","op","args","expandSingleElementArray","match","OPERATOR","operator","before","rightPart","startContext","getContext","endContext","oneOfSet","parseOneOfSet","ILLEGAL_CHARACTER_REGEXP","split","values","prevValue","charCodeAt","nextValue","String","fromCharCode","array","o","allowArrayLike","it","Symbol","iterator","call","next","bind","isArray","minLen","n","toString","constructor","name","from","done","PatternMatcher","matchTree","parse","allowOverflow","arguments","_match","matchedChars","overflow","characters","tree","last","characterString","join","indexOf","partialMatch","restCharacters","JSON","stringify","_step","_iterator","_result","_step2","_iterator2","_char","LONGEST_DUMMY_PHONE_NUMBER","NATIONAL_PREFIX_SEPARATORS_PATTERN","NON_ALTERING_FORMAT_REG_EXP","AsYouTypeFormatter","resetFormat","chosenFormat","template","nationalNumberTemplate","populatedNationalNumberTemplate","populatedNationalNumberTemplatePosition","numberingPlan","isNANP","matchingFormats","formats","narrowDownMatchingFormats","_this","checkNumberLength","formattedCompleteNumber","setNationalNumberTemplate","replace","lastIndexOf","formatNationalNumberWithNextDigits","previouslyChosenFormat","newlyChosenFormat","chooseFormat","formatNextNationalNumberDigits","_this2","leadingDigits","leadingDigitsPatternIndex","filter","formatSuits","formatMatches","usesNationalPrefix","nationalPrefixIsOptionalWhenFormattingInNationalFormat","nationalPrefixIsMandatoryWhenFormattingInNationalFormat","leadingDigitsPatternsCount","leadingDigitsPatterns","Math","min","leadingDigitsPattern","error","console","internationalFormat","_this3","_loop","getFormatFormat","createTemplateForFormat","_","getTemplateForFormat","nationalPrefixFormattingRule","options","spacing","internationalPrefix","getInternationalPrefixBeforeCountryCallingCode","getDigitsWithoutInternationalPrefix","_ref4","strictPattern","nationalNumberDummyDigits","nationalPrefixIncludedInTemplate","numberFormat","numberFormatWithNationalPrefix","applyInternationalSeparatorStyle","position","_unsupportedIterableToArray","_createForOfIteratorHelperLoose","digit","search","populateTemplateWithDigits","_ref5","_slicedToArray","_arrayWithHoles","_s","_e","_arr","_n","_d","err","_iterableToArrayLimit","_nonIterableRest","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","defaultCountry","defaultCallingCode","onNationalSignificantNumberChange","text","justLeadingPlus","_extractFormattedDigi","_extractFormattedDigi3","extractedNumber","hasPlus","startsAt","extractFormattedPhoneNumber","_extractFormattedDigitsAndPlus","_extractFormattedDigi4","formattedDigits","extractFormattedDigitsAndPlus","_extractFormattedDigi2","startInternationalNumber","inputDigits","hasReceivedThreeLeadingDigits","appendDigits","extractIddPrefix","isWaitingForCountryCallingCode","extractCountryCallingCode","appendNationalSignificantNumberDigits","hasExtractedNationalSignificantNumber","extractNationalSignificantNumber","stateUpdate","update","_extractCountryCallin","countryCallingCode","number","hasSelectedNumberingPlan","nationalPrefixForParsing","_nationalPrefixForParsing","couldPossiblyExtractAnotherNationalSignificantNumber","nationalDigits","setState","_extractNationalNumbe","extractNationalNumberFromPossiblyIncompleteNumber","nationalNumber","onExtractedNationalNumber","prevNationalSignificantNumber","_extractNationalNumbe2","nationalSignificantNumberIndex","prefixBeforeNationalNumber","extractAnotherNationalSignificantNumber","fixMissingPlus","extractCallingCodeAndNationalSignificantNumber","numberWithoutIDD","stripIddPrefix","_extractCountryCallin2","extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","newCallingCode","_typeof","obj","AsYouType","optionsOrDefaultCountry","_this$getCountryAndCa2","getCountryAndCallingCode","reset","hasCountry","_this$parser$input","parser","input","formattedOutput","determineTheCountryIfNeeded","formatter","reExtractNationalSignificantNumber","getFullNumber","getNonFormattedNumber","selectNumberingPlan","isInternational","getCallingCode","_getCountry","isCountryCallingCodeAmbiguous","determineTheCountry","_this$state","prefix","getNonFormattedNationalNumberWithPrefix","countryCodes","getCountryCodesForCallingCode","getCountryByCallingCode","_this$state2","_this$state3","_callingCode","ambiguousCountries","exactCountry","getCountryByNationalNumber","countries","phoneNumber","PhoneNumber","getNumber","isPossible","isValid","getTemplate","getNonFormattedTemplate","_assertThisInitialized","self","ReferenceError","_wrapNativeSuper","Class","_cache","Map","fn","Function","has","get","set","Wrapper","_construct","_getPrototypeOf","create","_setPrototypeOf","Parent","_isNativeReflectConstruct","Reflect","construct","a","apply","sham","Proxy","Boolean","valueOf","e","p","setPrototypeOf","__proto__","getPrototypeOf","ParseError","_Error","subClass","superClass","_inherits","Derived","hasNativeReflectConstruct","_super","Super","NewTarget","_possibleConstructorReturn","code","ownKeys","object","enumerableOnly","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","_objectSpread","source","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","USE_NON_GEOGRAPHIC_COUNTRY_CODE","countryOrCountryCallingCode","_getCountryAndCountry","metadataJson","isCountryCode","isNonGeographicCallingCode","getCountryAndCountryCallingCode","getMetadata","ext","v2","_format","MIN_LENGTH_FOR_NSN","MAX_LENGTH_FOR_NSN","MAX_LENGTH_COUNTRY_CODE","VALID_DIGITS","VALID_PUNCTUATION","PLUS_CHARS","DEFAULT_OPTIONS","formatExtension","extension","formatNumber","phone","addExtension","fromCountry","iddPrefix","formatIDD","formatAs","availableFormats","nationalNnumber","lastLeadingDigitsPattern","chooseFormatForNumber"],"sourceRoot":""}