{"version":3,"file":"js/vendors-0ce95ba7.min.js?t=1743075070513","mappings":"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","sources":["webpack://frontend/./node_modules/libphonenumber-js/es6/isPossible.js","webpack://frontend/./node_modules/libphonenumber-js/es6/isValid.js","webpack://frontend/./node_modules/libphonenumber-js/es6/metadata.js"],"sourcesContent":["import Metadata from './metadata.js';\nimport checkNumberLength from './helpers/checkNumberLength.js';\n/**\r\n * Checks if a phone number is \"possible\" (basically just checks its length).\r\n *\r\n * isPossible(phoneNumberInstance, { ..., v2: true }, metadata)\r\n *\r\n * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)\r\n * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)\r\n *\r\n * @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: '...' }`.\r\n * @param  {object} [options]\r\n * @param  {object} metadata\r\n * @return {string}\r\n */\n\nexport default function isPossiblePhoneNumber(input, options, metadata) {\n  /* istanbul ignore if */\n  if (options === undefined) {\n    options = {};\n  }\n\n  metadata = new Metadata(metadata);\n\n  if (options.v2) {\n    if (!input.countryCallingCode) {\n      throw new Error('Invalid phone number object passed');\n    }\n\n    metadata.selectNumberingPlan(input.countryCallingCode);\n  } else {\n    if (!input.phone) {\n      return false;\n    }\n\n    if (input.country) {\n      if (!metadata.hasCountry(input.country)) {\n        throw new Error(\"Unknown country: \".concat(input.country));\n      }\n\n      metadata.country(input.country);\n    } else {\n      if (!input.countryCallingCode) {\n        throw new Error('Invalid phone number object passed');\n      }\n\n      metadata.selectNumberingPlan(input.countryCallingCode);\n    }\n  } // Old metadata (< 1.0.18) had no \"possible length\" data.\n\n\n  if (metadata.possibleLengths()) {\n    return isPossibleNumber(input.phone || input.nationalNumber, metadata);\n  } else {\n    // There was a bug between `1.7.35` and `1.7.37` where \"possible_lengths\"\n    // were missing for \"non-geographical\" numbering plans.\n    // Just assume the number is possible in such cases:\n    // it's unlikely that anyone generated their custom metadata\n    // in that short period of time (one day).\n    // This code can be removed in some future major version update.\n    if (input.countryCallingCode && metadata.isNonGeographicCallingCode(input.countryCallingCode)) {\n      // \"Non-geographic entities\" did't have `possibleLengths`\n      // due to a bug in metadata generation process.\n      return true;\n    } else {\n      throw new Error('Missing \"possibleLengths\" in metadata. Perhaps the metadata has been generated before v1.0.18.');\n    }\n  }\n}\nexport function isPossibleNumber(nationalNumber, metadata) {\n  //, isInternational) {\n  switch (checkNumberLength(nationalNumber, metadata)) {\n    case 'IS_POSSIBLE':\n      return true;\n    // This library ignores \"local-only\" phone numbers (for simplicity).\n    // See the readme for more info on what are \"local-only\" phone numbers.\n    // case 'IS_POSSIBLE_LOCAL_ONLY':\n    // \treturn !isInternational\n\n    default:\n      return false;\n  }\n}\n//# sourceMappingURL=isPossible.js.map","import Metadata from './metadata.js';\nimport matchesEntirely from './helpers/matchesEntirely.js';\nimport getNumberType from './helpers/getNumberType.js';\n/**\r\n * Checks if a given phone number is valid.\r\n *\r\n * isValid(phoneNumberInstance, { ..., v2: true }, metadata)\r\n *\r\n * isPossible({ phone: '8005553535', country: 'RU' }, { ... }, metadata)\r\n * isPossible({ phone: '8005553535', country: 'RU' }, undefined, metadata)\r\n *\r\n * If the `number` is a string, it will be parsed to an object,\r\n * but only if it contains only valid phone number characters (including punctuation).\r\n * If the `number` is an object, it is used as is.\r\n *\r\n * The optional `defaultCountry` argument is the default country.\r\n * I.e. it does not restrict to just that country,\r\n * e.g. in those cases where several countries share\r\n * the same phone numbering rules (NANPA, Britain, etc).\r\n * For example, even though the number `07624 369230`\r\n * belongs to the Isle of Man (\"IM\" country code)\r\n * calling `isValidNumber('07624369230', 'GB', metadata)`\r\n * still returns `true` because the country is not restricted to `GB`,\r\n * it's just that `GB` is the default one for the phone numbering rules.\r\n * For restricting the country see `isValidNumberForRegion()`\r\n * though restricting a country might not be a good idea.\r\n * https://github.com/googlei18n/libphonenumber/blob/master/FAQ.md#when-should-i-use-isvalidnumberforregion\r\n *\r\n * Examples:\r\n *\r\n * ```js\r\n * isValidNumber('+78005553535', metadata)\r\n * isValidNumber('8005553535', 'RU', metadata)\r\n * isValidNumber('88005553535', 'RU', metadata)\r\n * isValidNumber({ phone: '8005553535', country: 'RU' }, metadata)\r\n * ```\r\n */\n\nexport default function isValidNumber(input, options, metadata) {\n  // If assigning the `{}` default value is moved to the arguments above,\n  // code coverage would decrease for some weird reason.\n  options = options || {};\n  metadata = new Metadata(metadata);\n  metadata.selectNumberingPlan(input.country, input.countryCallingCode); // By default, countries only have type regexps when it's required for\n  // distinguishing different countries having the same `countryCallingCode`.\n\n  if (metadata.hasTypes()) {\n    return getNumberType(input, options, metadata.metadata) !== undefined;\n  } // If there are no type regexps for this country in metadata then use\n  // `nationalNumberPattern` as a \"better than nothing\" replacement.\n\n\n  var nationalNumber = options.v2 ? input.nationalNumber : input.phone;\n  return matchesEntirely(nationalNumber, metadata.nationalNumberPattern());\n}\n//# sourceMappingURL=isValid.js.map","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); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\nimport compare from './tools/semver-compare.js';\nimport isObject from './helpers/isObject.js'; // Added \"possibleLengths\" and renamed\n// \"country_phone_code_to_countries\" to \"country_calling_codes\".\n\nvar V2 = '1.0.18'; // Added \"idd_prefix\" and \"default_idd_prefix\".\n\nvar V3 = '1.2.0'; // Moved `001` country code to \"nonGeographic\" section of metadata.\n\nvar V4 = '1.7.35';\nvar DEFAULT_EXT_PREFIX = ' ext. ';\nvar CALLING_CODE_REG_EXP = /^\\d+$/;\n/**\r\n * See: https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md\r\n */\n\nvar Metadata = /*#__PURE__*/function () {\n  function Metadata(metadata) {\n    _classCallCheck(this, Metadata);\n\n    validateMetadata(metadata);\n    this.metadata = metadata;\n    setVersion.call(this, metadata);\n  }\n\n  _createClass(Metadata, [{\n    key: \"getCountries\",\n    value: function getCountries() {\n      return Object.keys(this.metadata.countries).filter(function (_) {\n        return _ !== '001';\n      });\n    }\n  }, {\n    key: \"getCountryMetadata\",\n    value: function getCountryMetadata(countryCode) {\n      return this.metadata.countries[countryCode];\n    }\n  }, {\n    key: \"nonGeographic\",\n    value: function nonGeographic() {\n      if (this.v1 || this.v2 || this.v3) return; // `nonGeographical` was a typo.\n      // It's present in metadata generated from `1.7.35` to `1.7.37`.\n      // The test case could be found by searching for \"nonGeographical\".\n\n      return this.metadata.nonGeographic || this.metadata.nonGeographical;\n    }\n  }, {\n    key: \"hasCountry\",\n    value: function hasCountry(country) {\n      return this.getCountryMetadata(country) !== undefined;\n    }\n  }, {\n    key: \"hasCallingCode\",\n    value: function hasCallingCode(callingCode) {\n      if (this.getCountryCodesForCallingCode(callingCode)) {\n        return true;\n      }\n\n      if (this.nonGeographic()) {\n        if (this.nonGeographic()[callingCode]) {\n          return true;\n        }\n      } else {\n        // A hacky workaround for old custom metadata (generated before V4).\n        var countryCodes = this.countryCallingCodes()[callingCode];\n\n        if (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {\n          return true;\n        }\n      }\n    }\n  }, {\n    key: \"isNonGeographicCallingCode\",\n    value: function isNonGeographicCallingCode(callingCode) {\n      if (this.nonGeographic()) {\n        return this.nonGeographic()[callingCode] ? true : false;\n      } else {\n        return this.getCountryCodesForCallingCode(callingCode) ? false : true;\n      }\n    } // Deprecated.\n\n  }, {\n    key: \"country\",\n    value: function country(countryCode) {\n      return this.selectNumberingPlan(countryCode);\n    }\n  }, {\n    key: \"selectNumberingPlan\",\n    value: function selectNumberingPlan(countryCode, callingCode) {\n      // Supports just passing `callingCode` as the first argument.\n      if (countryCode && CALLING_CODE_REG_EXP.test(countryCode)) {\n        callingCode = countryCode;\n        countryCode = null;\n      }\n\n      if (countryCode && countryCode !== '001') {\n        if (!this.hasCountry(countryCode)) {\n          throw new Error(\"Unknown country: \".concat(countryCode));\n        }\n\n        this.numberingPlan = new NumberingPlan(this.getCountryMetadata(countryCode), this);\n      } else if (callingCode) {\n        if (!this.hasCallingCode(callingCode)) {\n          throw new Error(\"Unknown calling code: \".concat(callingCode));\n        }\n\n        this.numberingPlan = new NumberingPlan(this.getNumberingPlanMetadata(callingCode), this);\n      } else {\n        this.numberingPlan = undefined;\n      }\n\n      return this;\n    }\n  }, {\n    key: \"getCountryCodesForCallingCode\",\n    value: function getCountryCodesForCallingCode(callingCode) {\n      var countryCodes = this.countryCallingCodes()[callingCode];\n\n      if (countryCodes) {\n        // Metadata before V4 included \"non-geographic entity\" calling codes\n        // inside `country_calling_codes` (for example, `\"881\":[\"001\"]`).\n        // Now the semantics of `country_calling_codes` has changed:\n        // it's specifically for \"countries\" now.\n        // Older versions of custom metadata will simply skip parsing\n        // \"non-geographic entity\" phone numbers with new versions\n        // of this library: it's not considered a bug,\n        // because such numbers are extremely rare,\n        // and developers extremely rarely use custom metadata.\n        if (countryCodes.length === 1 && countryCodes[0].length === 3) {\n          return;\n        }\n\n        return countryCodes;\n      }\n    }\n  }, {\n    key: \"getCountryCodeForCallingCode\",\n    value: function getCountryCodeForCallingCode(callingCode) {\n      var countryCodes = this.getCountryCodesForCallingCode(callingCode);\n\n      if (countryCodes) {\n        return countryCodes[0];\n      }\n    }\n  }, {\n    key: \"getNumberingPlanMetadata\",\n    value: function getNumberingPlanMetadata(callingCode) {\n      var countryCode = this.getCountryCodeForCallingCode(callingCode);\n\n      if (countryCode) {\n        return this.getCountryMetadata(countryCode);\n      }\n\n      if (this.nonGeographic()) {\n        var metadata = this.nonGeographic()[callingCode];\n\n        if (metadata) {\n          return metadata;\n        }\n      } else {\n        // A hacky workaround for old custom metadata (generated before V4).\n        // In that metadata, there was no concept of \"non-geographic\" metadata\n        // so metadata for `001` country code was stored along with other countries.\n        // The test case can be found by searching for:\n        // \"should work around `nonGeographic` metadata not existing\".\n        var countryCodes = this.countryCallingCodes()[callingCode];\n\n        if (countryCodes && countryCodes.length === 1 && countryCodes[0] === '001') {\n          return this.metadata.countries['001'];\n        }\n      }\n    } // Deprecated.\n\n  }, {\n    key: \"countryCallingCode\",\n    value: function countryCallingCode() {\n      return this.numberingPlan.callingCode();\n    } // Deprecated.\n\n  }, {\n    key: \"IDDPrefix\",\n    value: function IDDPrefix() {\n      return this.numberingPlan.IDDPrefix();\n    } // Deprecated.\n\n  }, {\n    key: \"defaultIDDPrefix\",\n    value: function defaultIDDPrefix() {\n      return this.numberingPlan.defaultIDDPrefix();\n    } // Deprecated.\n\n  }, {\n    key: \"nationalNumberPattern\",\n    value: function nationalNumberPattern() {\n      return this.numberingPlan.nationalNumberPattern();\n    } // Deprecated.\n\n  }, {\n    key: \"possibleLengths\",\n    value: function possibleLengths() {\n      return this.numberingPlan.possibleLengths();\n    } // Deprecated.\n\n  }, {\n    key: \"formats\",\n    value: function formats() {\n      return this.numberingPlan.formats();\n    } // Deprecated.\n\n  }, {\n    key: \"nationalPrefixForParsing\",\n    value: function nationalPrefixForParsing() {\n      return this.numberingPlan.nationalPrefixForParsing();\n    } // Deprecated.\n\n  }, {\n    key: \"nationalPrefixTransformRule\",\n    value: function nationalPrefixTransformRule() {\n      return this.numberingPlan.nationalPrefixTransformRule();\n    } // Deprecated.\n\n  }, {\n    key: \"leadingDigits\",\n    value: function leadingDigits() {\n      return this.numberingPlan.leadingDigits();\n    } // Deprecated.\n\n  }, {\n    key: \"hasTypes\",\n    value: function hasTypes() {\n      return this.numberingPlan.hasTypes();\n    } // Deprecated.\n\n  }, {\n    key: \"type\",\n    value: function type(_type) {\n      return this.numberingPlan.type(_type);\n    } // Deprecated.\n\n  }, {\n    key: \"ext\",\n    value: function ext() {\n      return this.numberingPlan.ext();\n    }\n  }, {\n    key: \"countryCallingCodes\",\n    value: function countryCallingCodes() {\n      if (this.v1) return this.metadata.country_phone_code_to_countries;\n      return this.metadata.country_calling_codes;\n    } // Deprecated.\n\n  }, {\n    key: \"chooseCountryByCountryCallingCode\",\n    value: function chooseCountryByCountryCallingCode(callingCode) {\n      return this.selectNumberingPlan(callingCode);\n    }\n  }, {\n    key: \"hasSelectedNumberingPlan\",\n    value: function hasSelectedNumberingPlan() {\n      return this.numberingPlan !== undefined;\n    }\n  }]);\n\n  return Metadata;\n}();\n\nexport { Metadata as default };\n\nvar NumberingPlan = /*#__PURE__*/function () {\n  function NumberingPlan(metadata, globalMetadataObject) {\n    _classCallCheck(this, NumberingPlan);\n\n    this.globalMetadataObject = globalMetadataObject;\n    this.metadata = metadata;\n    setVersion.call(this, globalMetadataObject.metadata);\n  }\n\n  _createClass(NumberingPlan, [{\n    key: \"callingCode\",\n    value: function callingCode() {\n      return this.metadata[0];\n    } // Formatting information for regions which share\n    // a country calling code is contained by only one region\n    // for performance reasons. For example, for NANPA region\n    // (\"North American Numbering Plan Administration\",\n    //  which includes USA, Canada, Cayman Islands, Bahamas, etc)\n    // it will be contained in the metadata for `US`.\n\n  }, {\n    key: \"getDefaultCountryMetadataForRegion\",\n    value: function getDefaultCountryMetadataForRegion() {\n      return this.globalMetadataObject.getNumberingPlanMetadata(this.callingCode());\n    } // Is always present.\n\n  }, {\n    key: \"IDDPrefix\",\n    value: function IDDPrefix() {\n      if (this.v1 || this.v2) return;\n      return this.metadata[1];\n    } // Is only present when a country supports multiple IDD prefixes.\n\n  }, {\n    key: \"defaultIDDPrefix\",\n    value: function defaultIDDPrefix() {\n      if (this.v1 || this.v2) return;\n      return this.metadata[12];\n    }\n  }, {\n    key: \"nationalNumberPattern\",\n    value: function nationalNumberPattern() {\n      if (this.v1 || this.v2) return this.metadata[1];\n      return this.metadata[2];\n    } // \"possible length\" data is always present in Google's metadata.\n\n  }, {\n    key: \"possibleLengths\",\n    value: function possibleLengths() {\n      if (this.v1) return;\n      return this.metadata[this.v2 ? 2 : 3];\n    }\n  }, {\n    key: \"_getFormats\",\n    value: function _getFormats(metadata) {\n      return metadata[this.v1 ? 2 : this.v2 ? 3 : 4];\n    } // For countries of the same region (e.g. NANPA)\n    // formats are all stored in the \"main\" country for that region.\n    // E.g. \"RU\" and \"KZ\", \"US\" and \"CA\".\n\n  }, {\n    key: \"formats\",\n    value: function formats() {\n      var _this = this;\n\n      var formats = this._getFormats(this.metadata) || this._getFormats(this.getDefaultCountryMetadataForRegion()) || [];\n      return formats.map(function (_) {\n        return new Format(_, _this);\n      });\n    }\n  }, {\n    key: \"nationalPrefix\",\n    value: function nationalPrefix() {\n      return this.metadata[this.v1 ? 3 : this.v2 ? 4 : 5];\n    }\n  }, {\n    key: \"_getNationalPrefixFormattingRule\",\n    value: function _getNationalPrefixFormattingRule(metadata) {\n      return metadata[this.v1 ? 4 : this.v2 ? 5 : 6];\n    } // For countries of the same region (e.g. NANPA)\n    // national prefix formatting rule is stored in the \"main\" country for that region.\n    // E.g. \"RU\" and \"KZ\", \"US\" and \"CA\".\n\n  }, {\n    key: \"nationalPrefixFormattingRule\",\n    value: function nationalPrefixFormattingRule() {\n      return this._getNationalPrefixFormattingRule(this.metadata) || this._getNationalPrefixFormattingRule(this.getDefaultCountryMetadataForRegion());\n    }\n  }, {\n    key: \"_nationalPrefixForParsing\",\n    value: function _nationalPrefixForParsing() {\n      return this.metadata[this.v1 ? 5 : this.v2 ? 6 : 7];\n    }\n  }, {\n    key: \"nationalPrefixForParsing\",\n    value: function nationalPrefixForParsing() {\n      // If `national_prefix_for_parsing` is not set explicitly,\n      // then infer it from `national_prefix` (if any)\n      return this._nationalPrefixForParsing() || this.nationalPrefix();\n    }\n  }, {\n    key: \"nationalPrefixTransformRule\",\n    value: function nationalPrefixTransformRule() {\n      return this.metadata[this.v1 ? 6 : this.v2 ? 7 : 8];\n    }\n  }, {\n    key: \"_getNationalPrefixIsOptionalWhenFormatting\",\n    value: function _getNationalPrefixIsOptionalWhenFormatting() {\n      return !!this.metadata[this.v1 ? 7 : this.v2 ? 8 : 9];\n    } // For countries of the same region (e.g. NANPA)\n    // \"national prefix is optional when formatting\" flag is\n    // stored in the \"main\" country for that region.\n    // E.g. \"RU\" and \"KZ\", \"US\" and \"CA\".\n\n  }, {\n    key: \"nationalPrefixIsOptionalWhenFormattingInNationalFormat\",\n    value: function nationalPrefixIsOptionalWhenFormattingInNationalFormat() {\n      return this._getNationalPrefixIsOptionalWhenFormatting(this.metadata) || this._getNationalPrefixIsOptionalWhenFormatting(this.getDefaultCountryMetadataForRegion());\n    }\n  }, {\n    key: \"leadingDigits\",\n    value: function leadingDigits() {\n      return this.metadata[this.v1 ? 8 : this.v2 ? 9 : 10];\n    }\n  }, {\n    key: \"types\",\n    value: function types() {\n      return this.metadata[this.v1 ? 9 : this.v2 ? 10 : 11];\n    }\n  }, {\n    key: \"hasTypes\",\n    value: function hasTypes() {\n      // Versions 1.2.0 - 1.2.4: can be `[]`.\n\n      /* istanbul ignore next */\n      if (this.types() && this.types().length === 0) {\n        return false;\n      } // Versions <= 1.2.4: can be `undefined`.\n      // Version >= 1.2.5: can be `0`.\n\n\n      return !!this.types();\n    }\n  }, {\n    key: \"type\",\n    value: function type(_type2) {\n      if (this.hasTypes() && getType(this.types(), _type2)) {\n        return new Type(getType(this.types(), _type2), this);\n      }\n    }\n  }, {\n    key: \"ext\",\n    value: function ext() {\n      if (this.v1 || this.v2) return DEFAULT_EXT_PREFIX;\n      return this.metadata[13] || DEFAULT_EXT_PREFIX;\n    }\n  }]);\n\n  return NumberingPlan;\n}();\n\nvar Format = /*#__PURE__*/function () {\n  function Format(format, metadata) {\n    _classCallCheck(this, Format);\n\n    this._format = format;\n    this.metadata = metadata;\n  }\n\n  _createClass(Format, [{\n    key: \"pattern\",\n    value: function pattern() {\n      return this._format[0];\n    }\n  }, {\n    key: \"format\",\n    value: function format() {\n      return this._format[1];\n    }\n  }, {\n    key: \"leadingDigitsPatterns\",\n    value: function leadingDigitsPatterns() {\n      return this._format[2] || [];\n    }\n  }, {\n    key: \"nationalPrefixFormattingRule\",\n    value: function nationalPrefixFormattingRule() {\n      return this._format[3] || this.metadata.nationalPrefixFormattingRule();\n    }\n  }, {\n    key: \"nationalPrefixIsOptionalWhenFormattingInNationalFormat\",\n    value: function nationalPrefixIsOptionalWhenFormattingInNationalFormat() {\n      return !!this._format[4] || this.metadata.nationalPrefixIsOptionalWhenFormattingInNationalFormat();\n    }\n  }, {\n    key: \"nationalPrefixIsMandatoryWhenFormattingInNationalFormat\",\n    value: function nationalPrefixIsMandatoryWhenFormattingInNationalFormat() {\n      // National prefix is omitted if there's no national prefix formatting rule\n      // set for this country, or when the national prefix formatting rule\n      // contains no national prefix itself, or when this rule is set but\n      // national prefix is optional for this phone number format\n      // (and it is not enforced explicitly)\n      return this.usesNationalPrefix() && !this.nationalPrefixIsOptionalWhenFormattingInNationalFormat();\n    } // Checks whether national prefix formatting rule contains national prefix.\n\n  }, {\n    key: \"usesNationalPrefix\",\n    value: function usesNationalPrefix() {\n      return this.nationalPrefixFormattingRule() && // Check that national prefix formatting rule is not a \"dummy\" one.\n      !FIRST_GROUP_ONLY_PREFIX_PATTERN.test(this.nationalPrefixFormattingRule()) // In compressed metadata, `this.nationalPrefixFormattingRule()` is `0`\n      // when `national_prefix_formatting_rule` is not present.\n      // So, `true` or `false` are returned explicitly here, so that\n      // `0` number isn't returned.\n      ? true : false;\n    }\n  }, {\n    key: \"internationalFormat\",\n    value: function internationalFormat() {\n      return this._format[5] || this.format();\n    }\n  }]);\n\n  return Format;\n}();\n/**\r\n * A pattern that is used to determine if the national prefix formatting rule\r\n * has the first group only, i.e., does not start with the national prefix.\r\n * Note that the pattern explicitly allows for unbalanced parentheses.\r\n */\n\n\nvar FIRST_GROUP_ONLY_PREFIX_PATTERN = /^\\(?\\$1\\)?$/;\n\nvar Type = /*#__PURE__*/function () {\n  function Type(type, metadata) {\n    _classCallCheck(this, Type);\n\n    this.type = type;\n    this.metadata = metadata;\n  }\n\n  _createClass(Type, [{\n    key: \"pattern\",\n    value: function pattern() {\n      if (this.metadata.v1) return this.type;\n      return this.type[0];\n    }\n  }, {\n    key: \"possibleLengths\",\n    value: function possibleLengths() {\n      if (this.metadata.v1) return;\n      return this.type[1] || this.metadata.possibleLengths();\n    }\n  }]);\n\n  return Type;\n}();\n\nfunction getType(types, type) {\n  switch (type) {\n    case 'FIXED_LINE':\n      return types[0];\n\n    case 'MOBILE':\n      return types[1];\n\n    case 'TOLL_FREE':\n      return types[2];\n\n    case 'PREMIUM_RATE':\n      return types[3];\n\n    case 'PERSONAL_NUMBER':\n      return types[4];\n\n    case 'VOICEMAIL':\n      return types[5];\n\n    case 'UAN':\n      return types[6];\n\n    case 'PAGER':\n      return types[7];\n\n    case 'VOIP':\n      return types[8];\n\n    case 'SHARED_COST':\n      return types[9];\n  }\n}\n\nexport function validateMetadata(metadata) {\n  if (!metadata) {\n    throw new Error('[libphonenumber-js] `metadata` argument not passed. Check your arguments.');\n  } // `country_phone_code_to_countries` was renamed to `country_calling_codes` in `1.0.18`.\n  // For that reason, it's not used in this detection algorithm.\n  // Instead, it detects by `countries: {}` property existence.\n\n\n  if (!isObject(metadata) || !isObject(metadata.countries)) {\n    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, \".\"));\n  }\n} // Babel transforms `typeof` into some \"branches\"\n// so istanbul will show this as \"branch not covered\".\n\n/* istanbul ignore next */\n\nvar typeOf = function typeOf(_) {\n  return _typeof(_);\n};\n/**\r\n * Returns extension prefix for a country.\r\n * @param  {string} country\r\n * @param  {object} metadata\r\n * @return {string?}\r\n * @example\r\n * // Returns \" ext. \"\r\n * getExtPrefix(\"US\")\r\n */\n\n\nexport function getExtPrefix(country, metadata) {\n  metadata = new Metadata(metadata);\n\n  if (metadata.hasCountry(country)) {\n    return metadata.country(country).ext();\n  }\n\n  return DEFAULT_EXT_PREFIX;\n}\n/**\r\n * Returns \"country calling code\" for a country.\r\n * Throws an error if the country doesn't exist or isn't supported by this library.\r\n * @param  {string} country\r\n * @param  {object} metadata\r\n * @return {string}\r\n * @example\r\n * // Returns \"44\"\r\n * getCountryCallingCode(\"GB\")\r\n */\n\nexport function getCountryCallingCode(country, metadata) {\n  metadata = new Metadata(metadata);\n\n  if (metadata.hasCountry(country)) {\n    return metadata.country(country).countryCallingCode();\n  }\n\n  throw new Error(\"Unknown country: \".concat(country));\n}\nexport function isSupportedCountry(country, metadata) {\n  // metadata = new Metadata(metadata)\n  // return metadata.hasCountry(country)\n  return metadata.countries.hasOwnProperty(country);\n}\n\nfunction setVersion(metadata) {\n  var version = metadata.version;\n\n  if (typeof version === 'number') {\n    this.v1 = version === 1;\n    this.v2 = version === 2;\n    this.v3 = version === 3;\n    this.v4 = version === 4;\n  } else {\n    if (!version) {\n      this.v1 = true;\n    } else if (compare(version, V3) === -1) {\n      this.v2 = true;\n    } else if (compare(version, V4) === -1) {\n      this.v3 = true;\n    } else {\n      this.v4 = true;\n    }\n  }\n} // const ISO_COUNTRY_CODE = /^[A-Z]{2}$/\n// function isCountryCode(countryCode) {\n// \treturn ISO_COUNTRY_CODE.test(countryCodeOrCountryCallingCode)\n// }\n//# sourceMappingURL=metadata.js.map"],"names":["isPossiblePhoneNumber","input","options","metadata","undefined","v2","countryCallingCode","Error","selectNumberingPlan","phone","country","hasCountry","concat","possibleLengths","isPossibleNumber","nationalNumber","isNonGeographicCallingCode","isValidNumber","hasTypes","nationalNumberPattern","_typeof","obj","Symbol","iterator","constructor","prototype","_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_createClass","protoProps","staticProps","DEFAULT_EXT_PREFIX","CALLING_CODE_REG_EXP","Metadata","this","validateMetadata","setVersion","call","value","keys","countries","filter","_","countryCode","v1","v3","nonGeographic","nonGeographical","getCountryMetadata","callingCode","getCountryCodesForCallingCode","countryCodes","countryCallingCodes","test","numberingPlan","NumberingPlan","hasCallingCode","getNumberingPlanMetadata","getCountryCodeForCallingCode","IDDPrefix","defaultIDDPrefix","formats","nationalPrefixForParsing","nationalPrefixTransformRule","leadingDigits","_type","type","ext","country_phone_code_to_countries","country_calling_codes","globalMetadataObject","_this","_getFormats","getDefaultCountryMetadataForRegion","map","Format","_getNationalPrefixFormattingRule","_nationalPrefixForParsing","nationalPrefix","_getNationalPrefixIsOptionalWhenFormatting","types","_type2","getType","Type","format","_format","nationalPrefixFormattingRule","nationalPrefixIsOptionalWhenFormattingInNationalFormat","usesNationalPrefix","FIRST_GROUP_ONLY_PREFIX_PATTERN","join","typeOf","getCountryCallingCode","version","v4"],"sourceRoot":""}