meteor-node-stubs 1.0.3 → 1.2.1

package/node_modules/assert/test.js

@@ -1,360 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// 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.
-
-var nodeAssert = require('assert');
-var ourAssert = require('./');
-var keys = Object.keys;
-if (process.env.TEST_NATIVE === true) {
-  tests(nodeAssert, 'node assert');
-} else {
-  tests(ourAssert, 'our assert');
-}
-
-function makeBlock(f) {
-  var args = Array.prototype.slice.call(arguments, 1);
-  return function() {
-    return f.apply(this, args);
-  };
-}
-
-function tests (assert, what) {
-    test('assert.ok', function () {
-      assert.throws(makeBlock(assert, false), assert.AssertionError, 'ok(false)');
-
-      assert.doesNotThrow(makeBlock(assert, true), assert.AssertionError, 'ok(true)');
-
-      assert.doesNotThrow(makeBlock(assert, 'test', 'ok(\'test\')'));
-
-      assert.throws(makeBlock(assert.ok, false),
-                    assert.AssertionError, 'ok(false)');
-
-      assert.doesNotThrow(makeBlock(assert.ok, true),
-                          assert.AssertionError, 'ok(true)');
-
-      assert.doesNotThrow(makeBlock(assert.ok, 'test'), 'ok(\'test\')');
-    });
-
-    test('assert.equal', function () {
-      assert.throws(makeBlock(assert.equal, true, false), assert.AssertionError, 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, null, null), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, undefined, undefined), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, null, undefined), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, true, true), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.equal, 2, '2'), 'equal');
-
-      assert.doesNotThrow(makeBlock(assert.notEqual, true, false), 'notEqual');
-
-      assert.throws(makeBlock(assert.notEqual, true, true),
-                    assert.AssertionError, 'notEqual');
-    });
-
-    test('assert.strictEqual', function () {
-      assert.throws(makeBlock(assert.strictEqual, 2, '2'),
-                    assert.AssertionError, 'strictEqual');
-
-      assert.throws(makeBlock(assert.strictEqual, null, undefined),
-                    assert.AssertionError, 'strictEqual');
-
-      assert.doesNotThrow(makeBlock(assert.notStrictEqual, 2, '2'), 'notStrictEqual');
-    });
-
-    test('assert.deepStrictEqual', function () {
-      assert.throws(makeBlock(assert.deepStrictEqual, [2], ['2']),
-                    assert.AssertionError, 'deepStrictEqual');
-
-      assert.throws(makeBlock(assert.deepStrictEqual, [null], [undefined]),
-                    assert.AssertionError, 'deepStrictEqual');
-
-      assert.doesNotThrow(makeBlock(assert.notDeepStrictEqual, [2], ['2']), 'notDeepStrictEqual');
-    });
-
-    test('assert.deepEqual - 7.2', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new Date(2000, 3, 14),
-                          new Date(2000, 3, 14)), 'deepEqual date');
-
-      assert.throws(makeBlock(assert.deepEqual, new Date(), new Date(2000, 3, 14)),
-                    assert.AssertionError,
-                    'deepEqual date');
-    });
-
-    test('assert.deepEqual - 7.3', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/, /a/));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/g, /a/g));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/i, /a/i));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/m, /a/m));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, /a/igm, /a/igm));
-      assert.throws(makeBlock(assert.deepEqual, /ab/, /a/));
-      assert.throws(makeBlock(assert.deepEqual, /a/g, /a/));
-      assert.throws(makeBlock(assert.deepEqual, /a/i, /a/));
-      assert.throws(makeBlock(assert.deepEqual, /a/m, /a/));
-      assert.throws(makeBlock(assert.deepEqual, /a/igm, /a/im));
-
-      var re1 = /a/;
-      re1.lastIndex = 3;
-      assert.throws(makeBlock(assert.deepEqual, re1, /a/));
-    });
-
-    test('assert.deepEqual - 7.4', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, 4, '4'), 'deepEqual == check');
-      assert.doesNotThrow(makeBlock(assert.deepEqual, true, 1), 'deepEqual == check');
-      assert.throws(makeBlock(assert.deepEqual, 4, '5'),
-                assert.AssertionError,
-                'deepEqual == check');
-    });
-
-    test('assert.deepEqual - 7.5', function () {
-      // having the same number of owned properties && the same set of keys
-      assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4}, {a: 4}));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '2'}, {a: 4, b: '2'}));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, [4], ['4']));
-      assert.throws(makeBlock(assert.deepEqual, {a: 4}, {a: 4, b: true}),
-                assert.AssertionError);
-      assert.doesNotThrow(makeBlock(assert.deepEqual, ['a'], {0: 'a'}));
-      //(although not necessarily the same order),
-      assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '1'}, {b: '1', a: 4}));
-      var a1 = [1, 2, 3];
-      var a2 = [1, 2, 3];
-      a1.a = 'test';
-      a1.b = true;
-      a2.b = true;
-      a2.a = 'test';
-      assert.throws(makeBlock(assert.deepEqual, keys(a1), keys(a2)),
-                assert.AssertionError);
-      assert.doesNotThrow(makeBlock(assert.deepEqual, a1, a2));
-    });
-
-    test('assert.deepEqual - ES6 primitives', function () {
-      assert.throws(makeBlock(assert.deepEqual, null, {}), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, undefined, {}), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, 'a', ['a']), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, 'a', {0: 'a'}), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, 1, {}), assert.AssertionError);
-      assert.throws(makeBlock(assert.deepEqual, true, {}), assert.AssertionError);
-      if (typeof Symbol === 'symbol') {
-        assert.throws(makeBlock(assert.deepEqual, Symbol(), {}), assert.AssertionError);
-      }
-    });
-
-    test('assert.deepEqual - object wrappers', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), ['a']));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), {0: 'a'}));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new Number(1), {}));
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new Boolean(true), {}));
-    });
-
-    test('assert.deepEqual - Buffers', function () {
-      assert.doesNotThrow(makeBlock(assert.deepEqual, new Buffer([1, 2, 3]), new Buffer([1, 2, 3])));
-      if (typeof global.Uint8Array === 'function') {
-        assert.throws(makeBlock(assert.deepEqual, new Buffer([1, 2, 3]), new Uint8Array([1, 2, 3])));
-      }
-      if (typeof global.Uint16Array === 'function') {
-        assert.doesNotThrow(makeBlock(assert.deepEqual, new Uint16Array([1, 2, 3]), new Uint16Array([1, 2, 3])));
-      }
-    });
-
-    function thrower(errorConstructor) {
-      throw new errorConstructor('test');
-    }
-
-    test('assert - testing the throwing', function () {
-      var aethrow = makeBlock(thrower, assert.AssertionError);
-      aethrow = makeBlock(thrower, assert.AssertionError);
-
-      // the basic calls work
-      assert.throws(makeBlock(thrower, assert.AssertionError),
-                    assert.AssertionError, 'message');
-      assert.throws(makeBlock(thrower, assert.AssertionError), assert.AssertionError);
-      assert.throws(makeBlock(thrower, assert.AssertionError));
-
-      // if not passing an error, catch all.
-      assert.throws(makeBlock(thrower, TypeError));
-
-      // when passing a type, only catch errors of the appropriate type
-      var threw = false;
-      try {
-        assert.throws(makeBlock(thrower, TypeError), assert.AssertionError);
-      } catch (e) {
-        threw = true;
-        assert.ok(e instanceof TypeError, 'type');
-      }
-      assert.equal(true, threw,
-                   'a.throws with an explicit error is eating extra errors',
-                   assert.AssertionError);
-      threw = false;
-
-      // doesNotThrow should pass through all errors
-      try {
-        assert.doesNotThrow(makeBlock(thrower, TypeError), assert.AssertionError);
-      } catch (e) {
-        threw = true;
-        assert.ok(e instanceof TypeError);
-      }
-      assert.equal(true, threw,
-                   'a.doesNotThrow with an explicit error is eating extra errors');
-
-      // key difference is that throwing our correct error makes an assertion error
-      try {
-        assert.doesNotThrow(makeBlock(thrower, TypeError), TypeError);
-      } catch (e) {
-        threw = true;
-        assert.ok(e instanceof assert.AssertionError);
-      }
-      assert.equal(true, threw,
-                   'a.doesNotThrow is not catching type matching errors');
-    });
-
-    test('assert.ifError', function () {
-      assert.throws(function() {assert.ifError(new Error('test error'))});
-      assert.doesNotThrow(function() {assert.ifError(null)});
-      assert.doesNotThrow(function() {assert.ifError()});
-    });
-
-    test('assert - make sure that validating using constructor really works', function () {
-      var threw = false;
-      try {
-        assert.throws(
-            function() {
-              throw ({});
-            },
-            Array
-        );
-      } catch (e) {
-        threw = true;
-      }
-      assert.ok(threw, 'wrong constructor validation');
-    });
-
-    test('assert - use a RegExp to validate error message', function () {
-      assert.throws(makeBlock(thrower, TypeError), /test/);
-    });
-
-    test('assert - use a fn to validate error object', function () {
-      assert.throws(makeBlock(thrower, TypeError), function(err) {
-        if ((err instanceof TypeError) && /test/.test(err)) {
-          return true;
-        }
-      });
-    });
-
-    test('assert - make sure deepEqual doesn\'t loop forever on circular refs', function () {
-      var b = {};
-      b.b = b;
-
-      var c = {};
-      c.b = c;
-
-      var gotError = false;
-      var equal = true;
-      try {
-        equal = assert.deepEqual(b, c);
-      } catch (e) {
-        gotError = true;
-      }
-      assert.ok(gotError || !equal, gotError ? 'got error': 'are equal');
-    });
-
-    test('assert - ensure reflexivity of deepEqual with `arguments` objects', function() {
-        var args = (function() { return arguments; })();
-        assert.throws(makeBlock(assert.deepEqual, [], args), assert.AssertionError);
-        assert.throws(makeBlock(assert.deepEqual, args, []), assert.AssertionError);
-    });
-
-    test('assert - test assertion message', function () {
-      function testAssertionMessage(actual, expected) {
-        try {
-          assert.equal(actual, '');
-        } catch (e) {
-          assert.equal(e.toString(),
-              ['AssertionError:', expected, '==', '\'\''].join(' '));
-        }
-      }
-      testAssertionMessage(undefined, 'undefined');
-      testAssertionMessage(null, 'null');
-      testAssertionMessage(true, 'true');
-      testAssertionMessage(false, 'false');
-      testAssertionMessage(0, '0');
-      testAssertionMessage(100, '100');
-      testAssertionMessage(NaN, 'NaN');
-      testAssertionMessage(Infinity, 'Infinity');
-      testAssertionMessage(-Infinity, '-Infinity');
-      testAssertionMessage('', '""');
-      testAssertionMessage('foo', '\'foo\'');
-      testAssertionMessage([], '[]');
-      testAssertionMessage([1, 2, 3], '[ 1, 2, 3 ]');
-      testAssertionMessage(new Buffer([1, 2, 3]), '<Buffer 01 02 03>');
-      if (typeof global.Uint8Array === 'function' && Object.getOwnPropertyNames( new Uint8Array([])).length === 0) {
-        // todo fix util.inspect
-        testAssertionMessage(new Uint8Array([1, 2, 3]), '{ \'0\': 1, \'1\': 2, \'2\': 3 }');
-      }
-      testAssertionMessage(/a/, '/a/');
-      testAssertionMessage(function f() {}, '[Function: f]');
-      testAssertionMessage({}, '{}');
-      testAssertionMessage({a: undefined, b: null}, '{ a: undefined, b: null }');
-      testAssertionMessage({a: NaN, b: Infinity, c: -Infinity},
-          '{ a: NaN, b: Infinity, c: -Infinity }');
-    });
-
-    test('assert - regressions from node.js testcase', function () {
-      var threw = false;
-
-      try {
-        assert.throws(function () {
-          assert.ifError(null);
-        });
-      } catch (e) {
-        threw = true;
-        assert.equal(e.message, 'Missing expected exception..');
-      }
-      assert.ok(threw);
-
-      try {
-        assert.equal(1, 2);
-      } catch (e) {
-        assert.equal(e.toString().split('\n')[0], 'AssertionError: 1 == 2');
-      }
-
-      try {
-        assert.equal(1, 2, 'oh no');
-      } catch (e) {
-        assert.equal(e.toString().split('\n')[0], 'AssertionError: oh no');
-      }
-    });
-
-    test('assert - strict mode', function () {
-      var assertStrict = assert.strict;
-
-      assertStrict.throws(makeBlock(assertStrict.equal, 1, true), assertStrict.AssertionError);
-      assertStrict.notEqual(0, false);
-      assertStrict.throws(makeBlock(assertStrict.deepEqual, 1, true), assertStrict.AssertionError);
-      assertStrict.notDeepEqual(0, false);
-      assertStrict.equal(assertStrict.strict, assertStrict.strict.strict);
-      assertStrict.equal(assertStrict.equal, assertStrict.strictEqual);
-      assertStrict.equal(assertStrict.deepEqual, assertStrict.deepStrictEqual);
-      assertStrict.equal(assertStrict.notEqual, assertStrict.notStrictEqual);
-      assertStrict.equal(assertStrict.notDeepEqual, assertStrict.notDeepStrictEqual);
-      assertStrict.equal(Object.keys(assertStrict).length, Object.keys(assert).length);
-    });
-}

