@aws-amplify/graphql-api-construct 1.1.0

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

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = extractNationalNumber;
+
+var _extractNationalNumberFromPossiblyIncompleteNumber = _interopRequireDefault(require("./extractNationalNumberFromPossiblyIncompleteNumber"));
+
+var _matchesEntirely = _interopRequireDefault(require("./matchesEntirely"));
+
+var _checkNumberLength = _interopRequireDefault(require("./checkNumberLength"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * 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? }`.
+ */
+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 = (0, _extractNationalNumberFromPossiblyIncompleteNumber["default"])(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 ((0, _checkNumberLength["default"])(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 ((0, _matchesEntirely["default"])(number, metadata.nationalNumberPattern()) && !(0, _matchesEntirely["default"])(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/build/helpers/extractNationalNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/extractNationalNumber.js"],"names":["extractNationalNumber","number","metadata","nationalNumber","carrierCode","shouldExtractNationalPrefix","length","possibleLengths","nationalSignificantNumber","nationalNumberPattern"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;;;AAEA;;;;;;;;;AASe,SAASA,qBAAT,CAA+BC,MAA/B,EAAuCC,QAAvC,EAAiD;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAT+D,8BAa3D,mEACHD,MADG,EAEHC,QAFG,CAb2D;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,cAAQ,mCAAkBJ,cAAlB,EAAkCD,QAAlC,CAAR;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,MAAI,iCAAgBD,MAAhB,EAAwBC,QAAQ,CAACO,qBAAT,EAAxB,KACH,CAAC,iCAAgBD,yBAAhB,EAA2CN,QAAQ,CAACO,qBAAT,EAA3C,CADF,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/build/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = extractNationalNumberFromPossiblyIncompleteNumber;
+
+/**
+ * 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? }`.
+ */
+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/build/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;;;;;;;;;;;;;AAae,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"}

package/node_modules/libphonenumber-js/build/helpers/extractNationalNumberFromPossiblyIncompleteNumber.test.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _metadata = _interopRequireDefault(require("../metadata"));
+
+var _metadataMin = _interopRequireDefault(require("../../metadata.min.json"));
+
+var _extractNationalNumberFromPossiblyIncompleteNumber = _interopRequireDefault(require("./extractNationalNumberFromPossiblyIncompleteNumber"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+describe('extractNationalNumberFromPossiblyIncompleteNumber', function () {
+  it('should parse a carrier code when there is no national prefix transform rule', function () {
+    var meta = new _metadata["default"](_metadataMin["default"]);
+    meta.country('AU');
+    (0, _extractNationalNumberFromPossiblyIncompleteNumber["default"])('18311800123', meta).should.deep.equal({
+      nationalPrefix: undefined,
+      carrierCode: '1831',
+      nationalNumber: '1800123'
+    });
+  });
+});
+//# sourceMappingURL=extractNationalNumberFromPossiblyIncompleteNumber.test.js.map

package/node_modules/libphonenumber-js/build/helpers/extractNationalNumberFromPossiblyIncompleteNumber.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/extractNationalNumberFromPossiblyIncompleteNumber.test.js"],"names":["describe","it","meta","Metadata","metadata","country","should","deep","equal","nationalPrefix","undefined","carrierCode","nationalNumber"],"mappings":";;AAAA;;AACA;;AACA;;;;AAEAA,QAAQ,CAAC,mDAAD,EAAsD,YAAM;AACnEC,EAAAA,EAAE,CAAC,6EAAD,EAAgF,YAAM;AACvF,QAAMC,IAAI,GAAG,IAAIC,oBAAJ,CAAaC,uBAAb,CAAb;AACAF,IAAAA,IAAI,CAACG,OAAL,CAAa,IAAb;AACA,uEAAkD,aAAlD,EAAiEH,IAAjE,EAAuEI,MAAvE,CAA8EC,IAA9E,CAAmFC,KAAnF,CAAyF;AACxFC,MAAAA,cAAc,EAAEC,SADwE;AAExFC,MAAAA,WAAW,EAAE,MAF2E;AAGxFC,MAAAA,cAAc,EAAE;AAHwE,KAAzF;AAKA,GARC,CAAF;AASA,CAVO,CAAR","sourcesContent":["import Metadata from '../metadata'\r\nimport metadata from '../../metadata.min.json'\r\nimport extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber'\r\n\r\ndescribe('extractNationalNumberFromPossiblyIncompleteNumber', () => {\r\n\tit('should parse a carrier code when there is no national prefix transform rule', () => {\r\n\t\tconst meta = new Metadata(metadata)\r\n\t\tmeta.country('AU')\r\n\t\textractNationalNumberFromPossiblyIncompleteNumber('18311800123', meta).should.deep.equal({\r\n\t\t\tnationalPrefix: undefined,\r\n\t\t\tcarrierCode: '1831',\r\n\t\t\tnationalNumber: '1800123'\r\n\t\t})\r\n\t})\r\n})"],"file":"extractNationalNumberFromPossiblyIncompleteNumber.test.js"}

package/node_modules/libphonenumber-js/build/helpers/formatNationalNumberUsingFormat.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = formatNationalNumberUsingFormat;
+exports.FIRST_GROUP_PATTERN = void 0;
+
+var _applyInternationalSeparatorStyle = _interopRequireDefault(require("./applyInternationalSeparatorStyle"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+// This was originally set to $1 but there are some countries for which the
+// first group is not used in the national pattern (e.g. Argentina) so the $1
+// group does not match correctly. Therefore, we use `\d`, so that the first
+// group actually used in the pattern will be matched.
+var FIRST_GROUP_PATTERN = /(\$\d)/;
+exports.FIRST_GROUP_PATTERN = FIRST_GROUP_PATTERN;
+
+function formatNationalNumberUsingFormat(number, format, _ref) {
+  var useInternationalFormat = _ref.useInternationalFormat,
+      withNationalPrefix = _ref.withNationalPrefix,
+      carrierCode = _ref.carrierCode,
+      metadata = _ref.metadata;
+  var formattedNumber = number.replace(new RegExp(format.pattern()), useInternationalFormat ? format.internationalFormat() : // This library doesn't use `domestic_carrier_code_formatting_rule`,
+  // because that one is only used when formatting phone numbers
+  // for dialing from a mobile phone, and this is not a dialing library.
+  // carrierCode && format.domesticCarrierCodeFormattingRule()
+  // 	// First, replace the $CC in the formatting rule with the desired carrier code.
+  // 	// Then, replace the $FG in the formatting rule with the first group
+  // 	// and the carrier code combined in the appropriate way.
+  // 	? format.format().replace(FIRST_GROUP_PATTERN, format.domesticCarrierCodeFormattingRule().replace('$CC', carrierCode))
+  // 	: (
+  // 		withNationalPrefix && format.nationalPrefixFormattingRule()
+  // 			? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())
+  // 			: format.format()
+  // 	)
+  withNationalPrefix && format.nationalPrefixFormattingRule() ? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule()) : format.format());
+
+  if (useInternationalFormat) {
+    return (0, _applyInternationalSeparatorStyle["default"])(formattedNumber);
+  }
+
+  return formattedNumber;
+}
+//# sourceMappingURL=formatNationalNumberUsingFormat.js.map

package/node_modules/libphonenumber-js/build/helpers/formatNationalNumberUsingFormat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/formatNationalNumberUsingFormat.js"],"names":["FIRST_GROUP_PATTERN","formatNationalNumberUsingFormat","number","format","useInternationalFormat","withNationalPrefix","carrierCode","metadata","formattedNumber","replace","RegExp","pattern","internationalFormat","nationalPrefixFormattingRule"],"mappings":";;;;;;;;AAAA;;;;AAEA;AACA;AACA;AACA;AACO,IAAMA,mBAAmB,GAAG,QAA5B;;;AAEQ,SAASC,+BAAT,CACdC,MADc,EAEdC,MAFc,QASb;AAAA,MALAC,sBAKA,QALAA,sBAKA;AAAA,MAJAC,kBAIA,QAJAA,kBAIA;AAAA,MAHAC,WAGA,QAHAA,WAGA;AAAA,MAFAC,QAEA,QAFAA,QAEA;AACD,MAAMC,eAAe,GAAGN,MAAM,CAACO,OAAP,CACvB,IAAIC,MAAJ,CAAWP,MAAM,CAACQ,OAAP,EAAX,CADuB,EAEvBP,sBAAsB,GACnBD,MAAM,CAACS,mBAAP,EADmB,GAGpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAP,EAAAA,kBAAkB,IAAIF,MAAM,CAACU,4BAAP,EAAtB,GACGV,MAAM,CAACA,MAAP,GAAgBM,OAAhB,CAAwBT,mBAAxB,EAA6CG,MAAM,CAACU,4BAAP,EAA7C,CADH,GAEGV,MAAM,CAACA,MAAP,EApBkB,CAAxB;;AAuBA,MAAIC,sBAAJ,EAA4B;AAC3B,WAAO,kDAAiCI,eAAjC,CAAP;AACA;;AACD,SAAOA,eAAP;AACA","sourcesContent":["import applyInternationalSeparatorStyle from './applyInternationalSeparatorStyle'\r\n\r\n// This was originally set to $1 but there are some countries for which the\r\n// first group is not used in the national pattern (e.g. Argentina) so the $1\r\n// group does not match correctly. Therefore, we use `\\d`, so that the first\r\n// group actually used in the pattern will be matched.\r\nexport const FIRST_GROUP_PATTERN = /(\\$\\d)/\r\n\r\nexport default function formatNationalNumberUsingFormat(\r\n\tnumber,\r\n\tformat,\r\n\t{\r\n\t\tuseInternationalFormat,\r\n\t\twithNationalPrefix,\r\n\t\tcarrierCode,\r\n\t\tmetadata\r\n\t}\r\n) {\r\n\tconst formattedNumber = number.replace(\r\n\t\tnew RegExp(format.pattern()),\r\n\t\tuseInternationalFormat\r\n\t\t\t? format.internationalFormat()\r\n\t\t\t: (\r\n\t\t\t\t// This library doesn't use `domestic_carrier_code_formatting_rule`,\r\n\t\t\t\t// because that one is only used when formatting phone numbers\r\n\t\t\t\t// for dialing from a mobile phone, and this is not a dialing library.\r\n\t\t\t\t// carrierCode && format.domesticCarrierCodeFormattingRule()\r\n\t\t\t\t// \t// First, replace the $CC in the formatting rule with the desired carrier code.\r\n\t\t\t\t// \t// Then, replace the $FG in the formatting rule with the first group\r\n\t\t\t\t// \t// and the carrier code combined in the appropriate way.\r\n\t\t\t\t// \t? format.format().replace(FIRST_GROUP_PATTERN, format.domesticCarrierCodeFormattingRule().replace('$CC', carrierCode))\r\n\t\t\t\t// \t: (\r\n\t\t\t\t// \t\twithNationalPrefix && format.nationalPrefixFormattingRule()\r\n\t\t\t\t// \t\t\t? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())\r\n\t\t\t\t// \t\t\t: format.format()\r\n\t\t\t\t// \t)\r\n\t\t\t\twithNationalPrefix && format.nationalPrefixFormattingRule()\r\n\t\t\t\t\t? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())\r\n\t\t\t\t\t: format.format()\r\n\t\t\t)\r\n\t)\r\n\tif (useInternationalFormat) {\r\n\t\treturn applyInternationalSeparatorStyle(formattedNumber)\r\n\t}\r\n\treturn formattedNumber\r\n}"],"file":"formatNationalNumberUsingFormat.js"}

package/node_modules/libphonenumber-js/build/helpers/getCountryByCallingCode.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getCountryByCallingCode;
+
+var _metadata = _interopRequireDefault(require("../metadata"));
+
+var _getNumberType = _interopRequireDefault(require("./getNumberType"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;
+
+function getCountryByCallingCode(callingCode, nationalPhoneNumber, metadata) {
+  /* istanbul ignore if */
+  if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {
+    if (metadata.isNonGeographicCallingCode(callingCode)) {
+      return '001';
+    }
+  } // Is always non-empty, because `callingCode` is always valid
+
+
+  var possibleCountries = metadata.getCountryCodesForCallingCode(callingCode);
+
+  if (!possibleCountries) {
+    return;
+  } // If there's just one country corresponding to the country code,
+  // then just return it, without further phone number digits validation.
+
+
+  if (possibleCountries.length === 1) {
+    return possibleCountries[0];
+  }
+
+  return selectCountryFromList(possibleCountries, nationalPhoneNumber, metadata.metadata);
+}
+
+function selectCountryFromList(possibleCountries, nationalPhoneNumber, metadata) {
+  // Re-create `metadata` because it will be selecting a `country`.
+  metadata = new _metadata["default"](metadata);
+
+  for (var _iterator = possibleCountries, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    var country = _ref;
+    metadata.country(country); // Leading digits check would be the simplest and fastest one.
+    // Leading digits patterns are only defined for about 20% of all countries.
+    // https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md#leading_digits
+    // Matching "leading digits" is a sufficient but not necessary condition.
+
+    if (metadata.leadingDigits()) {
+      if (nationalPhoneNumber && nationalPhoneNumber.search(metadata.leadingDigits()) === 0) {
+        return country;
+      }
+    } // Else perform full validation with all of those
+    // fixed-line/mobile/etc regular expressions.
+    else if ((0, _getNumberType["default"])({
+        phone: nationalPhoneNumber,
+        country: country
+      }, undefined, metadata.metadata)) {
+        return country;
+      }
+  }
+}
+//# sourceMappingURL=getCountryByCallingCode.js.map

package/node_modules/libphonenumber-js/build/helpers/getCountryByCallingCode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/getCountryByCallingCode.js"],"names":["USE_NON_GEOGRAPHIC_COUNTRY_CODE","getCountryByCallingCode","callingCode","nationalPhoneNumber","metadata","isNonGeographicCallingCode","possibleCountries","getCountryCodesForCallingCode","length","selectCountryFromList","Metadata","country","leadingDigits","search","phone","undefined"],"mappings":";;;;;;;AAAA;;AACA;;;;AAEA,IAAMA,+BAA+B,GAAG,KAAxC;;AAEe,SAASC,uBAAT,CAAiCC,WAAjC,EAA8CC,mBAA9C,EAAmEC,QAAnE,EAA6E;AAC3F;AACA,MAAIJ,+BAAJ,EAAqC;AACpC,QAAII,QAAQ,CAACC,0BAAT,CAAoCH,WAApC,CAAJ,EAAsD;AACrD,aAAO,KAAP;AACA;AACD,GAN0F,CAO3F;;;AACA,MAAMI,iBAAiB,GAAGF,QAAQ,CAACG,6BAAT,CAAuCL,WAAvC,CAA1B;;AACA,MAAI,CAACI,iBAAL,EAAwB;AACvB;AACA,GAX0F,CAY3F;AACA;;;AACA,MAAIA,iBAAiB,CAACE,MAAlB,KAA6B,CAAjC,EAAoC;AACnC,WAAOF,iBAAiB,CAAC,CAAD,CAAxB;AACA;;AACD,SAAOG,qBAAqB,CAACH,iBAAD,EAAoBH,mBAApB,EAAyCC,QAAQ,CAACA,QAAlD,CAA5B;AACA;;AAED,SAASK,qBAAT,CAA+BH,iBAA/B,EAAkDH,mBAAlD,EAAuEC,QAAvE,EAAiF;AAChF;AACAA,EAAAA,QAAQ,GAAG,IAAIM,oBAAJ,CAAaN,QAAb,CAAX;;AACA,uBAAsBE,iBAAtB,kHAAyC;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA,QAA9BK,OAA8B;AACxCP,IAAAA,QAAQ,CAACO,OAAT,CAAiBA,OAAjB,EADwC,CAExC;AACA;AACA;AACA;;AACA,QAAIP,QAAQ,CAACQ,aAAT,EAAJ,EAA8B;AAC7B,UAAIT,mBAAmB,IACtBA,mBAAmB,CAACU,MAApB,CAA2BT,QAAQ,CAACQ,aAAT,EAA3B,MAAyD,CAD1D,EAC6D;AAC5D,eAAOD,OAAP;AACA;AACD,KALD,CAMA;AACA;AAPA,SAQK,IAAI,+BAAc;AAAEG,QAAAA,KAAK,EAAEX,mBAAT;AAA8BQ,QAAAA,OAAO,EAAPA;AAA9B,OAAd,EAAuDI,SAAvD,EAAkEX,QAAQ,CAACA,QAA3E,CAAJ,EAA0F;AAC9F,eAAOO,OAAP;AACA;AACD;AACD","sourcesContent":["import Metadata from '../metadata'\r\nimport getNumberType from './getNumberType'\r\n\r\nconst USE_NON_GEOGRAPHIC_COUNTRY_CODE = false\r\n\r\nexport default function getCountryByCallingCode(callingCode, nationalPhoneNumber, metadata) {\r\n\t/* istanbul ignore if */\r\n\tif (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\r\n\t\tif (metadata.isNonGeographicCallingCode(callingCode)) {\r\n\t\t\treturn '001'\r\n\t\t}\r\n\t}\r\n\t// Is always non-empty, because `callingCode` is always valid\r\n\tconst possibleCountries = metadata.getCountryCodesForCallingCode(callingCode)\r\n\tif (!possibleCountries) {\r\n\t\treturn\r\n\t}\r\n\t// If there's just one country corresponding to the country code,\r\n\t// then just return it, without further phone number digits validation.\r\n\tif (possibleCountries.length === 1) {\r\n\t\treturn possibleCountries[0]\r\n\t}\r\n\treturn selectCountryFromList(possibleCountries, nationalPhoneNumber, metadata.metadata)\r\n}\r\n\r\nfunction selectCountryFromList(possibleCountries, nationalPhoneNumber, metadata) {\r\n\t// Re-create `metadata` because it will be selecting a `country`.\r\n\tmetadata = new Metadata(metadata)\r\n\tfor (const country of possibleCountries) {\r\n\t\tmetadata.country(country)\r\n\t\t// Leading digits check would be the simplest and fastest one.\r\n\t\t// Leading digits patterns are only defined for about 20% of all countries.\r\n\t\t// https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md#leading_digits\r\n\t\t// Matching \"leading digits\" is a sufficient but not necessary condition.\r\n\t\tif (metadata.leadingDigits()) {\r\n\t\t\tif (nationalPhoneNumber &&\r\n\t\t\t\tnationalPhoneNumber.search(metadata.leadingDigits()) === 0) {\r\n\t\t\t\treturn country\r\n\t\t\t}\r\n\t\t}\r\n\t\t// Else perform full validation with all of those\r\n\t\t// fixed-line/mobile/etc regular expressions.\r\n\t\telse if (getNumberType({ phone: nationalPhoneNumber, country }, undefined, metadata.metadata)) {\r\n\t\t\treturn country\r\n\t\t}\r\n\t}\r\n}"],"file":"getCountryByCallingCode.js"}

package/node_modules/libphonenumber-js/build/helpers/getIddPrefix.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getIddPrefix;
+
+var _metadata = _interopRequireDefault(require("../metadata"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Pattern that makes it easy to distinguish whether a region has a single
+ * international dialing prefix or not. If a region has a single international
+ * prefix (e.g. 011 in USA), it will be represented as a string that contains
+ * a sequence of ASCII digits, and possibly a tilde, which signals waiting for
+ * the tone. If there are multiple available international prefixes in a
+ * region, they will be represented as a regex string that always contains one
+ * or more characters that are not ASCII digits or a tilde.
+ */
+var SINGLE_IDD_PREFIX_REG_EXP = /^[\d]+(?:[~\u2053\u223C\uFF5E][\d]+)?$/; // For regions that have multiple IDD prefixes
+// a preferred IDD prefix is returned.
+
+function getIddPrefix(country, callingCode, metadata) {
+  var countryMetadata = new _metadata["default"](metadata);
+  countryMetadata.selectNumberingPlan(country, callingCode);
+
+  if (countryMetadata.defaultIDDPrefix()) {
+    return countryMetadata.defaultIDDPrefix();
+  }
+
+  if (SINGLE_IDD_PREFIX_REG_EXP.test(countryMetadata.IDDPrefix())) {
+    return countryMetadata.IDDPrefix();
+  }
+}
+//# sourceMappingURL=getIddPrefix.js.map

package/node_modules/libphonenumber-js/build/helpers/getIddPrefix.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/getIddPrefix.js"],"names":["SINGLE_IDD_PREFIX_REG_EXP","getIddPrefix","country","callingCode","metadata","countryMetadata","Metadata","selectNumberingPlan","defaultIDDPrefix","test","IDDPrefix"],"mappings":";;;;;;;AAAA;;;;AAEA;;;;;;;;;AASA,IAAMA,yBAAyB,GAAG,wCAAlC,C,CAEA;AACA;;AACe,SAASC,YAAT,CAAsBC,OAAtB,EAA+BC,WAA/B,EAA4CC,QAA5C,EAAsD;AACpE,MAAMC,eAAe,GAAG,IAAIC,oBAAJ,CAAaF,QAAb,CAAxB;AACAC,EAAAA,eAAe,CAACE,mBAAhB,CAAoCL,OAApC,EAA6CC,WAA7C;;AACA,MAAIE,eAAe,CAACG,gBAAhB,EAAJ,EAAwC;AACvC,WAAOH,eAAe,CAACG,gBAAhB,EAAP;AACA;;AACD,MAAIR,yBAAyB,CAACS,IAA1B,CAA+BJ,eAAe,CAACK,SAAhB,EAA/B,CAAJ,EAAiE;AAChE,WAAOL,eAAe,CAACK,SAAhB,EAAP;AACA;AACD","sourcesContent":["import Metadata from '../metadata'\r\n\r\n/**\r\n * Pattern that makes it easy to distinguish whether a region has a single\r\n * international dialing prefix or not. If a region has a single international\r\n * prefix (e.g. 011 in USA), it will be represented as a string that contains\r\n * a sequence of ASCII digits, and possibly a tilde, which signals waiting for\r\n * the tone. If there are multiple available international prefixes in a\r\n * region, they will be represented as a regex string that always contains one\r\n * or more characters that are not ASCII digits or a tilde.\r\n */\r\nconst SINGLE_IDD_PREFIX_REG_EXP = /^[\\d]+(?:[~\\u2053\\u223C\\uFF5E][\\d]+)?$/\r\n\r\n// For regions that have multiple IDD prefixes\r\n// a preferred IDD prefix is returned.\r\nexport default function getIddPrefix(country, callingCode, metadata) {\r\n\tconst countryMetadata = new Metadata(metadata)\r\n\tcountryMetadata.selectNumberingPlan(country, callingCode)\r\n\tif (countryMetadata.defaultIDDPrefix()) {\r\n\t\treturn countryMetadata.defaultIDDPrefix()\r\n\t}\r\n\tif (SINGLE_IDD_PREFIX_REG_EXP.test(countryMetadata.IDDPrefix())) {\r\n\t\treturn countryMetadata.IDDPrefix()\r\n\t}\r\n}\r\n"],"file":"getIddPrefix.js"}

package/node_modules/libphonenumber-js/build/helpers/getNumberType.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getNumberType;
+exports.isNumberTypeEqualTo = isNumberTypeEqualTo;
+
+var _metadata = _interopRequireDefault(require("../metadata"));
+
+var _matchesEntirely = _interopRequireDefault(require("./matchesEntirely"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var NON_FIXED_LINE_PHONE_TYPES = ['MOBILE', 'PREMIUM_RATE', 'TOLL_FREE', 'SHARED_COST', 'VOIP', 'PERSONAL_NUMBER', 'PAGER', 'UAN', 'VOICEMAIL']; // Finds out national phone number type (fixed line, mobile, etc)
+
+function getNumberType(input, options, metadata) {
+  // If assigning the `{}` default value is moved to the arguments above,
+  // code coverage would decrease for some weird reason.
+  options = options || {}; // When `parse()` returned `{}`
+  // meaning that the phone number is not a valid one.
+
+  if (!input.country) {
+    return;
+  }
+
+  metadata = new _metadata["default"](metadata);
+  metadata.selectNumberingPlan(input.country, input.countryCallingCode);
+  var nationalNumber = options.v2 ? input.nationalNumber : input.phone; // The following is copy-pasted from the original function:
+  // https://github.com/googlei18n/libphonenumber/blob/3ea547d4fbaa2d0b67588904dfa5d3f2557c27ff/javascript/i18n/phonenumbers/phonenumberutil.js#L2835
+  // Is this national number even valid for this country
+
+  if (!(0, _matchesEntirely["default"])(nationalNumber, metadata.nationalNumberPattern())) {
+    return;
+  } // Is it fixed line number
+
+
+  if (isNumberTypeEqualTo(nationalNumber, 'FIXED_LINE', metadata)) {
+    // Because duplicate regular expressions are removed
+    // to reduce metadata size, if "mobile" pattern is ""
+    // then it means it was removed due to being a duplicate of the fixed-line pattern.
+    //
+    if (metadata.type('MOBILE') && metadata.type('MOBILE').pattern() === '') {
+      return 'FIXED_LINE_OR_MOBILE';
+    } // v1 metadata.
+    // Legacy.
+    // Deprecated.
+
+
+    if (!metadata.type('MOBILE')) {
+      return 'FIXED_LINE_OR_MOBILE';
+    } // Check if the number happens to qualify as both fixed line and mobile.
+    // (no such country in the minimal metadata set)
+
+    /* istanbul ignore if */
+
+
+    if (isNumberTypeEqualTo(nationalNumber, 'MOBILE', metadata)) {
+      return 'FIXED_LINE_OR_MOBILE';
+    }
+
+    return 'FIXED_LINE';
+  }
+
+  for (var _i = 0, _NON_FIXED_LINE_PHONE = NON_FIXED_LINE_PHONE_TYPES; _i < _NON_FIXED_LINE_PHONE.length; _i++) {
+    var type = _NON_FIXED_LINE_PHONE[_i];
+
+    if (isNumberTypeEqualTo(nationalNumber, type, metadata)) {
+      return type;
+    }
+  }
+}
+
+function isNumberTypeEqualTo(nationalNumber, type, metadata) {
+  type = metadata.type(type);
+
+  if (!type || !type.pattern()) {
+    return false;
+  } // Check if any possible number lengths are present;
+  // if so, we use them to avoid checking
+  // the validation pattern if they don't match.
+  // If they are absent, this means they match
+  // the general description, which we have
+  // already checked before a specific number type.
+
+
+  if (type.possibleLengths() && type.possibleLengths().indexOf(nationalNumber.length) < 0) {
+    return false;
+  }
+
+  return (0, _matchesEntirely["default"])(nationalNumber, type.pattern());
+}
+//# sourceMappingURL=getNumberType.js.map

package/node_modules/libphonenumber-js/build/helpers/getNumberType.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/helpers/getNumberType.js"],"names":["NON_FIXED_LINE_PHONE_TYPES","getNumberType","input","options","metadata","country","Metadata","selectNumberingPlan","countryCallingCode","nationalNumber","v2","phone","nationalNumberPattern","isNumberTypeEqualTo","type","pattern","possibleLengths","indexOf","length"],"mappings":";;;;;;;;AAAA;;AACA;;;;AAEA,IAAMA,0BAA0B,GAAG,CAClC,QADkC,EAElC,cAFkC,EAGlC,WAHkC,EAIlC,aAJkC,EAKlC,MALkC,EAMlC,iBANkC,EAOlC,OAPkC,EAQlC,KARkC,EASlC,WATkC,CAAnC,C,CAYA;;AACe,SAASC,aAAT,CAAuBC,KAAvB,EAA8BC,OAA9B,EAAuCC,QAAvC,EACf;AACC;AACA;AACAD,EAAAA,OAAO,GAAGA,OAAO,IAAI,EAArB,CAHD,CAKC;AACA;;AACA,MAAI,CAACD,KAAK,CAACG,OAAX,EAAoB;AACnB;AACA;;AAEDD,EAAAA,QAAQ,GAAG,IAAIE,oBAAJ,CAAaF,QAAb,CAAX;AAEAA,EAAAA,QAAQ,CAACG,mBAAT,CAA6BL,KAAK,CAACG,OAAnC,EAA4CH,KAAK,CAACM,kBAAlD;AAEA,MAAMC,cAAc,GAAGN,OAAO,CAACO,EAAR,GAAaR,KAAK,CAACO,cAAnB,GAAoCP,KAAK,CAACS,KAAjE,CAfD,CAiBC;AACA;AAEA;;AACA,MAAI,CAAC,iCAAgBF,cAAhB,EAAgCL,QAAQ,CAACQ,qBAAT,EAAhC,CAAL,EAAwE;AACvE;AACA,GAvBF,CAyBC;;;AACA,MAAIC,mBAAmB,CAACJ,cAAD,EAAiB,YAAjB,EAA+BL,QAA/B,CAAvB,EAAiE;AAChE;AACA;AACA;AACA;AACA,QAAIA,QAAQ,CAACU,IAAT,CAAc,QAAd,KAA2BV,QAAQ,CAACU,IAAT,CAAc,QAAd,EAAwBC,OAAxB,OAAsC,EAArE,EAAyE;AACxE,aAAO,sBAAP;AACA,KAP+D,CAShE;AACA;AACA;;;AACA,QAAI,CAACX,QAAQ,CAACU,IAAT,CAAc,QAAd,CAAL,EAA8B;AAC7B,aAAO,sBAAP;AACA,KAd+D,CAgBhE;AACA;;AACA;;;AACA,QAAID,mBAAmB,CAACJ,cAAD,EAAiB,QAAjB,EAA2BL,QAA3B,CAAvB,EAA6D;AAC5D,aAAO,sBAAP;AACA;;AAED,WAAO,YAAP;AACA;;AAED,2CAAmBJ,0BAAnB,2CAA+C;AAA1C,QAAMc,IAAI,4BAAV;;AACJ,QAAID,mBAAmB,CAACJ,cAAD,EAAiBK,IAAjB,EAAuBV,QAAvB,CAAvB,EAAyD;AACxD,aAAOU,IAAP;AACA;AACD;AACD;;AAEM,SAASD,mBAAT,CAA6BJ,cAA7B,EAA6CK,IAA7C,EAAmDV,QAAnD,EAA6D;AACnEU,EAAAA,IAAI,GAAGV,QAAQ,CAACU,IAAT,CAAcA,IAAd,CAAP;;AACA,MAAI,CAACA,IAAD,IAAS,CAACA,IAAI,CAACC,OAAL,EAAd,EAA8B;AAC7B,WAAO,KAAP;AACA,GAJkE,CAKnE;AACA;AACA;AACA;AACA;AACA;;;AACA,MAAID,IAAI,CAACE,eAAL,MACHF,IAAI,CAACE,eAAL,GAAuBC,OAAvB,CAA+BR,cAAc,CAACS,MAA9C,IAAwD,CADzD,EAC4D;AAC3D,WAAO,KAAP;AACA;;AACD,SAAO,iCAAgBT,cAAhB,EAAgCK,IAAI,CAACC,OAAL,EAAhC,CAAP;AACA","sourcesContent":["import Metadata from '../metadata'\r\nimport matchesEntirely from './matchesEntirely'\r\n\r\nconst NON_FIXED_LINE_PHONE_TYPES = [\r\n\t'MOBILE',\r\n\t'PREMIUM_RATE',\r\n\t'TOLL_FREE',\r\n\t'SHARED_COST',\r\n\t'VOIP',\r\n\t'PERSONAL_NUMBER',\r\n\t'PAGER',\r\n\t'UAN',\r\n\t'VOICEMAIL'\r\n]\r\n\r\n// Finds out national phone number type (fixed line, mobile, etc)\r\nexport default function getNumberType(input, options, metadata)\r\n{\r\n\t// If assigning the `{}` default value is moved to the arguments above,\r\n\t// code coverage would decrease for some weird reason.\r\n\toptions = options || {}\r\n\r\n\t// When `parse()` returned `{}`\r\n\t// meaning that the phone number is not a valid one.\r\n\tif (!input.country) {\r\n\t\treturn\r\n\t}\r\n\r\n\tmetadata = new Metadata(metadata)\r\n\r\n\tmetadata.selectNumberingPlan(input.country, input.countryCallingCode)\r\n\r\n\tconst nationalNumber = options.v2 ? input.nationalNumber : input.phone\r\n\r\n\t// The following is copy-pasted from the original function:\r\n\t// https://github.com/googlei18n/libphonenumber/blob/3ea547d4fbaa2d0b67588904dfa5d3f2557c27ff/javascript/i18n/phonenumbers/phonenumberutil.js#L2835\r\n\r\n\t// Is this national number even valid for this country\r\n\tif (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern())) {\r\n\t\treturn\r\n\t}\r\n\r\n\t// Is it fixed line number\r\n\tif (isNumberTypeEqualTo(nationalNumber, 'FIXED_LINE', metadata)) {\r\n\t\t// Because duplicate regular expressions are removed\r\n\t\t// to reduce metadata size, if \"mobile\" pattern is \"\"\r\n\t\t// then it means it was removed due to being a duplicate of the fixed-line pattern.\r\n\t\t//\r\n\t\tif (metadata.type('MOBILE') && metadata.type('MOBILE').pattern() === '') {\r\n\t\t\treturn 'FIXED_LINE_OR_MOBILE'\r\n\t\t}\r\n\r\n\t\t// v1 metadata.\r\n\t\t// Legacy.\r\n\t\t// Deprecated.\r\n\t\tif (!metadata.type('MOBILE')) {\r\n\t\t\treturn 'FIXED_LINE_OR_MOBILE'\r\n\t\t}\r\n\r\n\t\t// Check if the number happens to qualify as both fixed line and mobile.\r\n\t\t// (no such country in the minimal metadata set)\r\n\t\t/* istanbul ignore if */\r\n\t\tif (isNumberTypeEqualTo(nationalNumber, 'MOBILE', metadata)) {\r\n\t\t\treturn 'FIXED_LINE_OR_MOBILE'\r\n\t\t}\r\n\r\n\t\treturn 'FIXED_LINE'\r\n\t}\r\n\r\n\tfor (const type of NON_FIXED_LINE_PHONE_TYPES) {\r\n\t\tif (isNumberTypeEqualTo(nationalNumber, type, metadata)) {\r\n\t\t\treturn type\r\n\t\t}\r\n\t}\r\n}\r\n\r\nexport function isNumberTypeEqualTo(nationalNumber, type, metadata) {\r\n\ttype = metadata.type(type)\r\n\tif (!type || !type.pattern()) {\r\n\t\treturn false\r\n\t}\r\n\t// Check if any possible number lengths are present;\r\n\t// if so, we use them to avoid checking\r\n\t// the validation pattern if they don't match.\r\n\t// If they are absent, this means they match\r\n\t// the general description, which we have\r\n\t// already checked before a specific number type.\r\n\tif (type.possibleLengths() &&\r\n\t\ttype.possibleLengths().indexOf(nationalNumber.length) < 0) {\r\n\t\treturn false\r\n\t}\r\n\treturn matchesEntirely(nationalNumber, type.pattern())\r\n}"],"file":"getNumberType.js"}