ingeniuscliq-core 0.5.36 → 0.5.38

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

@@ -0,0 +1,103 @@
+/**
+ * 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? }`. Even if a national prefix was extracted, it's not necessarily present in the returned object, so don't rely on its presence in the returned object in order to find out whether a national prefix has been extracted or not.
+ */
+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
+  };
+}
+
+export { extractNationalNumberFromPossiblyIncompleteNumber as default };

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

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

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

@@ -0,0 +1,32 @@
+import applyInternationalSeparatorStyle from './applyInternationalSeparatorStyle.js';
+
+// This was originally set to $1 but there are some countries for which the
+// first group is not used in the national pattern (e.g. Argentina) so the $1
+// group does not match correctly. Therefore, we use `\d`, so that the first
+// group actually used in the pattern will be matched.
+var FIRST_GROUP_PATTERN = /(\$\d)/;
+function formatNationalNumberUsingFormat(number, format, _ref) {
+  var useInternationalFormat = _ref.useInternationalFormat,
+    withNationalPrefix = _ref.withNationalPrefix;
+  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 applyInternationalSeparatorStyle(formattedNumber);
+  }
+  return formattedNumber;
+}
+
+export { FIRST_GROUP_PATTERN, formatNationalNumberUsingFormat as default };

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

@@ -0,0 +1,23 @@
+import getCountryByNationalNumber from './getCountryByNationalNumber.js';
+
+// Returns the exact country for the `nationalNumber`
+// that belongs to the specified "country calling code".
+function getCountryByCallingCode(callingCode, _ref) {
+  var nationalPhoneNumber = _ref.nationalNumber,
+    metadata = _ref.metadata;
+  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 getCountryByNationalNumber(nationalPhoneNumber, {
+    countries: possibleCountries,
+    metadata: metadata.metadata
+  });
+}
+
+export { getCountryByCallingCode as default };

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

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

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

@@ -0,0 +1,27 @@
+import Metadata from '../metadata.js';
+
+/**
+ * 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]+)?$/;
+
+// If the `country` supports IDD calling, it returns a preferred IDD prefix.
+// If the `country` doesn't support IDD calling, it returns `undefined`.
+function getIddPrefix(country, callingCode, metadata) {
+  var countryMetadata = new Metadata(metadata);
+  countryMetadata.selectNumberingPlan(country, callingCode);
+  if (countryMetadata.defaultIDDPrefix()) {
+    return countryMetadata.defaultIDDPrefix();
+  }
+  if (SINGLE_IDD_PREFIX_REG_EXP.test(countryMetadata.IDDPrefix())) {
+    return countryMetadata.IDDPrefix();
+  }
+}
+
+export { getIddPrefix as default };

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

@@ -0,0 +1,86 @@
+import Metadata from '../metadata.js';
+import matchesEntirely from './matchesEntirely.js';
+
+function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: true } : { done: false, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var NON_FIXED_LINE_PHONE_TYPES = ['MOBILE', 'PREMIUM_RATE', 'TOLL_FREE', 'SHARED_COST', 'VOIP', 'PERSONAL_NUMBER', 'PAGER', 'UAN', 'VOICEMAIL'];
+
+// Finds out national phone number type (fixed line, mobile, etc)
+function getNumberType(input, options, metadata) {
+  // If assigning the `{}` default value is moved to the arguments above,
+  // code coverage would decrease for some weird reason.
+  options = options || {};
+
+  // When `parse()` returns an empty object — `{}` —
+  // that means that the phone number is malformed,
+  // so it can't possibly be valid.
+  if (!input.country && !input.countryCallingCode) {
+    return;
+  }
+  metadata = new Metadata(metadata);
+  metadata.selectNumberingPlan(input.country, input.countryCallingCode);
+  var nationalNumber = options.v2 ? input.nationalNumber : input.phone;
+
+  // The following is copy-pasted from the original function:
+  // https://github.com/googlei18n/libphonenumber/blob/3ea547d4fbaa2d0b67588904dfa5d3f2557c27ff/javascript/i18n/phonenumbers/phonenumberutil.js#L2835
+
+  // Is this national number even valid for this country
+  if (!matchesEntirely(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';
+    }
+
+    // `MOBILE` type pattern isn't included if it matched `FIXED_LINE` one.
+    // For example, for "US" country.
+    // Old metadata (< `1.0.18`) had a specific "types" data structure
+    // that happened to be `undefined` for `MOBILE` in that case.
+    // Newer metadata (>= `1.0.18`) has another data structure that is
+    // not `undefined` for `MOBILE` in that case (it's just an empty array).
+    // So this `if` is just for backwards compatibility with old metadata.
+    if (!metadata.type('MOBILE')) {
+      return 'FIXED_LINE_OR_MOBILE';
+    }
+
+    // Check if the number happens to qualify as both fixed line and mobile.
+    // (no such country in the minimal metadata set)
+    /* istanbul ignore if */
+    if (isNumberTypeEqualTo(nationalNumber, 'MOBILE', metadata)) {
+      return 'FIXED_LINE_OR_MOBILE';
+    }
+    return 'FIXED_LINE';
+  }
+  for (var _iterator = _createForOfIteratorHelperLoose(NON_FIXED_LINE_PHONE_TYPES), _step; !(_step = _iterator()).done;) {
+    var type = _step.value;
+    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 matchesEntirely(nationalNumber, type.pattern());
+}
+
+export { getNumberType as default, isNumberTypeEqualTo };

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

