pixel-react 1.15.13 → 1.15.15

package/lib/node_modules/libphonenumber-js/es6/helpers/getCountryByNationalNumber.js.map

@@ -1 +1 @@
-{"version":3,"file":"getCountryByNationalNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getCountryByNationalNumber.js"],"sourcesContent":["function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport Metadata from '../metadata.js';\nimport getNumberType from './getNumberType.js';\nexport default function getCountryByNationalNumber(nationalPhoneNumber, _ref) {\n  var countries = _ref.countries,\n      defaultCountry = _ref.defaultCountry,\n      metadata = _ref.metadata;\n  // Re-create `metadata` because it will be selecting a `country`.\n  metadata = new Metadata(metadata); // const matchingCountries = []\n\n  for (var _iterator = _createForOfIteratorHelperLoose(countries), _step; !(_step = _iterator()).done;) {\n    var country = _step.value;\n    metadata.country(country); // \"Leading digits\" patterns are only defined for about 20% of all countries.\n    // By definition, matching \"leading digits\" is a sufficient but not a necessary\n    // condition for a phone number to belong to a country.\n    // The point of \"leading digits\" check is that it's the fastest one to get a match.\n    // https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md#leading_digits\n    // I'd suppose that \"leading digits\" patterns are mutually exclusive for different countries\n    // because of the intended use of that feature.\n\n    if (metadata.leadingDigits()) {\n      if (nationalPhoneNumber && nationalPhoneNumber.search(metadata.leadingDigits()) === 0) {\n        return country;\n      }\n    } // Else perform full validation with all of those\n    // fixed-line/mobile/etc regular expressions.\n    else if (getNumberType({\n      phone: nationalPhoneNumber,\n      country: country\n    }, undefined, metadata.metadata)) {\n      // If both the `defaultCountry` and the \"main\" one match the phone number,\n      // don't prefer the `defaultCountry` over the \"main\" one.\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/154\n      return country; // // If the `defaultCountry` is among the `matchingCountries` then return it.\n      // if (defaultCountry) {\n      // \tif (country === defaultCountry) {\n      // \t\treturn country\n      // \t}\n      // \tmatchingCountries.push(country)\n      // } else {\n      // \treturn country\n      // }\n    }\n  } // // Return the first (\"main\") one of the `matchingCountries`.\n  // if (matchingCountries.length > 0) {\n  // \treturn matchingCountries[0]\n  // }\n\n}\n//# sourceMappingURL=getCountryByNationalNumber.js.map"],"names":["getCountryByNationalNumber","nationalPhoneNumber","_ref","countries","defaultCountry","metadata","Metadata","_iterator","_createForOfIteratorHelperLoose","_step","done","country","value","leadingDigits","search","getNumberType","phone","undefined"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGe,SAASA,0BAATA,CAAoCC,mBAApC,EAAAC,IAAA,EAIZ;AAAA,EAAA,IAHFC,SAGE,GAAAD,IAAA,CAHFC,SAGE;IAAAD,IAAA,CAFFE,cAEE;QADFC,QACE,GAAAH,IAAA,CADFG;AAEA;AACAA,EAAAA,QAAQ,GAAG,IAAIC,QAAJ,CAAaD,QAAb,CAAX,CAFE;;AAMF,EAAA,KAAA,IAAAE,SAAA,GAAAC,+BAAA,CAAsBL,SAAtB,CAAA,EAAAM,KAAA,EAAA,CAAA,CAAAA,KAAA,GAAAF,SAAA,EAAA,EAAAG,IAAA,GAAiC;AAAA,IAAA,IAAtBC,OAAsB,GAAAF,KAAA,CAAAG,KAAA;AAChCP,IAAAA,QAAQ,CAACM,OAAT,CAAiBA,OAAjB,EADgC;AAGhC;AACA;AACA;AACA;AACA;AACA;;AACA,IAAA,IAAIN,QAAQ,CAACQ,aAAT,EAAJ,EAA8B;AAC7B,MAAA,IAAIZ,mBAAmB,IACtBA,mBAAmB,CAACa,MAApB,CAA2BT,QAAQ,CAACQ,aAAT,EAA3B,CAAA,KAAyD,CAD1D,EAC6D;AAC5D,QAAA,OAAOF,OAAP;AACA,MAAA;AACD,IAAA,CALD;AAOA;SACK,IAAII,aAAa,CAAC;AAAEC,MAAAA,KAAK,EAAEf,mBAAT;AAA8BU,MAAAA,OAAO,EAAPA;AAA9B,KAAD,EAA0CM,SAA1C,EAAqDZ,QAAQ,CAACA,QAA9D,CAAjB,EAA0F;AAC9F;AACA;AACA;MACA,OAAOM,OAAP,CAJ8F;AAM9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAA;AACD,EAAA,CAtCC;AAyCF;AACA;AACA;AACA;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"getCountryByNationalNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getCountryByNationalNumber.js"],"sourcesContent":["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 && r && \"number\" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, 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.\"); }\nfunction _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; } }\nfunction _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; }\nimport Metadata from '../metadata.js';\nimport getNumberType from './getNumberType.js';\n\n// Returns the exact country that the `nationalPhoneNumber` belongs to\n// in cases of ambiguity, i.e. when multiple countries share the same \"country calling code\".\nexport default function getCountryByNationalNumber(nationalPhoneNumber, _ref) {\n  var countries = _ref.countries,\n    metadata = _ref.metadata;\n  // Re-create `metadata` because it will be selecting a `country`.\n  metadata = new Metadata(metadata);\n\n  // const matchingCountries = []\n\n  for (var _iterator = _createForOfIteratorHelperLoose(countries), _step; !(_step = _iterator()).done;) {\n    var country = _step.value;\n    metadata.selectNumberingPlan(country);\n    // \"Leading digits\" patterns are only defined for about 20% of all countries.\n    // By definition, matching \"leading digits\" is a sufficient but not a necessary\n    // condition for a phone number to belong to a country.\n    // The point of \"leading digits\" check is that it's the fastest one to get a match.\n    // https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md#leading_digits\n    // I'd suppose that \"leading digits\" patterns are mutually exclusive for different countries\n    // because of the intended use of that feature.\n    if (metadata.leadingDigits()) {\n      if (nationalPhoneNumber && nationalPhoneNumber.search(metadata.leadingDigits()) === 0) {\n        return country;\n      }\n    }\n    // Else perform full validation with all of those\n    // fixed-line/mobile/etc regular expressions.\n    else if (getNumberType({\n      phone: nationalPhoneNumber,\n      country: country\n    }, undefined, metadata.metadata)) {\n      // When multiple countries share the same \"country calling code\",\n      // type patterns aren't guaranteed to be unique among them.\n      // For example, both `US` and `CA` have the same pattern for `toll_free` numbers.\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/103#note_1417147572\n      //\n      // That means that this `if` condition could be `true` for multiple countries from the list.\n      // Currently, it just returns the first one, which is also the \"main\" country for the \"country calling code\".\n      // In an example with `toll_free` numbers above, `\"US\"` would be returned even though\n      // it could as well be `\"CA\"`.\n      //\n      // There was also a time when this attempted to be overly smart\n      // and kept track of all such multiple matching countries\n      // and then picked the one that matched the `defaultCountry`, if provided.\n      // For example, with `toll_free` numbers above, and with `defaultCountry: \"CA\"`,\n      // it would've returned `\"CA\"` instead of `\"US\"`.\n      // Later it turned out that such \"overly smart\" behavior turned out to be just confusing,\n      // so this \"overly smart\" country detection was reverted to returning the \"main\" country\n      // for the \"country calling code\".\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/154\n      //\n      return country;\n      //\n      // The \"overly smart\" behavior code:\n      //\n      // if (defaultCountry) {\n      // \tif (country === defaultCountry) {\n      // \t\treturn country\n      // \t} else {\n      // \t\tmatchingCountries.push(country)\n      // \t}\n      // } else {\n      // \treturn country\n      // }\n    }\n  }\n\n  // // Return the first (\"main\") one of the `matchingCountries`.\n  // if (matchingCountries.length > 0) {\n  // \treturn matchingCountries[0]\n  // }\n}\n//# sourceMappingURL=getCountryByNationalNumber.js.map"],"names":["getCountryByNationalNumber","nationalPhoneNumber","_ref","countries","metadata","Metadata","_iterator","_createForOfIteratorHelperLoose","_step","done","country","value","selectNumberingPlan","leadingDigits","search","getNumberType","phone","undefined"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;AACA;AACe,SAASA,0BAA0BA,CAACC,mBAAmB,EAAAC,IAAA,EAGnE;AAAA,EAAA,IAFFC,SAAS,GAAAD,IAAA,CAATC,SAAS;IACTC,QAAQ,GAAAF,IAAA,CAARE,QAAQ;AAER;AACAA,EAAAA,QAAQ,GAAG,IAAIC,QAAQ,CAACD,QAAQ,CAAC;;AAEjC;;AAEA,EAAA,KAAA,IAAAE,SAAA,GAAAC,+BAAA,CAAsBJ,SAAS,CAAA,EAAAK,KAAA,EAAA,CAAA,CAAAA,KAAA,GAAAF,SAAA,EAAA,EAAAG,IAAA,GAAE;AAAA,IAAA,IAAtBC,OAAO,GAAAF,KAAA,CAAAG,KAAA;AACjBP,IAAAA,QAAQ,CAACQ,mBAAmB,CAACF,OAAO,CAAC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAA,IAAIN,QAAQ,CAACS,aAAa,EAAE,EAAE;AAC7B,MAAA,IAAIZ,mBAAmB,IACtBA,mBAAmB,CAACa,MAAM,CAACV,QAAQ,CAACS,aAAa,EAAE,CAAC,KAAK,CAAC,EAAE;AAC5D,QAAA,OAAOH,OAAO;AACf,MAAA;AACD,IAAA;AACA;AACA;SACK,IAAIK,aAAa,CAAC;AAAEC,MAAAA,KAAK,EAAEf,mBAAmB;AAAES,MAAAA,OAAO,EAAPA;AAAQ,KAAC,EAAEO,SAAS,EAAEb,QAAQ,CAACA,QAAQ,CAAC,EAAE;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAA,OAAOM,OAAO;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACD,IAAA;AACD,EAAA;;AAEA;AACA;AACA;AACA;AACD;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js

@@ -9,10 +9,10 @@ import Metadata from '../metadata.js';
  * region, they will be represented as a regex string that always contains one
  * or more characters that are not ASCII digits or a tilde.
  */
+var SINGLE_IDD_PREFIX_REG_EXP = /^[\d]+(?:[~\u2053\u223C\uFF5E][\d]+)?$/;
 
-var SINGLE_IDD_PREFIX_REG_EXP = /^[\d]+(?:[~\u2053\u223C\uFF5E][\d]+)?$/; // For regions that have multiple IDD prefixes
+// For regions that have multiple IDD prefixes
 // a preferred IDD prefix is returned.
-
 function getIddPrefix(country, callingCode, metadata) {
   var countryMetadata = new Metadata(metadata);
   countryMetadata.selectNumberingPlan(country, callingCode);

package/lib/node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js.map

@@ -1 +1 @@
-{"version":3,"file":"getIddPrefix.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js"],"sourcesContent":["import Metadata from '../metadata.js';\n/**\r\n * Pattern that makes it easy to distinguish whether a region has a single\r\n * international dialing prefix or not. If a region has a single international\r\n * prefix (e.g. 011 in USA), it will be represented as a string that contains\r\n * a sequence of ASCII digits, and possibly a tilde, which signals waiting for\r\n * the tone. If there are multiple available international prefixes in a\r\n * region, they will be represented as a regex string that always contains one\r\n * or more characters that are not ASCII digits or a tilde.\r\n */\n\nvar SINGLE_IDD_PREFIX_REG_EXP = /^[\\d]+(?:[~\\u2053\\u223C\\uFF5E][\\d]+)?$/; // For regions that have multiple IDD prefixes\n// a preferred IDD prefix is returned.\n\nexport default function getIddPrefix(country, callingCode, metadata) {\n  var countryMetadata = new Metadata(metadata);\n  countryMetadata.selectNumberingPlan(country, callingCode);\n\n  if (countryMetadata.defaultIDDPrefix()) {\n    return countryMetadata.defaultIDDPrefix();\n  }\n\n  if (SINGLE_IDD_PREFIX_REG_EXP.test(countryMetadata.IDDPrefix())) {\n    return countryMetadata.IDDPrefix();\n  }\n}\n//# sourceMappingURL=getIddPrefix.js.map"],"names":["SINGLE_IDD_PREFIX_REG_EXP","getIddPrefix","country","callingCode","metadata","countryMetadata","Metadata","selectNumberingPlan","defaultIDDPrefix","test","IDDPrefix"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,IAAMA,yBAAyB,GAAG,wCAAlC;AAGA;;AACe,SAASC,YAATA,CAAsBC,OAAtB,EAA+BC,WAA/B,EAA4CC,QAA5C,EAAsD;AACpE,EAAA,IAAMC,eAAe,GAAG,IAAIC,QAAJ,CAAaF,QAAb,CAAxB;AACAC,EAAAA,eAAe,CAACE,mBAAhB,CAAoCL,OAApC,EAA6CC,WAA7C,CAAA;AACA,EAAA,IAAIE,eAAe,CAACG,gBAAhB,EAAJ,EAAwC;IACvC,OAAOH,eAAe,CAACG,gBAAhB,EAAP;AACA,EAAA;EACD,IAAIR,yBAAyB,CAACS,IAA1B,CAA+BJ,eAAe,CAACK,SAAhB,EAA/B,CAAJ,EAAiE;IAChE,OAAOL,eAAe,CAACK,SAAhB,EAAP;AACA,EAAA;AACD;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"getIddPrefix.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js"],"sourcesContent":["import Metadata from '../metadata.js';\n\n/**\r\n * Pattern that makes it easy to distinguish whether a region has a single\r\n * international dialing prefix or not. If a region has a single international\r\n * prefix (e.g. 011 in USA), it will be represented as a string that contains\r\n * a sequence of ASCII digits, and possibly a tilde, which signals waiting for\r\n * the tone. If there are multiple available international prefixes in a\r\n * region, they will be represented as a regex string that always contains one\r\n * or more characters that are not ASCII digits or a tilde.\r\n */\nvar SINGLE_IDD_PREFIX_REG_EXP = /^[\\d]+(?:[~\\u2053\\u223C\\uFF5E][\\d]+)?$/;\n\n// For regions that have multiple IDD prefixes\n// a preferred IDD prefix is returned.\nexport default function getIddPrefix(country, callingCode, metadata) {\n  var countryMetadata = new Metadata(metadata);\n  countryMetadata.selectNumberingPlan(country, callingCode);\n  if (countryMetadata.defaultIDDPrefix()) {\n    return countryMetadata.defaultIDDPrefix();\n  }\n  if (SINGLE_IDD_PREFIX_REG_EXP.test(countryMetadata.IDDPrefix())) {\n    return countryMetadata.IDDPrefix();\n  }\n}\n//# sourceMappingURL=getIddPrefix.js.map"],"names":["SINGLE_IDD_PREFIX_REG_EXP","getIddPrefix","country","callingCode","metadata","countryMetadata","Metadata","selectNumberingPlan","defaultIDDPrefix","test","IDDPrefix"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMA,yBAAyB,GAAG,wCAAwC;;AAE1E;AACA;AACe,SAASC,YAAYA,CAACC,OAAO,EAAEC,WAAW,EAAEC,QAAQ,EAAE;AACpE,EAAA,IAAMC,eAAe,GAAG,IAAIC,QAAQ,CAACF,QAAQ,CAAC;AAC9CC,EAAAA,eAAe,CAACE,mBAAmB,CAACL,OAAO,EAAEC,WAAW,CAAC;AACzD,EAAA,IAAIE,eAAe,CAACG,gBAAgB,EAAE,EAAE;AACvC,IAAA,OAAOH,eAAe,CAACG,gBAAgB,EAAE;AAC1C,EAAA;EACA,IAAIR,yBAAyB,CAACS,IAAI,CAACJ,eAAe,CAACK,SAAS,EAAE,CAAC,EAAE;AAChE,IAAA,OAAOL,eAAe,CAACK,SAAS,EAAE;AACnC,EAAA;AACD;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/libphonenumber-js/es6/helpers/getNumberType.js

@@ -1,61 +1,62 @@
 import Metadata from '../metadata.js';
 import matchesEntirely from './matchesEntirely.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 _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;
 }
-var NON_FIXED_LINE_PHONE_TYPES = ['MOBILE', 'PREMIUM_RATE', 'TOLL_FREE', 'SHARED_COST', 'VOIP', 'PERSONAL_NUMBER', 'PAGER', 'UAN', 'VOICEMAIL']; // Finds out national phone number type (fixed line, mobile, etc)
+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;
+}
+var NON_FIXED_LINE_PHONE_TYPES = ['MOBILE', 'PREMIUM_RATE', 'TOLL_FREE', 'SHARED_COST', 'VOIP', 'PERSONAL_NUMBER', 'PAGER', 'UAN', 'VOICEMAIL'];
 
+// Finds out national phone number type (fixed line, mobile, etc)
 function getNumberType(input, options, metadata) {
   // If assigning the `{}` default value is moved to the arguments above,
   // code coverage would decrease for some weird reason.
-  options = options || {}; // When `parse()` returns an empty object — `{}` —
+  options = options || {};
+
+  // When `parse()` returns an empty object — `{}` —
   // that means that the phone number is malformed,
   // so it can't possibly be valid.
-
   if (!input.country && !input.countryCallingCode) {
     return;
   }
   metadata = new Metadata(metadata);
   metadata.selectNumberingPlan(input.country, input.countryCallingCode);
-  var nationalNumber = options.v2 ? input.nationalNumber : input.phone; // The following is copy-pasted from the original function:
+  var nationalNumber = options.v2 ? input.nationalNumber : input.phone;
+
+  // The following is copy-pasted from the original function:
   // https://github.com/googlei18n/libphonenumber/blob/3ea547d4fbaa2d0b67588904dfa5d3f2557c27ff/javascript/i18n/phonenumbers/phonenumberutil.js#L2835
-  // Is this national number even valid for this country
 
+  // Is this national number even valid for this country
   if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern())) {
     return;
-  } // Is it fixed line number
+  }
 
