meteor-node-stubs 1.0.2 → 1.2.0

package/node_modules/base64-js/test/convert.js

@@ -1,88 +0,0 @@
-var test = require('tape')
-var b64 = require('../')
-var checks = [
-  'a',
-  'aa',
-  'aaa',
-  'hi',
-  'hi!',
-  'hi!!',
-  'sup',
-  'sup?',
-  'sup?!'
-]
-
-test('convert to base64 and back', function (t) {
-  t.plan(checks.length * 2)
-
-  for (var i = 0; i < checks.length; i++) {
-    var check = checks[i]
-    var b64Str, arr, str
-
-    b64Str = b64.fromByteArray(map(check, function (char) { return char.charCodeAt(0) }))
-
-    arr = b64.toByteArray(b64Str)
-    str = map(arr, function (byte) { return String.fromCharCode(byte) }).join('')
-
-    t.equal(check, str, 'Checked ' + check)
-    t.equal(b64.byteLength(b64Str), arr.length, 'Checked length for ' + check)
-  }
-})
-
-var data = [
-  [[0, 0, 0], 'AAAA'],
-  [[0, 0, 1], 'AAAB'],
-  [[0, 1, -1], 'AAH/'],
-  [[1, 1, 1], 'AQEB'],
-  [[0, -73, 23], 'ALcX']
-]
-
-test('convert known data to string', function (t) {
-  for (var i = 0; i < data.length; i++) {
-    var bytes = data[i][0]
-    var expected = data[i][1]
-    var actual = b64.fromByteArray(bytes)
-    t.equal(actual, expected, 'Ensure that ' + bytes + ' serialise to ' + expected)
-  }
-  t.end()
-})
-
-test('convert known data from string', function (t) {
-  for (var i = 0; i < data.length; i++) {
-    var expected = data[i][0]
-    var string = data[i][1]
-    var actual = b64.toByteArray(string)
-    t.ok(equal(actual, expected), 'Ensure that ' + string + ' deserialise to ' + expected)
-    var length = b64.byteLength(string)
-    t.equal(length, expected.length, 'Ensure that ' + string + ' has byte lentgh of ' + expected.length)
-  }
-  t.end()
-})
-
-function equal (a, b) {
-  var i
-  var length = a.length
-  if (length !== b.length) return false
-  for (i = 0; i < length; ++i) {
-    if ((a[i] & 0xFF) !== (b[i] & 0xFF)) return false
-  }
-  return true
-}
-
-function map (arr, callback) {
-  var res = []
-  var kValue, mappedValue
-
-  for (var k = 0, len = arr.length; k < len; k++) {
-    if ((typeof arr === 'string' && !!arr.charAt(k))) {
-      kValue = arr.charAt(k)
-      mappedValue = callback(kValue, k, arr)
-      res[k] = mappedValue
-    } else if (typeof arr !== 'string' && k in arr) {
-      kValue = arr[k]
-      mappedValue = callback(kValue, k, arr)
-      res[k] = mappedValue
-    }
-  }
-  return res
-}

package/node_modules/base64-js/test/corrupt.js

@@ -1,10 +0,0 @@
-var test = require('tape')
-var b64 = require('../')
-
-test('padding bytes found inside base64 string', function (t) {
-  // See https://github.com/beatgammit/base64-js/issues/42
-  var str = 'SQ==QU0='
-  t.deepEqual(b64.toByteArray(str), new Uint8Array([73]))
-  t.equal(b64.byteLength(str), 1)
-  t.end()
-})

package/node_modules/base64-js/test/url-safe.js

@@ -1,24 +0,0 @@
-var test = require('tape')
-var b64 = require('../')
-
-test('decode url-safe style base64 strings', function (t) {
-  var expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff]
-
-  var str = '//++/++/++//'
-  var actual = b64.toByteArray(str)
-  for (var i = 0; i < actual.length; i++) {
-    t.equal(actual[i], expected[i])
-  }
-
-  t.equal(b64.byteLength(str), actual.length)
-
-  str = '__--_--_--__'
-  actual = b64.toByteArray(str)
-  for (i = 0; i < actual.length; i++) {
-    t.equal(actual[i], expected[i])
-  }
-
-  t.equal(b64.byteLength(str), actual.length)
-
-  t.end()
-})

