gnezim
364 lines
11 KiB
JavaScript
364 lines
11 KiB
JavaScript
"use strict";
|
|
|
|
require("core-js/modules/es.symbol");
|
|
|
|
require("core-js/modules/es.symbol.description");
|
|
|
|
require("core-js/modules/es.symbol.iterator");
|
|
|
|
require("core-js/modules/es.array.concat");
|
|
|
|
require("core-js/modules/es.array.iterator");
|
|
|
|
require("core-js/modules/es.array.join");
|
|
|
|
require("core-js/modules/es.array.map");
|
|
|
|
require("core-js/modules/es.object.define-property");
|
|
|
|
require("core-js/modules/es.object.to-string");
|
|
|
|
require("core-js/modules/es.regexp.exec");
|
|
|
|
require("core-js/modules/es.string.iterator");
|
|
|
|
require("core-js/modules/es.string.match");
|
|
|
|
require("core-js/modules/es.string.split");
|
|
|
|
require("core-js/modules/es.string.trim");
|
|
|
|
require("core-js/modules/web.dom-collections.iterator");
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
var debug = require('../internal/debug');
|
|
|
|
var _require = require('../internal/constants'),
|
|
MAX_LENGTH = _require.MAX_LENGTH,
|
|
MAX_SAFE_INTEGER = _require.MAX_SAFE_INTEGER;
|
|
|
|
var _require2 = require('../internal/re'),
|
|
re = _require2.re,
|
|
t = _require2.t;
|
|
|
|
var _require3 = require('../internal/identifiers'),
|
|
compareIdentifiers = _require3.compareIdentifiers;
|
|
|
|
var SemVer = /*#__PURE__*/function () {
|
|
function SemVer(version, options) {
|
|
_classCallCheck(this, SemVer);
|
|
|
|
if (!options || _typeof(options) !== 'object') {
|
|
options = {
|
|
loose: !!options,
|
|
includePrerelease: false
|
|
};
|
|
}
|
|
|
|
if (version instanceof SemVer) {
|
|
if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
|
|
return version;
|
|
} else {
|
|
version = version.version;
|
|
}
|
|
} else if (typeof version !== 'string') {
|
|
throw new TypeError("Invalid Version: ".concat(version));
|
|
}
|
|
|
|
if (version.length > MAX_LENGTH) {
|
|
throw new TypeError("version is longer than ".concat(MAX_LENGTH, " characters"));
|
|
}
|
|
|
|
debug('SemVer', version, options);
|
|
this.options = options;
|
|
this.loose = !!options.loose; // this isn't actually relevant for versions, but keep it so that we
|
|
// don't run into trouble passing this.options around.
|
|
|
|
this.includePrerelease = !!options.includePrerelease;
|
|
var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
|
|
|
|
if (!m) {
|
|
throw new TypeError("Invalid Version: ".concat(version));
|
|
}
|
|
|
|
this.raw = version; // these are actually numbers
|
|
|
|
this.major = +m[1];
|
|
this.minor = +m[2];
|
|
this.patch = +m[3];
|
|
|
|
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
|
|
throw new TypeError('Invalid major version');
|
|
}
|
|
|
|
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
|
|
throw new TypeError('Invalid minor version');
|
|
}
|
|
|
|
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
|
|
throw new TypeError('Invalid patch version');
|
|
} // numberify any prerelease numeric ids
|
|
|
|
|
|
if (!m[4]) {
|
|
this.prerelease = [];
|
|
} else {
|
|
this.prerelease = m[4].split('.').map(function (id) {
|
|
if (/^[0-9]+$/.test(id)) {
|
|
var num = +id;
|
|
|
|
if (num >= 0 && num < MAX_SAFE_INTEGER) {
|
|
return num;
|
|
}
|
|
}
|
|
|
|
return id;
|
|
});
|
|
}
|
|
|
|
this.build = m[5] ? m[5].split('.') : [];
|
|
this.format();
|
|
}
|
|
|
|
_createClass(SemVer, [{
|
|
key: "format",
|
|
value: function format() {
|
|
this.version = "".concat(this.major, ".").concat(this.minor, ".").concat(this.patch);
|
|
|
|
if (this.prerelease.length) {
|
|
this.version += "-".concat(this.prerelease.join('.'));
|
|
}
|
|
|
|
return this.version;
|
|
}
|
|
}, {
|
|
key: "toString",
|
|
value: function toString() {
|
|
return this.version;
|
|
}
|
|
}, {
|
|
key: "compare",
|
|
value: function compare(other) {
|
|
debug('SemVer.compare', this.version, this.options, other);
|
|
|
|
if (!(other instanceof SemVer)) {
|
|
if (typeof other === 'string' && other === this.version) {
|
|
return 0;
|
|
}
|
|
|
|
other = new SemVer(other, this.options);
|
|
}
|
|
|
|
if (other.version === this.version) {
|
|
return 0;
|
|
}
|
|
|
|
return this.compareMain(other) || this.comparePre(other);
|
|
}
|
|
}, {
|
|
key: "compareMain",
|
|
value: function compareMain(other) {
|
|
if (!(other instanceof SemVer)) {
|
|
other = new SemVer(other, this.options);
|
|
}
|
|
|
|
return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
|
|
}
|
|
}, {
|
|
key: "comparePre",
|
|
value: function comparePre(other) {
|
|
if (!(other instanceof SemVer)) {
|
|
other = new SemVer(other, this.options);
|
|
} // NOT having a prerelease is > having one
|
|
|
|
|
|
if (this.prerelease.length && !other.prerelease.length) {
|
|
return -1;
|
|
} else if (!this.prerelease.length && other.prerelease.length) {
|
|
return 1;
|
|
} else if (!this.prerelease.length && !other.prerelease.length) {
|
|
return 0;
|
|
}
|
|
|
|
var i = 0;
|
|
|
|
do {
|
|
var a = this.prerelease[i];
|
|
var b = other.prerelease[i];
|
|
debug('prerelease compare', i, a, b);
|
|
|
|
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);
|
|
}
|
|
}, {
|
|
key: "compareBuild",
|
|
value: function compareBuild(other) {
|
|
if (!(other instanceof SemVer)) {
|
|
other = new SemVer(other, this.options);
|
|
}
|
|
|
|
var i = 0;
|
|
|
|
do {
|
|
var a = this.build[i];
|
|
var b = other.build[i];
|
|
debug('prerelease compare', i, a, b);
|
|
|
|
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);
|
|
} // preminor will bump the version up to the next minor release, and immediately
|
|
// down to pre-release. premajor and prepatch work the same way.
|
|
|
|
}, {
|
|
key: "inc",
|
|
value: function inc(release, identifier) {
|
|
switch (release) {
|
|
case 'premajor':
|
|
this.prerelease.length = 0;
|
|
this.patch = 0;
|
|
this.minor = 0;
|
|
this.major++;
|
|
this.inc('pre', identifier);
|
|
break;
|
|
|
|
case 'preminor':
|
|
this.prerelease.length = 0;
|
|
this.patch = 0;
|
|
this.minor++;
|
|
this.inc('pre', identifier);
|
|
break;
|
|
|
|
case 'prepatch':
|
|
// If this is already a prerelease, it will bump to the next version
|
|
// drop any prereleases that might already exist, since they are not
|
|
// relevant at this point.
|
|
this.prerelease.length = 0;
|
|
this.inc('patch', identifier);
|
|
this.inc('pre', identifier);
|
|
break;
|
|
// If the input is a non-prerelease version, this acts the same as
|
|
// prepatch.
|
|
|
|
case 'prerelease':
|
|
if (this.prerelease.length === 0) {
|
|
this.inc('patch', identifier);
|
|
}
|
|
|
|
this.inc('pre', identifier);
|
|
break;
|
|
|
|
case 'major':
|
|
// If this is a pre-major version, bump up to the same major version.
|
|
// Otherwise increment major.
|
|
// 1.0.0-5 bumps to 1.0.0
|
|
// 1.1.0 bumps to 2.0.0
|
|
if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
|
|
this.major++;
|
|
}
|
|
|
|
this.minor = 0;
|
|
this.patch = 0;
|
|
this.prerelease = [];
|
|
break;
|
|
|
|
case 'minor':
|
|
// If this is a pre-minor version, bump up to the same minor version.
|
|
// Otherwise increment minor.
|
|
// 1.2.0-5 bumps to 1.2.0
|
|
// 1.2.1 bumps to 1.3.0
|
|
if (this.patch !== 0 || this.prerelease.length === 0) {
|
|
this.minor++;
|
|
}
|
|
|
|
this.patch = 0;
|
|
this.prerelease = [];
|
|
break;
|
|
|
|
case 'patch':
|
|
// If this is not a pre-release version, it will increment the patch.
|
|
// If it is a pre-release it will bump up to the same patch version.
|
|
// 1.2.0-5 patches to 1.2.0
|
|
// 1.2.0 patches to 1.2.1
|
|
if (this.prerelease.length === 0) {
|
|
this.patch++;
|
|
}
|
|
|
|
this.prerelease = [];
|
|
break;
|
|
// This probably shouldn't be used publicly.
|
|
// 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
|
|
|
|
case 'pre':
|
|
if (this.prerelease.length === 0) {
|
|
this.prerelease = [0];
|
|
} else {
|
|
var i = this.prerelease.length;
|
|
|
|
while (--i >= 0) {
|
|
if (typeof this.prerelease[i] === 'number') {
|
|
this.prerelease[i]++;
|
|
i = -2;
|
|
}
|
|
}
|
|
|
|
if (i === -1) {
|
|
// didn't increment anything
|
|
this.prerelease.push(0);
|
|
}
|
|
}
|
|
|
|
if (identifier) {
|
|
// 1.2.0-beta.1 bumps to 1.2.0-beta.2,
|
|
// 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
|
|
if (this.prerelease[0] === identifier) {
|
|
if (isNaN(this.prerelease[1])) {
|
|
this.prerelease = [identifier, 0];
|
|
}
|
|
} else {
|
|
this.prerelease = [identifier, 0];
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
throw new Error("invalid increment argument: ".concat(release));
|
|
}
|
|
|
|
this.format();
|
|
this.raw = this.version;
|
|
return this;
|
|
}
|
|
}]);
|
|
|
|
return SemVer;
|
|
}();
|
|
|
|
module.exports = SemVer; |