jonaszbigda/menui_backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bcrypt -> bcryptjs

Browse Source
This commit is contained in:
Jonasz Bigda
2020-10-08 11:27:06 +02:00
parent 10a7680d90
commit 004d6c6718
392 changed files with 15 additions and 58535 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
node_modules/aproba/LICENSE generated vendored
View File

@@ -1,14 +0,0 @@
Copyright (c) 2015, Rebecca Turner <me@re-becca.org>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

94
node_modules/aproba/README.md generated vendored
View File

@@ -1,94 +0,0 @@
aproba
======
A ridiculously light-weight function argument validator
```
var validate = require("aproba")
function myfunc(a, b, c) {
// `a` must be a string, `b` a number, `c` a function
validate('SNF', arguments) // [a,b,c] is also valid
}
myfunc('test', 23, function () {}) // ok
myfunc(123, 23, function () {}) // type error
myfunc('test', 23) // missing arg error
myfunc('test', 23, function () {}, true) // too many args error
```
Valid types are:
| type | description
| :--: | :----------
| * | matches any type
| A | `Array.isArray` OR an `arguments` object
| S | typeof == string
| N | typeof == number
| F | typeof == function
| O | typeof == object and not type A and not type E
| B | typeof == boolean
| E | `instanceof Error` OR `null` **(special: see below)**
| Z | == `null`
Validation failures throw one of three exception types, distinguished by a
`code` property of `EMISSINGARG`, `EINVALIDTYPE` or `ETOOMANYARGS`.
If you pass in an invalid type then it will throw with a code of
`EUNKNOWNTYPE`.
If an **error** argument is found and is not null then the remaining
arguments are optional. That is, if you say `ESO` then that's like using a
non-magical `E` in: `E|ESO|ZSO`.
### But I have optional arguments?!
You can provide more than one signature by separating them with pipes `|`.
If any signature matches the arguments then they'll be considered valid.
So for example, say you wanted to write a signature for
`fs.createWriteStream`. The docs for it describe it thusly:
```
fs.createWriteStream(path[, options])
```
This would be a signature of `SO|S`. That is, a string and and object, or
just a string.
Now, if you read the full `fs` docs, you'll see that actually path can ALSO
be a buffer. And options can be a string, that is:
```
path <String> | <Buffer>
options <String> | <Object>
```
To reproduce this you have to fully enumerate all of the possible
combinations and that implies a signature of `SO|SS|OO|OS|S|O`. The
awkwardness is a feature: It reminds you of the complexity you're adding to
your API when you do this sort of thing.
### Browser support
This has no dependencies and should work in browsers, though you'll have
noisier stack traces.
### Why this exists
I wanted a very simple argument validator. It needed to do two things:
1. Be more concise and easier to use than assertions
2. Not encourage an infinite bikeshed of DSLs
This is why types are specified by a single character and there's no such
thing as an optional argument.
This is not intended to validate user data. This is specifically about
asserting the interface of your functions.
If you need greater validation, I encourage you to write them by hand or
look elsewhere.

105
node_modules/aproba/index.js generated vendored
View File

@@ -1,105 +0,0 @@
'use strict'
function isArguments (thingy) {
return thingy != null && typeof thingy === 'object' && thingy.hasOwnProperty('callee')
}
var types = {
'*': {label: 'any', check: function () { return true }},
A: {label: 'array', check: function (thingy) { return Array.isArray(thingy) || isArguments(thingy) }},
S: {label: 'string', check: function (thingy) { return typeof thingy === 'string' }},
N: {label: 'number', check: function (thingy) { return typeof thingy === 'number' }},
F: {label: 'function', check: function (thingy) { return typeof thingy === 'function' }},
O: {label: 'object', check: function (thingy) { return typeof thingy === 'object' && thingy != null && !types.A.check(thingy) && !types.E.check(thingy) }},
B: {label: 'boolean', check: function (thingy) { return typeof thingy === 'boolean' }},
E: {label: 'error', check: function (thingy) { return thingy instanceof Error }},
Z: {label: 'null', check: function (thingy) { return thingy == null }}
}
function addSchema (schema, arity) {
var group = arity[schema.length] = arity[schema.length] || []
if (group.indexOf(schema) === -1) group.push(schema)
}
var validate = module.exports = function (rawSchemas, args) {
if (arguments.length !== 2) throw wrongNumberOfArgs(['SA'], arguments.length)
if (!rawSchemas) throw missingRequiredArg(0, 'rawSchemas')
if (!args) throw missingRequiredArg(1, 'args')
if (!types.S.check(rawSchemas)) throw invalidType(0, ['string'], rawSchemas)
if (!types.A.check(args)) throw invalidType(1, ['array'], args)
var schemas = rawSchemas.split('|')
var arity = {}
schemas.forEach(function (schema) {
for (var ii = 0; ii < schema.length; ++ii) {
var type = schema[ii]
if (!types[type]) throw unknownType(ii, type)
}
if (/E.*E/.test(schema)) throw moreThanOneError(schema)
addSchema(schema, arity)
if (/E/.test(schema)) {
addSchema(schema.replace(/E.*$/, 'E'), arity)
addSchema(schema.replace(/E/, 'Z'), arity)
if (schema.length === 1) addSchema('', arity)
}
})
var matching = arity[args.length]
if (!matching) {
throw wrongNumberOfArgs(Object.keys(arity), args.length)
}
for (var ii = 0; ii < args.length; ++ii) {
var newMatching = matching.filter(function (schema) {
var type = schema[ii]
var typeCheck = types[type].check
return typeCheck(args[ii])
})
if (!newMatching.length) {
var labels = matching.map(function (schema) {
return types[schema[ii]].label
}).filter(function (schema) { return schema != null })
throw invalidType(ii, labels, args[ii])
}
matching = newMatching
}
}
function missingRequiredArg (num) {
return newException('EMISSINGARG', 'Missing required argument #' + (num + 1))
}
function unknownType (num, type) {
return newException('EUNKNOWNTYPE', 'Unknown type ' + type + ' in argument #' + (num + 1))
}
function invalidType (num, expectedTypes, value) {
var valueType
Object.keys(types).forEach(function (typeCode) {
if (types[typeCode].check(value)) valueType = types[typeCode].label
})
return newException('EINVALIDTYPE', 'Argument #' + (num + 1) + ': Expected ' +
englishList(expectedTypes) + ' but got ' + valueType)
}
function englishList (list) {
return list.join(', ').replace(/, ([^,]+)$/, ' or $1')
}
function wrongNumberOfArgs (expected, got) {
var english = englishList(expected)
var args = expected.every(function (ex) { return ex.length === 1 })
? 'argument'
: 'arguments'
return newException('EWRONGARGCOUNT', 'Expected ' + english + ' ' + args + ' but got ' + got)
}
function moreThanOneError (schema) {
return newException('ETOOMANYERRORTYPES',
'Only one error type per argument signature is allowed, more than one found in "' + schema + '"')
}
function newException (code, msg) {
var e = new Error(msg)
e.code = code
if (Error.captureStackTrace) Error.captureStackTrace(e, validate)
return e
}

38
node_modules/aproba/package.json generated vendored
View File

@@ -1,38 +0,0 @@
{
"name": "aproba",
"version": "1.2.0",
"description": "A ridiculously light-weight argument validator (now browser friendly)",
"main": "index.js",
"directories": {
"test": "test"
},
"dependencies": {},
"devDependencies": {
"standard": "^10.0.3",
"tap": "^10.0.2"
},
"files": [
"index.js"
],
"scripts": {
"test": "standard && tap -j3 test/*.js"
},
"repository": {
"type": "git",
"url": "https://github.com/iarna/aproba"
},
"keywords": [
"argument",
"validate"
],
"author": "Rebecca Turner <me@re-becca.org>",
"license": "ISC",
"bugs": {
"url": "https://github.com/iarna/aproba/issues"
},
"homepage": "https://github.com/iarna/aproba"
,"_resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz"
,"_integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw=="
,"_from": "aproba@1.2.0"
}

37
node_modules/are-we-there-yet/CHANGES.md generated vendored
View File

