extra-version/index.mjs

A version is a set of numbers that identify a unique evolution of a system.

function cmp(a, b) {
    if (isNaN(a) || isNaN(b))
        return a.localeCompare(b);
    else
        return parseInt(a, 10) - parseInt(b, 10);
}
function id(v) {
    return v;
}
function cmp$1(a, b) {
    return a < b ? -1 : (a > b ? 1 : 0);
}
function compare(x, y, fc = null, fm = null) {
    var fc = fc || cmp$1, fm = fm || id;
    var X = x.length, Y = y.length;
    for (var i = 0, I = Math.min(X, Y); i < I; i++) {
        var u1 = fm(x[i], i, x);
        var v1 = fm(y[i], i, y);
        var c = fc(u1, v1);
        if (c !== 0)
            return c;
    }
    return Math.sign(X - Y);
}
function compare$1(x, y, fc = null, fm = null) {
    var xp = x.prerelease || [], XP = xp.length;
    var yp = y.prerelease || [], YP = yp.length;
    if ((XP > 0) !== (YP > 0))
        return YP - XP;
    var c = x.major - y.major;
    if (c !== 0)
        return c;
    var c = x.minor - y.minor;
    if (c !== 0)
        return c;
    var c = x.patch - y.patch;
    if (c !== 0)
        return c;
    return compare(xp, yp, fc || cmp, fm);
}
function stringify(x) {
    var { major, minor, patch, prerelease, buildmetadata } = x;
    var a = `${major}.${minor}.${patch}`;
    if (prerelease && prerelease.length > 0)
        a += '-' + prerelease.join('.');
    if (buildmetadata && buildmetadata.length > 0)
        a += '+' + buildmetadata.join('.');
    return a;
}
class Version {
    constructor(major = 0, minor = 0, patch = 0, prerelease = null, buildmetadata = null) {
        this.major = major;
        this.minor = minor;
        this.patch = patch;
        this.prerelease = prerelease;
        this.buildmetadata = buildmetadata;
    }
    toString() { return stringify(this); }
}
const RPDEFAULT = /^\s*(\d+\.\d+\.\d+)(?:\-([\w-]+(?:\.[\w-]+)*))?(?:\+([\w-]+(?:\.[\w-]+)*))?/;
const RPVERSION = /^\s*(?:(?:v(?:er(?:sion)?)?)?\s*)?(\d+\.\d+\.\d+)(?:\-([\w-]+(?:\.[\w-]+)*))?(?:\+([\w-]+(?:\.[\w-]+)*))?/;
const RPPARTIAL = /^\s*(?:(?:v(?:er(?:sion)?)?)?\s*)?(\d+(?:\.\d+)*)(?:\-([\w-]+(?:\.[\w-]+)*))?(?:\+([\w-]+(?:\.[\w-]+)*))?/;
const RPANYWORD = /^\s*(?:(?:v(?:er(?:sion)?)?)?\s*)?(\d[^\s.+-]*(?:\.[^\s.+-]+)*)(?:\-([^\s.+]+(?:\.[^\s.+]+)*))?(?:\+([^\s.]+(?:\.[^\s.]+)*))?/;
const RPANYCHAR = /^\s*(?:(?:v(?:er(?:sion)?)?)?\s*)?(\d[^.+-]*(?:\.[^.+-]+)*)(?:\-([^.+]+(?:\.[^.+]+)*))?(?:\+([^.]+(?:\.[^.]+)*))?/;
const RPLEVELS = [RPDEFAULT, RPVERSION, RPPARTIAL, RPANYWORD, RPANYCHAR];
const RDASH = /[_-]+/g;
const RCHAR = /[^0-9A-Za-z-\.]/g;
const RZERO = /(^|-\.)0+([1-9]+)/g;
function parseRegexp(l) {
    var L = RPLEVELS.length;
    var l = l >= 0 && l < L ? l : L - 1;
    return RPLEVELS[l];
}
function parseSplit(s) {
    return s ? s.replace(RDASH, '-').replace(RCHAR, '').replace(RZERO, '$1$2').split('.') : [];
}
function parse(s, i = 0, lvl = 0) {
    var m = parseRegexp(lvl).exec(s.slice(i));
    if (m == null)
        return [-1, null];
    var [vs, prerelease, buildmetadata] = m.slice(1, 4).map(parseSplit);
    var [major, minor, patch] = [...vs, '', ''].slice(0, 3).map(v => parseInt(v, 10) || 0);
    buildmetadata.unshift(...vs.slice(3));
    var a = new Version(major, minor, patch, prerelease, buildmetadata);
    return [i + m[0].length, a];
}
function from(v) {
    if (typeof v === 'number')
        v = v.toString();
    if (typeof v === 'string')
        return parse(v, 0, -1)[1];
    return v && typeof v === 'object' ? new Version(v.major || 0, v.minor || 0, v.patch || 0, v.prerelease || [], v.buildmetadata || []) : null;
}
function is(v) {
    return v instanceof Version;
}
function isEqual(x, y, fc = null, fm = null) {
    return compare$1(x, y, fc, fm) === 0;
}
function isUnstable(x) {
    return x.major === 0 || (x.prerelease && x.prerelease.length > 0);
}
const MAJOR = new Version(1);
const MINOR = new Version(0, 1);
function nxt(v, d) {
    var r = d.startsWith('.'), d = d.slice(r ? 1 : 0);
    if (isNaN(v) || isNaN(d))
        return d || v;
    return ((r ? 0 : parseInt(v, 10) || 0) + (parseInt(d, 10) || 0)).toString();
}
const PATCH = new Version(0, 0, 1);
function next(x, s = PATCH, fn = null) {
    var fn = fn || nxt, r = false;
    var part = (xs, ss) => {
        for (var i = 0, I = xs.length, a = []; i < I; i++) {
            a[i] = fn(xs[i], (r ? '.' : '') + (ss[i] || ''));
            r = r || a[i] !== xs[i];
        }
        return a;
    };
    var xs = `${x.major}.${x.minor}.${x.patch}`.split('.');
    var ss = `${s.major}.${s.minor}.${s.patch}`.split('.');
    var [major, minor, patch] = part(xs, ss).map(v => parseInt(v, 10));
    var prerelease = s.prerelease ? part(x.prerelease || [], s.prerelease) : null;
    var buildmetadata = s.buildmetadata ? part(x.buildmetadata || [], s.buildmetadata) : null;
    return new Version(major, minor, patch, prerelease, buildmetadata);
}
const RVERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
export { MAJOR, MINOR, PATCH, RVERSION, Version, compare$1 as compare, from, is, isEqual, isUnstable, next, parse, stringify };