pixel-react 1.15.11 → 1.15.12

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

@@ -5,96 +5,82 @@ import stripIddPrefix from './helpers/stripIddPrefix.js';
 import parseDigits from './helpers/parseDigits.js';
 import { VALID_PUNCTUATION, VALID_DIGITS, PLUS_CHARS } from './constants.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 _slicedToArray(r, e) {
-  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
 function _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.");
 }
-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 _iterableToArrayLimit(r, l) {
-  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-  if (null != t) {
-    var e,
-      n,
-      i,
-      u,
-      a = [],
-      f = true,
-      o = false;
+function _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 (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-    } catch (r) {
-      o = true, n = r;
+      if (!_n && _i["return"] != null) _i["return"]();
     } finally {
-      try {
-        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
-      } finally {
-        if (o) throw n;
-      }
+      if (_d) throw _e;
     }
-    return a;
   }
+  return _arr;
 }
-function _arrayWithHoles(r) {
-  if (Array.isArray(r)) return r;
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
 }
-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 + "";
-}
-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);
+  });
+  return Constructor;
 }
 var VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART = '[' + VALID_PUNCTUATION + VALID_DIGITS + ']+';
 var VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN = new RegExp('^' + VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART + '$', 'i');
 var VALID_FORMATTED_PHONE_NUMBER_PART = '(?:' + '[' + PLUS_CHARS + ']' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']*' + '|' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']+' + ')';
-var AFTER_PHONE_NUMBER_DIGITS_END_PATTERN = new RegExp('[^' + VALID_PUNCTUATION + VALID_DIGITS + ']+' + '.*' + '$');
-
-// Tests whether `national_prefix_for_parsing` could match
+var AFTER_PHONE_NUMBER_DIGITS_END_PATTERN = new RegExp('[^' + VALID_PUNCTUATION + VALID_DIGITS + ']+' + '.*' + '$'); // Tests whether `national_prefix_for_parsing` could match
 // different national prefixes.
 // Matches anything that's not a digit or a square bracket.