+  // Is it fixed line number
   if (isNumberTypeEqualTo(nationalNumber, 'FIXED_LINE', metadata)) {
     // Because duplicate regular expressions are removed
     // to reduce metadata size, if "mobile" pattern is ""
@@ -63,21 +64,22 @@ function getNumberType(input, options, metadata) {
     //
     if (metadata.type('MOBILE') && metadata.type('MOBILE').pattern() === '') {
       return 'FIXED_LINE_OR_MOBILE';
-    } // `MOBILE` type pattern isn't included if it matched `FIXED_LINE` one.
+    }
+
+    // `MOBILE` type pattern isn't included if it matched `FIXED_LINE` one.
     // For example, for "US" country.
     // Old metadata (< `1.0.18`) had a specific "types" data structure
     // that happened to be `undefined` for `MOBILE` in that case.
     // Newer metadata (>= `1.0.18`) has another data structure that is
     // not `undefined` for `MOBILE` in that case (it's just an empty array).
     // So this `if` is just for backwards compatibility with old metadata.
-
     if (!metadata.type('MOBILE')) {
       return 'FIXED_LINE_OR_MOBILE';
-    } // Check if the number happens to qualify as both fixed line and mobile.
-    // (no such country in the minimal metadata set)
+    }
 
+    // Check if the number happens to qualify as both fixed line and mobile.
+    // (no such country in the minimal metadata set)
     /* istanbul ignore if */
-
     if (isNumberTypeEqualTo(nationalNumber, 'MOBILE', metadata)) {
       return 'FIXED_LINE_OR_MOBILE';
     }
@@ -94,13 +96,13 @@ function isNumberTypeEqualTo(nationalNumber, type, metadata) {
   type = metadata.type(type);
   if (!type || !type.pattern()) {
     return false;
-  } // Check if any possible number lengths are present;
+  }
+  // Check if any possible number lengths are present;
   // if so, we use them to avoid checking
   // the validation pattern if they don't match.
   // If they are absent, this means they match
   // the general description, which we have
   // already checked before a specific number type.
-
   if (type.possibleLengths() && type.possibleLengths().indexOf(nationalNumber.length) < 0) {
     return false;
   }

package/lib/node_modules/libphonenumber-js/es6/helpers/getNumberType.js.map

