pixel-react 1.14.87 → 1.14.89

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

@@ -10,18 +10,19 @@ import { MAX_LENGTH_COUNTRY_CODE } from '../constants.js';
  * a national prefix, carrier code, and national
  * (significant) number.
  * @param  {string} number — Phone number digits (possibly with a `+`).
- * @param  {string} [country] — Default country.
- * @param  {string} [callingCode] — Default calling code (some phone numbering plans are non-geographic).
+ * @param  {string} [country] — Country.
+ * @param  {string} [defaultCountry] — Default country.
+ * @param  {string} [defaultCallingCode] — Default calling code (some phone numbering plans are non-geographic).
  * @param  {object} metadata
  * @return {object} `{ countryCallingCodeSource: string?, countryCallingCode: string?, number: string }`
  * @example
  * // Returns `{ countryCallingCode: "1", number: "2133734253" }`.
- * extractCountryCallingCode('2133734253', 'US', null, metadata)
- * extractCountryCallingCode('2133734253', null, '1', metadata)
- * extractCountryCallingCode('+12133734253', null, null, metadata)
- * extractCountryCallingCode('+12133734253', 'RU', null, metadata)
+ * extractCountryCallingCode('2133734253', null, 'US', null, metadata)
+ * extractCountryCallingCode('2133734253', null, null, '1', metadata)
+ * extractCountryCallingCode('+12133734253', null, null, null, metadata)
+ * extractCountryCallingCode('+12133734253', null, 'RU', null, metadata)
  */
