pixel-react 1.15.13 → 1.15.15

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

@@ -5,82 +5,96 @@ import stripIddPrefix from './helpers/stripIddPrefix.js';
 import parseDigits from './helpers/parseDigits.js';
 import { VALID_PUNCTUATION, VALID_DIGITS, PLUS_CHARS } from './constants.js';
 
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+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 _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(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 _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 {
+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 _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;
     try {
-      if (!_n && _i["return"] != null) _i["return"]();
+      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;
     } finally {
-      if (_d) throw _e;
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
     }
+    return a;
   }
-  return _arr;
 }
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
 }
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
+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);
 }
 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) {
@@ -94,19 +108,19 @@ var AsYouTypeParser = /*#__PURE__*/function () {
     this.metadata = metadata;
     this.onNationalSignificantNumberChange = onNationalSignificantNumberChange;
   }
-  _createClass(AsYouTypeParser, [{
+  return _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();
+          state.startInternationalNumber(undefined, undefined);
           if (!digits) {
             justLeadingPlus = true;
           }
@@ -120,6 +134,7 @@ var AsYouTypeParser = /*#__PURE__*/function () {
         justLeadingPlus: justLeadingPlus
       };
     }
+
     /**
      * Inputs "next" phone number digits.
      * @param  {string} digits
@@ -129,9 +144,12 @@ 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.
+      var hasReceivedThreeLeadingDigits = digits.length < 3 && digits.length + nextDigits.length >= 3;
+
+      // Append phone number digits.
+      state.appendDigits(nextDigits);
 
-      state.appendDigits(nextDigits); // Attempt to extract IDD prefix:
+      // 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
@@ -145,7 +163,6 @@ 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);
       }
@@ -155,12 +172,13 @@ 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) {
@@ -175,12 +193,14 @@ 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(), this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),
+      var _extractCountryCallin = extractCountryCallingCode('+' + state.getDigitsWithoutInternationalPrefix(), state.country, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),
         countryCallingCode = _extractCountryCallin.countryCallingCode,
         number = _extractCountryCallin.number;
       if (countryCallingCode) {
@@ -203,6 +223,7 @@ 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`
@@ -226,6 +247,7 @@ 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.
@@ -243,14 +265,13 @@ 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;
       }
@@ -260,41 +281,55 @@ var AsYouTypeParser = /*#__PURE__*/function () {
   }, {
     key: "onExtractedNationalNumber",
     value: function onExtractedNationalNumber(nationalPrefix, carrierCode, nationalSignificantNumber, nationalDigits, setState) {
-      var complexPrefixBeforeNationalSignificantNumber;
-      var nationalSignificantNumberMatchesInput; // This check also works with empty `this.nationalSignificantNumber`.
-
-      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`.
+      // 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;
 
-      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.
+      // 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.
+      // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule
+      var prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix;
 
-        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.
+      // `nationalSignificantNumber` could be empty. In that case, `.lastIndexOf()` still works correctly.
+      var nationalSignificantNumberIndex = nationalDigits.lastIndexOf(nationalSignificantNumber);
 
-        if (prefixBeforeNationalNumber !== nationalPrefix) {
-          complexPrefixBeforeNationalSignificantNumber = prefixBeforeNationalNumber;
+      // 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;
+          }
         }
       }
       setState({
         nationalPrefix: nationalPrefix,
         carrierCode: carrierCode,
         nationalSignificantNumber: nationalSignificantNumber,
-        nationalSignificantNumberMatchesInput: nationalSignificantNumberMatchesInput,
-        complexPrefixBeforeNationalSignificantNumber: complexPrefixBeforeNationalSignificantNumber
-      }); // `onExtractedNationalNumber()` is only called when
+        nationalSignificantNumberIsModified: nationalSignificantNumberIsModified,
+        prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix: prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix
+      });
+      // `onExtractedNationalNumber()` is only called when
       // the national (significant) number actually did change.
-
       this.hasExtractedNationalSignificantNumber = true;
       this.onNationalSignificantNumberChange();
     }
@@ -338,7 +373,8 @@ 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
@@ -352,18 +388,17 @@ 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;
@@ -380,11 +415,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
@@ -403,9 +438,8 @@ var AsYouTypeParser = /*#__PURE__*/function () {
     key: "fixMissingPlus",
     value: function fixMissingPlus(state) {
       if (!state.international) {
-        var _extractCountryCallin2 = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(state.digits, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),
+        var _extractCountryCallin2 = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(state.digits, state.country, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata),
           newCallingCode = _extractCountryCallin2.countryCallingCode;
-          _extractCountryCallin2.number;
         if (newCallingCode) {
           state.update({
             missingPlus: true
@@ -423,8 +457,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();
@@ -447,59 +481,58 @@ 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 = '';
   }