@dbmx/confy 0.0.77 → 0.0.80

package/esm/node_modules/@dbmx/semver/dist/index.esm.js

@@ -1,958 +0,0 @@
-import LRU from '../node_modules/lru-cache/index.js';
-
-const MAX_LENGTH = 256;
-const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
-
-const numeric = /^[0-9]+$/;
-
-const compareIdentifiers = (a, b) => {
-  const anum = numeric.test(a);
-  const bnum = numeric.test(b);
-
-  if (anum && bnum) {
-    a = +a;
-    b = +b;
-  }
-
-  return a === b ? 0
-    : (anum && !bnum) ? -1
-    : (bnum && !anum) ? 1
-    : a < b ? -1
-    : 1
-};
-
-class SemVerError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-  }
-}
-
-const re = [];
-const src = [];
-const t = {};
-let R = 0;
-
-const createToken = (name, value, isGlobal) => {
-  const index = R++;
-  t[name] = index;
-  src[index] = value;
-  re[index] = new RegExp(value, undefined);
-};
-
-// The following Regular Expressions can be used for tokenizing,
-// validating, and parsing SemVer version strings.
-
-// ## Numeric Identifier
-// A single `0`, or a non-zero digit followed by zero or more digits.
-
-createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
-
-// ## Non-numeric Identifier
-// Zero or more digits, followed by a letter or hyphen, and then zero or
-// more letters, digits, or hyphens.
-
-createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*');
-
-// ## Main Version
-// Three dot-separated numeric identifiers.
-
-createToken(
-  'MAINVERSION',
-  `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})(?:\\.` + `(${src[t.NUMERICIDENTIFIER]}))?`,
-);
-
-// ## Pre-release Version Identifier
-// A numeric identifier, or a non-numeric identifier.
-
-createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
-
-// ## Pre-release Version
-// Hyphen, followed by one or more dot-separated pre-release version
-// identifiers.
-
-createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
-
-// ## Build Metadata Identifier
-// Any combination of digits, letters, or hyphens.
-
-createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+');
-
-// ## Build Metadata
-// Plus sign, followed by one or more period-separated build metadata
-// identifiers.
-
-createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
-
-// ## Full Version String
-// A main version, followed optionally by a pre-release version and
-// build metadata.
-
-// Note that the only major, minor, patch, and pre-release sections of
-// the version string are capturing groups.  The build metadata is not a
-// capturing group, because it should not ever be used in version
-// comparison.
-
-createToken('FULLPLAIN', `${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
-
-createToken('FULL', `^${src[t.FULLPLAIN]}$`);
-
-createToken('GTLT', '((?:<|>)?=?)');
-
-// A simple gt/lt/eq thing, or just "" to indicate "any version"
-createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
-
-/**
- * Represents a Semantic Version (SemVer) object
- *
- * @function SemVer
- * @tag semver
- * @param {string} - Version to parse
- * @throws {SemVerError} - Throws an error if the provided version is invalid
- * @example
- *
- * expect(SemVer('1.0').parts()).toEqual(2)
- * expect(SemVer('1.0.1').parts()).toEqual(3)
- * expect(SemVer('1.0.1-draft').parts()).toEqual(4)
- * expect(SemVer('1.0').isNonVersioned()).toBeTruthy()
- * expect(SemVer('1.0.1').isNonVersioned()).toBeFalsy()
- *
- * expect(SemVer('1.0').is2Parts()).toBeTruthy()
- * expect(SemVer('1.0').patch).toEqual(null)
- * expect(SemVer('1.0.0').patch).toEqual(0)
- * expect(SemVer('1.0.0').is2Parts()).toBeFalsy()
- * expect(SemVer('1.0.0-draft.1').extension).toEqual('draft.1')
- * expect(() => SemVer('1.0-draft.1')).toThrow(/Invalid version/)
- *
- * expect(SemVer('1.0').isStable()).toBeFalsy()
- * expect(SemVer('0.1.2').isStable()).toBeFalsy()
- * expect(SemVer('3.1.2-draft').isStable()).toBeFalsy()
- * expect(SemVer('3.1.2').isStable()).toBeTruthy()
- *
- * expect(SemVer('1.0').compare('1.0')).toEqual(0)
- * expect(SemVer('1.1').compare('1.0')).toEqual(1)
- * expect(SemVer('1.0').compare('1.0.0')).toEqual(-1)
- * expect(SemVer('1.0.0-draft').compare('1.0')).toEqual(1)
- * expect(SemVer('1.2.1').compare('1.2.1')).toEqual(0)
- * expect(SemVer('1.2.2').compare('1.2.1')).toEqual(1)
- * expect(SemVer('1.2.2').compare('1.2.2-draft')).toEqual(1)
- * expect(SemVer('1.2.2-draft').compare('1.2.2-draft.1')).toEqual(-1)
- *
- */
-
-class SemVer {
-  constructor(version) {
-    if (version instanceof SemVer) {
-      version = version.version;
-    } else if (typeof version !== 'string') {
-      throw new SemVerError(`Invalid Version: ${JSON.stringify(version, null, 4)}`)
-    }
-
-    if (version.length > MAX_LENGTH) {
-      throw new SemVerError(`version is longer than ${MAX_LENGTH} characters`)
-    }
-
-    const m = version.trim().match(re[t.FULL]);
-
-    if (!m) {
-      throw new SemVerError(`Invalid Version: ${version}`)
-    }
-
-    // these are actually numbers
-    this.major = +m[1];
-    this.minor = +m[2];
-    this.patch = m[3] ? +m[3] : null;
-
-    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-      throw new SemVerError('Invalid major version')
-    }
-
-    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-      throw new SemVerError('Invalid minor version')
-    }
-
-    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-      throw new SemVerError('Invalid patch version')
-    }
-
-    this.extension = m[4] || null;
-
-    if (this.patch === null && this.extension) {
-      throw new SemVerError('Invalid version')
-    }
-
-    this.format();
-  }
-
-  is2Parts() {
-    return this.patch === null
-  }
-
-  parts() {
-    return this.extension === null ? (this.patch === null ? 2 : 3) : 4
-  }
-
-  isNonVersioned() {
-    return this.parts() === 2
-  }
-
-  isStable() {
-    return !this.extension && this.major > 0 && !this.is2Parts()
-  }
-
-  format() {
-    this.version = this.is2Parts() ? `${this.major}.${this.minor}` : `${this.major}.${this.minor}.${this.patch}`;
-    if (this.extension) this.version += `-${this.extension}`;
-    return this.version
-  }
-
-  toString() {
-    return this.version
-  }
-
-  compare(other) {
-    if (!(other instanceof SemVer)) {
-      if (typeof other === 'string' && other === this.version) {
-        return 0
-      }
-      other = new SemVer(other);
-    }
-
-    if (other.version === this.version) {
-      return 0
-    }
-
-    return this.compareMain(other) || this.comparePre(other)
-  }
-
-  compareMain(other) {
-    if (!(other instanceof SemVer)) {
-      other = new SemVer(other);
-    }
-
-    return (
-      compareIdentifiers(this.major, other.major) ||
-      compareIdentifiers(this.minor, other.minor) ||
-      this.comparePatch(other)
-    )
-  }
-
-  comparePatch(other) {
-    if (this.patch === other.patch) return 0
-    // if (this.is2Parts() && other.patch === 0) return 0
-    if (this.is2Parts()) return -1
-    if (other.is2Parts()) return 1
-    return compareIdentifiers(this.patch, other.patch)
-  }
-
-  comparePre(other) {
-    if (!(other instanceof SemVer)) {
-      other = new SemVer(other);
-    }
-
-    // NOT having a extension is > having one
-    if (this.extension && !other.extension) {
-      return -1
-    } else if (!this.extension && other.extension) {
-      return 1
-    } else if (!this.extension && !other.extension) {
-      return 0
-    }
-
-    let i = 0;
-    do {
-      const a = this.extension[i];
-      const b = other.extension[i];
-      if (a === undefined && b === undefined) {
-        return 0
-      } else if (b === undefined) {
-        return 1
-      } else if (a === undefined) {
-        return -1
-      } else if (a === b) {
-        continue
-      } else {
-        return compareIdentifiers(a, b)
-      }
-    } while (++i)
-  }
-}
-
-var SemVer$1 = version => new SemVer(version);
-
-/**
- * Compares two version strings or SemVer instances
- *
- * @function compare
- * @tag core
- * @param {string|SemVer} - First version string or SemVer instance (a)
- * @param {string|SemVer} - Second version string or SemVer instance (b)
- * @return {number} - Returns 0 if versions are equal, 1 if `a` is greater than `b`, and -1 if `a` is less than `b`
- * @example
- *
- * compare('1.0.0', '1.2.0'); // -1
- * compare('1.2.0', '1.2.0'); // 0
- * compare('2.0.0', '1.2.0'); // 1
- */
-
-const compare = (a, b) => SemVer$1(a).compare(SemVer$1(b));
-
-/**
- * Checks if two version strings or SemVer instances are equal
- *
- * @function eq
- * @tag core
- * @param {string|SemVer} - First version string or SemVer instance
- * @param {string|SemVer} - Second version string or SemVer instance
- * @return {boolean} - Returns true if the versions are equal, otherwise false
- * @example
- *
- * eq('1.0.0', '1.0.0'); // true
- * eq('1.0.0', '1.2.0'); // false
- */
-
-const eq = (a, b) => compare(a, b) === 0;
-
-/**
- * Checks if two version strings or SemVer instances are not equal
- *
- * @function neq
- * @tag core
- * @param {string|SemVer} - First version string or SemVer instance
- * @param {string|SemVer} - Second version string or SemVer instance
- * @return {boolean} - Returns true if the versions are not equal, otherwise false
- * @example
- *
- * neq('1.0.0', '1.0.0'); // false
- * neq('1.0.0', '1.2.0'); // true
- */
-
-const neq = (a, b) => compare(a, b) !== 0;
-
-/**
- * Checks if the first version string or SemVer instance is greater than the second
- *
- * @function gt
- * @tag core
- * @param {string|SemVer} - First version string or SemVer instance (a)
- * @param {string|SemVer} - Second version string or SemVer instance (b)
- * @return {boolean} - Returns true if `a` is greater than `b`, otherwise false
- * @example
- *
- * gt('1.2.0', '1.0.0'); // true
- * gt('1.0.0', '1.2.0'); // false
- */
-
-const gt = (a, b) => compare(a, b) > 0;
-
-/**
- * Checks if the first version string or SemVer instance is greater than or equal to the second
- *
- * @function gte
- * @tag core
- * @param {string|SemVer} - First version string or SemVer instance (a)
- * @param {string|SemVer} - Second version string or SemVer instance (b)
- * @return {boolean} - Returns true if `a` is greater than or equal `b`, otherwise false
- * @example
- *
- * gte('1.2.0', '1.0.0'); // true
- * gte('1.0.0', '1.2.0'); // false
- * gte('1.2.0', '1.2.0'); // true
- */
-
-const gte = (a, b) => compare(a, b) >= 0;
-
-/**
- * Checks if the first version string or SemVer instance is less than the second
- *
- * @function lt
- * @tag core
- * @param {string|SemVer} - First version string or SemVer instance (a)
- * @param {string|SemVer} - Second version string or SemVer instance (b)
- * @return {boolean} - Returns true if `a` is less than `b`, otherwise false
- * @example
- *
- * lt('1.0.0', '1.2.0'); // true
- * lt('1.2.0', '1.0.0'); // false
- */
-
-const lt = (a, b) => compare(a, b) < 0;
-
-/**
- * Checks if the first version string or SemVer instance is less than or equal to the second
- *
- * @function lte
- * @tag core
- * @param {string|SemVer} - First version string or SemVer instance (a)
- * @param {string|SemVer} - Second version string or SemVer instance (b)
- * @return {boolean} - Returns true if `a` is less than or equal than `b`, otherwise false
- * @example
- *
- * lte('1.0.0', '1.2.0'); // true
- * lte('1.2.0', '1.0.0'); // false
- * lte('1.2.0', '1.2.0'); // true
- */
-
-const lte = (a, b) => compare(a, b) <= 0;
-
-/**
- * Performs comparison operations between version strings or SemVer instances
- *
- * @function cmp
- * @tag core
- * @param {string|SemVer} - First version string or SemVer instance
- * @param {string} - Comparison operator ('===', '!==', '=', '==', '!=', '>', '>=', '<', '<=')
- * @param {string|SemVer} - Second version string or SemVer instance
- * @return {boolean} - Returns true if the comparison operation is true, otherwise false.
- * @throws {SemVerError} - Throws an error if the comparison operator is invalid.
- * @example
- *
- * cmp('1.0.0', '===', '1.0.0'); // true
- * cmp('1.0.0', '!=', '1.0.1'); // true
- * cmp('1.2.0', '>', '1.0.0'); // true
- */
-
-var cmp = (a, op, b) => {
-  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)
-
-    case '!=':
-      return neq(a, b)
-
-    case '>':
-      return gt(a, b)
-
-    case '>=':
-      return gte(a, b)
-
-    case '<':
-      return lt(a, b)
-
-    case '<=':
-      return lte(a, b)
-
-    default:
-      throw new SemVerError(`Invalid operator: ${op}`)
-  }
-};
-
-const ANY = Symbol('SemVer ANY');
-
-/**
- * Represents a comparator object used for version comparison
- *
- * @function Comparator
- * @param {string|Comparator} - Comparator string or another Comparator object
- * @throw {SemVerError} - Throws an error if the provided comparator is invalid
- * @example
- *
- * Comparator('> 1.2.3')
- * Comparator('<= 1.2')
- * Comparator('= 1.21.3-draft')
- * Comparator('1.21.3-draft')
- *
- */
-
-class Comparator {
-  static get ANY() {
-    return ANY
-  }
-
-  constructor(comp) {
-    if (comp instanceof Comparator) {
-      comp = comp.value;
-    }
-
-    this.parse(comp);
-
-    if (this.semver === ANY) {
-      this.value = '';
-    } else {
-      this.value = this.operator + this.semver.version;
-    }
-  }
-
-  parse(comp) {
-    const r = re[t.COMPARATOR];
-    const m = comp.match(r);
-
-    if (!m) {
-      throw new SemVerError(`Invalid comparator: ${comp}`)
-    }
-
-    this.operator = m[1] !== undefined ? m[1] : '';
-    if (this.operator === '=') {
-      this.operator = '';
-    }
-
-    this.semver = SemVer$1(m[2]);
-  }
-
-  toString() {
-    return this.value
-  }
-
-  test(version) {
-    // if (this.semver === ANY || version === ANY) {
-    //   return true
-    // }
-
-    if (typeof version === 'string') {
-      try {
-        version = SemVer$1(version);
-      } catch (err) {
-        return false
-      }
-    }
-
-    return cmp(version, this.operator, this.semver)
-  }
-
-  intersects(comp) {
-    if (!(comp instanceof Comparator)) {
-      throw new SemVerError('a Comparator is required')
-    }
-
-    if (this.operator === '') {
-      if (this.value === '') {
-        return true
-      }
-      return Range$1(comp.value).test(this.value)
-    } else if (comp.operator === '') {
-      if (comp.value === '') {
-        return true
-      }
-      return Range$1(this.value).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) &&
-      (this.operator === '>=' || this.operator === '>') &&
-      (comp.operator === '<=' || comp.operator === '<');
-    const oppositeDirectionsGreaterThan =
-      cmp(this.semver, '>', comp.semver) &&
-      (this.operator === '<=' || this.operator === '<') &&
-      (comp.operator === '>=' || comp.operator === '>');
-
-    return (
-      sameDirectionIncreasing ||
-      sameDirectionDecreasing ||
-      (sameSemVer && differentDirectionsInclusive) ||
-      oppositeDirectionsLessThan ||
-      oppositeDirectionsGreaterThan
-    )
-  }
-}
-
-var Comparator$1 = comp => new Comparator(comp);
-
-const cache = new LRU({ max: 1000 });
-
-const NUM = '0|[1-9]\\d*';
-
-const RANGE_TYPE = {
-  ONE: 'one',
-  MANY: 'many',
-  LATEST: 'latest',
-};
-
-const matchSemVer = (string, map) => regexp => {
-  const res = string.match(regexp);
-  if (!res) return () => false
-  const result = () => true;
-  for (const [key, pos, def = 0] of map) {
-    result[key] = res[pos] || def;
-  }
-  return result
-};
-
-// take a set of comparators and determine whether there
-// exists a version which can satisfy it
-const isSatisfiable = comparators => {
-  let result = true;
-  const remainingComparators = comparators.slice();
-  let testComparator = remainingComparators.pop();
-
-  while (result && remainingComparators.length) {
-    result = remainingComparators.every(otherComparator => {
-      return testComparator.intersects(otherComparator)
-    });
-
-    testComparator = remainingComparators.pop();
-  }
-
-  return result
-};
-
-/**
- * Represents a range of versions for semantic versioning
- *
- * @function Range
- * @tag range
- * @param {string} - Version range
- * @throws {SemVerError} - Throws an error if the provided range is invalid
- * @example
- *
- * expect(() => Range('wrong range')).toThrow()
- * expect(Range('1.0').test('1.0')).toBeTruthy()
- * expect(Range('1.0').test('1.0.0')).toBeFalsy()
- *
- * expect(Range('~').toString()).toEqual('>=0.0.0-0')
- * expect(Range('~').test('1.2.3-draft')).toBeTruthy()
- * expect(Range('1.~').test('1.2.3-draft')).toBeFalsy()
- *
- * expect(Range('+').toString()).toEqual('>=1.0.0')
- * expect(Range('+').test('1.2.3-draft')).toBeFalsy()
- * expect(Range('1.0.+').test('1.0.3')).toBeTruthy()
- *
- * expect(Range('*').test('1.0')).toBeTruthy()
- * expect(Range('*').test('1.0.0-draft')).toBeTruthy()
- * expect(Range('1.*').test('1.1.3')).toBeFalsy()
- *
- * expect(Range('1~.2.0').test('4.3.2')).toBeTruthy()
- * expect(Range('1~.2.0').test('4.3.2-draft')).toBeTruthy()
- * expect(Range('1.2~.0').toString()).toEqual('>=1.2.0-0 <2.0.0-0')
- *
- */
-class Range {
-  constructor(range) {
-    if (range instanceof Range) return new Range(range.raw)
-
-    if (range instanceof Comparator) {
-      this.raw = range.value;
-      this.set = [[range]];
-      this.format();
-      return this
-    }
-
-    this.raw = range;
-    const [type, set, subType] = this.makeRangeSet(range);
-    this.set = set;
-    this.type = type;
-    this.subType = subType;
-
-    if (!this.set.length) {
-      throw new SemVerError(`Invalid SemVer Range: ${range}`)
-    }
-
-    this.format();
-  }
-
-  get comparators() {
-    const res = [];
-    for (const a of this.set) {
-      for (const b of a) {
-        res.push(b);
-      }
-    }
-    return res
-  }
-
-  isMonoVersion() {
-    return this.type === RANGE_TYPE.ONE
-  }
-
-  isResolved() {
-    return this.isMonoVersion()
-  }
-
-  format() {
-    this.range = this.set
-      .map(comps => {
-        return comps.join(' ').trim()
-      })
-      .join('||')
-      .trim();
-    return this.range
-  }
-
-  toString() {
-    return this.range
-  }
-
-  makeRangeSet(range) {
-    range = range.trim();
-    const memoKey = `parseRange:${range}`;
-    const cached = cache.get(memoKey);
-    if (cached) return cached
-
-    range = range.replace(/\s+/, '');
-
-    const [type, comparators, subType] = makeComparators(range);
-    if (!comparators) return [null, []]
-
-    const set = comparators.map(comp => comp.split(/\s+/).map(comp => Comparator$1(comp)));
-
-    cache.set(memoKey, [type, set, subType]);
-    return [type, set, subType]
-  }
-
-  intersects(range) {
-    if (!(range instanceof Range)) {
-      throw new SemVerError('a Range is required')
-    }
-
-    return this.set.some(thisComparators => {
-      return (
-        isSatisfiable(thisComparators) &&
-        range.set.some(rangeComparators => {
-          return (
-            isSatisfiable(rangeComparators) &&
-            thisComparators.every(thisComparator => {
-              return rangeComparators.every(rangeComparator => {
-                return thisComparator.intersects(rangeComparator)
-              })
-            })
-          )
-        })
-      )
-    })
-  }
-
-  // if ANY of the sets match ALL of its comparators, then pass
-  test(version) {
-    if (!version) {
-      return false
-    }
-
-    if (typeof version === 'string') {
-      try {
-        version = SemVer$1(version);
-      } catch (er) {
-        return false
-      }
-    }
-
-    for (let i = 0; i < this.set.length; i++) {
-      if (testSet(this.set[i], version)) return true
-    }
-    return false
-  }
-}
-
-const RANGE_SUB_TYPE = {
-  RESOLVED: 'resolved',
-  STABLE: 'stable',
-  LATEST_STABLE: 'latest_stable',
-  LATEST_UNSTABLE: 'latest_unstable',
-  UNSTABLE: 'unstable',
-  ALL: 'all',
-  ABOVE: 'above',
-};
-
-const makeComparators = comp => {
-  let newComp;
-
-  newComp = checkSpecific(comp);
-  if (newComp) return [RANGE_TYPE.ONE, [newComp], RANGE_SUB_TYPE.RESOLVED]
-
-  newComp = checkOnlyStable(comp);
-  if (newComp) return [RANGE_TYPE.LATEST, [newComp], RANGE_SUB_TYPE.STABLE]
-
-  newComp = checkLatestStable(comp);
-  if (newComp) return [RANGE_TYPE.LATEST, [newComp], RANGE_SUB_TYPE.LATEST_STABLE]
-
-  newComp = checkLatestUnStable(comp);
-  if (newComp) return [RANGE_TYPE.LATEST, [newComp], RANGE_SUB_TYPE.LATEST_UNSTABLE]
-
-  newComp = checkPossibleUnstable(comp);
-  if (newComp) return [RANGE_TYPE.LATEST, [newComp], RANGE_SUB_TYPE.UNSTABLE]
-
-  newComp = checkAllVersions(comp);
-  if (newComp) return [RANGE_TYPE.MANY, newComp, RANGE_SUB_TYPE.ALL]
-
-  newComp = checkAllAboveVersions(comp);
-  if (newComp) return [RANGE_TYPE.MANY, newComp, RANGE_SUB_TYPE.ABOVE]
-
-  return []
-};
-
-const checkSpecific = comp => {
-  const res = comp.match(re[t.FULL]);
-  if (res) return comp
-};
-
-const checkAllVersions = comp => {
-  if (comp === '*') return ['>=0.0.0-0', '>=0.0']
-  const match = matchSemVer(comp, [
-    ['M', 1],
-    ['m', 2],
-    ['p', 3],
-  ]);
-  let r;
-
-  r = match(`^(${NUM})[.]([*])$`);
-  if (r()) return [`>=${r.M}.0 <${+r.M + 1}.0`]
-
-  r = match(`^(${NUM})[.]([*])[.](${NUM})$`);
-  if (r()) return [`>=${r.M}.0.0-0 <${+r.M + 1}.0.0-0`]
-
-  r = match(`^(${NUM})[.](${NUM})[.]([*])$`);
-  if (r()) return [`>=${r.M}.${r.m}.0-0 <${r.M}.${+r.m + 1}.0-0`]
-};
-
-const checkAllAboveVersions = comp => {
-  const match = matchSemVer(comp, [
-    ['M', 1],
-    ['m', 2],
-    ['p', 3],
-  ]);
-  let r;
-
-  r = match(`^(${NUM})[.](${NUM})[*]$`);
-  if (r()) return [`>=${r.M}.${r.m} <${+r.M + 1}.0`]
-
-  r = match(`^(${NUM})[.](${NUM})[*][.](${NUM})$`);
-  if (r()) return [`>=${r.M}.${r.m}.0-0 <${+r.M + 1}.0.0-0`]
-
-  r = match(`^(${NUM})[.](${NUM})[.](${NUM})[*]$`);
-  if (r()) return [`>=${r.M}.${r.m}.${r.p}-0 <${r.M}.${+r.m + 1}.0-0`]
-};
-
-const checkPossibleUnstable = comp => {
-  if (comp === '~') return `>=0.0.0-0`
-  const match = matchSemVer(comp, [
-    ['M', 1],
-    ['m', 2],
-    ['p', 3],
-  ]);
-  let r;
-
-  r = match(`^(${NUM})[.]([~])$`);
-  if (r()) return `>=${r.M}.0 <${+r.M + 1}.0`
-
-  r = match(`^(${NUM})[.]([~])[.](${NUM})$`);
-  if (r()) return `>=${r.M}.0.0-0 <${+r.M + 1}.0.0-0`
-
-  r = match(`^(${NUM})[.](${NUM})[.]([~])$`);
-  if (r()) return `>=${r.M}.${r.m}.0-0 <${r.M}.${+r.m + 1}.0-0`
-};
-
-const checkOnlyStable = comp => {
-  if (comp === '+') return `>=1.0.0`
-  const match = matchSemVer(comp, [
-    ['M', 1],
-    ['m', 2],
-    ['p', 3],
-  ]);
-
-  let r;
-
-  r = match(`^(${NUM})[.]([+])(?:[.](${NUM}))?$`);
-  if (r()) return `>=${r.M}.0.0 <${+r.M + 1}.0.0`
-
-  r = match(`^(${NUM})[.](${NUM})[.]([+])$`);
-  if (r()) return `>=${r.M}.${r.m}.0 <${r.M}.${+r.m + 1}.0`
-};
-
-const checkLatestStable = comp => {
-  const match = matchSemVer(comp, [
-    ['M', 1],
-    ['m', 2],
-    ['p', 3],
-  ]);
-
-  let r;
-  r = match(`^(${NUM})[+][.](${NUM})[.](${NUM})$`);
-  if (r()) return `>=${r.M}.${r.m}.${r.p}`
-
-  r = match(`^(${NUM})[.](${NUM})[+][.](${NUM})$`);
-  if (r()) return `>=${r.M}.${r.m}.${r.p} <${+r.M + 1}.0.0`
-
-  r = match(`^(${NUM})[.](${NUM})[.](${NUM})[+]$`);
-  if (r()) return `>=${r.M}.${r.m}.${r.p} <${r.M}.${+r.m + 1}.0`
-};
-
-const checkLatestUnStable = comp => {
-  const match = matchSemVer(comp, [
-    ['M', 1],
-    ['m', 2],
-    ['p', 3],
-  ]);
-
-  let r;
-  r = match(`^(${NUM})[~][.](${NUM})[.](${NUM})$`);
-  if (r()) return `>=${r.M}.${r.m}.${r.p}-0`
-
-  r = match(`^(${NUM})[.](${NUM})[~][.](${NUM})$`);
-  if (r()) return `>=${r.M}.${r.m}.${r.p}-0 <${+r.M + 1}.0.0-0`
-
-  r = match(`^(${NUM})[.](${NUM})[.](${NUM})[~]$`);
-  if (r()) return `>=${r.M}.${r.m}.${r.p}-0 <${r.M}.${+r.m + 1}.0-0`
-};
-
-const testSet = (set, version) => {
-  for (let i = 0; i < set.length; i++) {
-    if (set[i].semver.is2Parts() && !version.is2Parts()) return false
-    if (version.is2Parts() && !set[i].semver.is2Parts()) return false
-    if (set[i].semver.isStable() && !version.isStable()) return false
-    if (!set[i].test(version)) return false
-  }
-
-  return true
-};
-
-var Range$1 = range => new Range(range);
-
-/**
- * Represents a matcher object used for version matching
- *
- * @function Matcher
- * @tag matcher
- * @param {string} - Version string or range to create a matcher for
- * @throws {SemVerError} - Throws an error if the provided version or range is invalid
- * @example
- *
- * expect(() => Matcher('wrong range')).toThrow()
- * expect(Matcher('1.0').isMonoType()).toBeTruthy()
- * expect(Matcher('1.0.1').isMonoType()).toBeTruthy()
- * expect(Matcher('1.0.1').isResolved()).toBeTruthy()
- * expect(Matcher('1~.2.0').isLatestType()).toBeTruthy()
- * expect(() => Matcher('1.*')).toThrow()
- *
- */
-class Matcher {
-  constructor(value) {
-    this.raw = value;
-    this.range = Range$1(value);
-    if (this.range.type !== RANGE_TYPE.ONE && this.range.type !== RANGE_TYPE.LATEST)
-      throw new SemVerError(`Wrong version for matcher ${value}`)
-  }
-
-  isMonoType() {
-    return this.range.type === RANGE_TYPE.ONE
-  }
-
-  isResolved() {
-    return this.isMonoType()
-  }
-
-  isLatestType() {
-    return this.range.type === RANGE_TYPE.LATEST
-  }
-}
-
-var matcher = value => new Matcher(value);
-
-export { Comparator$1 as Comparator, matcher as Matcher, RANGE_TYPE, Range$1 as Range, SemVer$1 as SemVer, SemVerError };
-//# sourceMappingURL=index.esm.js.map