pixel-react 1.15.13 → 1.15.15

package/lib/node_modules/libphonenumber-js/es6/AsYouTypeFormatter.js

@@ -6,84 +6,102 @@ import { FIRST_GROUP_PATTERN } from './helpers/formatNationalNumberUsingFormat.j
 import { VALID_PUNCTUATION } from './constants.js';
 import applyInternationalSeparatorStyle from './helpers/applyInternationalSeparatorStyle.js';
 
-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) {
-    if (it) o = it;
-    var i = 0;
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+function _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+    t && (r = t);
+    var o = 0;
     return function () {
-      if (i >= o.length) return {
+      return o >= r.length ? {
         done: true
-      };
-      return {
+      } : {
         done: false,
-        value: o[i++]
+        value: r[o++]
       };
     };
   }
   throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _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);
-}
-function _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];
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
   }
-  return arr2;
 }
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
 }
-function _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);
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
   }
 }
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  Object.defineProperty(Constructor, "prototype", {
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
     writable: false
-  });
-  return Constructor;
+  }), e;
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+function _toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (String )(t);
 }
-// Could be any digit, I guess.
-
-var DUMMY_DIGIT = '9'; // I don't know why is it exactly `15`
 
-var LONGEST_NATIONAL_PHONE_NUMBER_LENGTH = 15; // Create a phone number consisting only of the digit 9 that matches the
+// Used in phone number format template creation.
+// Could be any digit, I guess.
+var DUMMY_DIGIT = '9';
+// I don't know why is it exactly `15`
+var LONGEST_NATIONAL_PHONE_NUMBER_LENGTH = 15;
+// Create a phone number consisting only of the digit 9 that matches the
 // `number_pattern` by applying the pattern to the "longest phone number" string.
+var LONGEST_DUMMY_PHONE_NUMBER = repeat(DUMMY_DIGIT, LONGEST_NATIONAL_PHONE_NUMBER_LENGTH);
 
-var 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
+// A set of characters that, if found in a national prefix formatting rules, are an indicator to
 // us that we should separate the national prefix from the number when formatting.
+var NATIONAL_PREFIX_SEPARATORS_PATTERN = /[- ]/;
 
-var NATIONAL_PREFIX_SEPARATORS_PATTERN = /[- ]/; // Deprecated: Google has removed some formatting pattern related code from their repo.
+// A pattern that is used to match character classes in regular expressions.
 // An example of a character class is "[1-4]".
-
 var CREATE_CHARACTER_CLASS_PATTERN = function () {
   return /\[([^\[\]])*\]/g;
-}; // Any digit in a regular expression that actually denotes a digit. For
+};
+
+// Any digit in a regular expression that actually denotes a digit. For
 // example, in the regular expression "80[0-2]\d{6,10}", the first 2 digits
 // (8 and 0) are standalone digits, but the rest are not.
 // Two look-aheads are needed because the number following \\d could be a
 // two-digit number, since the phone number can be as long as 15 digits.
-
 var CREATE_STANDALONE_DIGIT_PATTERN = function () {
   return /\d(?=[^,}][^,}])/g;
-}; // A regular expression that is used to determine if a `format` is
+};
+
+// A regular expression that is used to determine if a `format` is
 // suitable to be used in the "as you type formatter".
 // A `format` is suitable when the resulting formatted number has
 // the same digits as the user has entered.
@@ -117,15 +135,15 @@ var CREATE_STANDALONE_DIGIT_PATTERN = function () {
 // This regular expression is called `ELIGIBLE_FORMAT_PATTERN` in Google's
 // `libphonenumber` code.
 //
-
 var NON_ALTERING_FORMAT_REG_EXP = new RegExp('[' + VALID_PUNCTUATION + ']*' +
 // Google developers say:
 // "We require that the first matching group is present in the
 //  output pattern to ensure no data is lost while formatting."
-'\\$1' + '[' + VALID_PUNCTUATION + ']*' + '(\\$\\d[' + VALID_PUNCTUATION + ']*)*' + '$'); // This is the minimum length of the leading digits of a phone number
+'\\$1' + '[' + VALID_PUNCTUATION + ']*' + '(\\$\\d[' + VALID_PUNCTUATION + ']*)*' + '$');
+
+// This is the minimum length of the leading digits of a phone number
 // to guarantee the first "leading digits pattern" for a phone number format
 // to be preemptive.
