install gulp to process code
This commit is contained in:
isUnknown
parent
24f6606c2c
commit
b6a3900ee2
1651 changed files with 253427 additions and 39 deletions
10
node_modules/sver/.travis.yml
generated
vendored
Normal file
10
node_modules/sver/.travis.yml
generated
vendored
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
git:
|
||||
depth: 1
|
||||
language: node_js
|
||||
node_js:
|
||||
- '8'
|
||||
|
||||
before_install:
|
||||
- npm install
|
||||
script:
|
||||
- npm run test
|
||||
10
node_modules/sver/LICENSE
generated
vendored
Normal file
10
node_modules/sver/LICENSE
generated
vendored
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
MIT License
|
||||
-----------
|
||||
|
||||
Copyright (C) 2017 Guy Bedford
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
161
node_modules/sver/README.md
generated
vendored
Normal file
161
node_modules/sver/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,161 @@
|
|||
# Sver
|
||||
|
||||
[](https://travis-ci.org/guybedford/sver)
|
||||
|
||||
Another Semver utility library. Supports NodeJS 6+ only. No maintenance guarantees.
|
||||
|
||||
This is the semver library used by jspm.
|
||||
|
||||
```
|
||||
npm install sver
|
||||
```
|
||||
|
||||
```js
|
||||
const { Semver, SemverRange } = require('sver');
|
||||
|
||||
// Static usage:
|
||||
SemverRange.match('^1.2.3', '1.2.4'); // true
|
||||
|
||||
// Class usage:
|
||||
let range = new SemverRange('^1.2.3');
|
||||
let version = new Semver('1.2.4');
|
||||
version.matches(range); // true
|
||||
range.has(version); // true
|
||||
```
|
||||
|
||||
### Range support
|
||||
|
||||
Restricts version ranges to the simplified cases:
|
||||
* `*`: Wildcard range
|
||||
* `MAJOR`: Match exact major
|
||||
* `MAJOR.MINOR` Match exact major and minor
|
||||
* `MAJOR.MINOR.PATCH[-PRE]` Match exact semver
|
||||
* `~MAJOR.MINOR.PATCH[-PRE]`: Match patch bumps
|
||||
* `^MAJOR.MINOR.PATCH[-PRE]`: Match minor and patch bumps
|
||||
|
||||
Invalid ranges will fallback to being detected as exact string matches.
|
||||
|
||||
### Prerelease Matching
|
||||
|
||||
By default, as per convention, ranges like `^1.2.3-alpha` only match prerelease ranges on the same patch (`1.2.3-alpha.4`), but
|
||||
not prerelease ranges from further patches (`1.3.4-alpha`).
|
||||
|
||||
To alter this matching, a third boolean argument can be provided to the match function to support these unstable matches:
|
||||
|
||||
```js
|
||||
SemverRange.match('^1.2.3', '1.5.6-beta'); // false
|
||||
SemverRange.match('^1.2.3', '1.5.6-beta', true); // true
|
||||
```
|
||||
|
||||
### Best Version Match
|
||||
|
||||
```js
|
||||
let versions = ['1.2.3', '1.3.4-alpha', '1.3.4-alpha.1', '1.3.4-beta'];
|
||||
let range = new SemverRange('*');
|
||||
|
||||
let bestStableMatch = range.bestMatch(versions);
|
||||
bestStableMatch.toString(); // 1.2.3
|
||||
|
||||
let bestUnstableMatch = range.bestMatch(versions, true);
|
||||
bestUnstableMatch.toString(); // 1.3.4-beta
|
||||
```
|
||||
|
||||
### Version and Range Sorting
|
||||
|
||||
```js
|
||||
let versions = ['2.4.5', '2.3.4-alpha', '1.2.3', '2.3.4-alpha.2'];
|
||||
let ranges = ['^1.2.3', '1.2', '2.3.4'];
|
||||
|
||||
versions.sort(Semver.compare); // [1.2.3, 2.3.4-alpha, 2.3.4-alpha.2, 2.4.5]
|
||||
ranges.sort(SemverRange.compare) // [1.2, ^1.2.3, 2.3.4]
|
||||
```
|
||||
|
||||
### Conversion from Node Semver Ranges
|
||||
|
||||
A utility function is included to convert Node Semver ranges into Semver ranges.
|
||||
|
||||
This requires `semver` to be installed in the application running this process.
|
||||
|
||||
_Note this conversion is lossy by definition._
|
||||
|
||||
```js
|
||||
const convertRange = require('sver/convert-range');
|
||||
|
||||
convertRange('>=2.3.4 <3.0.0').toString(); // ^2.3.4
|
||||
convertRange('1 || 2 || 3').toString(); // ^3.0.0
|
||||
```
|
||||
|
||||
### Semver and Semver Range Validation
|
||||
|
||||
When a version string fails semver validation it falls back to being treated as a tag, still as a `Semver` instance.
|
||||
|
||||
For example:
|
||||
|
||||
```js
|
||||
let version = new Semver('x.y.z');
|
||||
version.tag === 'x.y.z'; // true
|
||||
|
||||
version = new Semver('^1.2.3');
|
||||
version.major === undefined; // true
|
||||
version.tag === '^1.2.3'; // true
|
||||
```
|
||||
|
||||
For validation, rather use `Semver.isValid` and `SemverRange.isValid`:
|
||||
|
||||
```js
|
||||
Semver.isValid('x.y.z'); // false
|
||||
Semver.isValid('^1.2.3'); // false
|
||||
SemverRange.isValid('^1.2.3'); // true
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
### Semver
|
||||
|
||||
Static methods:
|
||||
|
||||
* `Semver.isValid(version: string): boolean`: Whether the given string is a valid semver.
|
||||
* `Semver.compare(v1: Semver|string, v2: Semver|string): number`: 1 if v1 > v2, -1 if v1 < v2, 0 if equal.
|
||||
|
||||
For a given Semver instance `version = new Semver('X.Y.Z')`,
|
||||
|
||||
* `version.major`: The major version number.
|
||||
* `version.minor`: The minor version number.
|
||||
* `version.patch`: The patch version number.
|
||||
* `version.pre`: The prerelease identifer, as an array of strings (`.`-separated).
|
||||
* `version.build`: The build identifier, as a string.
|
||||
* `version.tag`: If not a valid semver, the full tag string.
|
||||
* `version.gt(otherVersion: Semver|string): bool`: Whether this version is greater than the other version.
|
||||
* `version.lt(otherVersion: Semver|string): bool`: Whether this version is less than the other version.
|
||||
* `version.eq(otherVerion: Semver|string): bool`: Whether this version equals the other version.
|
||||
* `version.matches(range: SemverRange|string, unstable?: bool): bool`: Whether this version matches the given version range.
|
||||
* `version.toString(): string`: Convert the version back to a string.
|
||||
|
||||
### SemverRange
|
||||
|
||||
Static methods:
|
||||
|
||||
* `SemverRange.match(range: SemverRange|string, version: Semver|string, unstable = false): bool`: Whether the version matches the range.
|
||||
* `SemverRange.isValid(range: string): bool`: Whether the given range string is a valid semver range (in this simplified grammar).
|
||||
* `SemverRange.compare(r1: SemverRange|string, r2: SemverRange|string): number`: 1 if r1 > r2, -1 if r1 < r2, 0 if equal.
|
||||
|
||||
For a given SemverRange instance `range = new SemverRange('^X.Y.Z')`,
|
||||
|
||||
* `range.type: string`: Returns `'wildcard'`, `'major'`, `'stable'` or `'exact'`.
|
||||
* `range.version: Smever`: Returns the `Semver` instance corresponding to the range.
|
||||
* `range.isExact: string`: Returns true if the range is an exact version only.
|
||||
* `range.isStable: string`: Returns true if the range is a stable version range.
|
||||
* `range.isMajor: string`: Returns true if the range is a major version range.
|
||||
* `range.isWildcard: string`: Returns true if the range is the wildcard version range.
|
||||
* `range.gt(otherRange: SemverRange|string): bool`: Whether the range is greater than the other range.
|
||||
* `range.lt(otherRange: SemverRange|string): bool`: Whether the range is less than the other range.
|
||||
* `range.eq(otherRange: SemverRange|string): bool`: Whether the range is exactly the same as the other range.
|
||||
* `range.has(version: Semver|string, unstable = false): bool`: Whether the range includes the given version.
|
||||
* `range.contains(otherRange: SemverRange|string): bool`: Whether the range fully contains the other range.
|
||||
* `range.intersect(otherRange: SemverRange|string): SemverRange|undefined`: The intersection range, if any.
|
||||
* `range.bestMatch(versions: (Semver|string)[], unstable = false): Semver|undefined`: The intersection range, if any.
|
||||
* `range.toString()`: Convert the range back to a string.
|
||||
|
||||
## License
|
||||
|
||||
MIT
|
||||
144
node_modules/sver/convert-range.js
generated
vendored
Normal file
144
node_modules/sver/convert-range.js
generated
vendored
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
const nodeSemver = require('semver');
|
||||
const { Semver, SemverRange } = require('./sver');
|
||||
|
||||
module.exports = function nodeRangeToSemverRange (range) {
|
||||
let parsed = nodeSemver.validRange(range);
|
||||
|
||||
// tag version
|
||||
if (!parsed)
|
||||
return new SemverRange(range);
|
||||
|
||||
if (parsed === '*')
|
||||
return new SemverRange(parsed);
|
||||
|
||||
try {
|
||||
let semverRange = new SemverRange(range);
|
||||
if (!semverRange.version.tag)
|
||||
return semverRange;
|
||||
}
|
||||
catch (e) {
|
||||
if (e.code !== 'ENOTSEMVER')
|
||||
throw e;
|
||||
}
|
||||
|
||||
let outRange;
|
||||
for (let union of parsed.split('||')) {
|
||||
// compute the intersection into a lowest upper bound and a highest lower bound
|
||||
let upperBound, lowerBound, upperEq, lowerEq;
|
||||
for (let intersection of union.split(' ')) {
|
||||
let lt = intersection[0] === '<';
|
||||
let gt = intersection[0] === '>';
|
||||
if (!lt && !gt) {
|
||||
upperBound = intersection;
|
||||
upperEq = true;
|
||||
break;
|
||||
}
|
||||
let eq = intersection[1] === '=';
|
||||
if (!gt) {
|
||||
let version = new Semver(intersection.substr(1 + eq));
|
||||
if (!upperBound || upperBound.gt(version)) {
|
||||
upperBound = version;
|
||||
upperEq = eq;
|
||||
}
|
||||
}
|
||||
else if (!lt) {
|
||||
let eq = intersection[1] === '=';
|
||||
let version = new Semver(intersection.substr(1 + eq));
|
||||
if (!lowerBound || lowerBound.lt(version)) {
|
||||
lowerBound = version;
|
||||
lowerEq = eq;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// no upper bound -> wildcard
|
||||
if (!upperBound) {
|
||||
outRange = new SemverRange('*');
|
||||
continue;
|
||||
}
|
||||
|
||||
// if the lower bound is greater than the upper bound then just return the lower bound exactly
|
||||
if (lowerBound && upperBound && lowerBound.gt(upperBound)) {
|
||||
let curRange = new SemverRange(lowerBound.toString());
|
||||
// the largest or highest union range wins
|
||||
if (!outRange || !outRange.contains(curRange) && (curRange.gt(outRange) || curRange.contains(outRange)))
|
||||
outRange = curRange;
|
||||
continue;
|
||||
}
|
||||
|
||||
// determine the largest semver range satisfying the upper bound
|
||||
let upperRange;
|
||||
if (upperBound) {
|
||||
// if the upper bound has an equality then we return it directly
|
||||
if (upperEq) {
|
||||
let curRange = new SemverRange(upperBound.toString());
|
||||
// the largest or highest union range wins
|
||||
if (!outRange || !outRange.contains(curRange) && (curRange.gt(outRange) || curRange.contains(outRange)))
|
||||
outRange = curRange;
|
||||
continue;
|
||||
}
|
||||
|
||||
let major = 0, minor = 0, patch = 0, rangeType = '';
|
||||
|
||||
// if an exact prerelease range, match the lower bound as a range
|
||||
if (upperBound.pre && lowerBound.major === upperBound.major && lowerBound.minor === upperBound.minor && lowerBound.patch === upperBound.patch) {
|
||||
outRange = new SemverRange('~' + lowerBound.toString());
|
||||
continue;
|
||||
}
|
||||
|
||||
// <2.0.0 -> ^1.0.0
|
||||
else if (upperBound.patch === 0) {
|
||||
if (upperBound.minor === 0) {
|
||||
if (upperBound.major > 0) {
|
||||
major = upperBound.major - 1;
|
||||
rangeType = '^';
|
||||
}
|
||||
}
|
||||
// <1.2.0 -> ~1.1.0
|
||||
else {
|
||||
major = upperBound.major;
|
||||
minor = upperBound.minor - 1;
|
||||
rangeType = '~';
|
||||
}
|
||||
}
|
||||
// <1.2.3 -> ~1.2.0
|
||||
else {
|
||||
major = upperBound.major;
|
||||
minor = upperBound.minor;
|
||||
patch = 0;
|
||||
rangeType = '~';
|
||||
}
|
||||
|
||||
if (major === 0 && rangeType === '^')
|
||||
upperRange = new SemverRange('0');
|
||||
else
|
||||
upperRange = new SemverRange(rangeType + major + '.' + minor + '.' + patch);
|
||||
}
|
||||
|
||||
if (!lowerBound) {
|
||||
outRange = upperRange;
|
||||
continue;
|
||||
}
|
||||
|
||||
// determine the lower range semver range
|
||||
let lowerRange;
|
||||
if (!lowerEq) {
|
||||
if (lowerBound.pre)
|
||||
lowerRange = new SemverRange('^^' + lowerBound.major + '.' + lowerBound.minor + '.' + lowerBound.patch + '-' + [...lowerBound.pre, 1].join('.'));
|
||||
else
|
||||
lowerRange = new SemverRange('^^' + lowerBound.major + '.' + lowerBound.minor + '.' + (lowerBound.patch + 1));
|
||||
}
|
||||
else {
|
||||
lowerRange = new SemverRange('^^' + lowerBound.toString());
|
||||
}
|
||||
|
||||
// we then intersect the upper semver range with the lower semver range
|
||||
// if the intersection is empty, we return the upper range only
|
||||
let curRange = upperRange ? lowerRange.intersect(upperRange) || upperRange : lowerRange;
|
||||
|
||||
// the largest or highest union range wins
|
||||
if (!outRange || !outRange.contains(curRange) && (curRange.gt(outRange) || curRange.contains(outRange)))
|
||||
outRange = curRange;
|
||||
}
|
||||
return outRange;
|
||||
}
|
||||
29
node_modules/sver/package.json
generated
vendored
Normal file
29
node_modules/sver/package.json
generated
vendored
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
{
|
||||
"name": "sver",
|
||||
"version": "1.8.4",
|
||||
"description": "Simple Semver and SemverRange classes",
|
||||
"main": "sver.js",
|
||||
"scripts": {
|
||||
"test": "mocha -u tdd -R dot"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+ssh://git@github.com/guybedford/sver.git"
|
||||
},
|
||||
"keywords": [
|
||||
"semver"
|
||||
],
|
||||
"author": "Guy Bedford",
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://github.com/guybedford/sver/issues"
|
||||
},
|
||||
"homepage": "https://github.com/guybedford/sver#readme",
|
||||
"devDependencies": {
|
||||
"mocha": "^10.2.0",
|
||||
"semver": "^6.3.0"
|
||||
},
|
||||
"optionalDependencies": {
|
||||
"semver": "^6.3.0"
|
||||
}
|
||||
}
|
||||
392
node_modules/sver/sver.js
generated
vendored
Normal file
392
node_modules/sver/sver.js
generated
vendored
Normal file
|
|
@ -0,0 +1,392 @@
|
|||
'use strict';
|
||||
|
||||
const shortSemverRegEx = /^([~\^])?(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/;
|
||||
const semverRegEx = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([\da-z-]+(?:\.[\da-z-]+)*))?(\+[\da-z-]+)?$/i;
|
||||
exports.semverRegEx = semverRegEx;
|
||||
exports.shortSemverRegEx = shortSemverRegEx;
|
||||
|
||||
const MAJOR = Symbol('major');
|
||||
const MINOR = Symbol('minor');
|
||||
const PATCH = Symbol('patch');
|
||||
const PRE = Symbol('pre');
|
||||
const BUILD = Symbol('build');
|
||||
const TAG = Symbol('tag');
|
||||
|
||||
let numRegEx = /^\d+$/;
|
||||
class Semver {
|
||||
constructor (version) {
|
||||
let semver = version.match(semverRegEx);
|
||||
if (!semver) {
|
||||
this[TAG] = version;
|
||||
return;
|
||||
}
|
||||
this[MAJOR] = parseInt(semver[1], 10);
|
||||
this[MINOR] = parseInt(semver[2], 10);
|
||||
this[PATCH] = parseInt(semver[3], 10);
|
||||
this[PRE] = semver[4] && semver[4].split('.');
|
||||
this[BUILD] = semver[5];
|
||||
}
|
||||
get major () {
|
||||
return this[MAJOR];
|
||||
}
|
||||
get minor () {
|
||||
return this[MINOR];
|
||||
}
|
||||
get patch () {
|
||||
return this[PATCH];
|
||||
}
|
||||
get pre () {
|
||||
return this[PRE];
|
||||
}
|
||||
get build () {
|
||||
return this[BUILD];
|
||||
}
|
||||
get tag () {
|
||||
return this[TAG];
|
||||
}
|
||||
gt (version) {
|
||||
return Semver.compare(this, version) === 1;
|
||||
}
|
||||
lt (version) {
|
||||
return Semver.compare(this, version) === -1;
|
||||
}
|
||||
eq (version) {
|
||||
if (!(version instanceof Semver))
|
||||
version = new Semver(version);
|
||||
|
||||
if (this[TAG] && version[TAG])
|
||||
return this[TAG] === version[TAG];
|
||||
if (this[TAG] || version[TAG])
|
||||
return false;
|
||||
if (this[MAJOR] !== version[MAJOR])
|
||||
return false;
|
||||
if (this[MINOR] !== version[MINOR])
|
||||
return false;
|
||||
if (this[PATCH] !== version[PATCH])
|
||||
return false;
|
||||
if (this[PRE] === undefined && version[PRE] === undefined)
|
||||
return true;
|
||||
if (this[PRE] === undefined || version[PRE] === undefined)
|
||||
return false;
|
||||
if (this[PRE].length !== version[PRE].length)
|
||||
return false;
|
||||
for (let i = 0; i < this[PRE].length; i++) {
|
||||
if (this[PRE][i] !== version[PRE][i])
|
||||
return false;
|
||||
}
|
||||
return this[BUILD] === version[BUILD];
|
||||
}
|
||||
matches (range, unstable = false) {
|
||||
if (!(range instanceof SemverRange))
|
||||
range = new SemverRange(range);
|
||||
return range.has(this, unstable);
|
||||
}
|
||||
toString () {
|
||||
if (this[TAG])
|
||||
return this[TAG];
|
||||
return this[MAJOR] + '.' + this[MINOR] + '.' + this[PATCH] + (this[PRE] ? '-' + this[PRE].join('.') : '') + (this[BUILD] ? this[BUILD] : '');
|
||||
}
|
||||
toJSON() {
|
||||
return this.toString();
|
||||
}
|
||||
static isValid (version) {
|
||||
let semver = version.match(semverRegEx);
|
||||
return semver && semver[2] !== undefined && semver[3] !== undefined;
|
||||
}
|
||||
static compare (v1, v2) {
|
||||
if (!(v1 instanceof Semver))
|
||||
v1 = new Semver(v1);
|
||||
if (!(v2 instanceof Semver))
|
||||
v2 = new Semver(v2);
|
||||
|
||||
// not semvers - tags have equal precedence
|
||||
if (v1[TAG] && v2[TAG])
|
||||
return 0;
|
||||
// semver beats tag version
|
||||
if (v1[TAG])
|
||||
return -1;
|
||||
if (v2[TAG])
|
||||
return 1;
|
||||
// compare version numbers
|
||||
if (v1[MAJOR] !== v2[MAJOR])
|
||||
return v1[MAJOR] > v2[MAJOR] ? 1 : -1;
|
||||
if (v1[MINOR] !== v2[MINOR])
|
||||
return v1[MINOR] > v2[MINOR] ? 1 : -1;
|
||||
if (v1[PATCH] !== v2[PATCH])
|
||||
return v1[PATCH] > v2[PATCH] ? 1 : -1;
|
||||
if (!v1[PRE] && !v2[PRE])
|
||||
return 0;
|
||||
if (!v1[PRE])
|
||||
return 1;
|
||||
if (!v2[PRE])
|
||||
return -1;
|
||||
// prerelease comparison
|
||||
return prereleaseCompare(v1[PRE], v2[PRE]);
|
||||
}
|
||||
}
|
||||
exports.Semver = Semver;
|
||||
|
||||
function prereleaseCompare (v1Pre, v2Pre) {
|
||||
for (let i = 0, l = Math.min(v1Pre.length, v2Pre.length); i < l; i++) {
|
||||
if (v1Pre[i] !== v2Pre[i]) {
|
||||
let isNum1 = v1Pre[i].match(numRegEx);
|
||||
let isNum2 = v2Pre[i].match(numRegEx);
|
||||
// numeric has lower precedence
|
||||
if (isNum1 && !isNum2)
|
||||
return -1;
|
||||
if (isNum2 && !isNum1)
|
||||
return 1;
|
||||
// compare parts
|
||||
if (isNum1 && isNum2)
|
||||
return parseInt(v1Pre[i], 10) > parseInt(v2Pre[i], 10) ? 1 : -1;
|
||||
else
|
||||
return v1Pre[i] > v2Pre[i] ? 1 : -1;
|
||||
}
|
||||
}
|
||||
if (v1Pre.length === v2Pre.length)
|
||||
return 0;
|
||||
// more pre-release fields win if equal
|
||||
return v1Pre.length > v2Pre.length ? 1 : -1;
|
||||
|
||||
}
|
||||
|
||||
const WILDCARD_RANGE = 0;
|
||||
const MAJOR_RANGE = 1;
|
||||
const STABLE_RANGE = 2;
|
||||
const EXACT_RANGE = 3;
|
||||
|
||||
const TYPE = Symbol('type');
|
||||
const VERSION = Symbol('version');
|
||||
|
||||
class SemverRange {
|
||||
constructor (versionRange) {
|
||||
if (versionRange === '*' || versionRange === '') {
|
||||
this[TYPE] = WILDCARD_RANGE;
|
||||
return;
|
||||
}
|
||||
let shortSemver = versionRange.match(shortSemverRegEx);
|
||||
if (shortSemver) {
|
||||
if (shortSemver[1])
|
||||
versionRange = versionRange.substr(1);
|
||||
if (shortSemver[3] === undefined) {
|
||||
// ^, ~ mean the same thing for a single major
|
||||
this[VERSION] = new Semver(versionRange + '.0.0');
|
||||
this[TYPE] = MAJOR_RANGE;
|
||||
}
|
||||
else {
|
||||
this[VERSION] = new Semver(versionRange + '.0');
|
||||
// ^ only becomes major range for major > 0
|
||||
if (shortSemver[1] === '^' && shortSemver[2] !== '0')
|
||||
this[TYPE] = MAJOR_RANGE;
|
||||
else
|
||||
this[TYPE] = STABLE_RANGE;
|
||||
}
|
||||
// empty pre array === support prerelease ranges
|
||||
this[VERSION][PRE] = this[VERSION][PRE] || [];
|
||||
}
|
||||
// forces hat on 0.x versions
|
||||
else if (versionRange.startsWith('^^')) {
|
||||
this[VERSION] = new Semver(versionRange.substr(2));
|
||||
this[TYPE] = MAJOR_RANGE;
|
||||
}
|
||||
else if (versionRange[0] === '^') {
|
||||
this[VERSION] = new Semver(versionRange.substr(1));
|
||||
if (this[VERSION][MAJOR] === 0) {
|
||||
if (this[VERSION][MINOR] === 0)
|
||||
this[TYPE] = EXACT_RANGE;
|
||||
else
|
||||
this[TYPE] = STABLE_RANGE;
|
||||
}
|
||||
else {
|
||||
this[TYPE] = MAJOR_RANGE;
|
||||
}
|
||||
}
|
||||
else if (versionRange[0] === '~') {
|
||||
this[VERSION] = new Semver(versionRange.substr(1));
|
||||
this[TYPE] = STABLE_RANGE;
|
||||
}
|
||||
else {
|
||||
this[VERSION] = new Semver(versionRange);
|
||||
this[TYPE] = EXACT_RANGE;
|
||||
}
|
||||
if (this[VERSION][TAG] && this[TYPE] !== EXACT_RANGE)
|
||||
this[TYPE] = EXACT_RANGE;
|
||||
}
|
||||
get isExact () {
|
||||
return this[TYPE] === EXACT_RANGE;
|
||||
}
|
||||
get isExactSemver () {
|
||||
return this[TYPE] === EXACT_RANGE && this.version[TAG] === undefined;
|
||||
}
|
||||
get isExactTag () {
|
||||
return this[TYPE] === EXACT_RANGE && this.version[TAG] !== undefined;
|
||||
}
|
||||
get isStable () {
|
||||
return this[TYPE] === STABLE_RANGE;
|
||||
}
|
||||
get isMajor () {
|
||||
return this[TYPE] === MAJOR_RANGE;
|
||||
}
|
||||
get isWildcard () {
|
||||
return this[TYPE] === WILDCARD_RANGE;
|
||||
}
|
||||
get type () {
|
||||
switch (this[TYPE]) {
|
||||
case WILDCARD_RANGE:
|
||||
return 'wildcard';
|
||||
case MAJOR_RANGE:
|
||||
return 'major';
|
||||
case STABLE_RANGE:
|
||||
return 'stable';
|
||||
case EXACT_RANGE:
|
||||
return 'exact';
|
||||
}
|
||||
}
|
||||
get version () {
|
||||
return this[VERSION];
|
||||
}
|
||||
gt (range) {
|
||||
return SemverRange.compare(this, range) === 1;
|
||||
}
|
||||
lt (range) {
|
||||
return SemverRange.compare(this, range) === -1;
|
||||
}
|
||||
eq (range) {
|
||||
return SemverRange.compare(this, range) === 0;
|
||||
}
|
||||
has (version, unstable = false) {
|
||||
if (!(version instanceof Semver))
|
||||
version = new Semver(version);
|
||||
if (this[TYPE] === WILDCARD_RANGE)
|
||||
return unstable || (!version[PRE] && !version[TAG]);
|
||||
if (this[TYPE] === EXACT_RANGE)
|
||||
return this[VERSION].eq(version);
|
||||
if (version[TAG])
|
||||
return false;
|
||||
if (this[VERSION][MAJOR] !== version[MAJOR])
|
||||
return false;
|
||||
if (this[TYPE] === MAJOR_RANGE ? this[VERSION][MINOR] > version[MINOR] : this[VERSION][MINOR] !== version[MINOR])
|
||||
return false;
|
||||
if ((this[TYPE] === MAJOR_RANGE ? this[VERSION][MINOR] === version[MINOR] : true) && this[VERSION][PATCH] > version[PATCH])
|
||||
return false;
|
||||
if (version[PRE] === undefined || version[PRE].length === 0)
|
||||
return true;
|
||||
if (this[VERSION][PRE] === undefined || this[VERSION][PRE].length === 0)
|
||||
return unstable;
|
||||
if (unstable === false && (this[VERSION][MINOR] !== version[MINOR] || this[VERSION][PATCH] !== version[PATCH]))
|
||||
return false;
|
||||
return prereleaseCompare(this[VERSION][PRE], version[PRE]) !== 1;
|
||||
}
|
||||
contains (range) {
|
||||
if (!(range instanceof SemverRange))
|
||||
range = new SemverRange(range);
|
||||
if (this[TYPE] === WILDCARD_RANGE)
|
||||
return true;
|
||||
if (range[TYPE] === WILDCARD_RANGE)
|
||||
return false;
|
||||
return range[TYPE] >= this[TYPE] && this.has(range[VERSION], true);
|
||||
}
|
||||
intersect (range) {
|
||||
if (!(range instanceof SemverRange))
|
||||
range = new SemverRange(range);
|
||||
|
||||
if (this[TYPE] === WILDCARD_RANGE && range[TYPE] === WILDCARD_RANGE)
|
||||
return this;
|
||||
if (this[TYPE] === WILDCARD_RANGE)
|
||||
return range;
|
||||
if (range[TYPE] === WILDCARD_RANGE)
|
||||
return this;
|
||||
|
||||
if (this[TYPE] === EXACT_RANGE)
|
||||
return range.has(this[VERSION], true) ? this : undefined;
|
||||
if (range[TYPE] === EXACT_RANGE)
|
||||
return this.has(range[VERSION], true) ? range : undefined;
|
||||
|
||||
let higherRange, lowerRange, polarity;
|
||||
if (range[VERSION].gt(this[VERSION])) {
|
||||
higherRange = range;
|
||||
lowerRange = this;
|
||||
polarity = true;
|
||||
}
|
||||
else {
|
||||
higherRange = this;
|
||||
lowerRange = range;
|
||||
polarity = false;
|
||||
}
|
||||
|
||||
if (!lowerRange.has(higherRange[VERSION], true))
|
||||
return;
|
||||
|
||||
if (lowerRange[TYPE] === MAJOR_RANGE)
|
||||
return polarity ? range : this;
|
||||
|
||||
let intersection = new SemverRange(higherRange[VERSION].toString());
|
||||
intersection[TYPE] = STABLE_RANGE;
|
||||
return intersection;
|
||||
}
|
||||
bestMatch (versions, unstable = false) {
|
||||
let maxSemver;
|
||||
versions.forEach(version => {
|
||||
if (!(version instanceof Semver))
|
||||
version = new Semver(version);
|
||||
if (!this.has(version, unstable))
|
||||
return;
|
||||
if (!maxSemver)
|
||||
maxSemver = version;
|
||||
else if (Semver.compare(version, maxSemver) === 1)
|
||||
maxSemver = version;
|
||||
});
|
||||
return maxSemver;
|
||||
}
|
||||
toString () {
|
||||
let version = this[VERSION];
|
||||
switch (this[TYPE]) {
|
||||
case WILDCARD_RANGE:
|
||||
return '*';
|
||||
case MAJOR_RANGE:
|
||||
if (version[MAJOR] === 0 && version[MINOR] === 0 && version[PATCH] === 0)
|
||||
return '0';
|
||||
if (version[PRE] && version[PRE].length === 0 && version[PATCH] === 0)
|
||||
return '^' + version[MAJOR] + '.' + version[MINOR];
|
||||
return '^' + version.toString();
|
||||
case STABLE_RANGE:
|
||||
if (version[PRE] && version[PRE].length === 0 && version[PATCH] === 0 || version[MAJOR] === 0 && version[MINOR] === 0)
|
||||
return version[MAJOR] + '.' + version[MINOR];
|
||||
return '~' + version.toString();
|
||||
case EXACT_RANGE:
|
||||
return version.toString();
|
||||
}
|
||||
}
|
||||
toJSON() {
|
||||
return this.toString();
|
||||
}
|
||||
static match (range, version, unstable = false) {
|
||||
if (!(version instanceof Semver))
|
||||
version = new Semver(version);
|
||||
return version.matches(range, unstable);
|
||||
}
|
||||
static isValid (range) {
|
||||
let semverRange = new SemverRange(range);
|
||||
return semverRange[TYPE] !== EXACT_RANGE || semverRange[VERSION][TAG] === undefined;
|
||||
}
|
||||
static compare (r1, r2) {
|
||||
if (!(r1 instanceof SemverRange))
|
||||
r1 = new SemverRange(r1);
|
||||
if (!(r2 instanceof SemverRange))
|
||||
r2 = new SemverRange(r2);
|
||||
if (r1[TYPE] === WILDCARD_RANGE && r2[TYPE] === WILDCARD_RANGE)
|
||||
return 0;
|
||||
if (r1[TYPE] === WILDCARD_RANGE)
|
||||
return 1;
|
||||
if (r2[TYPE] === WILDCARD_RANGE)
|
||||
return -1;
|
||||
let cmp = Semver.compare(r1[VERSION], r2[VERSION]);
|
||||
if (cmp !== 0) {
|
||||
return cmp;
|
||||
}
|
||||
if (r1[TYPE] === r2[TYPE])
|
||||
return 0;
|
||||
return r1[TYPE] > r2[TYPE] ? 1 : -1;
|
||||
}
|
||||
}
|
||||
exports.SemverRange = SemverRange;
|
||||
Loading…
Add table
Add a link
Reference in a new issue