@aws-amplify/graphql-api-construct 1.1.0

package/node_modules/libphonenumber-js/es6/helpers/extension/createExtensionPattern.js

@@ -0,0 +1,108 @@
+import { VALID_DIGITS } from '../../constants'; // The RFC 3966 format for extensions.
+
+var RFC3966_EXTN_PREFIX = ';ext=';
+/**
+ * Helper method for constructing regular expressions for parsing. Creates
+ * an expression that captures up to max_length digits.
+ * @return {string} RegEx pattern to capture extension digits.
+ */
+
+var getExtensionDigitsPattern = function getExtensionDigitsPattern(maxLength) {
+  return "([".concat(VALID_DIGITS, "]{1,").concat(maxLength, "})");
+};
+/**
+ * Helper initialiser method to create the regular-expression pattern to match
+ * extensions.
+ * Copy-pasted from Google's `libphonenumber`:
+ * https://github.com/google/libphonenumber/blob/55b2646ec9393f4d3d6661b9c82ef9e258e8b829/javascript/i18n/phonenumbers/phonenumberutil.js#L759-L766
+ * @return {string} RegEx pattern to capture extensions.
+ */
+
+
+export default function createExtensionPattern(purpose) {
+  // We cap the maximum length of an extension based on the ambiguity of the way
+  // the extension is prefixed. As per ITU, the officially allowed length for
+  // extensions is actually 40, but we don't support this since we haven't seen real
+  // examples and this introduces many false interpretations as the extension labels
+  // are not standardized.
+
+  /** @type {string} */
+  var extLimitAfterExplicitLabel = '20';
+  /** @type {string} */
+
+  var extLimitAfterLikelyLabel = '15';
+  /** @type {string} */
+
+  var extLimitAfterAmbiguousChar = '9';
+  /** @type {string} */
+
+  var extLimitWhenNotSure = '6';
+  /** @type {string} */
+
+  var possibleSeparatorsBetweenNumberAndExtLabel = "[ \xA0\\t,]*"; // Optional full stop (.) or colon, followed by zero or more spaces/tabs/commas.
+
+  /** @type {string} */
+
+  var possibleCharsAfterExtLabel = "[:\\.\uFF0E]?[ \xA0\\t,-]*";
+  /** @type {string} */
+
+  var optionalExtnSuffix = "#?"; // Here the extension is called out in more explicit way, i.e mentioning it obvious
+  // patterns like "ext.".
+
+  /** @type {string} */
+
+  var explicitExtLabels = "(?:e?xt(?:ensi(?:o\u0301?|\xF3))?n?|\uFF45?\uFF58\uFF54\uFF4E?|\u0434\u043E\u0431|anexo)"; // One-character symbols that can be used to indicate an extension, and less
+  // commonly used or more ambiguous extension labels.
+
+  /** @type {string} */
+
+  var ambiguousExtLabels = "(?:[x\uFF58#\uFF03~\uFF5E]|int|\uFF49\uFF4E\uFF54)"; // When extension is not separated clearly.
+
+  /** @type {string} */
+
+  var ambiguousSeparator = "[- ]+"; // This is the same as possibleSeparatorsBetweenNumberAndExtLabel, but not matching
+  // comma as extension label may have it.
+
+  /** @type {string} */
+
+  var possibleSeparatorsNumberExtLabelNoComma = "[ \xA0\\t]*"; // ",," is commonly used for auto dialling the extension when connected. First
+  // comma is matched through possibleSeparatorsBetweenNumberAndExtLabel, so we do
+  // not repeat it here. Semi-colon works in Iphone and Android also to pop up a
+  // button with the extension number following.
+
+  /** @type {string} */
+
+  var autoDiallingAndExtLabelsFound = "(?:,{2}|;)";
+  /** @type {string} */
+
+  var rfcExtn = RFC3966_EXTN_PREFIX + getExtensionDigitsPattern(extLimitAfterExplicitLabel);
+  /** @type {string} */
+
+  var explicitExtn = possibleSeparatorsBetweenNumberAndExtLabel + explicitExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterExplicitLabel) + optionalExtnSuffix;
+  /** @type {string} */
+
+  var ambiguousExtn = possibleSeparatorsBetweenNumberAndExtLabel + ambiguousExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix;
+  /** @type {string} */
+
+  var americanStyleExtnWithSuffix = ambiguousSeparator + getExtensionDigitsPattern(extLimitWhenNotSure) + "#";
+  /** @type {string} */
+
+  var autoDiallingExtn = possibleSeparatorsNumberExtLabelNoComma + autoDiallingAndExtLabelsFound + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterLikelyLabel) + optionalExtnSuffix;
+  /** @type {string} */
+
+  var onlyCommasExtn = possibleSeparatorsNumberExtLabelNoComma + "(?:,)+" + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix; // The first regular expression covers RFC 3966 format, where the extension is added
+  // using ";ext=". The second more generic where extension is mentioned with explicit
+  // labels like "ext:". In both the above cases we allow more numbers in extension than
+  // any other extension labels. The third one captures when single character extension
+  // labels or less commonly used labels are used. In such cases we capture fewer
+  // extension digits in order to reduce the chance of falsely interpreting two
+  // numbers beside each other as a number + extension. The fourth one covers the
+  // special case of American numbers where the extension is written with a hash
+  // at the end, such as "- 503#". The fifth one is exclusively for extension
+  // autodialling formats which are used when dialling and in this case we accept longer
+  // extensions. The last one is more liberal on the number of commas that acts as
+  // extension labels, so we have a strict cap on the number of digits in such extensions.
+
+  return rfcExtn + "|" + explicitExtn + "|" + ambiguousExtn + "|" + americanStyleExtnWithSuffix + "|" + autoDiallingExtn + "|" + onlyCommasExtn;
+}
+//# sourceMappingURL=createExtensionPattern.js.map