+
 var COMPLEX_NATIONAL_PREFIX = /[^\d\[\]]/;
 var AsYouTypeParser = /*#__PURE__*/function () {
   function AsYouTypeParser(_ref) {
@@ -108,19 +94,19 @@ var AsYouTypeParser = /*#__PURE__*/function () {
     this.metadata = metadata;
     this.onNationalSignificantNumberChange = onNationalSignificantNumberChange;
   }
-  return _createClass(AsYouTypeParser, [{
+  _createClass(AsYouTypeParser, [{
     key: "input",
     value: function input(text, state) {
       var _extractFormattedDigi = extractFormattedDigitsAndPlus(text),
         _extractFormattedDigi2 = _slicedToArray(_extractFormattedDigi, 2),
         formattedDigits = _extractFormattedDigi2[0],
         hasPlus = _extractFormattedDigi2[1];
-      var digits = parseDigits(formattedDigits);
-      // Checks for a special case: just a leading `+` has been entered.
+      var digits = parseDigits(formattedDigits); // Checks for a special case: just a leading `+` has been entered.
+
       var justLeadingPlus;
       if (hasPlus) {
         if (!state.digits) {
-          state.startInternationalNumber(undefined, undefined);
+          state.startInternationalNumber();
           if (!digits) {
             justLeadingPlus = true;
           }
@@ -134,7 +120,6 @@ var AsYouTypeParser = /*#__PURE__*/function () {
         justLeadingPlus: justLeadingPlus
       };
     }
-
     /**
      * Inputs "next" phone number digits.
      * @param  {string} digits
@@ -144,12 +129,9 @@ var AsYouTypeParser = /*#__PURE__*/function () {
     key: "inputDigits",
     value: function inputDigits(nextDigits, state) {
       var digits = state.digits;
-      var hasReceivedThreeLeadingDigits = digits.length < 3 && digits.length + nextDigits.length >= 3;
-
-      // Append phone number digits.
-      state.appendDigits(nextDigits);
+      var hasReceivedThreeLeadingDigits = digits.length < 3 && digits.length + nextDigits.length >= 3; // Append phone number digits.
 
-      // Attempt to extract IDD prefix:
+      state.appendDigits(nextDigits); // Attempt to extract IDD prefix:
       // Some users input their phone number in international format,
       // but in an "out-of-country" dialing format instead of using the leading `+`.
       // https://github.com/catamphetamine/libphonenumber-js/issues/185
@@ -163,6 +145,7 @@ var AsYouTypeParser = /*#__PURE__*/function () {
       // and it could even be as long as `14880011`.
       // An IDD prefix is extracted here, and then every time when
       // there's a new digit and the number couldn't be formatted.
+
       if (hasReceivedThreeLeadingDigits) {
         this.extractIddPrefix(state);
       }
@@ -172,13 +155,12 @@ var AsYouTypeParser = /*#__PURE__*/function () {
         }
       } else {
         state.appendNationalSignificantNumberDigits(nextDigits);
-      }
-
-      // If a phone number is being input in international format,
+      } // If a phone number is being input in international format,
       // then it's not valid for it to have a national prefix.
       // Still, some people incorrectly input such numbers with a national prefix.
       // In such cases, only attempt to strip a national prefix if the number becomes too long.
       // (but that is done later, not here)
+
       if (!state.international) {
         if (!this.hasExtractedNationalSignificantNumber) {
           this.extractNationalSignificantNumber(state.getNationalDigits(), function (stateUpdate) {
@@ -193,14 +175,12 @@ var AsYouTypeParser = /*#__PURE__*/function () {
       var international = _ref2.international,
         callingCode = _ref2.callingCode;
       return international && !callingCode;
-    }
-
-    // Extracts a country calling code from a number
+    } // Extracts a country calling code from a number
     // being entered in internatonal format.
   }, {
     key: "extractCountryCallingCode",
     value: function extractCountryCallingCode$1(state) {
-      var _extractCountryCallin = extractCountryCallingCode('+' + state.getDigitsWithoutInternationalPrefix(), state.country, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),
+      var _extractCountryCallin = extractCountryCallingCode('+' + state.getDigitsWithoutInternationalPrefix(), this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),
         countryCallingCode = _extractCountryCallin.countryCallingCode,
         number = _extractCountryCallin.number;
       if (countryCallingCode) {
@@ -223,7 +203,6 @@ var AsYouTypeParser = /*#__PURE__*/function () {
         this.couldPossiblyExtractAnotherNationalSignificantNumber = undefined;
       }
     }
-
     /**
      * Extracts a national (significant) number from user input.
      * Google's library is different in that it only applies `national_prefix_for_parsing`
@@ -247,7 +226,6 @@ var AsYouTypeParser = /*#__PURE__*/function () {
       this.onExtractedNationalNumber(nationalPrefix, carrierCode, nationalNumber, nationalDigits, setState);
       return true;
     }
-
     /**
      * In Google's code this function is called "attempt to extract longer NDD".
      * "Some national prefixes are a substring of others", they say.
@@ -265,13 +243,14 @@ var AsYouTypeParser = /*#__PURE__*/function () {
       var _extractNationalNumbe2 = extractNationalNumberFromPossiblyIncompleteNumber(nationalDigits, this.metadata),
         nationalPrefix = _extractNationalNumbe2.nationalPrefix,
         nationalNumber = _extractNationalNumbe2.nationalNumber,
-        carrierCode = _extractNationalNumbe2.carrierCode;
-      // If a national prefix has been extracted previously,
+        carrierCode = _extractNationalNumbe2.carrierCode; // If a national prefix has been extracted previously,
       // then it's always extracted as additional digits are added.
       // That's assuming `extractNationalNumberFromPossiblyIncompleteNumber()`
       // doesn't do anything different from what it currently does.
       // So, just in case, here's this check, though it doesn't occur.
+
       /* istanbul ignore if */
+
       if (nationalNumber === prevNationalSignificantNumber) {
         return;
       }
@@ -281,55 +260,41 @@ var AsYouTypeParser = /*#__PURE__*/function () {
   }, {
     key: "onExtractedNationalNumber",
     value: function onExtractedNationalNumber(nationalPrefix, carrierCode, nationalSignificantNumber, nationalDigits, setState) {
-      // Tells if the parsed national (significant) number is present as-is in the input string.
-      // For example, when inputting "0343515551212999" Argentinian mobile number,
-      // the parsed national (significant) number is "93435551212999".
-      // There, one can see how it stripped "0" national prefix and prepended a "9",
-      // because that's how it is instructed to do in Argentina's metadata.
-      // So in the described example, the parsed national (significant) number is not present
-      // as-is in the input string. Instead, it's "modified" in the input string.
-      // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule
-      var nationalSignificantNumberIsModified = false;
+      var complexPrefixBeforeNationalSignificantNumber;
+      var nationalSignificantNumberMatchesInput; // This check also works with empty `this.nationalSignificantNumber`.
 
-      // In some countries, a phone number could have a prefix that is not a "national prefix"
-      // but rather some other type of "utility" prefix.
-      // For example, when calling within Australia, one could prepend `1831` prefix to hide
-      // caller's phone number.
+      var nationalSignificantNumberIndex = nationalDigits.lastIndexOf(nationalSignificantNumber); // If the extracted national (significant) number is the
+      // last substring of the `digits`, then it means that it hasn't been altered:
+      // no digits have been removed from the national (significant) number
+      // while applying `national_prefix_transform_rule`.
       // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule
-      var prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix;
 
-      // `nationalSignificantNumber` could be empty. In that case, `.lastIndexOf()` still works correctly.
-      var nationalSignificantNumberIndex = nationalDigits.lastIndexOf(nationalSignificantNumber);
+      if (nationalSignificantNumberIndex >= 0 && nationalSignificantNumberIndex === nationalDigits.length - nationalSignificantNumber.length) {
+        nationalSignificantNumberMatchesInput = true; // If a prefix of a national (significant) number is not as simple
+        // as just a basic national prefix, then such prefix is stored in
+        // `this.complexPrefixBeforeNationalSignificantNumber` property and will be
+        // prepended "as is" to the national (significant) number to produce
+        // a formatted result.
 
-      // If the parsed national (significant) number is the last substring of the `nationalDigits`,
-      // then it means that it's present as-is in the input string.
-      // In any other case, the parsed national (significant) number is "modified" in the input string.
-      if (nationalSignificantNumberIndex < 0 || nationalSignificantNumberIndex !== nationalDigits.length - nationalSignificantNumber.length) {
-        nationalSignificantNumberIsModified = true;
-      } else {
-        var prefixBeforeNationalNumber = nationalDigits.slice(0, nationalSignificantNumberIndex);
-        // When national (significant) number is equal to the `nationalDigits`,
-        // this `onExtractedNationalNumber()` function simply doesn't get called.
-        // This means that at this point, `prefixBeforeNationalNumber` is always non-empty.
-        // Still, added this `if` check just to prevent potential silly bugs.
-        // The `!prefixBeforeNationalNumber` case is not really testable
-        // so this line is exluded from the code coverage.
-        /* istanbul ignore if */
-        if (prefixBeforeNationalNumber) {
-          if (prefixBeforeNationalNumber !== nationalPrefix) {
-            prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix = prefixBeforeNationalNumber;
-          }
+        var prefixBeforeNationalNumber = nationalDigits.slice(0, nationalSignificantNumberIndex); // `prefixBeforeNationalNumber` is always non-empty,
+        // because `onExtractedNationalNumber()` isn't called
+        // when a national (significant) number hasn't been actually "extracted":
+        // when a national (significant) number is equal to the national part of `digits`,
+        // then `onExtractedNationalNumber()` doesn't get called.
+
+        if (prefixBeforeNationalNumber !== nationalPrefix) {
+          complexPrefixBeforeNationalSignificantNumber = prefixBeforeNationalNumber;
         }
       }
       setState({
         nationalPrefix: nationalPrefix,
         carrierCode: carrierCode,
         nationalSignificantNumber: nationalSignificantNumber,
-        nationalSignificantNumberIsModified: nationalSignificantNumberIsModified,
-        prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix: prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix
-      });
-      // `onExtractedNationalNumber()` is only called when
+        nationalSignificantNumberMatchesInput: nationalSignificantNumberMatchesInput,
+        complexPrefixBeforeNationalSignificantNumber: complexPrefixBeforeNationalSignificantNumber
+      }); // `onExtractedNationalNumber()` is only called when
       // the national (significant) number actually did change.
+
       this.hasExtractedNationalSignificantNumber = true;
       this.onNationalSignificantNumberChange();
     }
@@ -373,8 +338,7 @@ var AsYouTypeParser = /*#__PURE__*/function () {
         return state.update(stateUpdate);
       })) {
         return true;
-      }
-      // If no format matches the phone number, then it could be
+      } // If no format matches the phone number, then it could be
       // "a really long IDD" (quote from a comment in Google's library).
       // An IDD prefix is first extracted when the user has entered at least 3 digits,
       // and then here — every time when there's a new digit and the number
@@ -388,17 +352,18 @@ var AsYouTypeParser = /*#__PURE__*/function () {
       // but it's not a big deal, and in most cases there
       // will be a suitable `format` when there're 3 leading digits.
       //
+
       if (this.extractIddPrefix(state)) {
         this.extractCallingCodeAndNationalSignificantNumber(state);
         return true;
-      }
-      // Google's AsYouType formatter supports sort of an "autocorrection" feature
+      } // Google's AsYouType formatter supports sort of an "autocorrection" feature
       // when it "autocorrects" numbers that have been input for a country
       // with that country's calling code.
       // Such "autocorrection" feature looks weird, but different people have been requesting it:
       // https://github.com/catamphetamine/libphonenumber-js/issues/376
       // https://github.com/catamphetamine/libphonenumber-js/issues/375
       // https://github.com/catamphetamine/libphonenumber-js/issues/316
+
       if (this.fixMissingPlus(state)) {
         this.extractCallingCodeAndNationalSignificantNumber(state);
         return true;
@@ -415,11 +380,11 @@ var AsYouTypeParser = /*#__PURE__*/function () {
         state.nationalSignificantNumber;
       if (international || IDDPrefix) {
         return;
-      }
-      // Some users input their phone number in "out-of-country"
+      } // Some users input their phone number in "out-of-country"
       // dialing format instead of using the leading `+`.
       // https://github.com/catamphetamine/libphonenumber-js/issues/185
       // Detect such numbers.
+
       var numberWithoutIDD = stripIddPrefix(digits, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata);
       if (numberWithoutIDD !== undefined && numberWithoutIDD !== digits) {
         // If an IDD prefix was stripped then convert the IDD-prefixed number
@@ -438,8 +403,9 @@ var AsYouTypeParser = /*#__PURE__*/function () {
     key: "fixMissingPlus",
     value: function fixMissingPlus(state) {
       if (!state.international) {
-        var _extractCountryCallin2 = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(state.digits, state.country, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),
+        var _extractCountryCallin2 = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(state.digits, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),
           newCallingCode = _extractCountryCallin2.countryCallingCode;
+          _extractCountryCallin2.number;
         if (newCallingCode) {
           state.update({
             missingPlus: true
@@ -457,8 +423,8 @@ var AsYouTypeParser = /*#__PURE__*/function () {
     value: function startInternationalNumber(state, _ref3) {
       var country = _ref3.country,
         callingCode = _ref3.callingCode;
-      state.startInternationalNumber(country, callingCode);
-      // If a national (significant) number has been extracted before, reset it.
+      state.startInternationalNumber(country, callingCode); // If a national (significant) number has been extracted before, reset it.
+
       if (state.nationalSignificantNumber) {
         state.resetNationalSignificantNumber();
         this.onNationalSignificantNumberChange();
@@ -481,58 +447,59 @@ var AsYouTypeParser = /*#__PURE__*/function () {
       }
     }
   }]);
+  return AsYouTypeParser;
 }();
 function extractFormattedPhoneNumber(text) {
   // Attempt to extract a possible number from the string passed in.
   var startsAt = text.search(VALID_FORMATTED_PHONE_NUMBER_PART);
   if (startsAt < 0) {
     return;
-  }
-  // Trim everything to the left of the phone number.
-  text = text.slice(startsAt);
-  // Trim the `+`.
+  } // Trim everything to the left of the phone number.
+
+  text = text.slice(startsAt); // Trim the `+`.
+
   var hasPlus;
   if (text[0] === '+') {
     hasPlus = true;
     text = text.slice('+'.length);
-  }
-  // Trim everything to the right of the phone number.
-  text = text.replace(AFTER_PHONE_NUMBER_DIGITS_END_PATTERN, '');
-  // Re-add the previously trimmed `+`.
+  } // Trim everything to the right of the phone number.
+
+  text = text.replace(AFTER_PHONE_NUMBER_DIGITS_END_PATTERN, ''); // Re-add the previously trimmed `+`.
+
   if (hasPlus) {
     text = '+' + text;
   }
   return text;
 }
-
 /**
  * Extracts formatted phone number digits (and a `+`) from text (if there're any).
  * @param  {string} text
  * @return {any[]}
  */
+
 function _extractFormattedDigitsAndPlus(text) {
   // Extract a formatted phone number part from text.
-  var extractedNumber = extractFormattedPhoneNumber(text) || '';
-  // Trim a `+`.
+  var extractedNumber = extractFormattedPhoneNumber(text) || ''; // Trim a `+`.
+
   if (extractedNumber[0] === '+') {
     return [extractedNumber.slice('+'.length), true];
   }
   return [extractedNumber];
 }
-
 /**
  * Extracts formatted phone number digits (and a `+`) from text (if there're any).
  * @param  {string} text
  * @return {any[]}
  */
+
 function extractFormattedDigitsAndPlus(text) {
   var _extractFormattedDigi3 = _extractFormattedDigitsAndPlus(text),
     _extractFormattedDigi4 = _slicedToArray(_extractFormattedDigi3, 2),
     formattedDigits = _extractFormattedDigi4[0],
-    hasPlus = _extractFormattedDigi4[1];
-  // If the extracted phone number part
+    hasPlus = _extractFormattedDigi4[1]; // If the extracted phone number part
   // can possibly be a part of some valid phone number
   // then parse phone number characters from a formatted phone number.
+
   if (!VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN.test(formattedDigits)) {
     formattedDigits = '';
   }