UNPKG

64.5 kBSource Map (JSON)View Raw
1{"version":3,"names":[],"mappings":"","sources":["vue-axios.es5.js"],"sourcesContent":["'use strict';\n\nfunction _typeof(obj) {\n \"@babel/helpers - typeof\";\n\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n}\n\nfunction _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n}\n\nfunction _slicedToArray(arr, i) {\n return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();\n}\n\nfunction _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n}\n\nfunction _iterableToArrayLimit(arr, i) {\n if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n _arr.push(_s.value);\n\n if (i && _arr.length === i) break;\n }\n } catch (err) {\n _d = true;\n _e = err;\n } finally {\n try {\n if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n } finally {\n if (_d) throw _e;\n }\n }\n\n return _arr;\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n if (!o) return;\n if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n var n = Object.prototype.toString.call(o).slice(8, -1);\n if (n === \"Object\" && o.constructor) n = o.constructor.name;\n if (n === \"Map\" || n === \"Set\") return Array.from(o);\n if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n if (len == null || len > arr.length) len = arr.length;\n\n for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n return arr2;\n}\n\nfunction _nonIterableRest() {\n throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) {\n var it;\n\n if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) {\n if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n if (it) o = it;\n var i = 0;\n\n var F = function () {};\n\n return {\n s: F,\n n: function () {\n if (i >= o.length) return {\n done: true\n };\n return {\n done: false,\n value: o[i++]\n };\n },\n e: function (e) {\n throw e;\n },\n f: F\n };\n }\n\n throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n }\n\n var normalCompletion = true,\n didErr = false,\n err;\n return {\n s: function () {\n it = o[Symbol.iterator]();\n },\n n: function () {\n var step = it.next();\n normalCompletion = step.done;\n return step;\n },\n e: function (e) {\n didErr = true;\n err = e;\n },\n f: function () {\n try {\n if (!normalCompletion && it.return != null) it.return();\n } finally {\n if (didErr) throw err;\n }\n }\n };\n}\n\nfunction createCommonjsModule(fn, basedir, module) {\n\treturn module = {\n\t\tpath: basedir,\n\t\texports: {},\n\t\trequire: function (path, base) {\n\t\t\treturn commonjsRequire(path, (base === undefined || base === null) ? module.path : base);\n\t\t}\n\t}, fn(module, module.exports), module.exports;\n}\n\nfunction commonjsRequire () {\n\tthrow new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');\n}\n\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nvar SEMVER_SPEC_VERSION = '2.0.0';\nvar MAX_LENGTH = 256;\nvar MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n/* istanbul ignore next */\n9007199254740991; // Max safe segment length for coercion.\n\nvar MAX_SAFE_COMPONENT_LENGTH = 16;\nvar constants = {\n SEMVER_SPEC_VERSION: SEMVER_SPEC_VERSION,\n MAX_LENGTH: MAX_LENGTH,\n MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,\n MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH\n};\n\nvar debug = (typeof process === \"undefined\" ? \"undefined\" : _typeof(process)) === 'object' && process.env && process.env.NODE_DEBUG && /\\bsemver\\b/i.test(process.env.NODE_DEBUG) ? function () {\n var _console;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return (_console = console).error.apply(_console, ['SEMVER'].concat(args));\n} : function () {};\nvar debug_1 = debug;\n\nvar re_1 = createCommonjsModule(function (module, exports) {\n var MAX_SAFE_COMPONENT_LENGTH = constants.MAX_SAFE_COMPONENT_LENGTH;\n exports = module.exports = {}; // The actual regexps go on exports.re\n\n var re = exports.re = [];\n var src = exports.src = [];\n var t = exports.t = {};\n var R = 0;\n\n var createToken = function createToken(name, value, isGlobal) {\n var index = R++;\n debug_1(index, value);\n t[name] = index;\n src[index] = value;\n re[index] = new RegExp(value, isGlobal ? 'g' : undefined);\n }; // The following Regular Expressions can be used for tokenizing,\n // validating, and parsing SemVer version strings.\n // ## Numeric Identifier\n // A single `0`, or a non-zero digit followed by zero or more digits.\n\n\n createToken('NUMERICIDENTIFIER', '0|[1-9]\\\\d*');\n createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+'); // ## Non-numeric Identifier\n // Zero or more digits, followed by a letter or hyphen, and then zero or\n // more letters, digits, or hyphens.\n\n createToken('NONNUMERICIDENTIFIER', '\\\\d*[a-zA-Z-][a-zA-Z0-9-]*'); // ## Main Version\n // Three dot-separated numeric identifiers.\n\n createToken('MAINVERSION', \"(\".concat(src[t.NUMERICIDENTIFIER], \")\\\\.\") + \"(\".concat(src[t.NUMERICIDENTIFIER], \")\\\\.\") + \"(\".concat(src[t.NUMERICIDENTIFIER], \")\"));\n createToken('MAINVERSIONLOOSE', \"(\".concat(src[t.NUMERICIDENTIFIERLOOSE], \")\\\\.\") + \"(\".concat(src[t.NUMERICIDENTIFIERLOOSE], \")\\\\.\") + \"(\".concat(src[t.NUMERICIDENTIFIERLOOSE], \")\")); // ## Pre-release Version Identifier\n // A numeric identifier, or a non-numeric identifier.\n\n createToken('PRERELEASEIDENTIFIER', \"(?:\".concat(src[t.NUMERICIDENTIFIER], \"|\").concat(src[t.NONNUMERICIDENTIFIER], \")\"));\n createToken('PRERELEASEIDENTIFIERLOOSE', \"(?:\".concat(src[t.NUMERICIDENTIFIERLOOSE], \"|\").concat(src[t.NONNUMERICIDENTIFIER], \")\")); // ## Pre-release Version\n // Hyphen, followed by one or more dot-separated pre-release version\n // identifiers.\n\n createToken('PRERELEASE', \"(?:-(\".concat(src[t.PRERELEASEIDENTIFIER], \"(?:\\\\.\").concat(src[t.PRERELEASEIDENTIFIER], \")*))\"));\n createToken('PRERELEASELOOSE', \"(?:-?(\".concat(src[t.PRERELEASEIDENTIFIERLOOSE], \"(?:\\\\.\").concat(src[t.PRERELEASEIDENTIFIERLOOSE], \")*))\")); // ## Build Metadata Identifier\n // Any combination of digits, letters, or hyphens.\n\n createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+'); // ## Build Metadata\n // Plus sign, followed by one or more period-separated build metadata\n // identifiers.\n\n createToken('BUILD', \"(?:\\\\+(\".concat(src[t.BUILDIDENTIFIER], \"(?:\\\\.\").concat(src[t.BUILDIDENTIFIER], \")*))\")); // ## Full Version String\n // A main version, followed optionally by a pre-release version and\n // build metadata.\n // Note that the only major, minor, patch, and pre-release sections of\n // the version string are capturing groups. The build metadata is not a\n // capturing group, because it should not ever be used in version\n // comparison.\n\n createToken('FULLPLAIN', \"v?\".concat(src[t.MAINVERSION]).concat(src[t.PRERELEASE], \"?\").concat(src[t.BUILD], \"?\"));\n createToken('FULL', \"^\".concat(src[t.FULLPLAIN], \"$\")); // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n // common in the npm registry.\n\n createToken('LOOSEPLAIN', \"[v=\\\\s]*\".concat(src[t.MAINVERSIONLOOSE]).concat(src[t.PRERELEASELOOSE], \"?\").concat(src[t.BUILD], \"?\"));\n createToken('LOOSE', \"^\".concat(src[t.LOOSEPLAIN], \"$\"));\n createToken('GTLT', '((?:<|>)?=?)'); // Something like \"2.*\" or \"1.2.x\".\n // Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n // Only the first item is strictly required.\n\n createToken('XRANGEIDENTIFIERLOOSE', \"\".concat(src[t.NUMERICIDENTIFIERLOOSE], \"|x|X|\\\\*\"));\n createToken('XRANGEIDENTIFIER', \"\".concat(src[t.NUMERICIDENTIFIER], \"|x|X|\\\\*\"));\n createToken('XRANGEPLAIN', \"[v=\\\\s]*(\".concat(src[t.XRANGEIDENTIFIER], \")\") + \"(?:\\\\.(\".concat(src[t.XRANGEIDENTIFIER], \")\") + \"(?:\\\\.(\".concat(src[t.XRANGEIDENTIFIER], \")\") + \"(?:\".concat(src[t.PRERELEASE], \")?\").concat(src[t.BUILD], \"?\") + \")?)?\");\n createToken('XRANGEPLAINLOOSE', \"[v=\\\\s]*(\".concat(src[t.XRANGEIDENTIFIERLOOSE], \")\") + \"(?:\\\\.(\".concat(src[t.XRANGEIDENTIFIERLOOSE], \")\") + \"(?:\\\\.(\".concat(src[t.XRANGEIDENTIFIERLOOSE], \")\") + \"(?:\".concat(src[t.PRERELEASELOOSE], \")?\").concat(src[t.BUILD], \"?\") + \")?)?\");\n createToken('XRANGE', \"^\".concat(src[t.GTLT], \"\\\\s*\").concat(src[t.XRANGEPLAIN], \"$\"));\n createToken('XRANGELOOSE', \"^\".concat(src[t.GTLT], \"\\\\s*\").concat(src[t.XRANGEPLAINLOOSE], \"$\")); // Coercion.\n // Extract anything that could conceivably be a part of a valid semver\n\n createToken('COERCE', \"\".concat('(^|[^\\\\d])' + '(\\\\d{1,').concat(MAX_SAFE_COMPONENT_LENGTH, \"})\") + \"(?:\\\\.(\\\\d{1,\".concat(MAX_SAFE_COMPONENT_LENGTH, \"}))?\") + \"(?:\\\\.(\\\\d{1,\".concat(MAX_SAFE_COMPONENT_LENGTH, \"}))?\") + \"(?:$|[^\\\\d])\");\n createToken('COERCERTL', src[t.COERCE], true); // Tilde ranges.\n // Meaning is \"reasonably at or greater than\"\n\n createToken('LONETILDE', '(?:~>?)');\n createToken('TILDETRIM', \"(\\\\s*)\".concat(src[t.LONETILDE], \"\\\\s+\"), true);\n exports.tildeTrimReplace = '$1~';\n createToken('TILDE', \"^\".concat(src[t.LONETILDE]).concat(src[t.XRANGEPLAIN], \"$\"));\n createToken('TILDELOOSE', \"^\".concat(src[t.LONETILDE]).concat(src[t.XRANGEPLAINLOOSE], \"$\")); // Caret ranges.\n // Meaning is \"at least and backwards compatible with\"\n\n createToken('LONECARET', '(?:\\\\^)');\n createToken('CARETTRIM', \"(\\\\s*)\".concat(src[t.LONECARET], \"\\\\s+\"), true);\n exports.caretTrimReplace = '$1^';\n createToken('CARET', \"^\".concat(src[t.LONECARET]).concat(src[t.XRANGEPLAIN], \"$\"));\n createToken('CARETLOOSE', \"^\".concat(src[t.LONECARET]).concat(src[t.XRANGEPLAINLOOSE], \"$\")); // A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\n\n createToken('COMPARATORLOOSE', \"^\".concat(src[t.GTLT], \"\\\\s*(\").concat(src[t.LOOSEPLAIN], \")$|^$\"));\n createToken('COMPARATOR', \"^\".concat(src[t.GTLT], \"\\\\s*(\").concat(src[t.FULLPLAIN], \")$|^$\")); // An expression to strip any whitespace between the gtlt and the thing\n // it modifies, so that `> 1.2.3` ==> `>1.2.3`\n\n createToken('COMPARATORTRIM', \"(\\\\s*)\".concat(src[t.GTLT], \"\\\\s*(\").concat(src[t.LOOSEPLAIN], \"|\").concat(src[t.XRANGEPLAIN], \")\"), true);\n exports.comparatorTrimReplace = '$1$2$3'; // Something like `1.2.3 - 1.2.4`\n // Note that these all use the loose form, because they'll be\n // checked against either the strict or loose comparator form\n // later.\n\n createToken('HYPHENRANGE', \"^\\\\s*(\".concat(src[t.XRANGEPLAIN], \")\") + \"\\\\s+-\\\\s+\" + \"(\".concat(src[t.XRANGEPLAIN], \")\") + \"\\\\s*$\");\n createToken('HYPHENRANGELOOSE', \"^\\\\s*(\".concat(src[t.XRANGEPLAINLOOSE], \")\") + \"\\\\s+-\\\\s+\" + \"(\".concat(src[t.XRANGEPLAINLOOSE], \")\") + \"\\\\s*$\"); // Star ranges basically just allow anything at all.\n\n createToken('STAR', '(<|>)?=?\\\\s*\\\\*'); // >=0.0.0 is like a star\n\n createToken('GTE0', '^\\\\s*>=\\\\s*0\\.0\\.0\\\\s*$');\n createToken('GTE0PRE', '^\\\\s*>=\\\\s*0\\.0\\.0-0\\\\s*$');\n});\n\nvar numeric = /^[0-9]+$/;\n\nvar compareIdentifiers = function compareIdentifiers(a, b) {\n var anum = numeric.test(a);\n var bnum = numeric.test(b);\n\n if (anum && bnum) {\n a = +a;\n b = +b;\n }\n\n return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;\n};\n\nvar rcompareIdentifiers = function rcompareIdentifiers(a, b) {\n return compareIdentifiers(b, a);\n};\n\nvar identifiers = {\n compareIdentifiers: compareIdentifiers,\n rcompareIdentifiers: rcompareIdentifiers\n};\n\nvar MAX_LENGTH$1 = constants.MAX_LENGTH,\n MAX_SAFE_INTEGER$1 = constants.MAX_SAFE_INTEGER;\nvar re = re_1.re,\n t = re_1.t;\nvar compareIdentifiers$1 = identifiers.compareIdentifiers;\n\nvar SemVer = /*#__PURE__*/function () {\n function SemVer(version, options) {\n _classCallCheck(this, SemVer);\n\n if (!options || _typeof(options) !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n };\n }\n\n if (version instanceof SemVer) {\n if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {\n return version;\n } else {\n version = version.version;\n }\n } else if (typeof version !== 'string') {\n throw new TypeError(\"Invalid Version: \".concat(version));\n }\n\n if (version.length > MAX_LENGTH$1) {\n throw new TypeError(\"version is longer than \".concat(MAX_LENGTH$1, \" characters\"));\n }\n\n debug_1('SemVer', version, options);\n this.options = options;\n this.loose = !!options.loose; // this isn't actually relevant for versions, but keep it so that we\n // don't run into trouble passing this.options around.\n\n this.includePrerelease = !!options.includePrerelease;\n var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);\n\n if (!m) {\n throw new TypeError(\"Invalid Version: \".concat(version));\n }\n\n this.raw = version; // these are actually numbers\n\n this.major = +m[1];\n this.minor = +m[2];\n this.patch = +m[3];\n\n if (this.major > MAX_SAFE_INTEGER$1 || this.major < 0) {\n throw new TypeError('Invalid major version');\n }\n\n if (this.minor > MAX_SAFE_INTEGER$1 || this.minor < 0) {\n throw new TypeError('Invalid minor version');\n }\n\n if (this.patch > MAX_SAFE_INTEGER$1 || this.patch < 0) {\n throw new TypeError('Invalid patch version');\n } // numberify any prerelease numeric ids\n\n\n if (!m[4]) {\n this.prerelease = [];\n } else {\n this.prerelease = m[4].split('.').map(function (id) {\n if (/^[0-9]+$/.test(id)) {\n var num = +id;\n\n if (num >= 0 && num < MAX_SAFE_INTEGER$1) {\n return num;\n }\n }\n\n return id;\n });\n }\n\n this.build = m[5] ? m[5].split('.') : [];\n this.format();\n }\n\n _createClass(SemVer, [{\n key: \"format\",\n value: function format() {\n this.version = \"\".concat(this.major, \".\").concat(this.minor, \".\").concat(this.patch);\n\n if (this.prerelease.length) {\n this.version += \"-\".concat(this.prerelease.join('.'));\n }\n\n return this.version;\n }\n }, {\n key: \"toString\",\n value: function toString() {\n return this.version;\n }\n }, {\n key: \"compare\",\n value: function compare(other) {\n debug_1('SemVer.compare', this.version, this.options, other);\n\n if (!(other instanceof SemVer)) {\n if (typeof other === 'string' && other === this.version) {\n return 0;\n }\n\n other = new SemVer(other, this.options);\n }\n\n if (other.version === this.version) {\n return 0;\n }\n\n return this.compareMain(other) || this.comparePre(other);\n }\n }, {\n key: \"compareMain\",\n value: function compareMain(other) {\n if (!(other instanceof SemVer)) {\n other = new SemVer(other, this.options);\n }\n\n return compareIdentifiers$1(this.major, other.major) || compareIdentifiers$1(this.minor, other.minor) || compareIdentifiers$1(this.patch, other.patch);\n }\n }, {\n key: \"comparePre\",\n value: function comparePre(other) {\n if (!(other instanceof SemVer)) {\n other = new SemVer(other, this.options);\n } // NOT having a prerelease is > having one\n\n\n if (this.prerelease.length && !other.prerelease.length) {\n return -1;\n } else if (!this.prerelease.length && other.prerelease.length) {\n return 1;\n } else if (!this.prerelease.length && !other.prerelease.length) {\n return 0;\n }\n\n var i = 0;\n\n do {\n var a = this.prerelease[i];\n var b = other.prerelease[i];\n debug_1('prerelease compare', i, a, b);\n\n if (a === undefined && b === undefined) {\n return 0;\n } else if (b === undefined) {\n return 1;\n } else if (a === undefined) {\n return -1;\n } else if (a === b) {\n continue;\n } else {\n return compareIdentifiers$1(a, b);\n }\n } while (++i);\n }\n }, {\n key: \"compareBuild\",\n value: function compareBuild(other) {\n if (!(other instanceof SemVer)) {\n other = new SemVer(other, this.options);\n }\n\n var i = 0;\n\n do {\n var a = this.build[i];\n var b = other.build[i];\n debug_1('prerelease compare', i, a, b);\n\n if (a === undefined && b === undefined) {\n return 0;\n } else if (b === undefined) {\n return 1;\n } else if (a === undefined) {\n return -1;\n } else if (a === b) {\n continue;\n } else {\n return compareIdentifiers$1(a, b);\n }\n } while (++i);\n } // preminor will bump the version up to the next minor release, and immediately\n // down to pre-release. premajor and prepatch work the same way.\n\n }, {\n key: \"inc\",\n value: function inc(release, identifier) {\n switch (release) {\n case 'premajor':\n this.prerelease.length = 0;\n this.patch = 0;\n this.minor = 0;\n this.major++;\n this.inc('pre', identifier);\n break;\n\n case 'preminor':\n this.prerelease.length = 0;\n this.patch = 0;\n this.minor++;\n this.inc('pre', identifier);\n break;\n\n case 'prepatch':\n // If this is already a prerelease, it will bump to the next version\n // drop any prereleases that might already exist, since they are not\n // relevant at this point.\n this.prerelease.length = 0;\n this.inc('patch', identifier);\n this.inc('pre', identifier);\n break;\n // If the input is a non-prerelease version, this acts the same as\n // prepatch.\n\n case 'prerelease':\n if (this.prerelease.length === 0) {\n this.inc('patch', identifier);\n }\n\n this.inc('pre', identifier);\n break;\n\n case 'major':\n // If this is a pre-major version, bump up to the same major version.\n // Otherwise increment major.\n // 1.0.0-5 bumps to 1.0.0\n // 1.1.0 bumps to 2.0.0\n if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {\n this.major++;\n }\n\n this.minor = 0;\n this.patch = 0;\n this.prerelease = [];\n break;\n\n case 'minor':\n // If this is a pre-minor version, bump up to the same minor version.\n // Otherwise increment minor.\n // 1.2.0-5 bumps to 1.2.0\n // 1.2.1 bumps to 1.3.0\n if (this.patch !== 0 || this.prerelease.length === 0) {\n this.minor++;\n }\n\n this.patch = 0;\n this.prerelease = [];\n break;\n\n case 'patch':\n // If this is not a pre-release version, it will increment the patch.\n // If it is a pre-release it will bump up to the same patch version.\n // 1.2.0-5 patches to 1.2.0\n // 1.2.0 patches to 1.2.1\n if (this.prerelease.length === 0) {\n this.patch++;\n }\n\n this.prerelease = [];\n break;\n // This probably shouldn't be used publicly.\n // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.\n\n case 'pre':\n if (this.prerelease.length === 0) {\n this.prerelease = [0];\n } else {\n var i = this.prerelease.length;\n\n while (--i >= 0) {\n if (typeof this.prerelease[i] === 'number') {\n this.prerelease[i]++;\n i = -2;\n }\n }\n\n if (i === -1) {\n // didn't increment anything\n this.prerelease.push(0);\n }\n }\n\n if (identifier) {\n // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n if (this.prerelease[0] === identifier) {\n if (isNaN(this.prerelease[1])) {\n this.prerelease = [identifier, 0];\n }\n } else {\n this.prerelease = [identifier, 0];\n }\n }\n\n break;\n\n default:\n throw new Error(\"invalid increment argument: \".concat(release));\n }\n\n this.format();\n this.raw = this.version;\n return this;\n }\n }]);\n\n return SemVer;\n}();\n\nvar semver = SemVer;\n\nvar MAX_LENGTH$2 = constants.MAX_LENGTH;\nvar re$1 = re_1.re,\n t$1 = re_1.t;\n\nvar parse = function parse(version, options) {\n if (!options || _typeof(options) !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n };\n }\n\n if (version instanceof semver) {\n return version;\n }\n\n if (typeof version !== 'string') {\n return null;\n }\n\n if (version.length > MAX_LENGTH$2) {\n return null;\n }\n\n var r = options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL];\n\n if (!r.test(version)) {\n return null;\n }\n\n try {\n return new semver(version, options);\n } catch (er) {\n return null;\n }\n};\n\nvar parse_1 = parse;\n\nvar valid = function valid(version, options) {\n var v = parse_1(version, options);\n return v ? v.version : null;\n};\n\nvar valid_1 = valid;\n\nvar clean = function clean(version, options) {\n var s = parse_1(version.trim().replace(/^[=v]+/, ''), options);\n return s ? s.version : null;\n};\n\nvar clean_1 = clean;\n\nvar inc = function inc(version, release, options, identifier) {\n if (typeof options === 'string') {\n identifier = options;\n options = undefined;\n }\n\n try {\n return new semver(version, options).inc(release, identifier).version;\n } catch (er) {\n return null;\n }\n};\n\nvar inc_1 = inc;\n\nvar compare = function compare(a, b, loose) {\n return new semver(a, loose).compare(new semver(b, loose));\n};\n\nvar compare_1 = compare;\n\nvar eq = function eq(a, b, loose) {\n return compare_1(a, b, loose) === 0;\n};\n\nvar eq_1 = eq;\n\nvar diff = function diff(version1, version2) {\n if (eq_1(version1, version2)) {\n return null;\n } else {\n var v1 = parse_1(version1);\n var v2 = parse_1(version2);\n var hasPre = v1.prerelease.length || v2.prerelease.length;\n var prefix = hasPre ? 'pre' : '';\n var defaultResult = hasPre ? 'prerelease' : '';\n\n for (var key in v1) {\n if (key === 'major' || key === 'minor' || key === 'patch') {\n if (v1[key] !== v2[key]) {\n return prefix + key;\n }\n }\n }\n\n return defaultResult; // may be undefined\n }\n};\n\nvar diff_1 = diff;\n\nvar major = function major(a, loose) {\n return new semver(a, loose).major;\n};\n\nvar major_1 = major;\n\nvar minor = function minor(a, loose) {\n return new semver(a, loose).minor;\n};\n\nvar minor_1 = minor;\n\nvar patch = function patch(a, loose) {\n return new semver(a, loose).patch;\n};\n\nvar patch_1 = patch;\n\nvar prerelease = function prerelease(version, options) {\n var parsed = parse_1(version, options);\n return parsed && parsed.prerelease.length ? parsed.prerelease : null;\n};\n\nvar prerelease_1 = prerelease;\n\nvar rcompare = function rcompare(a, b, loose) {\n return compare_1(b, a, loose);\n};\n\nvar rcompare_1 = rcompare;\n\nvar compareLoose = function compareLoose(a, b) {\n return compare_1(a, b, true);\n};\n\nvar compareLoose_1 = compareLoose;\n\nvar compareBuild = function compareBuild(a, b, loose) {\n var versionA = new semver(a, loose);\n var versionB = new semver(b, loose);\n return versionA.compare(versionB) || versionA.compareBuild(versionB);\n};\n\nvar compareBuild_1 = compareBuild;\n\nvar sort = function sort(list, loose) {\n return list.sort(function (a, b) {\n return compareBuild_1(a, b, loose);\n });\n};\n\nvar sort_1 = sort;\n\nvar rsort = function rsort(list, loose) {\n return list.sort(function (a, b) {\n return compareBuild_1(b, a, loose);\n });\n};\n\nvar rsort_1 = rsort;\n\nvar gt = function gt(a, b, loose) {\n return compare_1(a, b, loose) > 0;\n};\n\nvar gt_1 = gt;\n\nvar lt = function lt(a, b, loose) {\n return compare_1(a, b, loose) < 0;\n};\n\nvar lt_1 = lt;\n\nvar neq = function neq(a, b, loose) {\n return compare_1(a, b, loose) !== 0;\n};\n\nvar neq_1 = neq;\n\nvar gte = function gte(a, b, loose) {\n return compare_1(a, b, loose) >= 0;\n};\n\nvar gte_1 = gte;\n\nvar lte = function lte(a, b, loose) {\n return compare_1(a, b, loose) <= 0;\n};\n\nvar lte_1 = lte;\n\nvar cmp = function cmp(a, op, b, loose) {\n switch (op) {\n case '===':\n if (_typeof(a) === 'object') a = a.version;\n if (_typeof(b) === 'object') b = b.version;\n return a === b;\n\n case '!==':\n if (_typeof(a) === 'object') a = a.version;\n if (_typeof(b) === 'object') b = b.version;\n return a !== b;\n\n case '':\n case '=':\n case '==':\n return eq_1(a, b, loose);\n\n case '!=':\n return neq_1(a, b, loose);\n\n case '>':\n return gt_1(a, b, loose);\n\n case '>=':\n return gte_1(a, b, loose);\n\n case '<':\n return lt_1(a, b, loose);\n\n case '<=':\n return lte_1(a, b, loose);\n\n default:\n throw new TypeError(\"Invalid operator: \".concat(op));\n }\n};\n\nvar cmp_1 = cmp;\n\nvar re$2 = re_1.re,\n t$2 = re_1.t;\n\nvar coerce = function coerce(version, options) {\n if (version instanceof semver) {\n return version;\n }\n\n if (typeof version === 'number') {\n version = String(version);\n }\n\n if (typeof version !== 'string') {\n return null;\n }\n\n options = options || {};\n var match = null;\n\n if (!options.rtl) {\n match = version.match(re$2[t$2.COERCE]);\n } else {\n // Find the right-most coercible string that does not share\n // a terminus with a more left-ward coercible string.\n // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n //\n // Walk through the string checking with a /g regexp\n // Manually set the index so as to pick up overlapping matches.\n // Stop when we get a match that ends at the string end, since no\n // coercible string can be more right-ward without the same terminus.\n var next;\n\n while ((next = re$2[t$2.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {\n if (!match || next.index + next[0].length !== match.index + match[0].length) {\n match = next;\n }\n\n re$2[t$2.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;\n } // leave it in a clean state\n\n\n re$2[t$2.COERCERTL].lastIndex = -1;\n }\n\n if (match === null) return null;\n return parse_1(\"\".concat(match[2], \".\").concat(match[3] || '0', \".\").concat(match[4] || '0'), options);\n};\n\nvar coerce_1 = coerce;\n\nvar Range = /*#__PURE__*/function () {\n function Range(range, options) {\n var _this = this;\n\n _classCallCheck(this, Range);\n\n if (!options || _typeof(options) !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n };\n }\n\n if (range instanceof Range) {\n if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {\n return range;\n } else {\n return new Range(range.raw, options);\n }\n }\n\n if (range instanceof comparator) {\n // just put it in the set and return\n this.raw = range.value;\n this.set = [[range]];\n this.format();\n return this;\n }\n\n this.options = options;\n this.loose = !!options.loose;\n this.includePrerelease = !!options.includePrerelease; // First, split based on boolean or ||\n\n this.raw = range;\n this.set = range.split(/\\s*\\|\\|\\s*/) // map the range to a 2d array of comparators\n .map(function (range) {\n return _this.parseRange(range.trim());\n }) // throw out any comparator lists that are empty\n // this generally means that it was not a valid range, which is allowed\n // in loose mode, but will still throw if the WHOLE range is invalid.\n .filter(function (c) {\n return c.length;\n });\n\n if (!this.set.length) {\n throw new TypeError(\"Invalid SemVer Range: \".concat(range));\n }\n\n this.format();\n }\n\n _createClass(Range, [{\n key: \"format\",\n value: function format() {\n this.range = this.set.map(function (comps) {\n return comps.join(' ').trim();\n }).join('||').trim();\n return this.range;\n }\n }, {\n key: \"toString\",\n value: function toString() {\n return this.range;\n }\n }, {\n key: \"parseRange\",\n value: function parseRange(range) {\n var _this2 = this;\n\n var loose = this.options.loose;\n range = range.trim(); // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n\n var hr = loose ? re$3[t$3.HYPHENRANGELOOSE] : re$3[t$3.HYPHENRANGE];\n range = range.replace(hr, hyphenReplace(this.options.includePrerelease));\n debug_1('hyphen replace', range); // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n\n range = range.replace(re$3[t$3.COMPARATORTRIM], comparatorTrimReplace);\n debug_1('comparator trim', range, re$3[t$3.COMPARATORTRIM]); // `~ 1.2.3` => `~1.2.3`\n\n range = range.replace(re$3[t$3.TILDETRIM], tildeTrimReplace); // `^ 1.2.3` => `^1.2.3`\n\n range = range.replace(re$3[t$3.CARETTRIM], caretTrimReplace); // normalize spaces\n\n range = range.split(/\\s+/).join(' '); // At this point, the range is completely trimmed and\n // ready to be split into comparators.\n\n var compRe = loose ? re$3[t$3.COMPARATORLOOSE] : re$3[t$3.COMPARATOR];\n return range.split(' ').map(function (comp) {\n return parseComparator(comp, _this2.options);\n }).join(' ').split(/\\s+/).map(function (comp) {\n return replaceGTE0(comp, _this2.options);\n }) // in loose mode, throw out any that are not valid comparators\n .filter(this.options.loose ? function (comp) {\n return !!comp.match(compRe);\n } : function () {\n return true;\n }).map(function (comp) {\n return new comparator(comp, _this2.options);\n });\n }\n }, {\n key: \"intersects\",\n value: function intersects(range, options) {\n if (!(range instanceof Range)) {\n throw new TypeError('a Range is required');\n }\n\n return this.set.some(function (thisComparators) {\n return isSatisfiable(thisComparators, options) && range.set.some(function (rangeComparators) {\n return isSatisfiable(rangeComparators, options) && thisComparators.every(function (thisComparator) {\n return rangeComparators.every(function (rangeComparator) {\n return thisComparator.intersects(rangeComparator, options);\n });\n });\n });\n });\n } // if ANY of the sets match ALL of its comparators, then pass\n\n }, {\n key: \"test\",\n value: function test(version) {\n if (!version) {\n return false;\n }\n\n if (typeof version === 'string') {\n try {\n version = new semver(version, this.options);\n } catch (er) {\n return false;\n }\n }\n\n for (var i = 0; i < this.set.length; i++) {\n if (testSet(this.set[i], version, this.options)) {\n return true;\n }\n }\n\n return false;\n }\n }]);\n\n return Range;\n}();\n\nvar range = Range;\nvar re$3 = re_1.re,\n t$3 = re_1.t,\n comparatorTrimReplace = re_1.comparatorTrimReplace,\n tildeTrimReplace = re_1.tildeTrimReplace,\n caretTrimReplace = re_1.caretTrimReplace; // take a set of comparators and determine whether there\n// exists a version which can satisfy it\n\nvar isSatisfiable = function isSatisfiable(comparators, options) {\n var result = true;\n var remainingComparators = comparators.slice();\n var testComparator = remainingComparators.pop();\n\n while (result && remainingComparators.length) {\n result = remainingComparators.every(function (otherComparator) {\n return testComparator.intersects(otherComparator, options);\n });\n testComparator = remainingComparators.pop();\n }\n\n return result;\n}; // comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\n\n\nvar parseComparator = function parseComparator(comp, options) {\n debug_1('comp', comp, options);\n comp = replaceCarets(comp, options);\n debug_1('caret', comp);\n comp = replaceTildes(comp, options);\n debug_1('tildes', comp);\n comp = replaceXRanges(comp, options);\n debug_1('xrange', comp);\n comp = replaceStars(comp, options);\n debug_1('stars', comp);\n return comp;\n};\n\nvar isX = function isX(id) {\n return !id || id.toLowerCase() === 'x' || id === '*';\n}; // ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\n\n\nvar replaceTildes = function replaceTildes(comp, options) {\n return comp.trim().split(/\\s+/).map(function (comp) {\n return replaceTilde(comp, options);\n }).join(' ');\n};\n\nvar replaceTilde = function replaceTilde(comp, options) {\n var r = options.loose ? re$3[t$3.TILDELOOSE] : re$3[t$3.TILDE];\n return comp.replace(r, function (_, M, m, p, pr) {\n debug_1('tilde', comp, _, M, m, p, pr);\n var ret;\n\n if (isX(M)) {\n ret = '';\n } else if (isX(m)) {\n ret = \">=\".concat(M, \".0.0 <\").concat(+M + 1, \".0.0-0\");\n } else if (isX(p)) {\n // ~1.2 == >=1.2.0 <1.3.0-0\n ret = \">=\".concat(M, \".\").concat(m, \".0 <\").concat(M, \".\").concat(+m + 1, \".0-0\");\n } else if (pr) {\n debug_1('replaceTilde pr', pr);\n ret = \">=\".concat(M, \".\").concat(m, \".\").concat(p, \"-\").concat(pr, \" <\").concat(M, \".\").concat(+m + 1, \".0-0\");\n } else {\n // ~1.2.3 == >=1.2.3 <1.3.0-0\n ret = \">=\".concat(M, \".\").concat(m, \".\").concat(p, \" <\").concat(M, \".\").concat(+m + 1, \".0-0\");\n }\n\n debug_1('tilde return', ret);\n return ret;\n });\n}; // ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\n\n\nvar replaceCarets = function replaceCarets(comp, options) {\n return comp.trim().split(/\\s+/).map(function (comp) {\n return replaceCaret(comp, options);\n }).join(' ');\n};\n\nvar replaceCaret = function replaceCaret(comp, options) {\n debug_1('caret', comp, options);\n var r = options.loose ? re$3[t$3.CARETLOOSE] : re$3[t$3.CARET];\n var z = options.includePrerelease ? '-0' : '';\n return comp.replace(r, function (_, M, m, p, pr) {\n debug_1('caret', comp, _, M, m, p, pr);\n var ret;\n\n if (isX(M)) {\n ret = '';\n } else if (isX(m)) {\n ret = \">=\".concat(M, \".0.0\").concat(z, \" <\").concat(+M + 1, \".0.0-0\");\n } else if (isX(p)) {\n if (M === '0') {\n ret = \">=\".concat(M, \".\").concat(m, \".0\").concat(z, \" <\").concat(M, \".\").concat(+m + 1, \".0-0\");\n } else {\n ret = \">=\".concat(M, \".\").concat(m, \".0\").concat(z, \" <\").concat(+M + 1, \".0.0-0\");\n }\n } else if (pr) {\n debug_1('replaceCaret pr', pr);\n\n if (M === '0') {\n if (m === '0') {\n ret = \">=\".concat(M, \".\").concat(m, \".\").concat(p, \"-\").concat(pr, \" <\").concat(M, \".\").concat(m, \".\").concat(+p + 1, \"-0\");\n } else {\n ret = \">=\".concat(M, \".\").concat(m, \".\").concat(p, \"-\").concat(pr, \" <\").concat(M, \".\").concat(+m + 1, \".0-0\");\n }\n } else {\n ret = \">=\".concat(M, \".\").concat(m, \".\").concat(p, \"-\").concat(pr, \" <\").concat(+M + 1, \".0.0-0\");\n }\n } else {\n debug_1('no pr');\n\n if (M === '0') {\n if (m === '0') {\n ret = \">=\".concat(M, \".\").concat(m, \".\").concat(p).concat(z, \" <\").concat(M, \".\").concat(m, \".\").concat(+p + 1, \"-0\");\n } else {\n ret = \">=\".concat(M, \".\").concat(m, \".\").concat(p).concat(z, \" <\").concat(M, \".\").concat(+m + 1, \".0-0\");\n }\n } else {\n ret = \">=\".concat(M, \".\").concat(m, \".\").concat(p, \" <\").concat(+M + 1, \".0.0-0\");\n }\n }\n\n debug_1('caret return', ret);\n return ret;\n });\n};\n\nvar replaceXRanges = function replaceXRanges(comp, options) {\n debug_1('replaceXRanges', comp, options);\n return comp.split(/\\s+/).map(function (comp) {\n return replaceXRange(comp, options);\n }).join(' ');\n};\n\nvar replaceXRange = function replaceXRange(comp, options) {\n comp = comp.trim();\n var r = options.loose ? re$3[t$3.XRANGELOOSE] : re$3[t$3.XRANGE];\n return comp.replace(r, function (ret, gtlt, M, m, p, pr) {\n debug_1('xRange', comp, ret, gtlt, M, m, p, pr);\n var xM = isX(M);\n var xm = xM || isX(m);\n var xp = xm || isX(p);\n var anyX = xp;\n\n if (gtlt === '=' && anyX) {\n gtlt = '';\n } // if we're including prereleases in the match, then we need\n // to fix this to -0, the lowest possible prerelease value\n\n\n pr = options.includePrerelease ? '-0' : '';\n\n if (xM) {\n if (gtlt === '>' || gtlt === '<') {\n // nothing is allowed\n ret = '<0.0.0-0';\n } else {\n // nothing is forbidden\n ret = '*';\n }\n } else if (gtlt && anyX) {\n // we know patch is an x, because we have any x at all.\n // replace X with 0\n if (xm) {\n m = 0;\n }\n\n p = 0;\n\n if (gtlt === '>') {\n // >1 => >=2.0.0\n // >1.2 => >=1.3.0\n gtlt = '>=';\n\n if (xm) {\n M = +M + 1;\n m = 0;\n p = 0;\n } else {\n m = +m + 1;\n p = 0;\n }\n } else if (gtlt === '<=') {\n // <=0.7.x is actually <0.8.0, since any 0.7.x should\n // pass. Similarly, <=7.x is actually <8.0.0, etc.\n gtlt = '<';\n\n if (xm) {\n M = +M + 1;\n } else {\n m = +m + 1;\n }\n }\n\n if (gtlt === '<') pr = '-0';\n ret = \"\".concat(gtlt + M, \".\").concat(m, \".\").concat(p).concat(pr);\n } else if (xm) {\n ret = \">=\".concat(M, \".0.0\").concat(pr, \" <\").concat(+M + 1, \".0.0-0\");\n } else if (xp) {\n ret = \">=\".concat(M, \".\").concat(m, \".0\").concat(pr, \" <\").concat(M, \".\").concat(+m + 1, \".0-0\");\n }\n\n debug_1('xRange return', ret);\n return ret;\n });\n}; // Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\n\n\nvar replaceStars = function replaceStars(comp, options) {\n debug_1('replaceStars', comp, options); // Looseness is ignored here. star is always as loose as it gets!\n\n return comp.trim().replace(re$3[t$3.STAR], '');\n};\n\nvar replaceGTE0 = function replaceGTE0(comp, options) {\n debug_1('replaceGTE0', comp, options);\n return comp.trim().replace(re$3[options.includePrerelease ? t$3.GTE0PRE : t$3.GTE0], '');\n}; // This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\n\n\nvar hyphenReplace = function hyphenReplace(incPr) {\n return function ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {\n if (isX(fM)) {\n from = '';\n } else if (isX(fm)) {\n from = \">=\".concat(fM, \".0.0\").concat(incPr ? '-0' : '');\n } else if (isX(fp)) {\n from = \">=\".concat(fM, \".\").concat(fm, \".0\").concat(incPr ? '-0' : '');\n } else if (fpr) {\n from = \">=\".concat(from);\n } else {\n from = \">=\".concat(from).concat(incPr ? '-0' : '');\n }\n\n if (isX(tM)) {\n to = '';\n } else if (isX(tm)) {\n to = \"<\".concat(+tM + 1, \".0.0-0\");\n } else if (isX(tp)) {\n to = \"<\".concat(tM, \".\").concat(+tm + 1, \".0-0\");\n } else if (tpr) {\n to = \"<=\".concat(tM, \".\").concat(tm, \".\").concat(tp, \"-\").concat(tpr);\n } else if (incPr) {\n to = \"<\".concat(tM, \".\").concat(tm, \".\").concat(+tp + 1, \"-0\");\n } else {\n to = \"<=\".concat(to);\n }\n\n return \"\".concat(from, \" \").concat(to).trim();\n };\n};\n\nvar testSet = function testSet(set, version, options) {\n for (var i = 0; i < set.length; i++) {\n if (!set[i].test(version)) {\n return false;\n }\n }\n\n if (version.prerelease.length && !options.includePrerelease) {\n // Find the set of versions that are allowed to have prereleases\n // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n // That should allow `1.2.3-pr.2` to pass.\n // However, `1.2.4-alpha.notready` should NOT be allowed,\n // even though it's within the range set by the comparators.\n for (var _i = 0; _i < set.length; _i++) {\n debug_1(set[_i].semver);\n\n if (set[_i].semver === comparator.ANY) {\n continue;\n }\n\n if (set[_i].semver.prerelease.length > 0) {\n var allowed = set[_i].semver;\n\n if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {\n return true;\n }\n }\n } // Version has a -pre, but it's not one of the ones we like.\n\n\n return false;\n }\n\n return true;\n};\n\nvar ANY = Symbol('SemVer ANY'); // hoisted class for cyclic dependency\n\nvar Comparator = /*#__PURE__*/function () {\n _createClass(Comparator, null, [{\n key: \"ANY\",\n get: function get() {\n return ANY;\n }\n }]);\n\n function Comparator(comp, options) {\n _classCallCheck(this, Comparator);\n\n if (!options || _typeof(options) !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n };\n }\n\n if (comp instanceof Comparator) {\n if (comp.loose === !!options.loose) {\n return comp;\n } else {\n comp = comp.value;\n }\n }\n\n debug_1('comparator', comp, options);\n this.options = options;\n this.loose = !!options.loose;\n this.parse(comp);\n\n if (this.semver === ANY) {\n this.value = '';\n } else {\n this.value = this.operator + this.semver.version;\n }\n\n debug_1('comp', this);\n }\n\n _createClass(Comparator, [{\n key: \"parse\",\n value: function parse(comp) {\n var r = this.options.loose ? re$4[t$4.COMPARATORLOOSE] : re$4[t$4.COMPARATOR];\n var m = comp.match(r);\n\n if (!m) {\n throw new TypeError(\"Invalid comparator: \".concat(comp));\n }\n\n this.operator = m[1] !== undefined ? m[1] : '';\n\n if (this.operator === '=') {\n this.operator = '';\n } // if it literally is just '>' or '' then allow anything.\n\n\n if (!m[2]) {\n this.semver = ANY;\n } else {\n this.semver = new semver(m[2], this.options.loose);\n }\n }\n }, {\n key: \"toString\",\n value: function toString() {\n return this.value;\n }\n }, {\n key: \"test\",\n value: function test(version) {\n debug_1('Comparator.test', version, this.options.loose);\n\n if (this.semver === ANY || version === ANY) {\n return true;\n }\n\n if (typeof version === 'string') {\n try {\n version = new semver(version, this.options);\n } catch (er) {\n return false;\n }\n }\n\n return cmp_1(version, this.operator, this.semver, this.options);\n }\n }, {\n key: \"intersects\",\n value: function intersects(comp, options) {\n if (!(comp instanceof Comparator)) {\n throw new TypeError('a Comparator is required');\n }\n\n if (!options || _typeof(options) !== 'object') {\n options = {\n loose: !!options,\n includePrerelease: false\n };\n }\n\n if (this.operator === '') {\n if (this.value === '') {\n return true;\n }\n\n return new range(comp.value, options).test(this.value);\n } else if (comp.operator === '') {\n if (comp.value === '') {\n return true;\n }\n\n return new range(this.value, options).test(comp.semver);\n }\n\n var sameDirectionIncreasing = (this.operator === '>=' || this.operator === '>') && (comp.operator === '>=' || comp.operator === '>');\n var sameDirectionDecreasing = (this.operator === '<=' || this.operator === '<') && (comp.operator === '<=' || comp.operator === '<');\n var sameSemVer = this.semver.version === comp.semver.version;\n var differentDirectionsInclusive = (this.operator === '>=' || this.operator === '<=') && (comp.operator === '>=' || comp.operator === '<=');\n var oppositeDirectionsLessThan = cmp_1(this.semver, '<', comp.semver, options) && (this.operator === '>=' || this.operator === '>') && (comp.operator === '<=' || comp.operator === '<');\n var oppositeDirectionsGreaterThan = cmp_1(this.semver, '>', comp.semver, options) && (this.operator === '<=' || this.operator === '<') && (comp.operator === '>=' || comp.operator === '>');\n return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;\n }\n }]);\n\n return Comparator;\n}();\n\nvar comparator = Comparator;\nvar re$4 = re_1.re,\n t$4 = re_1.t;\n\nvar satisfies = function satisfies(version, range$1, options) {\n try {\n range$1 = new range(range$1, options);\n } catch (er) {\n return false;\n }\n\n return range$1.test(version);\n};\n\nvar satisfies_1 = satisfies;\n\nvar toComparators = function toComparators(range$1, options) {\n return new range(range$1, options).set.map(function (comp) {\n return comp.map(function (c) {\n return c.value;\n }).join(' ').trim().split(' ');\n });\n};\n\nvar toComparators_1 = toComparators;\n\nvar maxSatisfying = function maxSatisfying(versions, range$1, options) {\n var max = null;\n var maxSV = null;\n var rangeObj = null;\n\n try {\n rangeObj = new range(range$1, options);\n } catch (er) {\n return null;\n }\n\n versions.forEach(function (v) {\n if (rangeObj.test(v)) {\n // satisfies(v, range, options)\n if (!max || maxSV.compare(v) === -1) {\n // compare(max, v, true)\n max = v;\n maxSV = new semver(max, options);\n }\n }\n });\n return max;\n};\n\nvar maxSatisfying_1 = maxSatisfying;\n\nvar minSatisfying = function minSatisfying(versions, range$1, options) {\n var min = null;\n var minSV = null;\n var rangeObj = null;\n\n try {\n rangeObj = new range(range$1, options);\n } catch (er) {\n return null;\n }\n\n versions.forEach(function (v) {\n if (rangeObj.test(v)) {\n // satisfies(v, range, options)\n if (!min || minSV.compare(v) === 1) {\n // compare(min, v, true)\n min = v;\n minSV = new semver(min, options);\n }\n }\n });\n return min;\n};\n\nvar minSatisfying_1 = minSatisfying;\n\nvar minVersion = function minVersion(range$1, loose) {\n range$1 = new range(range$1, loose);\n var minver = new semver('0.0.0');\n\n if (range$1.test(minver)) {\n return minver;\n }\n\n minver = new semver('0.0.0-0');\n\n if (range$1.test(minver)) {\n return minver;\n }\n\n minver = null;\n\n for (var i = 0; i < range$1.set.length; ++i) {\n var comparators = range$1.set[i];\n comparators.forEach(function (comparator) {\n // Clone to avoid manipulating the comparator's semver object.\n var compver = new semver(comparator.semver.version);\n\n switch (comparator.operator) {\n case '>':\n if (compver.prerelease.length === 0) {\n compver.patch++;\n } else {\n compver.prerelease.push(0);\n }\n\n compver.raw = compver.format();\n\n /* fallthrough */\n\n case '':\n case '>=':\n if (!minver || gt_1(minver, compver)) {\n minver = compver;\n }\n\n break;\n\n case '<':\n case '<=':\n /* Ignore maximum versions */\n break;\n\n /* istanbul ignore next */\n\n default:\n throw new Error(\"Unexpected operation: \".concat(comparator.operator));\n }\n });\n }\n\n if (minver && range$1.test(minver)) {\n return minver;\n }\n\n return null;\n};\n\nvar minVersion_1 = minVersion;\n\nvar validRange = function validRange(range$1, options) {\n try {\n // Return '*' instead of '' so that truthiness works.\n // This will throw if it's invalid anyway\n return new range(range$1, options).range || '*';\n } catch (er) {\n return null;\n }\n};\n\nvar valid$1 = validRange;\n\nvar ANY$1 = comparator.ANY;\n\nvar outside = function outside(version, range$1, hilo, options) {\n version = new semver(version, options);\n range$1 = new range(range$1, options);\n var gtfn, ltefn, ltfn, comp, ecomp;\n\n switch (hilo) {\n case '>':\n gtfn = gt_1;\n ltefn = lte_1;\n ltfn = lt_1;\n comp = '>';\n ecomp = '>=';\n break;\n\n case '<':\n gtfn = lt_1;\n ltefn = gte_1;\n ltfn = gt_1;\n comp = '<';\n ecomp = '<=';\n break;\n\n default:\n throw new TypeError('Must provide a hilo val of \"<\" or \">\"');\n } // If it satisifes the range it is not outside\n\n\n if (satisfies_1(version, range$1, options)) {\n return false;\n } // From now on, variable terms are as if we're in \"gtr\" mode.\n // but note that everything is flipped for the \"ltr\" function.\n\n\n var _loop = function _loop(i) {\n var comparators = range$1.set[i];\n var high = null;\n var low = null;\n comparators.forEach(function (comparator$1) {\n if (comparator$1.semver === ANY$1) {\n comparator$1 = new comparator('>=0.0.0');\n }\n\n high = high || comparator$1;\n low = low || comparator$1;\n\n if (gtfn(comparator$1.semver, high.semver, options)) {\n high = comparator$1;\n } else if (ltfn(comparator$1.semver, low.semver, options)) {\n low = comparator$1;\n }\n }); // If the edge version comparator has a operator then our version\n // isn't outside it\n\n if (high.operator === comp || high.operator === ecomp) {\n return {\n v: false\n };\n } // If the lowest version comparator has an operator and our version\n // is less than it then it isn't higher than the range\n\n\n if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {\n return {\n v: false\n };\n } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n return {\n v: false\n };\n }\n };\n\n for (var i = 0; i < range$1.set.length; ++i) {\n var _ret = _loop(i);\n\n if (_typeof(_ret) === \"object\") return _ret.v;\n }\n\n return true;\n};\n\nvar outside_1 = outside;\n\nvar gtr = function gtr(version, range, options) {\n return outside_1(version, range, '>', options);\n};\n\nvar gtr_1 = gtr;\n\nvar ltr = function ltr(version, range, options) {\n return outside_1(version, range, '<', options);\n};\n\nvar ltr_1 = ltr;\n\nvar intersects = function intersects(r1, r2, options) {\n r1 = new range(r1, options);\n r2 = new range(r2, options);\n return r1.intersects(r2);\n};\n\nvar intersects_1 = intersects;\n\n// that includes the same versions that the original range does\n// If the original range is shorter than the simplified one, return that.\n\nvar simplify = function simplify(versions, range, options) {\n var set = [];\n var min = null;\n var prev = null;\n var v = versions.sort(function (a, b) {\n return compare_1(a, b, options);\n });\n\n var _iterator = _createForOfIteratorHelper(v),\n _step;\n\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var version = _step.value;\n var included = satisfies_1(version, range, options);\n\n if (included) {\n prev = version;\n if (!min) min = version;\n } else {\n if (prev) {\n set.push([min, prev]);\n }\n\n prev = null;\n min = null;\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n\n if (min) set.push([min, null]);\n var ranges = [];\n\n for (var _i = 0, _set = set; _i < _set.length; _i++) {\n var _set$_i = _slicedToArray(_set[_i], 2),\n _min = _set$_i[0],\n max = _set$_i[1];\n\n if (_min === max) ranges.push(_min);else if (!max && _min === v[0]) ranges.push('*');else if (!max) ranges.push(\">=\".concat(_min));else if (_min === v[0]) ranges.push(\"<=\".concat(max));else ranges.push(\"\".concat(_min, \" - \").concat(max));\n }\n\n var simplified = ranges.join(' || ');\n var original = typeof range.raw === 'string' ? range.raw : String(range);\n return simplified.length < original.length ? simplified : range;\n};\n\nvar ANY$2 = comparator.ANY; // Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:\n// - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...`\n//\n// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:\n// - If c is only the ANY comparator\n// - If C is only the ANY comparator, return true\n// - Else return false\n// - Let EQ be the set of = comparators in c\n// - If EQ is more than one, return true (null set)\n// - Let GT be the highest > or >= comparator in c\n// - Let LT be the lowest < or <= comparator in c\n// - If GT and LT, and GT.semver > LT.semver, return true (null set)\n// - If EQ\n// - If GT, and EQ does not satisfy GT, return true (null set)\n// - If LT, and EQ does not satisfy LT, return true (null set)\n// - If EQ satisfies every C, return true\n// - Else return false\n// - If GT\n// - If GT is lower than any > or >= comp in C, return false\n// - If GT is >=, and GT.semver does not satisfy every C, return false\n// - If LT\n// - If LT.semver is greater than that of any > comp in C, return false\n// - If LT is <=, and LT.semver does not satisfy every C, return false\n// - If any C is a = range, and GT or LT are set, return false\n// - Else return true\n\nvar subset = function subset(sub, dom, options) {\n sub = new range(sub, options);\n dom = new range(dom, options);\n var sawNonNull = false;\n\n var _iterator = _createForOfIteratorHelper(sub.set),\n _step;\n\n try {\n OUTER: for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var simpleSub = _step.value;\n\n var _iterator2 = _createForOfIteratorHelper(dom.set),\n _step2;\n\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var simpleDom = _step2.value;\n var isSub = simpleSubset(simpleSub, simpleDom, options);\n sawNonNull = sawNonNull || isSub !== null;\n if (isSub) continue OUTER;\n } // the null set is a subset of everything, but null simple ranges in\n // a complex range should be ignored. so if we saw a non-null range,\n // then we know this isn't a subset, but if EVERY simple range was null,\n // then it is a subset.\n\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n\n if (sawNonNull) return false;\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n\n return true;\n};\n\nvar simpleSubset = function simpleSubset(sub, dom, options) {\n if (sub.length === 1 && sub[0].semver === ANY$2) return dom.length === 1 && dom[0].semver === ANY$2;\n var eqSet = new Set();\n var gt, lt;\n\n var _iterator3 = _createForOfIteratorHelper(sub),\n _step3;\n\n try {\n for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n var c = _step3.value;\n if (c.operator === '>' || c.operator === '>=') gt = higherGT(gt, c, options);else if (c.operator === '<' || c.operator === '<=') lt = lowerLT(lt, c, options);else eqSet.add(c.semver);\n }\n } catch (err) {\n _iterator3.e(err);\n } finally {\n _iterator3.f();\n }\n\n if (eqSet.size > 1) return null;\n var gtltComp;\n\n if (gt && lt) {\n gtltComp = compare_1(gt.semver, lt.semver, options);\n if (gtltComp > 0) return null;else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) return null;\n } // will iterate one or zero times\n\n\n var _iterator4 = _createForOfIteratorHelper(eqSet),\n _step4;\n\n try {\n for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n var eq = _step4.value;\n if (gt && !satisfies_1(eq, String(gt), options)) return null;\n if (lt && !satisfies_1(eq, String(lt), options)) return null;\n\n var _iterator6 = _createForOfIteratorHelper(dom),\n _step6;\n\n try {\n for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {\n var _c = _step6.value;\n if (!satisfies_1(eq, String(_c), options)) return false;\n }\n } catch (err) {\n _iterator6.e(err);\n } finally {\n _iterator6.f();\n }\n\n return true;\n }\n } catch (err) {\n _iterator4.e(err);\n } finally {\n _iterator4.f();\n }\n\n var higher, lower;\n var hasDomLT, hasDomGT;\n\n var _iterator5 = _createForOfIteratorHelper(dom),\n _step5;\n\n try {\n for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {\n var _c2 = _step5.value;\n hasDomGT = hasDomGT || _c2.operator === '>' || _c2.operator === '>=';\n hasDomLT = hasDomLT || _c2.operator === '<' || _c2.operator === '<=';\n\n if (gt) {\n if (_c2.operator === '>' || _c2.operator === '>=') {\n higher = higherGT(gt, _c2, options);\n if (higher === _c2) return false;\n } else if (gt.operator === '>=' && !satisfies_1(gt.semver, String(_c2), options)) return false;\n }\n\n if (lt) {\n if (_c2.operator === '<' || _c2.operator === '<=') {\n lower = lowerLT(lt, _c2, options);\n if (lower === _c2) return false;\n } else if (lt.operator === '<=' && !satisfies_1(lt.semver, String(_c2), options)) return false;\n }\n\n if (!_c2.operator && (lt || gt) && gtltComp !== 0) return false;\n } // if there was a < or >, and nothing in the dom, then must be false\n // UNLESS it was limited by another range in the other direction.\n // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0\n\n } catch (err) {\n _iterator5.e(err);\n } finally {\n _iterator5.f();\n }\n\n if (gt && hasDomLT && !lt && gtltComp !== 0) return false;\n if (lt && hasDomGT && !gt && gtltComp !== 0) return false;\n return true;\n}; // >=1.2.3 is lower than >1.2.3\n\n\nvar higherGT = function higherGT(a, b, options) {\n if (!a) return b;\n var comp = compare_1(a.semver, b.semver, options);\n return comp > 0 ? a : comp < 0 ? b : b.operator === '>' && a.operator === '>=' ? b : a;\n}; // <=1.2.3 is higher than <1.2.3\n\n\nvar lowerLT = function lowerLT(a, b, options) {\n if (!a) return b;\n var comp = compare_1(a.semver, b.semver, options);\n return comp < 0 ? a : comp > 0 ? b : b.operator === '<' && a.operator === '<=' ? b : a;\n};\n\nvar subset_1 = subset;\n\nvar semver$1 = {\n re: re_1.re,\n src: re_1.src,\n tokens: re_1.t,\n SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,\n SemVer: semver,\n compareIdentifiers: identifiers.compareIdentifiers,\n rcompareIdentifiers: identifiers.rcompareIdentifiers,\n parse: parse_1,\n valid: valid_1,\n clean: clean_1,\n inc: inc_1,\n diff: diff_1,\n major: major_1,\n minor: minor_1,\n patch: patch_1,\n prerelease: prerelease_1,\n compare: compare_1,\n rcompare: rcompare_1,\n compareLoose: compareLoose_1,\n compareBuild: compareBuild_1,\n sort: sort_1,\n rsort: rsort_1,\n gt: gt_1,\n lt: lt_1,\n eq: eq_1,\n neq: neq_1,\n gte: gte_1,\n lte: lte_1,\n cmp: cmp_1,\n coerce: coerce_1,\n Comparator: comparator,\n Range: range,\n satisfies: satisfies_1,\n toComparators: toComparators_1,\n maxSatisfying: maxSatisfying_1,\n minSatisfying: minSatisfying_1,\n minVersion: minVersion_1,\n validRange: valid$1,\n outside: outside_1,\n gtr: gtr_1,\n ltr: ltr_1,\n intersects: intersects_1,\n simplifyRange: simplify,\n subset: subset_1\n};\n\n(function () {\n /**\n * Install plugin\n * @param app\n * @param axios\n */\n function plugin(app, axios) {\n if (plugin.installed) {\n return;\n }\n\n if (!axios) {\n console.error('You have to install axios');\n return;\n }\n\n if (semver$1.valid(app.version) == null) {\n console.error('Unkown vue version');\n return;\n }\n\n plugin.installed = true;\n\n if (semver$1.lt(app.version, '3.0.0')) {\n Object.defineProperties(app.prototype, {\n axios: {\n get: function get() {\n return axios;\n }\n },\n $http: {\n get: function get() {\n return axios;\n }\n }\n });\n } else {\n app.config.globalProperties.axios = axios;\n app.config.globalProperties.$http = axios;\n }\n\n app.axios = axios;\n app.$http = axios;\n }\n\n if ((typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) == \"object\") {\n module.exports = plugin;\n } else if (typeof define == \"function\" && define.amd) {\n define([], function () {\n return plugin;\n });\n } else if (window.Vue && window.axios) {\n Vue.use(plugin, window.axios);\n }\n})();\n"],"file":"vue-axios.es5.js"}
\No newline at end of file