package/node_modules/libphonenumber-js/es6/helpers/extension/createExtensionPattern.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../source/helpers/extension/createExtensionPattern.js"],"names":["VALID_DIGITS","RFC3966_EXTN_PREFIX","getExtensionDigitsPattern","maxLength","createExtensionPattern","purpose","extLimitAfterExplicitLabel","extLimitAfterLikelyLabel","extLimitAfterAmbiguousChar","extLimitWhenNotSure","possibleSeparatorsBetweenNumberAndExtLabel","possibleCharsAfterExtLabel","optionalExtnSuffix","explicitExtLabels","ambiguousExtLabels","ambiguousSeparator","possibleSeparatorsNumberExtLabelNoComma","autoDiallingAndExtLabelsFound","rfcExtn","explicitExtn","ambiguousExtn","americanStyleExtnWithSuffix","autoDiallingExtn","onlyCommasExtn"],"mappings":"AAAA,SAASA,YAAT,QAA6B,iBAA7B,C,CAEA;;AACA,IAAMC,mBAAmB,GAAG,OAA5B;AAEA;;;;;;AAKA,IAAMC,yBAAyB,GAAG,SAA5BA,yBAA4B,CAACC,SAAD;AAAA,qBAAoBH,YAApB,iBAAuCG,SAAvC;AAAA,CAAlC;AAEA;;;;;;;;;AAOA,eAAe,SAASC,sBAAT,CAAgCC,OAAhC,EAAyC;AACvD;AACA;AACA;AACA;AACA;;AACA;AACA,MAAIC,0BAA0B,GAAG,IAAjC;AACA;;AACA,MAAIC,wBAAwB,GAAG,IAA/B;AACA;;AACA,MAAIC,0BAA0B,GAAG,GAAjC;AACA;;AACA,MAAIC,mBAAmB,GAAG,GAA1B;AAEA;;AACA,MAAIC,0CAA0C,GAAG,cAAjD,CAhBuD,CAiBvD;;AACA;;AACA,MAAIC,0BAA0B,GAAG,4BAAjC;AACA;;AACA,MAAIC,kBAAkB,GAAG,IAAzB,CArBuD,CAuBvD;AACA;;AACA;;AACA,MAAIC,iBAAiB,GACnB,0FADF,CA1BuD,CA4BvD;AACA;;AACA;;AACA,MAAIC,kBAAkB,GAAG,oDAAzB,CA/BuD,CAgCvD;;AACA;;AACA,MAAIC,kBAAkB,GAAG,OAAzB,CAlCuD,CAmCvD;AACA;;AACA;;AACA,MAAIC,uCAAuC,GAAG,aAA9C,CAtCuD,CAuCvD;AACA;AACA;AACA;;AACA;;AACA,MAAIC,6BAA6B,GAAG,YAApC;AAEA;;AACA,MAAIC,OAAO,GAAGjB,mBAAmB,GAC1BC,yBAAyB,CAACI,0BAAD,CADhC;AAEA;;AACA,MAAIa,YAAY,GAAGT,0CAA0C,GAAGG,iBAA7C,GACZF,0BADY,GAEZT,yBAAyB,CAACI,0BAAD,CAFb,GAGZM,kBAHP;AAIA;;AACA,MAAIQ,aAAa,GAAGV,0CAA0C,GAAGI,kBAA7C,GACbH,0BADa,GAElBT,yBAAyB,CAACM,0BAAD,CAFP,GAGlBI,kBAHF;AAIA;;AACA,MAAIS,2BAA2B,GAAGN,kBAAkB,GAClDb,yBAAyB,CAACO,mBAAD,CADO,GACiB,GADnD;AAGA;;AACA,MAAIa,gBAAgB,GAAGN,uCAAuC,GACvDC,6BADgB,GACgBN,0BADhB,GAEhBT,yBAAyB,CAACK,wBAAD,CAFT,GAGrBK,kBAHF;AAIA;;AACA,MAAIW,cAAc,GAAGP,uCAAuC,GACtD,QADe,GACJL,0BADI,GAEfT,yBAAyB,CAACM,0BAAD,CAFV,GAGfI,kBAHN,CArEuD,CA0EvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAAOM,OAAO,GAAG,GAAV,GACEC,YADF,GACiB,GADjB,GAEEC,aAFF,GAEkB,GAFlB,GAGEC,2BAHF,GAGgC,GAHhC,GAIEC,gBAJF,GAIqB,GAJrB,GAKEC,cALT;AAMA","sourcesContent":["import { VALID_DIGITS } from '../../constants'\r\n\r\n// The RFC 3966 format for extensions.\r\nconst RFC3966_EXTN_PREFIX = ';ext='\r\n\r\n/**\r\n * Helper method for constructing regular expressions for parsing. Creates\r\n * an expression that captures up to max_length digits.\r\n * @return {string} RegEx pattern to capture extension digits.\r\n */\r\nconst getExtensionDigitsPattern = (maxLength) => `([${VALID_DIGITS}]{1,${maxLength}})`\r\n\r\n/**\r\n * Helper initialiser method to create the regular-expression pattern to match\r\n * extensions.\r\n * Copy-pasted from Google's `libphonenumber`:\r\n * https://github.com/google/libphonenumber/blob/55b2646ec9393f4d3d6661b9c82ef9e258e8b829/javascript/i18n/phonenumbers/phonenumberutil.js#L759-L766\r\n * @return {string} RegEx pattern to capture extensions.\r\n */\r\nexport default function createExtensionPattern(purpose) {\r\n\t// We cap the maximum length of an extension based on the ambiguity of the way\r\n\t// the extension is prefixed. As per ITU, the officially allowed length for\r\n\t// extensions is actually 40, but we don't support this since we haven't seen real\r\n\t// examples and this introduces many false interpretations as the extension labels\r\n\t// are not standardized.\r\n\t/** @type {string} */\r\n\tvar extLimitAfterExplicitLabel = '20';\r\n\t/** @type {string} */\r\n\tvar extLimitAfterLikelyLabel = '15';\r\n\t/** @type {string} */\r\n\tvar extLimitAfterAmbiguousChar = '9';\r\n\t/** @type {string} */\r\n\tvar extLimitWhenNotSure = '6';\r\n\r\n\t/** @type {string} */\r\n\tvar possibleSeparatorsBetweenNumberAndExtLabel = \"[ \\u00A0\\\\t,]*\";\r\n\t// Optional full stop (.) or colon, followed by zero or more spaces/tabs/commas.\r\n\t/** @type {string} */\r\n\tvar possibleCharsAfterExtLabel = \"[:\\\\.\\uFF0E]?[ \\u00A0\\\\t,-]*\";\r\n\t/** @type {string} */\r\n\tvar optionalExtnSuffix = \"#?\";\r\n\r\n\t// Here the extension is called out in more explicit way, i.e mentioning it obvious\r\n\t// patterns like \"ext.\".\r\n\t/** @type {string} */\r\n\tvar explicitExtLabels =\r\n\t  \"(?:e?xt(?:ensi(?:o\\u0301?|\\u00F3))?n?|\\uFF45?\\uFF58\\uFF54\\uFF4E?|\\u0434\\u043E\\u0431|anexo)\";\r\n\t// One-character symbols that can be used to indicate an extension, and less\r\n\t// commonly used or more ambiguous extension labels.\r\n\t/** @type {string} */\r\n\tvar ambiguousExtLabels = \"(?:[x\\uFF58#\\uFF03~\\uFF5E]|int|\\uFF49\\uFF4E\\uFF54)\";\r\n\t// When extension is not separated clearly.\r\n\t/** @type {string} */\r\n\tvar ambiguousSeparator = \"[- ]+\";\r\n\t// This is the same as possibleSeparatorsBetweenNumberAndExtLabel, but not matching\r\n\t// comma as extension label may have it.\r\n\t/** @type {string} */\r\n\tvar possibleSeparatorsNumberExtLabelNoComma = \"[ \\u00A0\\\\t]*\";\r\n\t// \",,\" is commonly used for auto dialling the extension when connected. First\r\n\t// comma is matched through possibleSeparatorsBetweenNumberAndExtLabel, so we do\r\n\t// not repeat it here. Semi-colon works in Iphone and Android also to pop up a\r\n\t// button with the extension number following.\r\n\t/** @type {string} */\r\n\tvar autoDiallingAndExtLabelsFound = \"(?:,{2}|;)\";\r\n\r\n\t/** @type {string} */\r\n\tvar rfcExtn = RFC3966_EXTN_PREFIX\r\n\t     + getExtensionDigitsPattern(extLimitAfterExplicitLabel);\r\n\t/** @type {string} */\r\n\tvar explicitExtn = possibleSeparatorsBetweenNumberAndExtLabel + explicitExtLabels\r\n\t     + possibleCharsAfterExtLabel\r\n\t     + getExtensionDigitsPattern(extLimitAfterExplicitLabel)\r\n\t     + optionalExtnSuffix;\r\n\t/** @type {string} */\r\n\tvar ambiguousExtn = possibleSeparatorsBetweenNumberAndExtLabel + ambiguousExtLabels\r\n\t     + possibleCharsAfterExtLabel\r\n\t+ getExtensionDigitsPattern(extLimitAfterAmbiguousChar)\r\n\t+ optionalExtnSuffix;\r\n\t/** @type {string} */\r\n\tvar americanStyleExtnWithSuffix = ambiguousSeparator\r\n\t+ getExtensionDigitsPattern(extLimitWhenNotSure) + \"#\";\r\n\r\n\t/** @type {string} */\r\n\tvar autoDiallingExtn = possibleSeparatorsNumberExtLabelNoComma\r\n\t     + autoDiallingAndExtLabelsFound + possibleCharsAfterExtLabel\r\n\t     + getExtensionDigitsPattern(extLimitAfterLikelyLabel)\r\n\t+ optionalExtnSuffix;\r\n\t/** @type {string} */\r\n\tvar onlyCommasExtn = possibleSeparatorsNumberExtLabelNoComma\r\n\t    + \"(?:,)+\" + possibleCharsAfterExtLabel\r\n\t    + getExtensionDigitsPattern(extLimitAfterAmbiguousChar)\r\n\t    + optionalExtnSuffix;\r\n\r\n\t// The first regular expression covers RFC 3966 format, where the extension is added\r\n\t// using \";ext=\". The second more generic where extension is mentioned with explicit\r\n\t// labels like \"ext:\". In both the above cases we allow more numbers in extension than\r\n\t// any other extension labels. The third one captures when single character extension\r\n\t// labels or less commonly used labels are used. In such cases we capture fewer\r\n\t// extension digits in order to reduce the chance of falsely interpreting two\r\n\t// numbers beside each other as a number + extension. The fourth one covers the\r\n\t// special case of American numbers where the extension is written with a hash\r\n\t// at the end, such as \"- 503#\". The fifth one is exclusively for extension\r\n\t// autodialling formats which are used when dialling and in this case we accept longer\r\n\t// extensions. The last one is more liberal on the number of commas that acts as\r\n\t// extension labels, so we have a strict cap on the number of digits in such extensions.\r\n\treturn rfcExtn + \"|\"\r\n\t       + explicitExtn + \"|\"\r\n\t       + ambiguousExtn + \"|\"\r\n\t       + americanStyleExtnWithSuffix + \"|\"\r\n\t       + autoDiallingExtn + \"|\"\r\n\t       + onlyCommasExtn;\r\n}"],"file":"createExtensionPattern.js"}

