ingeniuscliq-core 0.5.38 → 0.5.39

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

@@ -1,31 +0,0 @@
-import Metadata from '../metadata.js';
-import { VALID_DIGITS } from '../constants.js';
-
-var CAPTURING_DIGIT_PATTERN = new RegExp('([' + VALID_DIGITS + '])');
-function stripIddPrefix(number, country, callingCode, metadata) {
-  if (!country) {
-    return;
-  }
-  // Check if the number is IDD-prefixed.
-  var countryMetadata = new Metadata(metadata);
-  countryMetadata.selectNumberingPlan(country, callingCode);
-  var IDDPrefixPattern = new RegExp(countryMetadata.IDDPrefix());
-  if (number.search(IDDPrefixPattern) !== 0) {
-    return;
-  }
-  // Strip IDD prefix.
-  number = number.slice(number.match(IDDPrefixPattern)[0].length);
-  // If there're any digits after an IDD prefix,
-  // then those digits are a country calling code.
-  // Since no country code starts with a `0`,
-  // the code below validates that the next digit (if present) is not `0`.
-  var matchedGroups = number.match(CAPTURING_DIGIT_PATTERN);
-  if (matchedGroups && matchedGroups[1] != null && matchedGroups[1].length > 0) {
-    if (matchedGroups[1] === '0') {
-      return;
-    }
-  }
-  return number;
-}
-
-export { stripIddPrefix as default };

package/dist/node_modules/libphonenumber-js/es6/isPossible.js

@@ -1,78 +0,0 @@
-import Metadata from './metadata.js';
-import checkNumberLength from './helpers/checkNumberLength.js';
-
-/**
- * Checks if a phone number is "possible" (basically just checks its length).
- *
- * isPossible(phoneNumberInstance, { ..., v2: true }, metadata)
- *
- * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)
- * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)
- *
- * @param  {object|PhoneNumber} input — If `options.v2: true` flag is passed, the `input` should be a `PhoneNumber` instance. Otherwise, it should be an object of shape `{ phone: '...', country: '...' }`.
- * @param  {object} [options]
- * @param  {object} metadata
- * @return {string}
- */
-function isPossiblePhoneNumber(input, options, metadata) {
-  /* istanbul ignore if */
-  if (options === undefined) {
-    options = {};
-  }
-  metadata = new Metadata(metadata);
-  if (options.v2) {
-    if (!input.countryCallingCode) {
-      throw new Error('Invalid phone number object passed');
-    }
-    metadata.selectNumberingPlan(input.countryCallingCode);
-  } else {
-    if (!input.phone) {
-      return false;
-    }
-    if (input.country) {
-      if (!metadata.hasCountry(input.country)) {
-        throw new Error("Unknown country: ".concat(input.country));
-      }
-      metadata.selectNumberingPlan(input.country);
-    } else {
-      if (!input.countryCallingCode) {
-        throw new Error('Invalid phone number object passed');
-      }
-      metadata.selectNumberingPlan(input.countryCallingCode);
-    }
-  }
-
-  // Old metadata (< 1.0.18) had no "possible length" data.
-  if (metadata.possibleLengths()) {
-    return isPossibleNumber(input.phone || input.nationalNumber, input.country, metadata);
-  } else {
-    // There was a bug between `1.7.35` and `1.7.37` where "possible_lengths"
-    // were missing for "non-geographical" numbering plans.
-    // Just assume the number is possible in such cases:
-    // it's unlikely that anyone generated their custom metadata
-    // in that short period of time (one day).
-    // This code can be removed in some future major version update.
-    if (input.countryCallingCode && metadata.isNonGeographicCallingCode(input.countryCallingCode)) {
-      // "Non-geographic entities" did't have `possibleLengths`
-      // due to a bug in metadata generation process.
-      return true;
-    } else {
-      throw new Error('Missing "possibleLengths" in metadata. Perhaps the metadata has been generated before v1.0.18.');
-    }
-  }
-}
-function isPossibleNumber(nationalNumber, country, metadata) {
-  //, isInternational) {
-  switch (checkNumberLength(nationalNumber, country, metadata)) {
-    case 'IS_POSSIBLE':
-      return true;
-    // This library ignores "local-only" phone numbers (for simplicity).
-    // See the readme for more info on what are "local-only" phone numbers.
-    // case 'IS_POSSIBLE_LOCAL_ONLY':
-    // 	return !isInternational
-    default:
-      return false;
-  }
-}
-
-export { isPossiblePhoneNumber as default, isPossibleNumber };