@@ -1,37 +0,0 @@
Hi, figured we could actually use a changelog now:
## 1.1.5 2018-05-24
* [#92](https://github.com/iarna/are-we-there-yet/pull/92) Fix bug where
`finish` would throw errors when including `TrackerStream` objects in
`TrackerGroup` collections. (@brianloveswords)
## 1.1.4 2017-04-21
* Fix typo in package.json
## 1.1.3 2017-04-21
* Improve documentation and limit files included in the distribution.
## 1.1.2 2016-03-15
* Add tracker group cycle detection and tests for it
## 1.1.1 2016-01-29
* Fix a typo in stream completion tracker
## 1.1.0 2016-01-29
* Rewrote completion percent computation to be low impact– no more walking a
tree of completion groups every time we need this info. Previously, with
medium sized tree of completion groups, even a relatively modest number of
calls to the top level `completed()` method would result in absurd numbers
of calls overall as it walked down the tree. We now, instead, keep track as
we bubble up changes, so the computation is limited to when data changes and
to the depth of that one branch, instead of _every_ node. (Plus, we were already
incurring _this_ cost, since we already bubbled out changes.)
* Moved different tracker types out to their own files.
* Made tests test for TOO MANY events too.
* Standarized the source code formatting

5
node_modules/are-we-there-yet/LICENSE generated vendored
View File

@@ -1,5 +0,0 @@
Copyright (c) 2015, Rebecca Turner
Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

195
node_modules/are-we-there-yet/README.md generated vendored
View File

@@ -1,195 +0,0 @@
are-we-there-yet
----------------
Track complex hiearchies of asynchronous task completion statuses. This is
intended to give you a way of recording and reporting the progress of the big
recursive fan-out and gather type workflows that are so common in async.
What you do with this completion data is up to you, but the most common use case is to
feed it to one of the many progress bar modules.
Most progress bar modules include a rudamentary version of this, but my
needs were more complex.
Usage
=====
```javascript
var TrackerGroup = require("are-we-there-yet").TrackerGroup
var top = new TrackerGroup("program")
var single = top.newItem("one thing", 100)
single.completeWork(20)
console.log(top.completed()) // 0.2
fs.stat("file", function(er, stat) {
if (er) throw er
var stream = top.newStream("file", stat.size)
console.log(top.completed()) // now 0.1 as single is 50% of the job and is 20% complete
// and 50% * 20% == 10%
fs.createReadStream("file").pipe(stream).on("data", function (chunk) {
// do stuff with chunk
})
top.on("change", function (name) {
// called each time a chunk is read from "file"
// top.completed() will start at 0.1 and fill up to 0.6 as the file is read
})
})
```
Shared Methods
==============
* var completed = tracker.completed()
Implemented in: `Tracker`, `TrackerGroup`, `TrackerStream`
Returns the ratio of completed work to work to be done. Range of 0 to 1.
* tracker.finish()
Implemented in: `Tracker`, `TrackerGroup`
Marks the tracker as completed. With a TrackerGroup this marks all of its
components as completed.
Marks all of the components of this tracker as finished, which in turn means
that `tracker.completed()` for this will now be 1.
This will result in one or more `change` events being emitted.
Events
======
All tracker objects emit `change` events with the following arguments:
```
function (name, completed, tracker)
```
`name` is the name of the tracker that originally emitted the event,
or if it didn't have one, the first containing tracker group that had one.
`completed` is the percent complete (as returned by `tracker.completed()` method).
`tracker` is the tracker object that you are listening for events on.
TrackerGroup
============
* var tracker = new TrackerGroup(**name**)
* **name** *(optional)* - The name of this tracker group, used in change
notifications if the component updating didn't have a name. Defaults to undefined.
Creates a new empty tracker aggregation group. These are trackers whose
completion status is determined by the completion status of other trackers.
* tracker.addUnit(**otherTracker**, **weight**)
* **otherTracker** - Any of the other are-we-there-yet tracker objects
* **weight** *(optional)* - The weight to give the tracker, defaults to 1.
Adds the **otherTracker** to this aggregation group. The weight determines
how long you expect this tracker to take to complete in proportion to other
units. So for instance, if you add one tracker with a weight of 1 and
another with a weight of 2, you're saying the second will take twice as long
to complete as the first. As such, the first will account for 33% of the
completion of this tracker and the second will account for the other 67%.
Returns **otherTracker**.
* var subGroup = tracker.newGroup(**name**, **weight**)
The above is exactly equivalent to:
```javascript
var subGroup = tracker.addUnit(new TrackerGroup(name), weight)
```
* var subItem = tracker.newItem(**name**, **todo**, **weight**)
The above is exactly equivalent to:
```javascript
var subItem = tracker.addUnit(new Tracker(name, todo), weight)
```
* var subStream = tracker.newStream(**name**, **todo**, **weight**)
The above is exactly equivalent to:
```javascript
var subStream = tracker.addUnit(new TrackerStream(name, todo), weight)
```
* console.log( tracker.debug() )
Returns a tree showing the completion of this tracker group and all of its
children, including recursively entering all of the children.
Tracker
=======
* var tracker = new Tracker(**name**, **todo**)
* **name** *(optional)* The name of this counter to report in change
events. Defaults to undefined.
* **todo** *(optional)* The amount of work todo (a number). Defaults to 0.
Ordinarily these are constructed as a part of a tracker group (via
`newItem`).
* var completed = tracker.completed()
Returns the ratio of completed work to work to be done. Range of 0 to 1. If
total work to be done is 0 then it will return 0.
* tracker.addWork(**todo**)
* **todo** A number to add to the amount of work to be done.
Increases the amount of work to be done, thus decreasing the completion
percentage. Triggers a `change` event.
* tracker.completeWork(**completed**)
* **completed** A number to add to the work complete
Increase the amount of work complete, thus increasing the completion percentage.
Will never increase the work completed past the amount of work todo. That is,
percentages > 100% are not allowed. Triggers a `change` event.
* tracker.finish()
Marks this tracker as finished, tracker.completed() will now be 1. Triggers
a `change` event.
TrackerStream
=============
* var tracker = new TrackerStream(**name**, **size**, **options**)
* **name** *(optional)* The name of this counter to report in change
events. Defaults to undefined.
* **size** *(optional)* The number of bytes being sent through this stream.
* **options** *(optional)* A hash of stream options
The tracker stream object is a pass through stream that updates an internal
tracker object each time a block passes through. It's intended to track
downloads, file extraction and other related activities. You use it by piping
your data source into it and then using it as your data source.
If your data has a length attribute then that's used as the amount of work
completed when the chunk is passed through. If it does not (eg, object
streams) then each chunk counts as completing 1 unit of work, so your size
should be the total number of objects being streamed.
* tracker.addWork(**todo**)
* **todo** Increase the expected overall size by **todo** bytes.
Increases the amount of work to be done, thus decreasing the completion
percentage. Triggers a `change` event.

4
node_modules/are-we-there-yet/index.js generated vendored
View File

@@ -1,4 +0,0 @@
'use strict'
exports.TrackerGroup = require('./tracker-group.js')
exports.Tracker = require('./tracker.js')
exports.TrackerStream = require('./tracker-stream.js')

39
node_modules/are-we-there-yet/package.json generated vendored
View File

@@ -1,39 +0,0 @@
{
"name": "are-we-there-yet",
"version": "1.1.5",
"description": "Keep track of the overall completion of many disparate processes",
"main": "index.js",
"scripts": {
"test": "standard && tap test/*.js"
},
"repository": {
"type": "git",
"url": "https://github.com/iarna/are-we-there-yet.git"
},
"author": "Rebecca Turner (http://re-becca.org)",
"license": "ISC",
"bugs": {
"url": "https://github.com/iarna/are-we-there-yet/issues"
},
"homepage": "https://github.com/iarna/are-we-there-yet",
"devDependencies": {
"standard": "^11.0.1",
"tap": "^12.0.1"
},
"dependencies": {
"delegates": "^1.0.0",
"readable-stream": "^2.0.6"
},
"files": [
"index.js",
"tracker-base.js",
"tracker-group.js",
"tracker-stream.js",
"tracker.js",
"CHANGES.md"
]
,"_resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.5.tgz"
,"_integrity": "sha512-5hYdAkZlcG8tOLujVDTgCT+uPX0VnpAH28gWsLfzpXYm7wP6mp5Q/gYyR7YQ0cKVJcXJnl3j2kpBan13PtQf6w=="
,"_from": "are-we-there-yet@1.1.5"
}

11
node_modules/are-we-there-yet/tracker-base.js generated vendored
View File

@@ -1,11 +0,0 @@
'use strict'
var EventEmitter = require('events').EventEmitter
var util = require('util')
var trackerId = 0
var TrackerBase = module.exports = function (name) {
EventEmitter.call(this)
this.id = ++trackerId
this.name = name
}
util.inherits(TrackerBase, EventEmitter)

107
node_modules/are-we-there-yet/tracker-group.js generated vendored
View File

@@ -1,107 +0,0 @@
'use strict'
var util = require('util')
var TrackerBase = require('./tracker-base.js')
var Tracker = require('./tracker.js')
var TrackerStream = require('./tracker-stream.js')
var TrackerGroup = module.exports = function (name) {
TrackerBase.call(this, name)
this.parentGroup = null
this.trackers = []
this.completion = {}
this.weight = {}
this.totalWeight = 0
this.finished = false
this.bubbleChange = bubbleChange(this)
}
util.inherits(TrackerGroup, TrackerBase)
function bubbleChange (trackerGroup) {
return function (name, completed, tracker) {
trackerGroup.completion[tracker.id] = completed
if (trackerGroup.finished) return
trackerGroup.emit('change', name || trackerGroup.name, trackerGroup.completed(), trackerGroup)
}
}
TrackerGroup.prototype.nameInTree = function () {
var names = []
var from = this
while (from) {
names.unshift(from.name)
from = from.parentGroup
}
return names.join('/')
}
TrackerGroup.prototype.addUnit = function (unit, weight) {
if (unit.addUnit) {
var toTest = this
while (toTest) {
if (unit === toTest) {
throw new Error(
'Attempted to add tracker group ' +
unit.name + ' to tree that already includes it ' +
this.nameInTree(this))
}
toTest = toTest.parentGroup
}
unit.parentGroup = this
}
this.weight[unit.id] = weight || 1
this.totalWeight += this.weight[unit.id]
this.trackers.push(unit)
this.completion[unit.id] = unit.completed()
unit.on('change', this.bubbleChange)
if (!this.finished) this.emit('change', unit.name, this.completion[unit.id], unit)
return unit
}
TrackerGroup.prototype.completed = function () {
if (this.trackers.length === 0) return 0
var valPerWeight = 1 / this.totalWeight
var completed = 0
for (var ii = 0; ii < this.trackers.length; ii++) {
var trackerId = this.trackers[ii].id
completed += valPerWeight * this.weight[trackerId] * this.completion[trackerId]
}
return completed
}
TrackerGroup.prototype.newGroup = function (name, weight) {
return this.addUnit(new TrackerGroup(name), weight)
}
TrackerGroup.prototype.newItem = function (name, todo, weight) {
return this.addUnit(new Tracker(name, todo), weight)
}
TrackerGroup.prototype.newStream = function (name, todo, weight) {
return this.addUnit(new TrackerStream(name, todo), weight)
}
TrackerGroup.prototype.finish = function () {
this.finished = true
if (!this.trackers.length) this.addUnit(new Tracker(), 1, true)
for (var ii = 0; ii < this.trackers.length; ii++) {
var tracker = this.trackers[ii]
tracker.finish()
tracker.removeListener('change', this.bubbleChange)
}
this.emit('change', this.name, 1, this)
}
var buffer = ' '
TrackerGroup.prototype.debug = function (depth) {
depth = depth || 0
var indent = depth ? buffer.substr(0, depth) : ''
var output = indent + (this.name || 'top') + ': ' + this.completed() + '\n'
this.trackers.forEach(function (tracker) {
if (tracker instanceof TrackerGroup) {
output += tracker.debug(depth + 1)
} else {
output += indent + ' ' + tracker.name + ': ' + tracker.completed() + '\n'
}
})
return output
}

36
node_modules/are-we-there-yet/tracker-stream.js generated vendored
View File

@@ -1,36 +0,0 @@
'use strict'
var util = require('util')
var stream = require('readable-stream')
var delegate = require('delegates')
var Tracker = require('./tracker.js')
var TrackerStream = module.exports = function (name, size, options) {
stream.Transform.call(this, options)
this.tracker = new Tracker(name, size)
this.name = name
this.id = this.tracker.id
this.tracker.on('change', delegateChange(this))
}
util.inherits(TrackerStream, stream.Transform)
function delegateChange (trackerStream) {
return function (name, completion, tracker) {
trackerStream.emit('change', name, completion, trackerStream)
}
}
TrackerStream.prototype._transform = function (data, encoding, cb) {
this.tracker.completeWork(data.length ? data.length : 1)
this.push(data)
cb()
}
TrackerStream.prototype._flush = function (cb) {
this.tracker.finish()
cb()
}
delegate(TrackerStream.prototype, 'tracker')
.method('completed')
.method('addWork')
.method('finish')

30
node_modules/are-we-there-yet/tracker.js generated vendored
View File

@@ -1,30 +0,0 @@
'use strict'
var util = require('util')
var TrackerBase = require('./tracker-base.js')
var Tracker = module.exports = function (name, todo) {
TrackerBase.call(this, name)
this.workDone = 0
this.workTodo = todo || 0
}
util.inherits(Tracker, TrackerBase)
Tracker.prototype.completed = function () {
return this.workTodo === 0 ? 0 : this.workDone / this.workTodo
}
Tracker.prototype.addWork = function (work) {
this.workTodo += work
this.emit('change', this.name, this.completed(), this)
}
Tracker.prototype.completeWork = function (work) {
this.workDone += work
if (this.workDone > this.workTodo) this.workDone = this.workTodo
this.emit('change', this.name, this.completed(), this)
}
Tracker.prototype.finish = function () {
this.workTodo = this.workDone = 1
this.emit('change', this.name, 1, this)
}

19
node_modules/bcrypt/.editorconfig generated vendored
View File

@@ -1,19 +0,0 @@
root = true
[*]
indent_style = space
indent_size = 4
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
[{package.json,*.yml}]
indent_style = space
indent_size = 2
[appveyor.yml]
end_of_line = crlf
[*.md]
trim_trailing_whitespace = false

61
node_modules/bcrypt/.travis.yml generated vendored
View File

@@ -1,61 +0,0 @@
language: node_js
services:
- docker
env:
- LINUX_CXX=g++-4.8
os:
- linux
- osx
arch:
- amd64
- arm64
node_js:
- '10'
- '11'
- '12'
- '13'
- '14'
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-4.8
- bc
before_install:
- echo Building for Node $TRAVIS_NODE_VERSION
- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then export CXX=$LINUX_CXX; $CXX --version;
fi;
- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then c++ --version; fi;
- npm install -g npm@latest
install: true
script:
- npm test
- "./node_modules/.bin/node-pre-gyp configure"
- "./node_modules/.bin/node-pre-gyp build"
- "./node_modules/.bin/node-pre-gyp package"
- |
if [[ "$TRAVIS_OS_NAME" == "linux" ]]
then
docker run -w /src --entrypoint /bin/sh -v`pwd`:/src "node:${TRAVIS_NODE_VERSION}-alpine" test_alpine.sh
fi
deploy:
provider: releases
api_key:
secure: j4gQ+m02izaw56EOd0gEStHAjCRfSCkohDWvpABiPzh1YPM9MvfEMSIvzzjV/0oMqi3Sy7eGyFv47EgQHZvouW0I8BIUzxuTCE5wP8z2SjABXCa/rz4WTppTc9d9ABq8JSdz80JxEwjmuwnYeMwWgOd7sT/VDiMxLYaXj0JWO7w=
file_glob: true
file: build/stage/*/*
on:
node_js: '10'
repo: kelektiv/node.bcrypt.js
condition: $TRAVIS_TAG =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-\w)?

167
node_modules/bcrypt/CHANGELOG.md generated vendored
View File

@@ -1,167 +0,0 @@
# 5.0.0 (2020-06-02)
* Fix the bcrypt "wrap-around" bug. It affects passwords with lengths >= 255.
It is uncommon but it's a bug nevertheless. Previous attempts to fix the bug
was unsuccessful.
* Experimental support for z/OS
* Fix a bug related to NUL in password input
* Update `node-pre-gyp` to 0.15.0
# 4.0.1 (2020-02-27)
* Fix compilation errors in Alpine linux
# 4.0.0 (2020-02-17)
* Switch to NAPI bcrypt
* Drop support for NodeJS 8
# 3.0.8 (2019-12-31)
* Update `node-pre-gyp` to 0.14
* Pre-built binaries for NodeJS 13
# 3.0.7 (2019-10-18)
* Update `nan` to 2.14.0
* Update `node-pre-gyp` to 0.13
# 3.0.6 (2019-04-11)
* Update `nan` to 2.13.2
# 3.0.5 (2019-03-19)
* Update `nan` to 2.13.1
* NodeJS 12 compatibility
* Remove `node-pre-gyp` from bundled dependencies
# 3.0.4-napi (2019-03-08)
* Sync N-API bcrypt with NAN bcrypt
# 3.0.4 (2019-02-07)
* Fix GCC, NAN and V8 deprecation warnings
# 3.0.3 (2018-12-19)
* Update `nan` to 2.12.1
# 3.0.2 (2018-10-18)
* Update `nan` to 2.11.1
# 3.0.1 (2018-09-20)
* Update `nan` to 2.11.0
# 3.0.0 (2018-07-06)
* Drop support for NodeJS <= 4
# 2.0.1 (2018-04-20)
* Update `node-pre-gyp` to allow downloading prebuilt modules
# 2.0.0 (2018-04-07)
* Make `2b` the default bcrypt version
# 1.1.0-napi (2018-01-21)
* Initial support for [N-API](https://nodejs.org/api/n-api.html)
# 1.0.3 (2016-08-23)
* update to nan v2.6.2 for NodeJS 8 support
* Fix: use npm scripts instead of node-gyp directly.
# 1.0.2 (2016-12-31)
* Fix `compare` promise rejection with invalid arguments
# 1.0.1 (2016-12-07)
* Fix destructuring imports with promises
# 1.0.0 (2016-12-04)
* add Promise support (commit 2488473)
# 0.8.7 (2016-06-09)
* update nan to 2.3.5 for improved node v6 support
# 0.8.6 (2016-04-20)
* update nan for node v6 support
# 0.8.5 (2015-08-12)
* update to nan v2 (adds support for iojs 3)
# 0.8.4 (2015-07-24)
* fix deprecation warning for the Encode API
# 0.8.3 (2015-05-06)
* update nan to 1.8.4 for iojs 2.x support
# 0.8.2 (2015-03-28)
* always use callback for generating random bytes to avoid blocking
# 0.8.1 (2015-01-18)
* update NaN to 1.5.0 for iojs support
# 0.8.0 (2014-08-03)
* migrate to NAN for bindings
# v0.5.0
* Fix for issue around empty string params throwing Errors.
* Method deprecation.
* Upgrade from libeio/ev to libuv. (shtylman)
** --- NOTE --- Breaks 0.4.x compatability
* EV_MULTIPLICITY compile flag.
# v0.4.1
* Thread safety fix around OpenSSL (GH-32). (bnoordhuis - through node)
* C++ code changes using delete and new instead of malloc and free. (shtylman)
* Compile options for speed, zoom. (shtylman)
* Move much of the type and variable checking to the JS. (shtylman)
# v0.4.0
* Added getRounds function that will tell you the number of rounds within a hash/salt
# v0.3.2
* Fix api issue with async salt gen first param
# v0.3.1
* Compile under node 0.5.x
# v0.3.0
* Internal Refactoring
* Remove pthread dependencies and locking
* Fix compiler warnings and a memory bug
# v0.2.4
* Use threadsafe functions instead of pthread mutexes
* salt validation to make sure the salt is of the correct size and format
# v0.2.3
* cygwin support
# v0.2.2
* Remove dependency on libbsd, use libssl instead
# v0.2.0
* Added async functionality
* API changes
* hashpw -> encrypt
* all old sync methods now end with _sync
* Removed libbsd(arc4random) dependency...now uses openssl which is more widely spread
# v0.1.2
* Security fix. Wasn't reading rounds in properly and was always only using 4 rounds

18
node_modules/bcrypt/ISSUE_TEMPLATE.md generated vendored
View File

@@ -1,18 +0,0 @@
Thanks for reporting a new issue with the node bcrypt module!
To help you resolve your issue faster please make sure you have done the following:
* Searched existing issues (even closed ones) for your same problem
* Make sure you have installed the required dependencies listed on the readme
* Read your npm error log for lines telling you what failed, usually it is a problem with not having the correct dependencies installed to build the native module
Once you have done the above and are still confident that the issue is with the module, please describe it below. Some things that really help get your issue resolved faster are:
* What went wrong?
* What did you expect to happen?
* Which version of nodejs and OS?
* If you find a bug, please write a failing test.
Thanks!
P.S. If it doesn't look like you read the above then your issue will likely be closed without further explanation. Sorry, but there are just too many issues opened with no useful information or questions which have been previously addressed.

19
node_modules/bcrypt/LICENSE generated vendored
View File

@@ -1,19 +0,0 @@
Copyright (c) 2010 Nicholas Campbell
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.

19
node_modules/bcrypt/Makefile generated vendored
View File

@@ -1,19 +0,0 @@
TESTS = test/*.js
all: test
build: clean compile
compile:
npm install .
npm run install
test: build
@./node_modules/nodeunit/bin/nodeunit \
$(TESTS)
clean:
rm -Rf lib/bindings/
.PHONY: clean test build

350
node_modules/bcrypt/README.md generated vendored
View File

@@ -1,350 +0,0 @@
# node.bcrypt.js
[![Build Status](https://travis-ci.org/kelektiv/node.bcrypt.js.svg?branch=master)](https://travis-ci.org/kelektiv/node.bcrypt.js)
[![Dependency Status](https://david-dm.org/kelektiv/node.bcrypt.js.svg)](https://david-dm.org/kelektiv/node.bcrypt.js)
A library to help you hash passwords.
You can read about [bcrypt in Wikipedia][bcryptwiki] as well as in the following article:
[How To Safely Store A Password][codahale]
## If You Are Submitting Bugs or Issues
Verify that the node version you are using is a _stable_ version; it has an even major release number. Unstable versions are currently not supported and issues created while using an unstable version will be closed.
If you are on a stable version of node, please provide a sufficient code snippet or log files for installation issues. The code snippet does not require you to include confidential information. However, it must provide enough information such that the problem can be replicable. Issues which are closed without resolution often lack required information for replication.
## Version Compatibility
| Node Version | Bcrypt Version |
| -------------- | ------------------|
| 0.4 | <= 0.4 |
| 0.6, 0.8, 0.10 | >= 0.5 |
| 0.11 | >= 0.8 |
| 4 | <= 2.1.0 |
| 8 | >= 1.0.3 < 4.0.0 |
| 10, 11 | >= 3 |
| 12 | >= 3.0.6 |
`node-gyp` only works with stable/released versions of node. Since the `bcrypt` module uses `node-gyp` to build and install, you'll need a stable version of node to use bcrypt. If you do not, you'll likely see an error that starts with:
```
gyp ERR! stack Error: "pre" versions of node cannot be installed, use the --nodedir flag instead
```
## Security Issues And Concerns
> Per bcrypt implementation, only the first 72 bytes of a string are used. Any extra bytes are ignored when matching passwords. Note that this is not the first 72 *characters*. It is possible for a string to contain less than 72 characters, while taking up more than 72 bytes (e.g. a UTF-8 encoded string containing emojis).
As should be the case with any security tool, this library should be scrutinized by anyone using it. If you find or suspect an issue with the code, please bring it to my attention and I'll spend some time trying to make sure that this tool is as secure as possible.
To make it easier for people using this tool to analyze what has been surveyed, here is a list of BCrypt related security issues/concerns as they've come up.
* An [issue with passwords][jtr] was found with a version of the Blowfish algorithm developed for John the Ripper. This is not present in the OpenBSD version and is thus not a problem for this module. HT [zooko][zooko].
## Compatibility Note
This library supports `$2a$` and `$2b$` prefix bcrypt hashes. `$2x$` and `$2y$` hashes are specific to bcrypt implementation developed for John the Ripper. In theory, they should be compatible with `$2b$` prefix.
Compatibility with hashes generated by other languages is not 100% guaranteed due to difference in character encodings. However, it should not be an issue for most cases.
### Migrating from v1.0.x
Hashes generated in earlier version of `bcrypt` remain 100% supported in `v2.x.x` and later versions. In most cases, the migration should be a bump in the `package.json`.
Hashes generated in `v2.x.x` using the defaults parameters will not work in earlier versions.
## Dependencies
* NodeJS
* `node-gyp`
* Please check the dependencies for this tool at: https://github.com/nodejs/node-gyp
* Windows users will need the options for c# and c++ installed with their visual studio instance.
* Python 2.x
* `OpenSSL` - This is only required to build the `bcrypt` project if you are using versions <= 0.7.7. Otherwise, we're using the builtin node crypto bindings for seed data (which use the same OpenSSL code paths we were, but don't have the external dependency).
## Install via NPM
```
npm install bcrypt
```
***Note:*** OS X users using Xcode 4.3.1 or above may need to run the following command in their terminal prior to installing if errors occur regarding xcodebuild: ```sudo xcode-select -switch /Applications/Xcode.app/Contents/Developer```
_Pre-built binaries for various NodeJS versions are made available on a best-effort basis._
Only the current stable and supported LTS releases are actively tested against. Please note that there may be an interval between the release of the module and the availabilty of the compiled modules.
Currently, we have pre-built binaries that support the following platforms:
1. Windows x32 and x64
2. Linux x64 (GlibC targets only). Pre-built binaries for MUSL targets such as Apline Linux are not available.
3. macOS
If you face an error like this:
```
node-pre-gyp ERR! Tried to download(404): https://github.com/kelektiv/node.bcrypt.js/releases/download/v1.0.2/bcrypt_lib-v1.0.2-node-v48-linux-x64.tar.gz
```
make sure you have the appropriate dependencies installed and configured for your platform. You can find installation instructions for the dependencies for some common platforms [in this page][depsinstall].
## Usage
### async (recommended)
```javascript
const bcrypt = require('bcrypt');
const saltRounds = 10;
const myPlaintextPassword = 's0/\/\P4$$w0rD';
const someOtherPlaintextPassword = 'not_bacon';
```
#### To hash a password:
Technique 1 (generate a salt and hash on separate function calls):
```javascript
bcrypt.genSalt(saltRounds, function(err, salt) {
bcrypt.hash(myPlaintextPassword, salt, function(err, hash) {
// Store hash in your password DB.
});
});
```
Technique 2 (auto-gen a salt and hash):
```javascript
bcrypt.hash(myPlaintextPassword, saltRounds, function(err, hash) {
// Store hash in your password DB.
});
```
Note that both techniques achieve the same end-result.
#### To check a password:
```javascript
// Load hash from your password DB.
bcrypt.compare(myPlaintextPassword, hash, function(err, result) {
// result == true
});
bcrypt.compare(someOtherPlaintextPassword, hash, function(err, result) {
// result == false
});
```
[A Note on Timing Attacks](#a-note-on-timing-attacks)
### with promises
bcrypt uses whatever Promise implementation is available in `global.Promise`. NodeJS >= 0.12 has a native Promise implementation built in. However, this should work in any Promises/A+ compliant implementation.
Async methods that accept a callback, return a `Promise` when callback is not specified if Promise support is available.
```javascript
bcrypt.hash(myPlaintextPassword, saltRounds).then(function(hash) {
// Store hash in your password DB.
});
```
```javascript
// Load hash from your password DB.
bcrypt.compare(myPlaintextPassword, hash).then(function(result) {
// result == true
});
bcrypt.compare(someOtherPlaintextPassword, hash).then(function(result) {
// result == false
});
```
This is also compatible with `async/await`
```javascript
async function checkUser(username, password) {
//... fetch user from a db etc.
const match = await bcrypt.compare(password, user.passwordHash);
if(match) {
//login
}
//...
}
```
### sync
```javascript
const bcrypt = require('bcrypt');
const saltRounds = 10;
const myPlaintextPassword = 's0/\/\P4$$w0rD';
const someOtherPlaintextPassword = 'not_bacon';
```
#### To hash a password:
Technique 1 (generate a salt and hash on separate function calls):
```javascript
const salt = bcrypt.genSaltSync(saltRounds);
const hash = bcrypt.hashSync(myPlaintextPassword, salt);
// Store hash in your password DB.
```
Technique 2 (auto-gen a salt and hash):
```javascript
const hash = bcrypt.hashSync(myPlaintextPassword, saltRounds);
// Store hash in your password DB.
```
As with async, both techniques achieve the same end-result.
#### To check a password:
```javascript
// Load hash from your password DB.
bcrypt.compareSync(myPlaintextPassword, hash); // true
bcrypt.compareSync(someOtherPlaintextPassword, hash); // false
```
[A Note on Timing Attacks](#a-note-on-timing-attacks)
### Why is async mode recommended over sync mode?
If you are using bcrypt on a simple script, using the sync mode is perfectly fine. However, if you are using bcrypt on a server, the async mode is recommended. This is because the hashing done by bcrypt is CPU intensive, so the sync version will block the event loop and prevent your application from servicing any other inbound requests or events. The async version uses a thread pool which does not block the main event loop.
## API
`BCrypt.`
* `genSaltSync(rounds, minor)`
* `rounds` - [OPTIONAL] - the cost of processing the data. (default - 10)
* `minor` - [OPTIONAL] - minor version of bcrypt to use. (default - b)
* `genSalt(rounds, minor, cb)`
* `rounds` - [OPTIONAL] - the cost of processing the data. (default - 10)
* `minor` - [OPTIONAL] - minor version of bcrypt to use. (default - b)
* `cb` - [OPTIONAL] - a callback to be fired once the salt has been generated. uses eio making it asynchronous. If `cb` is not specified, a `Promise` is returned if Promise support is available.
* `err` - First parameter to the callback detailing any errors.
* `salt` - Second parameter to the callback providing the generated salt.
* `hashSync(data, salt)`
* `data` - [REQUIRED] - the data to be encrypted.
* `salt` - [REQUIRED] - the salt to be used to hash the password. if specified as a number then a salt will be generated with the specified number of rounds and used (see example under **Usage**).
* `hash(data, salt, cb)`
* `data` - [REQUIRED] - the data to be encrypted.
* `salt` - [REQUIRED] - the salt to be used to hash the password. if specified as a number then a salt will be generated with the specified number of rounds and used (see example under **Usage**).
* `cb` - [OPTIONAL] - a callback to be fired once the data has been encrypted. uses eio making it asynchronous. If `cb` is not specified, a `Promise` is returned if Promise support is available.
* `err` - First parameter to the callback detailing any errors.
* `encrypted` - Second parameter to the callback providing the encrypted form.
* `compareSync(data, encrypted)`
* `data` - [REQUIRED] - data to compare.
* `encrypted` - [REQUIRED] - data to be compared to.
* `compare(data, encrypted, cb)`
* `data` - [REQUIRED] - data to compare.
* `encrypted` - [REQUIRED] - data to be compared to.
* `cb` - [OPTIONAL] - a callback to be fired once the data has been compared. uses eio making it asynchronous. If `cb` is not specified, a `Promise` is returned if Promise support is available.
* `err` - First parameter to the callback detailing any errors.
* `same` - Second parameter to the callback providing whether the data and encrypted forms match [true | false].
* `getRounds(encrypted)` - return the number of rounds used to encrypt a given hash
* `encrypted` - [REQUIRED] - hash from which the number of rounds used should be extracted.
## A Note on Rounds
A note about the cost. When you are hashing your data the module will go through a series of rounds to give you a secure hash. The value you submit there is not just the number of rounds that the module will go through to hash your data. The module will use the value you enter and go through `2^rounds` iterations of processing.
From @garthk, on a 2GHz core you can roughly expect:
rounds=8 : ~40 hashes/sec
rounds=9 : ~20 hashes/sec
rounds=10: ~10 hashes/sec
rounds=11: ~5 hashes/sec
rounds=12: 2-3 hashes/sec
rounds=13: ~1 sec/hash
rounds=14: ~1.5 sec/hash
rounds=15: ~3 sec/hash
rounds=25: ~1 hour/hash
rounds=31: 2-3 days/hash
## A Note on Timing Attacks
Because it's come up multiple times in this project, and other bcrypt projects, it needs to be said. The bcrypt comparison function is not susceptible to timing attacks. From codahale/bcrypt-ruby#42:
> One of the desired properties of a cryptographic hash function is preimage attack resistance, which means there is no shortcut for generating a message which, when hashed, produces a specific digest.
A great thread on this, in much more detail can be found @ codahale/bcrypt-ruby#43
If you're unfamiliar with timing attacks and want to learn more you can find a great writeup @ [A Lesson In Timing Attacks][timingatk]
However, timing attacks are real. And, the comparison function is _not_ time safe. What that means is that it may exit the function early in the comparison process. This happens because of the above. We don't need to be careful that an attacker is going to learn anything, and our comparison function serves to provide a comparison of hashes, it is a utility to the overall purpose of the library. If you end up using it for something else we cannot guarantee the security of the comparator. Keep that in mind as you use the library.
## Hash Info
The characters that comprise the resultant hash are `./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$`.
Resultant hashes will be 60 characters long.
## Testing
If you create a pull request, tests better pass :)
```
npm install
npm test
```
## Credits
The code for this comes from a few sources:
* blowfish.cc - OpenBSD
* bcrypt.cc - OpenBSD
* bcrypt::gen_salt - [gen_salt inclusion to bcrypt][bcryptgs]
* bcrypt_node.cc - me
## Contributors
* [Antonio Salazar Cardozo][shadowfiend] - Early MacOS X support (when we used libbsd)
* [Ben Glow][pixelglow] - Fixes for thread safety with async calls
* [Van Nguyen][thegoleffect] - Found a timing attack in the comparator
* [NewITFarmer][newitfarmer] - Initial Cygwin support
* [David Trejo][dtrejo] - packaging fixes
* [Alfred Westerveld][alfredwesterveld] - packaging fixes
* [Vincent Côté-Roy][vincentr] - Testing around concurrency issues
* [Lloyd Hilaiel][lloyd] - Documentation fixes
* [Roman Shtylman][shtylman] - Code refactoring, general rot reduction, compile options, better memory management with delete and new, and an upgrade to libuv over eio/ev.
* [Vadim Graboys][vadimg] - Code changes to support 0.5.5+
* [Ben Noordhuis][bnoordhuis] - Fixed a thread safety issue in nodejs that was perfectly mappable to this module.
* [Nate Rajlich][tootallnate] - Bindings and build process.
* [Sean McArthur][seanmonstar] - Windows Support
* [Fanie Oosthuysen][weareu] - Windows Support
* [Amitosh Swain Mahapatra][agathver] - $2b$ hash support, ES6 Promise support
* [Nicola Del Gobbo][NickNaso] - Initial implementation with N-API
## License
Unless stated elsewhere, file headers or otherwise, the license as stated in the LICENSE file.
[bcryptwiki]: https://en.wikipedia.org/wiki/Bcrypt
[bcryptgs]: http://mail-index.netbsd.org/tech-crypto/2002/05/24/msg000204.html
[codahale]: http://codahale.com/how-to-safely-store-a-password/
[gh13]: https://github.com/ncb000gt/node.bcrypt.js/issues/13
[jtr]: http://www.openwall.com/lists/oss-security/2011/06/20/2
[depsinstall]: https://github.com/kelektiv/node.bcrypt.js/wiki/Installation-Instructions
[timingatk]: https://codahale.com/a-lesson-in-timing-attacks/
[shadowfiend]:https://github.com/Shadowfiend
[thegoleffect]:https://github.com/thegoleffect
[pixelglow]:https://github.com/pixelglow
[dtrejo]:https://github.com/dtrejo
[alfredwesterveld]:https://github.com/alfredwesterveld
[newitfarmer]:https://github.com/newitfarmer
[zooko]:https://twitter.com/zooko
[vincentr]:https://twitter.com/vincentcr
[lloyd]:https://github.com/lloyd
[shtylman]:https://github.com/shtylman
[vadimg]:https://github.com/vadimg
[bnoordhuis]:https://github.com/bnoordhuis
[tootallnate]:https://github.com/tootallnate
[seanmonstar]:https://github.com/seanmonstar
[weareu]:https://github.com/weareu
[agathver]:https://github.com/Agathver
[NickNaso]: https://github.com/NickNaso

50
node_modules/bcrypt/appveyor.yml generated vendored
View File

@@ -1,50 +0,0 @@
environment:
matrix:
- nodejs_version: "10"
platform: x64
- nodejs_version: "10"
platform: x86
- nodejs_version: "11"
platform: x64
- nodejs_version: "11"
platform: x86
- nodejs_version: "12"
platform: x64
- nodejs_version: "12"
platform: x86
- nodejs_version: "13"
platform: x64
- nodejs_version: "13"
platform: x86
- nodejs_version: "14"
platform: x64
- nodejs_version: "14"
platform: x86
install:
- where npm
- where node
- ps: Install-Product node $env:nodejs_version $env:platform
- 'npm install -g npm@latest'
build: off
artifacts:
- path: 'build/stage/**/bcrypt*.tar.gz'
test_script:
- node --version
- npm --version
- npm test
after_test:
- .\node_modules\.bin\node-pre-gyp package
on_success:
- ps: >
if ($env:NODE_PRE_GYP_GITHUB_TOKEN -ne $null -and $env:APPVEYOR_REPO_TAG_NAME -match '^v(0|[1-9]+)\.(0|[1-9]+)\.(0|[1-9]+)(-\w)?$') {
echo "Publishing $env:APPVEYOR_REPO_TAG_NAME"
npm install node-pre-gyp-github@1.4.3
./node_modules/.bin/node-pre-gyp-github publish --release
}

BIN
node_modules/bcrypt/bcrypt-5.0.0.tgz generated vendored
View File

Binary file not shown.

236
node_modules/bcrypt/bcrypt.js generated vendored
View File

@@ -1,236 +0,0 @@
'use strict';
var binary = require('node-pre-gyp');
var path = require('path');
var binding_path = binary.find(path.resolve(path.join(__dirname, './package.json')));
var bindings = require(binding_path);
var crypto = require('crypto');
var promises = require('./promises');
/// generate a salt (sync)
/// @param {Number} [rounds] number of rounds (default 10)
/// @return {String} salt
module.exports.genSaltSync = function genSaltSync(rounds, minor) {
// default 10 rounds
if (!rounds) {
rounds = 10;
} else if (typeof rounds !== 'number') {
throw new Error('rounds must be a number');
}
if(!minor) {
minor = 'b';
} else if(minor !== 'b' && minor !== 'a') {
throw new Error('minor must be either "a" or "b"');
}
return bindings.gen_salt_sync(minor, rounds, crypto.randomBytes(16));
};
/// generate a salt
/// @param {Number} [rounds] number of rounds (default 10)
/// @param {Function} cb callback(err, salt)
module.exports.genSalt = function genSalt(rounds, minor, cb) {
var error;
// if callback is first argument, then use defaults for others
if (typeof arguments[0] === 'function') {
// have to set callback first otherwise arguments are overriden
cb = arguments[0];
rounds = 10;
minor = 'b';
// callback is second argument
} else if (typeof arguments[1] === 'function') {
// have to set callback first otherwise arguments are overriden
cb = arguments[1];
minor = 'b';
}
if (!cb) {
return promises.promise(genSalt, this, [rounds, minor]);
}
// default 10 rounds
if (!rounds) {
rounds = 10;
} else if (typeof rounds !== 'number') {
// callback error asynchronously
error = new Error('rounds must be a number');
return process.nextTick(function() {
cb(error);
});
}
if(!minor) {
minor = 'b'
} else if(minor !== 'b' && minor !== 'a') {
error = new Error('minor must be either "a" or "b"');
return process.nextTick(function() {
cb(error);
});
}
crypto.randomBytes(16, function(error, randomBytes) {
if (error) {
cb(error);
return;
}
bindings.gen_salt(minor, rounds, randomBytes, cb);
});
};
/// hash data using a salt
/// @param {String} data the data to encrypt
/// @param {String} salt the salt to use when hashing
/// @return {String} hash
module.exports.hashSync = function hashSync(data, salt) {
if (data == null || salt == null) {
throw new Error('data and salt arguments required');
}
if (typeof data !== 'string' || (typeof salt !== 'string' && typeof salt !== 'number')) {
throw new Error('data must be a string and salt must either be a salt string or a number of rounds');
}
if (typeof salt === 'number') {
salt = module.exports.genSaltSync(salt);
}
return bindings.encrypt_sync(data, salt);
};
/// hash data using a salt
/// @param {String} data the data to encrypt
/// @param {String} salt the salt to use when hashing
/// @param {Function} cb callback(err, hash)
module.exports.hash = function hash(data, salt, cb) {
var error;
if (typeof data === 'function') {
error = new Error('data must be a string and salt must either be a salt string or a number of rounds');
return process.nextTick(function() {
data(error);
});
}
if (typeof salt === 'function') {
error = new Error('data must be a string and salt must either be a salt string or a number of rounds');
return process.nextTick(function() {
salt(error);
});
}
// cb exists but is not a function
// return a rejecting promise
if (cb && typeof cb !== 'function') {
return promises.reject(new Error('cb must be a function or null to return a Promise'));
}
if (!cb) {
return promises.promise(hash, this, [data, salt]);
}
if (data == null || salt == null) {
error = new Error('data and salt arguments required');
return process.nextTick(function() {
cb(error);
});
}
if (typeof data !== 'string' || (typeof salt !== 'string' && typeof salt !== 'number')) {
error = new Error('data must be a string and salt must either be a salt string or a number of rounds');
return process.nextTick(function() {
cb(error);
});
}
if (typeof salt === 'number') {
return module.exports.genSalt(salt, function(err, salt) {
return bindings.encrypt(data, salt, cb);
});
}
return bindings.encrypt(data, salt, cb);
};
/// compare raw data to hash
/// @param {String} data the data to hash and compare
/// @param {String} hash expected hash
/// @return {bool} true if hashed data matches hash
module.exports.compareSync = function compareSync(data, hash) {
if (data == null || hash == null) {
throw new Error('data and hash arguments required');
}
if (typeof data !== 'string' || typeof hash !== 'string') {
throw new Error('data and hash must be strings');
}
return bindings.compare_sync(data, hash);
};
/// compare raw data to hash
/// @param {String} data the data to hash and compare
/// @param {String} hash expected hash
/// @param {Function} cb callback(err, matched) - matched is true if hashed data matches hash
module.exports.compare = function compare(data, hash, cb) {
var error;
if (typeof data === 'function') {
error = new Error('data and hash arguments required');
return process.nextTick(function() {
data(error);
});
}
if (typeof hash === 'function') {
error = new Error('data and hash arguments required');
return process.nextTick(function() {
hash(error);
});
}
// cb exists but is not a function
// return a rejecting promise
if (cb && typeof cb !== 'function') {
return promises.reject(new Error('cb must be a function or null to return a Promise'));
}
if (!cb) {
return promises.promise(compare, this, [data, hash]);
}
if (data == null || hash == null) {
error = new Error('data and hash arguments required');
return process.nextTick(function() {
cb(error);
});
}
if (typeof data !== 'string' || typeof hash !== 'string') {
error = new Error('data and hash must be strings');
return process.nextTick(function() {
cb(error);
});
}
return bindings.compare(data, hash, cb);
};
/// @param {String} hash extract rounds from this hash
/// @return {Number} the number of rounds used to encrypt a given hash
module.exports.getRounds = function getRounds(hash) {
if (hash == null) {
throw new Error('hash argument required');
}
if (typeof hash !== 'string') {
throw new Error('hash must be a string');
}
return bindings.get_rounds(hash);
};

57
node_modules/bcrypt/binding.gyp generated vendored
View File

@@ -1,57 +0,0 @@
{
'targets': [
{
'target_name': 'bcrypt_lib',
'sources': [
'src/blowfish.cc',
'src/bcrypt.cc',
'src/bcrypt_node.cc'
],
'defines': [
'_GNU_SOURCE',
],
'cflags!': [ '-fno-exceptions' ],
'cflags_cc!': [ '-fno-exceptions' ],
'include_dirs' : [
"<!@(node -p \"require('node-addon-api').include\")"
],
'dependencies': ["<!(node -p \"require('node-addon-api').gyp\")"],
'conditions': [
['OS=="win"', {
"msvs_settings": {
"VCCLCompilerTool": {
"ExceptionHandling": 1
}
},
'defines': [
'uint=unsigned int',
]
}],
['OS=="mac"', {
'cflags+': ['-fvisibility=hidden'],
"xcode_settings": {
"CLANG_CXX_LIBRARY": "libc++",
'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
'GCC_SYMBOLS_PRIVATE_EXTERN': 'YES', # -fvisibility=hidden
}
}],
[ 'OS=="zos"', {
'cflags': [
'-qascii',
],
}],
],
},
{
"target_name": "action_after_build",
"type": "none",
"dependencies": [ "<(module_name)" ],
"copies": [
{
"files": [ "<(PRODUCT_DIR)/<(module_name).node" ],
"destination": "<(module_path)"
}
]
}
]
}

21
node_modules/bcrypt/examples/async_compare.js generated vendored
View File

@@ -1,21 +0,0 @@
var bcrypt = require('../bcrypt');
var start = Date.now();
bcrypt.genSalt(10, function(err, salt) {
console.log('salt: ' + salt);
console.log('salt cb end: ' + (Date.now() - start) + 'ms');
bcrypt.hash('test', salt, function(err, crypted) {
console.log('crypted: ' + crypted);
console.log('crypted cb end: ' + (Date.now() - start) + 'ms');
console.log('rounds used from hash:', bcrypt.getRounds(crypted));
bcrypt.compare('test', crypted, function(err, res) {
console.log('compared true: ' + res);
console.log('compared true cb end: ' + (Date.now() - start) + 'ms');
});
bcrypt.compare('bacon', crypted, function(err, res) {
console.log('compared false: ' + res);
console.log('compared false cb end: ' + (Date.now() - start) + 'ms');
});
});
})
console.log('end: ' + (Date.now() - start) + 'ms');

8
node_modules/bcrypt/examples/forever_gen_salt.js generated vendored
View File

@@ -1,8 +0,0 @@
var bcrypt = require('../bcrypt');
(function printSalt() {
bcrypt.genSalt(10, function(err, salt) {
console.log('salt: ' + salt);
printSalt();
});
})()

BIN
node_modules/bcrypt/lib/binding/napi-v3/bcrypt_lib.node generated vendored
View File

Binary file not shown.

71
node_modules/bcrypt/package.json generated vendored
View File

@@ -1,71 +0,0 @@
{
"name": "bcrypt",
"description": "A bcrypt library for NodeJS.",
"keywords": [
"bcrypt",
"password",
"auth",
"authentication",
"encryption",
"crypt",
"crypto"
],
"main": "./bcrypt",
"version": "5.0.0",
"author": "Nick Campbell (https://github.com/ncb000gt)",
"engines": {
"node": ">= 10.0.0"
},
"repository": {
"type": "git",
"url": "https://github.com/kelektiv/node.bcrypt.js.git"
},
"license": "MIT",
"bugs": {
"url": "https://github.com/kelektiv/node.bcrypt.js/issues"
},
"scripts": {
"test": "npm install --build-from-source && nodeunit test",
"install": "node-pre-gyp install --fallback-to-build"
},
"dependencies": {
"node-pre-gyp": "0.15.0",
"node-addon-api": "^3.0.0"
},
"devDependencies": {
"nodeunit": "^0.11.3"
},
"contributors": [
"Antonio Salazar Cardozo <savedfastcool@gmail.com> (https://github.com/Shadowfiend)",
"Van Nguyen <the.gol.effect@gmail.com> (https://github.com/thegoleffect)",
"David Trejo <david@dtrejo.com> (https://github.com/dtrejo)",
"Ben Glow <glen.low@pixelglow.com> (https://github.com/pixelglow)",
"NewITFarmer.com <> (https://github.com/newitfarmer)",
"Alfred Westerveld <alfredwesterveld@gmail.com> (https://github.com/alfredwesterveld)",
"Vincent Côté-Roy <vincentcr@gmail.com> (https://github.com/vincentcr)",
"Lloyd Hilaiel <lloyd@hilaiel.com> (https://github.com/lloyd)",
"Roman Shtylman <shtylman@gmail.com> (https://github.com/shtylman)",
"Vadim Graboys <dimva13@gmail.com> (https://github.com/vadimg)",
"Ben Noorduis <> (https://github.com/bnoordhuis)",
"Nate Rajlich <nathan@tootallnate.net> (https://github.com/tootallnate)",
"Sean McArthur <sean.monstar@gmail.com> (https://github.com/seanmonstar)",
"Fanie Oosthuysen <fanie.oosthuysen@gmail.com> (https://github.com/weareu)",
"Amitosh Swain Mahapatra <amitosh.swain@gmail.com> (https://github.com/Agathver)",
"Corbin Crutchley <crutchcorn@gmail.com> (https://github.com/crutchcorn)",
"Nicola Del Gobbo <nicoladelgobbo@gmail.com> (https://github.com/NickNaso)"
],
"binary": {
"module_name": "bcrypt_lib",
"module_path": "./lib/binding/napi-v{napi_build_version}",
"package_name": "{module_name}-v{version}-napi-v{napi_build_version}-{platform}-{arch}-{libc}.tar.gz",
"host": "https://github.com",
"remote_path": "kelektiv/node.bcrypt.js/releases/download/v{version}",
"napi_versions": [
3
]
}
,"_resolved": "https://registry.npmjs.org/bcrypt/-/bcrypt-5.0.0.tgz"
,"_integrity": "sha512-jB0yCBl4W/kVHM2whjfyqnxTmOHkCX4kHEa5nYKSoGeYe8YrjTYTc87/6bwt1g8cmV0QrbhKriETg9jWtcREhg=="
,"_from": "bcrypt@5.0.0"
}

42
node_modules/bcrypt/promises.js generated vendored
View File

@@ -1,42 +0,0 @@
'use strict';
var Promise = global.Promise;
/// encapsulate a method with a node-style callback in a Promise
/// @param {object} 'this' of the encapsulated function
/// @param {function} function to be encapsulated
/// @param {Array-like} args to be passed to the called function
/// @return {Promise} a Promise encapsulating the function
module.exports.promise = function (fn, context, args) {
if (!Array.isArray(args)) {
args = Array.prototype.slice.call(args);
}
if (typeof fn !== 'function') {
return Promise.reject(new Error('fn must be a function'));
}
return new Promise(function(resolve, reject) {
args.push(function(err, data) {
if (err) {
reject(err);
} else {
resolve(data);
}
});
fn.apply(context, args);
});
};
/// @param {err} the error to be thrown
module.exports.reject = function (err) {
return Promise.reject(err);
};
/// changes the promise implementation that bcrypt uses
/// @param {Promise} the implementation to use
module.exports.use = function(promise) {
Promise = promise;
};

315
node_modules/bcrypt/src/bcrypt.cc generated vendored
View File

@@ -1,315 +0,0 @@
/* $OpenBSD: bcrypt.c,v 1.31 2014/03/22 23:02:03 tedu Exp $ */
/*
* Copyright (c) 1997 Niels Provos <provos@umich.edu>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/* This password hashing algorithm was designed by David Mazieres
* <dm@lcs.mit.edu> and works as follows:
*
* 1. state := InitState ()
* 2. state := ExpandKey (state, salt, password)
* 3. REPEAT rounds:
* state := ExpandKey (state, 0, password)
* state := ExpandKey (state, 0, salt)
* 4. ctext := "OrpheanBeholderScryDoubt"
* 5. REPEAT 64:
* ctext := Encrypt_ECB (state, ctext);
* 6. RETURN Concatenate (salt, ctext);
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include "node_blf.h"
#ifdef _WIN32
#define snprintf _snprintf
#endif
//#if !defined(__APPLE__) && !defined(__MACH__)
//#include "bsd/stdlib.h"
//#endif
/* This implementation is adaptable to current computing power.
* You can have up to 2^31 rounds which should be enough for some
* time to come.
*/
static void encode_base64(u_int8_t *, u_int8_t *, u_int16_t);
static void decode_base64(u_int8_t *, u_int16_t, u_int8_t *);
const static char* error = ":";
const static u_int8_t Base64Code[] =
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
const static u_int8_t index_64[128] = {
255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 0, 1, 54, 55,
56, 57, 58, 59, 60, 61, 62, 63, 255, 255,
255, 255, 255, 255, 255, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
255, 255, 255, 255, 255, 255, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, 255, 255, 255, 255, 255
};
#define CHAR64(c) ( (c) > 127 ? 255 : index_64[(c)])
static void
decode_base64(u_int8_t *buffer, u_int16_t len, u_int8_t *data)
{
u_int8_t *bp = buffer;
u_int8_t *p = data;
u_int8_t c1, c2, c3, c4;
while (bp < buffer + len) {
c1 = CHAR64(*p);
c2 = CHAR64(*(p + 1));
/* Invalid data */
if (c1 == 255 || c2 == 255)
break;
*bp++ = (c1 << 2) | ((c2 & 0x30) >> 4);
if (bp >= buffer + len)
break;
c3 = CHAR64(*(p + 2));
if (c3 == 255)
break;
*bp++ = ((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2);
if (bp >= buffer + len)
break;
c4 = CHAR64(*(p + 3));
if (c4 == 255)
break;
*bp++ = ((c3 & 0x03) << 6) | c4;
p += 4;
}
}
void
encode_salt(char *salt, u_int8_t *csalt, char minor, u_int16_t clen, u_int8_t logr)
{
salt[0] = '$';
salt[1] = BCRYPT_VERSION;
salt[2] = minor;
salt[3] = '$';
// Max rounds are 31
snprintf(salt + 4, 4, "%2.2u$", logr & 0x001F);
encode_base64((u_int8_t *) salt + 7, csalt, clen);
}
/* Generates a salt for this version of crypt.
Since versions may change. Keeping this here
seems sensible.
from: http://mail-index.netbsd.org/tech-crypto/2002/05/24/msg000204.html
*/
void
bcrypt_gensalt(char minor, u_int8_t log_rounds, u_int8_t *seed, char *gsalt)
{
if (log_rounds < 4)
log_rounds = 4;
else if (log_rounds > 31)
log_rounds = 31;
encode_salt(gsalt, seed, minor, BCRYPT_MAXSALT, log_rounds);
}
/* We handle $Vers$log2(NumRounds)$salt+passwd$
i.e. $2$04$iwouldntknowwhattosayetKdJ6iFtacBqJdKe6aW7ou */
void
bcrypt(const char *key, size_t key_len, const char *salt, char *encrypted)
{
blf_ctx state;
u_int32_t rounds, i, k;
u_int16_t j;
u_int8_t salt_len, logr, minor;
u_int8_t ciphertext[4 * BCRYPT_BLOCKS+1] = "OrpheanBeholderScryDoubt";
u_int8_t csalt[BCRYPT_MAXSALT];
u_int32_t cdata[BCRYPT_BLOCKS];
int n;
/* Discard "$" identifier */
salt++;
if (*salt > BCRYPT_VERSION) {
/* How do I handle errors ? Return ':' */
strcpy(encrypted, error);
return;
}
/* Check for minor versions */
if (salt[1] != '$') {
switch (salt[1]) {
case 'a': /* 'ab' should not yield the same as 'abab' */
case 'b': /* cap input length at 72 bytes */
minor = salt[1];
salt++;
break;
default:
strcpy(encrypted, error);
return;
}
} else
minor = 0;
/* Discard version + "$" identifier */
salt += 2;
if (salt[2] != '$') {
/* Out of sync with passwd entry */
strcpy(encrypted, error);
return;
}
/* Computer power doesn't increase linear, 2^x should be fine */
n = atoi(salt);
if (n > 31 || n < 0) {
strcpy(encrypted, error);
return;
}
logr = (u_int8_t)n;
if ((rounds = (u_int32_t) 1 << logr) < BCRYPT_MINROUNDS) {
strcpy(encrypted, error);
return;
}
/* Discard num rounds + "$" identifier */
salt += 3;
if (strlen(salt) * 3 / 4 < BCRYPT_MAXSALT) {
strcpy(encrypted, error);
return;
}
/* We dont want the base64 salt but the raw data */
decode_base64(csalt, BCRYPT_MAXSALT, (u_int8_t *) salt);
salt_len = BCRYPT_MAXSALT;
if (minor <= 'a')
key_len = (u_int8_t)(key_len + (minor >= 'a' ? 1 : 0));
else
{
/* cap key_len at the actual maximum supported
* length here to avoid integer wraparound */
if (key_len > 72)
key_len = 72;
key_len++; /* include the NUL */
}
/* Setting up S-Boxes and Subkeys */
Blowfish_initstate(&state);
Blowfish_expandstate(&state, csalt, salt_len,
(u_int8_t *) key, key_len);
for (k = 0; k < rounds; k++) {
Blowfish_expand0state(&state, (u_int8_t *) key, key_len);
Blowfish_expand0state(&state, csalt, salt_len);
}
/* This can be precomputed later */
j = 0;
for (i = 0; i < BCRYPT_BLOCKS; i++)
cdata[i] = Blowfish_stream2word(ciphertext, 4 * BCRYPT_BLOCKS, &j);
/* Now do the encryption */
for (k = 0; k < 64; k++)
blf_enc(&state, cdata, BCRYPT_BLOCKS / 2);
for (i = 0; i < BCRYPT_BLOCKS; i++) {
ciphertext[4 * i + 3] = cdata[i] & 0xff;
cdata[i] = cdata[i] >> 8;
ciphertext[4 * i + 2] = cdata[i] & 0xff;
cdata[i] = cdata[i] >> 8;
ciphertext[4 * i + 1] = cdata[i] & 0xff;
cdata[i] = cdata[i] >> 8;
ciphertext[4 * i + 0] = cdata[i] & 0xff;
}
i = 0;
encrypted[i++] = '$';
encrypted[i++] = BCRYPT_VERSION;
if (minor)
encrypted[i++] = minor;
encrypted[i++] = '$';
snprintf(encrypted + i, 4, "%2.2u$", logr & 0x001F);
encode_base64((u_int8_t *) encrypted + i + 3, csalt, BCRYPT_MAXSALT);
encode_base64((u_int8_t *) encrypted + strlen(encrypted), ciphertext,
4 * BCRYPT_BLOCKS - 1);
memset(&state, 0, sizeof(state));
memset(ciphertext, 0, sizeof(ciphertext));
memset(csalt, 0, sizeof(csalt));
memset(cdata, 0, sizeof(cdata));
}
u_int32_t bcrypt_get_rounds(const char * hash)
{
/* skip past the leading "$" */
if (!hash || *(hash++) != '$') return 0;
/* skip past version */
if (0 == (*hash++)) return 0;
if (*hash && *hash != '$') hash++;
if (*hash++ != '$') return 0;
return atoi(hash);
}
static void
encode_base64(u_int8_t *buffer, u_int8_t *data, u_int16_t len)
{
u_int8_t *bp = buffer;
u_int8_t *p = data;
u_int8_t c1, c2;
while (p < data + len) {
c1 = *p++;
*bp++ = Base64Code[(c1 >> 2)];
c1 = (c1 & 0x03) << 4;
if (p >= data + len) {
*bp++ = Base64Code[c1];
break;
}
c2 = *p++;
c1 |= (c2 >> 4) & 0x0f;
*bp++ = Base64Code[c1];
c1 = (c2 & 0x0f) << 2;
if (p >= data + len) {
*bp++ = Base64Code[c1];
break;
}
c2 = *p++;
c1 |= (c2 >> 6) & 0x03;
*bp++ = Base64Code[c1];
*bp++ = Base64Code[c2 & 0x3f];
}
*bp = '\0';
}

279
node_modules/bcrypt/src/bcrypt_node.cc generated vendored
View File

@@ -1,279 +0,0 @@
#include <napi.h>
#include <string>
#include <cstring>
#include <vector>
#include <stdlib.h> // atoi
#include "node_blf.h"
#define NODE_LESS_THAN (!(NODE_VERSION_AT_LEAST(0, 5, 4)))
namespace {
bool ValidateSalt(const char* salt) {
if (!salt || *salt != '$') {
return false;
}
// discard $
salt++;
if (*salt > BCRYPT_VERSION) {
return false;
}
if (salt[1] != '$') {
switch (salt[1]) {
case 'a':
case 'b':
salt++;
break;
default:
return false;
}
}
// discard version + $
salt += 2;
if (salt[2] != '$') {
return false;
}
int n = atoi(salt);
if (n > 31 || n < 0) {
return false;
}
if (((uint8_t)1 << (uint8_t)n) < BCRYPT_MINROUNDS) {
return false;
}
salt += 3;
if (strlen(salt) * 3 / 4 < BCRYPT_MAXSALT) {
return false;
}
return true;
}
char ToCharVersion(Napi::String str) {
std::string our_str = str.Utf8Value();
return our_str.c_str()[0];
}
/* SALT GENERATION */
class SaltAsyncWorker : public Napi::AsyncWorker {
public:
SaltAsyncWorker(Napi::Function& callback, std::string seed, ssize_t rounds, char minor_ver)
: Napi::AsyncWorker(callback, "bcrypt:SaltAsyncWorker"), seed(seed), rounds(rounds), minor_ver(minor_ver) {
}
~SaltAsyncWorker() {}
void Execute() {
char salt[_SALT_LEN];
bcrypt_gensalt(minor_ver, rounds, (u_int8_t *)&seed[0], salt);
this->salt = std::string(salt);
}
void OnOK() {
Napi::HandleScope scope(Env());
Callback().Call({Env().Undefined(), Napi::String::New(Env(), salt)});
}
private:
std::string seed;
std::string salt;
ssize_t rounds;
char minor_ver;
};
Napi::Value GenerateSalt(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() < 4) {
throw Napi::TypeError::New(env, "4 arguments expected");
}
if (!info[0].IsString()) {
throw Napi::TypeError::New(env, "First argument must be a string");
}
if (!info[2].IsBuffer() || (info[2].As<Napi::Buffer<char>>()).Length() != 16) {
throw Napi::TypeError::New(env, "Second argument must be a 16 byte Buffer");
}
const char minor_ver = ToCharVersion(info[0].As<Napi::String>());
const int32_t rounds = info[1].As<Napi::Number>();
Napi::Buffer<char> seed = info[2].As<Napi::Buffer<char>>();
Napi::Function callback = info[3].As<Napi::Function>();
SaltAsyncWorker* saltWorker = new SaltAsyncWorker(callback, std::string(seed.Data(), 16), rounds, minor_ver);
saltWorker->Queue();
return env.Undefined();
}
Napi::Value GenerateSaltSync(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() < 3) {
throw Napi::TypeError::New(env, "3 arguments expected");
}
if (!info[0].IsString()) {
throw Napi::TypeError::New(env, "First argument must be a string");
}
if (!info[2].IsBuffer() || (info[2].As<Napi::Buffer<char>>()).Length() != 16) {
throw Napi::TypeError::New(env, "Third argument must be a 16 byte Buffer");
}
const char minor_ver = ToCharVersion(info[0].As<Napi::String>());
const int32_t rounds = info[1].As<Napi::Number>();
Napi::Buffer<u_int8_t> buffer = info[2].As<Napi::Buffer<u_int8_t>>();
u_int8_t* seed = (u_int8_t*) buffer.Data();
char salt[_SALT_LEN];
bcrypt_gensalt(minor_ver, rounds, seed, salt);
return Napi::String::New(env, salt, strlen(salt));
}
/* ENCRYPT DATA - USED TO BE HASHPW */
class EncryptAsyncWorker : public Napi::AsyncWorker {
public:
EncryptAsyncWorker(Napi::Function& callback, std::string input, std::string salt)
: Napi::AsyncWorker(callback, "bcrypt:EncryptAsyncWorker"), input(input), salt(salt) {
}
~EncryptAsyncWorker() {}
void Execute() {
if (!(ValidateSalt(salt.c_str()))) {
SetError("Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue");
}
char bcrypted[_PASSWORD_LEN];
bcrypt(input.c_str(), input.length(), salt.c_str(), bcrypted);
output = std::string(bcrypted);
}
void OnOK() {
Napi::HandleScope scope(Env());
Callback().Call({Env().Undefined(),Napi::String::New(Env(), output)});
}
private:
std::string input;
std::string salt;
std::string output;
};
Napi::Value Encrypt(const Napi::CallbackInfo& info) {
if (info.Length() < 3) {
throw Napi::TypeError::New(info.Env(), "3 arguments expected");
}
std::string data = info[0].As<Napi::String>();;
std::string salt = info[1].As<Napi::String>();;
Napi::Function callback = info[2].As<Napi::Function>();
EncryptAsyncWorker* encryptWorker = new EncryptAsyncWorker(callback, data, salt);
encryptWorker->Queue();
return info.Env().Undefined();
}
Napi::Value EncryptSync(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() < 2) {
throw Napi::TypeError::New(info.Env(), "2 arguments expected");
}
std::string data = info[0].As<Napi::String>();;
std::string salt = info[1].As<Napi::String>();;
if (!(ValidateSalt(salt.c_str()))) {
throw Napi::Error::New(env, "Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue");
}
char bcrypted[_PASSWORD_LEN];
bcrypt(data.c_str(), data.length(), salt.c_str(), bcrypted);
return Napi::String::New(env, bcrypted, strlen(bcrypted));
}
/* COMPARATOR */
inline bool CompareStrings(const char* s1, const char* s2) {
return strcmp(s1, s2) == 0;
}
class CompareAsyncWorker : public Napi::AsyncWorker {
public:
CompareAsyncWorker(Napi::Function& callback, std::string input, std::string encrypted)
: Napi::AsyncWorker(callback, "bcrypt:CompareAsyncWorker"), input(input), encrypted(encrypted) {
result = false;
}
~CompareAsyncWorker() {}
void Execute() {
char bcrypted[_PASSWORD_LEN];
if (ValidateSalt(encrypted.c_str())) {
bcrypt(input.c_str(), input.length(), encrypted.c_str(), bcrypted);
result = CompareStrings(bcrypted, encrypted.c_str());
}
}
void OnOK() {
Napi::HandleScope scope(Env());
Callback().Call({Env().Undefined(), Napi::Boolean::New(Env(), result)});
}
private:
std::string input;
std::string encrypted;
bool result;
};
Napi::Value Compare(const Napi::CallbackInfo& info) {
if (info.Length() < 3) {
throw Napi::TypeError::New(info.Env(), "3 arguments expected");
}
std::string input = info[0].As<Napi::String>();
std::string encrypted = info[1].As<Napi::String>();
Napi::Function callback = info[2].As<Napi::Function>();
CompareAsyncWorker* compareWorker = new CompareAsyncWorker(callback, input, encrypted);
compareWorker->Queue();
return info.Env().Undefined();
}
Napi::Value CompareSync(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() < 2) {
throw Napi::TypeError::New(info.Env(), "2 arguments expected");
}
std::string pw = info[0].As<Napi::String>();
std::string hash = info[1].As<Napi::String>();
char bcrypted[_PASSWORD_LEN];
if (ValidateSalt(hash.c_str())) {
bcrypt(pw.c_str(), pw.length(), hash.c_str(), bcrypted);
return Napi::Boolean::New(env, CompareStrings(bcrypted, hash.c_str()));
} else {
return Napi::Boolean::New(env, false);
}
}
Napi::Value GetRounds(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
if (info.Length() < 1) {
throw Napi::TypeError::New(env, "1 argument expected");
}
std::string hash = info[0].As<Napi::String>();
u_int32_t rounds;
if (!(rounds = bcrypt_get_rounds(hash.c_str()))) {
throw Napi::Error::New(env, "invalid hash provided");
}
return Napi::Number::New(env, rounds);
}
} // anonymous namespace
Napi::Object init(Napi::Env env, Napi::Object exports) {
exports.Set(Napi::String::New(env, "gen_salt_sync"), Napi::Function::New(env, GenerateSaltSync));
exports.Set(Napi::String::New(env, "encrypt_sync"), Napi::Function::New(env, EncryptSync));
exports.Set(Napi::String::New(env, "compare_sync"), Napi::Function::New(env, CompareSync));
exports.Set(Napi::String::New(env, "get_rounds"), Napi::Function::New(env, GetRounds));
exports.Set(Napi::String::New(env, "gen_salt"), Napi::Function::New(env, GenerateSalt));
exports.Set(Napi::String::New(env, "encrypt"), Napi::Function::New(env, Encrypt));
exports.Set(Napi::String::New(env, "compare"), Napi::Function::New(env, Compare));
return exports;
}
NODE_API_MODULE(NODE_GYP_MODULE_NAME, init)