-
 var MIN_LEADING_DIGITS_LENGTH = 3;
 var AsYouTypeFormatter = /*#__PURE__*/function () {
   function AsYouTypeFormatter(_ref) {
@@ -135,7 +153,7 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
     this.metadata = metadata;
     this.resetFormat();
   }
-  _createClass(AsYouTypeFormatter, [{
+  return _createClass(AsYouTypeFormatter, [{
     key: "resetFormat",
     value: function resetFormat() {
       this.chosenFormat = undefined;
@@ -159,6 +177,7 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
         this.matchingFormats = [];
       }
     }
+
     /**
      * Formats an updated phone number.
      * @param  {string} nextDigits — Additional phone number digits.
@@ -169,7 +188,6 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
     key: "format",
     value: function format(nextDigits, state) {
       var _this = this;
-
       // See if the phone number digits can be formatted as a complete phone number.
       // If not, use the results from `formatNationalNumberWithNextDigits()`,
       // which formats based on the chosen formatting pattern.
@@ -184,10 +202,10 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       //  If so, we should use this instead of any other formatting template
       //  whose leadingDigitsPattern also matches the input."
       //
-      if (canFormatCompleteNumber(state.nationalSignificantNumber, this.metadata)) {
+      if (canFormatCompleteNumber(state.nationalSignificantNumber, state.country, this.metadata)) {
         for (var _iterator = _createForOfIteratorHelperLoose(this.matchingFormats), _step; !(_step = _iterator()).done;) {
-          var format = _step.value;
-          var formattedCompleteNumber = formatCompleteNumber(state, format, {
+          var _format = _step.value;
+          var formattedCompleteNumber = formatCompleteNumber(state, _format, {
             metadata: this.metadata,
             shouldTryNationalPrefixFormattingRule: function shouldTryNationalPrefixFormattingRule(format) {
               return _this.shouldTryNationalPrefixFormattingRule(format, {
@@ -201,25 +219,28 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
           });
           if (formattedCompleteNumber) {
             this.resetFormat();
-            this.chosenFormat = format;
+            this.chosenFormat = _format;
             this.setNationalNumberTemplate(formattedCompleteNumber.replace(/\d/g, DIGIT_PLACEHOLDER), state);
-            this.populatedNationalNumberTemplate = formattedCompleteNumber; // With a new formatting template, the matched position
+            this.populatedNationalNumberTemplate = formattedCompleteNumber;
+            // With a new formatting template, the matched position
             // using the old template needs to be reset.
-
             this.populatedNationalNumberTemplatePosition = this.template.lastIndexOf(DIGIT_PLACEHOLDER);
             return formattedCompleteNumber;
           }
         }
-      } // Format the digits as a partial (incomplete) phone number
+      }
+      // Format the digits as a partial (incomplete) phone number
       // using the previously chosen formatting pattern (or a newly chosen one).
-
       return this.formatNationalNumberWithNextDigits(nextDigits, state);
-    } // Formats the next phone number digits.
+    }
+
+    // Formats the next phone number digits.
   }, {
     key: "formatNationalNumberWithNextDigits",
     value: function formatNationalNumberWithNextDigits(nextDigits, state) {
-      var previouslyChosenFormat = this.chosenFormat; // Choose a format from the list of matching ones.
+      var previouslyChosenFormat = this.chosenFormat;
 
+      // Choose a format from the list of matching ones.
       var newlyChosenFormat = this.chooseFormat(state);
       if (newlyChosenFormat) {
         if (newlyChosenFormat === previouslyChosenFormat) {
@@ -243,32 +264,35 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       var nationalSignificantNumber = _ref2.nationalSignificantNumber,
         nationalPrefix = _ref2.nationalPrefix,
         international = _ref2.international;
-      var leadingDigits = nationalSignificantNumber; // "leading digits" pattern list starts with a
+      var leadingDigits = nationalSignificantNumber;
+
+      // "leading digits" pattern list starts with a
       // "leading digits" pattern fitting a maximum of 3 leading digits.
       // So, after a user inputs 3 digits of a national (significant) phone number
       // this national (significant) number can already be formatted.
       // The next "leading digits" pattern is for 4 leading digits max,
       // and the "leading digits" pattern after it is for 5 leading digits max, etc.
+
       // This implementation is different from Google's
       // in that it searches for a fitting format
       // even if the user has entered less than
       // `MIN_LEADING_DIGITS_LENGTH` digits of a national number.
       // Because some leading digit patterns already match for a single first digit.
-
       var leadingDigitsPatternIndex = leadingDigits.length - MIN_LEADING_DIGITS_LENGTH;
       if (leadingDigitsPatternIndex < 0) {
         leadingDigitsPatternIndex = 0;
       }
       this.matchingFormats = this.matchingFormats.filter(function (format) {
         return _this2.formatSuits(format, international, nationalPrefix) && _this2.formatMatches(format, leadingDigits, leadingDigitsPatternIndex);
-      }); // If there was a phone number format chosen
+      });
+
+      // If there was a phone number format chosen
       // and it no longer holds given the new leading digits then reset it.
       // The test for this `if` condition is marked as:
       // "Reset a chosen format when it no longer holds given the new leading digits".
       // To construct a valid test case for this one can find a country
       // in `PhoneNumberMetadata.xml` yielding one format for 3 `<leadingDigits>`
       // and yielding another format for 4 `<leadingDigits>` (Australia in this case).
-
       if (this.chosenFormat && this.matchingFormats.indexOf(this.chosenFormat) === -1) {
         this.resetFormat();
       }
@@ -290,12 +314,12 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       // !format.domesticCarrierCodeFormattingRule() &&
       !format.nationalPrefixIsOptionalWhenFormattingInNationalFormat()) {
         return false;
-      } // If national prefix is mandatory for this phone number format
+      }
+      // If national prefix is mandatory for this phone number format
       // and there're no guarantees that a national prefix is present in user input
       // then discard this phone number format as not suitable.
       // In Google's "AsYouType" formatter code, the equivalent would be this part:
       // https://github.com/google/libphonenumber/blob/0a45cfd96e71cad8edb0e162a70fcc8bd9728933/java/libphonenumber/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java#L185-L193
-
       if (!international && !nationalPrefix && format.nationalPrefixIsMandatoryWhenFormattingInNationalFormat()) {
         return false;
       }
@@ -304,19 +328,24 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
   }, {
     key: "formatMatches",
     value: function formatMatches(format, leadingDigits, leadingDigitsPatternIndex) {
-      var leadingDigitsPatternsCount = format.leadingDigitsPatterns().length; // If this format is not restricted to a certain
+      var leadingDigitsPatternsCount = format.leadingDigitsPatterns().length;
+
+      // If this format is not restricted to a certain
       // leading digits pattern then it fits.
       // The test case could be found by searching for "leadingDigitsPatternsCount === 0".
-
       if (leadingDigitsPatternsCount === 0) {
         return true;
-      } // Start narrowing down the list of possible formats based on the leading digits.
+      }
+
+      // Start narrowing down the list of possible formats based on the leading digits.
       // (only previously matched formats take part in the narrowing down process)
+
       // `leading_digits_patterns` start with 3 digits min
       // and then go up from there one digit at a time.
-
       leadingDigitsPatternIndex = Math.min(leadingDigitsPatternIndex, leadingDigitsPatternsCount - 1);
-      var leadingDigitsPattern = format.leadingDigitsPatterns()[leadingDigitsPatternIndex]; // Google imposes a requirement on the leading digits
+      var leadingDigitsPattern = format.leadingDigitsPatterns()[leadingDigitsPatternIndex];
+
+      // Google imposes a requirement on the leading digits
       // to be minimum 3 digits long in order to be eligible
       // for checking those with a leading digits pattern.
       //
@@ -341,7 +370,6 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       // even when there's only 1 or 2 digits of the national (significant) number.
       // To do that, it uses a non-strict pattern matcher written specifically for that.
       //
-
       if (leadingDigits.length < MIN_LEADING_DIGITS_LENGTH) {
         // Before leading digits < 3 matching was implemented:
         // return true
@@ -351,8 +379,7 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
           return new PatternMatcher(leadingDigitsPattern).match(leadingDigits, {
             allowOverflow: true
           }) !== undefined;
-        } catch (error) /* istanbul ignore next */
-        {
+        } catch (error) /* istanbul ignore next */{
           // There's a slight possibility that there could be some undiscovered bug
           // in the pattern matcher code. Since the "leading digits < 3 matching"
           // feature is not "essential" for operation, it can fall back to the old way
@@ -360,13 +387,14 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
           console.error(error);
           return true;
         }
-      } // If at least `MIN_LEADING_DIGITS_LENGTH` digits of a national number are
+      }
+
+      // If at least `MIN_LEADING_DIGITS_LENGTH` digits of a national number are
       // available then use the usual regular expression matching.
       //
       // The whole pattern is wrapped in round brackets (`()`) because
       // the pattern can use "or" operator (`|`) at the top level of the pattern.
       //
-
       return new RegExp("^(".concat(leadingDigitsPattern, ")")).test(leadingDigits);
     }
   }, {
@@ -379,67 +407,65 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
     value: function chooseFormat(state) {
       var _this3 = this;
       var _loop = function _loop() {
-        var format = _step2.value;
-
-        // If this format is currently being used
-        // and is still suitable, then stick to it.
-        if (_this3.chosenFormat === format) {
-          return "break";
-        } // Sometimes, a formatting rule inserts additional digits in a phone number,
-        // and "as you type" formatter can't do that: it should only use the digits
-        // that the user has input.
-        //
-        // For example, in Argentina, there's a format for mobile phone numbers:
-        //
-        // {
-        //    "pattern": "(\\d)(\\d{2})(\\d{4})(\\d{4})",
-        //    "leading_digits_patterns": ["91"],
-        //    "national_prefix_formatting_rule": "0$1",
-        //    "format": "$2 15-$3-$4",
-        //    "international_format": "$1 $2 $3-$4"
-        // }
-        //
-        // In that format, `international_format` is used instead of `format`
-        // because `format` inserts `15` in the formatted number,
-        // and `AsYouType` formatter should only use the digits
-        // the user has actually input, without adding any extra digits.
-        // In this case, it wouldn't make a difference, because the `15`
-        // is first stripped when applying `national_prefix_for_parsing`
-        // and then re-added when using `format`, so in reality it doesn't
-        // add any new digits to the number, but to detect that, the code
-        // would have to be more complex: it would have to try formatting
-        // the digits using the format and then see if any digits have
-        // actually been added or removed, and then, every time a new digit
-        // is input, it should re-check whether the chosen format doesn't
-        // alter the digits.
-        //
-        // Google's code doesn't go that far, and so does this library:
-        // it simply requires that a `format` doesn't add any additonal
-        // digits to user's input.
-        //
-        // Also, people in general should move from inputting phone numbers
-        // in national format (possibly with national prefixes)
-        // and use international phone number format instead:
-        // it's a logical thing in the modern age of mobile phones,
-        // globalization and the internet.
-        //
-
-        /* istanbul ignore if */
-
-        if (!NON_ALTERING_FORMAT_REG_EXP.test(_this3.getFormatFormat(format, state.international))) {
-          return "continue";
-        }
-        if (!_this3.createTemplateForFormat(format, state)) {
-          // Remove the format if it can't generate a template.
-          _this3.matchingFormats = _this3.matchingFormats.filter(function (_) {
-            return _ !== format;
-          });
-          return "continue";
-        }
-        _this3.chosenFormat = format;
-        return "break";
-      };
-
+          var format = _step2.value;
+          // If this format is currently being used
+          // and is still suitable, then stick to it.
+          if (_this3.chosenFormat === format) {
+            return 0; // break
+          }
+          // Sometimes, a formatting rule inserts additional digits in a phone number,
+          // and "as you type" formatter can't do that: it should only use the digits
+          // that the user has input.
+          //
+          // For example, in Argentina, there's a format for mobile phone numbers:
+          //
+          // {
+          //    "pattern": "(\\d)(\\d{2})(\\d{4})(\\d{4})",
+          //    "leading_digits_patterns": ["91"],
+          //    "national_prefix_formatting_rule": "0$1",
+          //    "format": "$2 15-$3-$4",
+          //    "international_format": "$1 $2 $3-$4"
+          // }
+          //
+          // In that format, `international_format` is used instead of `format`
+          // because `format` inserts `15` in the formatted number,
+          // and `AsYouType` formatter should only use the digits
+          // the user has actually input, without adding any extra digits.
+          // In this case, it wouldn't make a difference, because the `15`
+          // is first stripped when applying `national_prefix_for_parsing`
+          // and then re-added when using `format`, so in reality it doesn't
+          // add any new digits to the number, but to detect that, the code
+          // would have to be more complex: it would have to try formatting
+          // the digits using the format and then see if any digits have
+          // actually been added or removed, and then, every time a new digit
+          // is input, it should re-check whether the chosen format doesn't
+          // alter the digits.
+          //
+          // Google's code doesn't go that far, and so does this library:
+          // it simply requires that a `format` doesn't add any additonal
+          // digits to user's input.
+          //
+          // Also, people in general should move from inputting phone numbers
+          // in national format (possibly with national prefixes)
+          // and use international phone number format instead:
+          // it's a logical thing in the modern age of mobile phones,
+          // globalization and the internet.
+          //
+          /* istanbul ignore if */
+          if (!NON_ALTERING_FORMAT_REG_EXP.test(_this3.getFormatFormat(format, state.international))) {
+            return 1; // continue
+          }
+          if (!_this3.createTemplateForFormat(format, state)) {
+            // Remove the format if it can't generate a template.
+            _this3.matchingFormats = _this3.matchingFormats.filter(function (_) {
+              return _ !== format;
+            });
+            return 1; // continue
+          }
+          _this3.chosenFormat = format;
+          return 0; // break
+        },
+        _ret;
       // When there are multiple available formats, the formatter uses the first
       // format where a formatting template could be created.
       //
@@ -454,12 +480,11 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       // It doesn't skip the contents of the `for of` loop,
       // it just skips the `for of` line.
       //
-
       /* istanbul ignore next */
       for (var _iterator2 = _createForOfIteratorHelperLoose(this.matchingFormats.slice()), _step2; !(_step2 = _iterator2()).done;) {
-        var _ret = _loop();
-        if (_ret === "break") break;
-        if (_ret === "continue") continue;
+        _ret = _loop();
+        if (_ret === 0) break;
+        if (_ret === 1) continue;
       }
       if (!this.chosenFormat) {
         // No format matches the national (significant) phone number.
@@ -473,15 +498,14 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       // The formatter doesn't format numbers when numberPattern contains '|', e.g.
       // (20|3)\d{4}. In those cases we quickly return.
       // (Though there's no such format in current metadata)
-
       /* istanbul ignore if */
       if (format.pattern().indexOf('|') >= 0) {
         return;
-      } // Get formatting template for this phone number format
-
-      var template = this.getTemplateForFormat(format, state); // If the national number entered is too long
+      }
+      // Get formatting template for this phone number format
+      var template = this.getTemplateForFormat(format, state);
+      // If the national number entered is too long
       // for any phone number format, then abort.
-
       if (template) {
         this.setNationalNumberTemplate(template, state);
         return true;
@@ -497,17 +521,17 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       // So `US` national prefix separator is a "special" "hardcoded" case.
       if (this.isNANP) {
         return ' ';
-      } // If a `format` has a `national_prefix_formatting_rule`
+      }
+      // If a `format` has a `national_prefix_formatting_rule`
       // and that rule has a separator after a national prefix,
       // then it means that there should be a separator
       // between a national prefix and a national (significant) number.
-
       if (format && format.nationalPrefixFormattingRule() && NATIONAL_PREFIX_SEPARATORS_PATTERN.test(format.nationalPrefixFormattingRule())) {
         return ' ';
-      } // At this point, there seems to be no clear evidence that
+      }
+      // At this point, there seems to be no clear evidence that
       // there should be a separator between a national prefix
       // and a national (significant) number. So don't insert one.
-
       return '';
     }
   }, {
@@ -528,10 +552,10 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
     value: function getTemplate(state) {
       if (!this.template) {
         return;
-      } // `this.template` holds the template for a "complete" phone number.
+      }
+      // `this.template` holds the template for a "complete" phone number.
       // The currently entered phone number is most likely not "complete",
       // so trim all non-populated digits.
-
       var index = -1;
       var i = 0;
       var internationalPrefix = state.international ? this.getInternationalPrefixBeforeCountryCallingCode(state, {
@@ -547,21 +571,22 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
     key: "setNationalNumberTemplate",
     value: function setNationalNumberTemplate(template, state) {
       this.nationalNumberTemplate = template;
-      this.populatedNationalNumberTemplate = template; // With a new formatting template, the matched position
+      this.populatedNationalNumberTemplate = template;
+      // With a new formatting template, the matched position
       // using the old template needs to be reset.
-
-      this.populatedNationalNumberTemplatePosition = -1; // For convenience, the public `.template` property
+      this.populatedNationalNumberTemplatePosition = -1;
+      // For convenience, the public `.template` property
       // contains the whole international number
       // if the phone number being input is international:
       // 'x' for the '+' sign, 'x'es for the country phone code,
       // a spacebar and then the template for the formatted national number.
-
       if (state.international) {
         this.template = this.getInternationalPrefixBeforeCountryCallingCode(state).replace(/[\d\+]/g, DIGIT_PLACEHOLDER) + repeat(DIGIT_PLACEHOLDER, state.callingCode.length) + ' ' + template;
       } else {
         this.template = template;
       }
     }
+
     /**
      * Generates formatting template for a national phone number,
      * optionally containing a national prefix, for a format.
@@ -575,15 +600,19 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       var nationalSignificantNumber = _ref4.nationalSignificantNumber,
         international = _ref4.international,
         nationalPrefix = _ref4.nationalPrefix,
-        complexPrefixBeforeNationalSignificantNumber = _ref4.complexPrefixBeforeNationalSignificantNumber;
+        prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix = _ref4.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix;
       var pattern = format.pattern();
-      /* istanbul ignore else */
 
+      /* istanbul ignore else */
       {
-        pattern = pattern // Replace anything in the form of [..] with \d
-        .replace(CREATE_CHARACTER_CLASS_PATTERN(), '\\d') // Replace any standalone digit (not the one in `{}`) with \d
+        pattern = pattern
+        // Replace anything in the form of [..] with \d
+        .replace(CREATE_CHARACTER_CLASS_PATTERN(), '\\d')
+        // Replace any standalone digit (not the one in `{}`) with \d
         .replace(CREATE_STANDALONE_DIGIT_PATTERN(), '\\d');
-      } // Generate a dummy national number (consisting of `9`s)
+      }
+
+      // Generate a dummy national number (consisting of `9`s)
       // that fits this format's `pattern`.
       //
       // This match will always succeed,
@@ -591,14 +620,17 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       // has enough length to accomodate any possible
       // national phone number format pattern.
       //
+      var digits = LONGEST_DUMMY_PHONE_NUMBER.match(pattern)[0];
 
-      var digits = LONGEST_DUMMY_PHONE_NUMBER.match(pattern)[0]; // If the national number entered is too long
+      // If the national number entered is too long
       // for any phone number format, then abort.
-
       if (nationalSignificantNumber.length > digits.length) {
         return;
-      } // Get a formatting template which can be used to efficiently format
+      }
+
+      // Get a formatting template which can be used to efficiently format
       // a partial number where digits are added one by one.
+
       // Below `strictPattern` is used for the
       // regular expression (with `^` and `$`).
       // This wasn't originally in Google's `libphonenumber`
@@ -628,41 +660,42 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       // is used instead of `digits`.
 
       var strictPattern = new RegExp('^' + pattern + '$');
-      var nationalNumberDummyDigits = nationalSignificantNumber.replace(/\d/g, DUMMY_DIGIT); // If `this.nationalSignificantNumber` has already sufficient length
+      var nationalNumberDummyDigits = nationalSignificantNumber.replace(/\d/g, DUMMY_DIGIT);
+
+      // If `this.nationalSignificantNumber` has already sufficient length
       // to satisfy the `pattern` completely then use it
       // instead of `digits`.
-
       if (strictPattern.test(nationalNumberDummyDigits)) {
         digits = nationalNumberDummyDigits;
       }
       var numberFormat = this.getFormatFormat(format, international);
-      var nationalPrefixIncludedInTemplate; // If a user did input a national prefix (and that's guaranteed),
+      var nationalPrefixIncludedInTemplate;
+
+      // If a user did input a national prefix (and that's guaranteed),
       // and if a `format` does have a national prefix formatting rule,
       // then see if that national prefix formatting rule
       // prepends exactly the same national prefix the user has input.
       // If that's the case, then use the `format` with the national prefix formatting rule.
       // Otherwise, use  the `format` without the national prefix formatting rule,
       // and prepend a national prefix manually to it.
-
       if (this.shouldTryNationalPrefixFormattingRule(format, {
         international: international,
         nationalPrefix: nationalPrefix
       })) {
-        var numberFormatWithNationalPrefix = numberFormat.replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule()); // If `national_prefix_formatting_rule` of a `format` simply prepends
+        var numberFormatWithNationalPrefix = numberFormat.replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule());
+        // If `national_prefix_formatting_rule` of a `format` simply prepends
         // national prefix at the start of a national (significant) number,
         // then such formatting can be used with `AsYouType` formatter.
         // There seems to be no `else` case: everywhere in metadata,
         // national prefix formatting rule is national prefix + $1,
         // or `($1)`, in which case such format isn't even considered
         // when the user has input a national prefix.
