vue-axios/dist/vue-axios.es5.js.map

{"version":3,"sources":["vue-axios.es5.js"],"names":["_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","_slicedToArray","arr","_arrayWithHoles","_iterableToArrayLimit","_unsupportedIterableToArray","_nonIterableRest","Array","isArray","_arr","_n","_d","_e","_s","_i","next","done","push","value","err","return","o","minLen","_arrayLikeToArray","n","toString","call","slice","name","from","test","len","arr2","_createForOfIteratorHelper","allowArrayLike","it","s","F","e","f","normalCompletion","didErr","step","createCommonjsModule","fn","basedir","module","path","exports","require","base","commonjsRequire","Error","SEMVER_SPEC_VERSION","MAX_LENGTH","MAX_SAFE_INTEGER","Number","MAX_SAFE_COMPONENT_LENGTH","constants","debug","process","env","NODE_DEBUG","_console","_len","arguments","args","_key","console","error","apply","concat","debug_1","re_1","re","src","t","R","createToken","isGlobal","index","RegExp","NUMERICIDENTIFIER","NUMERICIDENTIFIERLOOSE","NONNUMERICIDENTIFIER","PRERELEASEIDENTIFIER","PRERELEASEIDENTIFIERLOOSE","BUILDIDENTIFIER","MAINVERSION","PRERELEASE","BUILD","FULLPLAIN","MAINVERSIONLOOSE","PRERELEASELOOSE","LOOSEPLAIN","XRANGEIDENTIFIER","XRANGEIDENTIFIERLOOSE","GTLT","XRANGEPLAIN","XRANGEPLAINLOOSE","COERCE","LONETILDE","tildeTrimReplace","LONECARET","caretTrimReplace","comparatorTrimReplace","numeric","compareIdentifiers","a","b","anum","bnum","rcompareIdentifiers","identifiers","MAX_LENGTH$1","MAX_SAFE_INTEGER$1","compareIdentifiers$1","SemVer","version","options","this","loose","includePrerelease","m","trim","match","LOOSE","FULL","raw","major","minor","patch","prerelease","split","map","id","num","build","format","join","other","compareMain","comparePre","release","identifier","inc","isNaN","semver","MAX_LENGTH$2","re$1","t$1","parse","er","parse_1","valid","v","valid_1","clean","replace","clean_1","inc_1","compare","compare_1","eq","eq_1","diff","version1","version2","v1","v2","prefix","hasPre","defaultResult","diff_1","major_1","minor_1","patch_1","parsed","prerelease_1","rcompare","rcompare_1","compareLoose","compareLoose_1","compareBuild","versionA","versionB","compareBuild_1","sort","list","sort_1","rsort","rsort_1","gt","gt_1","lt","lt_1","neq","neq_1","gte","gte_1","lte","lte_1","cmp","op","cmp_1","re$2","t$2","coerce","String","rtl","COERCERTL","exec","lastIndex","coerce_1","Range","range","_this","comparator","set","parseRange","filter","c","comps","_this2","hr","re$3","t$3","HYPHENRANGELOOSE","HYPHENRANGE","hyphenReplace","COMPARATORTRIM","TILDETRIM","CARETTRIM","compRe","COMPARATORLOOSE","COMPARATOR","comp","parseComparator","replaceGTE0","some","thisComparators","isSatisfiable","rangeComparators","every","thisComparator","rangeComparator","intersects","testSet","comparators","result","remainingComparators","testComparator","pop","otherComparator","replaceCarets","replaceTildes","replaceXRanges","replaceStars","isX","toLowerCase","replaceTilde","r","TILDELOOSE","TILDE","_","M","p","pr","ret","replaceCaret","CARETLOOSE","CARET","z","replaceXRange","XRANGELOOSE","XRANGE","gtlt","xM","xm","xp","STAR","GTE0PRE","GTE0","incPr","$0","fM","fm","fp","fpr","fb","to","tM","tm","tp","tpr","tb","ANY","allowed","Comparator","operator","get","re$4","t$4","sameDirectionIncreasing","sameDirectionDecreasing","sameSemVer","differentDirectionsInclusive","oppositeDirectionsLessThan","oppositeDirectionsGreaterThan","satisfies","range$1","satisfies_1","toComparators","toComparators_1","maxSatisfying","versions","max","maxSV","rangeObj","forEach","maxSatisfying_1","minSatisfying","min","minSV","minSatisfying_1","minVersion","minver","compver","minVersion_1","validRange","valid$1","ANY$1","outside","hilo","gtfn","ltefn","ltfn","ecomp","_ret","high","low","comparator$1","outside_1","gtr","gtr_1","ltr","ltr_1","r1","r2","intersects_1","simplify","prev","_iterator","_step","ranges","_set","_set$_i","_min","simplified","original","ANY$2","subset","sub","dom","sawNonNull","OUTER","simpleSub","_iterator2","_step2","simpleDom","isSub","simpleSubset","gtltComp","eqSet","Set","_iterator3","_step3","higherGT","lowerLT","add","size","_step4","_iterator4","_iterator6","_step6","_c","_iterator5","_step5","_c2","hasDomGT","hasDomLT","subset_1","semver$1","tokens","simplifyRange","plugin","app","axios","installed","defineProperties","$http","config","globalProperties","define","amd","window","Vue","use"],"mappings":"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","file":"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"]}AAQyE,UAC1DF,OAAOE,QAAU4V,EACS,mBAAVQ,QAAwBA,OAAOC,IAC/CD,OAAO,GAAI,WACT,OAAOR,IAEAU,OAAOC,KAAOD,OAAOR,OAC9BS,IAAIC,IAAIZ,EAAQU,OAAOR,OApD3B"}