pixel-react 1.15.11 → 1.15.13

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

@@ -6,102 +6,84 @@ import { FIRST_GROUP_PATTERN } from './helpers/formatNationalNumberUsingFormat.j
 import { VALID_PUNCTUATION } from './constants.js';
 import applyInternationalSeparatorStyle from './helpers/applyInternationalSeparatorStyle.js';
 
-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;
+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;
     return function () {
-      return o >= r.length ? {
+      if (i >= o.length) return {
         done: true
-      } : {
+      };
+      return {
         done: false,
-        value: r[o++]
+        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.");
 }
-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;
-  }
+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(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 _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;
 }
-function _classCallCheck(a, n) {
-  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
 }
-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 _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 _createClass(e, r, t) {
-  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", {
     writable: false
-  }), e;
-}
-function _toPropertyKey(t) {
-  var i = _toPrimitive(t, "string");
-  return "symbol" == _typeof(i) ? i : i + "";
+  });
+  return Constructor;
 }
-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);
-}
-
-// 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
+
+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);
 
-// A set of characters that, if found in a national prefix formatting rules, are an indicator to
+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
 // us that we should separate the national prefix from the number when formatting.
-var NATIONAL_PREFIX_SEPARATORS_PATTERN = /[- ]/;
 
-// A pattern that is used to match character classes in regular expressions.
+var NATIONAL_PREFIX_SEPARATORS_PATTERN = /[- ]/; // Deprecated: Google has removed some formatting pattern related code from their repo.
 // 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.
@@ -135,15 +117,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) {
@@ -153,7 +135,7 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
     this.metadata = metadata;
     this.resetFormat();
   }
-  return _createClass(AsYouTypeFormatter, [{
+  _createClass(AsYouTypeFormatter, [{
     key: "resetFormat",
     value: function resetFormat() {
       this.chosenFormat = undefined;
@@ -177,7 +159,6 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
         this.matchingFormats = [];
       }
     }
-
     /**
      * Formats an updated phone number.
      * @param  {string} nextDigits — Additional phone number digits.
@@ -188,6 +169,7 @@ 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.
@@ -202,10 +184,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, state.country, this.metadata)) {
+      if (canFormatCompleteNumber(state.nationalSignificantNumber, 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, {
@@ -219,28 +201,25 @@ 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.
+      return this.formatNationalNumberWithNextDigits(nextDigits, state);
+    } // Formats the next phone number digits.
   }, {
     key: "formatNationalNumberWithNextDigits",
     value: function formatNationalNumberWithNextDigits(nextDigits, state) {
-      var previouslyChosenFormat = this.chosenFormat;
+      var previouslyChosenFormat = this.chosenFormat; // Choose a format from the list of matching ones.
 
-      // Choose a format from the list of matching ones.
       var newlyChosenFormat = this.chooseFormat(state);
       if (newlyChosenFormat) {
         if (newlyChosenFormat === previouslyChosenFormat) {
@@ -264,35 +243,32 @@ 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();
       }
@@ -314,12 +290,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;
       }
@@ -328,24 +304,19 @@ 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
+      leadingDigitsPatternIndex = Math.min(leadingDigitsPatternIndex, leadingDigitsPatternsCount - 1);
+      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.
       //
@@ -370,6 +341,7 @@ 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
@@ -379,7 +351,8 @@ 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
@@ -387,14 +360,13 @@ 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);
     }
   }, {
@@ -407,65 +379,67 @@ 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 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;
+        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";
+      };
+
       // When there are multiple available formats, the formatter uses the first
       // format where a formatting template could be created.
       //
@@ -480,11 +454,12 @@ 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;) {
-        _ret = _loop();
-        if (_ret === 0) break;
-        if (_ret === 1) continue;
+        var _ret = _loop();
+        if (_ret === "break") break;
+        if (_ret === "continue") continue;
       }
       if (!this.chosenFormat) {
         // No format matches the national (significant) phone number.
@@ -498,14 +473,15 @@ 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;
@@ -521,17 +497,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 '';
     }
   }, {
@@ -552,10 +528,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, {
@@ -571,22 +547,21 @@ 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.
@@ -600,19 +575,15 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       var nationalSignificantNumber = _ref4.nationalSignificantNumber,
         international = _ref4.international,
         nationalPrefix = _ref4.nationalPrefix,
-        prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix = _ref4.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix;
+        complexPrefixBeforeNationalSignificantNumber = _ref4.complexPrefixBeforeNationalSignificantNumber;
       var pattern = format.pattern();
-
       /* 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,
@@ -620,17 +591,14 @@ 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];
 
-      // If the national number entered is too long
+      var digits = LONGEST_DUMMY_PHONE_NUMBER.match(pattern)[0]; // 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`
@@ -660,42 +628,41 @@ 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) {
@@ -704,23 +671,19 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
             }
           }
         }
-      }
-
-      // 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);
+      } // Generate formatting template for this phone number format.
 
-      // If a prefix of a national (significant) number is not as simple
+      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
       // 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 (prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix) {
+        if (complexPrefixBeforeNationalSignificantNumber) {
           // Prepend the prefix to the template manually.
-          template = repeat(DIGIT_PLACEHOLDER, prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix.length) + ' ' + template;
+          template = repeat(DIGIT_PLACEHOLDER, complexPrefixBeforeNationalSignificantNumber.length) + ' ' + template;
         } else if (nationalPrefix) {
           // Prepend national prefix to the template manually.
           template = repeat(DIGIT_PLACEHOLDER, nationalPrefix.length) + this.getSeparatorAfterNationalPrefix(format) + template;
@@ -741,12 +704,9 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
         return;
       }
       this.populatedNationalNumberTemplate = result[0];
-      this.populatedNationalNumberTemplatePosition = result[1];
-
-      // Return the formatted phone number so far.
-      return cutAndStripNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1);
+      this.populatedNationalNumberTemplatePosition = result[1]; // Return the formatted phone number so far.
 
-      // The old way which was good for `input-format` but is not so good
+      return cutAndStripNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1); // 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'), ' ')
@@ -767,6 +727,7 @@ var AsYouTypeFormatter = /*#__PURE__*/function () {
       }
     }
   }]);
+  return AsYouTypeFormatter;
 }();
 
 export { DIGIT_PLACEHOLDER, AsYouTypeFormatter as default };