Added Gulp.js for compiling SCSS stylesheets
This commit is contained in:
2
node_modules/sver-compat/.npmignore
generated
vendored
Normal file
2
node_modules/sver-compat/.npmignore
generated
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
package-lock.json
|
||||
test
|
||||
9
node_modules/sver-compat/.travis.yml
generated
vendored
Normal file
9
node_modules/sver-compat/.travis.yml
generated
vendored
Normal file
@ -0,0 +1,9 @@
|
||||
sudo: false
|
||||
language: node_js
|
||||
node_js:
|
||||
- '8'
|
||||
- '6'
|
||||
- '5'
|
||||
- '4'
|
||||
- '0.12'
|
||||
- '0.10'
|
||||
10
node_modules/sver-compat/LICENSE
generated
vendored
Normal file
10
node_modules/sver-compat/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.
|
||||
160
node_modules/sver-compat/README.md
generated
vendored
Normal file
160
node_modules/sver-compat/README.md
generated
vendored
Normal file
@ -0,0 +1,160 @@
|
||||
# sver-compat
|
||||
|
||||
[](https://travis-ci.org/phated/sver-compat)
|
||||
|
||||
Fork of @guybedford's [Sver](https://github.com/guybedford/sver) library. Adds compatibility for node <6.
|
||||
|
||||
```
|
||||
npm install sver-compat
|
||||
```
|
||||
|
||||
```js
|
||||
var Semver = require('sver-compat').Semver;
|
||||
var SemverRange = require('sver-compat').SemverRange;
|
||||
|
||||
// Static usage:
|
||||
SemverRange.match('^1.2.3', '1.2.4'); // true
|
||||
|
||||
// Class usage:
|
||||
var range = new SemverRange('^1.2.3');
|
||||
var 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
|
||||
var versions = ['1.2.3', '1.3.4-alpha', '1.3.4-alpha.1', '1.3.4-beta'];
|
||||
var range = new SemverRange('*');
|
||||
|
||||
var bestStableMatch = range.bestMatch(versions);
|
||||
bestStableMatch.toString(); // 1.2.3
|
||||
|
||||
var bestUnstableMatch = range.bestMatch(versions, true);
|
||||
bestUnstableMatch.toString(); // 1.3.4-beta
|
||||
```
|
||||
|
||||
### Version and Range Sorting
|
||||
|
||||
```js
|
||||
var versions = ['2.4.5', '2.3.4-alpha', '1.2.3', '2.3.4-alpha.2'];
|
||||
var 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
|
||||
var convertRange = require('sver-compat/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
|
||||
var 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
|
||||
132
node_modules/sver-compat/convert-range.js
generated
vendored
Normal file
132
node_modules/sver-compat/convert-range.js
generated
vendored
Normal file
@ -0,0 +1,132 @@
|
||||
var nodeSemver = require('semver');
|
||||
var sver = require('./sver');
|
||||
var Semver = sver.Semver;
|
||||
var SemverRange = sver.SemverRange;
|
||||
var forOf = require('es6-iterator/for-of');
|
||||
|
||||
module.exports = function nodeRangeToSemverRange (range) {
|
||||
var parsed = nodeSemver.validRange(range);
|
||||
|
||||
// tag version
|
||||
if (!parsed)
|
||||
return new SemverRange(range);
|
||||
|
||||
if (parsed === '*')
|
||||
return new SemverRange(parsed);
|
||||
|
||||
try {
|
||||
var semverRange = new SemverRange(range);
|
||||
if (!semverRange.version.tag)
|
||||
return semverRange;
|
||||
}
|
||||
catch (e) {
|
||||
if (e.code !== 'ENOTSEMVER')
|
||||
throw e;
|
||||
}
|
||||
|
||||
var outRange;
|
||||
forOf(parsed.split('||'), function(union) {
|
||||
|
||||
// compute the intersection into a lowest upper bound and a highest lower bound
|
||||
var upperBound, lowerBound, upperEq, lowerEq;
|
||||
forOf(union.split(' '), function(intersection, doBreak) {
|
||||
var lt = intersection[0] === '<';
|
||||
var gt = intersection[0] === '>';
|
||||
if (!lt && !gt) {
|
||||
upperBound = intersection;
|
||||
upperEq = true;
|
||||
return doBreak();
|
||||
}
|
||||
var eq = intersection[1] === '=';
|
||||
if (!gt) {
|
||||
var version = new Semver(intersection.substr(1 + eq));
|
||||
if (!upperBound || upperBound.gt(version)) {
|
||||
upperBound = version;
|
||||
upperEq = eq;
|
||||
}
|
||||
}
|
||||
else if (!lt) {
|
||||
var eq = intersection[1] === '=';
|
||||
var version = new Semver(intersection.substr(1 + eq));
|
||||
if (!lowerBound || lowerBound.lt(version)) {
|
||||
lowerBound = version;
|
||||
lowerEq = eq;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// if the lower bound is greater than the upper bound then just return the lower bound exactly
|
||||
if (lowerBound && upperBound && lowerBound.gt(upperBound)) {
|
||||
var 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;
|
||||
return;
|
||||
}
|
||||
|
||||
// determine the largest semver range satisfying the upper bound
|
||||
var upperRange;
|
||||
if (upperBound) {
|
||||
// if the upper bound has an equality then we return it directly
|
||||
if (upperEq) {
|
||||
var 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;
|
||||
return;
|
||||
}
|
||||
|
||||
// prerelease ignored in upper bound
|
||||
var major = 0, minor = 0, patch = 0, rangeType = '';
|
||||
|
||||
// <2.0.0 -> ^1.0.0
|
||||
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);
|
||||
}
|
||||
|
||||
// determine the lower range semver range
|
||||
var lowerRange;
|
||||
if (!lowerEq) {
|
||||
if (lowerBound.pre)
|
||||
lowerRange = new SemverRange('^' + lowerBound.major + '.' + lowerBound.minor + '.' + lowerBound.patch + '-' + lowerBound.pre.join('.') + '.1');
|
||||
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
|
||||
var 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;
|
||||
}
|
||||
30
node_modules/sver-compat/package.json
generated
vendored
Normal file
30
node_modules/sver-compat/package.json
generated
vendored
Normal file
@ -0,0 +1,30 @@
|
||||
{
|
||||
"name": "sver-compat",
|
||||
"version": "1.5.0",
|
||||
"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/phated/sver-compat.git"
|
||||
},
|
||||
"keywords": [
|
||||
"semver"
|
||||
],
|
||||
"author": "Guy Bedford",
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://github.com/phated/sver-compat/issues"
|
||||
},
|
||||
"homepage": "https://github.com/phated/sver-compat#readme",
|
||||
"devDependencies": {
|
||||
"mocha": "^3.4.2",
|
||||
"semver": "^5.3.0"
|
||||
},
|
||||
"dependencies": {
|
||||
"es6-iterator": "^2.0.1",
|
||||
"es6-symbol": "^3.1.1"
|
||||
}
|
||||
}
|
||||
400
node_modules/sver-compat/sver.js
generated
vendored
Normal file
400
node_modules/sver-compat/sver.js
generated
vendored
Normal file
@ -0,0 +1,400 @@
|
||||
'use strict';
|
||||
|
||||
var shortSemverRegEx = /^([~\^])?(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/;
|
||||
var 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;
|
||||
|
||||
var Symbol = require('es6-symbol');
|
||||
|
||||
var MAJOR = Symbol('major');
|
||||
var MINOR = Symbol('minor');
|
||||
var PATCH = Symbol('patch');
|
||||
var PRE = Symbol('pre');
|
||||
var BUILD = Symbol('build');
|
||||
var TAG = Symbol('tag');
|
||||
|
||||
var numRegEx = /^\d+$/;
|
||||
function Semver(version) {
|
||||
var 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];
|
||||
}
|
||||
Object.defineProperty(Semver.prototype, 'major', {
|
||||
get: function major () {
|
||||
return this[MAJOR];
|
||||
}
|
||||
});
|
||||
Object.defineProperty(Semver.prototype, 'minor', {
|
||||
get: function minor () {
|
||||
return this[MINOR];
|
||||
}
|
||||
});
|
||||
Object.defineProperty(Semver.prototype, 'patch', {
|
||||
get: function patch () {
|
||||
return this[PATCH];
|
||||
}
|
||||
});
|
||||
Object.defineProperty(Semver.prototype, 'pre', {
|
||||
get: function pre () {
|
||||
return this[PRE];
|
||||
}
|
||||
});
|
||||
Object.defineProperty(Semver.prototype, 'build', {
|
||||
get: function build () {
|
||||
return this[BUILD];
|
||||
}
|
||||
});
|
||||
Object.defineProperty(Semver.prototype, 'tag', {
|
||||
get: function tag () {
|
||||
return this[TAG];
|
||||
}
|
||||
});
|
||||
|
||||
Semver.prototype.gt = function gt(version) {
|
||||
return Semver.compare(this, version) === 1;
|
||||
}
|
||||
Semver.prototype.lt = function lt (version) {
|
||||
return Semver.compare(this, version) === -1;
|
||||
}
|
||||
Semver.prototype.eq = function 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 (var i = 0; i < this[PRE].length; i++) {
|
||||
if (this[PRE][i] !== version[PRE][i])
|
||||
return false;
|
||||
}
|
||||
return this[BUILD] === version[BUILD];
|
||||
}
|
||||
Semver.prototype.matches = function matches (range, unstable) {
|
||||
unstable = unstable || false;
|
||||
if (!(range instanceof SemverRange))
|
||||
range = new SemverRange(range);
|
||||
return range.has(this, unstable);
|
||||
}
|
||||
Semver.prototype.toString = function toString () {
|
||||
if (this[TAG])
|
||||
return this[TAG];
|
||||
return this[MAJOR] + '.' + this[MINOR] + '.' + this[PATCH] + (this[PRE] ? '-' + this[PRE].join('.') : '') + (this[BUILD] ? this[BUILD] : '');
|
||||
}
|
||||
Semver.isValid = function isValid (version) {
|
||||
var semver = version.match(semverRegEx);
|
||||
return semver && semver[2] !== undefined && semver[3] !== undefined;
|
||||
}
|
||||
Semver.compare = function 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
|
||||
for (var i = 0, l = Math.min(v1[PRE].length, v2[PRE].length); i < l; i++) {
|
||||
if (v1[PRE][i] !== v2[PRE][i]) {
|
||||
var isNum1 = v1[PRE][i].match(numRegEx);
|
||||
var isNum2 = v2[PRE][i].match(numRegEx);
|
||||
// numeric has lower precedence
|
||||
if (isNum1 && !isNum2)
|
||||
return -1;
|
||||
if (isNum2 && !isNum1)
|
||||
return 1;
|
||||
// compare parts
|
||||
if (isNum1 && isNum2)
|
||||
return parseInt(v1[PRE][i], 10) > parseInt(v2[PRE][i], 10) ? 1 : -1;
|
||||
else
|
||||
return v1[PRE][i] > v2[PRE][i] ? 1 : -1;
|
||||
}
|
||||
}
|
||||
if (v1[PRE].length === v2[PRE].length)
|
||||
return 0;
|
||||
// more pre-release fields win if equal
|
||||
return v1[PRE].length > v2[PRE].length ? 1 : -1;
|
||||
}
|
||||
exports.Semver = Semver;
|
||||
|
||||
var WILDCARD_RANGE = 0;
|
||||
var MAJOR_RANGE = 1;
|
||||
var STABLE_RANGE = 2;
|
||||
var EXACT_RANGE = 3;
|
||||
|
||||
var TYPE = Symbol('type');
|
||||
var VERSION = Symbol('version');
|
||||
|
||||
function SemverRange(versionRange) {
|
||||
if (versionRange === '*' || versionRange === '') {
|
||||
this[TYPE] = WILDCARD_RANGE;
|
||||
return;
|
||||
}
|
||||
var 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] || [];
|
||||
}
|
||||
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;
|
||||
}
|
||||
Object.defineProperty(SemverRange.prototype, 'isExact', {
|
||||
get: function isExact () {
|
||||
return this[TYPE] === EXACT_RANGE;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(SemverRange.prototype, 'isStable', {
|
||||
get: function isStable () {
|
||||
return this[TYPE] === STABLE_RANGE;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(SemverRange.prototype, 'isMajor', {
|
||||
get: function isMajor () {
|
||||
return this[TYPE] === MAJOR_RANGE;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(SemverRange.prototype, 'isWildcard', {
|
||||
get: function isWildcard () {
|
||||
return this[TYPE] === WILDCARD_RANGE;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(SemverRange.prototype, 'type', {
|
||||
get: function type () {
|
||||
switch (this[TYPE]) {
|
||||
case WILDCARD_RANGE:
|
||||
return 'wildcard';
|
||||
case MAJOR_RANGE:
|
||||
return 'major';
|
||||
case STABLE_RANGE:
|
||||
return 'stable';
|
||||
case EXACT_RANGE:
|
||||
return 'exact';
|
||||
}
|
||||
}
|
||||
});
|
||||
Object.defineProperty(SemverRange.prototype, 'version', {
|
||||
get: function version () {
|
||||
return this[VERSION];
|
||||
}
|
||||
});
|
||||
|
||||
SemverRange.prototype.gt = function gt (range) {
|
||||
return SemverRange.compare(this, range) === 1;
|
||||
}
|
||||
SemverRange.prototype.lt = function lt (range) {
|
||||
return SemverRange.compare(this, range) === -1;
|
||||
}
|
||||
SemverRange.prototype.eq = function eq (range) {
|
||||
return SemverRange.compare(this, range) === 0;
|
||||
}
|
||||
SemverRange.prototype.has = function has (version, unstable) {
|
||||
unstable = unstable || false;
|
||||
if (!(version instanceof Semver))
|
||||
version = new Semver(version);
|
||||
if (this[TYPE] === WILDCARD_RANGE)
|
||||
return true;
|
||||
if (this[TYPE] === EXACT_RANGE)
|
||||
return this[VERSION].eq(version);
|
||||
if (version[TAG])
|
||||
return false;
|
||||
if (version.lt(this[VERSION]))
|
||||
return false;
|
||||
if (version[PRE] && !unstable)
|
||||
return this[VERSION][MAJOR] === version[MAJOR] && this[VERSION][MINOR] === version[MINOR] && this[VERSION][PATCH] === version[PATCH];
|
||||
if (this[TYPE] === MAJOR_RANGE)
|
||||
return this[VERSION][MAJOR] === version[MAJOR];
|
||||
return this[VERSION][MAJOR] === version[MAJOR] && this[VERSION][MINOR] === version[MINOR];
|
||||
}
|
||||
SemverRange.prototype.contains = function 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);
|
||||
}
|
||||
SemverRange.prototype.intersect = function 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;
|
||||
|
||||
var 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;
|
||||
|
||||
var intersection = new SemverRange(higherRange[VERSION].toString());
|
||||
intersection[TYPE] = STABLE_RANGE;
|
||||
return intersection;
|
||||
}
|
||||
SemverRange.prototype.bestMatch = function bestMatch (versions, unstable) {
|
||||
unstable = unstable || false;
|
||||
var self = this;
|
||||
var maxSemver;
|
||||
versions.forEach(function(version) {
|
||||
if (!(version instanceof Semver))
|
||||
version = new Semver(version);
|
||||
if (!self.has(version, unstable))
|
||||
return;
|
||||
if (!unstable && version[PRE]) {
|
||||
if (self[TYPE] === WILDCARD_RANGE || !self[VERSION][PRE] || self[VERSION][MAJOR] !== version[MAJOR] ||
|
||||
self[VERSION][MINOR] !== version[MINOR] || self[VERSION][PATCH] !== version[PATCH])
|
||||
return;
|
||||
}
|
||||
if (!maxSemver) {
|
||||
maxSemver = version;
|
||||
}
|
||||
else if (Semver.compare(version, maxSemver) === 1) {
|
||||
maxSemver = version;
|
||||
}
|
||||
});
|
||||
return maxSemver;
|
||||
}
|
||||
SemverRange.prototype.toString = function toString () {
|
||||
var 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)
|
||||
return version[MAJOR] + '.' + version[MINOR];
|
||||
return '~' + version.toString();
|
||||
case EXACT_RANGE:
|
||||
return version.toString();
|
||||
}
|
||||
}
|
||||
SemverRange.match = function match (range, version, unstable) {
|
||||
unstable = unstable || false;
|
||||
if (!(version instanceof Semver))
|
||||
version = new Semver(version);
|
||||
return version.matches(range, unstable);
|
||||
}
|
||||
SemverRange.isValid = function isValid (range) {
|
||||
var semverRange = new SemverRange(range);
|
||||
return semverRange[TYPE] !== EXACT_RANGE || semverRange[VERSION][TAG] === undefined;
|
||||
}
|
||||
SemverRange.compare = function 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;
|
||||
var 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;
|
||||
Reference in New Issue
Block a user