@dbmx/toasts 0.0.38 → 0.0.40

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

@@ -1,584 +0,0 @@
-'use strict';
-
-var index = require('../../../lru-cache/index.cjs');
-
-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, isGlobal ? 'g' : 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]})$|^$`);
-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);
-const compare = (a, b) => SemVer$1(a).compare(SemVer$1(b));
-const eq = (a, b) => compare(a, b) === 0;
-const neq = (a, b) => compare(a, b) !== 0;
-const gt = (a, b) => compare(a, b) > 0;
-const gte = (a, b) => compare(a, b) >= 0;
-const lt = (a, b) => compare(a, b) < 0;
-const lte = (a, b) => compare(a, b) <= 0;
-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');
-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 index({
-  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;
-};
-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].test(version)) return false;
-    if (set[i].semver.isStable() && !version.isStable()) return false;
-    if (set[i].semver.is2Parts() && !version.is2Parts()) return false;
-  }
-  return true;
-};
-var Range$1 = range => new Range(range);
-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);
-class Dependency {
-  constructor(source, value) {
-    if (!value) throw new SemVerError(`Dependency version must be defined`);
-    if (!source?.version) throw new SemVerError(`Dependency source cannot be undefined`);
-    this.raw = value;
-    this.source = source;
-    this.range = Range$1(value);
-    const sVersion = SemVer$1(source.version);
-    if (!this.range.isResolved()) {
-      if (this.range.subType !== RANGE_SUB_TYPE.LATEST_STABLE) throw new SemVerError(`Wrong dependency ${value}`);
-      if (!sVersion.isStable()) {
-        this.range = Range$1(value.replace('+', '~'));
-      }
-    } else {
-      const tVersion = SemVer$1(value);
-      if (sVersion.isStable() && !tVersion.isStable()) throw new SemVerError(`Wrong dependency: Semantically  versioned  artefacts  MUST  only  reference  another  semantically versioned artefacts`);
-    }
-  }
-  isResolved() {
-    return this.range.type === RANGE_TYPE.ONE;
-  }
-}
-var dependency = (source, value) => new Dependency(source, value);
-const isValidDependency = (source, targetVersion) => {
-  try {
-    new Dependency(source, targetVersion);
-    return true;
-  } catch (err) {
-    return false;
-  }
-};
-
-exports.Comparator = Comparator$1;
-exports.Dependency = dependency;
-exports.Matcher = matcher;
-exports.RANGE_TYPE = RANGE_TYPE;
-exports.Range = Range$1;
-exports.SemVer = SemVer$1;
-exports.SemVerError = SemVerError;
-exports.isValidDependency = isValidDependency;