package/node_modules/libphonenumber-js/es6/helpers/extension/extractExtension.js

@@ -0,0 +1,32 @@
+import createExtensionPattern from './createExtensionPattern'; // Regexp of all known extension prefixes used by different regions followed by
+// 1 or more valid digits, for use when parsing.
+
+var EXTN_PATTERN = new RegExp('(?:' + createExtensionPattern() + ')$', 'i'); // Strips any extension (as in, the part of the number dialled after the call is
+// connected, usually indicated with extn, ext, x or similar) from the end of
+// the number, and returns it.
+
+export default function extractExtension(number) {
+  var start = number.search(EXTN_PATTERN);
+
+  if (start < 0) {
+    return {};
+  } // If we find a potential extension, and the number preceding this is a viable
+  // number, we assume it is an extension.
+
+
+  var numberWithoutExtension = number.slice(0, start);
+  var matches = number.match(EXTN_PATTERN);
+  var i = 1;
+
+  while (i < matches.length) {
+    if (matches[i]) {
+      return {
+        number: numberWithoutExtension,
+        ext: matches[i]
+      };
+    }
+
+    i++;
+  }
+}
+//# sourceMappingURL=extractExtension.js.map

package/node_modules/libphonenumber-js/es6/helpers/extension/extractExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../source/helpers/extension/extractExtension.js"],"names":["createExtensionPattern","EXTN_PATTERN","RegExp","extractExtension","number","start","search","numberWithoutExtension","slice","matches","match","i","length","ext"],"mappings":"AAAA,OAAOA,sBAAP,MAAmC,0BAAnC,C,CAEA;AACA;;AACA,IAAMC,YAAY,GAAG,IAAIC,MAAJ,CAAW,QAAQF,sBAAsB,EAA9B,GAAmC,IAA9C,EAAoD,GAApD,CAArB,C,CAEA;AACA;AACA;;AACA,eAAe,SAASG,gBAAT,CAA0BC,MAA1B,EAAkC;AAChD,MAAMC,KAAK,GAAGD,MAAM,CAACE,MAAP,CAAcL,YAAd,CAAd;;AACA,MAAII,KAAK,GAAG,CAAZ,EAAe;AACd,WAAO,EAAP;AACA,GAJ+C,CAKhD;AACA;;;AACA,MAAME,sBAAsB,GAAGH,MAAM,CAACI,KAAP,CAAa,CAAb,EAAgBH,KAAhB,CAA/B;AACA,MAAMI,OAAO,GAAGL,MAAM,CAACM,KAAP,CAAaT,YAAb,CAAhB;AACA,MAAIU,CAAC,GAAG,CAAR;;AACA,SAAOA,CAAC,GAAGF,OAAO,CAACG,MAAnB,EAA2B;AAC1B,QAAIH,OAAO,CAACE,CAAD,CAAX,EAAgB;AACf,aAAO;AACNP,QAAAA,MAAM,EAAEG,sBADF;AAENM,QAAAA,GAAG,EAAEJ,OAAO,CAACE,CAAD;AAFN,OAAP;AAIA;;AACDA,IAAAA,CAAC;AACD;AACD","sourcesContent":["import createExtensionPattern from './createExtensionPattern'\r\n\r\n// Regexp of all known extension prefixes used by different regions followed by\r\n// 1 or more valid digits, for use when parsing.\r\nconst EXTN_PATTERN = new RegExp('(?:' + createExtensionPattern() + ')$', 'i')\r\n\r\n// Strips any extension (as in, the part of the number dialled after the call is\r\n// connected, usually indicated with extn, ext, x or similar) from the end of\r\n// the number, and returns it.\r\nexport default function extractExtension(number) {\r\n\tconst start = number.search(EXTN_PATTERN)\r\n\tif (start < 0) {\r\n\t\treturn {}\r\n\t}\r\n\t// If we find a potential extension, and the number preceding this is a viable\r\n\t// number, we assume it is an extension.\r\n\tconst numberWithoutExtension = number.slice(0, start)\r\n\tconst matches = number.match(EXTN_PATTERN)\r\n\tlet i = 1\r\n\twhile (i < matches.length) {\r\n\t\tif (matches[i]) {\r\n\t\t\treturn {\r\n\t\t\t\tnumber: numberWithoutExtension,\r\n\t\t\t\text: matches[i]\r\n\t\t\t}\r\n\t\t}\r\n\t\ti++\r\n\t}\r\n}"],"file":"extractExtension.js"}

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

