You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
679 lines
21 KiB
679 lines
21 KiB
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
exports.getCountryCallingCode = getCountryCallingCode;
|
|
exports.getExtPrefix = getExtPrefix;
|
|
exports.isSupportedCountry = isSupportedCountry;
|
|
exports.validateMetadata = validateMetadata;
|
|
|
|
var _semverCompare = _interopRequireDefault(require("./tools/semver-compare.js"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
|
|
|
|
// Added "possibleLengths" and renamed
|
|
// "country_phone_code_to_countries" to "country_calling_codes".
|
|
var V2 = '1.0.18'; // 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);
|
|
}
|
|
|
|
_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;
|
|
}
|
|
}]);
|
|
|
|
return Metadata;
|
|
}();
|
|
|
|
exports["default"] = Metadata;
|
|
|
|
var NumberingPlan = /*#__PURE__*/function () {
|
|
function NumberingPlan(metadata, globalMetadataObject) {
|
|
_classCallCheck(this, NumberingPlan);
|
|
|
|
this.globalMetadataObject = globalMetadataObject;
|
|
this.metadata = metadata;
|
|
setVersion.call(this, globalMetadataObject.metadata);
|
|
}
|
|
|
|
_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;
|
|
}
|
|
}]);
|
|
|
|
return NumberingPlan;
|
|
}();
|
|
|
|
var Format = /*#__PURE__*/function () {
|
|
function Format(format, metadata) {
|
|
_classCallCheck(this, Format);
|
|
|
|
this._format = format;
|
|
this.metadata = metadata;
|
|
}
|
|
|
|
_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();
|
|
}
|
|
}]);
|
|
|
|
return 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;
|
|
}
|
|
|
|
_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();
|
|
}
|
|
}]);
|
|
|
|
return Type;
|
|
}();
|
|
|
|
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`.
|
|
|
|
|
|
if (!is_object(metadata) || !is_object(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(is_object(metadata) ? 'an object of shape: { ' + Object.keys(metadata).join(', ') + ' }' : 'a ' + type_of(metadata) + ': ' + metadata, "."));
|
|
}
|
|
} // Babel transforms `typeof` into some "branches"
|
|
// so istanbul will show this as "branch not covered".
|
|
|
|
/* istanbul ignore next */
|
|
|
|
|
|
var is_object = function is_object(_) {
|
|
return _typeof(_) === 'object';
|
|
}; // Babel transforms `typeof` into some "branches"
|
|
// so istanbul will show this as "branch not covered".
|
|
|
|
/* istanbul ignore next */
|
|
|
|
|
|
var type_of = function type_of(_) {
|
|
return _typeof(_);
|
|
};
|
|
/**
|
|
* Returns extension prefix for a country.
|
|
* @param {string} country
|
|
* @param {object} metadata
|
|
* @return {string?}
|
|
* @example
|
|
* // Returns " ext. "
|
|
* getExtPrefix("US")
|
|
*/
|
|
|
|
|
|
function getExtPrefix(country, metadata) {
|
|
metadata = new Metadata(metadata);
|
|
|
|
if (metadata.hasCountry(country)) {
|
|
return metadata.country(country).ext();
|
|
}
|
|
|
|
return DEFAULT_EXT_PREFIX;
|
|
}
|
|
/**
|
|
* 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.country(country).countryCallingCode();
|
|
}
|
|
|
|
throw new Error("Unknown country: ".concat(country));
|
|
}
|
|
|
|
function isSupportedCountry(country, metadata) {
|
|
// metadata = new Metadata(metadata)
|
|
// return metadata.hasCountry(country)
|
|
return metadata.countries[country] !== undefined;
|
|
}
|
|
|
|
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 ((0, _semverCompare["default"])(version, V3) === -1) {
|
|
this.v2 = true;
|
|
} else if ((0, _semverCompare["default"])(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)
|
|
// }
|
|
//# sourceMappingURL=metadata.js.map
|