@dbmx/confy 0.0.80 → 0.0.84

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

@@ -0,0 +1,960 @@
+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.version) {
+      version = version.version;
+    }
+
+    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