679
node_modules/bcrypt/src/blowfish.cc generated vendored
View File

@@ -1,679 +0,0 @@
/* $OpenBSD: blowfish.c,v 1.18 2004/11/02 17:23:26 hshoexer Exp $ */
/*
* Blowfish block cipher for OpenBSD
* Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
* All rights reserved.
*
* Implementation advice by David Mazieres <dm@lcs.mit.edu>.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Niels Provos.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This code is derived from section 14.3 and the given source
* in section V of Applied Cryptography, second edition.
* Blowfish is an unpatented fast block cipher designed by
* Bruce Schneier.
*/
#include "node_blf.h"
#undef inline
#ifdef __GNUC__
#define inline __inline
#else /* !__GNUC__ */
#define inline
#endif /* !__GNUC__ */
/* Function for Feistel Networks */
#define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \
+ (s)[0x100 + (((x)>>16)&0xFF)]) \
^ (s)[0x200 + (((x)>> 8)&0xFF)]) \
+ (s)[0x300 + ( (x) &0xFF)])
#define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
void
Blowfish_encipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr)
{
u_int32_t Xl;
u_int32_t Xr;
u_int32_t *s = c->S[0];
u_int32_t *p = c->P;
Xl = *xl;
Xr = *xr;
Xl ^= p[0];
BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2);
BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4);
BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6);
BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8);
BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10);
BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12);
BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14);
BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16);
*xl = Xr ^ p[17];
*xr = Xl;
}
void
Blowfish_decipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr)
{
u_int32_t Xl;
u_int32_t Xr;
u_int32_t *s = c->S[0];
u_int32_t *p = c->P;
Xl = *xl;
Xr = *xr;
Xl ^= p[17];
BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15);
BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13);
BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11);
BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9);
BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7);
BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5);
BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3);
BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1);
*xl = Xr ^ p[0];
*xr = Xl;
}
void
Blowfish_initstate(blf_ctx *c)
{
/* P-box and S-box tables initialized with digits of Pi */
static const blf_ctx initstate =
{ {
{
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
{
0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
{
0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
{
0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
},
{
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
0x9216d5d9, 0x8979fb1b
} };
*c = initstate;
}
u_int32_t
Blowfish_stream2word(const u_int8_t *data, u_int16_t databytes,
u_int16_t *current)
{
u_int8_t i;
u_int16_t j;
u_int32_t temp;
temp = 0x00000000;
j = *current;
for (i = 0; i < 4; i++, j++) {
if (j >= databytes)
j = 0;
temp = (temp << 8) | data[j];
}
*current = j;
return temp;
}
void
Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes)
{
u_int16_t i;
u_int16_t j;
u_int16_t k;
u_int32_t temp;
u_int32_t datal;
u_int32_t datar;
j = 0;
for (i = 0; i < BLF_N + 2; i++) {
/* Extract 4 int8 to 1 int32 from keystream */
temp = Blowfish_stream2word(key, keybytes, &j);
c->P[i] = c->P[i] ^ temp;
}
j = 0;
datal = 0x00000000;
datar = 0x00000000;
for (i = 0; i < BLF_N + 2; i += 2) {
Blowfish_encipher(c, &datal, &datar);
c->P[i] = datal;
c->P[i + 1] = datar;
}
for (i = 0; i < 4; i++) {
for (k = 0; k < 256; k += 2) {
Blowfish_encipher(c, &datal, &datar);
c->S[i][k] = datal;
c->S[i][k + 1] = datar;
}
}
}
void
Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes,
const u_int8_t *key, u_int16_t keybytes)
{
u_int16_t i;
u_int16_t j;
u_int16_t k;
u_int32_t temp;
u_int32_t datal;
u_int32_t datar;
j = 0;
for (i = 0; i < BLF_N + 2; i++) {
/* Extract 4 int8 to 1 int32 from keystream */
temp = Blowfish_stream2word(key, keybytes, &j);
c->P[i] = c->P[i] ^ temp;
}
j = 0;
datal = 0x00000000;
datar = 0x00000000;
for (i = 0; i < BLF_N + 2; i += 2) {
datal ^= Blowfish_stream2word(data, databytes, &j);
datar ^= Blowfish_stream2word(data, databytes, &j);
Blowfish_encipher(c, &datal, &datar);
c->P[i] = datal;
c->P[i + 1] = datar;
}
for (i = 0; i < 4; i++) {
for (k = 0; k < 256; k += 2) {
datal ^= Blowfish_stream2word(data, databytes, &j);
datar ^= Blowfish_stream2word(data, databytes, &j);
Blowfish_encipher(c, &datal, &datar);
c->S[i][k] = datal;
c->S[i][k + 1] = datar;
}
}
}
void
blf_key(blf_ctx *c, const u_int8_t *k, u_int16_t len)
{
/* Initialize S-boxes and subkeys with Pi */
Blowfish_initstate(c);
/* Transform S-boxes and subkeys with key */
Blowfish_expand0state(c, k, len);
}
void
blf_enc(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
{
u_int32_t *d;
u_int16_t i;
d = data;
for (i = 0; i < blocks; i++) {
Blowfish_encipher(c, d, d + 1);
d += 2;
}
}
void
blf_dec(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
{
u_int32_t *d;
u_int16_t i;
d = data;
for (i = 0; i < blocks; i++) {
Blowfish_decipher(c, d, d + 1);
d += 2;
}
}
void
blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
{
u_int32_t l, r;
u_int32_t i;
for (i = 0; i < len; i += 8) {
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
Blowfish_encipher(c, &l, &r);
data[0] = l >> 24 & 0xff;
data[1] = l >> 16 & 0xff;
data[2] = l >> 8 & 0xff;
data[3] = l & 0xff;
data[4] = r >> 24 & 0xff;
data[5] = r >> 16 & 0xff;
data[6] = r >> 8 & 0xff;
data[7] = r & 0xff;
data += 8;
}
}
void
blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
{
u_int32_t l, r;
u_int32_t i;
for (i = 0; i < len; i += 8) {
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
Blowfish_decipher(c, &l, &r);
data[0] = l >> 24 & 0xff;
data[1] = l >> 16 & 0xff;
data[2] = l >> 8 & 0xff;
data[3] = l & 0xff;
data[4] = r >> 24 & 0xff;
data[5] = r >> 16 & 0xff;
data[6] = r >> 8 & 0xff;
data[7] = r & 0xff;
data += 8;
}
}
void
blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len)
{
u_int32_t l, r;
u_int32_t i, j;
for (i = 0; i < len; i += 8) {
for (j = 0; j < 8; j++)
data[j] ^= iv[j];
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
Blowfish_encipher(c, &l, &r);
data[0] = l >> 24 & 0xff;
data[1] = l >> 16 & 0xff;
data[2] = l >> 8 & 0xff;
data[3] = l & 0xff;
data[4] = r >> 24 & 0xff;
data[5] = r >> 16 & 0xff;
data[6] = r >> 8 & 0xff;
data[7] = r & 0xff;
iv = data;
data += 8;
}
}
void
blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len)
{
u_int32_t l, r;
u_int8_t *iv;
u_int32_t i, j;
iv = data + len - 16;
data = data + len - 8;
for (i = len - 8; i >= 8; i -= 8) {
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
Blowfish_decipher(c, &l, &r);
data[0] = l >> 24 & 0xff;
data[1] = l >> 16 & 0xff;
data[2] = l >> 8 & 0xff;
data[3] = l & 0xff;
data[4] = r >> 24 & 0xff;
data[5] = r >> 16 & 0xff;
data[6] = r >> 8 & 0xff;
data[7] = r & 0xff;
for (j = 0; j < 8; j++)
data[j] ^= iv[j];
iv -= 8;
data -= 8;
}
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
Blowfish_decipher(c, &l, &r);
data[0] = l >> 24 & 0xff;
data[1] = l >> 16 & 0xff;
data[2] = l >> 8 & 0xff;
data[3] = l & 0xff;
data[4] = r >> 24 & 0xff;
data[5] = r >> 16 & 0xff;
data[6] = r >> 8 & 0xff;
data[7] = r & 0xff;
for (j = 0; j < 8; j++)
data[j] ^= iva[j];
}
#if 0
void
report(u_int32_t data[], u_int16_t len)
{
u_int16_t i;
for (i = 0; i < len; i += 2)
printf("Block %0hd: %08lx %08lx.\n",
i / 2, data[i], data[i + 1]);
}
void
main(void)
{
blf_ctx c;
char key[] = "AAAAA";
char key2[] = "abcdefghijklmnopqrstuvwxyz";
u_int32_t data[10];
u_int32_t data2[] =
{0x424c4f57l, 0x46495348l};
u_int16_t i;
/* First test */
for (i = 0; i < 10; i++)
data[i] = i;
blf_key(&c, (u_int8_t *) key, 5);
blf_enc(&c, data, 5);
blf_dec(&c, data, 1);
blf_dec(&c, data + 2, 4);
printf("Should read as 0 - 9.\n");
report(data, 10);
/* Second test */
blf_key(&c, (u_int8_t *) key2, strlen(key2));
blf_enc(&c, data2, 1);
printf("\nShould read as: 0x324ed0fe 0xf413a203.\n");
report(data2, 2);
blf_dec(&c, data2, 1);
report(data2, 2);
}
#endif

132
node_modules/bcrypt/src/node_blf.h generated vendored
View File

@@ -1,132 +0,0 @@
/* $OpenBSD: blf.h,v 1.7 2007/03/14 17:59:41 grunk Exp $ */
/*
* Blowfish - a fast block cipher designed by Bruce Schneier
*
* Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Niels Provos.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _NODE_BLF_H_
#define _NODE_BLF_H_
#include <sys/types.h>
/* Solaris compatibility */
#ifdef __sun
#define u_int8_t uint8_t
#define u_int16_t uint16_t
#define u_int32_t uint32_t
#define u_int64_t uint64_t
#endif
#ifdef _WIN32
#define u_int8_t unsigned __int8
#define u_int16_t unsigned __int16
#define u_int32_t unsigned __int32
#define u_int64_t unsigned __int64
#endif
/* Windows ssize_t compatibility */
#if defined(_WIN32) || defined(_WIN64)
# if defined(_WIN64)
typedef __int64 LONG_PTR;
# else
typedef long LONG_PTR;
# endif
typedef LONG_PTR SSIZE_T;
typedef SSIZE_T ssize_t;
#endif
/* z/OS compatibility */
#ifdef __MVS__
typedef unsigned char u_int8_t;
typedef unsigned short u_int16_t;
typedef unsigned int u_int32_t;
typedef unsigned long long u_int64_t;
#endif
#define BCRYPT_VERSION '2'
#define BCRYPT_MAXSALT 16 /* Precomputation is just so nice */
#define BCRYPT_BLOCKS 6 /* Ciphertext blocks */
#define BCRYPT_MINROUNDS 16 /* we have log2(rounds) in salt */
/* Schneier specifies a maximum key length of 56 bytes.
* This ensures that every key bit affects every cipher
* bit. However, the subkeys can hold up to 72 bytes.
* Warning: For normal blowfish encryption only 56 bytes
* of the key affect all cipherbits.
*/
#define BLF_N 16 /* Number of Subkeys */
#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */
#define BLF_MAXUTILIZED ((BLF_N+2)*4) /* 576 bits */
#define _PASSWORD_LEN 128 /* max length, not counting NUL */
#define _SALT_LEN 32 /* max length */
/* Blowfish context */
typedef struct BlowfishContext {
u_int32_t S[4][256]; /* S-Boxes */
u_int32_t P[BLF_N + 2]; /* Subkeys */
} blf_ctx;
/* Raw access to customized Blowfish
* blf_key is just:
* Blowfish_initstate( state )
* Blowfish_expand0state( state, key, keylen )
*/
void Blowfish_encipher(blf_ctx *, u_int32_t *, u_int32_t *);
void Blowfish_decipher(blf_ctx *, u_int32_t *, u_int32_t *);
void Blowfish_initstate(blf_ctx *);
void Blowfish_expand0state(blf_ctx *, const u_int8_t *, u_int16_t);
void Blowfish_expandstate
(blf_ctx *, const u_int8_t *, u_int16_t, const u_int8_t *, u_int16_t);
/* Standard Blowfish */
void blf_key(blf_ctx *, const u_int8_t *, u_int16_t);
void blf_enc(blf_ctx *, u_int32_t *, u_int16_t);
void blf_dec(blf_ctx *, u_int32_t *, u_int16_t);
void blf_ecb_encrypt(blf_ctx *, u_int8_t *, u_int32_t);
void blf_ecb_decrypt(blf_ctx *, u_int8_t *, u_int32_t);
void blf_cbc_encrypt(blf_ctx *, u_int8_t *, u_int8_t *, u_int32_t);
void blf_cbc_decrypt(blf_ctx *, u_int8_t *, u_int8_t *, u_int32_t);
/* Converts u_int8_t to u_int32_t */
u_int32_t Blowfish_stream2word(const u_int8_t *, u_int16_t , u_int16_t *);
/* bcrypt functions*/
void bcrypt_gensalt(char, u_int8_t, u_int8_t*, char *);
void bcrypt(const char *, size_t key_len, const char *, char *);
void encode_salt(char *, u_int8_t *, char, u_int16_t, u_int8_t);
u_int32_t bcrypt_get_rounds(const char *);
#endif

181
node_modules/bcrypt/test/async.js generated vendored
View File

@@ -1,181 +0,0 @@
var bcrypt = require('../bcrypt');
module.exports = {
test_salt_length: function(assert) {
assert.expect(1);
bcrypt.genSalt(10, function(err, salt) {
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
assert.done();
});
},
test_salt_only_cb: function(assert) {
assert.doesNotThrow(function() {bcrypt.genSalt(function(err, salt) {});}, "Should not throw an Error. Rounds and seed length are optional.");
assert.done();
},
test_salt_rounds_is_string_number: function(assert) {
bcrypt.genSalt('10', void 0, function (err, salt) {
assert.ok((err instanceof Error), "Should be an Error. genSalt requires round to be of type number.");
assert.done();
});
},
test_salt_rounds_is_string_non_number: function(assert) {
bcrypt.genSalt('z', function (err, salt) {
assert.ok((err instanceof Error), "Should throw an Error. genSalt requires rounds to of type number.");
assert.done();
});
},
test_salt_minor: function(assert) {
assert.expect(3);
bcrypt.genSalt(10, 'a', function(err, salt) {
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2a');
assert.strictEqual(split_salt[2], '10');
assert.done();
});
},
test_salt_minor_b: function(assert) {
assert.expect(3);
bcrypt.genSalt(10, 'b', function(err, salt) {
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '10');
assert.done();
});
},
test_hash: function(assert) {
assert.expect(1);
bcrypt.genSalt(10, function(err, salt) {
bcrypt.hash('password', salt, function(err, res) {
assert.ok(res, "Res should be defined.");
assert.done();
});
});
},
test_hash_rounds: function(assert) {
assert.expect(1);
bcrypt.hash('bacon', 8, function(err, hash) {
assert.strictEqual(bcrypt.getRounds(hash), 8, "Number of rounds should be that specified in the function call.");
assert.done();
});
},
test_hash_empty_strings: function(assert) {
assert.expect(2);
bcrypt.genSalt(10, function(err, salt) {
bcrypt.hash('', salt, function(err, res) {
assert.ok(res, "Res should be defined even with an empty pw.");
bcrypt.hash('', '', function(err, res) {
if (err) {
assert.ok(err);
} else {
assert.fail();
}
assert.done();
});
});
});
},
test_hash_no_params: function(assert) {
bcrypt.hash(function (err, hash) {
assert.ok(err, "Should be an error. No params.");
assert.done();
});
},
test_hash_one_param: function(assert) {
bcrypt.hash('password', function (err, hash) {
assert.ok(err, "Should be an Error. No salt.");
assert.done();
});
},
test_hash_salt_validity: function(assert) {
assert.expect(3);
bcrypt.hash('password', '$2a$10$somesaltyvaluertsetrse', function(err, enc) {
assert.strictEqual(err, undefined);
bcrypt.hash('password', 'some$value', function(err, enc) {
assert.notEqual(err, undefined);
assert.strictEqual(err.message, "Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue");
assert.done();
});
});
},
test_verify_salt: function(assert) {
assert.expect(2);
bcrypt.genSalt(10, function(err, salt) {
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '10');
assert.done();
});
},
test_verify_salt_min_rounds: function(assert) {
assert.expect(2);
bcrypt.genSalt(1, function(err, salt) {
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '04');
assert.done();
});
},
test_verify_salt_max_rounds: function(assert) {
assert.expect(2);
bcrypt.genSalt(100, function(err, salt) {
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '31');
assert.done();
});
},
test_hash_compare: function(assert) {
assert.expect(3);
bcrypt.genSalt(10, function(err, salt) {
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
bcrypt.hash("test", salt, function(err, hash) {
bcrypt.compare("test", hash, function(err, res) {
assert.strictEqual(res, true, "These hashes should be equal.");
bcrypt.compare("blah", hash, function(err, res) {
assert.strictEqual(res, false, "These hashes should not be equal.");
assert.done();
});
});
});
});
},
test_hash_compare_empty_strings: function(assert) {
assert.expect(2);
var hash = bcrypt.hashSync("test", bcrypt.genSaltSync(10));
bcrypt.compare("", hash, function(err, res) {
assert.strictEqual(res, false, "These hashes should not be equal.");
bcrypt.compare("", "", function(err, res) {
assert.strictEqual(res, false, "These hashes should not be equal.");
assert.done();
});
});
},
test_hash_compare_invalid_strings: function(assert) {
var fullString = 'envy1362987212538';
var hash = '$2a$10$XOPbrlUPQdwdJUpSrIF6X.LbE14qsMmKGhM1A8W9iqaG3vv1BD7WC';
var wut = ':';
bcrypt.compare(fullString, hash, function(err, res) {
assert.ok(res);
bcrypt.compare(fullString, wut, function(err, res) {
assert.ok(!res);
assert.done();
});
});
},
test_compare_no_params: function(assert) {
bcrypt.compare(function(err, hash) {
assert.ok(err, 'Should be an error. No params.');
assert.done();
});
},
test_hash_compare_one_param: function(assert) {
bcrypt.compare('password', function(err, hash) {
assert.ok(err, 'Should be an Error. No hash.');
assert.done();
});
}
};