package/dist/node_modules/libphonenumber-js/es6/isValid.js

@@ -1,58 +0,0 @@
-import Metadata from './metadata.js';
-import matchesEntirely from './helpers/matchesEntirely.js';
-import getNumberType from './helpers/getNumberType.js';
-
-/**
- * Checks if a given phone number is valid.
- *
- * isValid(phoneNumberInstance, { ..., v2: true }, metadata)
- *
- * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)
- * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)
- *
- * If the `number` is a string, it will be parsed to an object,
- * but only if it contains only valid phone number characters (including punctuation).
- * If the `number` is an object, it is used as is.
- *
- * The optional `defaultCountry` argument is the default country.
- * I.e. it does not restrict to just that country,
- * e.g. in those cases where several countries share
- * the same phone numbering rules (NANPA, Britain, etc).
- * For example, even though the number `07624 369230`
- * belongs to the Isle of Man ("IM" country code)
- * calling `isValidNumber('07624369230', 'GB', metadata)`
- * still returns `true` because the country is not restricted to `GB`,
- * it's just that `GB` is the default one for the phone numbering rules.
- * For restricting the country see `isValidNumberForRegion()`
- * though restricting a country might not be a good idea.
- * https://github.com/googlei18n/libphonenumber/blob/master/FAQ.md#when-should-i-use-isvalidnumberforregion
- *
- * Examples:
- *
- * ```js
- * isValidNumber('+78005553535', metadata)
- * isValidNumber('8005553535', 'RU', metadata)
- * isValidNumber('88005553535', 'RU', metadata)
- * isValidNumber({ phone: '8005553535', country: 'RU' }, metadata)
- * ```
- */
-function isValidNumber(input, options, metadata) {
-  // If assigning the `{}` default value is moved to the arguments above,
-  // code coverage would decrease for some weird reason.
-  options = options || {};
-  metadata = new Metadata(metadata);
-  metadata.selectNumberingPlan(input.country, input.countryCallingCode);
-
-  // By default, countries only have type regexps when it's required for
-  // distinguishing different countries having the same `countryCallingCode`.
-  if (metadata.hasTypes()) {
-    return getNumberType(input, options, metadata.metadata) !== undefined;
-  }
-
-  // If there are no type regexps for this country in metadata then use
-  // `nationalNumberPattern` as a "better than nothing" replacement.
-  var nationalNumber = options.v2 ? input.nationalNumber : input.phone;
-  return matchesEntirely(nationalNumber, metadata.nationalNumberPattern());
-}
-
-export { isValidNumber as default };

package/dist/node_modules/libphonenumber-js/es6/isValidPhoneNumber.js

@@ -1,22 +0,0 @@
-import normalizeArguments from './normalizeArguments.js';
-import parsePhoneNumber from './parsePhoneNumber_.js';
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function isValidPhoneNumber() {
-  var _normalizeArguments = normalizeArguments(arguments),
-    text = _normalizeArguments.text,
-    options = _normalizeArguments.options,
-    metadata = _normalizeArguments.metadata;
-  options = _objectSpread(_objectSpread({}, options), {}, {
-    extract: false
-  });
-  var phoneNumber = parsePhoneNumber(text, options, metadata);
-  return phoneNumber && phoneNumber.isValid() || false;
-}
-
-export { isValidPhoneNumber as default };

package/dist/node_modules/libphonenumber-js/es6/normalizeArguments.js

