ingeniuscliq-core 0.5.32 → 0.5.34

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

@@ -0,0 +1,602 @@
+import compare from './tools/semver-compare.js';
+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 _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", { writable: false }), 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 )(t); }
+
+// Added "idd_prefix" and "default_idd_prefix".
+var V3 = '1.2.0';
+
+// Moved `001` country code to "nonGeographic" section of metadata.
+var V4 = '1.7.35';
+var DEFAULT_EXT_PREFIX = ' ext. ';
+var CALLING_CODE_REG_EXP = /^\d+$/;
+
+/**
+ * See: https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md
+ */
+var Metadata = /*#__PURE__*/function () {
+  function Metadata(metadata) {
+    _classCallCheck(this, Metadata);
+    validateMetadata(metadata);
+    this.metadata = metadata;
+    setVersion.call(this, metadata);
+  }
+  return _createClass(Metadata, [{
+    key: "getCountries",
+    value: function getCountries() {
+      return Object.keys(this.metadata.countries).filter(function (_) {
+        return _ !== '001';
+      });
+    }
+  }, {
+    key: "getCountryMetadata",
+    value: function getCountryMetadata(countryCode) {
+      return this.metadata.countries[countryCode];
+    }
+  }, {
+    key: "nonGeographic",
+    value: function nonGeographic() {
+      if (this.v1 || this.v2 || this.v3) return;
+      // `nonGeographical` was a typo.
+      // It's present in metadata generated from `1.7.35` to `1.7.37`.
+      // The test case could be found by searching for "nonGeographical".
+      return this.metadata.nonGeographic || this.metadata.nonGeographical;
+    }
+  }, {
+    key: "hasCountry",
+    value: function hasCountry(country) {
+      return this.getCountryMetadata(country) !== undefined;
+    }
+  }, {
+    key: "hasCallingCode",
+    value: function hasCallingCode(callingCode) {
+      if (this.getCountryCodesForCallingCode(callingCode)) {
+        return true;
+      }
+      if (this.nonGeographic()) {
+        if (this.nonGeographic()[callingCode]) {
+          return true;
+        }
+      } else {
+        // A hacky workaround for old custom metadata (generated before V4).
+        var countryCodes = this.countryCallingCodes()[callingCode];
+        if (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {
+          return true;
+        }
+      }
+    }
+  }, {
+    key: "isNonGeographicCallingCode",
+    value: function isNonGeographicCallingCode(callingCode) {
+      if (this.nonGeographic()) {
+        return this.nonGeographic()[callingCode] ? true : false;
+      } else {
+        return this.getCountryCodesForCallingCode(callingCode) ? false : true;
+      }
+    }
+
+    // Deprecated.
+  }, {
+    key: "country",
+    value: function country(countryCode) {
+      return this.selectNumberingPlan(countryCode);
+    }
+  }, {
+    key: "selectNumberingPlan",
+    value: function selectNumberingPlan(countryCode, callingCode) {
+      // Supports just passing `callingCode` as the first argument.
+      if (countryCode && CALLING_CODE_REG_EXP.test(countryCode)) {
+        callingCode = countryCode;
+        countryCode = null;
+      }
+      if (countryCode && countryCode !== '001') {
+        if (!this.hasCountry(countryCode)) {
+          throw new Error("Unknown country: ".concat(countryCode));
+        }
+        this.numberingPlan = new NumberingPlan(this.getCountryMetadata(countryCode), this);
+      } else if (callingCode) {
+        if (!this.hasCallingCode(callingCode)) {
+          throw new Error("Unknown calling code: ".concat(callingCode));
+        }
+        this.numberingPlan = new NumberingPlan(this.getNumberingPlanMetadata(callingCode), this);
+      } else {
+        this.numberingPlan = undefined;
+      }
+      return this;
+    }
+  }, {
+    key: "getCountryCodesForCallingCode",
+    value: function getCountryCodesForCallingCode(callingCode) {
+      var countryCodes = this.countryCallingCodes()[callingCode];
+      if (countryCodes) {
+        // Metadata before V4 included "non-geographic entity" calling codes
+        // inside `country_calling_codes` (for example, `"881":["001"]`).
+        // Now the semantics of `country_calling_codes` has changed:
+        // it's specifically for "countries" now.
+        // Older versions of custom metadata will simply skip parsing
+        // "non-geographic entity" phone numbers with new versions
+        // of this library: it's not considered a bug,
+        // because such numbers are extremely rare,
+        // and developers extremely rarely use custom metadata.
+        if (countryCodes.length === 1 && countryCodes[0].length === 3) {
+          return;
+        }
+        return countryCodes;
+      }
+    }
+  }, {
+    key: "getCountryCodeForCallingCode",
+    value: function getCountryCodeForCallingCode(callingCode) {
+      var countryCodes = this.getCountryCodesForCallingCode(callingCode);
+      if (countryCodes) {
+        return countryCodes[0];
+      }
+    }
+  }, {
+    key: "getNumberingPlanMetadata",
+    value: function getNumberingPlanMetadata(callingCode) {
+      var countryCode = this.getCountryCodeForCallingCode(callingCode);
+      if (countryCode) {
+        return this.getCountryMetadata(countryCode);
+      }
+      if (this.nonGeographic()) {
+        var metadata = this.nonGeographic()[callingCode];
+        if (metadata) {
+          return metadata;
+        }
+      } else {
+        // A hacky workaround for old custom metadata (generated before V4).
+        // In that metadata, there was no concept of "non-geographic" metadata
+        // so metadata for `001` country code was stored along with other countries.
+        // The test case can be found by searching for:
+        // "should work around `nonGeographic` metadata not existing".
+        var countryCodes = this.countryCallingCodes()[callingCode];
+        if (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {
+          return this.metadata.countries['001'];
+        }
+      }
+    }
+
+    // Deprecated.
+  }, {
+    key: "countryCallingCode",
+    value: function countryCallingCode() {
+      return this.numberingPlan.callingCode();
+    }
+
+    // Deprecated.
+  }, {
+    key: "IDDPrefix",
+    value: function IDDPrefix() {
+      return this.numberingPlan.IDDPrefix();
+    }
+
+    // Deprecated.
+  }, {
+    key: "defaultIDDPrefix",
+    value: function defaultIDDPrefix() {
+      return this.numberingPlan.defaultIDDPrefix();
+    }
+
+    // Deprecated.
+  }, {
+    key: "nationalNumberPattern",
+    value: function nationalNumberPattern() {
+      return this.numberingPlan.nationalNumberPattern();
+    }
+
+    // Deprecated.
+  }, {
+    key: "possibleLengths",
+    value: function possibleLengths() {
+      return this.numberingPlan.possibleLengths();
+    }
+
+    // Deprecated.
+  }, {
+    key: "formats",
+    value: function formats() {
+      return this.numberingPlan.formats();
+    }
+
+    // Deprecated.
+  }, {
+    key: "nationalPrefixForParsing",
+    value: function nationalPrefixForParsing() {
+      return this.numberingPlan.nationalPrefixForParsing();
+    }
+
+    // Deprecated.
+  }, {
+    key: "nationalPrefixTransformRule",
+    value: function nationalPrefixTransformRule() {
+      return this.numberingPlan.nationalPrefixTransformRule();
+    }
+
+    // Deprecated.
+  }, {
+    key: "leadingDigits",
+    value: function leadingDigits() {
+      return this.numberingPlan.leadingDigits();
+    }
+
+    // Deprecated.
+  }, {
+    key: "hasTypes",
+    value: function hasTypes() {
+      return this.numberingPlan.hasTypes();
+    }
+
+    // Deprecated.
+  }, {
+    key: "type",
+    value: function type(_type) {
+      return this.numberingPlan.type(_type);
+    }
+
+    // Deprecated.
+  }, {
+    key: "ext",
+    value: function ext() {
+      return this.numberingPlan.ext();
+    }
+  }, {
+    key: "countryCallingCodes",
+    value: function countryCallingCodes() {
+      if (this.v1) return this.metadata.country_phone_code_to_countries;
+      return this.metadata.country_calling_codes;
+    }
+
+    // Deprecated.
+  }, {
+    key: "chooseCountryByCountryCallingCode",
+    value: function chooseCountryByCountryCallingCode(callingCode) {
+      return this.selectNumberingPlan(callingCode);
+    }
+  }, {
+    key: "hasSelectedNumberingPlan",
+    value: function hasSelectedNumberingPlan() {
+      return this.numberingPlan !== undefined;
+    }
+  }]);
+}();
+var NumberingPlan = /*#__PURE__*/function () {
+  function NumberingPlan(metadata, globalMetadataObject) {
+    _classCallCheck(this, NumberingPlan);
+    this.globalMetadataObject = globalMetadataObject;
+    this.metadata = metadata;
+    setVersion.call(this, globalMetadataObject.metadata);
+  }
+  return _createClass(NumberingPlan, [{
+    key: "callingCode",
+    value: function callingCode() {
+      return this.metadata[0];
+    }
+
+    // Formatting information for regions which share
+    // a country calling code is contained by only one region
+    // for performance reasons. For example, for NANPA region
+    // ("North American Numbering Plan Administration",
+    //  which includes USA, Canada, Cayman Islands, Bahamas, etc)
+    // it will be contained in the metadata for `US`.
+  }, {
+    key: "getDefaultCountryMetadataForRegion",
+    value: function getDefaultCountryMetadataForRegion() {
+      return this.globalMetadataObject.getNumberingPlanMetadata(this.callingCode());
+    }
+
+    // Is always present.
+  }, {
+    key: "IDDPrefix",
+    value: function IDDPrefix() {
+      if (this.v1 || this.v2) return;
+      return this.metadata[1];
+    }
+
+    // Is only present when a country supports multiple IDD prefixes.
+  }, {
+    key: "defaultIDDPrefix",
+    value: function defaultIDDPrefix() {
+      if (this.v1 || this.v2) return;
+      return this.metadata[12];
+    }
+  }, {
+    key: "nationalNumberPattern",
+    value: function nationalNumberPattern() {
+      if (this.v1 || this.v2) return this.metadata[1];
+      return this.metadata[2];
+    }
+
+    // "possible length" data is always present in Google's metadata.
+  }, {
+    key: "possibleLengths",
+    value: function possibleLengths() {
+      if (this.v1) return;
+      return this.metadata[this.v2 ? 2 : 3];
+    }
+  }, {
+    key: "_getFormats",
+    value: function _getFormats(metadata) {
+      return metadata[this.v1 ? 2 : this.v2 ? 3 : 4];
+    }
+
+    // For countries of the same region (e.g. NANPA)
+    // formats are all stored in the "main" country for that region.
+    // E.g. "RU" and "KZ", "US" and "CA".
+  }, {
+    key: "formats",
+    value: function formats() {
+      var _this = this;
+      var formats = this._getFormats(this.metadata) || this._getFormats(this.getDefaultCountryMetadataForRegion()) || [];
+      return formats.map(function (_) {
+        return new Format(_, _this);
+      });
+    }
+  }, {
+    key: "nationalPrefix",
+    value: function nationalPrefix() {
+      return this.metadata[this.v1 ? 3 : this.v2 ? 4 : 5];
+    }
+  }, {
+    key: "_getNationalPrefixFormattingRule",
+    value: function _getNationalPrefixFormattingRule(metadata) {
+      return metadata[this.v1 ? 4 : this.v2 ? 5 : 6];
+    }
+
+    // For countries of the same region (e.g. NANPA)
+    // national prefix formatting rule is stored in the "main" country for that region.
+    // E.g. "RU" and "KZ", "US" and "CA".
+  }, {
+    key: "nationalPrefixFormattingRule",
+    value: function nationalPrefixFormattingRule() {
+      return this._getNationalPrefixFormattingRule(this.metadata) || this._getNationalPrefixFormattingRule(this.getDefaultCountryMetadataForRegion());
+    }
+  }, {
+    key: "_nationalPrefixForParsing",
+    value: function _nationalPrefixForParsing() {
+      return this.metadata[this.v1 ? 5 : this.v2 ? 6 : 7];
+    }
+  }, {
+    key: "nationalPrefixForParsing",
+    value: function nationalPrefixForParsing() {
+      // If `national_prefix_for_parsing` is not set explicitly,
+      // then infer it from `national_prefix` (if any)
+      return this._nationalPrefixForParsing() || this.nationalPrefix();
+    }
+  }, {
+    key: "nationalPrefixTransformRule",
+    value: function nationalPrefixTransformRule() {
+      return this.metadata[this.v1 ? 6 : this.v2 ? 7 : 8];
+    }
+  }, {
+    key: "_getNationalPrefixIsOptionalWhenFormatting",
+    value: function _getNationalPrefixIsOptionalWhenFormatting() {
+      return !!this.metadata[this.v1 ? 7 : this.v2 ? 8 : 9];
+    }
+
+    // For countries of the same region (e.g. NANPA)
+    // "national prefix is optional when formatting" flag is
+    // stored in the "main" country for that region.
+    // E.g. "RU" and "KZ", "US" and "CA".
+  }, {
+    key: "nationalPrefixIsOptionalWhenFormattingInNationalFormat",
+    value: function nationalPrefixIsOptionalWhenFormattingInNationalFormat() {
+      return this._getNationalPrefixIsOptionalWhenFormatting(this.metadata) || this._getNationalPrefixIsOptionalWhenFormatting(this.getDefaultCountryMetadataForRegion());
+    }
+  }, {
+    key: "leadingDigits",
+    value: function leadingDigits() {
+      return this.metadata[this.v1 ? 8 : this.v2 ? 9 : 10];
+    }
+  }, {
+    key: "types",
+    value: function types() {
+      return this.metadata[this.v1 ? 9 : this.v2 ? 10 : 11];
+    }
+  }, {
+    key: "hasTypes",
+    value: function hasTypes() {
+      // Versions 1.2.0 - 1.2.4: can be `[]`.
+      /* istanbul ignore next */
+      if (this.types() && this.types().length === 0) {
+        return false;
+      }
+      // Versions <= 1.2.4: can be `undefined`.
+      // Version >= 1.2.5: can be `0`.
+      return !!this.types();
+    }
+  }, {
+    key: "type",
+    value: function type(_type2) {
+      if (this.hasTypes() && getType(this.types(), _type2)) {
+        return new Type(getType(this.types(), _type2), this);
+      }
+    }
+  }, {
+    key: "ext",
+    value: function ext() {
+      if (this.v1 || this.v2) return DEFAULT_EXT_PREFIX;
+      return this.metadata[13] || DEFAULT_EXT_PREFIX;
+    }
+  }]);
+}();
+var Format = /*#__PURE__*/function () {
+  function Format(format, metadata) {
+    _classCallCheck(this, Format);
+    this._format = format;
+    this.metadata = metadata;
+  }
+  return _createClass(Format, [{
+    key: "pattern",
+    value: function pattern() {
+      return this._format[0];
+    }
+  }, {
+    key: "format",
+    value: function format() {
+      return this._format[1];
+    }
+  }, {
+    key: "leadingDigitsPatterns",
+    value: function leadingDigitsPatterns() {
+      return this._format[2] || [];
+    }
+  }, {
+    key: "nationalPrefixFormattingRule",
+    value: function nationalPrefixFormattingRule() {
+      return this._format[3] || this.metadata.nationalPrefixFormattingRule();
+    }
+  }, {
+    key: "nationalPrefixIsOptionalWhenFormattingInNationalFormat",
+    value: function nationalPrefixIsOptionalWhenFormattingInNationalFormat() {
+      return !!this._format[4] || this.metadata.nationalPrefixIsOptionalWhenFormattingInNationalFormat();
+    }
+  }, {
+    key: "nationalPrefixIsMandatoryWhenFormattingInNationalFormat",
+    value: function nationalPrefixIsMandatoryWhenFormattingInNationalFormat() {
+      // National prefix is omitted if there's no national prefix formatting rule
+      // set for this country, or when the national prefix formatting rule
+      // contains no national prefix itself, or when this rule is set but
+      // national prefix is optional for this phone number format
+      // (and it is not enforced explicitly)
+      return this.usesNationalPrefix() && !this.nationalPrefixIsOptionalWhenFormattingInNationalFormat();
+    }
+
+    // Checks whether national prefix formatting rule contains national prefix.
+  }, {
+    key: "usesNationalPrefix",
+    value: function usesNationalPrefix() {
+      return this.nationalPrefixFormattingRule() &&
+      // Check that national prefix formatting rule is not a "dummy" one.
+      !FIRST_GROUP_ONLY_PREFIX_PATTERN.test(this.nationalPrefixFormattingRule())
+      // In compressed metadata, `this.nationalPrefixFormattingRule()` is `0`
+      // when `national_prefix_formatting_rule` is not present.
+      // So, `true` or `false` are returned explicitly here, so that
+      // `0` number isn't returned.
+      ? true : false;
+    }
+  }, {
+    key: "internationalFormat",
+    value: function internationalFormat() {
+      return this._format[5] || this.format();
+    }
+  }]);
+}();
+/**
+ * A pattern that is used to determine if the national prefix formatting rule
+ * has the first group only, i.e., does not start with the national prefix.
+ * Note that the pattern explicitly allows for unbalanced parentheses.
+ */
+var FIRST_GROUP_ONLY_PREFIX_PATTERN = /^\(?\$1\)?$/;
+var Type = /*#__PURE__*/function () {
+  function Type(type, metadata) {
+    _classCallCheck(this, Type);
+    this.type = type;
+    this.metadata = metadata;
+  }
+  return _createClass(Type, [{
+    key: "pattern",
+    value: function pattern() {
+      if (this.metadata.v1) return this.type;
+      return this.type[0];
+    }
+  }, {
+    key: "possibleLengths",
+    value: function possibleLengths() {
+      if (this.metadata.v1) return;
+      return this.type[1] || this.metadata.possibleLengths();
+    }
+  }]);
+}();
+function getType(types, type) {
+  switch (type) {
+    case 'FIXED_LINE':
+      return types[0];
+    case 'MOBILE':
+      return types[1];
+    case 'TOLL_FREE':
+      return types[2];
+    case 'PREMIUM_RATE':
+      return types[3];
+    case 'PERSONAL_NUMBER':
+      return types[4];
+    case 'VOICEMAIL':
+      return types[5];
+    case 'UAN':
+      return types[6];
+    case 'PAGER':
+      return types[7];
+    case 'VOIP':
+      return types[8];
+    case 'SHARED_COST':
+      return types[9];
+  }
+}
+function validateMetadata(metadata) {
+  if (!metadata) {
+    throw new Error('[libphonenumber-js] `metadata` argument not passed. Check your arguments.');
+  }
+
+  // `country_phone_code_to_countries` was renamed to `country_calling_codes` in `1.0.18`.
+  // For that reason, it's not used in this detection algorithm.
+  // Instead, it detects by `countries: {}` property existence.
+  if (!isObject(metadata) || !isObject(metadata.countries)) {
+    throw new Error("[libphonenumber-js] `metadata` argument was passed but it's not a valid metadata. Must be an object having `.countries` child object property. Got ".concat(isObject(metadata) ? 'an object of shape: { ' + Object.keys(metadata).join(', ') + ' }' : 'a ' + typeOf(metadata) + ': ' + metadata, "."));
+  }
+}
+
+// Babel transforms `typeof` into some "branches"
+// so istanbul will show this as "branch not covered".
+/* istanbul ignore next */
+var typeOf = function typeOf(_) {
+  return _typeof(_);
+};
+
+/**
+ * Returns "country calling code" for a country.
+ * Throws an error if the country doesn't exist or isn't supported by this library.
+ * @param  {string} country
+ * @param  {object} metadata
+ * @return {string}
+ * @example
+ * // Returns "44"
+ * getCountryCallingCode("GB")
+ */
+function getCountryCallingCode(country, metadata) {
+  metadata = new Metadata(metadata);
+  if (metadata.hasCountry(country)) {
+    return metadata.selectNumberingPlan(country).countryCallingCode();
+  }
+  throw new Error("Unknown country: ".concat(country));
+}
+function setVersion(metadata) {
+  var version = metadata.version;
+  if (typeof version === 'number') {
+    this.v1 = version === 1;
+    this.v2 = version === 2;
+    this.v3 = version === 3;
+    this.v4 = version === 4;
+  } else {
+    if (!version) {
+      this.v1 = true;
+    } else if (compare(version, V3) === -1) {
+      this.v2 = true;
+    } else if (compare(version, V4) === -1) {
+      this.v3 = true;
+    } else {
+      this.v4 = true;
+    }
+  }
+}
+
+// const ISO_COUNTRY_CODE = /^[A-Z]{2}$/
+// function isCountryCode(countryCode) {
+// 	return ISO_COUNTRY_CODE.test(countryCodeOrCountryCallingCode)
+// }
+
+export { Metadata as default, getCountryCallingCode, validateMetadata };

package/dist/node_modules/libphonenumber-js/es6/tools/semver-compare.js

@@ -0,0 +1,28 @@
+// Copy-pasted from:
+// https://github.com/substack/semver-compare/blob/master/index.js
+//
+// Inlining this function because some users reported issues with
+// importing from `semver-compare` in a browser with ES6 "native" modules.
+//
+// Fixes `semver-compare` not being able to compare versions with alpha/beta/etc "tags".
+// https://github.com/catamphetamine/libphonenumber-js/issues/381
+function compare (a, b) {
+  a = a.split('-');
+  b = b.split('-');
+  var pa = a[0].split('.');
+  var pb = b[0].split('.');
+  for (var i = 0; i < 3; i++) {
+    var na = Number(pa[i]);
+    var nb = Number(pb[i]);
+    if (na > nb) return 1;
+    if (nb > na) return -1;
+    if (!isNaN(na) && isNaN(nb)) return 1;
+    if (isNaN(na) && !isNaN(nb)) return -1;
+  }
+  if (a[1] && b[1]) {
+    return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
+  }
+  return !a[1] && b[1] ? 1 : a[1] && !b[1] ? -1 : 0;
+}
+
+export { compare as default };