48
node_modules/bcrypt/test/implementation.js generated vendored
View File

@@ -1,48 +0,0 @@
var bcrypt = require('../bcrypt');
// some tests were adapted from https://github.com/riverrun/bcrypt_elixir/blob/master/test/base_test.exs
// which are under the BSD LICENSE
module.exports = {
openwall_bcrypt_tests: function(assert) {
assert.strictEqual(bcrypt.hashSync("U*U", "$2a$05$CCCCCCCCCCCCCCCCCCCCC."), "$2a$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW");
assert.strictEqual(bcrypt.hashSync("U*U*", "$2a$05$CCCCCCCCCCCCCCCCCCCCC."), "$2a$05$CCCCCCCCCCCCCCCCCCCCC.VGOzA784oUp/Z0DY336zx7pLYAy0lwK");
assert.strictEqual(bcrypt.hashSync("U*U*U", "$2a$05$XXXXXXXXXXXXXXXXXXXXXO"), "$2a$05$XXXXXXXXXXXXXXXXXXXXXOAcXxm9kjPGEMsLznoKqmqw7tc8WCx4a");
assert.strictEqual(bcrypt.hashSync("", "$2a$05$CCCCCCCCCCCCCCCCCCCCC."), "$2a$05$CCCCCCCCCCCCCCCCCCCCC.7uG0VCzI2bS7j6ymqJi9CdcdxiRTWNy");
assert.strictEqual(bcrypt.hashSync("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", "$2a$05$abcdefghijklmnopqrstuu"), "$2a$05$abcdefghijklmnopqrstuu5s2v8.iXieOjg/.AySBTTZIIVFJeBui");
assert.done();
},
openbsd_bcrypt_tests: function(assert) {
assert.strictEqual(bcrypt.hashSync("000000000000000000000000000000000000000000000000000000000000000000000000", "$2a$05$CCCCCCCCCCCCCCCCCCCCC."), "$2a$05$CCCCCCCCCCCCCCCCCCCCC.6.O1dLNbjod2uo0DVcW.jHucKbPDdHS");
assert.strictEqual(bcrypt.hashSync("000000000000000000000000000000000000000000000000000000000000000000000000", "$2b$05$CCCCCCCCCCCCCCCCCCCCC."), "$2b$05$CCCCCCCCCCCCCCCCCCCCC.6.O1dLNbjod2uo0DVcW.jHucKbPDdHS");
assert.done();
},
test_long_passwords: function(assert) {
// bcrypt wrap-around bug in $2a$
assert.strictEqual(bcrypt.hashSync("012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234", "$2a$05$CCCCCCCCCCCCCCCCCCCCC."), "$2a$05$CCCCCCCCCCCCCCCCCCCCC.6.O1dLNbjod2uo0DVcW.jHucKbPDdHS");
assert.strictEqual(bcrypt.hashSync("01XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "$2a$05$CCCCCCCCCCCCCCCCCCCCC."), "$2a$05$CCCCCCCCCCCCCCCCCCCCC.6.O1dLNbjod2uo0DVcW.jHucKbPDdHS");
// tests for $2b$ which fixes wrap-around bugs
assert.strictEqual(bcrypt.hashSync("012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234", "$2b$05$CCCCCCCCCCCCCCCCCCCCC."), "$2b$05$CCCCCCCCCCCCCCCCCCCCC.XxrQqgBi/5Sxuq9soXzDtjIZ7w5pMfK");
assert.strictEqual(bcrypt.hashSync("0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", "$2b$05$CCCCCCCCCCCCCCCCCCCCC."), "$2b$05$CCCCCCCCCCCCCCCCCCCCC.XxrQqgBi/5Sxuq9soXzDtjIZ7w5pMfK");
assert.done();
},
test_embedded_nulls: function(assert) {
assert.strictEqual(bcrypt.hashSync("Passw\0rd123", "$2b$05$CCCCCCCCCCCCCCCCCCCCC."), "$2b$05$CCCCCCCCCCCCCCCCCCCCC.VHy/kzL4sCcX3Ib3wN5rNGiRt.TpfxS");
assert.strictEqual(bcrypt.hashSync("Passw\0 you can literally write anything after the NUL character", "$2b$05$CCCCCCCCCCCCCCCCCCCCC."), "$2b$05$CCCCCCCCCCCCCCCCCCCCC.4vJLJQ6nZ/70INTjjSZWQ0iyUek92tu");
assert.done();
},
test_shorten_salt_to_128_bits: function(assert) {
assert.strictEqual(bcrypt.hashSync("test", "$2a$10$1234567899123456789012"), "$2a$10$123456789912345678901u.OtL1A1eGK5wmvBKUDYKvuVKI7h2XBu");
assert.strictEqual(bcrypt.hashSync("U*U*", "$2a$05$CCCCCCCCCCCCCCCCCCCCCh"), "$2a$05$CCCCCCCCCCCCCCCCCCCCCeUQ7VjYZ2hd4bLYZdhuPpZMUpEUJDw1S");
assert.strictEqual(bcrypt.hashSync("U*U*", "$2a$05$CCCCCCCCCCCCCCCCCCCCCM"), "$2a$05$CCCCCCCCCCCCCCCCCCCCC.VGOzA784oUp/Z0DY336zx7pLYAy0lwK");
assert.strictEqual(bcrypt.hashSync("U*U*", "$2a$05$CCCCCCCCCCCCCCCCCCCCCA"), "$2a$05$CCCCCCCCCCCCCCCCCCCCC.VGOzA784oUp/Z0DY336zx7pLYAy0lwK");
assert.done();
},
test_consistency: function(assert) {
assert.strictEqual(bcrypt.hashSync("ππππππππ", "$2a$10$.TtQJ4Jr6isd4Hp.mVfZeu"), "$2a$10$.TtQJ4Jr6isd4Hp.mVfZeuh6Gws4rOQ/vdBczhDx.19NFK0Y84Dle");
assert.strictEqual(bcrypt.hashSync("p@5sw0rd", "$2b$12$zQ4CooEXdGqcwi0PHsgc8e"), "$2b$12$zQ4CooEXdGqcwi0PHsgc8eAf0DLXE/XHoBE8kCSGQ97rXwuClaPam");
assert.strictEqual(bcrypt.hashSync("C'est bon, la vie!", "$2b$12$cbo7LZ.wxgW4yxAA5Vqlv."), "$2b$12$cbo7LZ.wxgW4yxAA5Vqlv.KR6QFPt4qCdc9RYJNXxa/rbUOp.1sw.");
assert.strictEqual(bcrypt.hashSync("ἓν οἶδα ὅτι οὐδὲν οἶδα", "$2b$12$LeHKWR2bmrazi/6P22Jpau"), "$2b$12$LeHKWR2bmrazi/6P22JpauX5my/eKwwKpWqL7L5iEByBnxNc76FRW");
assert.done();
}
}

252
node_modules/bcrypt/test/promise.js generated vendored
View File

@@ -1,252 +0,0 @@
var bcrypt = require('../bcrypt');
var promises = require('../promises');
var fail = function(assert, error) {
assert.ok(false, error);
assert.done();
};
// only run these tests if Promise is available
if (typeof Promise !== 'undefined') {
module.exports = {
test_salt_returns_promise_on_no_args: function(assert) {
// make sure test passes with non-native implementations such as bluebird
// http://stackoverflow.com/questions/27746304/how-do-i-tell-if-an-object-is-a-promise
assert.strictEqual(typeof bcrypt.genSalt().then, 'function', "Should return a promise");
assert.done();
},
test_salt_returns_promise_on_null_callback: function(assert) {
assert.strictEqual(typeof bcrypt.genSalt(13, null, null).then,'function', "Should return a promise");
assert.done();
},
test_salt_length: function(assert) {
assert.expect(2);
bcrypt.genSalt(10).then(function(salt) {
assert.ok(salt,'salt must be defined');
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
assert.done();
});
},
test_salt_rounds_is_string_number: function(assert) {
assert.expect(1);
bcrypt.genSalt('10').then(function() {
fail(assert, "should not be resolved");
}).catch(function(err) {
assert.ok((err instanceof Error), "Should be an Error. genSalt requires round to be of type number.");
}).then(function() {
assert.done();
});
},
test_salt_rounds_is_string_non_number: function(assert) {
assert.expect(1);
bcrypt.genSalt('b').then(function() {
fail(assert, "should not be resolved");
}).catch(function(err) {
assert.ok((err instanceof Error), "Should be an Error. genSalt requires round to be of type number.");
}).then(function() {
assert.done();
});
},
test_hash_returns_promise_on_null_callback: function(assert) {
assert.strictEqual(typeof bcrypt.hash('password', 10, null).then,'function', "Should return a promise");
assert.done();
},
test_hash: function(assert) {
assert.expect(1);
bcrypt.genSalt(10).then(function(salt) {
return bcrypt.hash('password', salt);
}).then(function(res) {
assert.ok(res, "Res should be defined.");
assert.done();
});
},
test_hash_rounds: function(assert) {
assert.expect(1);
bcrypt.hash('bacon', 8).then(function(hash) {
assert.strictEqual(bcrypt.getRounds(hash), 8, "Number of rounds should be that specified in the function call.");
assert.done();
});
},
test_hash_empty_strings: function(assert) {
assert.expect(2);
Promise.all([
bcrypt.genSalt(10).then(function(salt) {
return bcrypt.hash('', salt);
}).then(function(res) {
assert.ok(res, "Res should be defined even with an empty pw.");
}),
bcrypt.hash('', '').then(function() {
fail(assert, "should not be resolved")
}).catch(function(err) {
assert.ok(err);
}),
]).then(function() {
assert.done();
});
},
test_hash_no_params: function(assert) {
assert.expect(1);
bcrypt.hash().then(function() {
fail(assert, "should not be resolved");
}).catch(function(err) {
assert.ok(err, "Should be an error. No params.");
}).then(function() {
assert.done();
});
},
test_hash_one_param: function(assert) {
assert.expect(1);
bcrypt.hash('password').then(function() {
fail(assert, "should not be resolved");
}).catch(function(err) {
assert.ok(err, "Should be an error. No salt.");
}).then(function() {
assert.done();
});
},
test_hash_salt_validity: function(assert) {
assert.expect(3);
Promise.all(
[
bcrypt.hash('password', '$2a$10$somesaltyvaluertsetrse').then(function(enc) {
assert.ok(enc, "should be resolved with a value");
}),
bcrypt.hash('password', 'some$value').then(function() {
fail(assert, "should not resolve");
}).catch(function(err) {
assert.notEqual(err, undefined);
assert.strictEqual(err.message, "Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue");
})
]).then(function() {
assert.done();
});
},
test_verify_salt: function(assert) {
assert.expect(2);
bcrypt.genSalt(10).then(function(salt) {
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '10');
assert.done();
});
},
test_verify_salt_min_rounds: function(assert) {
assert.expect(2);
bcrypt.genSalt(1).then(function(salt) {
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '04');
assert.done();
});
},
test_verify_salt_max_rounds: function(assert) {
assert.expect(2);
bcrypt.genSalt(100).then(function(salt) {
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '31');
assert.done();
});
},
test_hash_compare_returns_promise_on_null_callback: function(assert) {
assert.strictEqual(typeof bcrypt.compare('password', 'something', null).then, 'function', "Should return a promise");
assert.done();
},
test_hash_compare: function(assert) {
assert.expect(3);
bcrypt.genSalt(10).then(function(salt) {
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
return bcrypt.hash("test", salt);
}).then(function(hash) {
return Promise.all(
[
bcrypt.compare("test", hash).then(function(res) {
assert.strictEqual(res, true, "These hashes should be equal.");
}),
bcrypt.compare("blah", hash).then(function(res) {
assert.strictEqual(res, false, "These hashes should not be equal.");
})
]).then(function() {
assert.done();
});
});
},
test_hash_compare_empty_strings: function(assert) {
assert.expect(2);
var hash = bcrypt.hashSync("test", bcrypt.genSaltSync(10));
bcrypt.compare("", hash).then(function(res) {
assert.strictEqual(res, false, "These hashes should not be equal.");
return bcrypt.compare("", "");
}).then(function(res) {
assert.strictEqual(res, false, "These hashes should not be equal.");
assert.done();
});
},
test_hash_compare_invalid_strings: function(assert) {
var fullString = 'envy1362987212538';
var hash = '$2a$10$XOPbrlUPQdwdJUpSrIF6X.LbE14qsMmKGhM1A8W9iqaG3vv1BD7WC';
var wut = ':';
Promise.all([
bcrypt.compare(fullString, hash).then(function(res) {
assert.ok(res);
}),
bcrypt.compare(fullString, wut).then(function(res) {
assert.ok(!res);
})
]).then(function() {
assert.done();
});
},
test_hash_compare_no_params: function(assert) {
assert.expect(1);
bcrypt.compare().then(function() {
fail(assert, 'Should not resolve');
}).catch(function(err) {
assert.strictEqual(err.message, 'data and hash arguments required', 'Promise should be rejected when no parameters are supplied');
}).then(function() {
assert.done();
});
},
test_hash_compare_one_param: function(assert) {
assert.expect(1);
bcrypt.compare('password').then(function() {
fail(assert, 'Should not resolve');
}).catch(function(err) {
assert.strictEqual(err.message, 'data and hash arguments required', 'Promise should be rejected when no parameters are supplied');
}).then(function() {
assert.done();
});
},
test_change_promise_impl_reject: function(assert) {
promises.use({
reject: function() {
return 'mock';
}
});
assert.equal(promises.reject(), 'mock');
// need to reset the promise implementation because of require cache
promises.use(global.Promise);
assert.done();
},
test_change_promise_impl_promise: function(assert) {
promises.use({
reject: function(err) {
assert.equal(err.message, 'fn must be a function');
return 'mock';
}
});
assert.equal(promises.promise('', '', ''), 'mock');
// need to reset the promise implementation because of require cache
promises.use(global.Promise);
assert.done();
}
};
}

