@dbmx/toasts 0.0.47 → 0.0.48

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

@@ -0,0 +1,584 @@
+'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;