@@ -1,70 +0,0 @@
-import isObject from './helpers/isObject.js';
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = true, o = false; try { if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = true, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
-
-// Extracts the following properties from function arguments:
-// * input `text`
-// * `options` object
-// * `metadata` JSON
-function normalizeArguments(args) {
-  var _Array$prototype$slic = Array.prototype.slice.call(args),
-    _Array$prototype$slic2 = _slicedToArray(_Array$prototype$slic, 4),
-    arg_1 = _Array$prototype$slic2[0],
-    arg_2 = _Array$prototype$slic2[1],
-    arg_3 = _Array$prototype$slic2[2],
-    arg_4 = _Array$prototype$slic2[3];
-  var text;
-  var options;
-  var metadata;
-
-  // If the phone number is passed as a string.
-  // `parsePhoneNumber('88005553535', ...)`.
-  if (typeof arg_1 === 'string') {
-    text = arg_1;
-  } else throw new TypeError('A text for parsing must be a string.');
-
-  // If "default country" argument is being passed then move it to `options`.
-  // `parsePhoneNumber('88005553535', 'RU', [options], metadata)`.
-  if (!arg_2 || typeof arg_2 === 'string') {
-    if (arg_4) {
-      options = arg_3;
-      metadata = arg_4;
-    } else {
-      options = undefined;
-      metadata = arg_3;
-    }
-    if (arg_2) {
-      options = _objectSpread({
-        defaultCountry: arg_2
-      }, options);
-    }
-  }
-  // `defaultCountry` is not passed.
-  // Example: `parsePhoneNumber('+78005553535', [options], metadata)`.
-  else if (isObject(arg_2)) {
-    if (arg_3) {
-      options = arg_2;
-      metadata = arg_3;
-    } else {
-      metadata = arg_2;
-    }
-  } else throw new Error("Invalid second argument: ".concat(arg_2));
-  return {
-    text: text,
-    options: options,
-    metadata: metadata
-  };
-}
-
-export { normalizeArguments as default };

package/dist/node_modules/libphonenumber-js/es6/parse.js

@@ -1,326 +0,0 @@
-import { MIN_LENGTH_FOR_NSN, MAX_LENGTH_FOR_NSN, PLUS_CHARS, VALID_DIGITS } from './constants.js';
-import ParseError from './ParseError.js';
-import Metadata, { getCountryCallingCode } from './metadata.js';
-import isViablePhoneNumber, { isViablePhoneNumberStart } from './helpers/isViablePhoneNumber.js';
-import extractExtension from './helpers/extension/extractExtension.js';
-import parseIncompletePhoneNumber from './parseIncompletePhoneNumber.js';
-import { isPossibleNumber } from './isPossible.js';
-import PhoneNumber from './PhoneNumber.js';
-import matchesEntirely from './helpers/matchesEntirely.js';
-import extractCountryCallingCode from './helpers/extractCountryCallingCode.js';
-import extractNationalNumber from './helpers/extractNationalNumber.js';
-import getCountryByCallingCode from './helpers/getCountryByCallingCode.js';
-import extractFormattedPhoneNumberFromPossibleRfc3966NumberUri from './helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js';
-
-// This is a port of Google Android `libphonenumber`'s
-// `phonenumberutil.js` of December 31th, 2018.
-//
-// https://github.com/googlei18n/libphonenumber/commits/master/javascript/i18n/phonenumbers/phonenumberutil.js
-
-
-// We don't allow input strings for parsing to be longer than 250 chars.
-// This prevents malicious input from consuming CPU.
-var MAX_INPUT_STRING_LENGTH = 250;
-
-// This consists of the plus symbol, digits, and arabic-indic digits.
-var PHONE_NUMBER_START_PATTERN = new RegExp('[' + PLUS_CHARS + VALID_DIGITS + ']');
-
-// Regular expression of trailing characters that we want to remove.
-// A trailing `#` is sometimes used when writing phone numbers with extensions in US.
-// Example: "+1 (645) 123 1234-910#" number has extension "910".
-var AFTER_PHONE_NUMBER_END_PATTERN = new RegExp('[^' + VALID_DIGITS + '#' + ']+$');
-
-// Examples:
-//
-// ```js
-// parse('8 (800) 555-35-35', 'RU')
-// parse('8 (800) 555-35-35', 'RU', metadata)
-// parse('8 (800) 555-35-35', { country: { default: 'RU' } })
-// parse('8 (800) 555-35-35', { country: { default: 'RU' } }, metadata)
-// parse('+7 800 555 35 35')
-// parse('+7 800 555 35 35', metadata)
-// ```
-//
-
-/**
- * Parses a phone number.
- *
- * parse('123456789', { defaultCountry: 'RU', v2: true }, metadata)
- * parse('123456789', { defaultCountry: 'RU' }, metadata)
- * parse('123456789', undefined, metadata)
- *
- * @param  {string} input
- * @param  {object} [options]
- * @param  {object} metadata
- * @return {object|PhoneNumber?} If `options.v2: true` flag is passed, it returns a `PhoneNumber?` instance. Otherwise, returns an object of shape `{ phone: '...', country: '...' }` (or just `{}` if no phone number was parsed).
- */
-function parse(text, options, metadata) {
-  // If assigning the `{}` default value is moved to the arguments above,
-  // code coverage would decrease for some weird reason.
-  options = options || {};
-  metadata = new Metadata(metadata);
-
-  // Validate `defaultCountry`.
-  if (options.defaultCountry && !metadata.hasCountry(options.defaultCountry)) {
-    if (options.v2) {
-      throw new ParseError('INVALID_COUNTRY');
-    }
-    throw new Error("Unknown country: ".concat(options.defaultCountry));
-  }
-
-  // Parse the phone number.
-  var _parseInput = parseInput(text, options.v2, options.extract),
-    formattedPhoneNumber = _parseInput.number,
-    ext = _parseInput.ext,
-    error = _parseInput.error;
-
-  // If the phone number is not viable then return nothing.
-  if (!formattedPhoneNumber) {
-    if (options.v2) {
-      if (error === 'TOO_SHORT') {
-        throw new ParseError('TOO_SHORT');
-      }
-      throw new ParseError('NOT_A_NUMBER');
-    }
-    return {};
-  }
-  var _parsePhoneNumber = parsePhoneNumber(formattedPhoneNumber, options.defaultCountry, options.defaultCallingCode, metadata),
-    country = _parsePhoneNumber.country,
-    nationalNumber = _parsePhoneNumber.nationalNumber,
-    countryCallingCode = _parsePhoneNumber.countryCallingCode,
-    countryCallingCodeSource = _parsePhoneNumber.countryCallingCodeSource,
-    carrierCode = _parsePhoneNumber.carrierCode;
-  if (!metadata.hasSelectedNumberingPlan()) {
-    if (options.v2) {
-      throw new ParseError('INVALID_COUNTRY');
-    }
-    return {};
-  }
-
-  // Validate national (significant) number length.
-  if (!nationalNumber || nationalNumber.length < MIN_LENGTH_FOR_NSN) {
-    // Won't throw here because the regexp already demands length > 1.
-    /* istanbul ignore if */
-    if (options.v2) {
-      throw new ParseError('TOO_SHORT');
-    }
-    // Google's demo just throws an error in this case.
-    return {};
-  }
-
-  // Validate national (significant) number length.
-  //
-  // A sidenote:
-  //
-  // They say that sometimes national (significant) numbers
-  // can be longer than `MAX_LENGTH_FOR_NSN` (e.g. in Germany).
-  // https://github.com/googlei18n/libphonenumber/blob/7e1748645552da39c4e1ba731e47969d97bdb539/resources/phonenumber.proto#L36
-  // Such numbers will just be discarded.
-  //
-  if (nationalNumber.length > MAX_LENGTH_FOR_NSN) {
-    if (options.v2) {
-      throw new ParseError('TOO_LONG');
-    }
-    // Google's demo just throws an error in this case.
-    return {};
-  }
-  if (options.v2) {
-    var phoneNumber = new PhoneNumber(countryCallingCode, nationalNumber, metadata.metadata);
-    if (country) {
-      phoneNumber.country = country;
-    }
-    if (carrierCode) {
-      phoneNumber.carrierCode = carrierCode;
-    }
-    if (ext) {
-      phoneNumber.ext = ext;
-    }
-    phoneNumber.__countryCallingCodeSource = countryCallingCodeSource;
-    return phoneNumber;
-  }
-
-  // Check if national phone number pattern matches the number.
-  // National number pattern is different for each country,
-  // even for those ones which are part of the "NANPA" group.
-  var valid = (options.extended ? metadata.hasSelectedNumberingPlan() : country) ? matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) : false;
-  if (!options.extended) {
-    return valid ? result(country, nationalNumber, ext) : {};
-  }
-
-  // isInternational: countryCallingCode !== undefined
-
-  return {
-    country: country,
-    countryCallingCode: countryCallingCode,
-    carrierCode: carrierCode,
-    valid: valid,
-    possible: valid ? true : options.extended === true && metadata.possibleLengths() && isPossibleNumber(nationalNumber, country, metadata) ? true : false,
-    phone: nationalNumber,
-    ext: ext
-  };
-}
-
-/**
- * Extracts a formatted phone number from text.
- * Doesn't guarantee that the extracted phone number
- * is a valid phone number (for example, doesn't validate its length).
- * @param  {string} text
- * @param  {boolean} [extract] — If `false`, then will parse the entire `text` as a phone number.
- * @param  {boolean} [throwOnError] — By default, it won't throw if the text is too long.
- * @return {string}
- * @example
- * // Returns "(213) 373-4253".
- * extractFormattedPhoneNumber("Call (213) 373-4253 for assistance.")
- */
-function _extractFormattedPhoneNumber(text, extract, throwOnError) {
-  if (!text) {
-    return;
-  }
-  if (text.length > MAX_INPUT_STRING_LENGTH) {
-    if (throwOnError) {
-      throw new ParseError('TOO_LONG');
-    }
-    return;
-  }
-  if (extract === false) {
-    return text;
-  }
-  // Attempt to extract a possible number from the string passed in
-  var startsAt = text.search(PHONE_NUMBER_START_PATTERN);
-  if (startsAt < 0) {
-    return;
-  }
-  return text
-  // Trim everything to the left of the phone number
-  .slice(startsAt)
-  // Remove trailing non-numerical characters
-  .replace(AFTER_PHONE_NUMBER_END_PATTERN, '');
-}
-
-/**
- * @param  {string} text - Input.
- * @param  {boolean} v2 - Legacy API functions don't pass `v2: true` flag.
- * @param  {boolean} [extract] - Whether to extract a phone number from `text`, or attempt to parse the entire text as a phone number.
- * @return {object} `{ ?number, ?ext }`.
- */
-function parseInput(text, v2, extract) {
-  // // Parse RFC 3966 phone number URI.
-  // if (text && text.indexOf('tel:') === 0) {
-  // 	return parseRFC3966(text)
-  // }
-  // let number = extractFormattedPhoneNumber(text, extract, v2)
-  var number = extractFormattedPhoneNumberFromPossibleRfc3966NumberUri(text, {
-    extractFormattedPhoneNumber: function extractFormattedPhoneNumber(text) {
-      return _extractFormattedPhoneNumber(text, extract, v2);
-    }
-  });
-  // If the phone number is not viable, then abort.
-  if (!number) {
-    return {};
-  }
-  if (!isViablePhoneNumber(number)) {
-    if (isViablePhoneNumberStart(number)) {
-      return {
-        error: 'TOO_SHORT'
-      };
-    }
-    return {};
-  }
-  // Attempt to parse extension first, since it doesn't require region-specific
-  // data and we want to have the non-normalised number here.
-  var withExtensionStripped = extractExtension(number);
-  if (withExtensionStripped.ext) {
-    return withExtensionStripped;
-  }
-  return {
-    number: number
-  };
-}
-
-/**
- * Creates `parse()` result object.
- */
-function result(country, nationalNumber, ext) {
-  var result = {
-    country: country,
-    phone: nationalNumber
-  };
-  if (ext) {
-    result.ext = ext;
-  }
-  return result;
-}
-
-/**
- * Parses a viable phone number.
- * @param {string} formattedPhoneNumber — Example: "(213) 373-4253".
- * @param {string} [defaultCountry]
- * @param {string} [defaultCallingCode]
- * @param {Metadata} metadata
- * @return {object} Returns `{ country: string?, countryCallingCode: string?, nationalNumber: string? }`.
- */
-function parsePhoneNumber(formattedPhoneNumber, defaultCountry, defaultCallingCode, metadata) {
-  // Extract calling code from phone number.
-  var _extractCountryCallin = extractCountryCallingCode(parseIncompletePhoneNumber(formattedPhoneNumber), undefined, defaultCountry, defaultCallingCode, metadata.metadata),
-    countryCallingCodeSource = _extractCountryCallin.countryCallingCodeSource,
-    countryCallingCode = _extractCountryCallin.countryCallingCode,
-    number = _extractCountryCallin.number;
-
-  // The exact country of the phone number
-  var country;
-
-  // If `formattedPhoneNumber` is passed in "international" format,
-  // choose a country by `countryCallingCode`.
-  if (countryCallingCode) {
-    metadata.selectNumberingPlan(countryCallingCode);
-  }
-  // Else, if `formattedPhoneNumber` is passed in "national" format,
-  // then `number` is defined and `countryCallingCode` is `undefined`.
-  else if (number && (defaultCountry || defaultCallingCode)) {
-    metadata.selectNumberingPlan(defaultCountry, defaultCallingCode);
-    if (defaultCountry) {
-      country = defaultCountry;
-    }
-    countryCallingCode = defaultCallingCode || getCountryCallingCode(defaultCountry, metadata.metadata);
-  } else return {};
-  if (!number) {
-    return {
-      countryCallingCodeSource: countryCallingCodeSource,
-      countryCallingCode: countryCallingCode
-    };
-  }
-  var _extractNationalNumbe = extractNationalNumber(parseIncompletePhoneNumber(number), country, metadata),
-    nationalNumber = _extractNationalNumbe.nationalNumber,
-    carrierCode = _extractNationalNumbe.carrierCode;
-
-  // Sometimes there are several countries
-  // corresponding to the same country phone code
-  // (e.g. NANPA countries all having `1` country phone code).
-  // Therefore, to reliably determine the exact country,
-  // national (significant) number should have been parsed first.
-  //
-  // When `metadata.json` is generated, all "ambiguous" country phone codes
-  // get their countries populated with the full set of
-  // "phone number type" regular expressions.
-  //
-  var exactCountry = getCountryByCallingCode(countryCallingCode, {
-    nationalNumber: nationalNumber,
-    metadata: metadata
-  });
-  if (exactCountry) {
-    country = exactCountry;
-    /* istanbul ignore if */
-    if (exactCountry === '001') ; else {
-      metadata.selectNumberingPlan(country);
-    }
-  }
-  return {
-    country: country,
-    countryCallingCode: countryCallingCode,
-    countryCallingCodeSource: countryCallingCodeSource,
-    nationalNumber: nationalNumber,
-    carrierCode: carrierCode
-  };
-}
-
-export { parse as default };