package/node_modules/browserify-sign/node_modules/inherits/LICENSE

@@ -1,16 +0,0 @@
-The ISC License
-
-Copyright (c) Isaac Z. Schlueter
-
-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.
-

package/node_modules/browserify-sign/node_modules/inherits/README.md

@@ -1,42 +0,0 @@
-Browser-friendly inheritance fully compatible with standard node.js
-[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).
-
-This package exports standard `inherits` from node.js `util` module in
-node environment, but also provides alternative browser-friendly
-implementation through [browser
-field](https://gist.github.com/shtylman/4339901). Alternative
-implementation is a literal copy of standard one located in standalone
-module to avoid requiring of `util`. It also has a shim for old
-browsers with no `Object.create` support.
-
-While keeping you sure you are using standard `inherits`
-implementation in node.js environment, it allows bundlers such as
-[browserify](https://github.com/substack/node-browserify) to not
-include full `util` package to your client code if all you need is
-just `inherits` function. It worth, because browser shim for `util`
-package is large and `inherits` is often the single function you need
-from it.
-
-It's recommended to use this package instead of
-`require('util').inherits` for any code that has chances to be used
-not only in node.js but in browser too.
-
-## usage
-
-```js
-var inherits = require('inherits');
-// then use exactly as the standard one
-```
-
-## note on version ~1.0
-
-Version ~1.0 had completely different motivation and is not compatible
-neither with 2.0 nor with standard node.js `inherits`.
-
-If you are using version ~1.0 and planning to switch to ~2.0, be
-careful:
-
-* new version uses `super_` instead of `super` for referencing
-  superclass
-* new version overwrites current prototype while old one preserves any
-  existing fields on it

package/node_modules/browserify-sign/node_modules/inherits/inherits.js

@@ -1,9 +0,0 @@
-try {
-  var util = require('util');
-  /* istanbul ignore next */
-  if (typeof util.inherits !== 'function') throw '';
-  module.exports = util.inherits;
-} catch (e) {
-  /* istanbul ignore next */
-  module.exports = require('./inherits_browser.js');
-}

package/node_modules/browserify-sign/node_modules/inherits/inherits_browser.js

@@ -1,27 +0,0 @@
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  module.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor
-      ctor.prototype = Object.create(superCtor.prototype, {
-        constructor: {
-          value: ctor,
-          enumerable: false,
-          writable: true,
-          configurable: true
-        }
-      })
-    }
-  };
-} else {
-  // old school shim for old browsers
-  module.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor
-      var TempCtor = function () {}
-      TempCtor.prototype = superCtor.prototype
-      ctor.prototype = new TempCtor()
-      ctor.prototype.constructor = ctor
-    }
-  }
-}

