@slicemachine/init 1.1.16-dev-alpha.4 → 1.1.16-dev-alpha.6

package/build/index.js

@@ -457,7 +457,15 @@ async function lsfiles(dir) {
   });
 }
 
-var re$5 = {exports: {}};
+const debug$3 = (
+  typeof process === 'object' &&
+  process.env &&
+  process.env.NODE_DEBUG &&
+  /\bsemver\b/i.test(process.env.NODE_DEBUG)
+) ? (...args) => console.error('SEMVER', ...args)
+  : () => {};
+
+var debug_1 = debug$3;
 
 // Note: this is the semver.org version of the spec that it implements
 // Not necessarily the package version of this code.
@@ -470,25 +478,17 @@ const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER ||
 // Max safe segment length for coercion.
 const MAX_SAFE_COMPONENT_LENGTH = 16;
 
-var constants$1 = {
+var constants = {
   SEMVER_SPEC_VERSION,
   MAX_LENGTH: MAX_LENGTH$2,
   MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
   MAX_SAFE_COMPONENT_LENGTH,
 };
 
-const debug$3 = (
-  typeof process === 'object' &&
-  process.env &&
-  process.env.NODE_DEBUG &&
-  /\bsemver\b/i.test(process.env.NODE_DEBUG)
-) ? (...args) => console.error('SEMVER', ...args)
-  : () => {};
-
-var debug_1 = debug$3;
+var re$5 = {exports: {}};
 
 (function (module, exports) {
-const { MAX_SAFE_COMPONENT_LENGTH } = constants$1;
+const { MAX_SAFE_COMPONENT_LENGTH } = constants;
 const debug = debug_1;
 exports = module.exports = {};
 
@@ -703,22 +703,22 @@ const compareIdentifiers$1 = (a, b) => {
 
 const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
 
-var identifiers$1 = {
+var identifiers = {
   compareIdentifiers: compareIdentifiers$1,
   rcompareIdentifiers,
 };
 
 const debug$2 = debug_1;
-const { MAX_LENGTH: MAX_LENGTH$1, MAX_SAFE_INTEGER } = constants$1;
+const { MAX_LENGTH: MAX_LENGTH$1, MAX_SAFE_INTEGER } = constants;
 const { re: re$4, t: t$4 } = re$5.exports;
 
 const parseOptions$3 = parseOptions_1;
-const { compareIdentifiers } = identifiers$1;
-class SemVer$f {
+const { compareIdentifiers } = identifiers;
+class SemVer$5 {
   constructor (version, options) {
     options = parseOptions$3(options);
 
-    if (version instanceof SemVer$f) {
+    if (version instanceof SemVer$5) {
       if (version.loose === !!options.loose &&
           version.includePrerelease === !!options.includePrerelease) {
         return version
@@ -800,11 +800,11 @@ class SemVer$f {
 
   compare (other) {
     debug$2('SemVer.compare', this.version, this.options, other);
-    if (!(other instanceof SemVer$f)) {
+    if (!(other instanceof SemVer$5)) {
       if (typeof other === 'string' && other === this.version) {
         return 0
       }
-      other = new SemVer$f(other, this.options);
+      other = new SemVer$5(other, this.options);
     }
 
     if (other.version === this.version) {
@@ -815,8 +815,8 @@ class SemVer$f {
   }
 
   compareMain (other) {
-    if (!(other instanceof SemVer$f)) {
-      other = new SemVer$f(other, this.options);
+    if (!(other instanceof SemVer$5)) {
+      other = new SemVer$5(other, this.options);
     }
 
     return (
@@ -827,8 +827,8 @@ class SemVer$f {
   }
 
   comparePre (other) {
-    if (!(other instanceof SemVer$f)) {
-      other = new SemVer$f(other, this.options);
+    if (!(other instanceof SemVer$5)) {
+      other = new SemVer$5(other, this.options);
     }
 
     // NOT having a prerelease is > having one
@@ -860,8 +860,8 @@ class SemVer$f {
   }
 
   compareBuild (other) {
-    if (!(other instanceof SemVer$f)) {
-      other = new SemVer$f(other, this.options);
+    if (!(other instanceof SemVer$5)) {
+      other = new SemVer$5(other, this.options);
     }
 
     let i = 0;
@@ -994,17 +994,17 @@ class SemVer$f {
   }
 }
 
-var semver$1 = SemVer$f;
+var semver = SemVer$5;
 
-const { MAX_LENGTH } = constants$1;
+const { MAX_LENGTH } = constants;
 const { re: re$3, t: t$3 } = re$5.exports;
-const SemVer$e = semver$1;
+const SemVer$4 = semver;
 
 const parseOptions$2 = parseOptions_1;
-const parse$6 = (version, options) => {
+const parse$1 = (version, options) => {
   options = parseOptions$2(options);
 
-  if (version instanceof SemVer$e) {
+  if (version instanceof SemVer$4) {
     return version
   }
 
@@ -1022,203 +1022,20 @@ const parse$6 = (version, options) => {
   }
 
   try {
-    return new SemVer$e(version, options)
-  } catch (er) {
-    return null
-  }
-};
-
-var parse_1 = parse$6;
-
-const parse$5 = parse_1;
-const valid$2 = (version, options) => {
-  const v = parse$5(version, options);
-  return v ? v.version : null
-};
-var valid_1 = valid$2;
-
-const parse$4 = parse_1;
-const clean$1 = (version, options) => {
-  const s = parse$4(version.trim().replace(/^[=v]+/, ''), options);
-  return s ? s.version : null
-};
-var clean_1 = clean$1;
-
-const SemVer$d = semver$1;
-
-const inc$1 = (version, release, options, identifier) => {
-  if (typeof (options) === 'string') {
-    identifier = options;
-    options = undefined;
-  }
-
-  try {
-    return new SemVer$d(
-      version instanceof SemVer$d ? version.version : version,
-      options
-    ).inc(release, identifier).version
+    return new SemVer$4(version, options)
   } catch (er) {
     return null
   }
 };
-var inc_1 = inc$1;
-
-const SemVer$c = semver$1;
-const compare$b = (a, b, loose) =>
-  new SemVer$c(a, loose).compare(new SemVer$c(b, loose));
-
-var compare_1 = compare$b;
-
-const compare$a = compare_1;
-const eq$3 = (a, b, loose) => compare$a(a, b, loose) === 0;
-var eq_1 = eq$3;
-
-const parse$3 = parse_1;
-const eq$2 = eq_1;
-
-const diff$1 = (version1, version2) => {
-  if (eq$2(version1, version2)) {
-    return null
-  } else {
-    const v1 = parse$3(version1);
-    const v2 = parse$3(version2);
-    const hasPre = v1.prerelease.length || v2.prerelease.length;
-    const prefix = hasPre ? 'pre' : '';
-    const defaultResult = hasPre ? 'prerelease' : '';
-    for (const key in v1) {
-      if (key === 'major' || key === 'minor' || key === 'patch') {
-        if (v1[key] !== v2[key]) {
-          return prefix + key
-        }
-      }
-    }
-    return defaultResult // may be undefined
-  }
-};
-var diff_1 = diff$1;
-
-const SemVer$b = semver$1;
-const major$1 = (a, loose) => new SemVer$b(a, loose).major;
-var major_1 = major$1;
-
-const SemVer$a = semver$1;
-const minor$1 = (a, loose) => new SemVer$a(a, loose).minor;
-var minor_1 = minor$1;
-
-const SemVer$9 = semver$1;
-const patch$1 = (a, loose) => new SemVer$9(a, loose).patch;
-var patch_1 = patch$1;
-
-const parse$2 = parse_1;
-const prerelease$1 = (version, options) => {
-  const parsed = parse$2(version, options);
-  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
-};
-var prerelease_1 = prerelease$1;
-
-const compare$9 = compare_1;
-const rcompare$1 = (a, b, loose) => compare$9(b, a, loose);
-var rcompare_1 = rcompare$1;
-
-const compare$8 = compare_1;
-const compareLoose$1 = (a, b) => compare$8(a, b, true);
-var compareLoose_1 = compareLoose$1;
-
-const SemVer$8 = semver$1;
-const compareBuild$3 = (a, b, loose) => {
-  const versionA = new SemVer$8(a, loose);
-  const versionB = new SemVer$8(b, loose);
-  return versionA.compare(versionB) || versionA.compareBuild(versionB)
-};
-var compareBuild_1 = compareBuild$3;
-
-const compareBuild$2 = compareBuild_1;
-const sort$1 = (list, loose) => list.sort((a, b) => compareBuild$2(a, b, loose));
-var sort_1 = sort$1;
-
-const compareBuild$1 = compareBuild_1;
-const rsort$1 = (list, loose) => list.sort((a, b) => compareBuild$1(b, a, loose));
-var rsort_1 = rsort$1;
-
-const compare$7 = compare_1;
-const gt$4 = (a, b, loose) => compare$7(a, b, loose) > 0;
-var gt_1 = gt$4;
-
-const compare$6 = compare_1;
-const lt$3 = (a, b, loose) => compare$6(a, b, loose) < 0;
-var lt_1 = lt$3;
-
-const compare$5 = compare_1;
-const neq$2 = (a, b, loose) => compare$5(a, b, loose) !== 0;
-var neq_1 = neq$2;
-
-const compare$4 = compare_1;
-const gte$3 = (a, b, loose) => compare$4(a, b, loose) >= 0;
-var gte_1 = gte$3;
-
-const compare$3 = compare_1;
-const lte$3 = (a, b, loose) => compare$3(a, b, loose) <= 0;
-var lte_1 = lte$3;
-
-const eq$1 = eq_1;
-const neq$1 = neq_1;
-const gt$3 = gt_1;
-const gte$2 = gte_1;
-const lt$2 = lt_1;
-const lte$2 = lte_1;
-
-const cmp$2 = (a, op, b, loose) => {
-  switch (op) {
-    case '===':
-      if (typeof a === 'object') {
-        a = a.version;
-      }
-      if (typeof b === 'object') {
-        b = b.version;
-      }
-      return a === b
-
-    case '!==':
-      if (typeof a === 'object') {
-        a = a.version;
-      }
-      if (typeof b === 'object') {
-        b = b.version;
-      }
-      return a !== b
-
-    case '':
-    case '=':
-    case '==':
-      return eq$1(a, b, loose)
-
-    case '!=':
-      return neq$1(a, b, loose)
-
-    case '>':
-      return gt$3(a, b, loose)
-
-    case '>=':
-      return gte$2(a, b, loose)
-
-    case '<':
-      return lt$2(a, b, loose)
-
-    case '<=':
-      return lte$2(a, b, loose)
 
-    default:
-      throw new TypeError(`Invalid operator: ${op}`)
-  }
-};
-var cmp_1 = cmp$2;
+var parse_1 = parse$1;
 
-const SemVer$7 = semver$1;
-const parse$1 = parse_1;
+const SemVer$3 = semver;
+const parse = parse_1;
 const { re: re$2, t: t$2 } = re$5.exports;
 
-const coerce$1 = (version, options) => {
-  if (version instanceof SemVer$7) {
+const coerce = (version, options) => {
+  if (version instanceof SemVer$3) {
     return version
   }
 
@@ -1262,9 +1079,9 @@ const coerce$1 = (version, options) => {
     return null
   }
 
-  return parse$1(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
+  return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
 };
-var coerce_1 = coerce$1;
+var coerce_1 = coerce;
 
 var iterator = function (Yallist) {
   Yallist.prototype[Symbol.iterator] = function* () {
@@ -2033,110 +1850,330 @@ const forEachStep = (self, fn, node, thisp) => {
 
 var lruCache = LRUCache;
 
+const SemVer$2 = semver;
+const compare$6 = (a, b, loose) =>
+  new SemVer$2(a, loose).compare(new SemVer$2(b, loose));
+
+var compare_1 = compare$6;
+
+const compare$5 = compare_1;
+const eq$1 = (a, b, loose) => compare$5(a, b, loose) === 0;
+var eq_1 = eq$1;
+
+const compare$4 = compare_1;
+const neq$1 = (a, b, loose) => compare$4(a, b, loose) !== 0;
+var neq_1 = neq$1;
+
+const compare$3 = compare_1;
+const gt$1 = (a, b, loose) => compare$3(a, b, loose) > 0;
+var gt_1 = gt$1;
+
+const compare$2 = compare_1;
+const gte$1 = (a, b, loose) => compare$2(a, b, loose) >= 0;
+var gte_1 = gte$1;
+
+const compare$1 = compare_1;
+const lt$1 = (a, b, loose) => compare$1(a, b, loose) < 0;
+var lt_1 = lt$1;
+
+const compare = compare_1;
+const lte$1 = (a, b, loose) => compare(a, b, loose) <= 0;
+var lte_1 = lte$1;
+
+const eq = eq_1;
+const neq = neq_1;
+const gt = gt_1;
+const gte = gte_1;
+const lt = lt_1;
+const lte = lte_1;
+
+const cmp$1 = (a, op, b, loose) => {
+  switch (op) {
+    case '===':
+      if (typeof a === 'object') {
+        a = a.version;
+      }
+      if (typeof b === 'object') {
+        b = b.version;
+      }
+      return a === b
+
+    case '!==':
+      if (typeof a === 'object') {
+        a = a.version;
+      }
+      if (typeof b === 'object') {
+        b = b.version;
+      }
+      return a !== b
+
+    case '':
+    case '=':
+    case '==':
+      return eq(a, b, loose)
+
+    case '!=':
+      return neq(a, b, loose)
+
+    case '>':
+      return gt(a, b, loose)
+
+    case '>=':
+      return gte(a, b, loose)
+
+    case '<':
+      return lt(a, b, loose)
+
+    case '<=':
+      return lte(a, b, loose)
+
+    default:
+      throw new TypeError(`Invalid operator: ${op}`)
+  }
+};
+var cmp_1 = cmp$1;
+
+const ANY = Symbol('SemVer ANY');
 // hoisted class for cyclic dependency
-class Range$b {
-  constructor (range, options) {
+class Comparator$1 {
+  static get ANY () {
+    return ANY
+  }
+
+  constructor (comp, options) {
     options = parseOptions$1(options);
 
-    if (range instanceof Range$b) {
-      if (
-        range.loose === !!options.loose &&
-        range.includePrerelease === !!options.includePrerelease
-      ) {
-        return range
+    if (comp instanceof Comparator$1) {
+      if (comp.loose === !!options.loose) {
+        return comp
       } else {
-        return new Range$b(range.raw, options)
+        comp = comp.value;
       }
     }
 
-    if (range instanceof Comparator$4) {
-      // just put it in the set and return
-      this.raw = range.value;
-      this.set = [[range]];
-      this.format();
-      return this
-    }
-
+    debug$1('comparator', comp, options);
     this.options = options;
     this.loose = !!options.loose;
-    this.includePrerelease = !!options.includePrerelease;
-
-    // First, split based on boolean or ||
-    this.raw = range;
-    this.set = range
-      .split('||')
-      // map the range to a 2d array of comparators
-      .map(r => this.parseRange(r.trim()))
-      // throw out any comparator lists that are empty
-      // this generally means that it was not a valid range, which is allowed
-      // in loose mode, but will still throw if the WHOLE range is invalid.
-      .filter(c => c.length);
+    this.parse(comp);
 
-    if (!this.set.length) {
-      throw new TypeError(`Invalid SemVer Range: ${range}`)
+    if (this.semver === ANY) {
+      this.value = '';
+    } else {
+      this.value = this.operator + this.semver.version;
     }
 
-    // if we have any that are not the null set, throw out null sets.
-    if (this.set.length > 1) {
-      // keep the first one, in case they're all null sets
-      const first = this.set[0];
-      this.set = this.set.filter(c => !isNullSet(c[0]));
-      if (this.set.length === 0) {
-        this.set = [first];
-      } else if (this.set.length > 1) {
-        // if we have any that are *, then the range is just *
-        for (const c of this.set) {
-          if (c.length === 1 && isAny(c[0])) {
-            this.set = [c];
-            break
-          }
-        }
-      }
+    debug$1('comp', this);
+  }
+
+  parse (comp) {
+    const r = this.options.loose ? re$1[t$1.COMPARATORLOOSE] : re$1[t$1.COMPARATOR];
+    const m = comp.match(r);
+
+    if (!m) {
+      throw new TypeError(`Invalid comparator: ${comp}`)
     }
 
-    this.format();
-  }
+    this.operator = m[1] !== undefined ? m[1] : '';
+    if (this.operator === '=') {
+      this.operator = '';
+    }
 
-  format () {
-    this.range = this.set
-      .map((comps) => {
-        return comps.join(' ').trim()
-      })
-      .join('||')
-      .trim();
-    return this.range
+    // if it literally is just '>' or '' then allow anything.
+    if (!m[2]) {
+      this.semver = ANY;
+    } else {
+      this.semver = new SemVer$1(m[2], this.options.loose);
+    }
   }
 
   toString () {
-    return this.range
+    return this.value
   }
 
-  parseRange (range) {
-    range = range.trim();
+  test (version) {
+    debug$1('Comparator.test', version, this.options.loose);
 
-    // memoize range parsing for performance.
-    // this is a very hot path, and fully deterministic.
-    const memoOpts = Object.keys(this.options).join(',');
-    const memoKey = `parseRange:${memoOpts}:${range}`;
-    const cached = cache.get(memoKey);
-    if (cached) {
-      return cached
+    if (this.semver === ANY || version === ANY) {
+      return true
     }
 
-    const loose = this.options.loose;
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer$1(version, this.options);
+      } catch (er) {
+        return false
+      }
+    }
+
+    return cmp(version, this.operator, this.semver, this.options)
+  }
+
+  intersects (comp, options) {
+    if (!(comp instanceof Comparator$1)) {
+      throw new TypeError('a Comparator is required')
+    }
+
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false,
+      };
+    }
+
+    if (this.operator === '') {
+      if (this.value === '') {
+        return true
+      }
+      return new Range$2(comp.value, options).test(this.value)
+    } else if (comp.operator === '') {
+      if (comp.value === '') {
+        return true
+      }
+      return new Range$2(this.value, options).test(comp.semver)
+    }
+
+    const sameDirectionIncreasing =
+      (this.operator === '>=' || this.operator === '>') &&
+      (comp.operator === '>=' || comp.operator === '>');
+    const sameDirectionDecreasing =
+      (this.operator === '<=' || this.operator === '<') &&
+      (comp.operator === '<=' || comp.operator === '<');
+    const sameSemVer = this.semver.version === comp.semver.version;
+    const differentDirectionsInclusive =
+      (this.operator === '>=' || this.operator === '<=') &&
+      (comp.operator === '>=' || comp.operator === '<=');
+    const oppositeDirectionsLessThan =
+      cmp(this.semver, '<', comp.semver, options) &&
+      (this.operator === '>=' || this.operator === '>') &&
+        (comp.operator === '<=' || comp.operator === '<');
+    const oppositeDirectionsGreaterThan =
+      cmp(this.semver, '>', comp.semver, options) &&
+      (this.operator === '<=' || this.operator === '<') &&
+        (comp.operator === '>=' || comp.operator === '>');
+
+    return (
+      sameDirectionIncreasing ||
+      sameDirectionDecreasing ||
+      (sameSemVer && differentDirectionsInclusive) ||
+      oppositeDirectionsLessThan ||
+      oppositeDirectionsGreaterThan
+    )
+  }
+}
+
+var comparator = Comparator$1;
+
+const parseOptions$1 = parseOptions_1;
+const { re: re$1, t: t$1 } = re$5.exports;
+const cmp = cmp_1;
+const debug$1 = debug_1;
+const SemVer$1 = semver;
+const Range$2 = range;
+
+// hoisted class for cyclic dependency
+class Range$1 {
+  constructor (range, options) {
+    options = parseOptions(options);
+
+    if (range instanceof Range$1) {
+      if (
+        range.loose === !!options.loose &&
+        range.includePrerelease === !!options.includePrerelease
+      ) {
+        return range
+      } else {
+        return new Range$1(range.raw, options)
+      }
+    }
+
+    if (range instanceof Comparator) {
+      // just put it in the set and return
+      this.raw = range.value;
+      this.set = [[range]];
+      this.format();
+      return this
+    }
+
+    this.options = options;
+    this.loose = !!options.loose;
+    this.includePrerelease = !!options.includePrerelease;
+
+    // First, split based on boolean or ||
+    this.raw = range;
+    this.set = range
+      .split('||')
+      // map the range to a 2d array of comparators
+      .map(r => this.parseRange(r.trim()))
+      // throw out any comparator lists that are empty
+      // this generally means that it was not a valid range, which is allowed
+      // in loose mode, but will still throw if the WHOLE range is invalid.
+      .filter(c => c.length);
+
+    if (!this.set.length) {
+      throw new TypeError(`Invalid SemVer Range: ${range}`)
+    }
+
+    // if we have any that are not the null set, throw out null sets.
+    if (this.set.length > 1) {
+      // keep the first one, in case they're all null sets
+      const first = this.set[0];
+      this.set = this.set.filter(c => !isNullSet(c[0]));
+      if (this.set.length === 0) {
+        this.set = [first];
+      } else if (this.set.length > 1) {
+        // if we have any that are *, then the range is just *
+        for (const c of this.set) {
+          if (c.length === 1 && isAny(c[0])) {
+            this.set = [c];
+            break
+          }
+        }
+      }
+    }
+
+    this.format();
+  }
+
+  format () {
+    this.range = this.set
+      .map((comps) => {
+        return comps.join(' ').trim()
+      })
+      .join('||')
+      .trim();
+    return this.range
+  }
+
+  toString () {
+    return this.range
+  }
+
+  parseRange (range) {
+    range = range.trim();
+
+    // memoize range parsing for performance.
+    // this is a very hot path, and fully deterministic.
+    const memoOpts = Object.keys(this.options).join(',');
+    const memoKey = `parseRange:${memoOpts}:${range}`;
+    const cached = cache.get(memoKey);
+    if (cached) {
+      return cached
+    }
+
+    const loose = this.options.loose;
     // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-    const hr = loose ? re$1[t$1.HYPHENRANGELOOSE] : re$1[t$1.HYPHENRANGE];
+    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
     range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
-    debug$1('hyphen replace', range);
+    debug('hyphen replace', range);
     // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-    range = range.replace(re$1[t$1.COMPARATORTRIM], comparatorTrimReplace);
-    debug$1('comparator trim', range);
+    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+    debug('comparator trim', range);
 
     // `~ 1.2.3` => `~1.2.3`
-    range = range.replace(re$1[t$1.TILDETRIM], tildeTrimReplace);
+    range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
 
     // `^ 1.2.3` => `^1.2.3`
-    range = range.replace(re$1[t$1.CARETTRIM], caretTrimReplace);
+    range = range.replace(re[t.CARETTRIM], caretTrimReplace);
 
     // normalize spaces
     range = range.split(/\s+/).join(' ');
@@ -2155,17 +2192,17 @@ class Range$b {
     if (loose) {
       // in loose mode, throw out any that are not valid comparators
       rangeList = rangeList.filter(comp => {
-        debug$1('loose invalid filter', comp, this.options);
-        return !!comp.match(re$1[t$1.COMPARATORLOOSE])
+        debug('loose invalid filter', comp, this.options);
+        return !!comp.match(re[t.COMPARATORLOOSE])
       });
     }
-    debug$1('range list', rangeList);
+    debug('range list', rangeList);
 
     // if any comparators are the null set, then replace with JUST null set
     // if more than one comparator, remove any * comparators
     // also, don't include the same comparator more than once
     const rangeMap = new Map();
-    const comparators = rangeList.map(comp => new Comparator$4(comp, this.options));
+    const comparators = rangeList.map(comp => new Comparator(comp, this.options));
     for (const comp of comparators) {
       if (isNullSet(comp)) {
         return [comp]
@@ -2182,7 +2219,7 @@ class Range$b {
   }
 
   intersects (range, options) {
-    if (!(range instanceof Range$b)) {
+    if (!(range instanceof Range$1)) {
       throw new TypeError('a Range is required')
     }
 
@@ -2211,7 +2248,7 @@ class Range$b {
 
     if (typeof version === 'string') {
       try {
-        version = new SemVer$6(version, this.options);
+        version = new SemVer(version, this.options);
       } catch (er) {
         return false
       }
@@ -2225,18 +2262,18 @@ class Range$b {
     return false
   }
 }
-var range = Range$b;
+var range = Range$1;
 
 const LRU = lruCache;
 const cache = new LRU({ max: 1000 });
 
-const parseOptions$1 = parseOptions_1;
-const Comparator$4 = comparator;
-const debug$1 = debug_1;
-const SemVer$6 = semver$1;
+const parseOptions = parseOptions_1;
+const Comparator = comparator;
+const debug = debug_1;
+const SemVer = semver;
 const {
-  re: re$1,
-  t: t$1,
+  re,
+  t,
   comparatorTrimReplace,
   tildeTrimReplace,
   caretTrimReplace,
@@ -2267,15 +2304,15 @@ const isSatisfiable = (comparators, options) => {
 // already replaced the hyphen ranges
 // turn into a set of JUST comparators.
 const parseComparator = (comp, options) => {
-  debug$1('comp', comp, options);
+  debug('comp', comp, options);
   comp = replaceCarets(comp, options);
-  debug$1('caret', comp);
+  debug('caret', comp);
   comp = replaceTildes(comp, options);
-  debug$1('tildes', comp);
+  debug('tildes', comp);
   comp = replaceXRanges(comp, options);
-  debug$1('xrange', comp);
+  debug('xrange', comp);
   comp = replaceStars(comp, options);
-  debug$1('stars', comp);
+  debug('stars', comp);
   return comp
 };
 
@@ -2294,9 +2331,9 @@ const replaceTildes = (comp, options) =>
   }).join(' ');
 
 const replaceTilde = (comp, options) => {
-  const r = options.loose ? re$1[t$1.TILDELOOSE] : re$1[t$1.TILDE];
+  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
   return comp.replace(r, (_, M, m, p, pr) => {
-    debug$1('tilde', comp, _, M, m, p, pr);
+    debug('tilde', comp, _, M, m, p, pr);
     let ret;
 
     if (isX(M)) {
@@ -2307,7 +2344,7 @@ const replaceTilde = (comp, options) => {
       // ~1.2 == >=1.2.0 <1.3.0-0
       ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
     } else if (pr) {
-      debug$1('replaceTilde pr', pr);
+      debug('replaceTilde pr', pr);
       ret = `>=${M}.${m}.${p}-${pr
       } <${M}.${+m + 1}.0-0`;
     } else {
@@ -2316,7 +2353,7 @@ const replaceTilde = (comp, options) => {
       } <${M}.${+m + 1}.0-0`;
     }
 
-    debug$1('tilde return', ret);
+    debug('tilde return', ret);
     return ret
   })
 };
@@ -2335,11 +2372,11 @@ const replaceCarets = (comp, options) =>
   }).join(' ');
 
 const replaceCaret = (comp, options) => {
-  debug$1('caret', comp, options);
-  const r = options.loose ? re$1[t$1.CARETLOOSE] : re$1[t$1.CARET];
+  debug('caret', comp, options);
+  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
   const z = options.includePrerelease ? '-0' : '';
   return comp.replace(r, (_, M, m, p, pr) => {
-    debug$1('caret', comp, _, M, m, p, pr);
+    debug('caret', comp, _, M, m, p, pr);
     let ret;
 
     if (isX(M)) {
@@ -2353,7 +2390,7 @@ const replaceCaret = (comp, options) => {
         ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
       }
     } else if (pr) {
-      debug$1('replaceCaret pr', pr);
+      debug('replaceCaret pr', pr);
       if (M === '0') {
         if (m === '0') {
           ret = `>=${M}.${m}.${p}-${pr
@@ -2367,7 +2404,7 @@ const replaceCaret = (comp, options) => {
         } <${+M + 1}.0.0-0`;
       }
     } else {
-      debug$1('no pr');
+      debug('no pr');
       if (M === '0') {
         if (m === '0') {
           ret = `>=${M}.${m}.${p
@@ -2382,13 +2419,13 @@ const replaceCaret = (comp, options) => {
       }
     }
 
-    debug$1('caret return', ret);
+    debug('caret return', ret);
     return ret
   })
 };
 
 const replaceXRanges = (comp, options) => {
-  debug$1('replaceXRanges', comp, options);
+  debug('replaceXRanges', comp, options);
   return comp.split(/\s+/).map((c) => {
     return replaceXRange(c, options)
   }).join(' ')
@@ -2396,9 +2433,9 @@ const replaceXRanges = (comp, options) => {
 
 const replaceXRange = (comp, options) => {
   comp = comp.trim();
-  const r = options.loose ? re$1[t$1.XRANGELOOSE] : re$1[t$1.XRANGE];
+  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
   return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
-    debug$1('xRange', comp, ret, gtlt, M, m, p, pr);
+    debug('xRange', comp, ret, gtlt, M, m, p, pr);
     const xM = isX(M);
     const xm = xM || isX(m);
     const xp = xm || isX(p);
@@ -2463,7 +2500,7 @@ const replaceXRange = (comp, options) => {
       } <${M}.${+m + 1}.0-0`;
     }
 
-    debug$1('xRange return', ret);
+    debug('xRange return', ret);
 
     return ret
   })
@@ -2472,15 +2509,15 @@ const replaceXRange = (comp, options) => {
 // Because * is AND-ed with everything else in the comparator,
 // and '' means "any version", just remove the *s entirely.
 const replaceStars = (comp, options) => {
-  debug$1('replaceStars', comp, options);
+  debug('replaceStars', comp, options);
   // Looseness is ignored here.  star is always as loose as it gets!
-  return comp.trim().replace(re$1[t$1.STAR], '')
+  return comp.trim().replace(re[t.STAR], '')
 };
 
 const replaceGTE0 = (comp, options) => {
-  debug$1('replaceGTE0', comp, options);
+  debug('replaceGTE0', comp, options);
   return comp.trim()
-    .replace(re$1[options.includePrerelease ? t$1.GTE0PRE : t$1.GTE0], '')
+    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
 };
 
 // This function is passed to string.replace(re[t.HYPHENRANGE])
@@ -2534,8 +2571,8 @@ const testSet = (set, version, options) => {
     // However, `1.2.4-alpha.notready` should NOT be allowed,
     // even though it's within the range set by the comparators.
     for (let i = 0; i < set.length; i++) {
-      debug$1(set[i].semver);
-      if (set[i].semver === Comparator$4.ANY) {
+      debug(set[i].semver);
+      if (set[i].semver === Comparator.ANY) {
         continue
       }
 
@@ -2556,776 +2593,24 @@ const testSet = (set, version, options) => {
   return true
 };
 
-const ANY$2 = Symbol('SemVer ANY');
-// hoisted class for cyclic dependency
-class Comparator$3 {
-  static get ANY () {
-    return ANY$2
-  }
-
-  constructor (comp, options) {
-    options = parseOptions(options);
-
-    if (comp instanceof Comparator$3) {
-      if (comp.loose === !!options.loose) {
-        return comp
-      } else {
-        comp = comp.value;
-      }
-    }
-
-    debug('comparator', comp, options);
-    this.options = options;
-    this.loose = !!options.loose;
-    this.parse(comp);
-
-    if (this.semver === ANY$2) {
-      this.value = '';
-    } else {
-      this.value = this.operator + this.semver.version;
-    }
-
-    debug('comp', this);
-  }
-
-  parse (comp) {
-    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
-    const m = comp.match(r);
-
-    if (!m) {
-      throw new TypeError(`Invalid comparator: ${comp}`)
-    }
-
-    this.operator = m[1] !== undefined ? m[1] : '';
-    if (this.operator === '=') {
-      this.operator = '';
-    }
-
-    // if it literally is just '>' or '' then allow anything.
-    if (!m[2]) {
-      this.semver = ANY$2;
-    } else {
-      this.semver = new SemVer$5(m[2], this.options.loose);
-    }
-  }
-
-  toString () {
-    return this.value
-  }
-
-  test (version) {
-    debug('Comparator.test', version, this.options.loose);
-
-    if (this.semver === ANY$2 || version === ANY$2) {
-      return true
-    }
-
-    if (typeof version === 'string') {
-      try {
-        version = new SemVer$5(version, this.options);
-      } catch (er) {
-        return false
-      }
-    }
-
-    return cmp$1(version, this.operator, this.semver, this.options)
-  }
-
-  intersects (comp, options) {
-    if (!(comp instanceof Comparator$3)) {
-      throw new TypeError('a Comparator is required')
-    }
-
-    if (!options || typeof options !== 'object') {
-      options = {
-        loose: !!options,
-        includePrerelease: false,
-      };
-    }
-
-    if (this.operator === '') {
-      if (this.value === '') {
-        return true
-      }
-      return new Range$a(comp.value, options).test(this.value)
-    } else if (comp.operator === '') {
-      if (comp.value === '') {
-        return true
-      }
-      return new Range$a(this.value, options).test(comp.semver)
-    }
-
-    const sameDirectionIncreasing =
-      (this.operator === '>=' || this.operator === '>') &&
-      (comp.operator === '>=' || comp.operator === '>');
-    const sameDirectionDecreasing =
-      (this.operator === '<=' || this.operator === '<') &&
-      (comp.operator === '<=' || comp.operator === '<');
-    const sameSemVer = this.semver.version === comp.semver.version;
-    const differentDirectionsInclusive =
-      (this.operator === '>=' || this.operator === '<=') &&
-      (comp.operator === '>=' || comp.operator === '<=');
-    const oppositeDirectionsLessThan =
-      cmp$1(this.semver, '<', comp.semver, options) &&
-      (this.operator === '>=' || this.operator === '>') &&
-        (comp.operator === '<=' || comp.operator === '<');
-    const oppositeDirectionsGreaterThan =
-      cmp$1(this.semver, '>', comp.semver, options) &&
-      (this.operator === '<=' || this.operator === '<') &&
-        (comp.operator === '>=' || comp.operator === '>');
-
-    return (
-      sameDirectionIncreasing ||
-      sameDirectionDecreasing ||
-      (sameSemVer && differentDirectionsInclusive) ||
-      oppositeDirectionsLessThan ||
-      oppositeDirectionsGreaterThan
-    )
-  }
-}
-
-var comparator = Comparator$3;
-
-const parseOptions = parseOptions_1;
-const { re, t } = re$5.exports;
-const cmp$1 = cmp_1;
-const debug = debug_1;
-const SemVer$5 = semver$1;
-const Range$a = range;
-
-const Range$9 = range;
-const satisfies$4 = (version, range, options) => {
+const Range = range;
+const satisfies = (version, range, options) => {
   try {
-    range = new Range$9(range, options);
+    range = new Range(range, options);
   } catch (er) {
     return false
   }
   return range.test(version)
 };
-var satisfies_1 = satisfies$4;
-
-const Range$8 = range;
-
-// Mostly just for testing and legacy API reasons
-const toComparators$1 = (range, options) =>
-  new Range$8(range, options).set
-    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '));
-
-var toComparators_1 = toComparators$1;
-
-const SemVer$4 = semver$1;
-const Range$7 = range;
-
-const maxSatisfying$1 = (versions, range, options) => {
-  let max = null;
-  let maxSV = null;
-  let rangeObj = null;
-  try {
-    rangeObj = new Range$7(range, options);
-  } catch (er) {
-    return null
-  }
-  versions.forEach((v) => {
-    if (rangeObj.test(v)) {
-      // satisfies(v, range, options)
-      if (!max || maxSV.compare(v) === -1) {
-        // compare(max, v, true)
-        max = v;
-        maxSV = new SemVer$4(max, options);
-      }
-    }
-  });
-  return max
-};
-var maxSatisfying_1 = maxSatisfying$1;
-
-const SemVer$3 = semver$1;
-const Range$6 = range;
-const minSatisfying$1 = (versions, range, options) => {
-  let min = null;
-  let minSV = null;
-  let rangeObj = null;
-  try {
-    rangeObj = new Range$6(range, options);
-  } catch (er) {
-    return null
-  }
-  versions.forEach((v) => {
-    if (rangeObj.test(v)) {
-      // satisfies(v, range, options)
-      if (!min || minSV.compare(v) === 1) {
-        // compare(min, v, true)
-        min = v;
-        minSV = new SemVer$3(min, options);
-      }
-    }
-  });
-  return min
-};
-var minSatisfying_1 = minSatisfying$1;
-
-const SemVer$2 = semver$1;
-const Range$5 = range;
-const gt$2 = gt_1;
-
-const minVersion$1 = (range, loose) => {
-  range = new Range$5(range, loose);
-
-  let minver = new SemVer$2('0.0.0');
-  if (range.test(minver)) {
-    return minver
-  }
-
-  minver = new SemVer$2('0.0.0-0');
-  if (range.test(minver)) {
-    return minver
-  }
-
-  minver = null;
-  for (let i = 0; i < range.set.length; ++i) {
-    const comparators = range.set[i];
-
-    let setMin = null;
-    comparators.forEach((comparator) => {
-      // Clone to avoid manipulating the comparator's semver object.
-      const compver = new SemVer$2(comparator.semver.version);
-      switch (comparator.operator) {
-        case '>':
-          if (compver.prerelease.length === 0) {
-            compver.patch++;
-          } else {
-            compver.prerelease.push(0);
-          }
-          compver.raw = compver.format();
-          /* fallthrough */
-        case '':
-        case '>=':
-          if (!setMin || gt$2(compver, setMin)) {
-            setMin = compver;
-          }
-          break
-        case '<':
-        case '<=':
-          /* Ignore maximum versions */
-          break
-        /* istanbul ignore next */
-        default:
-          throw new Error(`Unexpected operation: ${comparator.operator}`)
-      }
-    });
-    if (setMin && (!minver || gt$2(minver, setMin))) {
-      minver = setMin;
-    }
-  }
-
-  if (minver && range.test(minver)) {
-    return minver
-  }
-
-  return null
-};
-var minVersion_1 = minVersion$1;
-
-const Range$4 = range;
-const validRange$1 = (range, options) => {
-  try {
-    // Return '*' instead of '' so that truthiness works.
-    // This will throw if it's invalid anyway
-    return new Range$4(range, options).range || '*'
-  } catch (er) {
-    return null
-  }
-};
-var valid$1 = validRange$1;
-
-const SemVer$1 = semver$1;
-const Comparator$2 = comparator;
-const { ANY: ANY$1 } = Comparator$2;
-const Range$3 = range;
-const satisfies$3 = satisfies_1;
-const gt$1 = gt_1;
-const lt$1 = lt_1;
-const lte$1 = lte_1;
-const gte$1 = gte_1;
-
-const outside$3 = (version, range, hilo, options) => {
-  version = new SemVer$1(version, options);
-  range = new Range$3(range, options);
-
-  let gtfn, ltefn, ltfn, comp, ecomp;
-  switch (hilo) {
-    case '>':
-      gtfn = gt$1;
-      ltefn = lte$1;
-      ltfn = lt$1;
-      comp = '>';
-      ecomp = '>=';
-      break
-    case '<':
-      gtfn = lt$1;
-      ltefn = gte$1;
-      ltfn = gt$1;
-      comp = '<';
-      ecomp = '<=';
-      break
-    default:
-      throw new TypeError('Must provide a hilo val of "<" or ">"')
-  }
-
-  // If it satisfies the range it is not outside
-  if (satisfies$3(version, range, options)) {
-    return false
-  }
-
-  // From now on, variable terms are as if we're in "gtr" mode.
-  // but note that everything is flipped for the "ltr" function.
-
-  for (let i = 0; i < range.set.length; ++i) {
-    const comparators = range.set[i];
-
-    let high = null;
-    let low = null;
-
-    comparators.forEach((comparator) => {
-      if (comparator.semver === ANY$1) {
-        comparator = new Comparator$2('>=0.0.0');
-      }
-      high = high || comparator;
-      low = low || comparator;
-      if (gtfn(comparator.semver, high.semver, options)) {
-        high = comparator;
-      } else if (ltfn(comparator.semver, low.semver, options)) {
-        low = comparator;
-      }
-    });
-
-    // If the edge version comparator has a operator then our version
-    // isn't outside it
-    if (high.operator === comp || high.operator === ecomp) {
-      return false
-    }
-
-    // If the lowest version comparator has an operator and our version
-    // is less than it then it isn't higher than the range
-    if ((!low.operator || low.operator === comp) &&
-        ltefn(version, low.semver)) {
-      return false
-    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
-      return false
-    }
-  }
-  return true
-};
-
-var outside_1 = outside$3;
-
-// Determine if version is greater than all the versions possible in the range.
-const outside$2 = outside_1;
-const gtr$1 = (version, range, options) => outside$2(version, range, '>', options);
-var gtr_1 = gtr$1;
-
-const outside$1 = outside_1;
-// Determine if version is less than all the versions possible in the range
-const ltr$1 = (version, range, options) => outside$1(version, range, '<', options);
-var ltr_1 = ltr$1;
-
-const Range$2 = range;
-const intersects$1 = (r1, r2, options) => {
-  r1 = new Range$2(r1, options);
-  r2 = new Range$2(r2, options);
-  return r1.intersects(r2)
-};
-var intersects_1 = intersects$1;
-
-// given a set of versions and a range, create a "simplified" range
-// that includes the same versions that the original range does
-// If the original range is shorter than the simplified one, return that.
-const satisfies$2 = satisfies_1;
-const compare$2 = compare_1;
-var simplify = (versions, range, options) => {
-  const set = [];
-  let first = null;
-  let prev = null;
-  const v = versions.sort((a, b) => compare$2(a, b, options));
-  for (const version of v) {
-    const included = satisfies$2(version, range, options);
-    if (included) {
-      prev = version;
-      if (!first) {
-        first = version;
-      }
-    } else {
-      if (prev) {
-        set.push([first, prev]);
-      }
-      prev = null;
-      first = null;
-    }
-  }
-  if (first) {
-    set.push([first, null]);
-  }
-
-  const ranges = [];
-  for (const [min, max] of set) {
-    if (min === max) {
-      ranges.push(min);
-    } else if (!max && min === v[0]) {
-      ranges.push('*');
-    } else if (!max) {
-      ranges.push(`>=${min}`);
-    } else if (min === v[0]) {
-      ranges.push(`<=${max}`);
-    } else {
-      ranges.push(`${min} - ${max}`);
-    }
-  }
-  const simplified = ranges.join(' || ');
-  const original = typeof range.raw === 'string' ? range.raw : String(range);
-  return simplified.length < original.length ? simplified : range
-};
-
-const Range$1 = range;
-const Comparator$1 = comparator;
-const { ANY } = Comparator$1;
-const satisfies$1 = satisfies_1;
-const compare$1 = compare_1;
-
-// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
-// - Every simple range `r1, r2, ...` is a null set, OR
-// - Every simple range `r1, r2, ...` which is not a null set is a subset of
-//   some `R1, R2, ...`
-//
-// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
-// - If c is only the ANY comparator
-//   - If C is only the ANY comparator, return true
-//   - Else if in prerelease mode, return false
-//   - else replace c with `[>=0.0.0]`
-// - If C is only the ANY comparator
-//   - if in prerelease mode, return true
-//   - else replace C with `[>=0.0.0]`
-// - Let EQ be the set of = comparators in c
-// - If EQ is more than one, return true (null set)
-// - Let GT be the highest > or >= comparator in c
-// - Let LT be the lowest < or <= comparator in c
-// - If GT and LT, and GT.semver > LT.semver, return true (null set)
-// - If any C is a = range, and GT or LT are set, return false
-// - If EQ
-//   - If GT, and EQ does not satisfy GT, return true (null set)
-//   - If LT, and EQ does not satisfy LT, return true (null set)
-//   - If EQ satisfies every C, return true
-//   - Else return false
-// - If GT
-//   - If GT.semver is lower than any > or >= comp in C, return false
-//   - If GT is >=, and GT.semver does not satisfy every C, return false
-//   - If GT.semver has a prerelease, and not in prerelease mode
-//     - If no C has a prerelease and the GT.semver tuple, return false
-// - If LT
-//   - If LT.semver is greater than any < or <= comp in C, return false
-//   - If LT is <=, and LT.semver does not satisfy every C, return false
-//   - If GT.semver has a prerelease, and not in prerelease mode
-//     - If no C has a prerelease and the LT.semver tuple, return false
-// - Else return true
-
-const subset$1 = (sub, dom, options = {}) => {
-  if (sub === dom) {
-    return true
-  }
-
-  sub = new Range$1(sub, options);
-  dom = new Range$1(dom, options);
-  let sawNonNull = false;
-
-  OUTER: for (const simpleSub of sub.set) {
-    for (const simpleDom of dom.set) {
-      const isSub = simpleSubset(simpleSub, simpleDom, options);
-      sawNonNull = sawNonNull || isSub !== null;
-      if (isSub) {
-        continue OUTER
-      }
-    }
-    // the null set is a subset of everything, but null simple ranges in
-    // a complex range should be ignored.  so if we saw a non-null range,
-    // then we know this isn't a subset, but if EVERY simple range was null,
-    // then it is a subset.
-    if (sawNonNull) {
-      return false
-    }
-  }
-  return true
-};
-
-const simpleSubset = (sub, dom, options) => {
-  if (sub === dom) {
-    return true
-  }
-
-  if (sub.length === 1 && sub[0].semver === ANY) {
-    if (dom.length === 1 && dom[0].semver === ANY) {
-      return true
-    } else if (options.includePrerelease) {
-      sub = [new Comparator$1('>=0.0.0-0')];
-    } else {
-      sub = [new Comparator$1('>=0.0.0')];
-    }
-  }
-
-  if (dom.length === 1 && dom[0].semver === ANY) {
-    if (options.includePrerelease) {
-      return true
-    } else {
-      dom = [new Comparator$1('>=0.0.0')];
-    }
-  }
-
-  const eqSet = new Set();
-  let gt, lt;
-  for (const c of sub) {
-    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);
-    }
-  }
-
-  if (eqSet.size > 1) {
-    return null
-  }
-
-  let gtltComp;
-  if (gt && lt) {
-    gtltComp = compare$1(gt.semver, lt.semver, options);
-    if (gtltComp > 0) {
-      return null
-    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
-      return null
-    }
-  }
-
-  // will iterate one or zero times
-  for (const eq of eqSet) {
-    if (gt && !satisfies$1(eq, String(gt), options)) {
-      return null
-    }
-
-    if (lt && !satisfies$1(eq, String(lt), options)) {
-      return null
-    }
-
-    for (const c of dom) {
-      if (!satisfies$1(eq, String(c), options)) {
-        return false
-      }
-    }
-
-    return true
-  }
-
-  let higher, lower;
-  let hasDomLT, hasDomGT;
-  // if the subset has a prerelease, we need a comparator in the superset
-  // with the same tuple and a prerelease, or it's not a subset
-  let needDomLTPre = lt &&
-    !options.includePrerelease &&
-    lt.semver.prerelease.length ? lt.semver : false;
-  let needDomGTPre = gt &&
-    !options.includePrerelease &&
-    gt.semver.prerelease.length ? gt.semver : false;
-  // exception: <1.2.3-0 is the same as <1.2.3
-  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
-      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
-    needDomLTPre = false;
-  }
-
-  for (const c of dom) {
-    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=';
-    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=';
-    if (gt) {
-      if (needDomGTPre) {
-        if (c.semver.prerelease && c.semver.prerelease.length &&
-            c.semver.major === needDomGTPre.major &&
-            c.semver.minor === needDomGTPre.minor &&
-            c.semver.patch === needDomGTPre.patch) {
-          needDomGTPre = false;
-        }
-      }
-      if (c.operator === '>' || c.operator === '>=') {
-        higher = higherGT(gt, c, options);
-        if (higher === c && higher !== gt) {
-          return false
-        }
-      } else if (gt.operator === '>=' && !satisfies$1(gt.semver, String(c), options)) {
-        return false
-      }
-    }
-    if (lt) {
-      if (needDomLTPre) {
-        if (c.semver.prerelease && c.semver.prerelease.length &&
-            c.semver.major === needDomLTPre.major &&
-            c.semver.minor === needDomLTPre.minor &&
-            c.semver.patch === needDomLTPre.patch) {
-          needDomLTPre = false;
-        }
-      }
-      if (c.operator === '<' || c.operator === '<=') {
-        lower = lowerLT(lt, c, options);
-        if (lower === c && lower !== lt) {
-          return false
-        }
-      } else if (lt.operator === '<=' && !satisfies$1(lt.semver, String(c), options)) {
-        return false
-      }
-    }
-    if (!c.operator && (lt || gt) && gtltComp !== 0) {
-      return false
-    }
-  }
-
-  // if there was a < or >, and nothing in the dom, then must be false
-  // UNLESS it was limited by another range in the other direction.
-  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
-  if (gt && hasDomLT && !lt && gtltComp !== 0) {
-    return false
-  }
-
-  if (lt && hasDomGT && !gt && gtltComp !== 0) {
-    return false
-  }
-
-  // we needed a prerelease range in a specific tuple, but didn't get one
-  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
-  // because it includes prereleases in the 1.2.3 tuple
-  if (needDomGTPre || needDomLTPre) {
-    return false
-  }
-
-  return true
-};
-
-// >=1.2.3 is lower than >1.2.3
-const higherGT = (a, b, options) => {
-  if (!a) {
-    return b
-  }
-  const comp = compare$1(a.semver, b.semver, options);
-  return comp > 0 ? a
-    : comp < 0 ? b
-    : b.operator === '>' && a.operator === '>=' ? b
-    : a
-};
-
-// <=1.2.3 is higher than <1.2.3
-const lowerLT = (a, b, options) => {
-  if (!a) {
-    return b
-  }
-  const comp = compare$1(a.semver, b.semver, options);
-  return comp < 0 ? a
-    : comp > 0 ? b
-    : b.operator === '<' && a.operator === '<=' ? b
-    : a
-};
-
-var subset_1 = subset$1;
-
-// just pre-load all the stuff that index.js lazily exports
-const internalRe = re$5.exports;
-const constants = constants$1;
-const SemVer = semver$1;
-const identifiers = identifiers$1;
-const parse = parse_1;
-const valid = valid_1;
-const clean = clean_1;
-const inc = inc_1;
-const diff = diff_1;
-const major = major_1;
-const minor = minor_1;
-const patch = patch_1;
-const prerelease = prerelease_1;
-const compare = compare_1;
-const rcompare = rcompare_1;
-const compareLoose = compareLoose_1;
-const compareBuild = compareBuild_1;
-const sort = sort_1;
-const rsort = rsort_1;
-const gt = gt_1;
-const lt = lt_1;
-const eq = eq_1;
-const neq = neq_1;
-const gte = gte_1;
-const lte = lte_1;
-const cmp = cmp_1;
-const coerce = coerce_1;
-const Comparator = comparator;
-const Range = range;
-const satisfies = satisfies_1;
-const toComparators = toComparators_1;
-const maxSatisfying = maxSatisfying_1;
-const minSatisfying = minSatisfying_1;
-const minVersion = minVersion_1;
-const validRange = valid$1;
-const outside = outside_1;
-const gtr = gtr_1;
-const ltr = ltr_1;
-const intersects = intersects_1;
-const simplifyRange = simplify;
-const subset = subset_1;
-var semver = {
-  parse,
-  valid,
-  clean,
-  inc,
-  diff,
-  major,
-  minor,
-  patch,
-  prerelease,
-  compare,
-  rcompare,
-  compareLoose,
-  compareBuild,
-  sort,
-  rsort,
-  gt,
-  lt,
-  eq,
-  neq,
-  gte,
-  lte,
-  cmp,
-  coerce,
-  Comparator,
-  Range,
-  satisfies,
-  toComparators,
-  maxSatisfying,
-  minSatisfying,
-  minVersion,
-  validRange,
-  outside,
-  gtr,
-  ltr,
-  intersects,
-  simplifyRange,
-  subset,
-  SemVer,
-  re: internalRe.re,
-  src: internalRe.src,
-  tokens: internalRe.t,
-  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
-  compareIdentifiers: identifiers.compareIdentifiers,
-  rcompareIdentifiers: identifiers.rcompareIdentifiers,
-};
+var satisfies_1 = satisfies;
 
 function checkVersion(threshold, version) {
   if (!version)
     return false;
-  const parsedVersion = semver.coerce(version);
+  const parsedVersion = coerce_1(version);
   if (parsedVersion === null)
     return false;
-  return semver.satisfies(parsedVersion, threshold);
+  return satisfies_1(parsedVersion, threshold);
 }
 
 function findArgument(args, name) {