118
node_modules/bcrypt/test/repetitions.js generated vendored
View File

@@ -1,118 +0,0 @@
var bcrypt = require('../bcrypt');
var EXPECTED = 2500; //number of times to iterate these tests...
module.exports = {
test_salt_length: function(assert) {
assert.expect(EXPECTED);
var n = 0;
for (var i = 0; i < EXPECTED; i++) {
bcrypt.genSalt(10, function(err, salt) {
assert.equals(29, salt.length, "Salt ("+salt+") isn't the correct length. It is: " + salt.length);
n++;
});
}
function checkVal() {
if (n == EXPECTED) {
assert.done();
} else {
setTimeout(checkVal, 100);
}
}
setTimeout(checkVal, 100);
},
test_hash_length: function(assert) {
assert.expect(EXPECTED);
var SALT = '$2a$04$TnjywYklQbbZjdjBgBoA4e';
var n = 0;
for (var i = 0; i < EXPECTED; i++) {
bcrypt.hash('test', SALT, function(err, crypted) {
assert.equals(60, crypted.length, "Encrypted ("+crypted+") isn't the correct length. It is: " + crypted.length);
n++;
});
}
function checkVal() {
if (n == EXPECTED) {
assert.done();
} else {
setTimeout(checkVal, 100);
}
}
setTimeout(checkVal, 100);
},
test_compare: function(assert) {
assert.expect(EXPECTED);
var HASH = '$2a$04$TnjywYklQbbZjdjBgBoA4e9G7RJt9blgMgsCvUvus4Iv4TENB5nHy';
var n = 0;
for (var i = 0; i < EXPECTED; i++) {
bcrypt.compare('test', HASH, function(err, match) {
assert.equal(true, match, "No match.");
n++;
});
}
function checkVal() {
if (n == EXPECTED) {
assert.done();
} else {
setTimeout(checkVal, 100);
}
}
setTimeout(checkVal, 100);
},
test_hash_and_compare: function(assert) {
assert.expect((EXPECTED-1)*3);
var salt = bcrypt.genSaltSync(4),
idx = 0,
good_done = false,
bad_done = false;
function next() {
return test('secret' + Math.random());
}
function test(password) {
idx += 1;
return bcrypt.hash(password, salt, function(err, hash) {
if (err) throw err;
//console.log('\nbcrypt iter ' + idx);
assert.ok(hash);
bcrypt.compare(password, hash, function(err, res) {
//if (err) throw err;
assert.ok(res);
if (idx >= (EXPECTED-1)) {
good_done = true;
}
});
bcrypt.compare('bad' + password, hash, function(err, res) {
//if (err) throw err;
assert.ok(!res);
if (idx >= (EXPECTED-1)) {
bad_done = true;
}
});
if (idx < ((EXPECTED)-1)) {
next();
} else {
function checkDone() {
if (idx >= (EXPECTED-1) && good_done && bad_done) {
assert.done();
} else {
setTimeout(checkDone, 100);
}
}
setTimeout(checkDone, 100);
}
});
}
next();
}
};

137
node_modules/bcrypt/test/sync.js generated vendored
View File

@@ -1,137 +0,0 @@
var bcrypt = require('../bcrypt');
module.exports = {
test_salt_length: function(assert) {
var salt = bcrypt.genSaltSync(10);
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '10');
assert.done();
},
test_salt_no_params: function(assert) {
// same as test_verify_salt except using default rounds of 10
var salt = bcrypt.genSaltSync();
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '10');
assert.done();
},
test_salt_rounds_is_string_number: function(assert) {
assert.throws(function() {bcrypt.genSaltSync('10');}, "Should throw an Error. No params.");
assert.done();
},
test_salt_rounds_is_NaN: function(assert) {
assert.throws(function() {bcrypt.genSaltSync('b');}, "Should throw an Error. gen_salt requires rounds to be a number.");
assert.done();
},
test_salt_minor_a: function(assert) {
var salt = bcrypt.genSaltSync(10, 'a');
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2a');
assert.strictEqual(split_salt[2], '10');
assert.done();
},
test_salt_minor_b: function(assert) {
var salt = bcrypt.genSaltSync(10, 'b');
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '10');
assert.done();
},
test_hash: function(assert) {
assert.ok(bcrypt.hashSync('password', bcrypt.genSaltSync(10)), "Shouldn't throw an Error.");
assert.done();
},
test_hash_rounds: function(assert) {
var hash = bcrypt.hashSync('password', 8);
assert.strictEqual(bcrypt.getRounds(hash), 8, "Number of rounds should equal 8.");
assert.done();
},
test_hash_empty_string: function(assert) {
assert.ok(bcrypt.hashSync('', bcrypt.genSaltSync(10)), "Shouldn't throw an Error.");
assert.throws(function() {bcrypt.hashSync('password', '')}, "Should have thrown an Error related to the salt.");
assert.throws(function() {bcrypt.hashSync('', '')}, "Should have thrown an Error related to the salt.");
assert.done();
},
test_hash_pw_no_params: function(assert) {
assert.throws(function() {bcrypt.hashSync();}, "Should throw an Error. No Params.");
assert.done();
},
test_hash_pw_one_param: function(assert) {
assert.throws(function() {bcrypt.hashSync('password');}, "Should throw an Error. No salt.");
assert.done();
},
test_hash_pw_not_hash_str: function(assert) {
assert.throws(function() {bcrypt.hashSync('password', {});}, "Should throw an Error. hash should be a string or number.");
assert.done();
},
test_hash_salt_validity: function(assert) {
assert.expect(2);
assert.ok(bcrypt.hashSync('password', '$2a$10$somesaltyvaluertsetrse'));
assert.throws(function() {
bcrypt.hashSync('password', 'some$value');
});
assert.done();
},
test_verify_salt: function(assert) {
var salt = bcrypt.genSaltSync(10);
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '10');
assert.done();
},
test_verify_salt_min_rounds: function(assert) {
var salt = bcrypt.genSaltSync(1);
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '04');
assert.done();
},
test_verify_salt_max_rounds: function(assert) {
var salt = bcrypt.genSaltSync(100);
var split_salt = salt.split('$');
assert.strictEqual(split_salt[1], '2b');
assert.strictEqual(split_salt[2], '31');
assert.done();
},
test_hash_compare: function(assert) {
var salt = bcrypt.genSaltSync(10);
assert.strictEqual(29, salt.length, "Salt isn't the correct length.");
var hash = bcrypt.hashSync("test", salt);
assert.ok(bcrypt.compareSync("test", hash), "These hashes should be equal.");
assert.ok(!(bcrypt.compareSync("blah", hash)), "These hashes should not be equal.");
assert.done();
},
test_hash_compare_empty_strings: function(assert) {
assert.ok(!(bcrypt.compareSync("", "password")), "These hashes should not be equal.");
assert.ok(!(bcrypt.compareSync("", "")), "These hashes should not be equal.");
assert.ok(!(bcrypt.compareSync("password", "")), "These hashes should not be equal.");
assert.done();
},
test_hash_compare_invalid_strings: function(assert) {
var fullString = 'envy1362987212538';
var hash = '$2a$10$XOPbrlUPQdwdJUpSrIF6X.LbE14qsMmKGhM1A8W9iqaG3vv1BD7WC';
var wut = ':';
bcrypt.compareSync(fullString, hash, function(err, res) {
assert.ok(res);
});
bcrypt.compareSync(fullString, wut, function(err, res) {
assert.ok(!res)
});
assert.done();
},
test_getRounds: function(assert) {
var hash = bcrypt.hashSync("test", bcrypt.genSaltSync(9));
assert.strictEqual(9, bcrypt.getRounds(hash), "getRounds can't extract rounds");
assert.done();
},
test_getRounds: function(assert) {
var hash = bcrypt.hashSync("test", bcrypt.genSaltSync(9));
assert.strictEqual(9, bcrypt.getRounds(hash), "getRounds can't extract rounds");
assert.throws(function() {bcrypt.getRounds(''); }, "Must pass a valid hash to getRounds");
assert.done();
}
};

12
node_modules/bcrypt/test_alpine.sh generated vendored
View File

@@ -1,12 +0,0 @@
#!/bin/sh
set -xe
echo "Running on $(node -v)"
apk add make g++ python
npm test --unsafe-perm
./node_modules/.bin/node-pre-gyp configure
./node_modules/.bin/node-pre-gyp build
./node_modules/.bin/node-pre-gyp package

15
node_modules/chownr/LICENSE generated vendored
View File

@@ -1,15 +0,0 @@
The ISC License
Copyright (c) Isaac Z. Schlueter and Contributors
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

3
node_modules/chownr/README.md generated vendored
View File

@@ -1,3 +0,0 @@
Like `chown -R`.
Takes the same arguments as `fs.chown()`

167
node_modules/chownr/chownr.js generated vendored
View File

@@ -1,167 +0,0 @@
'use strict'
const fs = require('fs')
const path = require('path')
/* istanbul ignore next */
const LCHOWN = fs.lchown ? 'lchown' : 'chown'
/* istanbul ignore next */
const LCHOWNSYNC = fs.lchownSync ? 'lchownSync' : 'chownSync'
/* istanbul ignore next */
const needEISDIRHandled = fs.lchown &&
!process.version.match(/v1[1-9]+\./) &&
!process.version.match(/v10\.[6-9]/)
const lchownSync = (path, uid, gid) => {
try {
return fs[LCHOWNSYNC](path, uid, gid)
} catch (er) {
if (er.code !== 'ENOENT')
throw er
}
}
/* istanbul ignore next */
const chownSync = (path, uid, gid) => {
try {
return fs.chownSync(path, uid, gid)
} catch (er) {
if (er.code !== 'ENOENT')
throw er
}
}
/* istanbul ignore next */
const handleEISDIR =
needEISDIRHandled ? (path, uid, gid, cb) => er => {
// Node prior to v10 had a very questionable implementation of
// fs.lchown, which would always try to call fs.open on a directory
// Fall back to fs.chown in those cases.
if (!er || er.code !== 'EISDIR')
cb(er)
else
fs.chown(path, uid, gid, cb)
}
: (_, __, ___, cb) => cb
/* istanbul ignore next */
const handleEISDirSync =
needEISDIRHandled ? (path, uid, gid) => {
try {
return lchownSync(path, uid, gid)
} catch (er) {
if (er.code !== 'EISDIR')
throw er
chownSync(path, uid, gid)
}
}
: (path, uid, gid) => lchownSync(path, uid, gid)
// fs.readdir could only accept an options object as of node v6
const nodeVersion = process.version
let readdir = (path, options, cb) => fs.readdir(path, options, cb)
let readdirSync = (path, options) => fs.readdirSync(path, options)
/* istanbul ignore next */
if (/^v4\./.test(nodeVersion))
readdir = (path, options, cb) => fs.readdir(path, cb)
const chown = (cpath, uid, gid, cb) => {
fs[LCHOWN](cpath, uid, gid, handleEISDIR(cpath, uid, gid, er => {
// Skip ENOENT error
cb(er && er.code !== 'ENOENT' ? er : null)
}))
}
const chownrKid = (p, child, uid, gid, cb) => {
if (typeof child === 'string')
return fs.lstat(path.resolve(p, child), (er, stats) => {
// Skip ENOENT error
if (er)
return cb(er.code !== 'ENOENT' ? er : null)
stats.name = child
chownrKid(p, stats, uid, gid, cb)
})
if (child.isDirectory()) {
chownr(path.resolve(p, child.name), uid, gid, er => {
if (er)
return cb(er)
const cpath = path.resolve(p, child.name)
chown(cpath, uid, gid, cb)
})
} else {
const cpath = path.resolve(p, child.name)
chown(cpath, uid, gid, cb)
}
}
const chownr = (p, uid, gid, cb) => {
readdir(p, { withFileTypes: true }, (er, children) => {
// any error other than ENOTDIR or ENOTSUP means it's not readable,
// or doesn't exist. give up.
if (er) {
if (er.code === 'ENOENT')
return cb()
else if (er.code !== 'ENOTDIR' && er.code !== 'ENOTSUP')
return cb(er)
}
if (er || !children.length)
return chown(p, uid, gid, cb)
let len = children.length
let errState = null
const then = er => {
if (errState)
return
if (er)
return cb(errState = er)
if (-- len === 0)
return chown(p, uid, gid, cb)
}
children.forEach(child => chownrKid(p, child, uid, gid, then))
})
}
const chownrKidSync = (p, child, uid, gid) => {
if (typeof child === 'string') {
try {
const stats = fs.lstatSync(path.resolve(p, child))
stats.name = child
child = stats
} catch (er) {
if (er.code === 'ENOENT')
return
else
throw er
}
}
if (child.isDirectory())
chownrSync(path.resolve(p, child.name), uid, gid)
handleEISDirSync(path.resolve(p, child.name), uid, gid)
}
const chownrSync = (p, uid, gid) => {
let children
try {
children = readdirSync(p, { withFileTypes: true })
} catch (er) {
if (er.code === 'ENOENT')
return
else if (er.code === 'ENOTDIR' || er.code === 'ENOTSUP')
return handleEISDirSync(p, uid, gid)
else
throw er
}
if (children && children.length)
children.forEach(child => chownrKidSync(p, child, uid, gid))
return handleEISDirSync(p, uid, gid)
}
module.exports = chownr
chownr.sync = chownrSync

33
node_modules/chownr/package.json generated vendored
View File

@@ -1,33 +0,0 @@
{
"author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
"name": "chownr",
"description": "like `chown -R`",
"version": "1.1.4",
"repository": {
"type": "git",
"url": "git://github.com/isaacs/chownr.git"
},
"main": "chownr.js",
"files": [
"chownr.js"
],
"devDependencies": {
"mkdirp": "0.3",
"rimraf": "^2.7.1",
"tap": "^14.10.6"
},
"tap": {
"check-coverage": true
},
"scripts": {
"test": "tap",
"preversion": "npm test",
"postversion": "npm publish",
"prepublishOnly": "git push origin --follow-tags"
},
"license": "ISC"
,"_resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz"
,"_integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg=="
,"_from": "chownr@1.1.4"
}

32
node_modules/code-point-at/index.js generated vendored
View File

@@ -1,32 +0,0 @@
/* eslint-disable babel/new-cap, xo/throw-new-error */
'use strict';
module.exports = function (str, pos) {
if (str === null || str === undefined) {
throw TypeError();
}
str = String(str);
var size = str.length;
var i = pos ? Number(pos) : 0;
if (Number.isNaN(i)) {
i = 0;
}
if (i < 0 || i >= size) {
return undefined;
}
var first = str.charCodeAt(i);
if (first >= 0xD800 && first <= 0xDBFF && size > i + 1) {
var second = str.charCodeAt(i + 1);
if (second >= 0xDC00 && second <= 0xDFFF) {
return ((first - 0xD800) * 0x400) + second - 0xDC00 + 0x10000;
}
}
return first;
};

21
node_modules/code-point-at/license generated vendored
View File

@@ -1,21 +0,0 @@
The MIT License (MIT)
Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
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.

42
node_modules/code-point-at/package.json generated vendored
View File

@@ -1,42 +0,0 @@
{
"name": "code-point-at",
"version": "1.1.0",
"description": "ES2015 `String#codePointAt()` ponyfill",
"license": "MIT",
"repository": "sindresorhus/code-point-at",
"author": {
"name": "Sindre Sorhus",
"email": "sindresorhus@gmail.com",
"url": "sindresorhus.com"
},
"engines": {
"node": ">=0.10.0"
},
"scripts": {
"test": "xo && ava"
},
"files": [
"index.js"
],
"keywords": [
"es2015",
"ponyfill",
"polyfill",
"shim",
"string",
"str",
"code",
"point",
"at",
"codepoint",
"unicode"
],
"devDependencies": {
"ava": "*",
"xo": "^0.16.0"
}
,"_resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz"
,"_integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c="
,"_from": "code-point-at@1.1.0"
}

32
node_modules/code-point-at/readme.md generated vendored
View File