@@ -0,0 +1,29 @@
+import Metadata from '../metadata.js';
+
+/**
+ * Returns a list of countries that the phone number could potentially belong to.
+ * @param  {string} callingCode — Calling code.
+ * @param  {string} nationalNumber — National (significant) number.
+ * @param  {object} metadata — Metadata.
+ * @return {string[]} A list of possible countries.
+ */
+function getPossibleCountriesForNumber(callingCode, nationalNumber, metadata) {
+  var _metadata = new Metadata(metadata);
+  var possibleCountries = _metadata.getCountryCodesForCallingCode(callingCode);
+  if (!possibleCountries) {
+    return [];
+  }
+  return possibleCountries.filter(function (country) {
+    return couldNationalNumberBelongToCountry(nationalNumber, country, metadata);
+  });
+}
+function couldNationalNumberBelongToCountry(nationalNumber, country, metadata) {
+  var _metadata = new Metadata(metadata);
+  _metadata.selectNumberingPlan(country);
+  if (_metadata.numberingPlan.possibleLengths().indexOf(nationalNumber.length) >= 0) {
+    return true;
+  }
+  return false;
+}
+
+export { getPossibleCountriesForNumber as default };

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

@@ -0,0 +1,78 @@
+import { MIN_LENGTH_FOR_NSN, VALID_DIGITS, PLUS_CHARS, VALID_PUNCTUATION } from '../constants.js';
+import createExtensionPattern from './extension/createExtensionPattern.js';
+
+//  Regular expression of viable phone numbers. This is location independent.
+//  Checks we have at least three leading digits, and only valid punctuation,
+//  alpha characters and digits in the phone number. Does not include extension
+//  data. The symbol 'x' is allowed here as valid punctuation since it is often
+//  used as a placeholder for carrier codes, for example in Brazilian phone
+//  numbers. We also allow multiple '+' characters at the start.
+//
+//  Corresponds to the following:
+//  [digits]{minLengthNsn}|
+//  plus_sign*
+//  (([punctuation]|[star])*[digits]){3,}([punctuation]|[star]|[digits]|[alpha])*
+//
+//  The first reg-ex is to allow short numbers (two digits long) to be parsed if
+//  they are entered as "15" etc, but only if there is no punctuation in them.
+//  The second expression restricts the number of digits to three or more, but
+//  then allows them to be in international form, and to have alpha-characters
+//  and punctuation. We split up the two reg-exes here and combine them when
+//  creating the reg-ex VALID_PHONE_NUMBER_PATTERN itself so we can prefix it
+//  with ^ and append $ to each branch.
+//
+//  "Note VALID_PUNCTUATION starts with a -,
+//   so must be the first in the range" (c) Google devs.
+//  (wtf did they mean by saying that; probably nothing)
+//
+var MIN_LENGTH_PHONE_NUMBER_PATTERN = '[' + VALID_DIGITS + ']{' + MIN_LENGTH_FOR_NSN + '}';
+//
+// And this is the second reg-exp:
+// (see MIN_LENGTH_PHONE_NUMBER_PATTERN for a full description of this reg-exp)
+//
+var VALID_PHONE_NUMBER = '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){3,}' + '[' + VALID_PUNCTUATION + VALID_DIGITS + ']*';
+
+// This regular expression isn't present in Google's `libphonenumber`
+// and is only used to determine whether the phone number being input
+// is too short for it to even consider it a "valid" number.
+// This is just a way to differentiate between a really invalid phone
+// number like "abcde" and a valid phone number that a user has just
+// started inputting, like "+1" or "1": both these cases would be
+// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this
+// library can provide a more detailed error message — whether it's
+// really "not a number", or is it just a start of a valid phone number.
+var VALID_PHONE_NUMBER_START_REG_EXP = new RegExp('^' + '[' + PLUS_CHARS + ']{0,1}' + '(?:' + '[' + VALID_PUNCTUATION + ']*' + '[' + VALID_DIGITS + ']' + '){1,2}' + '$', 'i');
+var VALID_PHONE_NUMBER_WITH_EXTENSION = VALID_PHONE_NUMBER +
+// Phone number extensions
+'(?:' + createExtensionPattern() + ')?';
+
+// The combined regular expression for valid phone numbers:
+//
+var VALID_PHONE_NUMBER_PATTERN = new RegExp(
+// Either a short two-digit-only phone number
+'^' + MIN_LENGTH_PHONE_NUMBER_PATTERN + '$' + '|' +
+// Or a longer fully parsed phone number (min 3 characters)
+'^' + VALID_PHONE_NUMBER_WITH_EXTENSION + '$', 'i');
+
+// Checks to see if the string of characters could possibly be a phone number at
+// all. At the moment, checks to see that the string begins with at least 2
+// digits, ignoring any punctuation commonly found in phone numbers. This method
+// does not require the number to be normalized in advance - but does assume
+// that leading non-number symbols have been removed, such as by the method
+// `extract_possible_number`.
+//
+function isViablePhoneNumber(number) {
+  return number.length >= MIN_LENGTH_FOR_NSN && VALID_PHONE_NUMBER_PATTERN.test(number);
+}
+
+// This is just a way to differentiate between a really invalid phone
+// number like "abcde" and a valid phone number that a user has just
+// started inputting, like "+1" or "1": both these cases would be
+// considered `NOT_A_NUMBER` by Google's `libphonenumber`, but this
+// library can provide a more detailed error message — whether it's
+// really "not a number", or is it just a start of a valid phone number.
+function isViablePhoneNumberStart(number) {
+  return VALID_PHONE_NUMBER_START_REG_EXP.test(number);
+}
+
+export { VALID_PHONE_NUMBER, VALID_PHONE_NUMBER_WITH_EXTENSION, isViablePhoneNumber as default, isViablePhoneNumberStart };

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

