pixel-react 1.15.11 → 1.15.12

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

@@ -1,7 +1,6 @@
 import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber.js';
 import matchesEntirely from './matchesEntirely.js';
 import checkNumberLength from './checkNumberLength.js';
-import getCountryByCallingCode from './getCountryByCallingCode.js';
 
 /**
  * Strips national prefix and carrier code from a complete phone number.
@@ -9,11 +8,11 @@ import getCountryByCallingCode from './getCountryByCallingCode.js';
  * it won't extract national prefix if the resultant number is too short
  * to be a complete number for the selected phone numbering plan.
  * @param  {string} number — Complete phone number digits.
- * @param  {string?} country — Country, if known.
  * @param  {Metadata} metadata — Metadata with a phone numbering plan selected.
  * @return {object} `{ nationalNumber: string, carrierCode: string? }`.
  */
-function extractNationalNumber(number, country, metadata) {
+
+function extractNationalNumber(number, metadata) {
   // Parsing national prefixes and carrier codes
   // is only required for local phone numbers
   // but some people don't understand that
@@ -32,18 +31,10 @@ function extractNationalNumber(number, country, metadata) {
       return {
         nationalNumber: number
       };
-    }
-    // Check the national (significant) number length after extracting national prefix and carrier code.
+    } // Check the national (significant) number length after extracting national prefix and carrier code.
     // Legacy generated metadata (before `1.0.18`) didn't support the "possible lengths" feature.
-    if (metadata.numberingPlan.possibleLengths()) {
-      // If an exact `country` is not specified, attempt to detect it from the assumed national number.
-      if (!country) {
-        country = getCountryByCallingCode(metadata.numberingPlan.callingCode(), {
-          nationalNumber: nationalNumber,
-          metadata: metadata
-        });
-      }
 
+    if (metadata.possibleLengths()) {
       // The number remaining after stripping the national prefix and carrier code
       // should be long enough to have a possible length for the country.
       // Otherwise, don't strip the national prefix and carrier code,
@@ -52,7 +43,7 @@ function extractNationalNumber(number, country, metadata) {
       // https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250
       // It doesn't check for the "possibility" of the original `number`.
       // I guess it's fine not checking that one. It works as is anyway.
-      if (!isPossibleIncompleteNationalNumber(nationalNumber, country, metadata)) {
+      if (!isPossibleIncompleteNationalNumber(nationalNumber, metadata)) {
         // Don't strip the national prefix.
         return {
           nationalNumber: number
@@ -64,9 +55,7 @@ function extractNationalNumber(number, country, metadata) {
     nationalNumber: nationalNumber,
     carrierCode: carrierCode
   };
-}
-
-// In some countries, the same digit could be a national prefix
+} // In some countries, the same digit could be a national prefix
 // or a leading digit of a valid phone number.
 // For example, in Russia, national prefix is `8`,
 // and also `800 555 35 35` is a valid number
@@ -80,13 +69,13 @@ function extractNationalNumber(number, country, metadata) {
 // is not extracted when the original number is "viable" and the
 // resultant number is not, a "viable" national number being the one
 // that matches `national_number_pattern`.
+
 function shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberAfter, metadata) {
   // The equivalent in Google's code is:
   // https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004
   if (matchesEntirely(nationalNumberBefore, metadata.nationalNumberPattern()) && !matchesEntirely(nationalNumberAfter, metadata.nationalNumberPattern())) {
     return false;
-  }
-  // This "is possible" national number (length) check has been commented out
+  } // This "is possible" national number (length) check has been commented out
   // because it's superceded by the (effectively) same check done in the
   // `extractNationalNumber()` function after it calls `shouldHaveExtractedNationalPrefix()`.
   // In other words, why run the same check twice if it could only be run once.
@@ -99,10 +88,11 @@ function shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberA
   // 		return false
   // 	}
   // }
+
   return true;
 }
-function isPossibleIncompleteNationalNumber(nationalNumber, country, metadata) {
-  switch (checkNumberLength(nationalNumber, country, metadata)) {
+function isPossibleIncompleteNationalNumber(nationalNumber, metadata) {
+  switch (checkNumberLength(nationalNumber, metadata)) {
     case 'TOO_SHORT':
     case 'INVALID_LENGTH':
       // This library ignores "local-only" phone numbers (for simplicity).

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

@@ -1 +1 @@
-{"version":3,"file":"extractNationalNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js"],"sourcesContent":["import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport checkNumberLength from './checkNumberLength.js';\nimport getCountryByCallingCode from './getCountryByCallingCode.js';\n\n/**\r\n * Strips national prefix and carrier code from a complete phone number.\r\n * The difference from the non-\"FromCompleteNumber\" function is that\r\n * it won't extract national prefix if the resultant number is too short\r\n * to be a complete number for the selected phone numbering plan.\r\n * @param  {string} number — Complete phone number digits.\r\n * @param  {string?} country — Country, if known.\r\n * @param  {Metadata} metadata — Metadata with a phone numbering plan selected.\r\n * @return {object} `{ nationalNumber: string, carrierCode: string? }`.\r\n */\nexport default function extractNationalNumber(number, country, metadata) {\n  // Parsing national prefixes and carrier codes\n  // is only required for local phone numbers\n  // but some people don't understand that\n  // and sometimes write international phone numbers\n  // with national prefixes (or maybe even carrier codes).\n  // http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html\n  // Google's original library forgives such mistakes\n  // and so does this library, because it has been requested:\n  // https://github.com/catamphetamine/libphonenumber-js/issues/127\n  var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(number, metadata),\n    carrierCode = _extractNationalNumbe.carrierCode,\n    nationalNumber = _extractNationalNumbe.nationalNumber;\n  if (nationalNumber !== number) {\n    if (!shouldHaveExtractedNationalPrefix(number, nationalNumber, metadata)) {\n      // Don't strip the national prefix.\n      return {\n        nationalNumber: number\n      };\n    }\n    // Check the national (significant) number length after extracting national prefix and carrier code.\n    // Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature.\n    if (metadata.numberingPlan.possibleLengths()) {\n      // If an exact `country` is not specified, attempt to detect it from the assumed national number.\n      if (!country) {\n        country = getCountryByCallingCode(metadata.numberingPlan.callingCode(), {\n          nationalNumber: nationalNumber,\n          metadata: metadata\n        });\n      }\n\n      // The number remaining after stripping the national prefix and carrier code\n      // should be long enough to have a possible length for the country.\n      // Otherwise, don't strip the national prefix and carrier code,\n      // since the original number could be a valid number.\n      // This check has been copy-pasted \"as is\" from Google's original library:\n      // https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250\n      // It doesn't check for the \"possibility\" of the original `number`.\n      // I guess it's fine not checking that one. It works as is anyway.\n      if (!isPossibleIncompleteNationalNumber(nationalNumber, country, metadata)) {\n        // Don't strip the national prefix.\n        return {\n          nationalNumber: number\n        };\n      }\n    }\n  }\n  return {\n    nationalNumber: nationalNumber,\n    carrierCode: carrierCode\n  };\n}\n\n// In some countries, the same digit could be a national prefix\n// or a leading digit of a valid phone number.\n// For example, in Russia, national prefix is `8`,\n// and also `800 555 35 35` is a valid number\n// in which `8` is not a national prefix, but the first digit\n// of a national (significant) number.\n// Same's with Belarus:\n// `82004910060` is a valid national (significant) number,\n// but `2004910060` is not.\n// To support such cases (to prevent the code from always stripping\n// national prefix), a condition is imposed: a national prefix\n// is not extracted when the original number is \"viable\" and the\n// resultant number is not, a \"viable\" national number being the one\n// that matches `national_number_pattern`.\nfunction shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberAfter, metadata) {\n  // The equivalent in Google's code is:\n  // https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004\n  if (matchesEntirely(nationalNumberBefore, metadata.nationalNumberPattern()) && !matchesEntirely(nationalNumberAfter, metadata.nationalNumberPattern())) {\n    return false;\n  }\n  // This \"is possible\" national number (length) check has been commented out\n  // because it's superceded by the (effectively) same check done in the\n  // `extractNationalNumber()` function after it calls `shouldHaveExtractedNationalPrefix()`.\n  // In other words, why run the same check twice if it could only be run once.\n  // // Check the national (significant) number length after extracting national prefix and carrier code.\n  // // Fixes a minor \"weird behavior\" bug: https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/57\n  // // (Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature).\n  // if (metadata.possibleLengths()) {\n  // \tif (isPossibleIncompleteNationalNumber(nationalNumberBefore, metadata) &&\n  // \t\t!isPossibleIncompleteNationalNumber(nationalNumberAfter, metadata)) {\n  // \t\treturn false\n  // \t}\n  // }\n  return true;\n}\nfunction isPossibleIncompleteNationalNumber(nationalNumber, country, metadata) {\n  switch (checkNumberLength(nationalNumber, country, metadata)) {\n    case 'TOO_SHORT':\n    case 'INVALID_LENGTH':\n      // This library ignores \"local-only\" phone numbers (for simplicity).\n      // See the readme for more info on what are \"local-only\" phone numbers.\n      // case 'IS_POSSIBLE_LOCAL_ONLY':\n      return false;\n    default:\n      return true;\n  }\n}\n//# sourceMappingURL=extractNationalNumber.js.map"],"names":["extractNationalNumber","number","country","metadata","_extractNationalNumbe","extractNationalNumberFromPossiblyIncompleteNumber","carrierCode","nationalNumber","shouldHaveExtractedNationalPrefix","numberingPlan","possibleLengths","getCountryByCallingCode","callingCode","isPossibleIncompleteNationalNumber","nationalNumberBefore","nationalNumberAfter","matchesEntirely","nationalNumberPattern","checkNumberLength"],"mappings":";;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,qBAAqBA,CAACC,MAAM,EAAEC,OAAO,EAAEC,QAAQ,EAAE;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,IAAAC,qBAAA,GAGIC,iDAAiD,CACpDJ,MAAM,EACNE,QACD,CAAC;IALAG,WAAW,GAAAF,qBAAA,CAAXE,WAAW;IACXC,cAAc,GAAAH,qBAAA,CAAdG,cAAc;EAMf,IAAIA,cAAc,KAAKN,MAAM,EAAE;IAC9B,IAAI,CAACO,iCAAiC,CAACP,MAAM,EAAEM,cAAc,EAAEJ,QAAQ,CAAC,EAAE;AACzE;MACA,OAAO;AAAEI,QAAAA,cAAc,EAAEN;OAAQ;AAClC,IAAA;AACA;AACA;AACA,IAAA,IAAIE,QAAQ,CAACM,aAAa,CAACC,eAAe,EAAE,EAAE;AAC7C;MACA,IAAI,CAACR,OAAO,EAAE;QACbA,OAAO,GAAGS,uBAAuB,CAACR,QAAQ,CAACM,aAAa,CAACG,WAAW,EAAE,EAAE;AACvEL,UAAAA,cAAc,EAAdA,cAAc;AACdJ,UAAAA,QAAQ,EAARA;AACD,SAAC,CAAC;AACH,MAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACA,IAAI,CAACU,kCAAkC,CAACN,cAAc,EAAEL,OAAO,EAAEC,QAAQ,CAAC,EAAE;AAC3E;QACA,OAAO;AAAEI,UAAAA,cAAc,EAAEN;SAAQ;AAClC,MAAA;AACD,IAAA;AACD,EAAA;EAEA,OAAO;AAAEM,IAAAA,cAAc,EAAdA,cAAc;AAAED,IAAAA,WAAW,EAAXA;GAAa;AACvC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASE,iCAAiCA,CAACM,oBAAoB,EAAEC,mBAAmB,EAAEZ,QAAQ,EAAE;AAC/F;AACA;EACA,IAAIa,eAAe,CAACF,oBAAoB,EAAEX,QAAQ,CAACc,qBAAqB,EAAE,CAAC,IAC1E,CAACD,eAAe,CAACD,mBAAmB,EAAEZ,QAAQ,CAACc,qBAAqB,EAAE,CAAC,EAAE;AACzE,IAAA,OAAO,KAAK;AACb,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,OAAO,IAAI;AACZ;AAEA,SAASJ,kCAAkCA,CAACN,cAAc,EAAEL,OAAO,EAAEC,QAAQ,EAAE;AAC9E,EAAA,QAAQe,iBAAiB,CAACX,cAAc,EAAEL,OAAO,EAAEC,QAAQ,CAAC;AAC3D,IAAA,KAAK,WAAW;AAChB,IAAA,KAAK,gBAAgB;AACrB;AACA;AACA;AACC,MAAA,OAAO,KAAK;AACb,IAAA;AACC,MAAA,OAAO,IAAI;AACb;AACD;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"extractNationalNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js"],"sourcesContent":["import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport checkNumberLength from './checkNumberLength.js';\n/**\r\n * Strips national prefix and carrier code from a complete phone number.\r\n * The difference from the non-\"FromCompleteNumber\" function is that\r\n * it won't extract national prefix if the resultant number is too short\r\n * to be a complete number for the selected phone numbering plan.\r\n * @param  {string} number — Complete phone number digits.\r\n * @param  {Metadata} metadata — Metadata with a phone numbering plan selected.\r\n * @return {object} `{ nationalNumber: string, carrierCode: string? }`.\r\n */\n\nexport default function extractNationalNumber(number, metadata) {\n  // Parsing national prefixes and carrier codes\n  // is only required for local phone numbers\n  // but some people don't understand that\n  // and sometimes write international phone numbers\n  // with national prefixes (or maybe even carrier codes).\n  // http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html\n  // Google's original library forgives such mistakes\n  // and so does this library, because it has been requested:\n  // https://github.com/catamphetamine/libphonenumber-js/issues/127\n  var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(number, metadata),\n      carrierCode = _extractNationalNumbe.carrierCode,\n      nationalNumber = _extractNationalNumbe.nationalNumber;\n\n  if (nationalNumber !== number) {\n    if (!shouldHaveExtractedNationalPrefix(number, nationalNumber, metadata)) {\n      // Don't strip the national prefix.\n      return {\n        nationalNumber: number\n      };\n    } // Check the national (significant) number length after extracting national prefix and carrier code.\n    // Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature.\n\n\n    if (metadata.possibleLengths()) {\n      // The number remaining after stripping the national prefix and carrier code\n      // should be long enough to have a possible length for the country.\n      // Otherwise, don't strip the national prefix and carrier code,\n      // since the original number could be a valid number.\n      // This check has been copy-pasted \"as is\" from Google's original library:\n      // https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250\n      // It doesn't check for the \"possibility\" of the original `number`.\n      // I guess it's fine not checking that one. It works as is anyway.\n      if (!isPossibleIncompleteNationalNumber(nationalNumber, metadata)) {\n        // Don't strip the national prefix.\n        return {\n          nationalNumber: number\n        };\n      }\n    }\n  }\n\n  return {\n    nationalNumber: nationalNumber,\n    carrierCode: carrierCode\n  };\n} // In some countries, the same digit could be a national prefix\n// or a leading digit of a valid phone number.\n// For example, in Russia, national prefix is `8`,\n// and also `800 555 35 35` is a valid number\n// in which `8` is not a national prefix, but the first digit\n// of a national (significant) number.\n// Same's with Belarus:\n// `82004910060` is a valid national (significant) number,\n// but `2004910060` is not.\n// To support such cases (to prevent the code from always stripping\n// national prefix), a condition is imposed: a national prefix\n// is not extracted when the original number is \"viable\" and the\n// resultant number is not, a \"viable\" national number being the one\n// that matches `national_number_pattern`.\n\nfunction shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberAfter, metadata) {\n  // The equivalent in Google's code is:\n  // https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004\n  if (matchesEntirely(nationalNumberBefore, metadata.nationalNumberPattern()) && !matchesEntirely(nationalNumberAfter, metadata.nationalNumberPattern())) {\n    return false;\n  } // This \"is possible\" national number (length) check has been commented out\n  // because it's superceded by the (effectively) same check done in the\n  // `extractNationalNumber()` function after it calls `shouldHaveExtractedNationalPrefix()`.\n  // In other words, why run the same check twice if it could only be run once.\n  // // Check the national (significant) number length after extracting national prefix and carrier code.\n  // // Fixes a minor \"weird behavior\" bug: https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/57\n  // // (Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature).\n  // if (metadata.possibleLengths()) {\n  // \tif (isPossibleIncompleteNationalNumber(nationalNumberBefore, metadata) &&\n  // \t\t!isPossibleIncompleteNationalNumber(nationalNumberAfter, metadata)) {\n  // \t\treturn false\n  // \t}\n  // }\n\n\n  return true;\n}\n\nfunction isPossibleIncompleteNationalNumber(nationalNumber, metadata) {\n  switch (checkNumberLength(nationalNumber, metadata)) {\n    case 'TOO_SHORT':\n    case 'INVALID_LENGTH':\n      // This library ignores \"local-only\" phone numbers (for simplicity).\n      // See the readme for more info on what are \"local-only\" phone numbers.\n      // case 'IS_POSSIBLE_LOCAL_ONLY':\n      return false;\n\n    default:\n      return true;\n  }\n}\n//# sourceMappingURL=extractNationalNumber.js.map"],"names":["extractNationalNumber","number","metadata","_extractNationalNumbe","extractNationalNumberFromPossiblyIncompleteNumber","carrierCode","nationalNumber","shouldHaveExtractedNationalPrefix","possibleLengths","isPossibleIncompleteNationalNumber","nationalNumberBefore","nationalNumberAfter","matchesEntirely","nationalNumberPattern","checkNumberLength"],"mappings":";;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACe,SAASA,qBAATA,CAA+BC,MAA/B,EAAuCC,QAAvC,EAAiD;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,IAAAC,qBAAA,GAGIC,iDAAiD,CACpDH,MADoD,EAEpDC,QAFoD,CAHrD;IACCG,WADD,GAAAF,qBAAA,CACCE,WADD;IAECC,cAFD,GAAAH,qBAAA,CAECG,cAFD;EAQA,IAAIA,cAAc,KAAKL,MAAvB,EAA+B;IAC9B,IAAI,CAACM,iCAAiC,CAACN,MAAD,EAASK,cAAT,EAAyBJ,QAAzB,CAAtC,EAA0E;AACzE;MACA,OAAO;AAAEI,QAAAA,cAAc,EAAEL;OAAzB;AACA,IAAA,CAJ6B;AAM9B;;AACA,IAAA,IAAIC,QAAQ,CAACM,eAAT,EAAJ,EAAgC;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAA,IAAI,CAACC,kCAAkC,CAACH,cAAD,EAAiBJ,QAAjB,CAAvC,EAAmE;AAClE;QACA,OAAO;AAAEI,UAAAA,cAAc,EAAEL;SAAzB;AACA,MAAA;AACD,IAAA;AACD,EAAA;EAED,OAAO;AAAEK,IAAAA,cAAc,EAAdA,cAAF;AAAkBD,IAAAA,WAAW,EAAXA;GAAzB;AACA;AAGD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,iCAATA,CAA2CG,oBAA3C,EAAiEC,mBAAjE,EAAsFT,QAAtF,EAAgG;AAC/F;AACA;EACA,IAAIU,eAAe,CAACF,oBAAD,EAAuBR,QAAQ,CAACW,qBAAT,EAAvB,CAAf,IACH,CAACD,eAAe,CAACD,mBAAD,EAAsBT,QAAQ,CAACW,qBAAT,EAAtB,CADjB,EAC0E;AACzE,IAAA,OAAO,KAAP;AACA,EAAA,CAN8F;AAQ/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,EAAA,OAAO,IAAP;AACA;AAED,SAASJ,kCAATA,CAA4CH,cAA5C,EAA4DJ,QAA5D,EAAsE;AACrE,EAAA,QAAQY,iBAAiB,CAACR,cAAD,EAAiBJ,QAAjB,CAAzB;AACC,IAAA,KAAK,WAAL;AACA,IAAA,KAAK,gBAAL;AACA;AACA;AACA;AACC,MAAA,OAAO,KAAP;AACD,IAAA;AACC,MAAA,OAAO,IAAP;AARF;AAUA;;;;","x_google_ignoreList":[0]}

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

@@ -20,8 +20,7 @@ function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {
     var prefixMatch = prefixPattern.exec(number);
     if (prefixMatch) {
       var nationalNumber;
-      var carrierCode;
-      // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule
+      var carrierCode; // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule
       // If a `national_prefix_for_parsing` has any "capturing groups"
       // then it means that the national (significant) number is equal to
       // those "capturing groups" transformed via `national_prefix_transform_rule`,
@@ -37,17 +36,17 @@ function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {
       // It's not possible to tell whether there'll be any "capturing gropus"
       // before the matching process, because a `national_prefix_for_parsing`
       // could exhibit both behaviors.
+
       var capturedGroupsCount = prefixMatch.length - 1;
       var hasCapturedGroups = capturedGroupsCount > 0 && prefixMatch[capturedGroupsCount];
       if (metadata.nationalPrefixTransformRule() && hasCapturedGroups) {
-        nationalNumber = number.replace(prefixPattern, metadata.nationalPrefixTransformRule());
-        // If there's more than one captured group,
+        nationalNumber = number.replace(prefixPattern, metadata.nationalPrefixTransformRule()); // If there's more than one captured group,
         // then carrier code is the second one.
+
         if (capturedGroupsCount > 1) {
           carrierCode = prefixMatch[1];
         }
-      }
-      // If there're no "capturing groups",
+      } // If there're no "capturing groups",
       // or if there're "capturing groups" but no
       // `national_prefix_transform_rule`,
       // then just strip the national prefix from the number,
@@ -60,28 +59,28 @@ function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {
         // For example, if there's a carrier code, it's gonna be a
         // part of `prefixBeforeNationalNumber` too.
         var prefixBeforeNationalNumber = prefixMatch[0];
-        nationalNumber = number.slice(prefixBeforeNationalNumber.length);
-        // If there's at least one captured group,
+        nationalNumber = number.slice(prefixBeforeNationalNumber.length); // If there's at least one captured group,
         // then carrier code is the first one.
+
         if (hasCapturedGroups) {
           carrierCode = prefixMatch[1];
         }
-      }
-      // Tries to guess whether a national prefix was present in the input.
+      } // Tries to guess whether a national prefix was present in the input.
       // This is not something copy-pasted from Google's library:
       // they don't seem to have an equivalent for that.
       // So this isn't an "officially approved" way of doing something like that.
       // But since there seems no other existing method, this library uses it.
+
       var nationalPrefix;
       if (hasCapturedGroups) {
         var possiblePositionOfTheFirstCapturedGroup = number.indexOf(prefixMatch[1]);
-        var possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup);
-        // Example: an Argentinian (AR) phone number `0111523456789`.
+        var possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup); // Example: an Argentinian (AR) phone number `0111523456789`.
         // `prefixMatch[0]` is `01115`, and `$1` is `11`,
         // and the rest of the phone number is `23456789`.
         // The national number is transformed via `9$1` to `91123456789`.
         // National prefix `0` is detected being present at the start.
         // if (possibleNationalPrefix.indexOf(metadata.numberingPlan.nationalPrefix()) === 0) {
+
         if (possibleNationalPrefix === metadata.numberingPlan.nationalPrefix()) {
           nationalPrefix = metadata.numberingPlan.nationalPrefix();
         }

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

@@ -1 +1 @@
-{"version":3,"file":"extractNationalNumberFromPossiblyIncompleteNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js"],"sourcesContent":["/**\r\n * Strips any national prefix (such as 0, 1) present in a\r\n * (possibly incomplete) number provided.\r\n * \"Carrier codes\" are only used  in Colombia and Brazil,\r\n * and only when dialing within those countries from a mobile phone to a fixed line number.\r\n * Sometimes it won't actually strip national prefix\r\n * and will instead prepend some digits to the `number`:\r\n * for example, when number `2345678` is passed with `VI` country selected,\r\n * it will return `{ number: \"3402345678\" }`, because `340` area code is prepended.\r\n * @param {string} number — National number digits.\r\n * @param {object} metadata — Metadata with country selected.\r\n * @return {object} `{ nationalNumber: string, nationalPrefix: string? carrierCode: string? }`. Even if a national prefix was extracted, it's not necessarily present in the returned object, so don't rely on its presence in the returned object in order to find out whether a national prefix has been extracted or not.\r\n */\nexport default function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {\n  if (number && metadata.numberingPlan.nationalPrefixForParsing()) {\n    // See METADATA.md for the description of\n    // `national_prefix_for_parsing` and `national_prefix_transform_rule`.\n    // Attempt to parse the first digits as a national prefix.\n    var prefixPattern = new RegExp('^(?:' + metadata.numberingPlan.nationalPrefixForParsing() + ')');\n    var prefixMatch = prefixPattern.exec(number);\n    if (prefixMatch) {\n      var nationalNumber;\n      var carrierCode;\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\n      // If a `national_prefix_for_parsing` has any \"capturing groups\"\n      // then it means that the national (significant) number is equal to\n      // those \"capturing groups\" transformed via `national_prefix_transform_rule`,\n      // and nothing could be said about the actual national prefix:\n      // what is it and was it even there.\n      // If a `national_prefix_for_parsing` doesn't have any \"capturing groups\",\n      // then everything it matches is a national prefix.\n      // To determine whether `national_prefix_for_parsing` matched any\n      // \"capturing groups\", the value of the result of calling `.exec()`\n      // is looked at, and if it has non-undefined values where there're\n      // \"capturing groups\" in the regular expression, then it means\n      // that \"capturing groups\" have been matched.\n      // It's not possible to tell whether there'll be any \"capturing gropus\"\n      // before the matching process, because a `national_prefix_for_parsing`\n      // could exhibit both behaviors.\n      var capturedGroupsCount = prefixMatch.length - 1;\n      var hasCapturedGroups = capturedGroupsCount > 0 && prefixMatch[capturedGroupsCount];\n      if (metadata.nationalPrefixTransformRule() && hasCapturedGroups) {\n        nationalNumber = number.replace(prefixPattern, metadata.nationalPrefixTransformRule());\n        // If there's more than one captured group,\n        // then carrier code is the second one.\n        if (capturedGroupsCount > 1) {\n          carrierCode = prefixMatch[1];\n        }\n      }\n      // If there're no \"capturing groups\",\n      // or if there're \"capturing groups\" but no\n      // `national_prefix_transform_rule`,\n      // then just strip the national prefix from the number,\n      // and possibly a carrier code.\n      // Seems like there could be more.\n      else {\n        // `prefixBeforeNationalNumber` is the whole substring matched by\n        // the `national_prefix_for_parsing` regular expression.\n        // There seem to be no guarantees that it's just a national prefix.\n        // For example, if there's a carrier code, it's gonna be a\n        // part of `prefixBeforeNationalNumber` too.\n        var prefixBeforeNationalNumber = prefixMatch[0];\n        nationalNumber = number.slice(prefixBeforeNationalNumber.length);\n        // If there's at least one captured group,\n        // then carrier code is the first one.\n        if (hasCapturedGroups) {\n          carrierCode = prefixMatch[1];\n        }\n      }\n      // Tries to guess whether a national prefix was present in the input.\n      // This is not something copy-pasted from Google's library:\n      // they don't seem to have an equivalent for that.\n      // So this isn't an \"officially approved\" way of doing something like that.\n      // But since there seems no other existing method, this library uses it.\n      var nationalPrefix;\n      if (hasCapturedGroups) {\n        var possiblePositionOfTheFirstCapturedGroup = number.indexOf(prefixMatch[1]);\n        var possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup);\n        // Example: an Argentinian (AR) phone number `0111523456789`.\n        // `prefixMatch[0]` is `01115`, and `$1` is `11`,\n        // and the rest of the phone number is `23456789`.\n        // The national number is transformed via `9$1` to `91123456789`.\n        // National prefix `0` is detected being present at the start.\n        // if (possibleNationalPrefix.indexOf(metadata.numberingPlan.nationalPrefix()) === 0) {\n        if (possibleNationalPrefix === metadata.numberingPlan.nationalPrefix()) {\n          nationalPrefix = metadata.numberingPlan.nationalPrefix();\n        }\n      } else {\n        nationalPrefix = prefixMatch[0];\n      }\n      return {\n        nationalNumber: nationalNumber,\n        nationalPrefix: nationalPrefix,\n        carrierCode: carrierCode\n      };\n    }\n  }\n  return {\n    nationalNumber: number\n  };\n}\n//# sourceMappingURL=extractNationalNumberFromPossiblyIncompleteNumber.js.map"],"names":["extractNationalNumberFromPossiblyIncompleteNumber","number","metadata","numberingPlan","nationalPrefixForParsing","prefixPattern","RegExp","prefixMatch","exec","nationalNumber","carrierCode","capturedGroupsCount","length","hasCapturedGroups","nationalPrefixTransformRule","replace","prefixBeforeNationalNumber","slice","nationalPrefix","possiblePositionOfTheFirstCapturedGroup","indexOf","possibleNationalPrefix"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,iDAAiDA,CAACC,MAAM,EAAEC,QAAQ,EAAE;EAC3F,IAAID,MAAM,IAAIC,QAAQ,CAACC,aAAa,CAACC,wBAAwB,EAAE,EAAE;AAChE;AACA;AACA;AACA,IAAA,IAAMC,aAAa,GAAG,IAAIC,MAAM,CAAC,MAAM,GAAGJ,QAAQ,CAACC,aAAa,CAACC,wBAAwB,EAAE,GAAG,GAAG,CAAC;AAClG,IAAA,IAAMG,WAAW,GAAGF,aAAa,CAACG,IAAI,CAACP,MAAM,CAAC;AAC9C,IAAA,IAAIM,WAAW,EAAE;AAChB,MAAA,IAAIE,cAAc;AAClB,MAAA,IAAIC,WAAW;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAA,IAAMC,mBAAmB,GAAGJ,WAAW,CAACK,MAAM,GAAG,CAAC;MAClD,IAAMC,iBAAiB,GAAGF,mBAAmB,GAAG,CAAC,IAAIJ,WAAW,CAACI,mBAAmB,CAAC;AACrF,MAAA,IAAIT,QAAQ,CAACY,2BAA2B,EAAE,IAAID,iBAAiB,EAAE;AAChEJ,QAAAA,cAAc,GAAGR,MAAM,CAACc,OAAO,CAC9BV,aAAa,EACbH,QAAQ,CAACY,2BAA2B,EACrC,CAAC;AACD;AACA;QACA,IAAIH,mBAAmB,GAAG,CAAC,EAAE;AAC5BD,UAAAA,WAAW,GAAGH,WAAW,CAAC,CAAC,CAAC;AAC7B,QAAA;AACD,MAAA;AACA;AACA;AACA;AACA;AACA;AACA;WACK;AACJ;AACA;AACA;AACA;AACA;AACA,QAAA,IAAMS,0BAA0B,GAAGT,WAAW,CAAC,CAAC,CAAC;QACjDE,cAAc,GAAGR,MAAM,CAACgB,KAAK,CAACD,0BAA0B,CAACJ,MAAM,CAAC;AAChE;AACA;AACA,QAAA,IAAIC,iBAAiB,EAAE;AACtBH,UAAAA,WAAW,GAAGH,WAAW,CAAC,CAAC,CAAC;AAC7B,QAAA;AACD,MAAA;AACA;AACA;AACA;AACA;AACA;AACA,MAAA,IAAIW,cAAc;AAClB,MAAA,IAAIL,iBAAiB,EAAE;QACtB,IAAMM,uCAAuC,GAAGlB,MAAM,CAACmB,OAAO,CAACb,WAAW,CAAC,CAAC,CAAC,CAAC;QAC9E,IAAMc,sBAAsB,GAAGpB,MAAM,CAACgB,KAAK,CAAC,CAAC,EAAEE,uCAAuC,CAAC;AACvF;AACA;AACA;AACA;AACA;AACA;QACA,IAAIE,sBAAsB,KAAKnB,QAAQ,CAACC,aAAa,CAACe,cAAc,EAAE,EAAE;AACvEA,UAAAA,cAAc,GAAGhB,QAAQ,CAACC,aAAa,CAACe,cAAc,EAAE;AACzD,QAAA;AACD,MAAA,CAAC,MAAM;AACNA,QAAAA,cAAc,GAAGX,WAAW,CAAC,CAAC,CAAC;AAChC,MAAA;MACA,OAAO;AACNE,QAAAA,cAAc,EAAdA,cAAc;AACdS,QAAAA,cAAc,EAAdA,cAAc;AACdR,QAAAA,WAAW,EAAXA;OACA;AACF,IAAA;AACD,EAAA;EACE,OAAO;AACND,IAAAA,cAAc,EAAER;GAChB;AACJ;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"extractNationalNumberFromPossiblyIncompleteNumber.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js"],"sourcesContent":["/**\r\n * Strips any national prefix (such as 0, 1) present in a\r\n * (possibly incomplete) number provided.\r\n * \"Carrier codes\" are only used  in Colombia and Brazil,\r\n * and only when dialing within those countries from a mobile phone to a fixed line number.\r\n * Sometimes it won't actually strip national prefix\r\n * and will instead prepend some digits to the `number`:\r\n * for example, when number `2345678` is passed with `VI` country selected,\r\n * it will return `{ number: \"3402345678\" }`, because `340` area code is prepended.\r\n * @param {string} number — National number digits.\r\n * @param {object} metadata — Metadata with country selected.\r\n * @return {object} `{ nationalNumber: string, nationalPrefix: string? carrierCode: string? }`. Even if a national prefix was extracted, it's not necessarily present in the returned object, so don't rely on its presence in the returned object in order to find out whether a national prefix has been extracted or not.\r\n */\nexport default function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {\n  if (number && metadata.numberingPlan.nationalPrefixForParsing()) {\n    // See METADATA.md for the description of\n    // `national_prefix_for_parsing` and `national_prefix_transform_rule`.\n    // Attempt to parse the first digits as a national prefix.\n    var prefixPattern = new RegExp('^(?:' + metadata.numberingPlan.nationalPrefixForParsing() + ')');\n    var prefixMatch = prefixPattern.exec(number);\n\n    if (prefixMatch) {\n      var nationalNumber;\n      var carrierCode; // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\n      // If a `national_prefix_for_parsing` has any \"capturing groups\"\n      // then it means that the national (significant) number is equal to\n      // those \"capturing groups\" transformed via `national_prefix_transform_rule`,\n      // and nothing could be said about the actual national prefix:\n      // what is it and was it even there.\n      // If a `national_prefix_for_parsing` doesn't have any \"capturing groups\",\n      // then everything it matches is a national prefix.\n      // To determine whether `national_prefix_for_parsing` matched any\n      // \"capturing groups\", the value of the result of calling `.exec()`\n      // is looked at, and if it has non-undefined values where there're\n      // \"capturing groups\" in the regular expression, then it means\n      // that \"capturing groups\" have been matched.\n      // It's not possible to tell whether there'll be any \"capturing gropus\"\n      // before the matching process, because a `national_prefix_for_parsing`\n      // could exhibit both behaviors.\n\n      var capturedGroupsCount = prefixMatch.length - 1;\n      var hasCapturedGroups = capturedGroupsCount > 0 && prefixMatch[capturedGroupsCount];\n\n      if (metadata.nationalPrefixTransformRule() && hasCapturedGroups) {\n        nationalNumber = number.replace(prefixPattern, metadata.nationalPrefixTransformRule()); // If there's more than one captured group,\n        // then carrier code is the second one.\n\n        if (capturedGroupsCount > 1) {\n          carrierCode = prefixMatch[1];\n        }\n      } // If there're no \"capturing groups\",\n      // or if there're \"capturing groups\" but no\n      // `national_prefix_transform_rule`,\n      // then just strip the national prefix from the number,\n      // and possibly a carrier code.\n      // Seems like there could be more.\n      else {\n        // `prefixBeforeNationalNumber` is the whole substring matched by\n        // the `national_prefix_for_parsing` regular expression.\n        // There seem to be no guarantees that it's just a national prefix.\n        // For example, if there's a carrier code, it's gonna be a\n        // part of `prefixBeforeNationalNumber` too.\n        var prefixBeforeNationalNumber = prefixMatch[0];\n        nationalNumber = number.slice(prefixBeforeNationalNumber.length); // If there's at least one captured group,\n        // then carrier code is the first one.\n\n        if (hasCapturedGroups) {\n          carrierCode = prefixMatch[1];\n        }\n      } // Tries to guess whether a national prefix was present in the input.\n      // This is not something copy-pasted from Google's library:\n      // they don't seem to have an equivalent for that.\n      // So this isn't an \"officially approved\" way of doing something like that.\n      // But since there seems no other existing method, this library uses it.\n\n\n      var nationalPrefix;\n\n      if (hasCapturedGroups) {\n        var possiblePositionOfTheFirstCapturedGroup = number.indexOf(prefixMatch[1]);\n        var possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup); // Example: an Argentinian (AR) phone number `0111523456789`.\n        // `prefixMatch[0]` is `01115`, and `$1` is `11`,\n        // and the rest of the phone number is `23456789`.\n        // The national number is transformed via `9$1` to `91123456789`.\n        // National prefix `0` is detected being present at the start.\n        // if (possibleNationalPrefix.indexOf(metadata.numberingPlan.nationalPrefix()) === 0) {\n\n        if (possibleNationalPrefix === metadata.numberingPlan.nationalPrefix()) {\n          nationalPrefix = metadata.numberingPlan.nationalPrefix();\n        }\n      } else {\n        nationalPrefix = prefixMatch[0];\n      }\n\n      return {\n        nationalNumber: nationalNumber,\n        nationalPrefix: nationalPrefix,\n        carrierCode: carrierCode\n      };\n    }\n  }\n\n  return {\n    nationalNumber: number\n  };\n}\n//# sourceMappingURL=extractNationalNumberFromPossiblyIncompleteNumber.js.map"],"names":["extractNationalNumberFromPossiblyIncompleteNumber","number","metadata","numberingPlan","nationalPrefixForParsing","prefixPattern","RegExp","prefixMatch","exec","nationalNumber","carrierCode","capturedGroupsCount","length","hasCapturedGroups","nationalPrefixTransformRule","replace","prefixBeforeNationalNumber","slice","nationalPrefix","possiblePositionOfTheFirstCapturedGroup","indexOf","possibleNationalPrefix"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,iDAATA,CAA2DC,MAA3D,EAAmEC,QAAnE,EAA6E;EAC3F,IAAID,MAAM,IAAIC,QAAQ,CAACC,aAAT,CAAuBC,wBAAvB,EAAd,EAAiE;AAChE;AACA;AACA;AACA,IAAA,IAAMC,aAAa,GAAG,IAAIC,MAAJ,CAAW,MAAA,GAASJ,QAAQ,CAACC,aAAT,CAAuBC,wBAAvB,EAAT,GAA6D,GAAxE,CAAtB;AACA,IAAA,IAAMG,WAAW,GAAGF,aAAa,CAACG,IAAd,CAAmBP,MAAnB,CAApB;AACA,IAAA,IAAIM,WAAJ,EAAiB;AAChB,MAAA,IAAIE,cAAJ;MACA,IAAIC,WAAJ,CAFgB;AAIhB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,MAAA,IAAMC,mBAAmB,GAAGJ,WAAW,CAACK,MAAZ,GAAqB,CAAjD;MACA,IAAMC,iBAAiB,GAAGF,mBAAmB,GAAG,CAAtB,IAA2BJ,WAAW,CAACI,mBAAD,CAAhE;AACA,MAAA,IAAIT,QAAQ,CAACY,2BAAT,EAAA,IAA0CD,iBAA9C,EAAiE;AAChEJ,QAAAA,cAAc,GAAGR,MAAM,CAACc,OAAP,CAChBV,aADgB,EAEhBH,QAAQ,CAACY,2BAAT,EAFgB,CAAjB,CADgE;AAMhE;;QACA,IAAIH,mBAAmB,GAAG,CAA1B,EAA6B;AAC5BD,UAAAA,WAAW,GAAGH,WAAW,CAAC,CAAD,CAAzB;AACA,QAAA;AACD,MAAA,CAVD;AAYA;AACA;AACA;AACA;AACA;WACK;AACJ;AACA;AACA;AACA;AACA;AACA,QAAA,IAAMS,0BAA0B,GAAGT,WAAW,CAAC,CAAD,CAA9C;QACAE,cAAc,GAAGR,MAAM,CAACgB,KAAP,CAAaD,0BAA0B,CAACJ,MAAxC,CAAjB,CAPI;AASJ;;AACA,QAAA,IAAIC,iBAAJ,EAAuB;AACtBH,UAAAA,WAAW,GAAGH,WAAW,CAAC,CAAD,CAAzB;AACA,QAAA;AACD,MAAA,CAnDe;AAqDhB;AACA;AACA;AACA;;AACA,MAAA,IAAIW,cAAJ;AACA,MAAA,IAAIL,iBAAJ,EAAuB;QACtB,IAAMM,uCAAuC,GAAGlB,MAAM,CAACmB,OAAP,CAAeb,WAAW,CAAC,CAAD,CAA1B,CAAhD;QACA,IAAMc,sBAAsB,GAAGpB,MAAM,CAACgB,KAAP,CAAa,CAAb,EAAgBE,uCAAhB,CAA/B,CAFsB;AAItB;AACA;AACA;AACA;AACA;;QACA,IAAIE,sBAAsB,KAAKnB,QAAQ,CAACC,aAAT,CAAuBe,cAAvB,EAA/B,EAAwE;AACvEA,UAAAA,cAAc,GAAGhB,QAAQ,CAACC,aAAT,CAAuBe,cAAvB,EAAjB;AACA,QAAA;AACD,MAAA,CAZD,MAYO;AACNA,QAAAA,cAAc,GAAGX,WAAW,CAAC,CAAD,CAA5B;AACA,MAAA;MACD,OAAO;AACNE,QAAAA,cAAc,EAAdA,cADM;AAENS,QAAAA,cAAc,EAAdA,cAFM;AAGNR,QAAAA,WAAW,EAAXA;OAHD;AAKA,IAAA;AACD,EAAA;EACC,OAAO;AACND,IAAAA,cAAc,EAAER;GADjB;AAGF;;;;","x_google_ignoreList":[0]}

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

@@ -5,35 +5,32 @@ import { VALID_DIGITS } from '../constants.js';
 // Example: `"tel:12133734253;phone-context=+1"`.
 // This function parses the full phone number from the local number and the `phone-context`
 // when the `phone-context` contains a `+` sign.
-
 var PLUS_SIGN = '+';
 var RFC3966_VISUAL_SEPARATOR_ = '[\\-\\.\\(\\)]?';
 var RFC3966_PHONE_DIGIT_ = '(' + '[' + VALID_DIGITS + ']' + '|' + RFC3966_VISUAL_SEPARATOR_ + ')';
 var RFC3966_GLOBAL_NUMBER_DIGITS_ = '^' + '\\' + PLUS_SIGN + RFC3966_PHONE_DIGIT_ + '*' + '[' + VALID_DIGITS + ']' + RFC3966_PHONE_DIGIT_ + '*' + '$';
-
 /**
  * Regular expression of valid global-number-digits for the phone-context
  * parameter, following the syntax defined in RFC3966.
  */
-var RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_ = new RegExp(RFC3966_GLOBAL_NUMBER_DIGITS_, 'g');
 
-// In this port of Google's library, we don't accept alpha characters in phone numbers.
+var RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_ = new RegExp(RFC3966_GLOBAL_NUMBER_DIGITS_, 'g'); // In this port of Google's library, we don't accept alpha characters in phone numbers.
 // const ALPHANUM_ = VALID_ALPHA_ + VALID_DIGITS
+
 var ALPHANUM_ = VALID_DIGITS;
 var RFC3966_DOMAINLABEL_ = '[' + ALPHANUM_ + ']+((\\-)*[' + ALPHANUM_ + '])*';
 var VALID_ALPHA_ = 'a-zA-Z';
 var RFC3966_TOPLABEL_ = '[' + VALID_ALPHA_ + ']+((\\-)*[' + ALPHANUM_ + '])*';
 var RFC3966_DOMAINNAME_ = '^(' + RFC3966_DOMAINLABEL_ + '\\.)*' + RFC3966_TOPLABEL_ + '\\.?$';
-
 /**
  * Regular expression of valid domainname for the phone-context parameter,
  * following the syntax defined in RFC3966.
  */
+
 var RFC3966_DOMAINNAME_PATTERN_ = new RegExp(RFC3966_DOMAINNAME_, 'g');
 var RFC3966_PREFIX_ = 'tel:';
 var RFC3966_PHONE_CONTEXT_ = ';phone-context=';
 var RFC3966_ISDN_SUBADDRESS_ = ';isub=';
-
 /**
  * Extracts the value of the phone-context parameter of `numberToExtractFrom`,
  * following the syntax defined in RFC3966.
@@ -41,41 +38,41 @@ var RFC3966_ISDN_SUBADDRESS_ = ';isub=';
  * @param {string} numberToExtractFrom
  * @return {string|null} the extracted string (possibly empty), or `null` if no phone-context parameter is found.
  */
+
 function extractPhoneContext(numberToExtractFrom) {
-  var indexOfPhoneContext = numberToExtractFrom.indexOf(RFC3966_PHONE_CONTEXT_);
-  // If no phone-context parameter is present
+  var indexOfPhoneContext = numberToExtractFrom.indexOf(RFC3966_PHONE_CONTEXT_); // If no phone-context parameter is present
+
   if (indexOfPhoneContext < 0) {
     return null;
   }
-  var phoneContextStart = indexOfPhoneContext + RFC3966_PHONE_CONTEXT_.length;
-  // If phone-context parameter is empty
+  var phoneContextStart = indexOfPhoneContext + RFC3966_PHONE_CONTEXT_.length; // If phone-context parameter is empty
+
   if (phoneContextStart >= numberToExtractFrom.length) {
     return '';
   }
-  var phoneContextEnd = numberToExtractFrom.indexOf(';', phoneContextStart);
-  // If phone-context is not the last parameter
+  var phoneContextEnd = numberToExtractFrom.indexOf(';', phoneContextStart); // If phone-context is not the last parameter
+
   if (phoneContextEnd >= 0) {
     return numberToExtractFrom.substring(phoneContextStart, phoneContextEnd);
   } else {
     return numberToExtractFrom.substring(phoneContextStart);
   }
 }
-
 /**
  * Returns whether the value of phoneContext follows the syntax defined in RFC3966.
  *
  * @param {string|null} phoneContext
  * @return {boolean}
  */
+
 function isPhoneContextValid(phoneContext) {
   if (phoneContext === null) {
     return true;
   }
   if (phoneContext.length === 0) {
     return false;
-  }
+  } // Does phone-context value match pattern of global-number-digits or domainname.
 
-  // Does phone-context value match pattern of global-number-digits or domainname.
   return RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_.test(phoneContext) || RFC3966_DOMAINNAME_PATTERN_.test(phoneContext);
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"extractPhoneContext.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractPhoneContext.js"],"sourcesContent":["// When phone numbers are written in `RFC3966` format — `\"tel:+12133734253\"` —\n// they can have their \"calling code\" part written separately in a `phone-context` parameter.\n// Example: `\"tel:12133734253;phone-context=+1\"`.\n// This function parses the full phone number from the local number and the `phone-context`\n// when the `phone-context` contains a `+` sign.\n\nimport { VALID_DIGITS\n// PLUS_CHARS\n} from '../constants.js';\nexport var PLUS_SIGN = '+';\nvar RFC3966_VISUAL_SEPARATOR_ = '[\\\\-\\\\.\\\\(\\\\)]?';\nvar RFC3966_PHONE_DIGIT_ = '(' + '[' + VALID_DIGITS + ']' + '|' + RFC3966_VISUAL_SEPARATOR_ + ')';\nvar RFC3966_GLOBAL_NUMBER_DIGITS_ = '^' + '\\\\' + PLUS_SIGN + RFC3966_PHONE_DIGIT_ + '*' + '[' + VALID_DIGITS + ']' + RFC3966_PHONE_DIGIT_ + '*' + '$';\n\n/**\r\n * Regular expression of valid global-number-digits for the phone-context\r\n * parameter, following the syntax defined in RFC3966.\r\n */\nvar RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_ = new RegExp(RFC3966_GLOBAL_NUMBER_DIGITS_, 'g');\n\n// In this port of Google's library, we don't accept alpha characters in phone numbers.\n// const ALPHANUM_ = VALID_ALPHA_ + VALID_DIGITS\nvar ALPHANUM_ = VALID_DIGITS;\nvar RFC3966_DOMAINLABEL_ = '[' + ALPHANUM_ + ']+((\\\\-)*[' + ALPHANUM_ + '])*';\nvar VALID_ALPHA_ = 'a-zA-Z';\nvar RFC3966_TOPLABEL_ = '[' + VALID_ALPHA_ + ']+((\\\\-)*[' + ALPHANUM_ + '])*';\nvar RFC3966_DOMAINNAME_ = '^(' + RFC3966_DOMAINLABEL_ + '\\\\.)*' + RFC3966_TOPLABEL_ + '\\\\.?$';\n\n/**\r\n * Regular expression of valid domainname for the phone-context parameter,\r\n * following the syntax defined in RFC3966.\r\n */\nvar RFC3966_DOMAINNAME_PATTERN_ = new RegExp(RFC3966_DOMAINNAME_, 'g');\nexport var RFC3966_PREFIX_ = 'tel:';\nexport var RFC3966_PHONE_CONTEXT_ = ';phone-context=';\nexport var RFC3966_ISDN_SUBADDRESS_ = ';isub=';\n\n/**\r\n * Extracts the value of the phone-context parameter of `numberToExtractFrom`,\r\n * following the syntax defined in RFC3966.\r\n *\r\n * @param {string} numberToExtractFrom\r\n * @return {string|null} the extracted string (possibly empty), or `null` if no phone-context parameter is found.\r\n */\nexport default function extractPhoneContext(numberToExtractFrom) {\n  var indexOfPhoneContext = numberToExtractFrom.indexOf(RFC3966_PHONE_CONTEXT_);\n  // If no phone-context parameter is present\n  if (indexOfPhoneContext < 0) {\n    return null;\n  }\n  var phoneContextStart = indexOfPhoneContext + RFC3966_PHONE_CONTEXT_.length;\n  // If phone-context parameter is empty\n  if (phoneContextStart >= numberToExtractFrom.length) {\n    return '';\n  }\n  var phoneContextEnd = numberToExtractFrom.indexOf(';', phoneContextStart);\n  // If phone-context is not the last parameter\n  if (phoneContextEnd >= 0) {\n    return numberToExtractFrom.substring(phoneContextStart, phoneContextEnd);\n  } else {\n    return numberToExtractFrom.substring(phoneContextStart);\n  }\n}\n\n/**\r\n * Returns whether the value of phoneContext follows the syntax defined in RFC3966.\r\n *\r\n * @param {string|null} phoneContext\r\n * @return {boolean}\r\n */\nexport function isPhoneContextValid(phoneContext) {\n  if (phoneContext === null) {\n    return true;\n  }\n  if (phoneContext.length === 0) {\n    return false;\n  }\n\n  // Does phone-context value match pattern of global-number-digits or domainname.\n  return RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_.test(phoneContext) || RFC3966_DOMAINNAME_PATTERN_.test(phoneContext);\n}\n//# sourceMappingURL=extractPhoneContext.js.map"],"names":["PLUS_SIGN","RFC3966_VISUAL_SEPARATOR_","RFC3966_PHONE_DIGIT_","VALID_DIGITS","RFC3966_GLOBAL_NUMBER_DIGITS_","RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_","RegExp","ALPHANUM_","RFC3966_DOMAINLABEL_","VALID_ALPHA_","RFC3966_TOPLABEL_","RFC3966_DOMAINNAME_","RFC3966_DOMAINNAME_PATTERN_","RFC3966_PREFIX_","RFC3966_PHONE_CONTEXT_","RFC3966_ISDN_SUBADDRESS_","extractPhoneContext","numberToExtractFrom","indexOfPhoneContext","indexOf","phoneContextStart","length","phoneContextEnd","substring","isPhoneContextValid","phoneContext","test"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;;AAOO,IAAMA,SAAS,GAAG;AAEzB,IAAMC,yBAAyB,GAAG,iBAAiB;AAEnD,IAAMC,oBAAoB,GAAG,GAAG,GAAG,GAAG,GAAGC,YAAY,GAAG,GAAG,GAAG,GAAG,GAAGF,yBAAyB,GAAG,GAAG;AAEnG,IAAMG,6BAA6B,GAClC,GAAG,GACH,IAAI,GACJJ,SAAS,GACTE,oBAAoB,GACpB,GAAG,GACH,GAAG,GAAGC,YAAY,GAAI,GAAG,GACzBD,oBAAoB,GACpB,GAAG,GACH,GAAG;;AAEJ;AACA;AACA;AACA;AACA,IAAMG,qCAAqC,GAAG,IAAIC,MAAM,CAACF,6BAA6B,EAAE,GAAG,CAAC;;AAE5F;AACA;AACA,IAAMG,SAAS,GAAGJ,YAAY;AAE9B,IAAMK,oBAAoB,GAAG,GAAG,GAAGD,SAAS,GAAG,YAAY,GAAGA,SAAS,GAAG,KAAK;AAE/E,IAAME,YAAY,GAAG,QAAQ;AAC7B,IAAMC,iBAAiB,GAAG,GAAG,GAAGD,YAAY,GAAG,YAAY,GAAGF,SAAS,GAAG,KAAK;AAE/E,IAAMI,mBAAmB,GAAG,IAAI,GAAGH,oBAAoB,GAAG,OAAO,GAAGE,iBAAiB,GAAG,OAAO;;AAE/F;AACA;AACA;AACA;AACA,IAAME,2BAA2B,GAAG,IAAIN,MAAM,CAACK,mBAAmB,EAAE,GAAG,CAAC;AAEjE,IAAME,eAAe,GAAG;AACxB,IAAMC,sBAAsB,GAAG;AAC/B,IAAMC,wBAAwB,GAAG;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,mBAAmBA,CAACC,mBAAmB,EAAE;AAChE,EAAA,IAAMC,mBAAmB,GAAGD,mBAAmB,CAACE,OAAO,CAACL,sBAAsB,CAAC;AAC/E;EACA,IAAII,mBAAmB,GAAG,CAAC,EAAE;AAC5B,IAAA,OAAO,IAAI;AACZ,EAAA;AAEA,EAAA,IAAME,iBAAiB,GAAGF,mBAAmB,GAAGJ,sBAAsB,CAACO,MAAM;AAC7E;AACA,EAAA,IAAID,iBAAiB,IAAIH,mBAAmB,CAACI,MAAM,EAAE;AACpD,IAAA,OAAO,EAAE;AACV,EAAA;EAEA,IAAMC,eAAe,GAAGL,mBAAmB,CAACE,OAAO,CAAC,GAAG,EAAEC,iBAAiB,CAAC;AAC3E;EACA,IAAIE,eAAe,IAAI,CAAC,EAAE;AACzB,IAAA,OAAOL,mBAAmB,CAACM,SAAS,CAACH,iBAAiB,EAAEE,eAAe,CAAC;AACzE,EAAA,CAAC,MAAM;AACN,IAAA,OAAOL,mBAAmB,CAACM,SAAS,CAACH,iBAAiB,CAAC;AACxD,EAAA;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASI,mBAAmBA,CAACC,YAAY,EAAE;EACjD,IAAIA,YAAY,KAAK,IAAI,EAAE;AAC1B,IAAA,OAAO,IAAI;AACZ,EAAA;AAEA,EAAA,IAAIA,YAAY,CAACJ,MAAM,KAAK,CAAC,EAAE;AAC9B,IAAA,OAAO,KAAK;AACb,EAAA;;AAEA;AACA,EAAA,OAAOhB,qCAAqC,CAACqB,IAAI,CAACD,YAAY,CAAC,IAC9Db,2BAA2B,CAACc,IAAI,CAACD,YAAY,CAAC;AAChD;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"extractPhoneContext.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractPhoneContext.js"],"sourcesContent":["// When phone numbers are written in `RFC3966` format — `\"tel:+12133734253\"` —\n// they can have their \"calling code\" part written separately in a `phone-context` parameter.\n// Example: `\"tel:12133734253;phone-context=+1\"`.\n// This function parses the full phone number from the local number and the `phone-context`\n// when the `phone-context` contains a `+` sign.\nimport { VALID_DIGITS // PLUS_CHARS\n} from '../constants.js';\nexport var PLUS_SIGN = '+';\nvar RFC3966_VISUAL_SEPARATOR_ = '[\\\\-\\\\.\\\\(\\\\)]?';\nvar RFC3966_PHONE_DIGIT_ = '(' + '[' + VALID_DIGITS + ']' + '|' + RFC3966_VISUAL_SEPARATOR_ + ')';\nvar RFC3966_GLOBAL_NUMBER_DIGITS_ = '^' + '\\\\' + PLUS_SIGN + RFC3966_PHONE_DIGIT_ + '*' + '[' + VALID_DIGITS + ']' + RFC3966_PHONE_DIGIT_ + '*' + '$';\n/**\r\n * Regular expression of valid global-number-digits for the phone-context\r\n * parameter, following the syntax defined in RFC3966.\r\n */\n\nvar RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_ = new RegExp(RFC3966_GLOBAL_NUMBER_DIGITS_, 'g'); // In this port of Google's library, we don't accept alpha characters in phone numbers.\n// const ALPHANUM_ = VALID_ALPHA_ + VALID_DIGITS\n\nvar ALPHANUM_ = VALID_DIGITS;\nvar RFC3966_DOMAINLABEL_ = '[' + ALPHANUM_ + ']+((\\\\-)*[' + ALPHANUM_ + '])*';\nvar VALID_ALPHA_ = 'a-zA-Z';\nvar RFC3966_TOPLABEL_ = '[' + VALID_ALPHA_ + ']+((\\\\-)*[' + ALPHANUM_ + '])*';\nvar RFC3966_DOMAINNAME_ = '^(' + RFC3966_DOMAINLABEL_ + '\\\\.)*' + RFC3966_TOPLABEL_ + '\\\\.?$';\n/**\r\n * Regular expression of valid domainname for the phone-context parameter,\r\n * following the syntax defined in RFC3966.\r\n */\n\nvar RFC3966_DOMAINNAME_PATTERN_ = new RegExp(RFC3966_DOMAINNAME_, 'g');\nexport var RFC3966_PREFIX_ = 'tel:';\nexport var RFC3966_PHONE_CONTEXT_ = ';phone-context=';\nexport var RFC3966_ISDN_SUBADDRESS_ = ';isub=';\n/**\r\n * Extracts the value of the phone-context parameter of `numberToExtractFrom`,\r\n * following the syntax defined in RFC3966.\r\n *\r\n * @param {string} numberToExtractFrom\r\n * @return {string|null} the extracted string (possibly empty), or `null` if no phone-context parameter is found.\r\n */\n\nexport default function extractPhoneContext(numberToExtractFrom) {\n  var indexOfPhoneContext = numberToExtractFrom.indexOf(RFC3966_PHONE_CONTEXT_); // If no phone-context parameter is present\n\n  if (indexOfPhoneContext < 0) {\n    return null;\n  }\n\n  var phoneContextStart = indexOfPhoneContext + RFC3966_PHONE_CONTEXT_.length; // If phone-context parameter is empty\n\n  if (phoneContextStart >= numberToExtractFrom.length) {\n    return '';\n  }\n\n  var phoneContextEnd = numberToExtractFrom.indexOf(';', phoneContextStart); // If phone-context is not the last parameter\n\n  if (phoneContextEnd >= 0) {\n    return numberToExtractFrom.substring(phoneContextStart, phoneContextEnd);\n  } else {\n    return numberToExtractFrom.substring(phoneContextStart);\n  }\n}\n/**\r\n * Returns whether the value of phoneContext follows the syntax defined in RFC3966.\r\n *\r\n * @param {string|null} phoneContext\r\n * @return {boolean}\r\n */\n\nexport function isPhoneContextValid(phoneContext) {\n  if (phoneContext === null) {\n    return true;\n  }\n\n  if (phoneContext.length === 0) {\n    return false;\n  } // Does phone-context value match pattern of global-number-digits or domainname.\n\n\n  return RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_.test(phoneContext) || RFC3966_DOMAINNAME_PATTERN_.test(phoneContext);\n}\n//# sourceMappingURL=extractPhoneContext.js.map"],"names":["PLUS_SIGN","RFC3966_VISUAL_SEPARATOR_","RFC3966_PHONE_DIGIT_","VALID_DIGITS","RFC3966_GLOBAL_NUMBER_DIGITS_","RFC3966_GLOBAL_NUMBER_DIGITS_PATTERN_","RegExp","ALPHANUM_","RFC3966_DOMAINLABEL_","VALID_ALPHA_","RFC3966_TOPLABEL_","RFC3966_DOMAINNAME_","RFC3966_DOMAINNAME_PATTERN_","RFC3966_PREFIX_","RFC3966_PHONE_CONTEXT_","RFC3966_ISDN_SUBADDRESS_","extractPhoneContext","numberToExtractFrom","indexOfPhoneContext","indexOf","phoneContextStart","length","phoneContextEnd","substring","isPhoneContextValid","phoneContext","test"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AAOO,IAAMA,SAAS,GAAG;AAEzB,IAAMC,yBAAyB,GAAG,iBAAlC;AAEA,IAAMC,oBAAoB,GAAG,GAAA,GAAM,GAAN,GAAYC,YAAZ,GAA2B,GAA3B,GAAiC,GAAjC,GAAuCF,yBAAvC,GAAmE,GAAhG;AAEA,IAAMG,6BAA6B,GAClC,GAAA,GACA,IADA,GAEAJ,SAFA,GAGAE,oBAHA,GAIA,GAJA,GAKA,GALA,GAKMC,YALN,GAKsB,GALtB,GAMAD,oBANA,GAOA,GAPA,GAQA,GATD;AAWA;AACA;AACA;AACA;;AACA,IAAMG,qCAAqC,GAAG,IAAIC,MAAJ,CAAWF,6BAAX,EAA0C,GAA1C,CAA9C;AAGA;;AACA,IAAMG,SAAS,GAAGJ,YAAlB;AAEA,IAAMK,oBAAoB,GAAG,GAAA,GAAMD,SAAN,GAAkB,YAAlB,GAAiCA,SAAjC,GAA6C,KAA1E;AAEA,IAAME,YAAY,GAAG,QAArB;AACA,IAAMC,iBAAiB,GAAG,GAAA,GAAMD,YAAN,GAAqB,YAArB,GAAoCF,SAApC,GAAgD,KAA1E;AAEA,IAAMI,mBAAmB,GAAG,IAAA,GAAOH,oBAAP,GAA8B,OAA9B,GAAwCE,iBAAxC,GAA4D,OAAxF;AAEA;AACA;AACA;AACA;;AACA,IAAME,2BAA2B,GAAG,IAAIN,MAAJ,CAAWK,mBAAX,EAAgC,GAAhC,CAApC;AAEO,IAAME,eAAe,GAAG;AACxB,IAAMC,sBAAsB,GAAG;AAC/B,IAAMC,wBAAwB,GAAG;AAExC;AACA;AACA;AACA;AACA;AACA;AACA;;AACe,SAASC,mBAATA,CAA6BC,mBAA7B,EAAkD;EAChE,IAAMC,mBAAmB,GAAGD,mBAAmB,CAACE,OAApB,CAA4BL,sBAA5B,CAA5B,CADgE;;EAGhE,IAAII,mBAAmB,GAAG,CAA1B,EAA6B;AAC5B,IAAA,OAAO,IAAP;AACA,EAAA;EAED,IAAME,iBAAiB,GAAGF,mBAAmB,GAAGJ,sBAAsB,CAACO,MAAvE,CAPgE;;AAShE,EAAA,IAAID,iBAAiB,IAAIH,mBAAmB,CAACI,MAA7C,EAAqD;AACpD,IAAA,OAAO,EAAP;AACA,EAAA;EAED,IAAMC,eAAe,GAAGL,mBAAmB,CAACE,OAApB,CAA4B,GAA5B,EAAiCC,iBAAjC,CAAxB,CAbgE;;EAehE,IAAIE,eAAe,IAAI,CAAvB,EAA0B;AACzB,IAAA,OAAOL,mBAAmB,CAACM,SAApB,CAA8BH,iBAA9B,EAAiDE,eAAjD,CAAP;AACA,EAAA,CAFD,MAEO;AACN,IAAA,OAAOL,mBAAmB,CAACM,SAApB,CAA8BH,iBAA9B,CAAP;AACA,EAAA;AACD;AAED;AACA;AACA;AACA;AACA;AACA;;AACO,SAASI,mBAATA,CAA6BC,YAA7B,EAA2C;EACjD,IAAIA,YAAY,KAAK,IAArB,EAA2B;AAC1B,IAAA,OAAO,IAAP;AACA,EAAA;AAED,EAAA,IAAIA,YAAY,CAACJ,MAAb,KAAwB,CAA5B,EAA+B;AAC9B,IAAA,OAAO,KAAP;AACA,EAAA,CAPgD;;EAUjD,OAAOhB,qCAAqC,CAACqB,IAAtC,CAA2CD,YAA3C,CAAA,IACNb,2BAA2B,CAACc,IAA5B,CAAiCD,YAAjC,CADD;AAEA;;;;","x_google_ignoreList":[0]}

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

@@ -1,9 +1,9 @@
 import applyInternationalSeparatorStyle from './applyInternationalSeparatorStyle.js';
 
-// This was originally set to $1 but there are some countries for which the
 // first group is not used in the national pattern (e.g. Argentina) so the $1
 // group does not match correctly. Therefore, we use `\d`, so that the first
 // group actually used in the pattern will be matched.
+
 var FIRST_GROUP_PATTERN = /(\$\d)/;
 function formatNationalNumberUsingFormat(number, format, _ref) {
   var useInternationalFormat = _ref.useInternationalFormat,

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

@@ -1 +1 @@
-{"version":3,"file":"formatNationalNumberUsingFormat.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/formatNationalNumberUsingFormat.js"],"sourcesContent":["import applyInternationalSeparatorStyle from './applyInternationalSeparatorStyle.js';\n\n// This was originally set to $1 but there are some countries for which the\n// first group is not used in the national pattern (e.g. Argentina) so the $1\n// group does not match correctly. Therefore, we use `\\d`, so that the first\n// group actually used in the pattern will be matched.\nexport var FIRST_GROUP_PATTERN = /(\\$\\d)/;\nexport default function formatNationalNumberUsingFormat(number, format, _ref) {\n  var useInternationalFormat = _ref.useInternationalFormat,\n    withNationalPrefix = _ref.withNationalPrefix,\n    carrierCode = _ref.carrierCode,\n    metadata = _ref.metadata;\n  var formattedNumber = number.replace(new RegExp(format.pattern()), useInternationalFormat ? format.internationalFormat() :\n  // This library doesn't use `domestic_carrier_code_formatting_rule`,\n  // because that one is only used when formatting phone numbers\n  // for dialing from a mobile phone, and this is not a dialing library.\n  // carrierCode && format.domesticCarrierCodeFormattingRule()\n  // \t// First, replace the $CC in the formatting rule with the desired carrier code.\n  // \t// Then, replace the $FG in the formatting rule with the first group\n  // \t// and the carrier code combined in the appropriate way.\n  // \t? format.format().replace(FIRST_GROUP_PATTERN, format.domesticCarrierCodeFormattingRule().replace('$CC', carrierCode))\n  // \t: (\n  // \t\twithNationalPrefix && format.nationalPrefixFormattingRule()\n  // \t\t\t? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())\n  // \t\t\t: format.format()\n  // \t)\n  withNationalPrefix && format.nationalPrefixFormattingRule() ? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule()) : format.format());\n  if (useInternationalFormat) {\n    return applyInternationalSeparatorStyle(formattedNumber);\n  }\n  return formattedNumber;\n}\n//# sourceMappingURL=formatNationalNumberUsingFormat.js.map"],"names":["FIRST_GROUP_PATTERN","formatNationalNumberUsingFormat","number","format","_ref","useInternationalFormat","withNationalPrefix","carrierCode","metadata","formattedNumber","replace","RegExp","pattern","internationalFormat","nationalPrefixFormattingRule","applyInternationalSeparatorStyle"],"mappings":";;AAEA;AACA;AACA;AACA;AACO,IAAMA,mBAAmB,GAAG;AAEpB,SAASC,+BAA+BA,CACtDC,MAAM,EACNC,MAAM,EAAAC,IAAA,EAOL;AAAA,EAAA,IALAC,sBAAsB,GAAAD,IAAA,CAAtBC,sBAAsB;IACtBC,kBAAkB,GAAAF,IAAA,CAAlBE,kBAAkB;IACPF,IAAA,CAAXG,WAAW;IACHH,IAAA,CAARI;EAGD,IAAMC,eAAe,GAAGP,MAAM,CAACQ,OAAO,CACrC,IAAIC,MAAM,CAACR,MAAM,CAACS,OAAO,EAAE,CAAC,EAC5BP,sBAAsB,GACnBF,MAAM,CAACU,mBAAmB,EAAE;AAE7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAP,EAAAA,kBAAkB,IAAIH,MAAM,CAACW,4BAA4B,EAAE,GACxDX,MAAM,CAACA,MAAM,EAAE,CAACO,OAAO,CAACV,mBAAmB,EAAEG,MAAM,CAACW,4BAA4B,EAAE,CAAC,GACnFX,MAAM,CAACA,MAAM,EAEnB,CAAC;AACD,EAAA,IAAIE,sBAAsB,EAAE;IAC3B,OAAOU,gCAAgC,CAACN,eAAe,CAAC;AACzD,EAAA;AACA,EAAA,OAAOA,eAAe;AACvB;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"formatNationalNumberUsingFormat.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/formatNationalNumberUsingFormat.js"],"sourcesContent":["import applyInternationalSeparatorStyle from './applyInternationalSeparatorStyle.js'; // This was originally set to $1 but there are some countries for which the\n// first group is not used in the national pattern (e.g. Argentina) so the $1\n// group does not match correctly. Therefore, we use `\\d`, so that the first\n// group actually used in the pattern will be matched.\n\nexport var FIRST_GROUP_PATTERN = /(\\$\\d)/;\nexport default function formatNationalNumberUsingFormat(number, format, _ref) {\n  var useInternationalFormat = _ref.useInternationalFormat,\n      withNationalPrefix = _ref.withNationalPrefix,\n      carrierCode = _ref.carrierCode,\n      metadata = _ref.metadata;\n  var formattedNumber = number.replace(new RegExp(format.pattern()), useInternationalFormat ? format.internationalFormat() : // This library doesn't use `domestic_carrier_code_formatting_rule`,\n  // because that one is only used when formatting phone numbers\n  // for dialing from a mobile phone, and this is not a dialing library.\n  // carrierCode && format.domesticCarrierCodeFormattingRule()\n  // \t// First, replace the $CC in the formatting rule with the desired carrier code.\n  // \t// Then, replace the $FG in the formatting rule with the first group\n  // \t// and the carrier code combined in the appropriate way.\n  // \t? format.format().replace(FIRST_GROUP_PATTERN, format.domesticCarrierCodeFormattingRule().replace('$CC', carrierCode))\n  // \t: (\n  // \t\twithNationalPrefix && format.nationalPrefixFormattingRule()\n  // \t\t\t? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())\n  // \t\t\t: format.format()\n  // \t)\n  withNationalPrefix && format.nationalPrefixFormattingRule() ? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule()) : format.format());\n\n  if (useInternationalFormat) {\n    return applyInternationalSeparatorStyle(formattedNumber);\n  }\n\n  return formattedNumber;\n}\n//# sourceMappingURL=formatNationalNumberUsingFormat.js.map"],"names":["FIRST_GROUP_PATTERN","formatNationalNumberUsingFormat","number","format","_ref","useInternationalFormat","withNationalPrefix","carrierCode","metadata","formattedNumber","replace","RegExp","pattern","internationalFormat","nationalPrefixFormattingRule","applyInternationalSeparatorStyle"],"mappings":";;AAGA;AACA;AACA;;AACO,IAAMA,mBAAmB,GAAG;AAEpB,SAASC,+BAATA,CACdC,MADc,EAEdC,MAFc,EAAAC,IAAA,EASb;AAAA,EAAA,IALAC,sBAKA,GAAAD,IAAA,CALAC,sBAKA;IAJAC,kBAIA,GAAAF,IAAA,CAJAE,kBAIA;IAAAF,IAAA,CAHAG,WAGA;IAAAH,IAAA,CAFAI;EAGD,IAAMC,eAAe,GAAGP,MAAM,CAACQ,OAAP,CACvB,IAAIC,MAAJ,CAAWR,MAAM,CAACS,OAAP,EAAX,CADuB,EAEvBP,sBAAsB,GACnBF,MAAM,CAACU,mBAAP,EADmB;AAGpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACAP,kBAAkB,IAAIH,MAAM,CAACW,4BAAP,EAAtB,GACGX,MAAM,CAACA,MAAP,EAAA,CAAgBO,OAAhB,CAAwBV,mBAAxB,EAA6CG,MAAM,CAACW,4BAAP,EAA7C,CADH,GAEGX,MAAM,CAACA,MAAP,EApBkB,CAAxB;AAuBA,EAAA,IAAIE,sBAAJ,EAA4B;IAC3B,OAAOU,gCAAgC,CAACN,eAAD,CAAvC;AACA,EAAA;AACD,EAAA,OAAOA,eAAP;AACA;;;;","x_google_ignoreList":[0]}

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

@@ -1,21 +1,21 @@
 import getCountryByNationalNumber from './getCountryByNationalNumber.js';
 
-// Returns the exact country for the `nationalNumber`
-// that belongs to the specified "country calling code".
 function getCountryByCallingCode(callingCode, _ref) {
   var nationalPhoneNumber = _ref.nationalNumber,
+    defaultCountry = _ref.defaultCountry,
     metadata = _ref.metadata;
   var possibleCountries = metadata.getCountryCodesForCallingCode(callingCode);
   if (!possibleCountries) {
     return;
-  }
-  // If there's just one country corresponding to the country code,
+  } // If there's just one country corresponding to the country code,
   // then just return it, without further phone number digits validation.
+
   if (possibleCountries.length === 1) {
     return possibleCountries[0];
   }
   return getCountryByNationalNumber(nationalPhoneNumber, {
     countries: possibleCountries,
+    defaultCountry: defaultCountry,
     metadata: metadata.metadata
   });
 }

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

@@ -1 +1 @@
-{"version":3,"file":"getCountryByCallingCode.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getCountryByCallingCode.js"],"sourcesContent":["import getCountryByNationalNumber from './getCountryByNationalNumber.js';\nvar USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;\n\n// Returns the exact country for the `nationalNumber`\n// that belongs to the specified \"country calling code\".\nexport default function getCountryByCallingCode(callingCode, _ref) {\n  var nationalPhoneNumber = _ref.nationalNumber,\n    metadata = _ref.metadata;\n  /* istanbul ignore if */\n  if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n    if (metadata.isNonGeographicCallingCode(callingCode)) {\n      return '001';\n    }\n  }\n  var possibleCountries = metadata.getCountryCodesForCallingCode(callingCode);\n  if (!possibleCountries) {\n    return;\n  }\n  // If there's just one country corresponding to the country code,\n  // then just return it, without further phone number digits validation.\n  if (possibleCountries.length === 1) {\n    return possibleCountries[0];\n  }\n  return getCountryByNationalNumber(nationalPhoneNumber, {\n    countries: possibleCountries,\n    metadata: metadata.metadata\n  });\n}\n//# sourceMappingURL=getCountryByCallingCode.js.map"],"names":["getCountryByCallingCode","callingCode","_ref","nationalPhoneNumber","nationalNumber","metadata","possibleCountries","getCountryCodesForCallingCode","length","getCountryByNationalNumber","countries"],"mappings":";;AAIA;AACA;AACe,SAASA,uBAAuBA,CAACC,WAAW,EAAAC,IAAA,EAGxD;AAAA,EAAA,IAFcC,mBAAmB,GAAAD,IAAA,CAAnCE,cAAc;IACdC,QAAQ,GAAAH,IAAA,CAARG,QAAQ;AAQR,EAAA,IAAMC,iBAAiB,GAAGD,QAAQ,CAACE,6BAA6B,CAACN,WAAW,CAAC;EAC7E,IAAI,CAACK,iBAAiB,EAAE;AACvB,IAAA;AACD,EAAA;AACA;AACA;AACA,EAAA,IAAIA,iBAAiB,CAACE,MAAM,KAAK,CAAC,EAAE;IACnC,OAAOF,iBAAiB,CAAC,CAAC,CAAC;AAC5B,EAAA;EACA,OAAOG,0BAA0B,CAACN,mBAAmB,EAAE;AACtDO,IAAAA,SAAS,EAAEJ,iBAAiB;IAC5BD,QAAQ,EAAEA,QAAQ,CAACA;AACpB,GAAC,CAAC;AACH;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"getCountryByCallingCode.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/getCountryByCallingCode.js"],"sourcesContent":["import getCountryByNationalNumber from './getCountryByNationalNumber.js';\nvar USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;\nexport default function getCountryByCallingCode(callingCode, _ref) {\n  var nationalPhoneNumber = _ref.nationalNumber,\n      defaultCountry = _ref.defaultCountry,\n      metadata = _ref.metadata;\n\n  /* istanbul ignore if */\n  if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n    if (metadata.isNonGeographicCallingCode(callingCode)) {\n      return '001';\n    }\n  }\n\n  var possibleCountries = metadata.getCountryCodesForCallingCode(callingCode);\n\n  if (!possibleCountries) {\n    return;\n  } // If there's just one country corresponding to the country code,\n  // then just return it, without further phone number digits validation.\n\n\n  if (possibleCountries.length === 1) {\n    return possibleCountries[0];\n  }\n\n  return getCountryByNationalNumber(nationalPhoneNumber, {\n    countries: possibleCountries,\n    defaultCountry: defaultCountry,\n    metadata: metadata.metadata\n  });\n}\n//# sourceMappingURL=getCountryByCallingCode.js.map"],"names":["getCountryByCallingCode","callingCode","_ref","nationalPhoneNumber","nationalNumber","defaultCountry","metadata","possibleCountries","getCountryCodesForCallingCode","length","getCountryByNationalNumber","countries"],"mappings":";;AAIe,SAASA,uBAATA,CAAiCC,WAAjC,EAAAC,IAAA,EAIZ;AAAA,EAAA,IAHcC,mBAGd,GAAAD,IAAA,CAHFE,cAGE;IAFFC,cAEE,GAAAH,IAAA,CAFFG,cAEE;IADFC,QACE,GAAAJ,IAAA,CADFI,QACE;AAOF,EAAA,IAAMC,iBAAiB,GAAGD,QAAQ,CAACE,6BAAT,CAAuCP,WAAvC,CAA1B;EACA,IAAI,CAACM,iBAAL,EAAwB;AACvB,IAAA;AACA,EAAA,CAVC;AAYF;;AACA,EAAA,IAAIA,iBAAiB,CAACE,MAAlB,KAA6B,CAAjC,EAAoC;IACnC,OAAOF,iBAAiB,CAAC,CAAD,CAAxB;AACA,EAAA;EACD,OAAOG,0BAA0B,CAACP,mBAAD,EAAsB;AACtDQ,IAAAA,SAAS,EAAEJ,iBAD2C;AAEtDF,IAAAA,cAAc,EAAdA,cAFsD;IAGtDC,QAAQ,EAAEA,QAAQ,CAACA;AAHmC,GAAtB,CAAjC;AAKA;;;;","x_google_ignoreList":[0]}

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

@@ -1,104 +1,80 @@
 import Metadata from '../metadata.js';
 import getNumberType from './getNumberType.js';
 
-function _createForOfIteratorHelperLoose(r, e) {
-  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-  if (t) return (t = t.call(r)).next.bind(t);
-  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
-    t && (r = t);
-    var o = 0;
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) {
+    if (it) o = it;
+    var i = 0;
     return function () {
-      return o >= r.length ? {
+      if (i >= o.length) return {
         done: true
-      } : {
+      };
+      return {
         done: false,
-        value: r[o++]
+        value: o[i++]
       };
     };
   }
   throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _unsupportedIterableToArray(r, a) {
-  if (r) {
-    if ("string" == typeof r) return _arrayLikeToArray(r, a);
-    var t = {}.toString.call(r).slice(8, -1);
-    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
-  }
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
 }
-function _arrayLikeToArray(r, a) {
-  (null == a || a > r.length) && (a = r.length);
-  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-  return n;
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+  return arr2;
 }
-
-// Returns the exact country that the `nationalPhoneNumber` belongs to
-// in cases of ambiguity, i.e. when multiple countries share the same "country calling code".
 function getCountryByNationalNumber(nationalPhoneNumber, _ref) {
-  var countries = _ref.countries,
-    metadata = _ref.metadata;
+  var countries = _ref.countries;
+    _ref.defaultCountry;
+    var metadata = _ref.metadata;
   // Re-create `metadata` because it will be selecting a `country`.
-  metadata = new Metadata(metadata);
-
-  // const matchingCountries = []
+  metadata = new Metadata(metadata); // const matchingCountries = []
 
   for (var _iterator = _createForOfIteratorHelperLoose(countries), _step; !(_step = _iterator()).done;) {
     var country = _step.value;
-    metadata.selectNumberingPlan(country);
-    // "Leading digits" patterns are only defined for about 20% of all countries.
+    metadata.country(country); // "Leading digits" patterns are only defined for about 20% of all countries.
     // By definition, matching "leading digits" is a sufficient but not a necessary
     // condition for a phone number to belong to a country.
     // The point of "leading digits" check is that it's the fastest one to get a match.
     // https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md#leading_digits
     // I'd suppose that "leading digits" patterns are mutually exclusive for different countries
     // because of the intended use of that feature.
+
     if (metadata.leadingDigits()) {
       if (nationalPhoneNumber && nationalPhoneNumber.search(metadata.leadingDigits()) === 0) {
         return country;
       }
-    }
-    // Else perform full validation with all of those
+    } // Else perform full validation with all of those
     // fixed-line/mobile/etc regular expressions.
     else if (getNumberType({
       phone: nationalPhoneNumber,
       country: country
     }, undefined, metadata.metadata)) {
-      // When multiple countries share the same "country calling code",
-      // type patterns aren't guaranteed to be unique among them.
-      // For example, both `US` and `CA` have the same pattern for `toll_free` numbers.
-      // https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/103#note_1417147572
-      //
-      // That means that this `if` condition could be `true` for multiple countries from the list.
-      // Currently, it just returns the first one, which is also the "main" country for the "country calling code".
-      // In an example with `toll_free` numbers above, `"US"` would be returned even though
-      // it could as well be `"CA"`.
-      //
-      // There was also a time when this attempted to be overly smart
-      // and kept track of all such multiple matching countries
-      // and then picked the one that matched the `defaultCountry`, if provided.
-      // For example, with `toll_free` numbers above, and with `defaultCountry: "CA"`,
-      // it would've returned `"CA"` instead of `"US"`.
-      // Later it turned out that such "overly smart" behavior turned out to be just confusing,
-      // so this "overly smart" country detection was reverted to returning the "main" country
-      // for the "country calling code".
+      // If both the `defaultCountry` and the "main" one match the phone number,
+      // don't prefer the `defaultCountry` over the "main" one.
       // https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/154
-      //
-      return country;
-      //
-      // The "overly smart" behavior code:
-      //
+      return country; // // If the `defaultCountry` is among the `matchingCountries` then return it.
       // if (defaultCountry) {
       // 	if (country === defaultCountry) {
       // 		return country
-      // 	} else {
-      // 		matchingCountries.push(country)
       // 	}
+      // 	matchingCountries.push(country)
       // } else {
       // 	return country
       // }
     }
-  }
-
-  // // Return the first ("main") one of the `matchingCountries`.
+  } // // Return the first ("main") one of the `matchingCountries`.
   // if (matchingCountries.length > 0) {
   // 	return matchingCountries[0]
   // }