@@ -1,32 +0,0 @@
# code-point-at [![Build Status](https://travis-ci.org/sindresorhus/code-point-at.svg?branch=master)](https://travis-ci.org/sindresorhus/code-point-at)
> ES2015 [`String#codePointAt()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt) [ponyfill](https://ponyfill.com)
## Install
```
$ npm install --save code-point-at
```
## Usage
```js
var codePointAt = require('code-point-at');
codePointAt('🐴');
//=> 128052
codePointAt('abc', 2);
//=> 99
```
## API
### codePointAt(input, [position])
## License
MIT © [Sindre Sorhus](https://sindresorhus.com)

13
node_modules/console-control-strings/LICENSE generated vendored
View File

@@ -1,13 +0,0 @@
Copyright (c) 2014, Rebecca Turner <me@re-becca.org>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

145
node_modules/console-control-strings/README.md generated vendored
View File

@@ -1,145 +0,0 @@
# Console Control Strings
A library of cross-platform tested terminal/console command strings for
doing things like color and cursor positioning. This is a subset of both
ansi and vt100. All control codes included work on both Windows & Unix-like
OSes, except where noted.
## Usage
```js
var consoleControl = require('console-control-strings')
console.log(consoleControl.color('blue','bgRed', 'bold') + 'hi there' + consoleControl.color('reset'))
process.stdout.write(consoleControl.goto(75, 10))
```
## Why Another?
There are tons of libraries similar to this one. I wanted one that was:
1. Very clear about compatibility goals.
2. Could emit, for instance, a start color code without an end one.
3. Returned strings w/o writing to streams.
4. Was not weighed down with other unrelated baggage.
## Functions
### var code = consoleControl.up(_num = 1_)
Returns the escape sequence to move _num_ lines up.
### var code = consoleControl.down(_num = 1_)
Returns the escape sequence to move _num_ lines down.
### var code = consoleControl.forward(_num = 1_)
Returns the escape sequence to move _num_ lines righ.
### var code = consoleControl.back(_num = 1_)
Returns the escape sequence to move _num_ lines left.
### var code = consoleControl.nextLine(_num = 1_)
Returns the escape sequence to move _num_ lines down and to the beginning of
the line.
### var code = consoleControl.previousLine(_num = 1_)
Returns the escape sequence to move _num_ lines up and to the beginning of
the line.
### var code = consoleControl.eraseData()
Returns the escape sequence to erase everything from the current cursor
position to the bottom right of the screen. This is line based, so it
erases the remainder of the current line and all following lines.
### var code = consoleControl.eraseLine()
Returns the escape sequence to erase to the end of the current line.
### var code = consoleControl.goto(_x_, _y_)
Returns the escape sequence to move the cursor to the designated position.
Note that the origin is _1, 1_ not _0, 0_.
### var code = consoleControl.gotoSOL()
Returns the escape sequence to move the cursor to the beginning of the
current line. (That is, it returns a carriage return, `\r`.)
### var code = consoleControl.beep()
Returns the escape sequence to cause the termianl to beep. (That is, it
returns unicode character `\x0007`, a Control-G.)
### var code = consoleControl.hideCursor()
Returns the escape sequence to hide the cursor.
### var code = consoleControl.showCursor()
Returns the escape sequence to show the cursor.
### var code = consoleControl.color(_colors = []_)
### var code = consoleControl.color(_color1_, _color2_, _…_, _colorn_)
Returns the escape sequence to set the current terminal display attributes
(mostly colors). Arguments can either be a list of attributes or an array
of attributes. The difference between passing in an array or list of colors
and calling `.color` separately for each one, is that in the former case a
single escape sequence will be produced where as in the latter each change
will have its own distinct escape sequence. Each attribute can be one of:
* Reset:
* **reset** – Reset all attributes to the terminal default.
* Styles:
* **bold** – Display text as bold. In some terminals this means using a
bold font, in others this means changing the color. In some it means
both.
* **italic** – Display text as italic. This is not available in most Windows terminals.
* **underline** – Underline text. This is not available in most Windows Terminals.
* **inverse** – Invert the foreground and background colors.
* **stopBold** – Do not display text as bold.
* **stopItalic** – Do not display text as italic.
* **stopUnderline** – Do not underline text.
* **stopInverse** – Do not invert foreground and background.
* Colors:
* **white**
* **black**
* **blue**
* **cyan**
* **green**
* **magenta**
* **red**
* **yellow**
* **grey** / **brightBlack**
* **brightRed**
* **brightGreen**
* **brightYellow**
* **brightBlue**
* **brightMagenta**
* **brightCyan**
* **brightWhite**
* Background Colors:
* **bgWhite**
* **bgBlack**
* **bgBlue**
* **bgCyan**
* **bgGreen**
* **bgMagenta**
* **bgRed**
* **bgYellow**
* **bgGrey** / **bgBrightBlack**
* **bgBrightRed**
* **bgBrightGreen**
* **bgBrightYellow**
* **bgBrightBlue**
* **bgBrightMagenta**
* **bgBrightCyan**
* **bgBrightWhite**

140
node_modules/console-control-strings/README.md~ generated vendored
View File

@@ -1,140 +0,0 @@
# Console Control Strings
A library of cross-platform tested terminal/console command strings for
doing things like color and cursor positioning. This is a subset of both
ansi and vt100. All control codes included work on both Windows & Unix-like
OSes, except where noted.
## Usage
```js
var consoleControl = require('console-control-strings')
console.log(consoleControl.color('blue','bgRed', 'bold') + 'hi there' + consoleControl.color('reset'))
process.stdout.write(consoleControl.goto(75, 10))
```
## Why Another?
There are tons of libraries similar to this one. I wanted one that was:
1. Very clear about compatibility goals.
2. Could emit, for instance, a start color code without an end one.
3. Returned strings w/o writing to streams.
4. Was not weighed down with other unrelated baggage.
## Functions
### var code = consoleControl.up(_num = 1_)
Returns the escape sequence to move _num_ lines up.
### var code = consoleControl.down(_num = 1_)
Returns the escape sequence to move _num_ lines down.
### var code = consoleControl.forward(_num = 1_)
Returns the escape sequence to move _num_ lines righ.
### var code = consoleControl.back(_num = 1_)
Returns the escape sequence to move _num_ lines left.
### var code = consoleControl.nextLine(_num = 1_)
Returns the escape sequence to move _num_ lines down and to the beginning of
the line.
### var code = consoleControl.previousLine(_num = 1_)
Returns the escape sequence to move _num_ lines up and to the beginning of
the line.
### var code = consoleControl.eraseData()
Returns the escape sequence to erase everything from the current cursor
position to the bottom right of the screen. This is line based, so it
erases the remainder of the current line and all following lines.
### var code = consoleControl.eraseLine()
Returns the escape sequence to erase to the end of the current line.
### var code = consoleControl.goto(_x_, _y_)
Returns the escape sequence to move the cursor to the designated position.
Note that the origin is _1, 1_ not _0, 0_.
### var code = consoleControl.gotoSOL()
Returns the escape sequence to move the cursor to the beginning of the
current line. (That is, it returns a carriage return, `\r`.)
### var code = consoleControl.hideCursor()
Returns the escape sequence to hide the cursor.
### var code = consoleControl.showCursor()
Returns the escape sequence to show the cursor.
### var code = consoleControl.color(_colors = []_)
### var code = consoleControl.color(_color1_, _color2_, _…_, _colorn_)
Returns the escape sequence to set the current terminal display attributes
(mostly colors). Arguments can either be a list of attributes or an array
of attributes. The difference between passing in an array or list of colors
and calling `.color` separately for each one, is that in the former case a
single escape sequence will be produced where as in the latter each change
will have its own distinct escape sequence. Each attribute can be one of:
* Reset:
* **reset** – Reset all attributes to the terminal default.
* Styles:
* **bold** – Display text as bold. In some terminals this means using a
bold font, in others this means changing the color. In some it means
both.
* **italic** – Display text as italic. This is not available in most Windows terminals.
* **underline** – Underline text. This is not available in most Windows Terminals.
* **inverse** – Invert the foreground and background colors.
* **stopBold** – Do not display text as bold.
* **stopItalic** – Do not display text as italic.
* **stopUnderline** – Do not underline text.
* **stopInverse** – Do not invert foreground and background.
* Colors:
* **white**
* **black**
* **blue**
* **cyan**
* **green**
* **magenta**
* **red**
* **yellow**
* **grey** / **brightBlack**
* **brightRed**
* **brightGreen**
* **brightYellow**
* **brightBlue**
* **brightMagenta**
* **brightCyan**
* **brightWhite**
* Background Colors:
* **bgWhite**
* **bgBlack**
* **bgBlue**
* **bgCyan**
* **bgGreen**
* **bgMagenta**
* **bgRed**
* **bgYellow**
* **bgGrey** / **bgBrightBlack**
* **bgBrightRed**
* **bgBrightGreen**
* **bgBrightYellow**
* **bgBrightBlue**
* **bgBrightMagenta**
* **bgBrightCyan**
* **bgBrightWhite**

125
node_modules/console-control-strings/index.js generated vendored
View File

@@ -1,125 +0,0 @@
'use strict'
// These tables borrowed from `ansi`
var prefix = '\x1b['
exports.up = function up (num) {
return prefix + (num || '') + 'A'
}
exports.down = function down (num) {
return prefix + (num || '') + 'B'
}
exports.forward = function forward (num) {
return prefix + (num || '') + 'C'
}
exports.back = function back (num) {
return prefix + (num || '') + 'D'
}
exports.nextLine = function nextLine (num) {
return prefix + (num || '') + 'E'
}
exports.previousLine = function previousLine (num) {
return prefix + (num || '') + 'F'
}
exports.horizontalAbsolute = function horizontalAbsolute (num) {
if (num == null) throw new Error('horizontalAboslute requires a column to position to')
return prefix + num + 'G'
}
exports.eraseData = function eraseData () {
return prefix + 'J'
}
exports.eraseLine = function eraseLine () {
return prefix + 'K'
}
exports.goto = function (x, y) {
return prefix + y + ';' + x + 'H'
}
exports.gotoSOL = function () {
return '\r'
}
exports.beep = function () {
return '\x07'
}
exports.hideCursor = function hideCursor () {
return prefix + '?25l'
}
exports.showCursor = function showCursor () {
return prefix + '?25h'
}
var colors = {
reset: 0,
// styles
bold: 1,
italic: 3,
underline: 4,
inverse: 7,
// resets
stopBold: 22,
stopItalic: 23,
stopUnderline: 24,
stopInverse: 27,
// colors
white: 37,
black: 30,
blue: 34,
cyan: 36,
green: 32,
magenta: 35,
red: 31,
yellow: 33,
bgWhite: 47,
bgBlack: 40,
bgBlue: 44,
bgCyan: 46,
bgGreen: 42,
bgMagenta: 45,
bgRed: 41,
bgYellow: 43,
grey: 90,
brightBlack: 90,
brightRed: 91,
brightGreen: 92,
brightYellow: 93,
brightBlue: 94,
brightMagenta: 95,
brightCyan: 96,
brightWhite: 97,
bgGrey: 100,
bgBrightBlack: 100,
bgBrightRed: 101,
bgBrightGreen: 102,
bgBrightYellow: 103,
bgBrightBlue: 104,
bgBrightMagenta: 105,
bgBrightCyan: 106,
bgBrightWhite: 107
}
exports.color = function color (colorWith) {
if (arguments.length !== 1 || !Array.isArray(colorWith)) {
colorWith = Array.prototype.slice.call(arguments)
}
return prefix + colorWith.map(colorNameToCode).join(';') + 'm'
}
function colorNameToCode (color) {
if (colors[color] != null) return colors[color]
throw new Error('Unknown color or style name: ' + color)
}

31
node_modules/console-control-strings/package.json generated vendored
View File

@@ -1,31 +0,0 @@
{
"name": "console-control-strings",
"version": "1.1.0",
"description": "A library of cross-platform tested terminal/console command strings for doing things like color and cursor positioning. This is a subset of both ansi and vt100. All control codes included work on both Windows & Unix-like OSes, except where noted.",
"main": "index.js",
"directories": {
"test": "test"
},
"scripts": {
"test": "standard && tap test/*.js"
},
"repository": {
"type": "git",
"url": "https://github.com/iarna/console-control-strings"
},
"keywords": [],
"author": "Rebecca Turner <me@re-becca.org> (http://re-becca.org/)",
"license": "ISC",
"files": [
"LICENSE",
"index.js"
],
"devDependencies": {
"standard": "^7.1.2",
"tap": "^5.7.2"
}
,"_resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz"
,"_integrity": "sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4="
,"_from": "console-control-strings@1.1.0"
}

1
node_modules/delegates/.npmignore generated vendored
View File

@@ -1 +0,0 @@
node_modules/

22
node_modules/delegates/History.md generated vendored
View File

@@ -1,22 +0,0 @@
1.0.0 / 2015-12-14
==================
* Merge pull request #12 from kasicka/master
* Add license text
0.1.0 / 2014-10-17
==================
* adds `.fluent()` to api
0.0.3 / 2014-01-13
==================
* fix receiver for .method()
0.0.2 / 2014-01-13
==================
* Object.defineProperty() sucks
* Initial commit

20
node_modules/delegates/License generated vendored
View File

@@ -1,20 +0,0 @@
Copyright (c) 2015 TJ Holowaychuk <tj@vision-media.ca>
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.

8
node_modules/delegates/Makefile generated vendored
View File

@@ -1,8 +0,0 @@
test:
@./node_modules/.bin/mocha \
--require should \
--reporter spec \
--bail
.PHONY: test

94
node_modules/delegates/Readme.md generated vendored
View File

@@ -1,94 +0,0 @@
# delegates
Node method and accessor delegation utilty.
## Installation
```
$ npm install delegates
```
## Example
```js
var delegate = require('delegates');
...
delegate(proto, 'request')
.method('acceptsLanguages')
.method('acceptsEncodings')
.method('acceptsCharsets')
.method('accepts')
.method('is')
.access('querystring')
.access('idempotent')
.access('socket')
.access('length')
.access('query')
.access('search')
.access('status')
.access('method')
.access('path')
.access('body')
.access('host')
.access('url')
.getter('subdomains')
.getter('protocol')
.getter('header')
.getter('stale')
.getter('fresh')
.getter('secure')
.getter('ips')
.getter('ip')
```
# API
## Delegate(proto, prop)
Creates a delegator instance used to configure using the `prop` on the given
`proto` object. (which is usually a prototype)
## Delegate#method(name)
Allows the given method `name` to be accessed on the host.
## Delegate#getter(name)
Creates a "getter" for the property with the given `name` on the delegated
object.
## Delegate#setter(name)
Creates a "setter" for the property with the given `name` on the delegated
object.
## Delegate#access(name)
Creates an "accessor" (ie: both getter *and* setter) for the property with the
given `name` on the delegated object.
## Delegate#fluent(name)
A unique type of "accessor" that works for a "fluent" API. When called as a
getter, the method returns the expected value. However, if the method is called
with a value, it will return itself so it can be chained. For example:
```js
delegate(proto, 'request')
.fluent('query')
// getter
var q = request.query();
// setter (chainable)
request
.query({ a: 1 })
.query({ b: 2 });
```
# License
MIT

121
node_modules/delegates/index.js generated vendored
View File

@@ -1,121 +0,0 @@
/**
* Expose `Delegator`.
*/
module.exports = Delegator;
/**
* Initialize a delegator.
*
* @param {Object} proto
* @param {String} target
* @api public
*/
function Delegator(proto, target) {
if (!(this instanceof Delegator)) return new Delegator(proto, target);
this.proto = proto;
this.target = target;
this.methods = [];
this.getters = [];
this.setters = [];
this.fluents = [];
}
/**
* Delegate method `name`.
*
* @param {String} name
* @return {Delegator} self
* @api public
*/
Delegator.prototype.method = function(name){
var proto = this.proto;
var target = this.target;
this.methods.push(name);
proto[name] = function(){
return this[target][name].apply(this[target], arguments);
};
return this;
};
/**
* Delegator accessor `name`.
*
* @param {String} name
* @return {Delegator} self
* @api public
*/
Delegator.prototype.access = function(name){
return this.getter(name).setter(name);
};
/**
* Delegator getter `name`.
*
* @param {String} name
* @return {Delegator} self
* @api public
*/
Delegator.prototype.getter = function(name){
var proto = this.proto;
var target = this.target;
this.getters.push(name);
proto.__defineGetter__(name, function(){
return this[target][name];
});
return this;
};
/**
* Delegator setter `name`.
*
* @param {String} name
* @return {Delegator} self
* @api public
*/
Delegator.prototype.setter = function(name){
var proto = this.proto;
var target = this.target;
this.setters.push(name);
proto.__defineSetter__(name, function(val){
return this[target][name] = val;
});
return this;
};
/**
* Delegator fluent accessor
*
* @param {String} name
* @return {Delegator} self
* @api public
*/
Delegator.prototype.fluent = function (name) {
var proto = this.proto;
var target = this.target;
this.fluents.push(name);
proto[name] = function(val){
if ('undefined' != typeof val) {
this[target][name] = val;
return this;
} else {
return this[target][name];
}
};
return this;
};

17
node_modules/delegates/package.json generated vendored
View File

@@ -1,17 +0,0 @@
{
"name": "delegates",
"version": "1.0.0",
"repository": "visionmedia/node-delegates",
"description": "delegate methods and accessors to another property",
"keywords": ["delegate", "delegation"],
"dependencies": {},
"devDependencies": {
"mocha": "*",
"should": "*"
},
"license": "MIT"
,"_resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz"
,"_integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o="
,"_from": "delegates@1.0.0"
}

94
node_modules/delegates/test/index.js generated vendored
View File

@@ -1,94 +0,0 @@
var assert = require('assert');
var delegate = require('..');
describe('.method(name)', function(){
it('should delegate methods', function(){
var obj = {};
obj.request = {
foo: function(bar){
assert(this == obj.request);
return bar;
}
};
delegate(obj, 'request').method('foo');
obj.foo('something').should.equal('something');
})
})
describe('.getter(name)', function(){
it('should delegate getters', function(){
var obj = {};
obj.request = {
get type() {
return 'text/html';
}
}
delegate(obj, 'request').getter('type');
obj.type.should.equal('text/html');
})
})
describe('.setter(name)', function(){
it('should delegate setters', function(){
var obj = {};
obj.request = {
get type() {
return this._type.toUpperCase();
},
set type(val) {
this._type = val;
}
}
delegate(obj, 'request').setter('type');
obj.type = 'hey';
obj.request.type.should.equal('HEY');
})
})
describe('.access(name)', function(){
it('should delegate getters and setters', function(){
var obj = {};
obj.request = {
get type() {
return this._type.toUpperCase();
},
set type(val) {
this._type = val;
}
}
delegate(obj, 'request').access('type');
obj.type = 'hey';
obj.type.should.equal('HEY');
})
})
describe('.fluent(name)', function () {
it('should delegate in a fluent fashion', function () {
var obj = {
settings: {
env: 'development'
}
};
delegate(obj, 'settings').fluent('env');
obj.env().should.equal('development');
obj.env('production').should.equal(obj);
obj.settings.env.should.equal('production');
})
})

7
node_modules/detect-libc/.npmignore generated vendored
View File

@@ -1,7 +0,0 @@
.nyc_output
.travis.yml
coverage
test.js
node_modules
/.circleci
/tests/integration

201
node_modules/detect-libc/LICENSE generated vendored
View File

@@ -1,201 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

78
node_modules/detect-libc/README.md generated vendored
View File

@@ -1,78 +0,0 @@
# detect-libc
Node.js module to detect the C standard library (libc) implementation
family and version in use on a given Linux system.
Provides a value suitable for use with the `LIBC` option of
[prebuild](https://www.npmjs.com/package/prebuild),
[prebuild-ci](https://www.npmjs.com/package/prebuild-ci) and
[prebuild-install](https://www.npmjs.com/package/prebuild-install),
therefore allowing build and provision of pre-compiled binaries
for musl-based Linux e.g. Alpine as well as glibc-based.
Currently supports libc detection of `glibc` and `musl`.
## Install
```sh
npm install detect-libc
```
## Usage
### API
```js
const { GLIBC, MUSL, family, version, isNonGlibcLinux } = require('detect-libc');
```
* `GLIBC` is a String containing the value "glibc" for comparison with `family`.
* `MUSL` is a String containing the value "musl" for comparison with `family`.
* `family` is a String representing the system libc family.
* `version` is a String representing the system libc version number.
* `isNonGlibcLinux` is a Boolean representing whether the system is a non-glibc Linux, e.g. Alpine.
### detect-libc command line tool
When run on a Linux system with a non-glibc libc,
the child command will be run with the `LIBC` environment variable
set to the relevant value.
On all other platforms will run the child command as-is.
The command line feature requires `spawnSync` provided by Node v0.12+.
```sh
detect-libc child-command
```
## Integrating with prebuild
```json
"scripts": {
"install": "detect-libc prebuild-install || node-gyp rebuild",
"test": "mocha && detect-libc prebuild-ci"
},
"dependencies": {
"detect-libc": "^1.0.2",
"prebuild-install": "^2.2.0"
},
"devDependencies": {
"prebuild": "^6.2.1",
"prebuild-ci": "^2.2.3"
}
```
## Licence
Copyright 2017 Lovell Fuller
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

18
node_modules/detect-libc/bin/detect-libc.js generated vendored
View File

@@ -1,18 +0,0 @@
#!/usr/bin/env node
'use strict';
var spawnSync = require('child_process').spawnSync;
var libc = require('../');
var spawnOptions = {
env: process.env,
shell: true,
stdio: 'inherit'
};
if (libc.isNonGlibcLinux) {
spawnOptions.env.LIBC = process.env.LIBC || libc.family;
}
process.exit(spawnSync(process.argv[2], process.argv.slice(3), spawnOptions).status);

92
node_modules/detect-libc/lib/detect-libc.js generated vendored
View File

@@ -1,92 +0,0 @@
'use strict';
var platform = require('os').platform();
var spawnSync = require('child_process').spawnSync;
var readdirSync = require('fs').readdirSync;
var GLIBC = 'glibc';
var MUSL = 'musl';
var spawnOptions = {
encoding: 'utf8',
env: process.env
};
if (!spawnSync) {
spawnSync = function () {
return { status: 126, stdout: '', stderr: '' };
};
}
function contains (needle) {
return function (haystack) {
return haystack.indexOf(needle) !== -1;
};
}
function versionFromMuslLdd (out) {
return out.split(/[\r\n]+/)[1].trim().split(/\s/)[1];
}
function safeReaddirSync (path) {
try {
return readdirSync(path);
} catch (e) {}
return [];
}
var family = '';
var version = '';
var method = '';
if (platform === 'linux') {
// Try getconf
var glibc = spawnSync('getconf', ['GNU_LIBC_VERSION'], spawnOptions);
if (glibc.status === 0) {
family = GLIBC;
version = glibc.stdout.trim().split(' ')[1];
method = 'getconf';
} else {
// Try ldd
var ldd = spawnSync('ldd', ['--version'], spawnOptions);
if (ldd.status === 0 && ldd.stdout.indexOf(MUSL) !== -1) {
family = MUSL;
version = versionFromMuslLdd(ldd.stdout);
method = 'ldd';
} else if (ldd.status === 1 && ldd.stderr.indexOf(MUSL) !== -1) {
family = MUSL;
version = versionFromMuslLdd(ldd.stderr);
method = 'ldd';
} else {
// Try filesystem (family only)
var lib = safeReaddirSync('/lib');
if (lib.some(contains('-linux-gnu'))) {
family = GLIBC;
method = 'filesystem';
} else if (lib.some(contains('libc.musl-'))) {
family = MUSL;
method = 'filesystem';
} else if (lib.some(contains('ld-musl-'))) {
family = MUSL;
method = 'filesystem';
} else {
var usrSbin = safeReaddirSync('/usr/sbin');
if (usrSbin.some(contains('glibc'))) {
family = GLIBC;
method = 'filesystem';
}
}
}
}
}
var isNonGlibcLinux = (family !== '' && family !== GLIBC);
module.exports = {
GLIBC: GLIBC,
MUSL: MUSL,
family: family,
version: version,
method: method,
isNonGlibcLinux: isNonGlibcLinux
};

39
node_modules/detect-libc/package.json generated vendored
View File

@@ -1,39 +0,0 @@
{
"name": "detect-libc",
"version": "1.0.3",
"description": "Node.js module to detect the C standard library (libc) implementation family and version",
"main": "lib/detect-libc.js",
"bin": {
"detect-libc": "./bin/detect-libc.js"
},
"scripts": {
"test": "semistandard && nyc --reporter=lcov ava"
},
"repository": {
"type": "git",
"url": "git://github.com/lovell/detect-libc"
},
"keywords": [
"libc",
"glibc",
"musl"
],
"author": "Lovell Fuller <npm@lovell.info>",
"contributors": [
"Niklas Salmoukas <niklas@salmoukas.com>"
],
"license": "Apache-2.0",
"devDependencies": {
"ava": "^0.23.0",
"nyc": "^11.3.0",
"proxyquire": "^1.8.0",
"semistandard": "^11.0.0"
},
"engines": {
"node": ">=0.10"
}
,"_resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-1.0.3.tgz"
,"_integrity": "sha1-+hN8S9aY7fVc1c0CrFWfkaTEups="
,"_from": "detect-libc@1.0.3"
}

15
node_modules/fs-minipass/LICENSE generated vendored
View File

@@ -1,15 +0,0 @@
The ISC License
Copyright (c) Isaac Z. Schlueter and Contributors
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

70
node_modules/fs-minipass/README.md generated vendored
View File

@@ -1,70 +0,0 @@
# fs-minipass
Filesystem streams based on [minipass](http://npm.im/minipass).
4 classes are exported:
- ReadStream
- ReadStreamSync
- WriteStream
- WriteStreamSync
When using `ReadStreamSync`, all of the data is made available
immediately upon consuming the stream. Nothing is buffered in memory
when the stream is constructed. If the stream is piped to a writer,
then it will synchronously `read()` and emit data into the writer as
fast as the writer can consume it. (That is, it will respect
backpressure.) If you call `stream.read()` then it will read the
entire file and return the contents.
When using `WriteStreamSync`, every write is flushed to the file
synchronously. If your writes all come in a single tick, then it'll
write it all out in a single tick. It's as synchronous as you are.
The async versions work much like their node builtin counterparts,
with the exception of introducing significantly less Stream machinery
overhead.
## USAGE
It's just streams, you pipe them or read() them or write() to them.
```js
const fsm = require('fs-minipass')
const readStream = new fsm.ReadStream('file.txt')
const writeStream = new fsm.WriteStream('output.txt')
writeStream.write('some file header or whatever\n')
readStream.pipe(writeStream)
```
## ReadStream(path, options)
Path string is required, but somewhat irrelevant if an open file
descriptor is passed in as an option.
Options:
- `fd` Pass in a numeric file descriptor, if the file is already open.
- `readSize` The size of reads to do, defaults to 16MB
- `size` The size of the file, if known. Prevents zero-byte read()
call at the end.
- `autoClose` Set to `false` to prevent the file descriptor from being
closed when the file is done being read.
## WriteStream(path, options)
Path string is required, but somewhat irrelevant if an open file
descriptor is passed in as an option.
Options:
- `fd` Pass in a numeric file descriptor, if the file is already open.
- `mode` The mode to create the file with. Defaults to `0o666`.
- `start` The position in the file to start reading. If not
specified, then the file will start writing at position zero, and be
truncated by default.
- `autoClose` Set to `false` to prevent the file descriptor from being
closed when the stream is ended.
- `flags` Flags to use when opening the file. Irrelevant if `fd` is
passed in, since file won't be opened in that case. Defaults to
`'a'` if a `pos` is specified, or `'w'` otherwise.

387
node_modules/fs-minipass/index.js generated vendored
View File

@@ -1,387 +0,0 @@
'use strict'
const MiniPass = require('minipass')
const EE = require('events').EventEmitter
const fs = require('fs')
// for writev
const binding = process.binding('fs')
const writeBuffers = binding.writeBuffers
/* istanbul ignore next */
const FSReqWrap = binding.FSReqWrap || binding.FSReqCallback
const _autoClose = Symbol('_autoClose')
const _close = Symbol('_close')
const _ended = Symbol('_ended')
const _fd = Symbol('_fd')
const _finished = Symbol('_finished')
const _flags = Symbol('_flags')
const _flush = Symbol('_flush')
const _handleChunk = Symbol('_handleChunk')
const _makeBuf = Symbol('_makeBuf')
const _mode = Symbol('_mode')
const _needDrain = Symbol('_needDrain')
const _onerror = Symbol('_onerror')
const _onopen = Symbol('_onopen')
const _onread = Symbol('_onread')
const _onwrite = Symbol('_onwrite')
const _open = Symbol('_open')
const _path = Symbol('_path')
const _pos = Symbol('_pos')
const _queue = Symbol('_queue')
const _read = Symbol('_read')
const _readSize = Symbol('_readSize')
const _reading = Symbol('_reading')
const _remain = Symbol('_remain')
const _size = Symbol('_size')
const _write = Symbol('_write')
const _writing = Symbol('_writing')
const _defaultFlag = Symbol('_defaultFlag')
class ReadStream extends MiniPass {
constructor (path, opt) {
opt = opt || {}
super(opt)
this.writable = false
if (typeof path !== 'string')
throw new TypeError('path must be a string')
this[_fd] = typeof opt.fd === 'number' ? opt.fd : null
this[_path] = path
this[_readSize] = opt.readSize || 16*1024*1024
this[_reading] = false
this[_size] = typeof opt.size === 'number' ? opt.size : Infinity
this[_remain] = this[_size]
this[_autoClose] = typeof opt.autoClose === 'boolean' ?
opt.autoClose : true
if (typeof this[_fd] === 'number')
this[_read]()
else
this[_open]()
}
get fd () { return this[_fd] }
get path () { return this[_path] }
write () {
throw new TypeError('this is a readable stream')
}
end () {
throw new TypeError('this is a readable stream')
}
[_open] () {
fs.open(this[_path], 'r', (er, fd) => this[_onopen](er, fd))
}
[_onopen] (er, fd) {
if (er)
this[_onerror](er)
else {
this[_fd] = fd
this.emit('open', fd)
this[_read]()
}
}
[_makeBuf] () {
return Buffer.allocUnsafe(Math.min(this[_readSize], this[_remain]))
}
[_read] () {
if (!this[_reading]) {
this[_reading] = true
const buf = this[_makeBuf]()
/* istanbul ignore if */
if (buf.length === 0) return process.nextTick(() => this[_onread](null, 0, buf))
fs.read(this[_fd], buf, 0, buf.length, null, (er, br, buf) =>
this[_onread](er, br, buf))
}
}
[_onread] (er, br, buf) {
this[_reading] = false
if (er)
this[_onerror](er)
else if (this[_handleChunk](br, buf))
this[_read]()
}
[_close] () {
if (this[_autoClose] && typeof this[_fd] === 'number') {
fs.close(this[_fd], _ => this.emit('close'))
this[_fd] = null
}
}
[_onerror] (er) {
this[_reading] = true
this[_close]()
this.emit('error', er)
}
[_handleChunk] (br, buf) {
let ret = false
// no effect if infinite
this[_remain] -= br
if (br > 0)
ret = super.write(br < buf.length ? buf.slice(0, br) : buf)
if (br === 0 || this[_remain] <= 0) {
ret = false
this[_close]()
super.end()
}
return ret
}
emit (ev, data) {
switch (ev) {
case 'prefinish':
case 'finish':
break
case 'drain':
if (typeof this[_fd] === 'number')
this[_read]()
break
default:
return super.emit(ev, data)
}
}
}
class ReadStreamSync extends ReadStream {
[_open] () {
let threw = true
try {
this[_onopen](null, fs.openSync(this[_path], 'r'))
threw = false
} finally {
if (threw)
this[_close]()
}
}
[_read] () {
let threw = true
try {
if (!this[_reading]) {
this[_reading] = true
do {
const buf = this[_makeBuf]()
/* istanbul ignore next */
const br = buf.length === 0 ? 0 : fs.readSync(this[_fd], buf, 0, buf.length, null)
if (!this[_handleChunk](br, buf))
break
} while (true)
this[_reading] = false
}
threw = false
} finally {
if (threw)
this[_close]()
}
}
[_close] () {
if (this[_autoClose] && typeof this[_fd] === 'number') {
try {
fs.closeSync(this[_fd])
} catch (er) {}
this[_fd] = null
this.emit('close')
}
}
}
class WriteStream extends EE {
constructor (path, opt) {
opt = opt || {}
super(opt)
this.readable = false
this[_writing] = false
this[_ended] = false
this[_needDrain] = false
this[_queue] = []
this[_path] = path
this[_fd] = typeof opt.fd === 'number' ? opt.fd : null
this[_mode] = opt.mode === undefined ? 0o666 : opt.mode
this[_pos] = typeof opt.start === 'number' ? opt.start : null
this[_autoClose] = typeof opt.autoClose === 'boolean' ?
opt.autoClose : true
// truncating makes no sense when writing into the middle
const defaultFlag = this[_pos] !== null ? 'r+' : 'w'
this[_defaultFlag] = opt.flags === undefined
this[_flags] = this[_defaultFlag] ? defaultFlag : opt.flags
if (this[_fd] === null)
this[_open]()
}
get fd () { return this[_fd] }
get path () { return this[_path] }
[_onerror] (er) {
this[_close]()
this[_writing] = true
this.emit('error', er)
}
[_open] () {
fs.open(this[_path], this[_flags], this[_mode],
(er, fd) => this[_onopen](er, fd))
}
[_onopen] (er, fd) {
if (this[_defaultFlag] &&
this[_flags] === 'r+' &&
er && er.code === 'ENOENT') {
this[_flags] = 'w'
this[_open]()
} else if (er)
this[_onerror](er)
else {
this[_fd] = fd
this.emit('open', fd)
this[_flush]()
}
}
end (buf, enc) {
if (buf)
this.write(buf, enc)
this[_ended] = true
// synthetic after-write logic, where drain/finish live
if (!this[_writing] && !this[_queue].length &&
typeof this[_fd] === 'number')
this[_onwrite](null, 0)
}
write (buf, enc) {
if (typeof buf === 'string')
buf = new Buffer(buf, enc)
if (this[_ended]) {
this.emit('error', new Error('write() after end()'))
return false
}
if (this[_fd] === null || this[_writing] || this[_queue].length) {
this[_queue].push(buf)
this[_needDrain] = true
return false
}
this[_writing] = true
this[_write](buf)
return true
}
[_write] (buf) {
fs.write(this[_fd], buf, 0, buf.length, this[_pos], (er, bw) =>
this[_onwrite](er, bw))
}
[_onwrite] (er, bw) {
if (er)
this[_onerror](er)
else {
if (this[_pos] !== null)
this[_pos] += bw
if (this[_queue].length)
this[_flush]()
else {
this[_writing] = false
if (this[_ended] && !this[_finished]) {
this[_finished] = true
this[_close]()
this.emit('finish')
} else if (this[_needDrain]) {
this[_needDrain] = false
this.emit('drain')
}
}
}
}
[_flush] () {
if (this[_queue].length === 0) {
if (this[_ended])
this[_onwrite](null, 0)
} else if (this[_queue].length === 1)
this[_write](this[_queue].pop())
else {
const iovec = this[_queue]
this[_queue] = []
writev(this[_fd], iovec, this[_pos],
(er, bw) => this[_onwrite](er, bw))
}
}
[_close] () {
if (this[_autoClose] && typeof this[_fd] === 'number') {
fs.close(this[_fd], _ => this.emit('close'))
this[_fd] = null
}
}
}
class WriteStreamSync extends WriteStream {
[_open] () {
let fd
try {
fd = fs.openSync(this[_path], this[_flags], this[_mode])
} catch (er) {
if (this[_defaultFlag] &&
this[_flags] === 'r+' &&
er && er.code === 'ENOENT') {
this[_flags] = 'w'
return this[_open]()
} else
throw er
}
this[_onopen](null, fd)
}
[_close] () {
if (this[_autoClose] && typeof this[_fd] === 'number') {
try {
fs.closeSync(this[_fd])
} catch (er) {}
this[_fd] = null
this.emit('close')
}
}
[_write] (buf) {
try {
this[_onwrite](null,
fs.writeSync(this[_fd], buf, 0, buf.length, this[_pos]))
} catch (er) {
this[_onwrite](er, 0)
}
}
}
const writev = (fd, iovec, pos, cb) => {
const done = (er, bw) => cb(er, bw, iovec)
const req = new FSReqWrap()
req.oncomplete = done
binding.writeBuffers(fd, iovec, pos, req)
}
exports.ReadStream = ReadStream
exports.ReadStreamSync = ReadStreamSync
exports.WriteStream = WriteStream
exports.WriteStreamSync = WriteStreamSync

40
node_modules/fs-minipass/package.json generated vendored
View File

@@ -1,40 +0,0 @@
{
"name": "fs-minipass",
"version": "1.2.7",
"main": "index.js",
"scripts": {
"test": "tap",
"preversion": "npm test",
"postversion": "npm publish",
"postpublish": "git push origin --follow-tags"
},
"keywords": [],
"author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
"license": "ISC",
"repository": {
"type": "git",
"url": "git+https://github.com/npm/fs-minipass.git"
},
"bugs": {
"url": "https://github.com/npm/fs-minipass/issues"
},
"homepage": "https://github.com/npm/fs-minipass#readme",
"description": "fs read and write streams based on minipass",
"dependencies": {
"minipass": "^2.6.0"
},
"devDependencies": {
"mutate-fs": "^2.0.1",
"tap": "^14.6.4"
},
"files": [
"index.js"
],
"tap": {
"check-coverage": true
}
,"_resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-1.2.7.tgz"
,"_integrity": "sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA=="
,"_from": "fs-minipass@1.2.7"
}

160
node_modules/gauge/CHANGELOG.md generated vendored
View File

@@ -1,160 +0,0 @@
### v2.7.4
* Reset colors prior to ending a line, to eliminate flicker when a line
is trucated between start and end color sequences.
### v2.7.3
* Only create our onExit handler when we're enabled and remove it when we're
disabled. This stops us from creating multiple onExit handlers when
multiple gauge objects are being used.
* Fix bug where if a theme name were given instead of a theme object, it
would crash.
* Remove supports-color because it's not actually used. Uhm. Yes, I just
updated it. >.>
### v2.7.2
* Use supports-color instead of has-color (as the module has been renamed)
### v2.7.1
* Bug fix: Calls to show/pulse while the progress bar is disabled should still
update our internal representation of what would be shown should it be enabled.
### v2.7.0
* New feature: Add new `isEnabled` method to allow introspection of the gauge's
"enabledness" as controlled by `.enable()` and `.disable()`.
### v2.6.0
* Bug fix: Don't run the code associated with `enable`/`disable` if the gauge
is already enabled or disabled respectively. This prevents leaking event
listeners, amongst other weirdness.
* New feature: Template items can have default values that will be used if no
value was otherwise passed in.
### v2.5.3
* Default to `enabled` only if we have a tty. Users can always override
this by passing in the `enabled` option explicitly or by calling calling
`gauge.enable()`.
### v2.5.2
* Externalized `./console-strings.js` into `console-control-strings`.
### v2.5.1
* Update to `signal-exit@3.0.0`, which fixes a compatibility bug with the
node profiler.
* [#39](https://github.com/iarna/gauge/pull/39) Fix tests on 0.10 and add
a missing devDependency. ([@helloyou2012](https://github.com/helloyou2012))
### v2.5.0
* Add way to programmatically fetch a list of theme names in a themeset
(`Themeset.getThemeNames`).
### v2.4.0
* Add support for setting themesets on existing gauge objects.
* Add post-IO callback to `gauge.hide()` as it is somtetimes necessary when
your terminal is interleaving output from multiple filehandles (ie, stdout
& stderr).
### v2.3.1
* Fix a refactor bug in setTheme where it wasn't accepting the various types
of args it should.
### v2.3.0
#### FEATURES
* Add setTemplate & setTheme back in.
* Add support for named themes, you can now ask for things like 'colorASCII'
and 'brailleSpinner'. Of course, you can still pass in theme objects.
Additionally you can now pass in an object with `hasUnicode`, `hasColor` and
`platform` keys in order to override our guesses as to those values when
selecting a default theme from the themeset.
* Make the output stream optional (it defaults to `process.stderr` now).
* Add `setWriteTo(stream[, tty])` to change the output stream and,
optionally, tty.
#### BUG FIXES & REFACTORING
* Abort the display phase early if we're supposed to be hidden and we are.
* Stop printing a bunch of spaces at the end of lines, since we're already
using an erase-to-end-of-line code anyway.
* The unicode themes were missing the subsection separator.
### v2.2.1
* Fix image in readme
### v2.2.0
* All new themes API– reference themes by name and pass in custom themes and
themesets (themesets get platform support autodetection done on them to
select the best theme). Theme mixins let you add features to all existing
themes.
* Much, much improved test coverage.
### v2.1.0
* Got rid of ░ in the default platform, noUnicode, hasColor theme. Thanks
to @yongtw123 for pointing out this had snuck in.
* Fiddled with the demo output to make it easier to see the spinner spin. Also
added prints before each platforms test output.
* I forgot to include `signal-exit` in our deps. <.< Thank you @KenanY for
finding this. Then I was lazy and made a new commit instead of using his
PR. Again, thank you for your patience @KenenY.
* Drastically speed up travis testing.
* Add a small javascript demo (demo.js) for showing off the various themes
(and testing them on diff platforms).
* Change: The subsection separator from ⁄ and / (different chars) to >.
* Fix crasher: A show or pulse without a label would cause the template renderer
to complain about a missing value.
* New feature: Add the ability to disable the clean-up-on-exit behavior.
Not something I expect to be widely desirable, but important if you have
multiple distinct gauge instances in your app.
* Use our own color support detection.
The `has-color` module proved too magic for my needs, making assumptions
as to which stream we write to and reading command line arguments.
### v2.0.0
This is a major rewrite of the internals. Externally there are fewer
changes:
* On node>0.8 gauge object now prints updates at a fixed rate. This means
that when you call `show` it may wate up to `updateInterval` ms before it
actually prints an update. You override this behavior with the
`fixedFramerate` option.
* The gauge object now keeps the cursor hidden as long as it's enabled and
shown.
* The constructor's arguments have changed, now it takes a mandatory output
stream and an optional options object. The stream no longer needs to be
an `ansi`ified stream, although it can be if you want (but we won't make
use of its special features).
* Previously the gauge was disabled by default if `process.stdout` wasn't a
tty. Now it always defaults to enabled. If you want the previous
behavior set the `enabled` option to `process.stdout.isTTY`.
* The constructor's options have changed– see the docs for details.
* Themes are entirely different. If you were using a custom theme, or
referring to one directly (eg via `Gauge.unicode` or `Gauge.ascii`) then
you'll need to change your code. You can get the equivalent of the latter
with:
```
var themes = require('gauge/themes')
var unicodeTheme = themes(true, true) // returns the color unicode theme for your platform
```
The default themes no longer use any ambiguous width characters, so even
if you choose to display those as wide your progress bar should still
display correctly.
* Templates are entirely different and if you were using a custom one, you
should consult the documentation to learn how to recreate it. If you were
using the default, be aware that it has changed and the result looks quite
a bit different.

13
node_modules/gauge/LICENSE generated vendored
View File

@@ -1,13 +0,0 @@
Copyright (c) 2014, Rebecca Turner <me@re-becca.org>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

399
node_modules/gauge/README.md generated vendored
View File

@@ -1,399 +0,0 @@
gauge
=====
A nearly stateless terminal based horizontal gauge / progress bar.
```javascript
var Gauge = require("gauge")
var gauge = new Gauge()
gauge.show("test", 0.20)
gauge.pulse("this")
gauge.hide()
```
![](gauge-demo.gif)
### CHANGES FROM 1.x
Gauge 2.x is breaking release, please see the [changelog] for details on
what's changed if you were previously a user of this module.
[changelog]: CHANGELOG.md
### THE GAUGE CLASS
This is the typical interface to the module– it provides a pretty
fire-and-forget interface to displaying your status information.
```
var Gauge = require("gauge")
var gauge = new Gauge([stream], [options])
```
* **stream** – *(optional, default STDERR)* A stream that progress bar
updates are to be written to. Gauge honors backpressure and will pause
most writing if it is indicated.
* **options** – *(optional)* An option object.
Constructs a new gauge. Gauges are drawn on a single line, and are not drawn
if **stream** isn't a tty and a tty isn't explicitly provided.
If **stream** is a terminal or if you pass in **tty** to **options** then we
will detect terminal resizes and redraw to fit. We do this by watching for
`resize` events on the tty. (To work around a bug in verisons of Node prior
to 2.5.0, we watch for them on stdout if the tty is stderr.) Resizes to
larger window sizes will be clean, but shrinking the window will always
result in some cruft.
**IMPORTANT:** If you prevously were passing in a non-tty stream but you still
want output (for example, a stream wrapped by the `ansi` module) then you
need to pass in the **tty** option below, as `gauge` needs access to
the underlying tty in order to do things like terminal resizes and terminal
width detection.
The **options** object can have the following properties, all of which are
optional:
* **updateInterval**: How often gauge updates should be drawn, in miliseconds.
* **fixedFramerate**: Defaults to false on node 0.8, true on everything
else. When this is true a timer is created to trigger once every
`updateInterval` ms, when false, updates are printed as soon as they come
in but updates more often than `updateInterval` are ignored. The reason
0.8 doesn't have this set to true is that it can't `unref` its timer and
so it would stop your program from exiting– if you want to use this
feature with 0.8 just make sure you call `gauge.disable()` before you
expect your program to exit.
* **themes**: A themeset to use when selecting the theme to use. Defaults
to `gauge/themes`, see the [themes] documentation for details.
* **theme**: Select a theme for use, it can be a:
* Theme object, in which case the **themes** is not used.
* The name of a theme, which will be looked up in the current *themes*
object.
* A configuration object with any of `hasUnicode`, `hasColor` or
`platform` keys, which if wlll be used to override our guesses when making
a default theme selection.
If no theme is selected then a default is picked using a combination of our
best guesses at your OS, color support and unicode support.
* **template**: Describes what you want your gauge to look like. The
default is what npm uses. Detailed [documentation] is later in this
document.
* **hideCursor**: Defaults to true. If true, then the cursor will be hidden
while the gauge is displayed.
* **tty**: The tty that you're ultimately writing to. Defaults to the same
as **stream**. This is used for detecting the width of the terminal and
resizes. The width used is `tty.columns - 1`. If no tty is available then
a width of `79` is assumed.
* **enabled**: Defaults to true if `tty` is a TTY, false otherwise. If true
the gauge starts enabled. If disabled then all update commands are
ignored and no gauge will be printed until you call `.enable()`.
* **Plumbing**: The class to use to actually generate the gauge for
printing. This defaults to `require('gauge/plumbing')` and ordinarly you
shouldn't need to override this.
* **cleanupOnExit**: Defaults to true. Ordinarily we register an exit
handler to make sure your cursor is turned back on and the progress bar
erased when your process exits, even if you Ctrl-C out or otherwise exit
unexpectedly. You can disable this and it won't register the exit handler.
[has-unicode]: https://www.npmjs.com/package/has-unicode
[themes]: #themes
[documentation]: #templates
#### `gauge.show(section | status, [completed])`
The first argument is either the section, the name of the current thing
contributing to progress, or an object with keys like **section**,
**subsection** & **completed** (or any others you have types for in a custom
template). If you don't want to update or set any of these you can pass
`null` and it will be ignored.
The second argument is the percent completed as a value between 0 and 1.
Without it, completion is just not updated. You'll also note that completion
can be passed in as part of a status object as the first argument. If both
it and the completed argument are passed in, the completed argument wins.
#### `gauge.hide([cb])`
Removes the gauge from the terminal. Optionally, callback `cb` after IO has
had an opportunity to happen (currently this just means after `setImmediate`
has called back.)
It turns out this is important when you're pausing the progress bar on one
filehandle and printing to another– otherwise (with a big enough print) node
can end up printing the "end progress bar" bits to the progress bar filehandle
while other stuff is printing to another filehandle. These getting interleaved
can cause corruption in some terminals.
#### `gauge.pulse([subsection])`
* **subsection** – *(optional)* The specific thing that triggered this pulse
Spins the spinner in the gauge to show output. If **subsection** is
included then it will be combined with the last name passed to `gauge.show`.
#### `gauge.disable()`
Hides the gauge and ignores further calls to `show` or `pulse`.
#### `gauge.enable()`
Shows the gauge and resumes updating when `show` or `pulse` is called.
#### `gauge.isEnabled()`
Returns true if the gauge is enabled.
#### `gauge.setThemeset(themes)`
Change the themeset to select a theme from. The same as the `themes` option
used in the constructor. The theme will be reselected from this themeset.
#### `gauge.setTheme(theme)`
Change the active theme, will be displayed with the next show or pulse. This can be:
* Theme object, in which case the **themes** is not used.
* The name of a theme, which will be looked up in the current *themes*
object.
* A configuration object with any of `hasUnicode`, `hasColor` or
`platform` keys, which if wlll be used to override our guesses when making
a default theme selection.
If no theme is selected then a default is picked using a combination of our
best guesses at your OS, color support and unicode support.
#### `gauge.setTemplate(template)`
Change the active template, will be displayed with the next show or pulse
### Tracking Completion
If you have more than one thing going on that you want to track completion
of, you may find the related [are-we-there-yet] helpful. It's `change`
event can be wired up to the `show` method to get a more traditional
progress bar interface.
[are-we-there-yet]: https://www.npmjs.com/package/are-we-there-yet
### THEMES
```
var themes = require('gauge/themes')
// fetch the default color unicode theme for this platform
var ourTheme = themes({hasUnicode: true, hasColor: true})
// fetch the default non-color unicode theme for osx
var ourTheme = themes({hasUnicode: true, hasColor: false, platform: 'darwin'})
// create a new theme based on the color ascii theme for this platform
// that brackets the progress bar with arrows
var ourTheme = themes.newTheme(theme(hasUnicode: false, hasColor: true}), {
preProgressbar: '→',
postProgressbar: '←'
})
```
The object returned by `gauge/themes` is an instance of the `ThemeSet` class.
```
var ThemeSet = require('gauge/theme-set')
var themes = new ThemeSet()
// or
var themes = require('gauge/themes')
var mythemes = themes.newThemeset() // creates a new themeset based on the default themes
```
#### themes(opts)
#### themes.getDefault(opts)
Theme objects are a function that fetches the default theme based on
platform, unicode and color support.
Options is an object with the following properties:
* **hasUnicode** - If true, fetch a unicode theme, if no unicode theme is
available then a non-unicode theme will be used.
* **hasColor** - If true, fetch a color theme, if no color theme is
available a non-color theme will be used.
* **platform** (optional) - Defaults to `process.platform`. If no
platform match is available then `fallback` is used instead.
If no compatible theme can be found then an error will be thrown with a
`code` of `EMISSINGTHEME`.
#### themes.addTheme(themeName, themeObj)
#### themes.addTheme(themeName, [parentTheme], newTheme)
Adds a named theme to the themeset. You can pass in either a theme object,
as returned by `themes.newTheme` or the arguments you'd pass to
`themes.newTheme`.
#### themes.getThemeNames()
Return a list of all of the names of the themes in this themeset. Suitable
for use in `themes.getTheme(…)`.
#### themes.getTheme(name)
Returns the theme object from this theme set named `name`.
If `name` does not exist in this themeset an error will be thrown with
a `code` of `EMISSINGTHEME`.
#### themes.setDefault([opts], themeName)
`opts` is an object with the following properties.
* **platform** - Defaults to `'fallback'`. If your theme is platform
specific, specify that here with the platform from `process.platform`, eg,
`win32`, `darwin`, etc.
* **hasUnicode** - Defaults to `false`. If your theme uses unicode you
should set this to true.
* **hasColor** - Defaults to `false`. If your theme uses color you should
set this to true.
`themeName` is the name of the theme (as given to `addTheme`) to use for
this set of `opts`.
#### themes.newTheme([parentTheme,] newTheme)
Create a new theme object based on `parentTheme`. If no `parentTheme` is
provided then a minimal parentTheme that defines functions for rendering the
activity indicator (spinner) and progress bar will be defined. (This
fallback parent is defined in `gauge/base-theme`.)
newTheme should be a bare object– we'll start by discussing the properties
defined by the default themes:
* **preProgressbar** - displayed prior to the progress bar, if the progress
bar is displayed.
* **postProgressbar** - displayed after the progress bar, if the progress bar
is displayed.
* **progressBarTheme** - The subtheme passed through to the progress bar
renderer, it's an object with `complete` and `remaining` properties
that are the strings you want repeated for those sections of the progress
bar.
* **activityIndicatorTheme** - The theme for the activity indicator (spinner),
this can either be a string, in which each character is a different step, or
an array of strings.
* **preSubsection** - Displayed as a separator between the `section` and
`subsection` when the latter is printed.
More generally, themes can have any value that would be a valid value when rendering
templates. The properties in the theme are used when their name matches a type in
the template. Their values can be:
* **strings & numbers** - They'll be included as is
* **function (values, theme, width)** - Should return what you want in your output.
*values* is an object with values provided via `gauge.show`,
*theme* is the theme specific to this item (see below) or this theme object,
and *width* is the number of characters wide your result should be.
There are a couple of special prefixes:
* **pre** - Is shown prior to the property, if its displayed.
* **post** - Is shown after the property, if its displayed.
And one special suffix:
* **Theme** - Its value is passed to a function-type item as the theme.
#### themes.addToAllThemes(theme)
This *mixes-in* `theme` into all themes currently defined. It also adds it
to the default parent theme for this themeset, so future themes added to
this themeset will get the values from `theme` by default.
#### themes.newThemeset()
Copy the current themeset into a new one. This allows you to easily inherit
one themeset from another.
### TEMPLATES
A template is an array of objects and strings that, after being evaluated,
will be turned into the gauge line. The default template is:
```javascript
[
{type: 'progressbar', length: 20},
{type: 'activityIndicator', kerning: 1, length: 1},
{type: 'section', kerning: 1, default: ''},
{type: 'subsection', kerning: 1, default: ''}
]
```
The various template elements can either be **plain strings**, in which case they will
be be included verbatum in the output, or objects with the following properties:
* *type* can be any of the following plus any keys you pass into `gauge.show` plus
any keys you have on a custom theme.
* `section` – What big thing you're working on now.
* `subsection` – What component of that thing is currently working.
* `activityIndicator` – Shows a spinner using the `activityIndicatorTheme`
from your active theme.
* `progressbar` – A progress bar representing your current `completed`
using the `progressbarTheme` from your active theme.
* *kerning* – Number of spaces that must be between this item and other
items, if this item is displayed at all.
* *maxLength* – The maximum length for this element. If its value is longer it
will be truncated.
* *minLength* – The minimum length for this element. If its value is shorter it
will be padded according to the *align* value.
* *align* – (Default: left) Possible values "left", "right" and "center". Works
as you'd expect from word processors.
* *length* – Provides a single value for both *minLength* and *maxLength*. If both
*length* and *minLength or *maxLength* are specifed then the latter take precedence.
* *value* – A literal value to use for this template item.
* *default* – A default value to use for this template item if a value
wasn't otherwise passed in.
### PLUMBING
This is the super simple, assume nothing, do no magic internals used by gauge to
implement its ordinary interface.
```
var Plumbing = require('gauge/plumbing')
var gauge = new Plumbing(theme, template, width)
```
* **theme**: The theme to use.
* **template**: The template to use.
* **width**: How wide your gauge should be
#### `gauge.setTheme(theme)`
Change the active theme.
#### `gauge.setTemplate(template)`
Change the active template.
#### `gauge.setWidth(width)`
Change the width to render at.
#### `gauge.hide()`
Return the string necessary to hide the progress bar
#### `gauge.hideCursor()`
Return a string to hide the cursor.
#### `gauge.showCursor()`
Return a string to show the cursor.
#### `gauge.show(status)`
Using `status` for values, render the provided template with the theme and return
a string that is suitable for printing to update the gauge.

14
node_modules/gauge/base-theme.js generated vendored
View File

@@ -1,14 +0,0 @@
'use strict'
var spin = require('./spin.js')
var progressBar = require('./progress-bar.js')
module.exports = {
activityIndicator: function (values, theme, width) {
if (values.spun == null) return
return spin(theme, values.spun)
},
progressbar: function (values, theme, width) {
if (values.completed == null) return
return progressBar(theme, width, values.completed)
}
}

24
node_modules/gauge/error.js generated vendored
View File

@@ -1,24 +0,0 @@
'use strict'
var util = require('util')
var User = exports.User = function User (msg) {
var err = new Error(msg)
Error.captureStackTrace(err, User)
err.code = 'EGAUGE'
return err
}
exports.MissingTemplateValue = function MissingTemplateValue (item, values) {
var err = new User(util.format('Missing template value "%s"', item.type))
Error.captureStackTrace(err, MissingTemplateValue)
err.template = item
err.values = values
return err
}
exports.Internal = function Internal (msg) {
var err = new Error(msg)
Error.captureStackTrace(err, Internal)
err.code = 'EGAUGEINTERNAL'
return err
}

12
node_modules/gauge/has-color.js generated vendored
View File

@@ -1,12 +0,0 @@
'use strict'
module.exports = isWin32() || isColorTerm()
function isWin32 () {
return process.platform === 'win32'
}
function isColorTerm () {
var termHasColor = /^screen|^xterm|^vt100|color|ansi|cygwin|linux/i
return !!process.env.COLORTERM || termHasColor.test(process.env.TERM)
}

233
node_modules/gauge/index.js generated vendored
View File

@@ -1,233 +0,0 @@
'use strict'
var Plumbing = require('./plumbing.js')
var hasUnicode = require('has-unicode')
var hasColor = require('./has-color.js')
var onExit = require('signal-exit')
var defaultThemes = require('./themes')
var setInterval = require('./set-interval.js')
var process = require('./process.js')
var setImmediate = require('./set-immediate')
module.exports = Gauge
function callWith (obj, method) {
return function () {
return method.call(obj)
}
}
function Gauge (arg1, arg2) {
var options, writeTo
if (arg1 && arg1.write) {
writeTo = arg1
options = arg2 || {}
} else if (arg2 && arg2.write) {
writeTo = arg2
options = arg1 || {}
} else {
writeTo = process.stderr
options = arg1 || arg2 || {}
}
this._status = {
spun: 0,
section: '',
subsection: ''
}
this._paused = false // are we paused for back pressure?
this._disabled = true // are all progress bar updates disabled?
this._showing = false // do we WANT the progress bar on screen
this._onScreen = false // IS the progress bar on screen
this._needsRedraw = false // should we print something at next tick?
this._hideCursor = options.hideCursor == null ? true : options.hideCursor
this._fixedFramerate = options.fixedFramerate == null
? !(/^v0\.8\./.test(process.version))
: options.fixedFramerate
this._lastUpdateAt = null
this._updateInterval = options.updateInterval == null ? 50 : options.updateInterval
this._themes = options.themes || defaultThemes
this._theme = options.theme
var theme = this._computeTheme(options.theme)
var template = options.template || [
{type: 'progressbar', length: 20},
{type: 'activityIndicator', kerning: 1, length: 1},
{type: 'section', kerning: 1, default: ''},
{type: 'subsection', kerning: 1, default: ''}
]
this.setWriteTo(writeTo, options.tty)
var PlumbingClass = options.Plumbing || Plumbing
this._gauge = new PlumbingClass(theme, template, this.getWidth())
this._$$doRedraw = callWith(this, this._doRedraw)
this._$$handleSizeChange = callWith(this, this._handleSizeChange)
this._cleanupOnExit = options.cleanupOnExit == null || options.cleanupOnExit
this._removeOnExit = null
if (options.enabled || (options.enabled == null && this._tty && this._tty.isTTY)) {
this.enable()
} else {
this.disable()
}
}
Gauge.prototype = {}
Gauge.prototype.isEnabled = function () {
return !this._disabled
}
Gauge.prototype.setTemplate = function (template) {
this._gauge.setTemplate(template)
if (this._showing) this._requestRedraw()
}
Gauge.prototype._computeTheme = function (theme) {
if (!theme) theme = {}
if (typeof theme === 'string') {
theme = this._themes.getTheme(theme)
} else if (theme && (Object.keys(theme).length === 0 || theme.hasUnicode != null || theme.hasColor != null)) {
var useUnicode = theme.hasUnicode == null ? hasUnicode() : theme.hasUnicode
var useColor = theme.hasColor == null ? hasColor : theme.hasColor
theme = this._themes.getDefault({hasUnicode: useUnicode, hasColor: useColor, platform: theme.platform})
}
return theme
}
Gauge.prototype.setThemeset = function (themes) {
this._themes = themes
this.setTheme(this._theme)
}
Gauge.prototype.setTheme = function (theme) {
this._gauge.setTheme(this._computeTheme(theme))
if (this._showing) this._requestRedraw()
this._theme = theme
}
Gauge.prototype._requestRedraw = function () {
this._needsRedraw = true
if (!this._fixedFramerate) this._doRedraw()
}
Gauge.prototype.getWidth = function () {
return ((this._tty && this._tty.columns) || 80) - 1
}
Gauge.prototype.setWriteTo = function (writeTo, tty) {
var enabled = !this._disabled
if (enabled) this.disable()
this._writeTo = writeTo
this._tty = tty ||
(writeTo === process.stderr && process.stdout.isTTY && process.stdout) ||
(writeTo.isTTY && writeTo) ||
this._tty
if (this._gauge) this._gauge.setWidth(this.getWidth())
if (enabled) this.enable()
}
Gauge.prototype.enable = function () {
if (!this._disabled) return
this._disabled = false
if (this._tty) this._enableEvents()
if (this._showing) this.show()
}
Gauge.prototype.disable = function () {
if (this._disabled) return
if (this._showing) {
this._lastUpdateAt = null
this._showing = false
this._doRedraw()
this._showing = true
}
this._disabled = true
if (this._tty) this._disableEvents()
}
Gauge.prototype._enableEvents = function () {
if (this._cleanupOnExit) {
this._removeOnExit = onExit(callWith(this, this.disable))
}
this._tty.on('resize', this._$$handleSizeChange)
if (this._fixedFramerate) {
this.redrawTracker = setInterval(this._$$doRedraw, this._updateInterval)
if (this.redrawTracker.unref) this.redrawTracker.unref()
}
}
Gauge.prototype._disableEvents = function () {
this._tty.removeListener('resize', this._$$handleSizeChange)
if (this._fixedFramerate) clearInterval(this.redrawTracker)
if (this._removeOnExit) this._removeOnExit()
}
Gauge.prototype.hide = function (cb) {
if (this._disabled) return cb && process.nextTick(cb)
if (!this._showing) return cb && process.nextTick(cb)
this._showing = false
this._doRedraw()
cb && setImmediate(cb)
}
Gauge.prototype.show = function (section, completed) {
this._showing = true
if (typeof section === 'string') {
this._status.section = section
} else if (typeof section === 'object') {
var sectionKeys = Object.keys(section)
for (var ii = 0; ii < sectionKeys.length; ++ii) {
var key = sectionKeys[ii]
this._status[key] = section[key]
}
}
if (completed != null) this._status.completed = completed
if (this._disabled) return
this._requestRedraw()
}
Gauge.prototype.pulse = function (subsection) {
this._status.subsection = subsection || ''
this._status.spun ++
if (this._disabled) return
if (!this._showing) return
this._requestRedraw()
}
Gauge.prototype._handleSizeChange = function () {
this._gauge.setWidth(this._tty.columns - 1)
this._requestRedraw()
}
Gauge.prototype._doRedraw = function () {
if (this._disabled || this._paused) return
if (!this._fixedFramerate) {
var now = Date.now()
if (this._lastUpdateAt && now - this._lastUpdateAt < this._updateInterval) return
this._lastUpdateAt = now
}
if (!this._showing && this._onScreen) {
this._onScreen = false
var result = this._gauge.hide()
if (this._hideCursor) {
result += this._gauge.showCursor()
}
return this._writeTo.write(result)
}
if (!this._showing && !this._onScreen) return
if (this._showing && !this._onScreen) {
this._onScreen = true
this._needsRedraw = true
if (this._hideCursor) {
this._writeTo.write(this._gauge.hideCursor())
}
}
if (!this._needsRedraw) return
if (!this._writeTo.write(this._gauge.show(this._status))) {
this._paused = true
this._writeTo.on('drain', callWith(this, function () {
this._paused = false
this._doRedraw()
}))
}
}

4
node_modules/gauge/node_modules/ansi-regex/index.js generated vendored
View File

@@ -1,4 +0,0 @@
'use strict';
module.exports = function () {
return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
};

21
node_modules/gauge/node_modules/ansi-regex/license generated vendored
View File

@@ -1,21 +0,0 @@
The MIT License (MIT)
Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
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.

68
node_modules/gauge/node_modules/ansi-regex/package.json generated vendored
View File

@@ -1,68 +0,0 @@
{
"name": "ansi-regex",
"version": "2.1.1",
"description": "Regular expression for matching ANSI escape codes",
"license": "MIT",
"repository": "chalk/ansi-regex",
"author": {
"name": "Sindre Sorhus",
"email": "sindresorhus@gmail.com",
"url": "sindresorhus.com"
},
"maintainers": [
"Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)",
"Joshua Appelman <jappelman@xebia.com> (jbnicolai.com)",
"JD Ballard <i.am.qix@gmail.com> (github.com/qix-)"
],
"engines": {
"node": ">=0.10.0"
},
"scripts": {
"test": "xo && ava --verbose",
"view-supported": "node fixtures/view-codes.js"
},
"files": [
"index.js"
],
"keywords": [
"ansi",
"styles",
"color",
"colour",
"colors",
"terminal",
"console",
"cli",
"string",
"tty",
"escape",
"formatting",
"rgb",
"256",
"shell",
"xterm",
"command-line",
"text",
"regex",
"regexp",
"re",
"match",
"test",
"find",
"pattern"
],
"devDependencies": {
"ava": "0.17.0",
"xo": "0.16.0"
},
"xo": {
"rules": {
"guard-for-in": 0,
"no-loop-func": 0
}
}
,"_resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz"
,"_integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8="
,"_from": "ansi-regex@2.1.1"
}

39
node_modules/gauge/node_modules/ansi-regex/readme.md generated vendored
View File

@@ -1,39 +0,0 @@
# ansi-regex [![Build Status](https://travis-ci.org/chalk/ansi-regex.svg?branch=master)](https://travis-ci.org/chalk/ansi-regex)
> Regular expression for matching [ANSI escape codes](http://en.wikipedia.org/wiki/ANSI_escape_code)
## Install
```
$ npm install --save ansi-regex
```
## Usage
```js
const ansiRegex = require('ansi-regex');
ansiRegex().test('\u001b[4mcake\u001b[0m');
//=> true
ansiRegex().test('cake');
//=> false
'\u001b[4mcake\u001b[0m'.match(ansiRegex());
//=> ['\u001b[4m', '\u001b[0m']
```
## FAQ
### Why do you test for codes not in the ECMA 48 standard?
Some of the codes we run as a test are codes that we acquired finding various lists of non-standard or manufacturer specific codes. If I recall correctly, we test for both standard and non-standard codes, as most of them follow the same or similar format and can be safely matched in strings without the risk of removing actual string content. There are a few non-standard control codes that do not follow the traditional format (i.e. they end in numbers) thus forcing us to exclude them from the test because we cannot reliably match them.
On the historical side, those ECMA standards were established in the early 90's whereas the VT100, for example, was designed in the mid/late 70's. At that point in time, control codes were still pretty ungoverned and engineers used them for a multitude of things, namely to activate hardware ports that may have been proprietary. Somewhere else you see a similar 'anarchy' of codes is in the x86 architecture for processors; there are a ton of "interrupts" that can mean different things on certain brands of processors, most of which have been phased out.
## License
MIT © [Sindre Sorhus](http://sindresorhus.com)

46
node_modules/gauge/node_modules/is-fullwidth-code-point/index.js generated vendored
View File

@@ -1,46 +0,0 @@
'use strict';
var numberIsNan = require('number-is-nan');
module.exports = function (x) {
if (numberIsNan(x)) {
return false;
}
// https://github.com/nodejs/io.js/blob/cff7300a578be1b10001f2d967aaedc88aee6402/lib/readline.js#L1369
// code points are derived from:
// http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt
if (x >= 0x1100 && (
x <= 0x115f || // Hangul Jamo
0x2329 === x || // LEFT-POINTING ANGLE BRACKET
0x232a === x || // RIGHT-POINTING ANGLE BRACKET
// CJK Radicals Supplement .. Enclosed CJK Letters and Months
(0x2e80 <= x && x <= 0x3247 && x !== 0x303f) ||
// Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
0x3250 <= x && x <= 0x4dbf ||
// CJK Unified Ideographs .. Yi Radicals
0x4e00 <= x && x <= 0xa4c6 ||
// Hangul Jamo Extended-A
0xa960 <= x && x <= 0xa97c ||
// Hangul Syllables
0xac00 <= x && x <= 0xd7a3 ||
// CJK Compatibility Ideographs
0xf900 <= x && x <= 0xfaff ||
// Vertical Forms
0xfe10 <= x && x <= 0xfe19 ||
// CJK Compatibility Forms .. Small Form Variants
0xfe30 <= x && x <= 0xfe6b ||
// Halfwidth and Fullwidth Forms
0xff01 <= x && x <= 0xff60 ||
0xffe0 <= x && x <= 0xffe6 ||
// Kana Supplement
0x1b000 <= x && x <= 0x1b001 ||
// Enclosed Ideographic Supplement
0x1f200 <= x && x <= 0x1f251 ||
// CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
0x20000 <= x && x <= 0x3fffd)) {
return true;
}
return false;
}

21
node_modules/gauge/node_modules/is-fullwidth-code-point/license generated vendored
View File

@@ -1,21 +0,0 @@
The MIT License (MIT)
Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
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.

49
node_modules/gauge/node_modules/is-fullwidth-code-point/package.json generated vendored
View File

@@ -1,49 +0,0 @@
{
"name": "is-fullwidth-code-point",
"version": "1.0.0",
"description": "Check if the character represented by a given Unicode code point is fullwidth",
"license": "MIT",
"repository": "sindresorhus/is-fullwidth-code-point",
"author": {
"name": "Sindre Sorhus",
"email": "sindresorhus@gmail.com",
"url": "sindresorhus.com"
},
"engines": {
"node": ">=0.10.0"
},
"scripts": {
"test": "node test.js"
},
"files": [
"index.js"
],
"keywords": [
"fullwidth",
"full-width",
"full",
"width",
"unicode",
"character",
"char",
"string",
"str",
"codepoint",
"code",
"point",
"is",
"detect",
"check"
],
"dependencies": {
"number-is-nan": "^1.0.0"
},
"devDependencies": {
"ava": "0.0.4",
"code-point-at": "^1.0.0"
}
,"_resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz"
,"_integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs="
,"_from": "is-fullwidth-code-point@1.0.0"
}

39
node_modules/gauge/node_modules/is-fullwidth-code-point/readme.md generated vendored
View File

@@ -1,39 +0,0 @@
# is-fullwidth-code-point [![Build Status](https://travis-ci.org/sindresorhus/is-fullwidth-code-point.svg?branch=master)](https://travis-ci.org/sindresorhus/is-fullwidth-code-point)
> Check if the character represented by a given [Unicode code point](https://en.wikipedia.org/wiki/Code_point) is [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms)
## Install
```
$ npm install --save is-fullwidth-code-point
```
## Usage
```js
var isFullwidthCodePoint = require('is-fullwidth-code-point');
isFullwidthCodePoint('谢'.codePointAt());
//=> true
isFullwidthCodePoint('a'.codePointAt());
//=> false
```
## API
### isFullwidthCodePoint(input)
#### input
Type: `number`
[Code point](https://en.wikipedia.org/wiki/Code_point) of a character.
## License
MIT © [Sindre Sorhus](http://sindresorhus.com)

37
node_modules/gauge/node_modules/string-width/index.js generated vendored
View File

@@ -1,37 +0,0 @@
'use strict';
var stripAnsi = require('strip-ansi');
var codePointAt = require('code-point-at');
var isFullwidthCodePoint = require('is-fullwidth-code-point');
// https://github.com/nodejs/io.js/blob/cff7300a578be1b10001f2d967aaedc88aee6402/lib/readline.js#L1345
module.exports = function (str) {
if (typeof str !== 'string' || str.length === 0) {
return 0;
}
var width = 0;
str = stripAnsi(str);
for (var i = 0; i < str.length; i++) {
var code = codePointAt(str, i);
// ignore control characters
if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) {
continue;
}
// surrogates
if (code >= 0x10000) {
i++;
}
if (isFullwidthCodePoint(code)) {
width += 2;
} else {
width++;
}
}
return width;
};

21
node_modules/gauge/node_modules/string-width/license generated vendored
View File

@@ -1,21 +0,0 @@
The MIT License (MIT)
Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
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.

60
node_modules/gauge/node_modules/string-width/package.json generated vendored
View File

@@ -1,60 +0,0 @@
{
"name": "string-width",
"version": "1.0.2",
"description": "Get the visual width of a string - the number of columns required to display it",
"license": "MIT",
"repository": "sindresorhus/string-width",
"author": {
"name": "Sindre Sorhus",
"email": "sindresorhus@gmail.com",
"url": "sindresorhus.com"
},
"engines": {
"node": ">=0.10.0"
},
"scripts": {
"test": "xo && ava"
},
"files": [
"index.js"
],
"keywords": [
"string",
"str",
"character",
"char",
"unicode",
"width",
"visual",
"column",
"columns",
"fullwidth",
"full-width",
"full",
"ansi",
"escape",
"codes",
"cli",
"command-line",
"terminal",
"console",
"cjk",
"chinese",
"japanese",
"korean",
"fixed-width"
],
"dependencies": {
"code-point-at": "^1.0.0",
"is-fullwidth-code-point": "^1.0.0",
"strip-ansi": "^3.0.0"
},
"devDependencies": {
"ava": "*",
"xo": "*"
}
,"_resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz"
,"_integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M="
,"_from": "string-width@1.0.2"
}

42
node_modules/gauge/node_modules/string-width/readme.md generated vendored
View File

@@ -1,42 +0,0 @@
# string-width [![Build Status](https://travis-ci.org/sindresorhus/string-width.svg?branch=master)](https://travis-ci.org/sindresorhus/string-width)
> Get the visual width of a string - the number of columns required to display it
Some Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](http://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and doesn't affect the width.
Useful to be able to measure the actual width of command-line output.
## Install
```
$ npm install --save string-width
```
## Usage
```js
const stringWidth = require('string-width');
stringWidth('古');
//=> 2
stringWidth('\u001b[1m古\u001b[22m');
//=> 2
stringWidth('a');
//=> 1
```
## Related
- [string-width-cli](https://github.com/sindresorhus/string-width-cli) - CLI for this module
- [string-length](https://github.com/sindresorhus/string-length) - Get the real length of a string
- [widest-line](https://github.com/sindresorhus/widest-line) - Get the visual width of the widest line in a string
## License
MIT © [Sindre Sorhus](https://sindresorhus.com)

6
node_modules/gauge/node_modules/strip-ansi/index.js generated vendored
View File

@@ -1,6 +0,0 @@
'use strict';
var ansiRegex = require('ansi-regex')();
module.exports = function (str) {
return typeof str === 'string' ? str.replace(ansiRegex, '') : str;
};

21
node_modules/gauge/node_modules/strip-ansi/license generated vendored
View File

@@ -1,21 +0,0 @@
The MIT License (MIT)
Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
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.

61
node_modules/gauge/node_modules/strip-ansi/package.json generated vendored
View File

@@ -1,61 +0,0 @@
{
"name": "strip-ansi",
"version": "3.0.1",
"description": "Strip ANSI escape codes",
"license": "MIT",
"repository": "chalk/strip-ansi",
"author": {
"name": "Sindre Sorhus",
"email": "sindresorhus@gmail.com",
"url": "sindresorhus.com"
},
"maintainers": [
"Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)",
"Joshua Boy Nicolai Appelman <joshua@jbna.nl> (jbna.nl)",
"JD Ballard <i.am.qix@gmail.com> (github.com/qix-)"
],
"engines": {
"node": ">=0.10.0"
},
"scripts": {
"test": "xo && ava"
},
"files": [
"index.js"
],
"keywords": [
"strip",
"trim",
"remove",
"ansi",
"styles",
"color",
"colour",
"colors",
"terminal",
"console",
"string",
"tty",
"escape",
"formatting",
"rgb",
"256",
"shell",
"xterm",
"log",
"logging",
"command-line",
"text"
],
"dependencies": {
"ansi-regex": "^2.0.0"
},
"devDependencies": {
"ava": "*",
"xo": "*"
}
,"_resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz"
,"_integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8="
,"_from": "strip-ansi@3.0.1"
}

33
node_modules/gauge/node_modules/strip-ansi/readme.md generated vendored
View File

@@ -1,33 +0,0 @@
# strip-ansi [![Build Status](https://travis-ci.org/chalk/strip-ansi.svg?branch=master)](https://travis-ci.org/chalk/strip-ansi)
> Strip [ANSI escape codes](http://en.wikipedia.org/wiki/ANSI_escape_code)
## Install
```
$ npm install --save strip-ansi
```
## Usage
```js
var stripAnsi = require('strip-ansi');
stripAnsi('\u001b[4mcake\u001b[0m');
//=> 'cake'
```
## Related
- [strip-ansi-cli](https://github.com/chalk/strip-ansi-cli) - CLI for this module
- [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes
- [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes
- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right
## License
MIT © [Sindre Sorhus](http://sindresorhus.com)

67
node_modules/gauge/package.json generated vendored
View File

@@ -1,67 +0,0 @@
{
"name": "gauge",
"version": "2.7.4",
"description": "A terminal based horizontal guage",
"main": "index.js",
"scripts": {
"test": "standard && tap test/*.js --coverage",
"prepublish": "rm -f *~"
},
"repository": {
"type": "git",
"url": "https://github.com/iarna/gauge"
},
"keywords": [
"progressbar",
"progress",
"gauge"
],
"author": "Rebecca Turner <me@re-becca.org>",
"license": "ISC",
"bugs": {
"url": "https://github.com/iarna/gauge/issues"
},
"homepage": "https://github.com/iarna/gauge",
"dependencies": {
"aproba": "^1.0.3",
"console-control-strings": "^1.0.0",
"has-unicode": "^2.0.0",
"object-assign": "^4.1.0",
"signal-exit": "^3.0.0",
"string-width": "^1.0.1",
"strip-ansi": "^3.0.1",
"wide-align": "^1.1.0"
},
"devDependencies": {
"readable-stream": "^2.0.6",
"require-inject": "^1.4.0",
"standard": "^7.1.2",
"tap": "^5.7.2",
"through2": "^2.0.0"
},
"files": [
"base-theme.js",
"CHANGELOG.md",
"error.js",
"has-color.js",
"index.js",
"LICENSE",
"package.json",
"plumbing.js",
"process.js",
"progress-bar.js",
"README.md",
"render-template.js",
"set-immediate.js",
"set-interval.js",
"spin.js",
"template-item.js",
"theme-set.js",
"themes.js",
"wide-truncate.js"
]
,"_resolved": "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz"
,"_integrity": "sha1-LANAXHU4w51+s3sxcCLjJfsBi/c="
,"_from": "gauge@2.7.4"
}

48
node_modules/gauge/plumbing.js generated vendored
View File

@@ -1,48 +0,0 @@
'use strict'
var consoleControl = require('console-control-strings')
var renderTemplate = require('./render-template.js')
var validate = require('aproba')
var Plumbing = module.exports = function (theme, template, width) {
if (!width) width = 80
validate('OAN', [theme, template, width])
this.showing = false
this.theme = theme
this.width = width
this.template = template
}
Plumbing.prototype = {}
Plumbing.prototype.setTheme = function (theme) {
validate('O', [theme])
this.theme = theme
}
Plumbing.prototype.setTemplate = function (template) {
validate('A', [template])
this.template = template
}
Plumbing.prototype.setWidth = function (width) {
validate('N', [width])
this.width = width
}
Plumbing.prototype.hide = function () {
return consoleControl.gotoSOL() + consoleControl.eraseLine()
}
Plumbing.prototype.hideCursor = consoleControl.hideCursor
Plumbing.prototype.showCursor = consoleControl.showCursor
Plumbing.prototype.show = function (status) {
var values = Object.create(this.theme)
for (var key in status) {
values[key] = status[key]
}
return renderTemplate(this.width, this.template, values).trim() +
consoleControl.color('reset') +
consoleControl.eraseLine() + consoleControl.gotoSOL()
}

3
node_modules/gauge/process.js generated vendored
View File

@@ -1,3 +0,0 @@
'use strict'
// this exists so we can replace it during testing
module.exports = process

35
node_modules/gauge/progress-bar.js generated vendored
View File

@@ -1,35 +0,0 @@
'use strict'
var validate = require('aproba')
var renderTemplate = require('./render-template.js')
var wideTruncate = require('./wide-truncate')
var stringWidth = require('string-width')
module.exports = function (theme, width, completed) {
validate('ONN', [theme, width, completed])
if (completed < 0) completed = 0
if (completed > 1) completed = 1
if (width <= 0) return ''
var sofar = Math.round(width * completed)
var rest = width - sofar
var template = [
{type: 'complete', value: repeat(theme.complete, sofar), length: sofar},
{type: 'remaining', value: repeat(theme.remaining, rest), length: rest}
]
return renderTemplate(width, template, theme)
}
// lodash's way of repeating
function repeat (string, width) {
var result = ''
var n = width
do {
if (n % 2) {
result += string
}
n = Math.floor(n / 2)
/*eslint no-self-assign: 0*/
string += string
} while (n && stringWidth(result) < width)
return wideTruncate(result, width)
}

181
node_modules/gauge/render-template.js generated vendored
View File

@@ -1,181 +0,0 @@
'use strict'
var align = require('wide-align')
var validate = require('aproba')
var objectAssign = require('object-assign')
var wideTruncate = require('./wide-truncate')
var error = require('./error')
var TemplateItem = require('./template-item')
function renderValueWithValues (values) {
return function (item) {
return renderValue(item, values)
}
}
var renderTemplate = module.exports = function (width, template, values) {
var items = prepareItems(width, template, values)
var rendered = items.map(renderValueWithValues(values)).join('')
return align.left(wideTruncate(rendered, width), width)
}
function preType (item) {
var cappedTypeName = item.type[0].toUpperCase() + item.type.slice(1)
return 'pre' + cappedTypeName
}
function postType (item) {
var cappedTypeName = item.type[0].toUpperCase() + item.type.slice(1)
return 'post' + cappedTypeName
}
function hasPreOrPost (item, values) {
if (!item.type) return
return values[preType(item)] || values[postType(item)]
}
function generatePreAndPost (baseItem, parentValues) {
var item = objectAssign({}, baseItem)
var values = Object.create(parentValues)
var template = []
var pre = preType(item)
var post = postType(item)
if (values[pre]) {
template.push({value: values[pre]})
values[pre] = null
}
item.minLength = null
item.length = null
item.maxLength = null
template.push(item)
values[item.type] = values[item.type]
if (values[post]) {
template.push({value: values[post]})
values[post] = null
}
return function ($1, $2, length) {
return renderTemplate(length, template, values)
}
}
function prepareItems (width, template, values) {
function cloneAndObjectify (item, index, arr) {
var cloned = new TemplateItem(item, width)
var type = cloned.type
if (cloned.value == null) {
if (!(type in values)) {
if (cloned.default == null) {
throw new error.MissingTemplateValue(cloned, values)
} else {
cloned.value = cloned.default
}
} else {
cloned.value = values[type]
}
}
if (cloned.value == null || cloned.value === '') return null
cloned.index = index
cloned.first = index === 0
cloned.last = index === arr.length - 1
if (hasPreOrPost(cloned, values)) cloned.value = generatePreAndPost(cloned, values)
return cloned
}
var output = template.map(cloneAndObjectify).filter(function (item) { return item != null })
var outputLength = 0
var remainingSpace = width
var variableCount = output.length
function consumeSpace (length) {
if (length > remainingSpace) length = remainingSpace
outputLength += length
remainingSpace -= length
}
function finishSizing (item, length) {
if (item.finished) throw new error.Internal('Tried to finish template item that was already finished')
if (length === Infinity) throw new error.Internal('Length of template item cannot be infinity')
if (length != null) item.length = length
item.minLength = null
item.maxLength = null
--variableCount
item.finished = true
if (item.length == null) item.length = item.getBaseLength()
if (item.length == null) throw new error.Internal('Finished template items must have a length')
consumeSpace(item.getLength())
}
output.forEach(function (item) {
if (!item.kerning) return
var prevPadRight = item.first ? 0 : output[item.index - 1].padRight
if (!item.first && prevPadRight < item.kerning) item.padLeft = item.kerning - prevPadRight
if (!item.last) item.padRight = item.kerning
})
// Finish any that have a fixed (literal or intuited) length
output.forEach(function (item) {
if (item.getBaseLength() == null) return
finishSizing(item)
})
var resized = 0
var resizing
var hunkSize
do {
resizing = false
hunkSize = Math.round(remainingSpace / variableCount)
output.forEach(function (item) {
if (item.finished) return
if (!item.maxLength) return
if (item.getMaxLength() < hunkSize) {
finishSizing(item, item.maxLength)
resizing = true
}
})
} while (resizing && resized++ < output.length)
if (resizing) throw new error.Internal('Resize loop iterated too many times while determining maxLength')
resized = 0
do {
resizing = false
hunkSize = Math.round(remainingSpace / variableCount)
output.forEach(function (item) {
if (item.finished) return
if (!item.minLength) return
if (item.getMinLength() >= hunkSize) {
finishSizing(item, item.minLength)
resizing = true
}
})
} while (resizing && resized++ < output.length)
if (resizing) throw new error.Internal('Resize loop iterated too many times while determining minLength')
hunkSize = Math.round(remainingSpace / variableCount)
output.forEach(function (item) {
if (item.finished) return
finishSizing(item, hunkSize)
})
return output
}
function renderFunction (item, values, length) {
validate('OON', arguments)
if (item.type) {
return item.value(values, values[item.type + 'Theme'] || {}, length)
} else {
return item.value(values, {}, length)
}
}
function renderValue (item, values) {
var length = item.getBaseLength()
var value = typeof item.value === 'function' ? renderFunction(item, values, length) : item.value
if (value == null || value === '') return ''
var alignWith = align[item.align] || align.left
var leftPadding = item.padLeft ? align.left('', item.padLeft) : ''
var rightPadding = item.padRight ? align.right('', item.padRight) : ''
var truncated = wideTruncate(String(value), length)
var aligned = alignWith(truncated, length)
return leftPadding + aligned + rightPadding
}

7
node_modules/gauge/set-immediate.js generated vendored
View File

@@ -1,7 +0,0 @@
'use strict'
var process = require('./process')
try {
module.exports = setImmediate
} catch (ex) {
module.exports = process.nextTick
}

3
node_modules/gauge/set-interval.js generated vendored
View File

@@ -1,3 +0,0 @@
'use strict'
// this exists so we can replace it during testing
module.exports = setInterval

Some files were not shown because too many files have changed in this diff Show More