@@ -1 +1 @@
-{"version":3,"file":"getNumberType.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getNumberType.js"],"sourcesContent":["function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport Metadata from '../metadata.js';\nimport matchesEntirely from './matchesEntirely.js';\nvar NON_FIXED_LINE_PHONE_TYPES = ['MOBILE', 'PREMIUM_RATE', 'TOLL_FREE', 'SHARED_COST', 'VOIP', 'PERSONAL_NUMBER', 'PAGER', 'UAN', 'VOICEMAIL']; // Finds out national phone number type (fixed line, mobile, etc)\n\nexport default function getNumberType(input, options, metadata) {\n  // If assigning the `{}` default value is moved to the arguments above,\n  // code coverage would decrease for some weird reason.\n  options = options || {}; // When `parse()` returns an empty object — `{}` —\n  // that means that the phone number is malformed,\n  // so it can't possibly be valid.\n\n  if (!input.country && !input.countryCallingCode) {\n    return;\n  }\n\n  metadata = new Metadata(metadata);\n  metadata.selectNumberingPlan(input.country, input.countryCallingCode);\n  var nationalNumber = options.v2 ? input.nationalNumber : input.phone; // The following is copy-pasted from the original function:\n  // https://github.com/googlei18n/libphonenumber/blob/3ea547d4fbaa2d0b67588904dfa5d3f2557c27ff/javascript/i18n/phonenumbers/phonenumberutil.js#L2835\n  // Is this national number even valid for this country\n\n  if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern())) {\n    return;\n  } // Is it fixed line number\n\n\n  if (isNumberTypeEqualTo(nationalNumber, 'FIXED_LINE', metadata)) {\n    // Because duplicate regular expressions are removed\n    // to reduce metadata size, if \"mobile\" pattern is \"\"\n    // then it means it was removed due to being a duplicate of the fixed-line pattern.\n    //\n    if (metadata.type('MOBILE') && metadata.type('MOBILE').pattern() === '') {\n      return 'FIXED_LINE_OR_MOBILE';\n    } // `MOBILE` type pattern isn't included if it matched `FIXED_LINE` one.\n    // For example, for \"US\" country.\n    // Old metadata (< `1.0.18`) had a specific \"types\" data structure\n    // that happened to be `undefined` for `MOBILE` in that case.\n    // Newer metadata (>= `1.0.18`) has another data structure that is\n    // not `undefined` for `MOBILE` in that case (it's just an empty array).\n    // So this `if` is just for backwards compatibility with old metadata.\n\n\n    if (!metadata.type('MOBILE')) {\n      return 'FIXED_LINE_OR_MOBILE';\n    } // Check if the number happens to qualify as both fixed line and mobile.\n    // (no such country in the minimal metadata set)\n\n    /* istanbul ignore if */\n\n\n    if (isNumberTypeEqualTo(nationalNumber, 'MOBILE', metadata)) {\n      return 'FIXED_LINE_OR_MOBILE';\n    }\n\n    return 'FIXED_LINE';\n  }\n\n  for (var _iterator = _createForOfIteratorHelperLoose(NON_FIXED_LINE_PHONE_TYPES), _step; !(_step = _iterator()).done;) {\n    var type = _step.value;\n\n    if (isNumberTypeEqualTo(nationalNumber, type, metadata)) {\n      return type;\n    }\n  }\n}\nexport function isNumberTypeEqualTo(nationalNumber, type, metadata) {\n  type = metadata.type(type);\n\n  if (!type || !type.pattern()) {\n    return false;\n  } // Check if any possible number lengths are present;\n  // if so, we use them to avoid checking\n  // the validation pattern if they don't match.\n  // If they are absent, this means they match\n  // the general description, which we have\n  // already checked before a specific number type.\n\n\n  if (type.possibleLengths() && type.possibleLengths().indexOf(nationalNumber.length) < 0) {\n    return false;\n  }\n\n  return matchesEntirely(nationalNumber, type.pattern());\n}\n//# sourceMappingURL=getNumberType.js.map"],"names":["NON_FIXED_LINE_PHONE_TYPES","getNumberType","input","options","metadata","country","countryCallingCode","Metadata","selectNumberingPlan","nationalNumber","v2","phone","matchesEntirely","nationalNumberPattern","isNumberTypeEqualTo","type","pattern","_iterator","_createForOfIteratorHelperLoose","_step","done","value","possibleLengths","indexOf","length"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAMA,0BAA0B,GAAG,CAClC,QADkC,EAElC,cAFkC,EAGlC,WAHkC,EAIlC,aAJkC,EAKlC,MALkC,EAMlC,iBANkC,EAOlC,OAPkC,EAQlC,KARkC,EASlC,WATkC,CAAnC;;AAae,SAASC,aAATA,CAAuBC,KAAvB,EAA8BC,OAA9B,EAAuCC,QAAvC,EACf;AACC;AACA;AACAD,EAAAA,OAAO,GAAGA,OAAO,IAAI,EAArB,CAHD;AAMC;AACA;;EACA,IAAI,CAACD,KAAK,CAACG,OAAP,IAAkB,CAACH,KAAK,CAACI,kBAA7B,EAAiD;AAChD,IAAA;AACA,EAAA;AAEDF,EAAAA,QAAQ,GAAG,IAAIG,QAAJ,CAAaH,QAAb,CAAX;EAEAA,QAAQ,CAACI,mBAAT,CAA6BN,KAAK,CAACG,OAAnC,EAA4CH,KAAK,CAACI,kBAAlD,CAAA;AAEA,EAAA,IAAMG,cAAc,GAAGN,OAAO,CAACO,EAAR,GAAaR,KAAK,CAACO,cAAnB,GAAoCP,KAAK,CAACS,KAAjE,CAhBD;AAmBC;AAEA;;EACA,IAAI,CAACC,eAAe,CAACH,cAAD,EAAiBL,QAAQ,CAACS,qBAAT,EAAjB,CAApB,EAAwE;AACvE,IAAA;AACA,EAAA,CAxBF;;EA2BC,IAAIC,mBAAmB,CAACL,cAAD,EAAiB,YAAjB,EAA+BL,QAA/B,CAAvB,EAAiE;AAChE;AACA;AACA;AACA;AACA,IAAA,IAAIA,QAAQ,CAACW,IAAT,CAAc,QAAd,CAAA,IAA2BX,QAAQ,CAACW,IAAT,CAAc,QAAd,CAAA,CAAwBC,OAAxB,EAAA,KAAsC,EAArE,EAAyE;AACxE,MAAA,OAAO,sBAAP;AACA,IAAA,CAP+D;AAUhE;AACA;AACA;AACA;AACA;AACA;;AACA,IAAA,IAAI,CAACZ,QAAQ,CAACW,IAAT,CAAc,QAAd,CAAL,EAA8B;AAC7B,MAAA,OAAO,sBAAP;AACA,IAAA,CAlB+D;AAqBhE;;AACA;;IACA,IAAID,mBAAmB,CAACL,cAAD,EAAiB,QAAjB,EAA2BL,QAA3B,CAAvB,EAA6D;AAC5D,MAAA,OAAO,sBAAP;AACA,IAAA;AAED,IAAA,OAAO,YAAP;AACA,EAAA;AAED,EAAA,KAAA,IAAAa,SAAA,GAAAC,+BAAA,CAAmBlB,0BAAnB,CAAA,EAAAmB,KAAA,EAAA,CAAA,CAAAA,KAAA,GAAAF,SAAA,EAAA,EAAAG,IAAA,GAA+C;AAAA,IAAA,IAApCL,IAAoC,GAAAI,KAAA,CAAAE,KAAA;IAC9C,IAAIP,mBAAmB,CAACL,cAAD,EAAiBM,IAAjB,EAAuBX,QAAvB,CAAvB,EAAyD;AACxD,MAAA,OAAOW,IAAP;AACA,IAAA;AACD,EAAA;AACD;AAEM,SAASD,mBAATA,CAA6BL,cAA7B,EAA6CM,IAA7C,EAAmDX,QAAnD,EAA6D;AACnEW,EAAAA,IAAI,GAAGX,QAAQ,CAACW,IAAT,CAAcA,IAAd,CAAP;EACA,IAAI,CAACA,IAAD,IAAS,CAACA,IAAI,CAACC,OAAL,EAAd,EAA8B;AAC7B,IAAA,OAAO,KAAP;AACA,EAAA,CAJkE;AAMnE;AACA;AACA;AACA;AACA;;AACA,EAAA,IAAID,IAAI,CAACO,eAAL,EAAA,IACHP,IAAI,CAACO,eAAL,EAAA,CAAuBC,OAAvB,CAA+Bd,cAAc,CAACe,MAA9C,CAAA,GAAwD,CADzD,EAC4D;AAC3D,IAAA,OAAO,KAAP;AACA,EAAA;EACD,OAAOZ,eAAe,CAACH,cAAD,EAAiBM,IAAI,CAACC,OAAL,EAAjB,CAAtB;AACA;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"getNumberType.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getNumberType.js"],"sourcesContent":["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 && r && \"number\" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, 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.\"); }\nfunction _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; } }\nfunction _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; }\nimport Metadata from '../metadata.js';\nimport matchesEntirely from './matchesEntirely.js';\nvar NON_FIXED_LINE_PHONE_TYPES = ['MOBILE', 'PREMIUM_RATE', 'TOLL_FREE', 'SHARED_COST', 'VOIP', 'PERSONAL_NUMBER', 'PAGER', 'UAN', 'VOICEMAIL'];\n\n// Finds out national phone number type (fixed line, mobile, etc)\nexport default function getNumberType(input, options, metadata) {\n  // If assigning the `{}` default value is moved to the arguments above,\n  // code coverage would decrease for some weird reason.\n  options = options || {};\n\n  // When `parse()` returns an empty object — `{}` —\n  // that means that the phone number is malformed,\n  // so it can't possibly be valid.\n  if (!input.country && !input.countryCallingCode) {\n    return;\n  }\n  metadata = new Metadata(metadata);\n  metadata.selectNumberingPlan(input.country, input.countryCallingCode);\n  var nationalNumber = options.v2 ? input.nationalNumber : input.phone;\n\n  // The following is copy-pasted from the original function:\n  // https://github.com/googlei18n/libphonenumber/blob/3ea547d4fbaa2d0b67588904dfa5d3f2557c27ff/javascript/i18n/phonenumbers/phonenumberutil.js#L2835\n\n  // Is this national number even valid for this country\n  if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern())) {\n    return;\n  }\n\n  // Is it fixed line number\n  if (isNumberTypeEqualTo(nationalNumber, 'FIXED_LINE', metadata)) {\n    // Because duplicate regular expressions are removed\n    // to reduce metadata size, if \"mobile\" pattern is \"\"\n    // then it means it was removed due to being a duplicate of the fixed-line pattern.\n    //\n    if (metadata.type('MOBILE') && metadata.type('MOBILE').pattern() === '') {\n      return 'FIXED_LINE_OR_MOBILE';\n    }\n\n    // `MOBILE` type pattern isn't included if it matched `FIXED_LINE` one.\n    // For example, for \"US\" country.\n    // Old metadata (< `1.0.18`) had a specific \"types\" data structure\n    // that happened to be `undefined` for `MOBILE` in that case.\n    // Newer metadata (>= `1.0.18`) has another data structure that is\n    // not `undefined` for `MOBILE` in that case (it's just an empty array).\n    // So this `if` is just for backwards compatibility with old metadata.\n    if (!metadata.type('MOBILE')) {\n      return 'FIXED_LINE_OR_MOBILE';\n    }\n\n    // Check if the number happens to qualify as both fixed line and mobile.\n    // (no such country in the minimal metadata set)\n    /* istanbul ignore if */\n    if (isNumberTypeEqualTo(nationalNumber, 'MOBILE', metadata)) {\n      return 'FIXED_LINE_OR_MOBILE';\n    }\n    return 'FIXED_LINE';\n  }\n  for (var _iterator = _createForOfIteratorHelperLoose(NON_FIXED_LINE_PHONE_TYPES), _step; !(_step = _iterator()).done;) {\n    var type = _step.value;\n    if (isNumberTypeEqualTo(nationalNumber, type, metadata)) {\n      return type;\n    }\n  }\n}\nexport function isNumberTypeEqualTo(nationalNumber, type, metadata) {\n  type = metadata.type(type);\n  if (!type || !type.pattern()) {\n    return false;\n  }\n  // Check if any possible number lengths are present;\n  // if so, we use them to avoid checking\n  // the validation pattern if they don't match.\n  // If they are absent, this means they match\n  // the general description, which we have\n  // already checked before a specific number type.\n  if (type.possibleLengths() && type.possibleLengths().indexOf(nationalNumber.length) < 0) {\n    return false;\n  }\n  return matchesEntirely(nationalNumber, type.pattern());\n}\n//# sourceMappingURL=getNumberType.js.map"],"names":["NON_FIXED_LINE_PHONE_TYPES","getNumberType","input","options","metadata","country","countryCallingCode","Metadata","selectNumberingPlan","nationalNumber","v2","phone","matchesEntirely","nationalNumberPattern","isNumberTypeEqualTo","type","pattern","_iterator","_createForOfIteratorHelperLoose","_step","done","value","possibleLengths","indexOf","length"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAMA,0BAA0B,GAAG,CAClC,QAAQ,EACR,cAAc,EACd,WAAW,EACX,aAAa,EACb,MAAM,EACN,iBAAiB,EACjB,OAAO,EACP,KAAK,EACL,WAAW,CACX;;AAED;AACe,SAASC,aAAaA,CAACC,KAAK,EAAEC,OAAO,EAAEC,QAAQ,EAC9D;AACC;AACA;AACAD,EAAAA,OAAO,GAAGA,OAAO,IAAI,EAAE;;AAEvB;AACA;AACA;EACA,IAAI,CAACD,KAAK,CAACG,OAAO,IAAI,CAACH,KAAK,CAACI,kBAAkB,EAAE;AAChD,IAAA;AACD,EAAA;AAEAF,EAAAA,QAAQ,GAAG,IAAIG,QAAQ,CAACH,QAAQ,CAAC;EAEjCA,QAAQ,CAACI,mBAAmB,CAACN,KAAK,CAACG,OAAO,EAAEH,KAAK,CAACI,kBAAkB,CAAC;AAErE,EAAA,IAAMG,cAAc,GAAGN,OAAO,CAACO,EAAE,GAAGR,KAAK,CAACO,cAAc,GAAGP,KAAK,CAACS,KAAK;;AAEtE;AACA;;AAEA;EACA,IAAI,CAACC,eAAe,CAACH,cAAc,EAAEL,QAAQ,CAACS,qBAAqB,EAAE,CAAC,EAAE;AACvE,IAAA;AACD,EAAA;;AAEA;EACA,IAAIC,mBAAmB,CAACL,cAAc,EAAE,YAAY,EAAEL,QAAQ,CAAC,EAAE;AAChE;AACA;AACA;AACA;AACA,IAAA,IAAIA,QAAQ,CAACW,IAAI,CAAC,QAAQ,CAAC,IAAIX,QAAQ,CAACW,IAAI,CAAC,QAAQ,CAAC,CAACC,OAAO,EAAE,KAAK,EAAE,EAAE;AACxE,MAAA,OAAO,sBAAsB;AAC9B,IAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAA,IAAI,CAACZ,QAAQ,CAACW,IAAI,CAAC,QAAQ,CAAC,EAAE;AAC7B,MAAA,OAAO,sBAAsB;AAC9B,IAAA;;AAEA;AACA;AACA;IACA,IAAID,mBAAmB,CAACL,cAAc,EAAE,QAAQ,EAAEL,QAAQ,CAAC,EAAE;AAC5D,MAAA,OAAO,sBAAsB;AAC9B,IAAA;AAEA,IAAA,OAAO,YAAY;AACpB,EAAA;AAEA,EAAA,KAAA,IAAAa,SAAA,GAAAC,+BAAA,CAAmBlB,0BAA0B,CAAA,EAAAmB,KAAA,EAAA,CAAA,CAAAA,KAAA,GAAAF,SAAA,EAAA,EAAAG,IAAA,GAAE;AAAA,IAAA,IAApCL,IAAI,GAAAI,KAAA,CAAAE,KAAA;IACd,IAAIP,mBAAmB,CAACL,cAAc,EAAEM,IAAI,EAAEX,QAAQ,CAAC,EAAE;AACxD,MAAA,OAAOW,IAAI;AACZ,IAAA;AACD,EAAA;AACD;AAEO,SAASD,mBAAmBA,CAACL,cAAc,EAAEM,IAAI,EAAEX,QAAQ,EAAE;AACnEW,EAAAA,IAAI,GAAGX,QAAQ,CAACW,IAAI,CAACA,IAAI,CAAC;EAC1B,IAAI,CAACA,IAAI,IAAI,CAACA,IAAI,CAACC,OAAO,EAAE,EAAE;AAC7B,IAAA,OAAO,KAAK;AACb,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;EACA,IAAID,IAAI,CAACO,eAAe,EAAE,IACzBP,IAAI,CAACO,eAAe,EAAE,CAACC,OAAO,CAACd,cAAc,CAACe,MAAM,CAAC,GAAG,CAAC,EAAE;AAC3D,IAAA,OAAO,KAAK;AACb,EAAA;EACA,OAAOZ,eAAe,CAACH,cAAc,EAAEM,IAAI,CAACC,OAAO,EAAE,CAAC;AACvD;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/libphonenumber-js/es6/helpers/getPossibleCountriesForNumber.js

@@ -7,7 +7,6 @@ import Metadata from '../metadata.js';
  * @param  {object} metadata — Metadata.
  * @return {string[]} A list of possible countries.
  */
-
 function getPossibleCountriesForNumber(callingCode, nationalNumber, metadata) {
   var _metadata = new Metadata(metadata);
   var possibleCountries = _metadata.getCountryCodesForCallingCode(callingCode);

package/lib/node_modules/libphonenumber-js/es6/helpers/getPossibleCountriesForNumber.js.map

@@ -1 +1 @@
-{"version":3,"file":"getPossibleCountriesForNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getPossibleCountriesForNumber.js"],"sourcesContent":["import Metadata from '../metadata.js';\n/**\r\n * Returns a list of countries that the phone number could potentially belong to.\r\n * @param  {string} callingCode — Calling code.\r\n * @param  {string} nationalNumber — National (significant) number.\r\n * @param  {object} metadata — Metadata.\r\n * @return {string[]} A list of possible countries.\r\n */\n\nexport default function getPossibleCountriesForNumber(callingCode, nationalNumber, metadata) {\n  var _metadata = new Metadata(metadata);\n\n  var possibleCountries = _metadata.getCountryCodesForCallingCode(callingCode);\n\n  if (!possibleCountries) {\n    return [];\n  }\n\n  return possibleCountries.filter(function (country) {\n    return couldNationalNumberBelongToCountry(nationalNumber, country, metadata);\n  });\n}\n\nfunction couldNationalNumberBelongToCountry(nationalNumber, country, metadata) {\n  var _metadata = new Metadata(metadata);\n\n  _metadata.selectNumberingPlan(country);\n\n  if (_metadata.numberingPlan.possibleLengths().indexOf(nationalNumber.length) >= 0) {\n    return true;\n  }\n\n  return false;\n}\n//# sourceMappingURL=getPossibleCountriesForNumber.js.map"],"names":["getPossibleCountriesForNumber","callingCode","nationalNumber","metadata","_metadata","Metadata","possibleCountries","getCountryCodesForCallingCode","filter","country","couldNationalNumberBelongToCountry","selectNumberingPlan","numberingPlan","possibleLengths","indexOf","length"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AACe,SAASA,6BAATA,CAAuCC,WAAvC,EAAoDC,cAApD,EAAoEC,QAApE,EAA8E;AAC5F,EAAA,IAAMC,SAAS,GAAG,IAAIC,QAAJ,CAAaF,QAAb,CAAlB;AACA,EAAA,IAAIG,iBAAiB,GAAGF,SAAS,CAACG,6BAAV,CAAwCN,WAAxC,CAAxB;EACA,IAAI,CAACK,iBAAL,EAAwB;AACvB,IAAA,OAAO,EAAP;AACA,EAAA;AACD,EAAA,OAAOA,iBAAiB,CAACE,MAAlB,CAAyB,UAACC,OAAD,EAAa;AAC5C,IAAA,OAAOC,kCAAkC,CAACR,cAAD,EAAiBO,OAAjB,EAA0BN,QAA1B,CAAzC;AACA,EAAA,CAFM,CAAP;AAGA;AAED,SAASO,kCAATA,CAA4CR,cAA5C,EAA4DO,OAA5D,EAAqEN,QAArE,EAA+E;AAC9E,EAAA,IAAMC,SAAS,GAAG,IAAIC,QAAJ,CAAaF,QAAb,CAAlB;EACAC,SAAS,CAACO,mBAAV,CAA8BF,OAA9B,CAAA;AACA,EAAA,IAAIL,SAAS,CAACQ,aAAV,CAAwBC,eAAxB,EAAA,CAA0CC,OAA1C,CAAkDZ,cAAc,CAACa,MAAjE,CAAA,IAA4E,CAAhF,EAAmF;AAClF,IAAA,OAAO,IAAP;AACA,EAAA;AACD,EAAA,OAAO,KAAP;AACA;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"getPossibleCountriesForNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getPossibleCountriesForNumber.js"],"sourcesContent":["import Metadata from '../metadata.js';\n\n/**\r\n * Returns a list of countries that the phone number could potentially belong to.\r\n * @param  {string} callingCode — Calling code.\r\n * @param  {string} nationalNumber — National (significant) number.\r\n * @param  {object} metadata — Metadata.\r\n * @return {string[]} A list of possible countries.\r\n */\nexport default function getPossibleCountriesForNumber(callingCode, nationalNumber, metadata) {\n  var _metadata = new Metadata(metadata);\n  var possibleCountries = _metadata.getCountryCodesForCallingCode(callingCode);\n  if (!possibleCountries) {\n    return [];\n  }\n  return possibleCountries.filter(function (country) {\n    return couldNationalNumberBelongToCountry(nationalNumber, country, metadata);\n  });\n}\nfunction couldNationalNumberBelongToCountry(nationalNumber, country, metadata) {\n  var _metadata = new Metadata(metadata);\n  _metadata.selectNumberingPlan(country);\n  if (_metadata.numberingPlan.possibleLengths().indexOf(nationalNumber.length) >= 0) {\n    return true;\n  }\n  return false;\n}\n//# sourceMappingURL=getPossibleCountriesForNumber.js.map"],"names":["getPossibleCountriesForNumber","callingCode","nationalNumber","metadata","_metadata","Metadata","possibleCountries","getCountryCodesForCallingCode","filter","country","couldNationalNumberBelongToCountry","selectNumberingPlan","numberingPlan","possibleLengths","indexOf","length"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,6BAA6BA,CAACC,WAAW,EAAEC,cAAc,EAAEC,QAAQ,EAAE;AAC5F,EAAA,IAAMC,SAAS,GAAG,IAAIC,QAAQ,CAACF,QAAQ,CAAC;AACxC,EAAA,IAAIG,iBAAiB,GAAGF,SAAS,CAACG,6BAA6B,CAACN,WAAW,CAAC;EAC5E,IAAI,CAACK,iBAAiB,EAAE;AACvB,IAAA,OAAO,EAAE;AACV,EAAA;AACA,EAAA,OAAOA,iBAAiB,CAACE,MAAM,CAAC,UAACC,OAAO,EAAK;AAC5C,IAAA,OAAOC,kCAAkC,CAACR,cAAc,EAAEO,OAAO,EAAEN,QAAQ,CAAC;AAC7E,EAAA,CAAC,CAAC;AACH;AAEA,SAASO,kCAAkCA,CAACR,cAAc,EAAEO,OAAO,EAAEN,QAAQ,EAAE;AAC9E,EAAA,IAAMC,SAAS,GAAG,IAAIC,QAAQ,CAACF,QAAQ,CAAC;AACxCC,EAAAA,SAAS,CAACO,mBAAmB,CAACF,OAAO,CAAC;AACtC,EAAA,IAAIL,SAAS,CAACQ,aAAa,CAACC,eAAe,EAAE,CAACC,OAAO,CAACZ,cAAc,CAACa,MAAM,CAAC,IAAI,CAAC,EAAE;AAClF,IAAA,OAAO,IAAI;AACZ,EAAA;AACA,EAAA,OAAO,KAAK;AACb;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/libphonenumber-js/es6/helpers/isObject.js.map

@@ -1 +1 @@
-{"version":3,"file":"isObject.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/isObject.js"],"sourcesContent":["var objectConstructor = {}.constructor;\nexport default function isObject(object) {\n  return object !== undefined && object !== null && object.constructor === objectConstructor;\n}\n//# sourceMappingURL=isObject.js.map"],"names":["objectConstructor","constructor","isObject","object","undefined"],"mappings":"AAAA,IAAMA,iBAAiB,GAAG,EAAA,CAAGC,WAA7B;AAEe,SAASC,QAATA,CAAkBC,MAAlB,EAA0B;AACvC,EAAA,OAAOA,MAAM,KAAKC,SAAX,IAAwBD,MAAM,KAAK,IAAnC,IAA2CA,MAAM,CAACF,WAAP,KAAuBD,iBAAzE;AACD;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"isObject.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/isObject.js"],"sourcesContent":["var objectConstructor = {}.constructor;\nexport default function isObject(object) {\n  return object !== undefined && object !== null && object.constructor === objectConstructor;\n}\n//# sourceMappingURL=isObject.js.map"],"names":["objectConstructor","constructor","isObject","object","undefined"],"mappings":"AAAA,IAAMA,iBAAiB,GAAG,EAAE,CAACC,WAAW;AAEzB,SAASC,QAAQA,CAACC,MAAM,EAAE;AACvC,EAAA,OAAOA,MAAM,KAAKC,SAAS,IAAID,MAAM,KAAK,IAAI,IAAIA,MAAM,CAACF,WAAW,KAAKD,iBAAiB;AAC5F;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/libphonenumber-js/es6/helpers/isViablePhoneNumber.js

@@ -1,6 +1,7 @@
 import { MIN_LENGTH_FOR_NSN, VALID_DIGITS, PLUS_CHARS, VALID_PUNCTUATION } from '../constants.js';
 import createExtensionPattern from './extension/createExtensionPattern.js';
 
+//  Regular expression of viable phone numbers. This is location independent.
 //  Checks we have at least three leading digits, and only valid punctuation,
 //  alpha characters and digits in the phone number. Does not include extension
 //  data. The symbol 'x' is allowed here as valid punctuation since it is often
@@ -24,13 +25,14 @@ import createExtensionPattern from './extension/createExtensionPattern.js';
 //   so must be the first in the range" (c) Google devs.
 //  (wtf did they mean by saying that; probably nothing)
 //
-
-var MIN_LENGTH_PHONE_NUMBER_PATTERN = '[' + VALID_DIGITS + ']{' + MIN_LENGTH_FOR_NSN + '}'; //
+var MIN_LENGTH_PHONE_NUMBER_PATTERN = '[' + VALID_DIGITS + ']{' + MIN_LENGTH_FOR_NSN + '}';
+//
 // And this is the second reg-exp:
 // (see MIN_LENGTH_PHONE_NUMBER_PATTERN for a full description of this reg-exp)
 //
+var VALID_PHONE_NUMBER = '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){3,}' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']*';
 
-var VALID_PHONE_NUMBER = '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){3,}' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']*'; // This regular expression isn't present in Google's `libphonenumber`
+// This regular expression isn't present in Google's `libphonenumber`
 // and is only used to determine whether the phone number being input
 // is too short for it to even consider it a "valid" number.
 // This is just a way to differentiate between a really invalid phone
@@ -39,34 +41,36 @@ var VALID_PHONE_NUMBER = '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCT
 // considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this
 // library can provide a more detailed error message — whether it's
 // really "not a number", or is it just a start of a valid phone number.
-
 var VALID_PHONE_NUMBER_START_REG_EXP = new RegExp('^' + '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){1,2}' + '$', 'i');
 var VALID_PHONE_NUMBER_WITH_EXTENSION = VALID_PHONE_NUMBER +
 // Phone number extensions
-'(?:' + createExtensionPattern() + ')?'; // The combined regular expression for valid phone numbers:
-//
+'(?:' + createExtensionPattern() + ')?';
 
+// The combined regular expression for valid phone numbers:
+//
 var VALID_PHONE_NUMBER_PATTERN = new RegExp(
 // Either a short two-digit-only phone number
 '^' + MIN_LENGTH_PHONE_NUMBER_PATTERN + '$' + '|' +
 // Or a longer fully parsed phone number (min 3 characters)
-'^' + VALID_PHONE_NUMBER_WITH_EXTENSION + '$', 'i'); // Checks to see if the string of characters could possibly be a phone number at
+'^' + VALID_PHONE_NUMBER_WITH_EXTENSION + '$', 'i');
+
+// Checks to see if the string of characters could possibly be a phone number at
 // all. At the moment, checks to see that the string begins with at least 2
 // digits, ignoring any punctuation commonly found in phone numbers. This method
 // does not require the number to be normalized in advance - but does assume
 // that leading non-number symbols have been removed, such as by the method
 // `extract_possible_number`.
 //
-
 function isViablePhoneNumber(number) {
   return number.length >= MIN_LENGTH_FOR_NSN && VALID_PHONE_NUMBER_PATTERN.test(number);
-} // This is just a way to differentiate between a really invalid phone
+}
+
+// This is just a way to differentiate between a really invalid phone
 // number like "abcde" and a valid phone number that a user has just
 // started inputting, like "+1" or "1": both these cases would be
 // considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this
 // library can provide a more detailed error message — whether it's
 // really "not a number", or is it just a start of a valid phone number.
-
 function isViablePhoneNumberStart(number) {
   return VALID_PHONE_NUMBER_START_REG_EXP.test(number);
 }

package/lib/node_modules/libphonenumber-js/es6/helpers/isViablePhoneNumber.js.map

@@ -1 +1 @@
-{"version":3,"file":"isViablePhoneNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/isViablePhoneNumber.js"],"sourcesContent":["import { MIN_LENGTH_FOR_NSN, VALID_DIGITS, VALID_PUNCTUATION, PLUS_CHARS } from '../constants.js';\nimport createExtensionPattern from './extension/createExtensionPattern.js'; //  Regular expression of viable phone numbers. This is location independent.\n//  Checks we have at least three leading digits, and only valid punctuation,\n//  alpha characters and digits in the phone number. Does not include extension\n//  data. The symbol 'x' is allowed here as valid punctuation since it is often\n//  used as a placeholder for carrier codes, for example in Brazilian phone\n//  numbers. We also allow multiple '+' characters at the start.\n//\n//  Corresponds to the following:\n//  [digits]{minLengthNsn}|\n//  plus_sign*\n//  (([punctuation]|[star])*[digits]){3,}([punctuation]|[star]|[digits]|[alpha])*\n//\n//  The first reg-ex is to allow short numbers (two digits long) to be parsed if\n//  they are entered as \"15\" etc, but only if there is no punctuation in them.\n//  The second expression restricts the number of digits to three or more, but\n//  then allows them to be in international form, and to have alpha-characters\n//  and punctuation. We split up the two reg-exes here and combine them when\n//  creating the reg-ex VALID_PHONE_NUMBER_PATTERN itself so we can prefix it\n//  with ^ and append $ to each branch.\n//\n//  \"Note VALID_PUNCTUATION starts with a -,\n//   so must be the first in the range\" (c) Google devs.\n//  (wtf did they mean by saying that; probably nothing)\n//\n\nvar MIN_LENGTH_PHONE_NUMBER_PATTERN = '[' + VALID_DIGITS + ']{' + MIN_LENGTH_FOR_NSN + '}'; //\n// And this is the second reg-exp:\n// (see MIN_LENGTH_PHONE_NUMBER_PATTERN for a full description of this reg-exp)\n//\n\nexport var VALID_PHONE_NUMBER = '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){3,}' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']*'; // This regular expression isn't present in Google's `libphonenumber`\n// and is only used to determine whether the phone number being input\n// is too short for it to even consider it a \"valid\" number.\n// This is just a way to differentiate between a really invalid phone\n// number like \"abcde\" and a valid phone number that a user has just\n// started inputting, like \"+1\" or \"1\": both these cases would be\n// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this\n// library can provide a more detailed error message — whether it's\n// really \"not a number\", or is it just a start of a valid phone number.\n\nvar VALID_PHONE_NUMBER_START_REG_EXP = new RegExp('^' + '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){1,2}' + '$', 'i');\nexport var VALID_PHONE_NUMBER_WITH_EXTENSION = VALID_PHONE_NUMBER + // Phone number extensions\n'(?:' + createExtensionPattern() + ')?'; // The combined regular expression for valid phone numbers:\n//\n\nvar VALID_PHONE_NUMBER_PATTERN = new RegExp( // Either a short two-digit-only phone number\n'^' + MIN_LENGTH_PHONE_NUMBER_PATTERN + '$' + '|' + // Or a longer fully parsed phone number (min 3 characters)\n'^' + VALID_PHONE_NUMBER_WITH_EXTENSION + '$', 'i'); // Checks to see if the string of characters could possibly be a phone number at\n// all. At the moment, checks to see that the string begins with at least 2\n// digits, ignoring any punctuation commonly found in phone numbers. This method\n// does not require the number to be normalized in advance - but does assume\n// that leading non-number symbols have been removed, such as by the method\n// `extract_possible_number`.\n//\n\nexport default function isViablePhoneNumber(number) {\n  return number.length >= MIN_LENGTH_FOR_NSN && VALID_PHONE_NUMBER_PATTERN.test(number);\n} // This is just a way to differentiate between a really invalid phone\n// number like \"abcde\" and a valid phone number that a user has just\n// started inputting, like \"+1\" or \"1\": both these cases would be\n// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this\n// library can provide a more detailed error message — whether it's\n// really \"not a number\", or is it just a start of a valid phone number.\n\nexport function isViablePhoneNumberStart(number) {\n  return VALID_PHONE_NUMBER_START_REG_EXP.test(number);\n}\n//# sourceMappingURL=isViablePhoneNumber.js.map"],"names":["MIN_LENGTH_PHONE_NUMBER_PATTERN","VALID_DIGITS","MIN_LENGTH_FOR_NSN","VALID_PHONE_NUMBER","PLUS_CHARS","VALID_PUNCTUATION","VALID_PHONE_NUMBER_START_REG_EXP","RegExp","VALID_PHONE_NUMBER_WITH_EXTENSION","createExtensionPattern","VALID_PHONE_NUMBER_PATTERN","isViablePhoneNumber","number","length","test","isViablePhoneNumberStart"],"mappings":";;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,IAAMA,+BAA+B,GAAG,GAAA,GAAMC,YAAN,GAAqB,IAArB,GAA4BC,kBAA5B,GAAiD,GAAzF;AAEA;AACA;AACA;;AACO,IAAMC,kBAAkB,GAC9B,GAAA,GAAMC,UAAN,GAAmB,QAAnB,GACA,KADA,GAEC,GAFD,GAEOC,iBAFP,GAE2B,IAF3B,GAGC,GAHD,GAGOJ,YAHP,GAGsB,GAHtB,GAIA,OAJA,GAKA,GALA,GAMCI,iBAND,GAOCJ,YAPD,GAQA;AAGD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,IAAMK,gCAAgC,GAAG,IAAIC,MAAJ,CACxC,GAAA,GACA,GADA,GACMH,UADN,GACmB,QADnB,GAEA,KAFA,GAGC,GAHD,GAGOC,iBAHP,GAG2B,IAH3B,GAIC,GAJD,GAIOJ,YAJP,GAIsB,GAJtB,GAKA,QALA,GAMA,GAPwC,EAQvC,GARuC,CAAzC;AAUO,IAAMO,iCAAiC,GAC7CL,kBAAkB;AAClB;AACA,KAFA,GAEQM,sBAAsB,EAF9B,GAEmC;AAGpC;;AACA,IAAMC,0BAA0B,GAAG,IAAIH,MAAJ;AAClC;AACA,GAAA,GACCP,+BADD,GAEA,GAFA,GAGA,GAHA;AAIA;AACA,GALA,GAMCQ,iCAND,GAOA,GATkC,EAUjC,GAViC,CAAnC;AAaA;AACA;AACA;AACA;AACA;AACA;;AACe,SAASG,mBAATA,CAA6BC,MAA7B,EAAqC;EACnD,OAAOA,MAAM,CAACC,MAAP,IAAiBX,kBAAjB,IACNQ,0BAA0B,CAACI,IAA3B,CAAgCF,MAAhC,CADD;AAEA;AAGD;AACA;AACA;AACA;AACA;;AACO,SAASG,wBAATA,CAAkCH,MAAlC,EAA0C;AAChD,EAAA,OAAON,gCAAgC,CAACQ,IAAjC,CAAsCF,MAAtC,CAAP;AACA;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"isViablePhoneNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/isViablePhoneNumber.js"],"sourcesContent":["import { MIN_LENGTH_FOR_NSN, VALID_DIGITS, VALID_PUNCTUATION, PLUS_CHARS } from '../constants.js';\nimport createExtensionPattern from './extension/createExtensionPattern.js';\n\n//  Regular expression of viable phone numbers. This is location independent.\n//  Checks we have at least three leading digits, and only valid punctuation,\n//  alpha characters and digits in the phone number. Does not include extension\n//  data. The symbol 'x' is allowed here as valid punctuation since it is often\n//  used as a placeholder for carrier codes, for example in Brazilian phone\n//  numbers. We also allow multiple '+' characters at the start.\n//\n//  Corresponds to the following:\n//  [digits]{minLengthNsn}|\n//  plus_sign*\n//  (([punctuation]|[star])*[digits]){3,}([punctuation]|[star]|[digits]|[alpha])*\n//\n//  The first reg-ex is to allow short numbers (two digits long) to be parsed if\n//  they are entered as \"15\" etc, but only if there is no punctuation in them.\n//  The second expression restricts the number of digits to three or more, but\n//  then allows them to be in international form, and to have alpha-characters\n//  and punctuation. We split up the two reg-exes here and combine them when\n//  creating the reg-ex VALID_PHONE_NUMBER_PATTERN itself so we can prefix it\n//  with ^ and append $ to each branch.\n//\n//  \"Note VALID_PUNCTUATION starts with a -,\n//   so must be the first in the range\" (c) Google devs.\n//  (wtf did they mean by saying that; probably nothing)\n//\nvar MIN_LENGTH_PHONE_NUMBER_PATTERN = '[' + VALID_DIGITS + ']{' + MIN_LENGTH_FOR_NSN + '}';\n//\n// And this is the second reg-exp:\n// (see MIN_LENGTH_PHONE_NUMBER_PATTERN for a full description of this reg-exp)\n//\nexport var VALID_PHONE_NUMBER = '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){3,}' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']*';\n\n// This regular expression isn't present in Google's `libphonenumber`\n// and is only used to determine whether the phone number being input\n// is too short for it to even consider it a \"valid\" number.\n// This is just a way to differentiate between a really invalid phone\n// number like \"abcde\" and a valid phone number that a user has just\n// started inputting, like \"+1\" or \"1\": both these cases would be\n// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this\n// library can provide a more detailed error message — whether it's\n// really \"not a number\", or is it just a start of a valid phone number.\nvar VALID_PHONE_NUMBER_START_REG_EXP = new RegExp('^' + '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){1,2}' + '$', 'i');\nexport var VALID_PHONE_NUMBER_WITH_EXTENSION = VALID_PHONE_NUMBER +\n// Phone number extensions\n'(?:' + createExtensionPattern() + ')?';\n\n// The combined regular expression for valid phone numbers:\n//\nvar VALID_PHONE_NUMBER_PATTERN = new RegExp(\n// Either a short two-digit-only phone number\n'^' + MIN_LENGTH_PHONE_NUMBER_PATTERN + '$' + '|' +\n// Or a longer fully parsed phone number (min 3 characters)\n'^' + VALID_PHONE_NUMBER_WITH_EXTENSION + '$', 'i');\n\n// Checks to see if the string of characters could possibly be a phone number at\n// all. At the moment, checks to see that the string begins with at least 2\n// digits, ignoring any punctuation commonly found in phone numbers. This method\n// does not require the number to be normalized in advance - but does assume\n// that leading non-number symbols have been removed, such as by the method\n// `extract_possible_number`.\n//\nexport default function isViablePhoneNumber(number) {\n  return number.length >= MIN_LENGTH_FOR_NSN && VALID_PHONE_NUMBER_PATTERN.test(number);\n}\n\n// This is just a way to differentiate between a really invalid phone\n// number like \"abcde\" and a valid phone number that a user has just\n// started inputting, like \"+1\" or \"1\": both these cases would be\n// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this\n// library can provide a more detailed error message — whether it's\n// really \"not a number\", or is it just a start of a valid phone number.\nexport function isViablePhoneNumberStart(number) {\n  return VALID_PHONE_NUMBER_START_REG_EXP.test(number);\n}\n//# sourceMappingURL=isViablePhoneNumber.js.map"],"names":["MIN_LENGTH_PHONE_NUMBER_PATTERN","VALID_DIGITS","MIN_LENGTH_FOR_NSN","VALID_PHONE_NUMBER","PLUS_CHARS","VALID_PUNCTUATION","VALID_PHONE_NUMBER_START_REG_EXP","RegExp","VALID_PHONE_NUMBER_WITH_EXTENSION","createExtensionPattern","VALID_PHONE_NUMBER_PATTERN","isViablePhoneNumber","number","length","test","isViablePhoneNumberStart"],"mappings":";;;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMA,+BAA+B,GAAG,GAAG,GAAGC,YAAY,GAAG,IAAI,GAAGC,kBAAkB,GAAG,GAAG;AAC5F;AACA;AACA;AACA;AACO,IAAMC,kBAAkB,GAC9B,GAAG,GAAGC,UAAU,GAAG,QAAQ,GAC3B,KAAK,GACJ,GAAG,GAAGC,iBAAiB,GAAG,IAAI,GAC9B,GAAG,GAAGJ,YAAY,GAAG,GAAG,GACzB,OAAO,GACP,GAAG,GACFI,iBAAiB,GACjBJ,YAAY,GACb;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMK,gCAAgC,GAAG,IAAIC,MAAM,CAClD,GAAG,GACH,GAAG,GAAGH,UAAU,GAAG,QAAQ,GAC3B,KAAK,GACJ,GAAG,GAAGC,iBAAiB,GAAG,IAAI,GAC9B,GAAG,GAAGJ,YAAY,GAAG,GAAG,GACzB,QAAQ,GACR,GAAG,EACF,GAAG,CAAC;AAEC,IAAMO,iCAAiC,GAC7CL,kBAAkB;AAClB;AACA,KAAK,GAAGM,sBAAsB,EAAE,GAAG;;AAEpC;AACA;AACA,IAAMC,0BAA0B,GAAG,IAAIH,MAAM;AAC5C;AACA,GAAG,GACFP,+BAA+B,GAChC,GAAG,GACH,GAAG;AACH;AACA,GAAG,GACFQ,iCAAiC,GAClC,GAAG,EACF,GAAG,CAAC;;AAEN;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASG,mBAAmBA,CAACC,MAAM,EAAE;EACnD,OAAOA,MAAM,CAACC,MAAM,IAAIX,kBAAkB,IACzCQ,0BAA0B,CAACI,IAAI,CAACF,MAAM,CAAC;AACzC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,wBAAwBA,CAACH,MAAM,EAAE;AAChD,EAAA,OAAON,gCAAgC,CAACQ,IAAI,CAACF,MAAM,CAAC;AACrD;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/libphonenumber-js/es6/helpers/matchesEntirely.js

@@ -3,11 +3,11 @@
  * against the regular expression.
  * @return {boolean}
  */
-function matchesEntirely(text, regular_expression) {
-  // If assigning the `''` default value is moved to the arguments above,
-  // code coverage would decrease for some weird reason.
+function matchesEntirely(text, regularExpressionText) {
+  // If the assigning of the `''` default value is moved to the arguments above,
+  // the code coverage would decrease for some weird reason.
   text = text || '';
-  return new RegExp('^(?:' + regular_expression + ')$').test(text);
+  return new RegExp('^(?:' + regularExpressionText + ')$').test(text);
 }
 
 export { matchesEntirely as default };

package/lib/node_modules/libphonenumber-js/es6/helpers/matchesEntirely.js.map

@@ -1 +1 @@
-{"version":3,"file":"matchesEntirely.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/matchesEntirely.js"],"sourcesContent":["/**\r\n * Checks whether the entire input sequence can be matched\r\n * against the regular expression.\r\n * @return {boolean}\r\n */\nexport default function matchesEntirely(text, regular_expression) {\n  // If assigning the `''` default value is moved to the arguments above,\n  // code coverage would decrease for some weird reason.\n  text = text || '';\n  return new RegExp('^(?:' + regular_expression + ')$').test(text);\n}\n//# sourceMappingURL=matchesEntirely.js.map"],"names":["matchesEntirely","text","regular_expression","RegExp","test"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACe,SAASA,eAATA,CAAyBC,IAAzB,EAA+BC,kBAA/B,EAAmD;AACjE;AACA;EACAD,IAAI,GAAGA,IAAI,IAAI,EAAf;EACA,OAAO,IAAIE,MAAJ,CAAW,MAAA,GAASD,kBAAT,GAA8B,IAAzC,CAAA,CAA+CE,IAA/C,CAAoDH,IAApD,CAAP;AACA;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"matchesEntirely.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/matchesEntirely.js"],"sourcesContent":["/**\r\n * Checks whether the entire input sequence can be matched\r\n * against the regular expression.\r\n * @return {boolean}\r\n */\nexport default function matchesEntirely(text, regularExpressionText) {\n  // If the assigning of the `''` default value is moved to the arguments above,\n  // the code coverage would decrease for some weird reason.\n  text = text || '';\n  return new RegExp('^(?:' + regularExpressionText + ')$').test(text);\n}\n//# sourceMappingURL=matchesEntirely.js.map"],"names":["matchesEntirely","text","regularExpressionText","RegExp","test"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACe,SAASA,eAAeA,CAACC,IAAI,EAAEC,qBAAqB,EAAE;AACpE;AACA;EACAD,IAAI,GAAGA,IAAI,IAAI,EAAE;AACjB,EAAA,OAAO,IAAIE,MAAM,CAAC,MAAM,GAAGD,qBAAqB,GAAG,IAAI,CAAC,CAACE,IAAI,CAACH,IAAI,CAAC;AACpE;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/libphonenumber-js/es6/helpers/parseDigits.js

@@ -1,37 +1,32 @@
-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 _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 _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;
+}
 // These mappings map a character (key) to a specific digit that should
 // replace it for normalization purposes. Non-European digits that
 // may be used in phone numbers are mapped to a European equivalent.
@@ -112,6 +107,7 @@ var DIGITS = {
 function parseDigit(character) {
   return DIGITS[character];
 }
+
 /**
  * Parses phone number digits from a string.
  * Drops all punctuation leaving only digits.
@@ -125,15 +121,14 @@ function parseDigit(character) {
  * // Outputs '8800555'.
  * ```
  */
-
 function parseDigits(string) {
-  var result = ''; // Using `.split('')` here instead of normal `for ... of`
+  var result = '';
+  // Using `.split('')` here instead of normal `for ... of`
   // because the importing application doesn't neccessarily include an ES6 polyfill.
   // The `.split('')` approach discards "exotic" UTF-8 characters
   // (the ones consisting of four bytes) but digits
   // (including non-European ones) don't fall into that range
   // so such "exotic" characters would be discarded anyway.
-
   for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {
     var character = _step.value;
     var digit = parseDigit(character);

package/lib/node_modules/libphonenumber-js/es6/helpers/parseDigits.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseDigits.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/parseDigits.js"],"sourcesContent":["function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\n// These mappings map a character (key) to a specific digit that should\n// replace it for normalization purposes. Non-European digits that\n// may be used in phone numbers are mapped to a European equivalent.\n//\n// E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.\n//\nexport var DIGITS = {\n  '0': '0',\n  '1': '1',\n  '2': '2',\n  '3': '3',\n  '4': '4',\n  '5': '5',\n  '6': '6',\n  '7': '7',\n  '8': '8',\n  '9': '9',\n  \"\\uFF10\": '0',\n  // Fullwidth digit 0\n  \"\\uFF11\": '1',\n  // Fullwidth digit 1\n  \"\\uFF12\": '2',\n  // Fullwidth digit 2\n  \"\\uFF13\": '3',\n  // Fullwidth digit 3\n  \"\\uFF14\": '4',\n  // Fullwidth digit 4\n  \"\\uFF15\": '5',\n  // Fullwidth digit 5\n  \"\\uFF16\": '6',\n  // Fullwidth digit 6\n  \"\\uFF17\": '7',\n  // Fullwidth digit 7\n  \"\\uFF18\": '8',\n  // Fullwidth digit 8\n  \"\\uFF19\": '9',\n  // Fullwidth digit 9\n  \"\\u0660\": '0',\n  // Arabic-indic digit 0\n  \"\\u0661\": '1',\n  // Arabic-indic digit 1\n  \"\\u0662\": '2',\n  // Arabic-indic digit 2\n  \"\\u0663\": '3',\n  // Arabic-indic digit 3\n  \"\\u0664\": '4',\n  // Arabic-indic digit 4\n  \"\\u0665\": '5',\n  // Arabic-indic digit 5\n  \"\\u0666\": '6',\n  // Arabic-indic digit 6\n  \"\\u0667\": '7',\n  // Arabic-indic digit 7\n  \"\\u0668\": '8',\n  // Arabic-indic digit 8\n  \"\\u0669\": '9',\n  // Arabic-indic digit 9\n  \"\\u06F0\": '0',\n  // Eastern-Arabic digit 0\n  \"\\u06F1\": '1',\n  // Eastern-Arabic digit 1\n  \"\\u06F2\": '2',\n  // Eastern-Arabic digit 2\n  \"\\u06F3\": '3',\n  // Eastern-Arabic digit 3\n  \"\\u06F4\": '4',\n  // Eastern-Arabic digit 4\n  \"\\u06F5\": '5',\n  // Eastern-Arabic digit 5\n  \"\\u06F6\": '6',\n  // Eastern-Arabic digit 6\n  \"\\u06F7\": '7',\n  // Eastern-Arabic digit 7\n  \"\\u06F8\": '8',\n  // Eastern-Arabic digit 8\n  \"\\u06F9\": '9' // Eastern-Arabic digit 9\n\n};\nexport function parseDigit(character) {\n  return DIGITS[character];\n}\n/**\r\n * Parses phone number digits from a string.\r\n * Drops all punctuation leaving only digits.\r\n * Also converts wide-ascii and arabic-indic numerals to conventional numerals.\r\n * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.\r\n * @param  {string} string\r\n * @return {string}\r\n * @example\r\n * ```js\r\n * parseDigits('8 (800) 555')\r\n * // Outputs '8800555'.\r\n * ```\r\n */\n\nexport default function parseDigits(string) {\n  var result = ''; // Using `.split('')` here instead of normal `for ... of`\n  // because the importing application doesn't neccessarily include an ES6 polyfill.\n  // The `.split('')` approach discards \"exotic\" UTF-8 characters\n  // (the ones consisting of four bytes) but digits\n  // (including non-European ones) don't fall into that range\n  // so such \"exotic\" characters would be discarded anyway.\n\n  for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {\n    var character = _step.value;\n    var digit = parseDigit(character);\n\n    if (digit) {\n      result += digit;\n    }\n  }\n\n  return result;\n}\n//# sourceMappingURL=parseDigits.js.map"],"names":["DIGITS","parseDigit","character","parseDigits","string","result","_iterator","_createForOfIteratorHelperLoose","split","_step","done","value","digit"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,MAAM,GAAG;AACrB,EAAA,GAAA,EAAK,GADgB;AAErB,EAAA,GAAA,EAAK,GAFgB;AAGrB,EAAA,GAAA,EAAK,GAHgB;AAIrB,EAAA,GAAA,EAAK,GAJgB;AAKrB,EAAA,GAAA,EAAK,GALgB;AAMrB,EAAA,GAAA,EAAK,GANgB;AAOrB,EAAA,GAAA,EAAK,GAPgB;AAQrB,EAAA,GAAA,EAAK,GARgB;AASrB,EAAA,GAAA,EAAK,GATgB;AAUrB,EAAA,GAAA,EAAK,GAVgB;AAWrB,EAAA,QAAA,EAAU,GAXW;AAWN;AACf,EAAA,QAAA,EAAU,GAZW;AAYN;AACf,EAAA,QAAA,EAAU,GAbW;AAaN;AACf,EAAA,QAAA,EAAU,GAdW;AAcN;AACf,EAAA,QAAA,EAAU,GAfW;AAeN;AACf,EAAA,QAAA,EAAU,GAhBW;AAgBN;AACf,EAAA,QAAA,EAAU,GAjBW;AAiBN;AACf,EAAA,QAAA,EAAU,GAlBW;AAkBN;AACf,EAAA,QAAA,EAAU,GAnBW;AAmBN;AACf,EAAA,QAAA,EAAU,GApBW;AAoBN;AACf,EAAA,QAAA,EAAU,GArBW;AAqBN;AACf,EAAA,QAAA,EAAU,GAtBW;AAsBN;AACf,EAAA,QAAA,EAAU,GAvBW;AAuBN;AACf,EAAA,QAAA,EAAU,GAxBW;AAwBN;AACf,EAAA,QAAA,EAAU,GAzBW;AAyBN;AACf,EAAA,QAAA,EAAU,GA1BW;AA0BN;AACf,EAAA,QAAA,EAAU,GA3BW;AA2BN;AACf,EAAA,QAAA,EAAU,GA5BW;AA4BN;AACf,EAAA,QAAA,EAAU,GA7BW;AA6BN;AACf,EAAA,QAAA,EAAU,GA9BW;AA8BN;AACf,EAAA,QAAA,EAAU,GA/BW;AA+BN;AACf,EAAA,QAAA,EAAU,GAhCW;AAgCN;AACf,EAAA,QAAA,EAAU,GAjCW;AAiCN;AACf,EAAA,QAAA,EAAU,GAlCW;AAkCN;AACf,EAAA,QAAA,EAAU,GAnCW;AAmCN;AACf,EAAA,QAAA,EAAU,GApCW;AAoCN;AACf,EAAA,QAAA,EAAU,GArCW;AAqCN;AACf,EAAA,QAAA,EAAU,GAtCW;AAsCN;AACf,EAAA,QAAA,EAAU,GAvCW;AAuCN;AACf,EAAA,QAAA,EAAU,GAxCW;AAAA;AA2Cf,SAASC,UAATA,CAAoBC,SAApB,EAA+B;EACrC,OAAOF,MAAM,CAACE,SAAD,CAAb;AACA;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACe,SAASC,WAATA,CAAqBC,MAArB,EAA6B;AAC3C,EAAA,IAAIC,MAAM,GAAG,EAAb,CAD2C;AAG3C;AACA;AACA;AACA;AACA;;AACA,EAAA,KAAA,IAAAC,SAAA,GAAAC,+BAAA,CAAwBH,MAAM,CAACI,KAAP,CAAa,EAAb,CAAxB,CAAA,EAAAC,KAAA,EAAA,CAAA,CAAAA,KAAA,GAAAH,SAAA,EAAA,EAAAI,IAAA,GAA0C;AAAA,IAAA,IAA/BR,SAA+B,GAAAO,KAAA,CAAAE,KAAA;AACzC,IAAA,IAAMC,KAAK,GAAGX,UAAU,CAACC,SAAD,CAAxB;AACA,IAAA,IAAIU,KAAJ,EAAW;AACVP,MAAAA,MAAM,IAAIO,KAAV;AACA,IAAA;AACD,EAAA;AACD,EAAA,OAAOP,MAAP;AACA;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"parseDigits.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/parseDigits.js"],"sourcesContent":["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 && r && \"number\" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, 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.\"); }\nfunction _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; } }\nfunction _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; }\n// These mappings map a character (key) to a specific digit that should\n// replace it for normalization purposes. Non-European digits that\n// may be used in phone numbers are mapped to a European equivalent.\n//\n// E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.\n//\nexport var DIGITS = {\n  '0': '0',\n  '1': '1',\n  '2': '2',\n  '3': '3',\n  '4': '4',\n  '5': '5',\n  '6': '6',\n  '7': '7',\n  '8': '8',\n  '9': '9',\n  \"\\uFF10\": '0',\n  // Fullwidth digit 0\n  \"\\uFF11\": '1',\n  // Fullwidth digit 1\n  \"\\uFF12\": '2',\n  // Fullwidth digit 2\n  \"\\uFF13\": '3',\n  // Fullwidth digit 3\n  \"\\uFF14\": '4',\n  // Fullwidth digit 4\n  \"\\uFF15\": '5',\n  // Fullwidth digit 5\n  \"\\uFF16\": '6',\n  // Fullwidth digit 6\n  \"\\uFF17\": '7',\n  // Fullwidth digit 7\n  \"\\uFF18\": '8',\n  // Fullwidth digit 8\n  \"\\uFF19\": '9',\n  // Fullwidth digit 9\n  \"\\u0660\": '0',\n  // Arabic-indic digit 0\n  \"\\u0661\": '1',\n  // Arabic-indic digit 1\n  \"\\u0662\": '2',\n  // Arabic-indic digit 2\n  \"\\u0663\": '3',\n  // Arabic-indic digit 3\n  \"\\u0664\": '4',\n  // Arabic-indic digit 4\n  \"\\u0665\": '5',\n  // Arabic-indic digit 5\n  \"\\u0666\": '6',\n  // Arabic-indic digit 6\n  \"\\u0667\": '7',\n  // Arabic-indic digit 7\n  \"\\u0668\": '8',\n  // Arabic-indic digit 8\n  \"\\u0669\": '9',\n  // Arabic-indic digit 9\n  \"\\u06F0\": '0',\n  // Eastern-Arabic digit 0\n  \"\\u06F1\": '1',\n  // Eastern-Arabic digit 1\n  \"\\u06F2\": '2',\n  // Eastern-Arabic digit 2\n  \"\\u06F3\": '3',\n  // Eastern-Arabic digit 3\n  \"\\u06F4\": '4',\n  // Eastern-Arabic digit 4\n  \"\\u06F5\": '5',\n  // Eastern-Arabic digit 5\n  \"\\u06F6\": '6',\n  // Eastern-Arabic digit 6\n  \"\\u06F7\": '7',\n  // Eastern-Arabic digit 7\n  \"\\u06F8\": '8',\n  // Eastern-Arabic digit 8\n  \"\\u06F9\": '9' // Eastern-Arabic digit 9\n};\nexport function parseDigit(character) {\n  return DIGITS[character];\n}\n\n/**\r\n * Parses phone number digits from a string.\r\n * Drops all punctuation leaving only digits.\r\n * Also converts wide-ascii and arabic-indic numerals to conventional numerals.\r\n * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.\r\n * @param  {string} string\r\n * @return {string}\r\n * @example\r\n * ```js\r\n * parseDigits('8 (800) 555')\r\n * // Outputs '8800555'.\r\n * ```\r\n */\nexport default function parseDigits(string) {\n  var result = '';\n  // Using `.split('')` here instead of normal `for ... of`\n  // because the importing application doesn't neccessarily include an ES6 polyfill.\n  // The `.split('')` approach discards \"exotic\" UTF-8 characters\n  // (the ones consisting of four bytes) but digits\n  // (including non-European ones) don't fall into that range\n  // so such \"exotic\" characters would be discarded anyway.\n  for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {\n    var character = _step.value;\n    var digit = parseDigit(character);\n    if (digit) {\n      result += digit;\n    }\n  }\n  return result;\n}\n//# sourceMappingURL=parseDigits.js.map"],"names":["DIGITS","parseDigit","character","parseDigits","string","result","_iterator","_createForOfIteratorHelperLoose","split","_step","done","value","digit"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,MAAM,GAAG;AACrB,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,GAAG,EAAE,GAAG;AACR,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;AACf,EAAA,QAAQ,EAAE,GAAG;AAAE;EACf,QAAQ,EAAE,GAAG;AACd;AAEO,SAASC,UAAUA,CAACC,SAAS,EAAE;EACrC,OAAOF,MAAM,CAACE,SAAS,CAAC;AACzB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,WAAWA,CAACC,MAAM,EAAE;EAC3C,IAAIC,MAAM,GAAG,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,KAAA,IAAAC,SAAA,GAAAC,+BAAA,CAAwBH,MAAM,CAACI,KAAK,CAAC,EAAE,CAAC,CAAA,EAAAC,KAAA,EAAA,CAAA,CAAAA,KAAA,GAAAH,SAAA,EAAA,EAAAI,IAAA,GAAE;AAAA,IAAA,IAA/BR,SAAS,GAAAO,KAAA,CAAAE,KAAA;AACnB,IAAA,IAAMC,KAAK,GAAGX,UAAU,CAACC,SAAS,CAAC;AACnC,IAAA,IAAIU,KAAK,EAAE;AACVP,MAAAA,MAAM,IAAIO,KAAK;AAChB,IAAA;AACD,EAAA;AACA,EAAA,OAAOP,MAAM;AACd;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/libphonenumber-js/es6/helpers/stripIddPrefix.js

@@ -5,20 +5,20 @@ var CAPTURING_DIGIT_PATTERN = new RegExp('([' + VALID_DIGITS + '])');
 function stripIddPrefix(number, country, callingCode, metadata) {
   if (!country) {
     return;
-  } // Check if the number is IDD-prefixed.
-
+  }
+  // Check if the number is IDD-prefixed.
   var countryMetadata = new Metadata(metadata);
   countryMetadata.selectNumberingPlan(country, callingCode);
   var IDDPrefixPattern = new RegExp(countryMetadata.IDDPrefix());
   if (number.search(IDDPrefixPattern) !== 0) {
     return;
-  } // Strip IDD prefix.
-
-  number = number.slice(number.match(IDDPrefixPattern)[0].length); // If there're any digits after an IDD prefix,
+  }
+  // Strip IDD prefix.
+  number = number.slice(number.match(IDDPrefixPattern)[0].length);
+  // If there're any digits after an IDD prefix,
   // then those digits are a country calling code.
   // Since no country code starts with a `0`,
   // the code below validates that the next digit (if present) is not `0`.
-
   var matchedGroups = number.match(CAPTURING_DIGIT_PATTERN);
   if (matchedGroups && matchedGroups[1] != null && matchedGroups[1].length > 0) {
     if (matchedGroups[1] === '0') {