package/node_modules/bn.js/.npmignore

@@ -1,8 +0,0 @@
-benchmarks/
-coverage/
-test/
-node_modules/
-npm-debug.log
-1.js
-logo.png
-.travis.yml

package/node_modules/bn.js/README.md

@@ -1,221 +0,0 @@
-# <img src="./logo.png" alt="bn.js" width="160" height="160" />
-
-> BigNum in pure javascript
-
-[![Build Status](https://secure.travis-ci.org/indutny/bn.js.png)](http://travis-ci.org/indutny/bn.js)
-
-## Install
-`npm install --save bn.js`
-
-## Usage
-
-```js
-const BN = require('bn.js');
-
-var a = new BN('dead', 16);
-var b = new BN('101010', 2);
-
-var res = a.add(b);
-console.log(res.toString(10));  // 57047
-```
-
-**Note**: decimals are not supported in this library.
-
-## Notation
-
-### Prefixes
-
-There are several prefixes to instructions that affect the way the work. Here
-is the list of them in the order of appearance in the function name:
-
-* `i` - perform operation in-place, storing the result in the host object (on
-  which the method was invoked). Might be used to avoid number allocation costs
-* `u` - unsigned, ignore the sign of operands when performing operation, or
-  always return positive value. Second case applies to reduction operations
-  like `mod()`. In such cases if the result will be negative - modulo will be
-  added to the result to make it positive
-
-### Postfixes
-
-The only available postfix at the moment is:
-
-* `n` - which means that the argument of the function must be a plain JavaScript
-  Number. Decimals are not supported.
-
-### Examples
-
-* `a.iadd(b)` - perform addition on `a` and `b`, storing the result in `a`
-* `a.umod(b)` - reduce `a` modulo `b`, returning positive value
-* `a.iushln(13)` - shift bits of `a` left by 13
-
-## Instructions
-
-Prefixes/postfixes are put in parens at the of the line. `endian` - could be
-either `le` (little-endian) or `be` (big-endian).
-
-### Utilities
-
-* `a.clone()` - clone number
-* `a.toString(base, length)` - convert to base-string and pad with zeroes
-* `a.toNumber()` - convert to Javascript Number (limited to 53 bits)
-* `a.toJSON()` - convert to JSON compatible hex string (alias of `toString(16)`)
-* `a.toArray(endian, length)` - convert to byte `Array`, and optionally zero
-  pad to length, throwing if already exceeding
-* `a.toArrayLike(type, endian, length)` - convert to an instance of `type`,
-  which must behave like an `Array`
-* `a.toBuffer(endian, length)` - convert to Node.js Buffer (if available). For
-  compatibility with browserify and similar tools, use this instead:
-  `a.toArrayLike(Buffer, endian, length)`
-* `a.bitLength()` - get number of bits occupied
-* `a.zeroBits()` - return number of less-significant consequent zero bits
-  (example: `1010000` has 4 zero bits)
-* `a.byteLength()` - return number of bytes occupied
-* `a.isNeg()` - true if the number is negative
-* `a.isEven()` - no comments
-* `a.isOdd()` - no comments
-* `a.isZero()` - no comments
-* `a.cmp(b)` - compare numbers and return `-1` (a `<` b), `0` (a `==` b), or `1` (a `>` b)
-  depending on the comparison result (`ucmp`, `cmpn`)
-* `a.lt(b)` - `a` less than `b` (`n`)
-* `a.lte(b)` - `a` less than or equals `b` (`n`)
-* `a.gt(b)` - `a` greater than `b` (`n`)
-* `a.gte(b)` - `a` greater than or equals `b` (`n`)
-* `a.eq(b)` - `a` equals `b` (`n`)
-* `a.toTwos(width)` - convert to two's complement representation, where `width` is bit width
-* `a.fromTwos(width)` - convert from two's complement representation, where `width` is the bit width
-* `BN.isBN(object)` - returns true if the supplied `object` is a BN.js instance
-
-### Arithmetics
-
-* `a.neg()` - negate sign (`i`)
-* `a.abs()` - absolute value (`i`)
-* `a.add(b)` - addition (`i`, `n`, `in`)
-* `a.sub(b)` - subtraction (`i`, `n`, `in`)
-* `a.mul(b)` - multiply (`i`, `n`, `in`)
-* `a.sqr()` - square (`i`)
-* `a.pow(b)` - raise `a` to the power of `b`
-* `a.div(b)` - divide (`divn`, `idivn`)
-* `a.mod(b)` - reduct (`u`, `n`) (but no `umodn`)
-* `a.divRound(b)` - rounded division
-
-### Bit operations
-
-* `a.or(b)` - or (`i`, `u`, `iu`)
-* `a.and(b)` - and (`i`, `u`, `iu`, `andln`) (NOTE: `andln` is going to be replaced
-  with `andn` in future)
-* `a.xor(b)` - xor (`i`, `u`, `iu`)
-* `a.setn(b)` - set specified bit to `1`
-* `a.shln(b)` - shift left (`i`, `u`, `iu`)
-* `a.shrn(b)` - shift right (`i`, `u`, `iu`)
-* `a.testn(b)` - test if specified bit is set
-* `a.maskn(b)` - clear bits with indexes higher or equal to `b` (`i`)
-* `a.bincn(b)` - add `1 << b` to the number
-* `a.notn(w)` - not (for the width specified by `w`) (`i`)
-
-### Reduction
-
-* `a.gcd(b)` - GCD
-* `a.egcd(b)` - Extended GCD results (`{ a: ..., b: ..., gcd: ... }`)
-* `a.invm(b)` - inverse `a` modulo `b`
-
-## Fast reduction
-
-When doing lots of reductions using the same modulo, it might be beneficial to
-use some tricks: like [Montgomery multiplication][0], or using special algorithm
-for [Mersenne Prime][1].
-
-### Reduction context
-
-To enable this tricks one should create a reduction context:
-
-```js
-var red = BN.red(num);
-```
-where `num` is just a BN instance.
-
-Or:
-
-```js
-var red = BN.red(primeName);
-```
-
-Where `primeName` is either of these [Mersenne Primes][1]:
-
-* `'k256'`
-* `'p224'`
-* `'p192'`
-* `'p25519'`
-
-Or:
-
-```js
-var red = BN.mont(num);
-```
-
-To reduce numbers with [Montgomery trick][0]. `.mont()` is generally faster than
-`.red(num)`, but slower than `BN.red(primeName)`.
-
-### Converting numbers
-
-Before performing anything in reduction context - numbers should be converted
-to it. Usually, this means that one should:
-
-* Convert inputs to reducted ones
-* Operate on them in reduction context
-* Convert outputs back from the reduction context
-
-Here is how one may convert numbers to `red`:
-
-```js
-var redA = a.toRed(red);
-```
-Where `red` is a reduction context created using instructions above
-
-Here is how to convert them back:
-
-```js
-var a = redA.fromRed();
-```
-
-### Red instructions
-
-Most of the instructions from the very start of this readme have their
-counterparts in red context:
-
-* `a.redAdd(b)`, `a.redIAdd(b)`
-* `a.redSub(b)`, `a.redISub(b)`
-* `a.redShl(num)`
-* `a.redMul(b)`, `a.redIMul(b)`
-* `a.redSqr()`, `a.redISqr()`
-* `a.redSqrt()` - square root modulo reduction context's prime
-* `a.redInvm()` - modular inverse of the number
-* `a.redNeg()`
-* `a.redPow(b)` - modular exponentiation
-
-## LICENSE
-
-This software is licensed under the MIT License.
-
-Copyright Fedor Indutny, 2015.
-
-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.
-
-[0]: https://en.wikipedia.org/wiki/Montgomery_modular_multiplication
-[1]: https://en.wikipedia.org/wiki/Mersenne_prime