-
         /* istanbul ignore else */
-
         if (parseDigits(format.nationalPrefixFormattingRule()) === (nationalPrefix || '') + parseDigits('$1')) {
           numberFormat = numberFormatWithNationalPrefix;
-          nationalPrefixIncludedInTemplate = true; // Replace all digits of the national prefix in the formatting template
+          nationalPrefixIncludedInTemplate = true;
+          // Replace all digits of the national prefix in the formatting template
           // with `DIGIT_PLACEHOLDER`s.
-
           if (nationalPrefix) {
             var i = nationalPrefix.length;
             while (i > 0) {
@@ -671,19 +704,23 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
             }
           }
         }
-      } // Generate formatting template for this phone number format.
+      }
+
+      // Generate formatting template for this phone number format.
+      var template = digits
+      // Format the dummy phone number according to the format.
+      .replace(new RegExp(pattern), numberFormat)
+      // Replace each dummy digit with a DIGIT_PLACEHOLDER.
+      .replace(new RegExp(DUMMY_DIGIT, 'g'), DIGIT_PLACEHOLDER);
 
-      var template = digits // Format the dummy phone number according to the format.
-      .replace(new RegExp(pattern), numberFormat) // Replace each dummy digit with a DIGIT_PLACEHOLDER.
-      .replace(new RegExp(DUMMY_DIGIT, 'g'), DIGIT_PLACEHOLDER); // If a prefix of a national (significant) number is not as simple
+      // If a prefix of a national (significant) number is not as simple
       // as just a basic national prefix, then just prepend such prefix
       // before the national (significant) number, optionally spacing
       // the two with a whitespace.