@@ -0,0 +1,102 @@
+import stripIddPrefix from './stripIddPrefix';
+import extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './extractCountryCallingCodeFromInternationalNumberWithoutPlusSign';
+import Metadata from '../metadata';
+import { MAX_LENGTH_COUNTRY_CODE } from '../constants';
+/**
+ * Converts a phone number digits (possibly with a `+`)
+ * into a calling code and the rest phone number digits.
+ * The "rest phone number digits" could include
+ * 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  {object} metadata
+ * @return {object} `{ 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)
+ */
+
+export default function extractCountryCallingCode(number, country, callingCode, metadata) {
+  if (!number) {
+    return {};
+  } // If this is not an international phone number,
+  // then either extract an "IDD" prefix, or extract a
+  // country calling code from a number by autocorrecting it
+  // by prepending a leading `+` in cases when it starts
+  // with the country calling code.
+  // https://wikitravel.org/en/International_dialling_prefix
+  // https://github.com/catamphetamine/libphonenumber-js/issues/376
+
+
+  if (number[0] !== '+') {
+    // Convert an "out-of-country" dialing phone number
+    // to a proper international phone number.
+    var numberWithoutIDD = stripIddPrefix(number, country, callingCode, metadata); // If an IDD prefix was stripped then
+    // convert the number to international one
+    // for subsequent parsing.
+
+    if (numberWithoutIDD && numberWithoutIDD !== number) {
+      number = '+' + numberWithoutIDD;
+    } else {
+      // Check to see if the number starts with the country calling code
+      // 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),
+            countryCallingCode = _extractCountryCallin.countryCallingCode,
+            shorterNumber = _extractCountryCallin.number;
+
+        if (countryCallingCode) {
+          return {
+            countryCallingCode: countryCallingCode,
+            number: shorterNumber
+          };
+        }
+      }
+
+      return {
+        number: number
+      };
+    }
+  } // Fast abortion: country codes do not begin with a '0'
+
+
+  if (number[1] === '0') {
+    return {};
+  }
+
+  metadata = new Metadata(metadata); // The thing with country phone codes
+  // is that they are orthogonal to each other
+  // i.e. there's no such country phone code A
+  // for which country phone code B exists
+  // where B starts with A.
+  // Therefore, while scanning digits,
+  // if a valid country code is found,
+  // that means that it is the country code.
+  //
+
+  var i = 2;
+
+  while (i - 1 <= MAX_LENGTH_COUNTRY_CODE && i <= number.length) {
+    var _countryCallingCode = number.slice(1, i);
+
+    if (metadata.hasCallingCode(_countryCallingCode)) {
+      metadata.selectNumberingPlan(_countryCallingCode);
+      return {
+        countryCallingCode: _countryCallingCode,
+        number: number.slice(i)
+      };
+    }
+
+    i++;
+  }
+
+  return {};
+}
+//# sourceMappingURL=extractCountryCallingCode.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/extractCountryCallingCode.js"],"names":["stripIddPrefix","extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","Metadata","MAX_LENGTH_COUNTRY_CODE","extractCountryCallingCode","number","country","callingCode","metadata","numberWithoutIDD","countryCallingCode","shorterNumber","i","length","slice","hasCallingCode","selectNumberingPlan"],"mappings":"AAAA,OAAOA,cAAP,MAA2B,kBAA3B;AACA,OAAOC,+DAAP,MAA4E,mEAA5E;AACA,OAAOC,QAAP,MAAqB,aAArB;AACA,SAASC,uBAAT,QAAwC,cAAxC;AAEA;;;;;;;;;;;;;;;;;;;AAkBA,eAAe,SAASC,yBAAT,CACdC,MADc,EAEdC,OAFc,EAGdC,WAHc,EAIdC,QAJc,EAKb;AACD,MAAI,CAACH,MAAL,EAAa;AACZ,WAAO,EAAP;AACA,GAHA,CAKD;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,MAAIA,MAAM,CAAC,CAAD,CAAN,KAAc,GAAlB,EAAuB;AACtB;AACA;AACA,QAAMI,gBAAgB,GAAGT,cAAc,CAACK,MAAD,EAASC,OAAT,EAAkBC,WAAlB,EAA+BC,QAA/B,CAAvC,CAHsB,CAItB;AACA;AACA;;AACA,QAAIC,gBAAgB,IAAIA,gBAAgB,KAAKJ,MAA7C,EAAqD;AACpDA,MAAAA,MAAM,GAAG,MAAMI,gBAAf;AACA,KAFD,MAEO;AACN;AACA;AACA;AACA;AACA,UAAIH,OAAO,IAAIC,WAAf,EAA4B;AAAA,oCAIvBN,+DAA+D,CAClEI,MADkE,EAElEC,OAFkE,EAGlEC,WAHkE,EAIlEC,QAJkE,CAJxC;AAAA,YAE1BE,kBAF0B,yBAE1BA,kBAF0B;AAAA,YAGlBC,aAHkB,yBAG1BN,MAH0B;;AAU3B,YAAIK,kBAAJ,EAAwB;AACvB,iBAAO;AACNA,YAAAA,kBAAkB,EAAlBA,kBADM;AAENL,YAAAA,MAAM,EAAEM;AAFF,WAAP;AAIA;AACD;;AACD,aAAO;AAAEN,QAAAA,MAAM,EAANA;AAAF,OAAP;AACA;AACD,GA7CA,CA+CD;;;AACA,MAAIA,MAAM,CAAC,CAAD,CAAN,KAAc,GAAlB,EAAuB;AACtB,WAAO,EAAP;AACA;;AAEDG,EAAAA,QAAQ,GAAG,IAAIN,QAAJ,CAAaM,QAAb,CAAX,CApDC,CAsDD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,MAAII,CAAC,GAAG,CAAR;;AACA,SAAOA,CAAC,GAAG,CAAJ,IAAST,uBAAT,IAAoCS,CAAC,IAAIP,MAAM,CAACQ,MAAvD,EAA+D;AAC9D,QAAMH,mBAAkB,GAAGL,MAAM,CAACS,KAAP,CAAa,CAAb,EAAgBF,CAAhB,CAA3B;;AACA,QAAIJ,QAAQ,CAACO,cAAT,CAAwBL,mBAAxB,CAAJ,EAAiD;AAChDF,MAAAA,QAAQ,CAACQ,mBAAT,CAA6BN,mBAA7B;AACA,aAAO;AACNA,QAAAA,kBAAkB,EAAlBA,mBADM;AAENL,QAAAA,MAAM,EAAEA,MAAM,CAACS,KAAP,CAAaF,CAAb;AAFF,OAAP;AAIA;;AACDA,IAAAA,CAAC;AACD;;AAED,SAAO,EAAP;AACA","sourcesContent":["import stripIddPrefix from './stripIddPrefix'\r\nimport extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './extractCountryCallingCodeFromInternationalNumberWithoutPlusSign'\r\nimport Metadata from '../metadata'\r\nimport { MAX_LENGTH_COUNTRY_CODE } from '../constants'\r\n\r\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} `{ 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 */\r\nexport default function extractCountryCallingCode(\r\n\tnumber,\r\n\tcountry,\r\n\tcallingCode,\r\n\tmetadata\r\n) {\r\n\tif (!number) {\r\n\t\treturn {}\r\n\t}\r\n\r\n\t// If this is not an international phone number,\r\n\t// then either extract an \"IDD\" prefix, or extract a\r\n\t// country calling code from a number by autocorrecting it\r\n\t// by prepending a leading `+` in cases when it starts\r\n\t// with the country calling code.\r\n\t// https://wikitravel.org/en/International_dialling_prefix\r\n\t// https://github.com/catamphetamine/libphonenumber-js/issues/376\r\n\tif (number[0] !== '+') {\r\n\t\t// Convert an \"out-of-country\" dialing phone number\r\n\t\t// to a proper international phone number.\r\n\t\tconst numberWithoutIDD = stripIddPrefix(number, country, callingCode, metadata)\r\n\t\t// If an IDD prefix was stripped then\r\n\t\t// convert the number to international one\r\n\t\t// for subsequent parsing.\r\n\t\tif (numberWithoutIDD && numberWithoutIDD !== number) {\r\n\t\t\tnumber = '+' + numberWithoutIDD\r\n\t\t} else {\r\n\t\t\t// Check to see if the number starts with the country calling code\r\n\t\t\t// for the default country. If so, we remove the country calling code,\r\n\t\t\t// and do some checks on the validity of the number before and after.\r\n\t\t\t// https://github.com/catamphetamine/libphonenumber-js/issues/376\r\n\t\t\tif (country || callingCode) {\r\n\t\t\t\tconst {\r\n\t\t\t\t\tcountryCallingCode,\r\n\t\t\t\t\tnumber: shorterNumber\r\n\t\t\t\t} = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(\r\n\t\t\t\t\tnumber,\r\n\t\t\t\t\tcountry,\r\n\t\t\t\t\tcallingCode,\r\n\t\t\t\t\tmetadata\r\n\t\t\t\t)\r\n\t\t\t\tif (countryCallingCode) {\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\tcountryCallingCode,\r\n\t\t\t\t\t\tnumber: shorterNumber\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn { number }\r\n\t\t}\r\n\t}\r\n\r\n\t// Fast abortion: country codes do not begin with a '0'\r\n\tif (number[1] === '0') {\r\n\t\treturn {}\r\n\t}\r\n\r\n\tmetadata = new Metadata(metadata)\r\n\r\n\t// The thing with country phone codes\r\n\t// is that they are orthogonal to each other\r\n\t// i.e. there's no such country phone code A\r\n\t// for which country phone code B exists\r\n\t// where B starts with A.\r\n\t// Therefore, while scanning digits,\r\n\t// if a valid country code is found,\r\n\t// that means that it is the country code.\r\n\t//\r\n\tlet i = 2\r\n\twhile (i - 1 <= MAX_LENGTH_COUNTRY_CODE && i <= number.length) {\r\n\t\tconst countryCallingCode = number.slice(1, i)\r\n\t\tif (metadata.hasCallingCode(countryCallingCode)) {\r\n\t\t\tmetadata.selectNumberingPlan(countryCallingCode)\r\n\t\t\treturn {\r\n\t\t\t\tcountryCallingCode,\r\n\t\t\t\tnumber: number.slice(i)\r\n\t\t\t}\r\n\t\t}\r\n\t\ti++\r\n\t}\r\n\r\n\treturn {}\r\n}"],"file":"extractCountryCallingCode.js"}

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

