semver-ts/dist/index.js

Tree-shakable, lightweight, drop-in replacement of semver with correct type definition

// src/constants.ts
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;

// src/regex.ts
var FULL = /^v?(0|[1-9]\d{0,256})\.(0|[1-9]\d{0,256})\.(0|[1-9]\d{0,256})(?:-((?:0|[1-9]\d{0,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\.(?:0|[1-9]\d{0,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*))?(?:\+([a-zA-Z0-9-]{1,250}(?:\.[a-zA-Z0-9-]{1,250})*))?$/;
var LOOSE = /^[v=\s]*(\d{1,256})\.(\d{1,256})\.(\d{1,256})(?:-?((?:\d{1,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\.(?:\d{1,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*))?(?:\+([a-zA-Z0-9-]{1,250}(?:\.[a-zA-Z0-9-]{1,250})*))?$/;
var COERCEFULL = /(^|[^\d])(\d{1,16})(?:\.(\d{1,16}))?(?:\.(\d{1,16}))?(?:(?:-((?:0|[1-9]\d{0,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\.(?:0|[1-9]\d{0,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*)))?(?:(?:\+([a-zA-Z0-9-]{1,250}(?:\.[a-zA-Z0-9-]{1,250})*)))?(?:$|[^\d])/;
var COERCE = /(^|[^\d])(\d{1,16})(?:\.(\d{1,16}))?(?:\.(\d{1,16}))?(?:$|[^\d])/;
var COERCERTLFULL = /(^|[^\d])(\d{1,16})(?:\.(\d{1,16}))?(?:\.(\d{1,16}))?(?:(?:-((?:0|[1-9]\d{0,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\.(?:0|[1-9]\d{0,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*)))?(?:(?:\+([a-zA-Z0-9-]{1,250}(?:\.[a-zA-Z0-9-]{1,250})*)))?(?:$|[^\d])/g;
var COERCERTL = /(^|[^\d])(\d{1,16})(?:\.(\d{1,16}))?(?:\.(\d{1,16}))?(?:$|[^\d])/g;
var PRERELEASE = /^(?:-((?:0|[1-9]\d{0,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\.(?:0|[1-9]\d{0,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*))$/;
var PRERELEASELOOSE = /^(?:-?((?:\d{1,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\.(?:\d{1,256}|\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*))$/;

// src/utils/parseOptions.ts
var parseOptions = (options) => {
  if (!options) {
    return false;
  } else if (typeof options !== "object") {
    return true;
  }
  return !!options.loose;
};
var parseOptions_default = parseOptions;

// src/utils/format.ts
var format = (major2, minor2, patch2, prerelease2, build) => {
  let version = `${major2}.${minor2}.${patch2}`;
  if (prerelease2.length) {
    version += `-${prerelease2.join(".")}`;
  }
  let fullVersion = version;
  if (build.length) {
    fullVersion += `+${build.join(".")}`;
  }
  return [version, fullVersion];
};
var format_default = format;

// src/functions/parse.ts
var MAX_LENGTH = 256;
var parseThrow = (ver, optionsOrLoose) => {
  if (typeof ver !== "string") {
    throw new TypeError(
      `Invalid version. Must be a string. Got type "${typeof ver}".`
    );
  }
  if (ver.length > MAX_LENGTH) {
    throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
  }
  const loose = parseOptions_default(optionsOrLoose);
  const m = ver.trim().match(loose ? LOOSE : FULL);
  if (!m) {
    throw new TypeError(`Invalid Version: ${ver}`);
  }
  const major2 = +m[1];
  const minor2 = +m[2];
  const patch2 = +m[3];
  if (major2 > MAX_SAFE_INTEGER || major2 < 0) {
    throw new TypeError("Invalid major version");
  }
  if (minor2 > MAX_SAFE_INTEGER || minor2 < 0) {
    throw new TypeError("Invalid minor version");
  }
  if (patch2 > MAX_SAFE_INTEGER || patch2 < 0) {
    throw new TypeError("Invalid patch version");
  }
  const prerelease2 = !m[4] ? [] : m[4].split(".").map((id) => {
    if (/^[0-9]+$/.test(id)) {
      const num = +id;
      if (num >= 0 && num < MAX_SAFE_INTEGER) {
        return num;
      }
    }
    return id;
  });
  const build = m[5] ? m[5].split(".") : [];
  const [version, fullVersion] = format_default(major2, minor2, patch2, prerelease2, build);
  return { version, fullVersion, major: major2, minor: minor2, patch: patch2, prerelease: prerelease2, build };
};
var parse = (ver, optionsOrLoose, throwErrors) => {
  try {
    return parseThrow(ver, optionsOrLoose);
  } catch (err) {
    if (!throwErrors) {
      return null;
    }
    throw err;
  }
};
var parse_default = parse;

// src/functions/clean.ts
var clean = (version, optionsOrLoose) => {
  const s = parse_default(version.trim().replace(/^[=v]+/, ""), optionsOrLoose);
  return s ? s.version : null;
};
var clean_default = clean;

// src/utils/compareIdentifiers.ts
var numericRegex = /^[0-9]+$/;
var compareIdentifiers = (a, b) => {
  let _a = a.toString();
  let _b = b.toString();
  const anum = numericRegex.test(_a);
  const bnum = numericRegex.test(_b);
  if (anum && bnum) {
    _a = +_a;
    _b = +_b;
  }
  return _a === _b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : _a < _b ? -1 : 1;
};
var compareIdentifiers_default = compareIdentifiers;

// src/functions/compareCore.ts
var compareMainCore = (parsedV1, parsedV2) => {
  return compareIdentifiers_default(parsedV1.major, parsedV2.major) || compareIdentifiers_default(parsedV1.minor, parsedV2.minor) || compareIdentifiers_default(parsedV1.patch, parsedV2.patch);
};
var comparePreCore = (prerelease1, prerelease2) => {
  if (prerelease1.length && !prerelease2.length) {
    return -1;
  }
  if (!prerelease1.length && prerelease2.length) {
    return 1;
  }
  if (!prerelease1.length && !prerelease2.length) {
    return 0;
  }
  let i = 0;
  while (true) {
    const a = prerelease1[i];
    const b = prerelease2[i];
    if (a === void 0 && b === void 0) {
      return 0;
    }
    if (b === void 0) {
      return 1;
    }
    if (a === void 0) {
      return -1;
    }
    if (a !== b) {
      return compareIdentifiers_default(a, b);
    }
    i++;
  }
};
var compareCore = (parsedV1, parsedV2) => {
  if (parsedV1.version === parsedV2.version) {
    return 0;
  }
  return compareMainCore(parsedV1, parsedV2) || comparePreCore(parsedV1.prerelease, parsedV2.prerelease);
};
var compareCore_default = compareCore;

// src/functions/compare.ts
var compare = (v1, v2, optionsOrLoose) => compareCore_default(parse_default(v1, optionsOrLoose, true), parse_default(v2, optionsOrLoose, true));
var compare_default = compare;

// src/functions/eq.ts
var eq = (v1, v2, optionsOrLoose) => compare_default(v1, v2, optionsOrLoose) === 0;
var eq_default = eq;

// src/functions/gt.ts
var gt = (v1, v2, optionsOrLoose) => compare_default(v1, v2, optionsOrLoose) > 0;
var gt_default = gt;

// src/functions/gte.ts
var gte = (v1, v2, optionsOrLoose) => compare_default(v1, v2, optionsOrLoose) >= 0;
var gte_default = gte;

// src/functions/lt.ts
var lt = (v1, v2, optionsOrLoose) => compare_default(v1, v2, optionsOrLoose) < 0;
var lt_default = lt;

// src/functions/lte.ts
var lte = (v1, v2, optionsOrLoose) => compare_default(v1, v2, optionsOrLoose) <= 0;
var lte_default = lte;

// src/functions/neq.ts
var neq = (v1, v2, optionsOrLoose) => compare_default(v1, v2, optionsOrLoose) !== 0;
var neq_default = neq;

// src/functions/cmp.ts
var cmp = (v1, operator, v2, optionsOrLoose) => {
  switch (operator) {
    case "===": {
      return v1 === v2;
    }
    case "!==": {
      return v1 !== v2;
    }
    case "":
    case "=":
    case "==": {
      return eq_default(v1, v2, optionsOrLoose);
    }
    case "!=": {
      return neq_default(v1, v2, optionsOrLoose);
    }
    case ">": {
      return gt_default(v1, v2, optionsOrLoose);
    }
    case ">=": {
      return gte_default(v1, v2, optionsOrLoose);
    }
    case "<": {
      return lt_default(v1, v2, optionsOrLoose);
    }
    case "<=": {
      return lte_default(v1, v2, optionsOrLoose);
    }
    default: {
      throw new TypeError(`Invalid operator: ${operator}`);
    }
  }
};

// src/functions/coerce.ts
var coerce = (version, options) => {
  let _version = version;
  if (typeof _version === "number") {
    _version = String(_version);
  }
  if (typeof _version !== "string") {
    return null;
  }
  options = options || {};
  let match = null;
  if (!options.rtl) {
    match = _version.match(options.includePrerelease ? COERCEFULL : COERCE);
  } else {
    const coerceRtlRegex = options.includePrerelease ? COERCERTLFULL : COERCERTL;
    let next;
    while ((next = coerceRtlRegex.exec(_version)) && (!match || match.index + match[0].length !== _version.length)) {
      if (!match || next.index + next[0].length !== match.index + match[0].length) {
        match = next;
      }
      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
    }
    coerceRtlRegex.lastIndex = -1;
  }
  if (match === null) {
    return null;
  }
  const major2 = match[2];
  const minor2 = match[3] || "0";
  const patch2 = match[4] || "0";
  const prerelease2 = options.includePrerelease && match[5] ? `-${match[5]}` : "";
  const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
  const parsed = parse_default(
    `${major2}.${minor2}.${patch2}${prerelease2}${build}`,
    options
  );
  return parsed ? parsed.fullVersion : null;
};
var coerce_default = coerce;

// src/functions/compareBuild.ts
var compareBuildCore = (build1, build2) => {
  let i = 0;
  while (true) {
    const a = build1[i];
    const b = build2[i];
    if (a === void 0 && b === void 0) {
      return 0;
    }
    if (b === void 0) {
      return 1;
    }
    if (a === void 0) {
      return -1;
    }
    if (a !== b) {
      return compareIdentifiers_default(a, b);
    }
    i++;
  }
};
var compareBuild = (v1, v2, optionsOrLoose) => {
  const parsedV1 = parse_default(v1, optionsOrLoose, true);
  const parsedV2 = parse_default(v2, optionsOrLoose, true);
  return compareCore_default(parsedV1, parsedV2) || compareBuildCore(parsedV1.build, parsedV2.build);
};
var compareBuild_default = compareBuild;

// src/functions/compareLoose.ts
var compareLoose = (v1, v2) => compare_default(v1, v2, true);
var compareLoose_default = compareLoose;

// src/functions/diff.ts
var diff = (version1, version2) => {
  const v1 = parse_default(version1, false, true);
  const v2 = parse_default(version2, false, true);
  const comparison = compareCore_default(v1, v2);
  if (comparison === 0) {
    return null;
  }
  const v1Higher = comparison > 0;
  const highVersion = v1Higher ? v1 : v2;
  const lowVersion = v1Higher ? v2 : v1;
  const highHasPre = !!highVersion.prerelease.length;
  const lowHasPre = !!lowVersion.prerelease.length;
  if (lowHasPre && !highHasPre) {
    if (!lowVersion.patch && !lowVersion.minor) {
      return "major";
    }
    if (compareMainCore(lowVersion, highVersion) === 0) {
      if (lowVersion.minor && !lowVersion.patch) {
        return "minor";
      }
      return "patch";
    }
  }
  const prefix = highHasPre ? "pre" : "";
  if (v1.major !== v2.major) {
    return prefix + "major";
  }
  if (v1.minor !== v2.minor) {
    return prefix + "minor";
  }
  if (v1.patch !== v2.patch) {
    return prefix + "patch";
  }
  return "prerelease";
};
var diff_default = diff;

// src/functions/inc.ts
var incCore = (parsedVersion, release, identifier, identifierBase, loose) => {
  if (release === 0 || release.startsWith("pre")) {
    if (!identifier && identifierBase === false) {
      throw new Error("invalid increment argument: identifier is empty");
    }
    if (identifier) {
      const r = loose ? PRERELEASELOOSE : PRERELEASE;
      const match = `-${identifier}`.match(r);
      if (!match || match[1] !== identifier) {
        throw new Error(`invalid identifier: ${identifier}`);
      }
    }
  }
  switch (release) {
    case "premajor":
      parsedVersion.prerelease.length = 0;
      parsedVersion.patch = 0;
      parsedVersion.minor = 0;
      parsedVersion.major++;
      incCore(parsedVersion, 0, identifier, identifierBase, loose);
      break;
    case "preminor":
      parsedVersion.prerelease.length = 0;
      parsedVersion.patch = 0;
      parsedVersion.minor++;
      incCore(parsedVersion, 0, identifier, identifierBase, loose);
      break;
    case "prepatch":
      parsedVersion.prerelease.length = 0;
      incCore(parsedVersion, "patch", identifier, identifierBase, loose);
      incCore(parsedVersion, 0, identifier, identifierBase, loose);
      break;
    // If the input is a non-prerelease version, this acts the same as
    // prepatch.
    case "prerelease":
      if (parsedVersion.prerelease.length === 0) {
        incCore(parsedVersion, "patch", identifier, identifierBase, loose);
      }
      incCore(parsedVersion, 0, identifier, identifierBase, loose);
      break;
    case "release":
      if (parsedVersion.prerelease.length === 0) {
        throw new Error(
          `version ${parsedVersion.fullVersion} is not a prerelease`
        );
      }
      parsedVersion.prerelease.length = 0;
      break;
    case "major":
      if (parsedVersion.minor !== 0 || parsedVersion.patch !== 0 || parsedVersion.prerelease.length === 0) {
        parsedVersion.major++;
      }
      parsedVersion.minor = 0;
      parsedVersion.patch = 0;
      parsedVersion.prerelease.length = 0;
      break;
    case "minor":
      if (parsedVersion.patch !== 0 || parsedVersion.prerelease.length === 0) {
        parsedVersion.minor++;
      }
      parsedVersion.patch = 0;
      parsedVersion.prerelease.length = 0;
      break;
    case "patch":
      if (parsedVersion.prerelease.length === 0) {
        parsedVersion.patch++;
      }
      parsedVersion.prerelease.length = 0;
      break;
    // This probably shouldn't be used publicly.
    // 1.0.0 `0` would become 1.0.0-0 which is the wrong direction.
    case 0: {
      const base = Number(identifierBase) ? 1 : 0;
      if (parsedVersion.prerelease.length === 0) {
        parsedVersion.prerelease = [base];
      } else {
        let i = parsedVersion.prerelease.length;
        while (--i >= 0) {
          if (typeof parsedVersion.prerelease[i] === "number") {
            parsedVersion.prerelease[i]++;
            i = -2;
          }
        }
        if (i === -1) {
          if (identifier === parsedVersion.prerelease.join(".") && identifierBase === false) {
            throw new Error(
              "invalid increment argument: identifier already exists"
            );
          }
          parsedVersion.prerelease.push(base);
        }
      }
      if (identifier) {
        let prerelease3 = [identifier, base];
        if (identifierBase === false) {
          prerelease3 = [identifier];
        }
        if (compareIdentifiers_default(parsedVersion.prerelease[0], identifier) === 0) {
          if (isNaN(parsedVersion.prerelease[1])) {
            parsedVersion.prerelease = prerelease3;
          }
        } else {
          parsedVersion.prerelease = prerelease3;
        }
      }
      break;
    }
    default:
      throw new Error(`invalid increment argument: ${release}`);
  }
  const { major: major2, minor: minor2, patch: patch2, prerelease: prerelease2, build } = parsedVersion;
  const [version, fullVersion] = format_default(major2, minor2, patch2, prerelease2, build);
  return {
    version,
    fullVersion,
    major: major2,
    minor: minor2,
    patch: patch2,
    prerelease: prerelease2,
    build
  };
};
function inc(version, release, options, identifier, identifierBase) {
  let _options = options;
  let _identifier = identifier;
  let _identifierBase = identifierBase;
  if (typeof _options === "string") {
    _identifierBase = _identifier;
    _identifier = _options;
    _options = void 0;
  }
  const loose = parseOptions_default(_options);
  try {
    return incCore(
      parse_default(version, _options, true),
      release,
      _identifier,
      _identifierBase,
      loose
    ).version;
  } catch (e) {
    return null;
  }
}
var incThrow = (version, release, identifier, identifierBase, optionsOrLoose) => {
  const loose = parseOptions_default(optionsOrLoose);
  return incCore(
    parse_default(version, optionsOrLoose, true),
    release,
    identifier,
    identifierBase,
    loose
  ).version;
};

// src/functions/major.ts
var major = (version, optionsOrLoose) => parse_default(version, optionsOrLoose, true).major;
var major_default = major;

// src/functions/minor.ts
var minor = (version, optionsOrLoose) => parse_default(version, optionsOrLoose, true).minor;
var minor_default = minor;

// src/functions/patch.ts
var patch = (version, optionsOrLoose) => parse_default(version, optionsOrLoose, true).patch;
var patch_default = patch;

// src/functions/prerelease.ts
var prerelease = (version, optionsOrLoose) => {
  const parsed = parse_default(version, optionsOrLoose);
  return parsed && parsed.prerelease.length ? parsed.prerelease : null;
};
var prerelease_default = prerelease;

// src/functions/rcompare.ts
var rcompare = (v1, v2, optionsOrLoose) => compare_default(v2, v1, optionsOrLoose);
var rcompare_default = rcompare;

// src/functions/rsort.ts
var rsort = (list, optionsOrLoose) => list.sort((v1, v2) => compareBuild_default(v2, v1, optionsOrLoose));
var rsort_default = rsort;

// src/functions/sort.ts
var sort = (list, optionsOrLoose) => list.sort((v1, v2) => compareBuild_default(v1, v2, optionsOrLoose));
var sort_default = sort;

// src/functions/valid.ts
var valid = (version, optionsOrLoose) => {
  const v = parse_default(version, optionsOrLoose);
  return v ? v.version : null;
};
var valid_default = valid;

export { clean_default as clean, cmp, coerce_default as coerce, compare_default as compare, compareBuild_default as compareBuild, compareIdentifiers_default as compareIdentifiers, compareLoose_default as compareLoose, diff_default as diff, eq_default as eq, gt_default as gt, gte_default as gte, inc, incThrow, lt_default as lt, lte_default as lte, major_default as major, minor_default as minor, neq_default as neq, parse_default as parse, patch_default as patch, prerelease_default as prerelease, rcompare_default as rcompare, rsort_default as rsort, FULL as semverRegex, sort_default as sort, valid_default as valid };
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map