-
       if (!nationalPrefixIncludedInTemplate) {
-        if (complexPrefixBeforeNationalSignificantNumber) {
+        if (prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix) {
           // Prepend the prefix to the template manually.
-          template = repeat(DIGIT_PLACEHOLDER, complexPrefixBeforeNationalSignificantNumber.length) + ' ' + template;
+          template = repeat(DIGIT_PLACEHOLDER, prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix.length) + ' ' + template;
         } else if (nationalPrefix) {
           // Prepend national prefix to the template manually.
           template = repeat(DIGIT_PLACEHOLDER, nationalPrefix.length) + this.getSeparatorAfterNationalPrefix(format) + template;
@@ -704,9 +741,12 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
         return;
       }
       this.populatedNationalNumberTemplate = result[0];
-      this.populatedNationalNumberTemplatePosition = result[1]; // Return the formatted phone number so far.
+      this.populatedNationalNumberTemplatePosition = result[1];
+
+      // Return the formatted phone number so far.
+      return cutAndStripNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1);
 
-      return cutAndStripNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1); // The old way which was good for `input-format` but is not so good
+      // The old way which was good for `input-format` but is not so good
       // for `react-phone-number-input`'s default input (`InputBasic`).
       // return closeNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1)
       // 	.replace(new RegExp(DIGIT_PLACEHOLDER, 'g'), ' ')
@@ -727,7 +767,6 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       }
     }
   }]);
-  return AsYouTypeFormatter;
 }();
 
 export { DIGIT_PLACEHOLDER, AsYouTypeFormatter as default };