@@ -0,0 +1,16 @@
+import extractCountryCallingCode from './extractCountryCallingCode';
+import metadata from '../../metadata.min.json';
+describe('extractCountryCallingCode', function () {
+  it('should extract country calling code from a number', function () {
+    extractCountryCallingCode('+78005553535', null, null, metadata).should.deep.equal({
+      countryCallingCode: '7',
+      number: '8005553535'
+    });
+    extractCountryCallingCode('+7800', null, null, metadata).should.deep.equal({
+      countryCallingCode: '7',
+      number: '800'
+    });
+    extractCountryCallingCode('', null, null, metadata).should.deep.equal({});
+  });
+});
+//# sourceMappingURL=extractCountryCallingCode.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/extractCountryCallingCode.test.js"],"names":["extractCountryCallingCode","metadata","describe","it","should","deep","equal","countryCallingCode","number"],"mappings":"AAAA,OAAOA,yBAAP,MAAsC,6BAAtC;AACA,OAAOC,QAAP,MAAqB,yBAArB;AAEAC,QAAQ,CAAC,2BAAD,EAA8B,YAAM;AAC3CC,EAAAA,EAAE,CAAC,mDAAD,EAAsD,YAAM;AAC7DH,IAAAA,yBAAyB,CAAC,cAAD,EAAiB,IAAjB,EAAuB,IAAvB,EAA6BC,QAA7B,CAAzB,CAAgEG,MAAhE,CAAuEC,IAAvE,CAA4EC,KAA5E,CAAkF;AACjFC,MAAAA,kBAAkB,EAAE,GAD6D;AAEjFC,MAAAA,MAAM,EAAE;AAFyE,KAAlF;AAKAR,IAAAA,yBAAyB,CAAC,OAAD,EAAU,IAAV,EAAgB,IAAhB,EAAsBC,QAAtB,CAAzB,CAAyDG,MAAzD,CAAgEC,IAAhE,CAAqEC,KAArE,CAA2E;AAC1EC,MAAAA,kBAAkB,EAAE,GADsD;AAE1EC,MAAAA,MAAM,EAAE;AAFkE,KAA3E;AAKAR,IAAAA,yBAAyB,CAAC,EAAD,EAAK,IAAL,EAAW,IAAX,EAAiBC,QAAjB,CAAzB,CAAoDG,MAApD,CAA2DC,IAA3D,CAAgEC,KAAhE,CAAsE,EAAtE;AACA,GAZC,CAAF;AAaA,CAdO,CAAR","sourcesContent":["import extractCountryCallingCode from './extractCountryCallingCode'\r\nimport metadata from '../../metadata.min.json'\r\n\r\ndescribe('extractCountryCallingCode', () => {\r\n\tit('should extract country calling code from a number', () => {\r\n\t\textractCountryCallingCode('+78005553535', null, null, metadata).should.deep.equal({\r\n\t\t\tcountryCallingCode: '7',\r\n\t\t\tnumber: '8005553535'\r\n\t\t})\r\n\r\n\t\textractCountryCallingCode('+7800', null, null, metadata).should.deep.equal({\r\n\t\t\tcountryCallingCode: '7',\r\n\t\t\tnumber: '800'\r\n\t\t})\r\n\r\n\t\textractCountryCallingCode('', null, null, metadata).should.deep.equal({})\r\n\t})\r\n})\r\n"],"file":"extractCountryCallingCode.test.js"}

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

@@ -0,0 +1,50 @@
+import Metadata from '../metadata';
+import matchesEntirely from './matchesEntirely';
+import extractNationalNumber from './extractNationalNumber';
+import checkNumberLength from './checkNumberLength';
+import getCountryCallingCode from '../getCountryCallingCode';
+/**
+ * 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  {object} metadata
+ * @return {object} `{ countryCallingCode: string?, number: string }`.
+ */
+
+export default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, callingCode, metadata) {
+  var countryCallingCode = country ? getCountryCallingCode(country, metadata) : callingCode;
+
+  if (number.indexOf(countryCallingCode) === 0) {
+    metadata = new Metadata(metadata);
+    metadata.selectNumberingPlan(country, callingCode);
+    var possibleShorterNumber = number.slice(countryCallingCode.length);
+
+    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, metadata),
+        possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;
+
+    var _extractNationalNumbe2 = extractNationalNumber(number, 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
+    // and keep that instead.
+    // For example, in Germany (+49), `49` is a valid area code,
+    // 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') {
+      return {
+        countryCallingCode: countryCallingCode,
+        number: possibleShorterNumber
+      };
+    }
+  }
+
+  return {
+    number: number
+  };
+}
+//# sourceMappingURL=extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js"],"names":["Metadata","matchesEntirely","extractNationalNumber","checkNumberLength","getCountryCallingCode","extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","number","country","callingCode","metadata","countryCallingCode","indexOf","selectNumberingPlan","possibleShorterNumber","slice","length","possibleShorterNationalNumber","nationalNumber","nationalNumberPattern"],"mappings":"AAAA,OAAOA,QAAP,MAAqB,aAArB;AACA,OAAOC,eAAP,MAA4B,mBAA5B;AACA,OAAOC,qBAAP,MAAkC,yBAAlC;AACA,OAAOC,iBAAP,MAA8B,qBAA9B;AACA,OAAOC,qBAAP,MAAkC,0BAAlC;AAEA;;;;;;;;;;AASA,eAAe,SAASC,+DAAT,CACdC,MADc,EAEdC,OAFc,EAGdC,WAHc,EAIdC,QAJc,EAKb;AACD,MAAMC,kBAAkB,GAAGH,OAAO,GAAGH,qBAAqB,CAACG,OAAD,EAAUE,QAAV,CAAxB,GAA8CD,WAAhF;;AACA,MAAIF,MAAM,CAACK,OAAP,CAAeD,kBAAf,MAAuC,CAA3C,EAA8C;AAC7CD,IAAAA,QAAQ,GAAG,IAAIT,QAAJ,CAAaS,QAAb,CAAX;AACAA,IAAAA,QAAQ,CAACG,mBAAT,CAA6BL,OAA7B,EAAsCC,WAAtC;AACA,QAAMK,qBAAqB,GAAGP,MAAM,CAACQ,KAAP,CAAaJ,kBAAkB,CAACK,MAAhC,CAA9B;;AAH6C,gCAMzCb,qBAAqB,CACxBW,qBADwB,EAExBJ,QAFwB,CANoB;AAAA,QAK5BO,6BAL4B,yBAK5CC,cAL4C;;AAAA,iCAYzCf,qBAAqB,CACxBI,MADwB,EAExBG,QAFwB,CAZoB;AAAA,QAW5CQ,cAX4C,0BAW5CA,cAX4C,EAgB7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,QAEE,CAAChB,eAAe,CAACgB,cAAD,EAAiBR,QAAQ,CAACS,qBAAT,EAAjB,CAAhB,IAEAjB,eAAe,CAACe,6BAAD,EAAgCP,QAAQ,CAACS,qBAAT,EAAhC,CAHhB,IAMAf,iBAAiB,CAACc,cAAD,EAAiBR,QAAjB,CAAjB,KAAgD,UAPjD,EAQE;AACD,aAAO;AACNC,QAAAA,kBAAkB,EAAlBA,kBADM;AAENJ,QAAAA,MAAM,EAAEO;AAFF,OAAP;AAIA;AACD;;AACD,SAAO;AAAEP,IAAAA,MAAM,EAANA;AAAF,GAAP;AACA","sourcesContent":["import Metadata from '../metadata'\r\nimport matchesEntirely from './matchesEntirely'\r\nimport extractNationalNumber from './extractNationalNumber'\r\nimport checkNumberLength from './checkNumberLength'\r\nimport getCountryCallingCode from '../getCountryCallingCode'\r\n\r\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 */\r\nexport default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(\r\n\tnumber,\r\n\tcountry,\r\n\tcallingCode,\r\n\tmetadata\r\n) {\r\n\tconst countryCallingCode = country ? getCountryCallingCode(country, metadata) : callingCode\r\n\tif (number.indexOf(countryCallingCode) === 0) {\r\n\t\tmetadata = new Metadata(metadata)\r\n\t\tmetadata.selectNumberingPlan(country, callingCode)\r\n\t\tconst possibleShorterNumber = number.slice(countryCallingCode.length)\r\n\t\tconst {\r\n\t\t\tnationalNumber: possibleShorterNationalNumber,\r\n\t\t} = extractNationalNumber(\r\n\t\t\tpossibleShorterNumber,\r\n\t\t\tmetadata\r\n\t\t)\r\n\t\tconst {\r\n\t\t\tnationalNumber\r\n\t\t} = extractNationalNumber(\r\n\t\t\tnumber,\r\n\t\t\tmetadata\r\n\t\t)\r\n\t\t// If the number was not valid before but is valid now,\r\n\t\t// or if it was too long before, we consider the number\r\n\t\t// with the country calling code stripped to be a better result\r\n\t\t// and keep that instead.\r\n\t\t// For example, in Germany (+49), `49` is a valid area code,\r\n\t\t// so if a number starts with `49`, it could be both a valid\r\n\t\t// national German number or an international number without\r\n\t\t// a leading `+`.\r\n\t\tif (\r\n\t\t\t(\r\n\t\t\t\t!matchesEntirely(nationalNumber, metadata.nationalNumberPattern())\r\n\t\t\t\t&&\r\n\t\t\t\tmatchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern())\r\n\t\t\t)\r\n\t\t\t||\r\n\t\t\tcheckNumberLength(nationalNumber, metadata) === 'TOO_LONG'\r\n\t\t) {\r\n\t\t\treturn {\r\n\t\t\t\tcountryCallingCode,\r\n\t\t\t\tnumber: possibleShorterNumber\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\treturn { number }\r\n}"],"file":"extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js"}

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