package/node_modules/browserify-sign/node_modules/inherits/package.json

@@ -1,61 +0,0 @@
-{
-  "_from": "inherits@^2.0.4",
-  "_id": "inherits@2.0.4",
-  "_inBundle": false,
-  "_integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-  "_location": "/browserify-sign/inherits",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "inherits@^2.0.4",
-    "name": "inherits",
-    "escapedName": "inherits",
-    "rawSpec": "^2.0.4",
-    "saveSpec": null,
-    "fetchSpec": "^2.0.4"
-  },
-  "_requiredBy": [
-    "/browserify-sign"
-  ],
-  "_resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-  "_shasum": "0fa2c64f932917c3433a0ded55363aae37416b7c",
-  "_spec": "inherits@^2.0.4",
-  "_where": "/Users/filipe/Documents/meteor/ws/node-stubs/node_modules/browserify-sign",
-  "browser": "./inherits_browser.js",
-  "bugs": {
-    "url": "https://github.com/isaacs/inherits/issues"
-  },
-  "bundleDependencies": false,
-  "deprecated": false,
-  "description": "Browser-friendly inheritance fully compatible with standard node.js inherits()",
-  "devDependencies": {
-    "tap": "^14.2.4"
-  },
-  "files": [
-    "inherits.js",
-    "inherits_browser.js"
-  ],
-  "homepage": "https://github.com/isaacs/inherits#readme",
-  "keywords": [
-    "inheritance",
-    "class",
-    "klass",
-    "oop",
-    "object-oriented",
-    "inherits",
-    "browser",
-    "browserify"
-  ],
-  "license": "ISC",
-  "main": "./inherits.js",
-  "name": "inherits",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/isaacs/inherits.git"
-  },
-  "scripts": {
-    "test": "tap"
-  },
-  "version": "2.0.4"
-}

package/node_modules/core-util-is/LICENSE

@@ -1,19 +0,0 @@
-Copyright Node.js contributors. All rights reserved.
-
-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.

package/node_modules/core-util-is/README.md

@@ -1,3 +0,0 @@
-# core-util-is
-
-The `util.is*` functions introduced in Node v0.12.