package/dist/node_modules/libphonenumber-js/es6/parseIncompletePhoneNumber.js

@@ -1,62 +0,0 @@
-import { parseDigit } from './helpers/parseDigits.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; }
-
-/**
- * Parses phone number characters from a string.
- * Drops all punctuation leaving only digits and the leading `+` sign (if any).
- * Also converts wide-ascii and arabic-indic numerals to conventional numerals.
- * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.
- * @param  {string} string
- * @return {string}
- * @example
- * ```js
- * // Outputs '8800555'.
- * parseIncompletePhoneNumber('8 (800) 555')
- * // Outputs '+7800555'.
- * parseIncompletePhoneNumber('+7 800 555')
- * ```
- */
-function parseIncompletePhoneNumber(string) {
-  var result = '';
-  // Using `.split('')` here instead of normal `for ... of`
-  // because the importing application doesn't neccessarily include an ES6 polyfill.
-  // The `.split('')` approach discards "exotic" UTF-8 characters
-  // (the ones consisting of four bytes) but digits
-  // (including non-European ones) don't fall into that range
-  // so such "exotic" characters would be discarded anyway.
-  for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {
-    var character = _step.value;
-    result += parsePhoneNumberCharacter(character, result) || '';
-  }
-  return result;
-}
-
-/**
- * Parses next character while parsing phone number digits (including a `+`)
- * from text: discards everything except `+` and digits, and `+` is only allowed
- * at the start of a phone number.
- * For example, is used in `react-phone-number-input` where it uses
- * [`input-format`](https://gitlab.com/catamphetamine/input-format).
- * @param  {string} character - Yet another character from raw input string.
- * @param  {string?} prevParsedCharacters - Previous parsed characters.
- * @param  {function?} eventListener - An optional "on event" function.
- * @return {string?} The parsed character.
- */
-function parsePhoneNumberCharacter(character, prevParsedCharacters, eventListener) {
-  // Only allow a leading `+`.
-  if (character === '+') {
-    // If this `+` is not the first parsed character
-    // then discard it.
-    if (prevParsedCharacters) {
-      return;
-    }
-    return '+';
-  }
-  // Allow digits.
-  return parseDigit(character);
-}
-
-export { parseIncompletePhoneNumber as default, parsePhoneNumberCharacter };

package/dist/node_modules/libphonenumber-js/es6/parsePhoneNumberWithError_.js

@@ -1,15 +0,0 @@
-import parse from './parse.js';
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function parsePhoneNumberWithError(text, options, metadata) {
-  return parse(text, _objectSpread(_objectSpread({}, options), {}, {
-    v2: true
-  }), metadata);
-}
-
-export { parsePhoneNumberWithError as default };