@@ -0,0 +1,98 @@
+import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber';
+import matchesEntirely from './matchesEntirely';
+import checkNumberLength from './checkNumberLength';
+/**
+ * Strips national prefix and carrier code from a complete phone number.
+ * The difference from the non-"FromCompleteNumber" function is that
+ * 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  {Metadata} metadata — Metadata with a phone numbering plan selected.
+ * @return {object} `{ nationalNumber: string, carrierCode: string? }`.
+ */
+
+export default function extractNationalNumber(number, metadata) {
+  // Parsing national prefixes and carrier codes
+  // is only required for local phone numbers
+  // but some people don't understand that
+  // and sometimes write international phone numbers
+  // with national prefixes (or maybe even carrier codes).
+  // http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html
+  // Google's original library forgives such mistakes
+  // and so does this library, because it has been requested:
+  // https://github.com/catamphetamine/libphonenumber-js/issues/127
+  var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(number, metadata),
+      nationalNumber = _extractNationalNumbe.nationalNumber,
+      carrierCode = _extractNationalNumbe.carrierCode;
+
+  if (!shouldExtractNationalPrefix(number, nationalNumber, metadata)) {
+    // Don't strip the national prefix.
+    return {
+      nationalNumber: number
+    };
+  } // If a national prefix has been extracted, check to see
+  // if the resultant number isn't too short.
+  // Same code in Google's `libphonenumber`:
+  // https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3291-L3302
+  // For some reason, they do this check right after the `national_number_pattern` check
+  // this library does in `shouldExtractNationalPrefix()` function.
+  // Why is there a second "resultant" number validity check?
+  // They don't provide an explanation.
+  // This library just copies the behavior.
+
+
+  if (number.length !== nationalNumber.length + (carrierCode ? carrierCode.length : 0)) {
+    // If not using legacy generated metadata (before version `1.0.18`)
+    // then it has "possible lengths", so use those to validate the number length.
+    if (metadata.possibleLengths()) {
+      // "We require that the NSN remaining after stripping the national prefix and
+      // carrier code be long enough to be a possible length for the region.
+      // Otherwise, we don't do the stripping, since the original number could be
+      // a valid short number."
+      // https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250
+      switch (checkNumberLength(nationalNumber, metadata)) {
+        case 'TOO_SHORT':
+        case 'INVALID_LENGTH':
+          // case 'IS_POSSIBLE_LOCAL_ONLY':
+          // Don't strip the national prefix.
+          return {
+            nationalNumber: number
+          };
+      }
+    }
+  }
+
+  return {
+    nationalNumber: nationalNumber,
+    carrierCode: carrierCode
+  };
+} // 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
+// in which `8` is not a national prefix, but the first digit
+// of a national (significant) number.
+// Same's with Belarus:
+// `82004910060` is a valid national (significant) number,
+// but `2004910060` is not.
+// To support such cases (to prevent the code from always stripping
+// national prefix), a condition is imposed: a national prefix
+// 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 shouldExtractNationalPrefix(number, nationalSignificantNumber, 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(number, metadata.nationalNumberPattern()) && !matchesEntirely(nationalSignificantNumber, metadata.nationalNumberPattern())) {
+    return false;
+  } // Just "possible" number check would be more relaxed, so it's not used.
+  // if (isPossibleNumber(number, metadata) &&
+  // 	!isPossibleNumber(numberWithNationalPrefixExtracted, metadata)) {
+  // 	return false
+  // }
+
+
+  return true;
+}
+//# sourceMappingURL=extractNationalNumber.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/extractNationalNumber.js"],"names":["extractNationalNumberFromPossiblyIncompleteNumber","matchesEntirely","checkNumberLength","extractNationalNumber","number","metadata","nationalNumber","carrierCode","shouldExtractNationalPrefix","length","possibleLengths","nationalSignificantNumber","nationalNumberPattern"],"mappings":"AAAA,OAAOA,iDAAP,MAA8D,qDAA9D;AACA,OAAOC,eAAP,MAA4B,mBAA5B;AACA,OAAOC,iBAAP,MAA8B,qBAA9B;AAEA;;;;;;;;;;AASA,eAAe,SAASC,qBAAT,CAA+BC,MAA/B,EAAuCC,QAAvC,EAAiD;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAT+D,8BAa3DL,iDAAiD,CACpDI,MADoD,EAEpDC,QAFoD,CAbU;AAAA,MAW9DC,cAX8D,yBAW9DA,cAX8D;AAAA,MAY9DC,WAZ8D,yBAY9DA,WAZ8D;;AAiB/D,MAAI,CAACC,2BAA2B,CAACJ,MAAD,EAASE,cAAT,EAAyBD,QAAzB,CAAhC,EAAoE;AACnE;AACA,WAAO;AAAEC,MAAAA,cAAc,EAAEF;AAAlB,KAAP;AACA,GApB8D,CAqB/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,MAAIA,MAAM,CAACK,MAAP,KAAkBH,cAAc,CAACG,MAAf,IAAyBF,WAAW,GAAGA,WAAW,CAACE,MAAf,GAAwB,CAA5D,CAAtB,EAAsF;AACrF;AACA;AACA,QAAIJ,QAAQ,CAACK,eAAT,EAAJ,EAAgC;AAC/B;AACA;AACA;AACA;AACA;AACA,cAAQR,iBAAiB,CAACI,cAAD,EAAiBD,QAAjB,CAAzB;AACC,aAAK,WAAL;AACA,aAAK,gBAAL;AACA;AACC;AACA,iBAAO;AAAEC,YAAAA,cAAc,EAAEF;AAAlB,WAAP;AALF;AAOA;AACD;;AACD,SAAO;AAAEE,IAAAA,cAAc,EAAdA,cAAF;AAAkBC,IAAAA,WAAW,EAAXA;AAAlB,GAAP;AACA,C,CAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASC,2BAAT,CAAqCJ,MAArC,EAA6CO,yBAA7C,EAAwEN,QAAxE,EAAkF;AACjF;AACA;AACA,MAAIJ,eAAe,CAACG,MAAD,EAASC,QAAQ,CAACO,qBAAT,EAAT,CAAf,IACH,CAACX,eAAe,CAACU,yBAAD,EAA4BN,QAAQ,CAACO,qBAAT,EAA5B,CADjB,EACgF;AAC/E,WAAO,KAAP;AACA,GANgF,CAOjF;AACA;AACA;AACA;AACA;;;AACA,SAAO,IAAP;AACA","sourcesContent":["import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber'\r\nimport matchesEntirely from './matchesEntirely'\r\nimport checkNumberLength from './checkNumberLength'\r\n\r\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 */\r\nexport default function extractNationalNumber(number, metadata) {\r\n\t// Parsing national prefixes and carrier codes\r\n\t// is only required for local phone numbers\r\n\t// but some people don't understand that\r\n\t// and sometimes write international phone numbers\r\n\t// with national prefixes (or maybe even carrier codes).\r\n\t// http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html\r\n\t// Google's original library forgives such mistakes\r\n\t// and so does this library, because it has been requested:\r\n\t// https://github.com/catamphetamine/libphonenumber-js/issues/127\r\n\tconst {\r\n\t\tnationalNumber,\r\n\t\tcarrierCode\r\n\t} = extractNationalNumberFromPossiblyIncompleteNumber(\r\n\t\tnumber,\r\n\t\tmetadata\r\n\t)\r\n\tif (!shouldExtractNationalPrefix(number, nationalNumber, metadata)) {\r\n\t\t// Don't strip the national prefix.\r\n\t\treturn { nationalNumber: number }\r\n\t}\r\n\t// If a national prefix has been extracted, check to see\r\n\t// if the resultant number isn't too short.\r\n\t// Same code in Google's `libphonenumber`:\r\n\t// https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3291-L3302\r\n\t// For some reason, they do this check right after the `national_number_pattern` check\r\n\t// this library does in `shouldExtractNationalPrefix()` function.\r\n\t// Why is there a second \"resultant\" number validity check?\r\n\t// They don't provide an explanation.\r\n\t// This library just copies the behavior.\r\n\tif (number.length !== nationalNumber.length + (carrierCode ? carrierCode.length : 0)) {\r\n\t\t// If not using legacy generated metadata (before version `1.0.18`)\r\n\t\t// then it has \"possible lengths\", so use those to validate the number length.\r\n\t\tif (metadata.possibleLengths()) {\r\n\t\t\t// \"We require that the NSN remaining after stripping the national prefix and\r\n\t\t\t// carrier code be long enough to be a possible length for the region.\r\n\t\t\t// Otherwise, we don't do the stripping, since the original number could be\r\n\t\t\t// a valid short number.\"\r\n\t\t\t// https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250\r\n\t\t\tswitch (checkNumberLength(nationalNumber, metadata)) {\r\n\t\t\t\tcase 'TOO_SHORT':\r\n\t\t\t\tcase 'INVALID_LENGTH':\r\n\t\t\t\t// case 'IS_POSSIBLE_LOCAL_ONLY':\r\n\t\t\t\t\t// Don't strip the national prefix.\r\n\t\t\t\t\treturn { nationalNumber: number }\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\treturn { nationalNumber, carrierCode }\r\n}\r\n\r\n// In some countries, the same digit could be a national prefix\r\n// or a leading digit of a valid phone number.\r\n// For example, in Russia, national prefix is `8`,\r\n// and also `800 555 35 35` is a valid number\r\n// in which `8` is not a national prefix, but the first digit\r\n// of a national (significant) number.\r\n// Same's with Belarus:\r\n// `82004910060` is a valid national (significant) number,\r\n// but `2004910060` is not.\r\n// To support such cases (to prevent the code from always stripping\r\n// national prefix), a condition is imposed: a national prefix\r\n// is not extracted when the original number is \"viable\" and the\r\n// resultant number is not, a \"viable\" national number being the one\r\n// that matches `national_number_pattern`.\r\nfunction shouldExtractNationalPrefix(number, nationalSignificantNumber, metadata) {\r\n\t// The equivalent in Google's code is:\r\n\t// https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004\r\n\tif (matchesEntirely(number, metadata.nationalNumberPattern()) &&\r\n\t\t!matchesEntirely(nationalSignificantNumber, metadata.nationalNumberPattern())) {\r\n\t\treturn false\r\n\t}\r\n\t// Just \"possible\" number check would be more relaxed, so it's not used.\r\n\t// if (isPossibleNumber(number, metadata) &&\r\n\t// \t!isPossibleNumber(numberWithNationalPrefixExtracted, metadata)) {\r\n\t// \treturn false\r\n\t// }\r\n\treturn true\r\n}"],"file":"extractNationalNumber.js"}

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