@@ -0,0 +1,13 @@
+/**
+ * Checks whether the entire input sequence can be matched
+ * against the regular expression.
+ * @return {boolean}
+ */
+function matchesEntirely(text, regularExpressionText) {
+  // If the assigning of the `''` default value is moved to the arguments above,
+  // the code coverage would decrease for some weird reason.
+  text = text || '';
+  return new RegExp('^(?:' + regularExpressionText + ')$').test(text);
+}
+
+export { matchesEntirely as default };

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

@@ -0,0 +1,82 @@
+// These mappings map a character (key) to a specific digit that should
+// replace it for normalization purposes. Non-European digits that
+// may be used in phone numbers are mapped to a European equivalent.
+//
+// E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.
+//
+var DIGITS = {
+  '0': '0',
+  '1': '1',
+  '2': '2',
+  '3': '3',
+  '4': '4',
+  '5': '5',
+  '6': '6',
+  '7': '7',
+  '8': '8',
+  '9': '9',
+  "\uFF10": '0',
+  // Fullwidth digit 0
+  "\uFF11": '1',
+  // Fullwidth digit 1
+  "\uFF12": '2',
+  // Fullwidth digit 2
+  "\uFF13": '3',
+  // Fullwidth digit 3
+  "\uFF14": '4',
+  // Fullwidth digit 4
+  "\uFF15": '5',
+  // Fullwidth digit 5
+  "\uFF16": '6',
+  // Fullwidth digit 6
+  "\uFF17": '7',
+  // Fullwidth digit 7
+  "\uFF18": '8',
+  // Fullwidth digit 8
+  "\uFF19": '9',
+  // Fullwidth digit 9
+  "\u0660": '0',
+  // Arabic-indic digit 0
+  "\u0661": '1',
+  // Arabic-indic digit 1
+  "\u0662": '2',
+  // Arabic-indic digit 2
+  "\u0663": '3',
+  // Arabic-indic digit 3
+  "\u0664": '4',
+  // Arabic-indic digit 4
+  "\u0665": '5',
+  // Arabic-indic digit 5
+  "\u0666": '6',
+  // Arabic-indic digit 6
+  "\u0667": '7',
+  // Arabic-indic digit 7
+  "\u0668": '8',
+  // Arabic-indic digit 8
+  "\u0669": '9',
+  // Arabic-indic digit 9
+  "\u06F0": '0',
+  // Eastern-Arabic digit 0
+  "\u06F1": '1',
+  // Eastern-Arabic digit 1
+  "\u06F2": '2',
+  // Eastern-Arabic digit 2
+  "\u06F3": '3',
+  // Eastern-Arabic digit 3
+  "\u06F4": '4',
+  // Eastern-Arabic digit 4
+  "\u06F5": '5',
+  // Eastern-Arabic digit 5
+  "\u06F6": '6',
+  // Eastern-Arabic digit 6
+  "\u06F7": '7',
+  // Eastern-Arabic digit 7
+  "\u06F8": '8',
+  // Eastern-Arabic digit 8
+  "\u06F9": '9' // Eastern-Arabic digit 9
+};
+function parseDigit(character) {
+  return DIGITS[character];
+}
+
+export { DIGITS, parseDigit };