-function extractCountryCallingCode(number, country, callingCode, metadata) {
+function extractCountryCallingCode(number, country, defaultCountry, defaultCallingCode, metadata) {
   if (!number) {
     return {};
   }
@@ -37,7 +38,7 @@ function extractCountryCallingCode(number, country, callingCode, metadata) {
   if (number[0] !== '+') {
     // Convert an "out-of-country" dialing phone number
     // to a proper international phone number.
-    var numberWithoutIDD = stripIddPrefix(number, country, callingCode, metadata);
+    var numberWithoutIDD = stripIddPrefix(number, country || defaultCountry, defaultCallingCode, metadata);
     // If an IDD prefix was stripped then
     // convert the number to international one
     // for subsequent parsing.
@@ -49,8 +50,8 @@ function extractCountryCallingCode(number, country, callingCode, metadata) {
       // for the default country. If so, we remove the country calling code,
       // and do some checks on the validity of the number before and after.
       // https://github.com/catamphetamine/libphonenumber-js/issues/376
-      if (country || callingCode) {
-        var _extractCountryCallin = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, callingCode, metadata),
+      if (country || defaultCountry || defaultCallingCode) {
+        var _extractCountryCallin = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadata),
           countryCallingCode = _extractCountryCallin.countryCallingCode,
           shorterNumber = _extractCountryCallin.number;
         if (countryCallingCode) {
@@ -69,6 +70,8 @@ function extractCountryCallingCode(number, country, callingCode, metadata) {
     }
   }
 
+  // `number` can only be international at this point.
+
   // Fast abortion: country codes do not begin with a '0'
   if (number[1] === '0') {
     return {};

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

@@ -1 +1 @@
-{"version":3,"file":"extractCountryCallingCode.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js"],"sourcesContent":["import stripIddPrefix from './stripIddPrefix.js';\nimport extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js';\nimport Metadata from '../metadata.js';\nimport { MAX_LENGTH_COUNTRY_CODE } from '../constants.js';\n\n/**\r\n * Converts a phone number digits (possibly with a `+`)\r\n * into a calling code and the rest phone number digits.\r\n * The \"rest phone number digits\" could include\r\n * a national prefix, carrier code, and national\r\n * (significant) number.\r\n * @param  {string} number — Phone number digits (possibly with a `+`).\r\n * @param  {string} [country] — Default country.\r\n * @param  {string} [callingCode] — Default calling code (some phone numbering plans are non-geographic).\r\n * @param  {object} metadata\r\n * @return {object} `{ countryCallingCodeSource: string?, countryCallingCode: string?, number: string }`\r\n * @example\r\n * // Returns `{ countryCallingCode: \"1\", number: \"2133734253\" }`.\r\n * extractCountryCallingCode('2133734253', 'US', null, metadata)\r\n * extractCountryCallingCode('2133734253', null, '1', metadata)\r\n * extractCountryCallingCode('+12133734253', null, null, metadata)\r\n * extractCountryCallingCode('+12133734253', 'RU', null, metadata)\r\n */\nexport default function extractCountryCallingCode(number, country, callingCode, metadata) {\n  if (!number) {\n    return {};\n  }\n  var isNumberWithIddPrefix;\n\n  // If this is not an international phone number,\n  // then either extract an \"IDD\" prefix, or extract a\n  // country calling code from a number by autocorrecting it\n  // by prepending a leading `+` in cases when it starts\n  // with the country calling code.\n  // https://wikitravel.org/en/International_dialling_prefix\n  // https://github.com/catamphetamine/libphonenumber-js/issues/376\n  if (number[0] !== '+') {\n    // Convert an \"out-of-country\" dialing phone number\n    // to a proper international phone number.\n    var numberWithoutIDD = stripIddPrefix(number, country, callingCode, metadata);\n    // If an IDD prefix was stripped then\n    // convert the number to international one\n    // for subsequent parsing.\n    if (numberWithoutIDD && numberWithoutIDD !== number) {\n      isNumberWithIddPrefix = true;\n      number = '+' + numberWithoutIDD;\n    } else {\n      // Check to see if the number starts with the country calling code\n      // for the default country. If so, we remove the country calling code,\n      // and do some checks on the validity of the number before and after.\n      // https://github.com/catamphetamine/libphonenumber-js/issues/376\n      if (country || callingCode) {\n        var _extractCountryCallin = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, callingCode, metadata),\n          countryCallingCode = _extractCountryCallin.countryCallingCode,\n          shorterNumber = _extractCountryCallin.number;\n        if (countryCallingCode) {\n          return {\n            countryCallingCodeSource: 'FROM_NUMBER_WITHOUT_PLUS_SIGN',\n            countryCallingCode: countryCallingCode,\n            number: shorterNumber\n          };\n        }\n      }\n      return {\n        // No need to set it to `UNSPECIFIED`. It can be just `undefined`.\n        // countryCallingCodeSource: 'UNSPECIFIED',\n        number: number\n      };\n    }\n  }\n\n  // Fast abortion: country codes do not begin with a '0'\n  if (number[1] === '0') {\n    return {};\n  }\n  metadata = new Metadata(metadata);\n\n  // The thing with country phone codes\n  // is that they are orthogonal to each other\n  // i.e. there's no such country phone code A\n  // for which country phone code B exists\n  // where B starts with A.\n  // Therefore, while scanning digits,\n  // if a valid country code is found,\n  // that means that it is the country code.\n  //\n  var i = 2;\n  while (i - 1 <= MAX_LENGTH_COUNTRY_CODE && i <= number.length) {\n    var _countryCallingCode = number.slice(1, i);\n    if (metadata.hasCallingCode(_countryCallingCode)) {\n      metadata.selectNumberingPlan(_countryCallingCode);\n      return {\n        countryCallingCodeSource: isNumberWithIddPrefix ? 'FROM_NUMBER_WITH_IDD' : 'FROM_NUMBER_WITH_PLUS_SIGN',\n        countryCallingCode: _countryCallingCode,\n        number: number.slice(i)\n      };\n    }\n    i++;\n  }\n  return {};\n}\n\n// The possible values for the returned `countryCallingCodeSource` are:\n//\n// Copy-pasted from:\n// https://github.com/google/libphonenumber/blob/master/resources/phonenumber.proto\n//\n// // The source from which the country_code is derived. This is not set in the\n// // general parsing method, but in the method that parses and keeps raw_input.\n// // New fields could be added upon request.\n// enum CountryCodeSource {\n//  // Default value returned if this is not set, because the phone number was\n//  // created using parse, not parseAndKeepRawInput. hasCountryCodeSource will\n//  // return false if this is the case.\n//  UNSPECIFIED = 0;\n//\n//  // The country_code is derived based on a phone number with a leading \"+\",\n//  // e.g. the French number \"+33 1 42 68 53 00\".\n//  FROM_NUMBER_WITH_PLUS_SIGN = 1;\n//\n//  // The country_code is derived based on a phone number with a leading IDD,\n//  // e.g. the French number \"011 33 1 42 68 53 00\", as it is dialled from US.\n//  FROM_NUMBER_WITH_IDD = 5;\n//\n//  // The country_code is derived based on a phone number without a leading\n//  // \"+\", e.g. the French number \"33 1 42 68 53 00\" when defaultCountry is\n//  // supplied as France.\n//  FROM_NUMBER_WITHOUT_PLUS_SIGN = 10;\n//\n//  // The country_code is derived NOT based on the phone number itself, but\n//  // from the defaultCountry parameter provided in the parsing function by the\n//  // clients. This happens mostly for numbers written in the national format\n//  // (without country code). For example, this would be set when parsing the\n//  // French number \"01 42 68 53 00\", when defaultCountry is supplied as\n//  // France.\n//  FROM_DEFAULT_COUNTRY = 20;\n// }\n//# sourceMappingURL=extractCountryCallingCode.js.map"],"names":["extractCountryCallingCode","number","country","callingCode","metadata","isNumberWithIddPrefix","numberWithoutIDD","stripIddPrefix","_extractCountryCallin","extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","countryCallingCode","shorterNumber","countryCallingCodeSource","Metadata","i","MAX_LENGTH_COUNTRY_CODE","length","_countryCallingCode","slice","hasCallingCode","selectNumberingPlan"],"mappings":";;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,yBAAyBA,CAChDC,MAAM,EACNC,OAAO,EACPC,WAAW,EACXC,QAAQ,EACP;EACD,IAAI,CAACH,MAAM,EAAE;AACZ,IAAA,OAAO,EAAE;AACV,EAAA;AAEA,EAAA,IAAII,qBAAqB;;AAEzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,IAAIJ,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;AACtB;AACA;IACA,IAAMK,gBAAgB,GAAGC,cAAc,CAACN,MAAM,EAAEC,OAAO,EAAEC,WAAW,EAAEC,QAAQ,CAAC;AAC/E;AACA;AACA;AACA,IAAA,IAAIE,gBAAgB,IAAIA,gBAAgB,KAAKL,MAAM,EAAE;AACpDI,MAAAA,qBAAqB,GAAG,IAAI;MAC5BJ,MAAM,GAAG,GAAG,GAAGK,gBAAgB;AAChC,IAAA,CAAC,MAAM;AACN;AACA;AACA;AACA;MACA,IAAIJ,OAAO,IAAIC,WAAW,EAAE;QAC3B,IAAAK,qBAAA,GAGIC,+DAA+D,CAClER,MAAM,EACNC,OAAO,EACPC,WAAW,EACXC,QACD,CAAC;UAPAM,kBAAkB,GAAAF,qBAAA,CAAlBE,kBAAkB;UACVC,aAAa,GAAAH,qBAAA,CAArBP,MAAM;AAOP,QAAA,IAAIS,kBAAkB,EAAE;UACvB,OAAO;AACNE,YAAAA,wBAAwB,EAAE,+BAA+B;AACzDF,YAAAA,kBAAkB,EAAlBA,kBAAkB;AAClBT,YAAAA,MAAM,EAAEU;WACR;AACF,QAAA;AACD,MAAA;MACA,OAAO;AACN;AACA;AACAV,QAAAA,MAAM,EAANA;OACA;AACF,IAAA;AACD,EAAA;;AAEA;AACA,EAAA,IAAIA,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;AACtB,IAAA,OAAO,EAAE;AACV,EAAA;AAEAG,EAAAA,QAAQ,GAAG,IAAIS,QAAQ,CAACT,QAAQ,CAAC;;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACA,IAAIU,CAAC,GAAG,CAAC;EACT,OAAOA,CAAC,GAAG,CAAC,IAAIC,uBAAuB,IAAID,CAAC,IAAIb,MAAM,CAACe,MAAM,EAAE;IAC9D,IAAMC,mBAAkB,GAAGhB,MAAM,CAACiB,KAAK,CAAC,CAAC,EAAEJ,CAAC,CAAC;AAC7C,IAAA,IAAIV,QAAQ,CAACe,cAAc,CAACF,mBAAkB,CAAC,EAAE;AAChDb,MAAAA,QAAQ,CAACgB,mBAAmB,CAACH,mBAAkB,CAAC;MAChD,OAAO;AACNL,QAAAA,wBAAwB,EAAEP,qBAAqB,GAAG,sBAAsB,GAAG,4BAA4B;AACvGK,QAAAA,kBAAkB,EAAlBO,mBAAkB;AAClBhB,QAAAA,MAAM,EAAEA,MAAM,CAACiB,KAAK,CAACJ,CAAC;OACtB;AACF,IAAA;AACAA,IAAAA,CAAC,EAAE;AACJ,EAAA;AAEA,EAAA,OAAO,EAAE;AACV;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"extractCountryCallingCode.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js"],"sourcesContent":["import stripIddPrefix from './stripIddPrefix.js';\nimport extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js';\nimport Metadata from '../metadata.js';\nimport { MAX_LENGTH_COUNTRY_CODE } from '../constants.js';\n\n/**\r\n * Converts a phone number digits (possibly with a `+`)\r\n * into a calling code and the rest phone number digits.\r\n * The \"rest phone number digits\" could include\r\n * a national prefix, carrier code, and national\r\n * (significant) number.\r\n * @param  {string} number — Phone number digits (possibly with a `+`).\r\n * @param  {string} [country] — Country.\r\n * @param  {string} [defaultCountry] — Default country.\r\n * @param  {string} [defaultCallingCode] — Default calling code (some phone numbering plans are non-geographic).\r\n * @param  {object} metadata\r\n * @return {object} `{ countryCallingCodeSource: string?, countryCallingCode: string?, number: string }`\r\n * @example\r\n * // Returns `{ countryCallingCode: \"1\", number: \"2133734253\" }`.\r\n * extractCountryCallingCode('2133734253', null, 'US', null, metadata)\r\n * extractCountryCallingCode('2133734253', null, null, '1', metadata)\r\n * extractCountryCallingCode('+12133734253', null, null, null, metadata)\r\n * extractCountryCallingCode('+12133734253', null, 'RU', null, metadata)\r\n */\nexport default function extractCountryCallingCode(number, country, defaultCountry, defaultCallingCode, metadata) {\n  if (!number) {\n    return {};\n  }\n  var isNumberWithIddPrefix;\n\n  // If this is not an international phone number,\n  // then either extract an \"IDD\" prefix, or extract a\n  // country calling code from a number by autocorrecting it\n  // by prepending a leading `+` in cases when it starts\n  // with the country calling code.\n  // https://wikitravel.org/en/International_dialling_prefix\n  // https://github.com/catamphetamine/libphonenumber-js/issues/376\n  if (number[0] !== '+') {\n    // Convert an \"out-of-country\" dialing phone number\n    // to a proper international phone number.\n    var numberWithoutIDD = stripIddPrefix(number, country || defaultCountry, defaultCallingCode, metadata);\n    // If an IDD prefix was stripped then\n    // convert the number to international one\n    // for subsequent parsing.\n    if (numberWithoutIDD && numberWithoutIDD !== number) {\n      isNumberWithIddPrefix = true;\n      number = '+' + numberWithoutIDD;\n    } else {\n      // Check to see if the number starts with the country calling code\n      // for the default country. If so, we remove the country calling code,\n      // and do some checks on the validity of the number before and after.\n      // https://github.com/catamphetamine/libphonenumber-js/issues/376\n      if (country || defaultCountry || defaultCallingCode) {\n        var _extractCountryCallin = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadata),\n          countryCallingCode = _extractCountryCallin.countryCallingCode,\n          shorterNumber = _extractCountryCallin.number;\n        if (countryCallingCode) {\n          return {\n            countryCallingCodeSource: 'FROM_NUMBER_WITHOUT_PLUS_SIGN',\n            countryCallingCode: countryCallingCode,\n            number: shorterNumber\n          };\n        }\n      }\n      return {\n        // No need to set it to `UNSPECIFIED`. It can be just `undefined`.\n        // countryCallingCodeSource: 'UNSPECIFIED',\n        number: number\n      };\n    }\n  }\n\n  // `number` can only be international at this point.\n\n  // Fast abortion: country codes do not begin with a '0'\n  if (number[1] === '0') {\n    return {};\n  }\n  metadata = new Metadata(metadata);\n\n  // The thing with country phone codes\n  // is that they are orthogonal to each other\n  // i.e. there's no such country phone code A\n  // for which country phone code B exists\n  // where B starts with A.\n  // Therefore, while scanning digits,\n  // if a valid country code is found,\n  // that means that it is the country code.\n  //\n  var i = 2;\n  while (i - 1 <= MAX_LENGTH_COUNTRY_CODE && i <= number.length) {\n    var _countryCallingCode = number.slice(1, i);\n    if (metadata.hasCallingCode(_countryCallingCode)) {\n      metadata.selectNumberingPlan(_countryCallingCode);\n      return {\n        countryCallingCodeSource: isNumberWithIddPrefix ? 'FROM_NUMBER_WITH_IDD' : 'FROM_NUMBER_WITH_PLUS_SIGN',\n        countryCallingCode: _countryCallingCode,\n        number: number.slice(i)\n      };\n    }\n    i++;\n  }\n  return {};\n}\n\n// The possible values for the returned `countryCallingCodeSource` are:\n//\n// Copy-pasted from:\n// https://github.com/google/libphonenumber/blob/master/resources/phonenumber.proto\n//\n// // The source from which the country_code is derived. This is not set in the\n// // general parsing method, but in the method that parses and keeps raw_input.\n// // New fields could be added upon request.\n// enum CountryCodeSource {\n//  // Default value returned if this is not set, because the phone number was\n//  // created using parse, not parseAndKeepRawInput. hasCountryCodeSource will\n//  // return false if this is the case.\n//  UNSPECIFIED = 0;\n//\n//  // The country_code is derived based on a phone number with a leading \"+\",\n//  // e.g. the French number \"+33 1 42 68 53 00\".\n//  FROM_NUMBER_WITH_PLUS_SIGN = 1;\n//\n//  // The country_code is derived based on a phone number with a leading IDD,\n//  // e.g. the French number \"011 33 1 42 68 53 00\", as it is dialled from US.\n//  FROM_NUMBER_WITH_IDD = 5;\n//\n//  // The country_code is derived based on a phone number without a leading\n//  // \"+\", e.g. the French number \"33 1 42 68 53 00\" when defaultCountry is\n//  // supplied as France.\n//  FROM_NUMBER_WITHOUT_PLUS_SIGN = 10;\n//\n//  // The country_code is derived NOT based on the phone number itself, but\n//  // from the defaultCountry parameter provided in the parsing function by the\n//  // clients. This happens mostly for numbers written in the national format\n//  // (without country code). For example, this would be set when parsing the\n//  // French number \"01 42 68 53 00\", when defaultCountry is supplied as\n//  // France.\n//  FROM_DEFAULT_COUNTRY = 20;\n// }\n//# sourceMappingURL=extractCountryCallingCode.js.map"],"names":["extractCountryCallingCode","number","country","defaultCountry","defaultCallingCode","metadata","isNumberWithIddPrefix","numberWithoutIDD","stripIddPrefix","_extractCountryCallin","extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","countryCallingCode","shorterNumber","countryCallingCodeSource","Metadata","i","MAX_LENGTH_COUNTRY_CODE","length","_countryCallingCode","slice","hasCallingCode","selectNumberingPlan"],"mappings":";;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,yBAAyBA,CAChDC,MAAM,EACNC,OAAO,EACPC,cAAc,EACdC,kBAAkB,EAClBC,QAAQ,EACP;EACD,IAAI,CAACJ,MAAM,EAAE;AACZ,IAAA,OAAO,EAAE;AACV,EAAA;AAEA,EAAA,IAAIK,qBAAqB;;AAEzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,IAAIL,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;AACtB;AACA;AACA,IAAA,IAAMM,gBAAgB,GAAGC,cAAc,CAACP,MAAM,EAAEC,OAAO,IAAIC,cAAc,EAAEC,kBAAkB,EAAEC,QAAQ,CAAC;AACxG;AACA;AACA;AACA,IAAA,IAAIE,gBAAgB,IAAIA,gBAAgB,KAAKN,MAAM,EAAE;AACpDK,MAAAA,qBAAqB,GAAG,IAAI;MAC5BL,MAAM,GAAG,GAAG,GAAGM,gBAAgB;AAChC,IAAA,CAAC,MAAM;AACN;AACA;AACA;AACA;AACA,MAAA,IAAIL,OAAO,IAAIC,cAAc,IAAIC,kBAAkB,EAAE;AACpD,QAAA,IAAAK,qBAAA,GAGIC,+DAA+D,CAClET,MAAM,EACNC,OAAO,EACPC,cAAc,EACdC,kBAAkB,EAClBC,QACD,CAAC;UARAM,kBAAkB,GAAAF,qBAAA,CAAlBE,kBAAkB;UACVC,aAAa,GAAAH,qBAAA,CAArBR,MAAM;AAQP,QAAA,IAAIU,kBAAkB,EAAE;UACvB,OAAO;AACNE,YAAAA,wBAAwB,EAAE,+BAA+B;AACzDF,YAAAA,kBAAkB,EAAlBA,kBAAkB;AAClBV,YAAAA,MAAM,EAAEW;WACR;AACF,QAAA;AACD,MAAA;MACA,OAAO;AACN;AACA;AACAX,QAAAA,MAAM,EAANA;OACA;AACF,IAAA;AACD,EAAA;;AAEA;;AAEA;AACA,EAAA,IAAIA,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;AACtB,IAAA,OAAO,EAAE;AACV,EAAA;AAEAI,EAAAA,QAAQ,GAAG,IAAIS,QAAQ,CAACT,QAAQ,CAAC;;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACA,IAAIU,CAAC,GAAG,CAAC;EACT,OAAOA,CAAC,GAAG,CAAC,IAAIC,uBAAuB,IAAID,CAAC,IAAId,MAAM,CAACgB,MAAM,EAAE;IAC9D,IAAMC,mBAAkB,GAAGjB,MAAM,CAACkB,KAAK,CAAC,CAAC,EAAEJ,CAAC,CAAC;AAC7C,IAAA,IAAIV,QAAQ,CAACe,cAAc,CAACF,mBAAkB,CAAC,EAAE;AAChDb,MAAAA,QAAQ,CAACgB,mBAAmB,CAACH,mBAAkB,CAAC;MAChD,OAAO;AACNL,QAAAA,wBAAwB,EAAEP,qBAAqB,GAAG,sBAAsB,GAAG,4BAA4B;AACvGK,QAAAA,kBAAkB,EAAlBO,mBAAkB;AAClBjB,QAAAA,MAAM,EAAEA,MAAM,CAACkB,KAAK,CAACJ,CAAC;OACtB;AACF,IAAA;AACAA,IAAAA,CAAC,EAAE;AACJ,EAAA;AAEA,EAAA,OAAO,EAAE;AACV;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;","x_google_ignoreList":[0]}

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

@@ -7,21 +7,23 @@ import checkNumberLength from './checkNumberLength.js';
  * Sometimes some people incorrectly input international phone numbers
  * without the leading `+`. This function corrects such input.
  * @param  {string} number — Phone number digits.
- * @param  {string?} country
- * @param  {string?} callingCode
+ * @param  {string} [country] — Exact country of the phone number.
+ * @param  {string} [defaultCountry]
+ * @param  {string} [defaultCallingCode]
  * @param  {object} metadata
  * @return {object} `{ countryCallingCode: string?, number: string }`.
  */
-function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, callingCode, metadata) {
-  var countryCallingCode = country ? getCountryCallingCode(country, metadata) : callingCode;
+function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadata) {
+  var countryCallingCode = country || defaultCountry ? getCountryCallingCode(country || defaultCountry, metadata) : defaultCallingCode;
   if (number.indexOf(countryCallingCode) === 0) {
     metadata = new Metadata(metadata);
-    metadata.selectNumberingPlan(country, callingCode);
+    metadata.selectNumberingPlan(country || defaultCountry, countryCallingCode);
     var possibleShorterNumber = number.slice(countryCallingCode.length);
-    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, metadata),
+    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, country, metadata),
       possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;
-    var _extractNationalNumbe2 = extractNationalNumber(number, metadata),
+    var _extractNationalNumbe2 = extractNationalNumber(number, country, metadata),
       nationalNumber = _extractNationalNumbe2.nationalNumber;
+
     // If the number was not valid before but is valid now,
     // or if it was too long before, we consider the number
     // with the country calling code stripped to be a better result
@@ -30,7 +32,7 @@ function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number,
     // so if a number starts with `49`, it could be both a valid
     // national German number or an international number without
     // a leading `+`.
-    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, metadata) === 'TOO_LONG') {
+    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, country, metadata) === 'TOO_LONG') {
       return {
         countryCallingCode: countryCallingCode,
         number: possibleShorterNumber

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

@@ -1 +1 @@
-{"version":3,"file":"extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js"],"sourcesContent":["import Metadata from '../metadata.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport extractNationalNumber from './extractNationalNumber.js';\nimport checkNumberLength from './checkNumberLength.js';\nimport getCountryCallingCode from '../getCountryCallingCode.js';\n\n/**\r\n * Sometimes some people incorrectly input international phone numbers\r\n * without the leading `+`. This function corrects such input.\r\n * @param  {string} number — Phone number digits.\r\n * @param  {string?} country\r\n * @param  {string?} callingCode\r\n * @param  {object} metadata\r\n * @return {object} `{ countryCallingCode: string?, number: string }`.\r\n */\nexport default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, callingCode, metadata) {\n  var countryCallingCode = country ? getCountryCallingCode(country, metadata) : callingCode;\n  if (number.indexOf(countryCallingCode) === 0) {\n    metadata = new Metadata(metadata);\n    metadata.selectNumberingPlan(country, callingCode);\n    var possibleShorterNumber = number.slice(countryCallingCode.length);\n    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, metadata),\n      possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;\n    var _extractNationalNumbe2 = extractNationalNumber(number, metadata),\n      nationalNumber = _extractNationalNumbe2.nationalNumber;\n    // If the number was not valid before but is valid now,\n    // or if it was too long before, we consider the number\n    // with the country calling code stripped to be a better result\n    // and keep that instead.\n    // For example, in Germany (+49), `49` is a valid area code,\n    // so if a number starts with `49`, it could be both a valid\n    // national German number or an international number without\n    // a leading `+`.\n    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, metadata) === 'TOO_LONG') {\n      return {\n        countryCallingCode: countryCallingCode,\n        number: possibleShorterNumber\n      };\n    }\n  }\n  return {\n    number: number\n  };\n}\n//# sourceMappingURL=extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js.map"],"names":["extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","number","country","callingCode","metadata","countryCallingCode","getCountryCallingCode","indexOf","Metadata","selectNumberingPlan","possibleShorterNumber","slice","length","_extractNationalNumbe","extractNationalNumber","possibleShorterNationalNumber","nationalNumber","_extractNationalNumbe2","matchesEntirely","nationalNumberPattern","checkNumberLength"],"mappings":";;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,+DAA+DA,CACtFC,MAAM,EACNC,OAAO,EACPC,WAAW,EACXC,QAAQ,EACP;EACD,IAAMC,kBAAkB,GAAGH,OAAO,GAAGI,qBAAqB,CAACJ,OAAO,EAAEE,QAAQ,CAAC,GAAGD,WAAW;EAC3F,IAAIF,MAAM,CAACM,OAAO,CAACF,kBAAkB,CAAC,KAAK,CAAC,EAAE;AAC7CD,IAAAA,QAAQ,GAAG,IAAII,QAAQ,CAACJ,QAAQ,CAAC;AACjCA,IAAAA,QAAQ,CAACK,mBAAmB,CAACP,OAAO,EAAEC,WAAW,CAAC;IAClD,IAAMO,qBAAqB,GAAGT,MAAM,CAACU,KAAK,CAACN,kBAAkB,CAACO,MAAM,CAAC;AACrE,IAAA,IAAAC,qBAAA,GAEIC,qBAAqB,CACxBJ,qBAAqB,EACrBN,QACD,CAAC;MAJgBW,6BAA6B,GAAAF,qBAAA,CAA7CG,cAAc;AAKf,IAAA,IAAAC,sBAAA,GAEIH,qBAAqB,CACxBb,MAAM,EACNG,QACD,CAAC;MAJAY,cAAc,GAAAC,sBAAA,CAAdD,cAAc;AAKf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAA,IAEE,CAACE,eAAe,CAACF,cAAc,EAAEZ,QAAQ,CAACe,qBAAqB,EAAE,CAAC,IAElED,eAAe,CAACH,6BAA6B,EAAEX,QAAQ,CAACe,qBAAqB,EAAE,CAAC,IAGjFC,iBAAiB,CAACJ,cAAc,EAAEZ,QAAQ,CAAC,KAAK,UAAU,EACzD;MACD,OAAO;AACNC,QAAAA,kBAAkB,EAAlBA,kBAAkB;AAClBJ,QAAAA,MAAM,EAAES;OACR;AACF,IAAA;AACD,EAAA;EACA,OAAO;AAAET,IAAAA,MAAM,EAANA;GAAQ;AAClB;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js","sources":["../../../../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js"],"sourcesContent":["import Metadata from '../metadata.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport extractNationalNumber from './extractNationalNumber.js';\nimport checkNumberLength from './checkNumberLength.js';\nimport getCountryCallingCode from '../getCountryCallingCode.js';\n\n/**\r\n * Sometimes some people incorrectly input international phone numbers\r\n * without the leading `+`. This function corrects such input.\r\n * @param  {string} number — Phone number digits.\r\n * @param  {string} [country] — Exact country of the phone number.\r\n * @param  {string} [defaultCountry]\r\n * @param  {string} [defaultCallingCode]\r\n * @param  {object} metadata\r\n * @return {object} `{ countryCallingCode: string?, number: string }`.\r\n */\nexport default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadata) {\n  var countryCallingCode = country || defaultCountry ? getCountryCallingCode(country || defaultCountry, metadata) : defaultCallingCode;\n  if (number.indexOf(countryCallingCode) === 0) {\n    metadata = new Metadata(metadata);\n    metadata.selectNumberingPlan(country || defaultCountry, countryCallingCode);\n    var possibleShorterNumber = number.slice(countryCallingCode.length);\n    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, country, metadata),\n      possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;\n    var _extractNationalNumbe2 = extractNationalNumber(number, country, metadata),\n      nationalNumber = _extractNationalNumbe2.nationalNumber;\n\n    // If the number was not valid before but is valid now,\n    // or if it was too long before, we consider the number\n    // with the country calling code stripped to be a better result\n    // and keep that instead.\n    // For example, in Germany (+49), `49` is a valid area code,\n    // so if a number starts with `49`, it could be both a valid\n    // national German number or an international number without\n    // a leading `+`.\n    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, country, metadata) === 'TOO_LONG') {\n      return {\n        countryCallingCode: countryCallingCode,\n        number: possibleShorterNumber\n      };\n    }\n  }\n  return {\n    number: number\n  };\n}\n//# sourceMappingURL=extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js.map"],"names":["extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","number","country","defaultCountry","defaultCallingCode","metadata","countryCallingCode","getCountryCallingCode","indexOf","Metadata","selectNumberingPlan","possibleShorterNumber","slice","length","_extractNationalNumbe","extractNationalNumber","possibleShorterNationalNumber","nationalNumber","_extractNationalNumbe2","matchesEntirely","nationalNumberPattern","checkNumberLength"],"mappings":";;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,+DAA+DA,CACtFC,MAAM,EACNC,OAAO,EACPC,cAAc,EACdC,kBAAkB,EAClBC,QAAQ,EACP;AACD,EAAA,IAAMC,kBAAkB,GAAGJ,OAAO,IAAIC,cAAc,GACjDI,qBAAqB,CAACL,OAAO,IAAIC,cAAc,EAAEE,QAAQ,CAAC,GAC1DD,kBAAkB;EAErB,IAAIH,MAAM,CAACO,OAAO,CAACF,kBAAkB,CAAC,KAAK,CAAC,EAAE;AAC7CD,IAAAA,QAAQ,GAAG,IAAII,QAAQ,CAACJ,QAAQ,CAAC;IACjCA,QAAQ,CAACK,mBAAmB,CAACR,OAAO,IAAIC,cAAc,EAAEG,kBAAkB,CAAC;IAE3E,IAAMK,qBAAqB,GAAGV,MAAM,CAACW,KAAK,CAACN,kBAAkB,CAACO,MAAM,CAAC;IAErE,IAAAC,qBAAA,GAEIC,qBAAqB,CACxBJ,qBAAqB,EACrBT,OAAO,EACPG,QACD,CAAC;MALgBW,6BAA6B,GAAAF,qBAAA,CAA7CG,cAAc;IAOf,IAAAC,sBAAA,GAEIH,qBAAqB,CACxBd,MAAM,EACNC,OAAO,EACPG,QACD,CAAC;MALAY,cAAc,GAAAC,sBAAA,CAAdD,cAAc;;AAOf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAA,IAEE,CAACE,eAAe,CAACF,cAAc,EAAEZ,QAAQ,CAACe,qBAAqB,EAAE,CAAC,IAClED,eAAe,CAACH,6BAA6B,EAAEX,QAAQ,CAACe,qBAAqB,EAAE,CAAC,IAGjFC,iBAAiB,CAACJ,cAAc,EAAEf,OAAO,EAAEG,QAAQ,CAAC,KAAK,UAAU,EAClE;MACD,OAAO;AACNC,QAAAA,kBAAkB,EAAlBA,kBAAkB;AAClBL,QAAAA,MAAM,EAAEU;OACR;AACF,IAAA;AACD,EAAA;EAEA,OAAO;AAAEV,IAAAA,MAAM,EAANA;GAAQ;AAClB;;;;","x_google_ignoreList":[0]}

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

@@ -1,6 +1,7 @@
 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.
@@ -8,10 +9,11 @@ import checkNumberLength from './checkNumberLength.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, metadata) {
+function extractNationalNumber(number, country, metadata) {
   // Parsing national prefixes and carrier codes
   // is only required for local phone numbers
   // but some people don't understand that
@@ -33,7 +35,15 @@ function extractNationalNumber(number, metadata) {
     }
     // 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.possibleLengths()) {
+    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
+        });
+      }
+
       // 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,
@@ -42,7 +52,7 @@ function extractNationalNumber(number, 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, metadata)) {
+      if (!isPossibleIncompleteNationalNumber(nationalNumber, country, metadata)) {
         // Don't strip the national prefix.
         return {
           nationalNumber: number
@@ -91,8 +101,8 @@ function shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberA
   // }
   return true;
 }
-function isPossibleIncompleteNationalNumber(nationalNumber, metadata) {
-  switch (checkNumberLength(nationalNumber, metadata)) {
+function isPossibleIncompleteNationalNumber(nationalNumber, country, metadata) {
+  switch (checkNumberLength(nationalNumber, country, 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';\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  {Metadata} metadata — Metadata with a phone numbering plan selected.\r\n * @return {object} `{ nationalNumber: string, carrierCode: string? }`.\r\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  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.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  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, 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    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,qBAAqBA,CAACC,MAAM,EAAEC,QAAQ,EAAE;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,IAAAC,qBAAA,GAGIC,iDAAiD,CACpDH,MAAM,EACNC,QACD,CAAC;IALAG,WAAW,GAAAF,qBAAA,CAAXE,WAAW;IACXC,cAAc,GAAAH,qBAAA,CAAdG,cAAc;EAMf,IAAIA,cAAc,KAAKL,MAAM,EAAE;IAC9B,IAAI,CAACM,iCAAiC,CAACN,MAAM,EAAEK,cAAc,EAAEJ,QAAQ,CAAC,EAAE;AACzE;MACA,OAAO;AAAEI,QAAAA,cAAc,EAAEL;OAAQ;AAClC,IAAA;AACA;AACA;AACA,IAAA,IAAIC,QAAQ,CAACM,eAAe,EAAE,EAAE;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAA,IAAI,CAACC,kCAAkC,CAACH,cAAc,EAAEJ,QAAQ,CAAC,EAAE;AAClE;QACA,OAAO;AAAEI,UAAAA,cAAc,EAAEL;SAAQ;AAClC,MAAA;AACD,IAAA;AACD,EAAA;EAEA,OAAO;AAAEK,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,CAACG,oBAAoB,EAAEC,mBAAmB,EAAET,QAAQ,EAAE;AAC/F;AACA;EACA,IAAIU,eAAe,CAACF,oBAAoB,EAAER,QAAQ,CAACW,qBAAqB,EAAE,CAAC,IAC1E,CAACD,eAAe,CAACD,mBAAmB,EAAET,QAAQ,CAACW,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,CAACH,cAAc,EAAEJ,QAAQ,EAAE;AACrE,EAAA,QAAQY,iBAAiB,CAACR,cAAc,EAAEJ,QAAQ,CAAC;AAClD,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';\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]}

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

@@ -1,8 +1,9 @@
 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) {
@@ -15,7 +16,6 @@ function getCountryByCallingCode(callingCode, _ref) {
   }
   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;\nexport default function getCountryByCallingCode(callingCode, _ref) {\n  var nationalPhoneNumber = _ref.nationalNumber,\n    defaultCountry = _ref.defaultCountry,\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    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,uBAAuBA,CAACC,WAAW,EAAAC,IAAA,EAIxD;AAAA,EAAA,IAHcC,mBAAmB,GAAAD,IAAA,CAAnCE,cAAc;IACdC,cAAc,GAAAH,IAAA,CAAdG,cAAc;IACdC,QAAQ,GAAAJ,IAAA,CAARI,QAAQ;AAQR,EAAA,IAAMC,iBAAiB,GAAGD,QAAQ,CAACE,6BAA6B,CAACP,WAAW,CAAC;EAC7E,IAAI,CAACM,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,CAACP,mBAAmB,EAAE;AACtDQ,IAAAA,SAAS,EAAEJ,iBAAiB;AAC5BF,IAAAA,cAAc,EAAdA,cAAc;IACdC,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;\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]}

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

@@ -30,10 +30,12 @@ function _arrayLikeToArray(r, a) {
   for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
   return n;
 }
+
+// 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;
-    _ref.defaultCountry;
-    var metadata = _ref.metadata;
+  var countries = _ref.countries,
+    metadata = _ref.metadata;
   // Re-create `metadata` because it will be selecting a `country`.
   metadata = new Metadata(metadata);
 
@@ -41,7 +43,7 @@ function getCountryByNationalNumber(nationalPhoneNumber, _ref) {
 
   for (var _iterator = _createForOfIteratorHelperLoose(countries), _step; !(_step = _iterator()).done;) {
     var country = _step.value;
-    metadata.country(country);
+    metadata.selectNumberingPlan(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.
@@ -60,16 +62,36 @@ function getCountryByNationalNumber(nationalPhoneNumber, _ref) {
       phone: nationalPhoneNumber,
       country: country
     }, undefined, metadata.metadata)) {
-      // If both the `defaultCountry` and the "main" one match the phone number,
-      // don't prefer the `defaultCountry` over the "main" one.
+      // 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".
       // https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/154
+      //
       return country;
-      // // If the `defaultCountry` is among the `matchingCountries` then return it.
+      //
+      // The "overly smart" behavior code:
+      //
       // if (defaultCountry) {
       // 	if (country === defaultCountry) {
       // 		return country
+      // 	} else {
+      // 		matchingCountries.push(country)
       // 	}
-      // 	matchingCountries.push(country)
       // } else {
       // 	return country
       // }

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(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';\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);\n\n  // const matchingCountries = []\n\n  for (var _iterator = _createForOfIteratorHelperLoose(countries), _step; !(_step = _iterator()).done;) {\n    var country = _step.value;\n    metadata.country(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      // 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;\n      // // 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  }\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","defaultCountry","metadata","Metadata","_iterator","_createForOfIteratorHelperLoose","_step","done","country","value","leadingDigits","search","getNumberType","phone","undefined"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGe,SAASA,0BAA0BA,CAACC,mBAAmB,EAAAC,IAAA,EAInE;AAAA,EAAA,IAHFC,SAAS,GAAAD,IAAA,CAATC,SAAS;IACKD,IAAA,CAAdE,cAAc;QACdC,QAAQ,GAAAH,IAAA,CAARG;AAEA;AACAA,EAAAA,QAAQ,GAAG,IAAIC,QAAQ,CAACD,QAAQ,CAAC;;AAEjC;;AAEA,EAAA,KAAA,IAAAE,SAAA,GAAAC,+BAAA,CAAsBL,SAAS,CAAA,EAAAM,KAAA,EAAA,CAAA,CAAAA,KAAA,GAAAF,SAAA,EAAA,EAAAG,IAAA,GAAE;AAAA,IAAA,IAAtBC,OAAO,GAAAF,KAAA,CAAAG,KAAA;AACjBP,IAAAA,QAAQ,CAACM,OAAO,CAACA,OAAO,CAAC;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAA,IAAIN,QAAQ,CAACQ,aAAa,EAAE,EAAE;AAC7B,MAAA,IAAIZ,mBAAmB,IACtBA,mBAAmB,CAACa,MAAM,CAACT,QAAQ,CAACQ,aAAa,EAAE,CAAC,KAAK,CAAC,EAAE;AAC5D,QAAA,OAAOF,OAAO;AACf,MAAA;AACD,IAAA;AACA;AACA;SACK,IAAII,aAAa,CAAC;AAAEC,MAAAA,KAAK,EAAEf,mBAAmB;AAAEU,MAAAA,OAAO,EAAPA;AAAQ,KAAC,EAAEM,SAAS,EAAEZ,QAAQ,CAACA,QAAQ,CAAC,EAAE;AAC9F;AACA;AACA;AACA,MAAA,OAAOM,OAAO;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACD,IAAA;AACD,EAAA;;AAEA;AACA;AACA;AACA;AACD;;;;","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/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,eAAeA,CAACC,IAAI,EAAEC,kBAAkB,EAAE;AACjE;AACA;EACAD,IAAI,GAAGA,IAAI,IAAI,EAAE;AACjB,EAAA,OAAO,IAAIE,MAAM,CAAC,MAAM,GAAGD,kBAAkB,GAAG,IAAI,CAAC,CAACE,IAAI,CAACH,IAAI,CAAC;AACjE;;;;","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/isPossible.js

@@ -33,7 +33,7 @@ function isPossiblePhoneNumber(input, options, metadata) {
       if (!metadata.hasCountry(input.country)) {
         throw new Error("Unknown country: ".concat(input.country));
       }
-      metadata.country(input.country);
+      metadata.selectNumberingPlan(input.country);
     } else {
       if (!input.countryCallingCode) {
         throw new Error('Invalid phone number object passed');
@@ -44,7 +44,7 @@ function isPossiblePhoneNumber(input, options, metadata) {
 
   // Old metadata (< 1.0.18) had no "possible length" data.
   if (metadata.possibleLengths()) {
-    return isPossibleNumber(input.phone || input.nationalNumber, metadata);
+    return isPossibleNumber(input.phone || input.nationalNumber, input.country, metadata);
   } else {
     // There was a bug between `1.7.35` and `1.7.37` where "possible_lengths"
     // were missing for "non-geographical" numbering plans.
@@ -61,9 +61,9 @@ function isPossiblePhoneNumber(input, options, metadata) {
     }
   }
 }
-function isPossibleNumber(nationalNumber, metadata) {
+function isPossibleNumber(nationalNumber, country, metadata) {
   //, isInternational) {
-  switch (checkNumberLength(nationalNumber, metadata)) {
+  switch (checkNumberLength(nationalNumber, country, metadata)) {
     case 'IS_POSSIBLE':
       return true;
     // This library ignores "local-only" phone numbers (for simplicity).

package/lib/node_modules/libphonenumber-js/es6/isPossible.js.map

@@ -1 +1 @@
-{"version":3,"file":"isPossible.js","sources":["../../../../node_modules/libphonenumber-js/es6/isPossible.js"],"sourcesContent":["import Metadata from './metadata.js';\nimport checkNumberLength from './helpers/checkNumberLength.js';\n\n/**\r\n * Checks if a phone number is \"possible\" (basically just checks its length).\r\n *\r\n * isPossible(phoneNumberInstance, { ..., v2: true }, metadata)\r\n *\r\n * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)\r\n * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)\r\n *\r\n * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.\r\n * @param  {object} [options]\r\n * @param  {object} metadata\r\n * @return {string}\r\n */\nexport default function isPossiblePhoneNumber(input, options, metadata) {\n  /* istanbul ignore if */\n  if (options === undefined) {\n    options = {};\n  }\n  metadata = new Metadata(metadata);\n  if (options.v2) {\n    if (!input.countryCallingCode) {\n      throw new Error('Invalid phone number object passed');\n    }\n    metadata.selectNumberingPlan(input.countryCallingCode);\n  } else {\n    if (!input.phone) {\n      return false;\n    }\n    if (input.country) {\n      if (!metadata.hasCountry(input.country)) {\n        throw new Error(\"Unknown country: \".concat(input.country));\n      }\n      metadata.country(input.country);\n    } else {\n      if (!input.countryCallingCode) {\n        throw new Error('Invalid phone number object passed');\n      }\n      metadata.selectNumberingPlan(input.countryCallingCode);\n    }\n  }\n\n  // Old metadata (< 1.0.18) had no \"possible length\" data.\n  if (metadata.possibleLengths()) {\n    return isPossibleNumber(input.phone || input.nationalNumber, metadata);\n  } else {\n    // There was a bug between `1.7.35` and `1.7.37` where \"possible_lengths\"\n    // were missing for \"non-geographical\" numbering plans.\n    // Just assume the number is possible in such cases:\n    // it's unlikely that anyone generated their custom metadata\n    // in that short period of time (one day).\n    // This code can be removed in some future major version update.\n    if (input.countryCallingCode && metadata.isNonGeographicCallingCode(input.countryCallingCode)) {\n      // \"Non-geographic entities\" did't have `possibleLengths`\n      // due to a bug in metadata generation process.\n      return true;\n    } else {\n      throw new Error('Missing \"possibleLengths\" in metadata. Perhaps the metadata has been generated before v1.0.18.');\n    }\n  }\n}\nexport function isPossibleNumber(nationalNumber, metadata) {\n  //, isInternational) {\n  switch (checkNumberLength(nationalNumber, metadata)) {\n    case 'IS_POSSIBLE':\n      return true;\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    // \treturn !isInternational\n    default:\n      return false;\n  }\n}\n//# sourceMappingURL=isPossible.js.map"],"names":["isPossiblePhoneNumber","input","options","metadata","undefined","Metadata","v2","countryCallingCode","Error","selectNumberingPlan","phone","country","hasCountry","concat","possibleLengths","isPossibleNumber","nationalNumber","isNonGeographicCallingCode","checkNumberLength"],"mappings":";;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,qBAAqBA,CAACC,KAAK,EAAEC,OAAO,EAAEC,QAAQ,EAAE;AACvE;EACA,IAAID,OAAO,KAAKE,SAAS,EAAE;IAC1BF,OAAO,GAAG,EAAE;AACb,EAAA;AAEAC,EAAAA,QAAQ,GAAG,IAAIE,QAAQ,CAACF,QAAQ,CAAC;EAEjC,IAAID,OAAO,CAACI,EAAE,EAAE;AACf,IAAA,IAAI,CAACL,KAAK,CAACM,kBAAkB,EAAE;AAC9B,MAAA,MAAM,IAAIC,KAAK,CAAC,oCAAoC,CAAC;AACtD,IAAA;AACAL,IAAAA,QAAQ,CAACM,mBAAmB,CAACR,KAAK,CAACM,kBAAkB,CAAC;AACvD,EAAA,CAAC,MAAM;AACN,IAAA,IAAI,CAACN,KAAK,CAACS,KAAK,EAAE;AACjB,MAAA,OAAO,KAAK;AACb,IAAA;IACA,IAAIT,KAAK,CAACU,OAAO,EAAE;MAClB,IAAI,CAACR,QAAQ,CAACS,UAAU,CAACX,KAAK,CAACU,OAAO,CAAC,EAAE;QACxC,MAAM,IAAIH,KAAK,CAAA,mBAAA,CAAAK,MAAA,CAAqBZ,KAAK,CAACU,OAAO,CAAE,CAAC;AACrD,MAAA;AACAR,MAAAA,QAAQ,CAACQ,OAAO,CAACV,KAAK,CAACU,OAAO,CAAC;AAChC,IAAA,CAAC,MAAM;AACN,MAAA,IAAI,CAACV,KAAK,CAACM,kBAAkB,EAAE;AAC9B,QAAA,MAAM,IAAIC,KAAK,CAAC,oCAAoC,CAAC;AACtD,MAAA;AACAL,MAAAA,QAAQ,CAACM,mBAAmB,CAACR,KAAK,CAACM,kBAAkB,CAAC;AACvD,IAAA;AACD,EAAA;;AAEA;AACA,EAAA,IAAIJ,QAAQ,CAACW,eAAe,EAAE,EAAE;IAC/B,OAAOC,gBAAgB,CAACd,KAAK,CAACS,KAAK,IAAIT,KAAK,CAACe,cAAc,EAAEb,QAAQ,CAAC;AACvE,EAAA,CAAC,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,IAAA,IAAIF,KAAK,CAACM,kBAAkB,IAAIJ,QAAQ,CAACc,0BAA0B,CAAChB,KAAK,CAACM,kBAAkB,CAAC,EAAE;AAC9F;AACA;AACA,MAAA,OAAO,IAAI;AACZ,IAAA,CAAC,MAAM;AACN,MAAA,MAAM,IAAIC,KAAK,CAAC,gGAAgG,CAAC;AAClH,IAAA;AACD,EAAA;AACD;AAEO,SAASO,gBAAgBA,CAACC,cAAc,EAAEb,QAAQ,EAAE;AAAE;AAC5D,EAAA,QAAQe,iBAAiB,CAACF,cAAc,EAAEb,QAAQ,CAAC;AAClD,IAAA,KAAK,aAAa;AACjB,MAAA,OAAO,IAAI;AACZ;AACA;AACA;AACA;AACA,IAAA;AACC,MAAA,OAAO,KAAK;AACd;AACD;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"isPossible.js","sources":["../../../../node_modules/libphonenumber-js/es6/isPossible.js"],"sourcesContent":["import Metadata from './metadata.js';\nimport checkNumberLength from './helpers/checkNumberLength.js';\n\n/**\r\n * Checks if a phone number is \"possible\" (basically just checks its length).\r\n *\r\n * isPossible(phoneNumberInstance, { ..., v2: true }, metadata)\r\n *\r\n * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)\r\n * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)\r\n *\r\n * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.\r\n * @param  {object} [options]\r\n * @param  {object} metadata\r\n * @return {string}\r\n */\nexport default function isPossiblePhoneNumber(input, options, metadata) {\n  /* istanbul ignore if */\n  if (options === undefined) {\n    options = {};\n  }\n  metadata = new Metadata(metadata);\n  if (options.v2) {\n    if (!input.countryCallingCode) {\n      throw new Error('Invalid phone number object passed');\n    }\n    metadata.selectNumberingPlan(input.countryCallingCode);\n  } else {\n    if (!input.phone) {\n      return false;\n    }\n    if (input.country) {\n      if (!metadata.hasCountry(input.country)) {\n        throw new Error(\"Unknown country: \".concat(input.country));\n      }\n      metadata.selectNumberingPlan(input.country);\n    } else {\n      if (!input.countryCallingCode) {\n        throw new Error('Invalid phone number object passed');\n      }\n      metadata.selectNumberingPlan(input.countryCallingCode);\n    }\n  }\n\n  // Old metadata (< 1.0.18) had no \"possible length\" data.\n  if (metadata.possibleLengths()) {\n    return isPossibleNumber(input.phone || input.nationalNumber, input.country, metadata);\n  } else {\n    // There was a bug between `1.7.35` and `1.7.37` where \"possible_lengths\"\n    // were missing for \"non-geographical\" numbering plans.\n    // Just assume the number is possible in such cases:\n    // it's unlikely that anyone generated their custom metadata\n    // in that short period of time (one day).\n    // This code can be removed in some future major version update.\n    if (input.countryCallingCode && metadata.isNonGeographicCallingCode(input.countryCallingCode)) {\n      // \"Non-geographic entities\" did't have `possibleLengths`\n      // due to a bug in metadata generation process.\n      return true;\n    } else {\n      throw new Error('Missing \"possibleLengths\" in metadata. Perhaps the metadata has been generated before v1.0.18.');\n    }\n  }\n}\nexport function isPossibleNumber(nationalNumber, country, metadata) {\n  //, isInternational) {\n  switch (checkNumberLength(nationalNumber, country, metadata)) {\n    case 'IS_POSSIBLE':\n      return true;\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    // \treturn !isInternational\n    default:\n      return false;\n  }\n}\n//# sourceMappingURL=isPossible.js.map"],"names":["isPossiblePhoneNumber","input","options","metadata","undefined","Metadata","v2","countryCallingCode","Error","selectNumberingPlan","phone","country","hasCountry","concat","possibleLengths","isPossibleNumber","nationalNumber","isNonGeographicCallingCode","checkNumberLength"],"mappings":";;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,qBAAqBA,CAACC,KAAK,EAAEC,OAAO,EAAEC,QAAQ,EAAE;AACvE;EACA,IAAID,OAAO,KAAKE,SAAS,EAAE;IAC1BF,OAAO,GAAG,EAAE;AACb,EAAA;AAEAC,EAAAA,QAAQ,GAAG,IAAIE,QAAQ,CAACF,QAAQ,CAAC;EAEjC,IAAID,OAAO,CAACI,EAAE,EAAE;AACf,IAAA,IAAI,CAACL,KAAK,CAACM,kBAAkB,EAAE;AAC9B,MAAA,MAAM,IAAIC,KAAK,CAAC,oCAAoC,CAAC;AACtD,IAAA;AACAL,IAAAA,QAAQ,CAACM,mBAAmB,CAACR,KAAK,CAACM,kBAAkB,CAAC;AACvD,EAAA,CAAC,MAAM;AACN,IAAA,IAAI,CAACN,KAAK,CAACS,KAAK,EAAE;AACjB,MAAA,OAAO,KAAK;AACb,IAAA;IACA,IAAIT,KAAK,CAACU,OAAO,EAAE;MAClB,IAAI,CAACR,QAAQ,CAACS,UAAU,CAACX,KAAK,CAACU,OAAO,CAAC,EAAE;QACxC,MAAM,IAAIH,KAAK,CAAA,mBAAA,CAAAK,MAAA,CAAqBZ,KAAK,CAACU,OAAO,CAAE,CAAC;AACrD,MAAA;AACAR,MAAAA,QAAQ,CAACM,mBAAmB,CAACR,KAAK,CAACU,OAAO,CAAC;AAC5C,IAAA,CAAC,MAAM;AACN,MAAA,IAAI,CAACV,KAAK,CAACM,kBAAkB,EAAE;AAC9B,QAAA,MAAM,IAAIC,KAAK,CAAC,oCAAoC,CAAC;AACtD,MAAA;AACAL,MAAAA,QAAQ,CAACM,mBAAmB,CAACR,KAAK,CAACM,kBAAkB,CAAC;AACvD,IAAA;AACD,EAAA;;AAEA;AACA,EAAA,IAAIJ,QAAQ,CAACW,eAAe,EAAE,EAAE;AAC/B,IAAA,OAAOC,gBAAgB,CAACd,KAAK,CAACS,KAAK,IAAIT,KAAK,CAACe,cAAc,EAAEf,KAAK,CAACU,OAAO,EAAER,QAAQ,CAAC;AACtF,EAAA,CAAC,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,IAAA,IAAIF,KAAK,CAACM,kBAAkB,IAAIJ,QAAQ,CAACc,0BAA0B,CAAChB,KAAK,CAACM,kBAAkB,CAAC,EAAE;AAC9F;AACA;AACA,MAAA,OAAO,IAAI;AACZ,IAAA,CAAC,MAAM;AACN,MAAA,MAAM,IAAIC,KAAK,CAAC,gGAAgG,CAAC;AAClH,IAAA;AACD,EAAA;AACD;AAEO,SAASO,gBAAgBA,CAACC,cAAc,EAAEL,OAAO,EAAER,QAAQ,EAAE;AAAE;AACrE,EAAA,QAAQe,iBAAiB,CAACF,cAAc,EAAEL,OAAO,EAAER,QAAQ,CAAC;AAC3D,IAAA,KAAK,aAAa;AACjB,MAAA,OAAO,IAAI;AACZ;AACA;AACA;AACA;AACA,IAAA;AACC,MAAA,OAAO,KAAK;AACd;AACD;;;;","x_google_ignoreList":[0]}

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

@@ -601,7 +601,7 @@ var typeOf = function typeOf(_) {
 function getCountryCallingCode(country, metadata) {
   metadata = new Metadata(metadata);
   if (metadata.hasCountry(country)) {
-    return metadata.country(country).countryCallingCode();
+    return metadata.selectNumberingPlan(country).countryCallingCode();
   }
   throw new Error("Unknown country: ".concat(country));
 }