@@ -0,0 +1,107 @@
+/**
+ * Strips any national prefix (such as 0, 1) present in a
+ * (possibly incomplete) number provided.
+ * "Carrier codes" are only used  in Colombia and Brazil,
+ * and only when dialing within those countries from a mobile phone to a fixed line number.
+ * Sometimes it won't actually strip national prefix
+ * and will instead prepend some digits to the `number`:
+ * for example, when number `2345678` is passed with `VI` country selected,
+ * it will return `{ number: "3402345678" }`, because `340` area code is prepended.
+ * @param {string} number — National number digits.
+ * @param {object} metadata — Metadata with country selected.
+ * @return {object} `{ nationalNumber: string, nationalPrefix: string? carrierCode: string? }`.
+ */
+export default function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {
+  if (number && metadata.numberingPlan.nationalPrefixForParsing()) {
+    // See METADATA.md for the description of
+    // `national_prefix_for_parsing` and `national_prefix_transform_rule`.
+    // Attempt to parse the first digits as a national prefix.
+    var prefixPattern = new RegExp('^(?:' + metadata.numberingPlan.nationalPrefixForParsing() + ')');
+    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
+      // 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`,
+      // and nothing could be said about the actual national prefix:
+      // what is it and was it even there.
+      // If a `national_prefix_for_parsing` doesn't have any "capturing groups",
+      // then everything it matches is a national prefix.
+      // To determine whether `national_prefix_for_parsing` matched any
+      // "capturing groups", the value of the result of calling `.exec()`
+      // is looked at, and if it has non-undefined values where there're
+      // "capturing groups" in the regular expression, then it means
+      // that "capturing groups" have been matched.
+      // 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,
+        // then carrier code is the second one.
+
+        if (capturedGroupsCount > 1) {
+          carrierCode = prefixMatch[1];
+        }
+      } // 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,
+      // and possibly a carrier code.
+      // Seems like there could be more.
+      else {
+          // `prefixBeforeNationalNumber` is the whole substring matched by
+          // the `national_prefix_for_parsing` regular expression.
+          // There seem to be no guarantees that it's just a national prefix.
+          // 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,
+          // then carrier code is the first one.
+
+          if (hasCapturedGroups) {
+            carrierCode = prefixMatch[1];
+          }
+        } // 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`.
+        // `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();
+        }
+      } else {
+        nationalPrefix = prefixMatch[0];
+      }
+
+      return {
+        nationalNumber: nationalNumber,
+        nationalPrefix: nationalPrefix,
+        carrierCode: carrierCode
+      };
+    }
+  }
+
+  return {
+    nationalNumber: number
+  };
+}
+//# sourceMappingURL=extractNationalNumberFromPossiblyIncompleteNumber.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js"],"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;;;;;;;;;;;;;AAaA,eAAe,SAASA,iDAAT,CAA2DC,MAA3D,EAAmEC,QAAnE,EAA6E;AAC3F,MAAID,MAAM,IAAIC,QAAQ,CAACC,aAAT,CAAuBC,wBAAvB,EAAd,EAAiE;AAChE;AACA;AACA;AACA,QAAMC,aAAa,GAAG,IAAIC,MAAJ,CAAW,SAASJ,QAAQ,CAACC,aAAT,CAAuBC,wBAAvB,EAAT,GAA6D,GAAxE,CAAtB;AACA,QAAMG,WAAW,GAAGF,aAAa,CAACG,IAAd,CAAmBP,MAAnB,CAApB;;AACA,QAAIM,WAAJ,EAAiB;AAChB,UAAIE,cAAJ;AACA,UAAIC,WAAJ,CAFgB,CAGhB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,UAAMC,mBAAmB,GAAGJ,WAAW,CAACK,MAAZ,GAAqB,CAAjD;AACA,UAAMC,iBAAiB,GAAGF,mBAAmB,GAAG,CAAtB,IAA2BJ,WAAW,CAACI,mBAAD,CAAhE;;AACA,UAAIT,QAAQ,CAACY,2BAAT,MAA0CD,iBAA9C,EAAiE;AAChEJ,QAAAA,cAAc,GAAGR,MAAM,CAACc,OAAP,CAChBV,aADgB,EAEhBH,QAAQ,CAACY,2BAAT,EAFgB,CAAjB,CADgE,CAKhE;AACA;;AACA,YAAIH,mBAAmB,GAAG,CAA1B,EAA6B;AAC5BD,UAAAA,WAAW,GAAGH,WAAW,CAAC,CAAD,CAAzB;AACA;AACD,OAVD,CAWA;AACA;AACA;AACA;AACA;AACA;AAhBA,WAiBK;AACJ;AACA;AACA;AACA;AACA;AACA,cAAMS,0BAA0B,GAAGT,WAAW,CAAC,CAAD,CAA9C;AACAE,UAAAA,cAAc,GAAGR,MAAM,CAACgB,KAAP,CAAaD,0BAA0B,CAACJ,MAAxC,CAAjB,CAPI,CAQJ;AACA;;AACA,cAAIC,iBAAJ,EAAuB;AACtBH,YAAAA,WAAW,GAAGH,WAAW,CAAC,CAAD,CAAzB;AACA;AACD,SAnDe,CAoDhB;AACA;AACA;AACA;AACA;;;AACA,UAAIW,cAAJ;;AACA,UAAIL,iBAAJ,EAAuB;AACtB,YAAMM,uCAAuC,GAAGlB,MAAM,CAACmB,OAAP,CAAeb,WAAW,CAAC,CAAD,CAA1B,CAAhD;AACA,YAAMc,sBAAsB,GAAGpB,MAAM,CAACgB,KAAP,CAAa,CAAb,EAAgBE,uCAAhB,CAA/B,CAFsB,CAGtB;AACA;AACA;AACA;AACA;AACA;;AACA,YAAIE,sBAAsB,KAAKnB,QAAQ,CAACC,aAAT,CAAuBe,cAAvB,EAA/B,EAAwE;AACvEA,UAAAA,cAAc,GAAGhB,QAAQ,CAACC,aAAT,CAAuBe,cAAvB,EAAjB;AACA;AACD,OAZD,MAYO;AACNA,QAAAA,cAAc,GAAGX,WAAW,CAAC,CAAD,CAA5B;AACA;;AACD,aAAO;AACNE,QAAAA,cAAc,EAAdA,cADM;AAENS,QAAAA,cAAc,EAAdA,cAFM;AAGNR,QAAAA,WAAW,EAAXA;AAHM,OAAP;AAKA;AACD;;AACC,SAAO;AACND,IAAAA,cAAc,EAAER;AADV,GAAP;AAGF","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? }`.\r\n */\r\nexport default function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {\r\n\tif (number && metadata.numberingPlan.nationalPrefixForParsing()) {\r\n\t\t// See METADATA.md for the description of\r\n\t\t// `national_prefix_for_parsing` and `national_prefix_transform_rule`.\r\n\t\t// Attempt to parse the first digits as a national prefix.\r\n\t\tconst prefixPattern = new RegExp('^(?:' + metadata.numberingPlan.nationalPrefixForParsing() + ')')\r\n\t\tconst prefixMatch = prefixPattern.exec(number)\r\n\t\tif (prefixMatch) {\r\n\t\t\tlet nationalNumber\r\n\t\t\tlet carrierCode\r\n\t\t\t// https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\r\n\t\t\t// If a `national_prefix_for_parsing` has any \"capturing groups\"\r\n\t\t\t// then it means that the national (significant) number is equal to\r\n\t\t\t// those \"capturing groups\" transformed via `national_prefix_transform_rule`,\r\n\t\t\t// and nothing could be said about the actual national prefix:\r\n\t\t\t// what is it and was it even there.\r\n\t\t\t// If a `national_prefix_for_parsing` doesn't have any \"capturing groups\",\r\n\t\t\t// then everything it matches is a national prefix.\r\n\t\t\t// To determine whether `national_prefix_for_parsing` matched any\r\n\t\t\t// \"capturing groups\", the value of the result of calling `.exec()`\r\n\t\t\t// is looked at, and if it has non-undefined values where there're\r\n\t\t\t// \"capturing groups\" in the regular expression, then it means\r\n\t\t\t// that \"capturing groups\" have been matched.\r\n\t\t\t// It's not possible to tell whether there'll be any \"capturing gropus\"\r\n\t\t\t// before the matching process, because a `national_prefix_for_parsing`\r\n\t\t\t// could exhibit both behaviors.\r\n\t\t\tconst capturedGroupsCount = prefixMatch.length - 1\r\n\t\t\tconst hasCapturedGroups = capturedGroupsCount > 0 && prefixMatch[capturedGroupsCount]\r\n\t\t\tif (metadata.nationalPrefixTransformRule() && hasCapturedGroups) {\r\n\t\t\t\tnationalNumber = number.replace(\r\n\t\t\t\t\tprefixPattern,\r\n\t\t\t\t\tmetadata.nationalPrefixTransformRule()\r\n\t\t\t\t)\r\n\t\t\t\t// If there's more than one captured group,\r\n\t\t\t\t// then carrier code is the second one.\r\n\t\t\t\tif (capturedGroupsCount > 1) {\r\n\t\t\t\t\tcarrierCode = prefixMatch[1]\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// If there're no \"capturing groups\",\r\n\t\t\t// or if there're \"capturing groups\" but no\r\n\t\t\t// `national_prefix_transform_rule`,\r\n\t\t\t// then just strip the national prefix from the number,\r\n\t\t\t// and possibly a carrier code.\r\n\t\t\t// Seems like there could be more.\r\n\t\t\telse {\r\n\t\t\t\t// `prefixBeforeNationalNumber` is the whole substring matched by\r\n\t\t\t\t// the `national_prefix_for_parsing` regular expression.\r\n\t\t\t\t// There seem to be no guarantees that it's just a national prefix.\r\n\t\t\t\t// For example, if there's a carrier code, it's gonna be a\r\n\t\t\t\t// part of `prefixBeforeNationalNumber` too.\r\n\t\t\t\tconst prefixBeforeNationalNumber = prefixMatch[0]\r\n\t\t\t\tnationalNumber = number.slice(prefixBeforeNationalNumber.length)\r\n\t\t\t\t// If there's at least one captured group,\r\n\t\t\t\t// then carrier code is the first one.\r\n\t\t\t\tif (hasCapturedGroups) {\r\n\t\t\t\t\tcarrierCode = prefixMatch[1]\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// Tries to guess whether a national prefix was present in the input.\r\n\t\t\t// This is not something copy-pasted from Google's library:\r\n\t\t\t// they don't seem to have an equivalent for that.\r\n\t\t\t// So this isn't an \"officially approved\" way of doing something like that.\r\n\t\t\t// But since there seems no other existing method, this library uses it.\r\n\t\t\tlet nationalPrefix\r\n\t\t\tif (hasCapturedGroups) {\r\n\t\t\t\tconst possiblePositionOfTheFirstCapturedGroup = number.indexOf(prefixMatch[1])\r\n\t\t\t\tconst possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup)\r\n\t\t\t\t// Example: an Argentinian (AR) phone number `0111523456789`.\r\n\t\t\t\t// `prefixMatch[0]` is `01115`, and `$1` is `11`,\r\n\t\t\t\t// and the rest of the phone number is `23456789`.\r\n\t\t\t\t// The national number is transformed via `9$1` to `91123456789`.\r\n\t\t\t\t// National prefix `0` is detected being present at the start.\r\n\t\t\t\t// if (possibleNationalPrefix.indexOf(metadata.numberingPlan.nationalPrefix()) === 0) {\r\n\t\t\t\tif (possibleNationalPrefix === metadata.numberingPlan.nationalPrefix()) {\r\n\t\t\t\t\tnationalPrefix = metadata.numberingPlan.nationalPrefix()\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tnationalPrefix = prefixMatch[0]\r\n\t\t\t}\r\n\t\t\treturn {\r\n\t\t\t\tnationalNumber,\r\n\t\t\t\tnationalPrefix,\r\n\t\t\t\tcarrierCode\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n   return {\r\n   \tnationalNumber: number\r\n   }\r\n}"],"file":"extractNationalNumberFromPossiblyIncompleteNumber.js"}