meteor-node-stubs 1.2.16 → 1.2.18

package/node_modules/stream-browserify/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "stream-browserify",
+  "version": "3.0.0",
+  "description": "the stream module from node core for browsers",
+  "main": "index.js",
+  "dependencies": {
+    "inherits": "~2.0.4",
+    "readable-stream": "^3.5.0"
+  },
+  "devDependencies": {
+    "airtap": "^1.0.2",
+    "safe-buffer": "^5.1.2",
+    "tape": "^4.13.0",
+    "through": "^2.3.8"
+  },
+  "scripts": {
+    "test": "node test",
+    "test:browsers": "airtap -- test/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/browserify/stream-browserify.git"
+  },
+  "homepage": "https://github.com/browserify/stream-browserify",
+  "keywords": [
+    "stream",
+    "browser",
+    "browserify"
+  ],
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "license": "MIT",
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/3.5",
+      "firefox/10",
+      "firefox/nightly",
+      "chrome/10",
+      "chrome/latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  }
+}

package/node_modules/stream-browserify/readme.markdown

@@ -0,0 +1,32 @@
+# stream-browserify
+
+the stream module from node core, for browsers!
+
+This module uses [`readable-stream`](https://github.com/nodejs/readable-stream), with additions for compatibility with npm packages that use old Node.js stream APIs.
+
+[![build status](https://secure.travis-ci.org/browserify/stream-browserify.svg?branch=master)](http://travis-ci.org/browserify/stream-browserify)
+
+## Install
+
+You usually do not have to install `stream-browserify` yourself! If your code runs in Node.js, `stream` is built in, or `readable-stream` can be used. If your code runs in the browser, bundlers like [browserify](https://github.com/browserify/browserify) also include the `stream-browserify` module.
+
+But if none of those apply, with [npm](https://npmjs.org) do:
+
+```bash
+npm install stream-browserify
+```
+
+## API
+
+Consult the node core
+[documentation on streams](http://nodejs.org/docs/latest/api/stream.html).
+
+## Browser Support
+
+Cross-browser testing generously provided by [Sauce Labs](https://saucelabs.com).
+
+[![Sauce Test Status](https://saucelabs.com/browser-matrix/stream-browserify.svg)](https://saucelabs.com/u/stream-browserify)
+
+## License
+
+[MIT](./LICENSE)

package/node_modules/stream-browserify/security.md

@@ -0,0 +1,10 @@
+# Security Policy
+
+## Supported Versions
+Only the latest major version is supported at any given time.
+
+## Reporting a Vulnerability
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.

package/node_modules/stream-browserify/test/buf.js

@@ -0,0 +1,33 @@
+var path = require('path');
+var test = require('tape');
+var Buffer = require('safe-buffer').Buffer;
+
+var Writable = require('..').Writable;
+var inherits = require('inherits');
+
+inherits(TestWritable, Writable);
+
+function TestWritable(opt) {
+    if (!(this instanceof TestWritable))
+        return new TestWritable(opt);
+    Writable.call(this, opt);
+    this._written = [];
+}
+
+TestWritable.prototype._write = function(chunk, encoding, cb) {
+    this._written.push(chunk);
+    cb();
+};
+
+var buf = Buffer.from([ 88 ]);
+
+test('.writable writing ArrayBuffer', function(t) {
+    var writable = new TestWritable();
+    
+    writable.write(buf);
+    writable.end();
+    
+    t.equal(writable._written.length, 1);
+    t.equal(writable._written[0].toString(), 'X')
+    t.end()
+});

package/node_modules/stream-browserify/test/index.js

@@ -0,0 +1,2 @@
+require('./buf');
+require('./pipeline');

package/node_modules/stream-browserify/test/pipeline.js

@@ -0,0 +1,38 @@
+var test = require('tape');
+var pipeline = require('..').pipeline;
+var stream = require('..');
+var Buffer = require('safe-buffer').Buffer;
+
+test('supports pipeline', function(t) {
+    t.plan(4);
+    var readable = new stream.Readable({
+        read: function () {
+            this.push(Buffer.from('chunk', 'ascii'));
+        }
+    });
+    var transform1 = new stream.Transform({
+        transform: function (chunk, enc, cb) {
+            cb(new Error('fail'));
+        }
+    });
+    var transform2 = new stream.PassThrough();
+    transform2.on('close', function () {
+        t.pass('transform2.close called');
+    });
+    var writable = new stream.Writable({
+        write: function (chunk, enc, cb) { cb(); }
+    });
+    writable.on('close', function () {
+        t.pass('writable.close called');
+    });
+
+    pipeline(
+        readable,
+        transform1,
+        transform2,
+        writable,
+        function(err) {
+            t.ok(err);
+            t.equal(err.message, 'fail');
+        });
+});

package/node_modules/stream-browserify/test/use-stream.js

@@ -0,0 +1,4 @@
+// browserify plugin to swap out the `stream` builtin node shim with the stream-browserify version in this repo.
+module.exports = function (b) {
+  b._mdeps.options.modules.stream = require.resolve('../index.js');
+};

package/node_modules/stream-http/LICENSE

@@ -0,0 +1,24 @@
+The MIT License
+
+Copyright (c) 2015 John Hiesey
+
+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/stream-http/README.md

@@ -0,0 +1,134 @@
+# stream-http [![Build Status](https://travis-ci.org/jhiesey/stream-http.svg?branch=master)](https://travis-ci.org/jhiesey/stream-http)
+
+[![Sauce Test Status](https://app.saucelabs.com/browser-matrix/stream-http.svg)](https://app.saucelabs.com/u/stream-http)
+
+This module is an implementation of Node's native `http` module for the browser.
+It tries to match Node's API and behavior as closely as possible, but some features
+aren't available, since browsers don't give nearly as much control over requests.
+
+This is heavily inspired by, and intended to replace, [http-browserify](https://github.com/substack/http-browserify).
+
+## What does it do?
+
+In accordance with its name, `stream-http` tries to provide data to its caller before
+the request has completed whenever possible.
+
+Backpressure, allowing the browser to only pull data from the server as fast as it is
+consumed, is supported in:
+* Chrome >= 58 (using `fetch` and `WritableStream`)
+
+The following browsers support true streaming, where only a small amount of the request
+has to be held in memory at once:
+* Chrome >= 43 (using the `fetch` API)
+* Firefox >= 9 (using `moz-chunked-arraybuffer` responseType with xhr)
+
+All other supported browsers support pseudo-streaming, where the data is available before
+the request finishes, but the entire response must be held in memory. This works for both
+text and binary data.
+
+### IE note:
+As of version 3.0.0, IE10 and below are no longer supported. IE11 support will remain for
+now.
+
+## How do you use it?
+
+The intent is to have the same API as the client part of the
+[Node HTTP module](https://nodejs.org/api/http.html). The interfaces are the same wherever
+practical, although limitations in browsers make an exact clone of the Node API impossible.
+
+This module implements `http.request`, `http.get`, and most of `http.ClientRequest`
+and `http.IncomingMessage` in addition to `http.METHODS` and `http.STATUS_CODES`. See the
+Node docs for how these work.
+
+### Extra features compared to Node
+
+* The `message.url` property provides access to the final URL after all redirects. This
+is useful since the browser follows all redirects silently, unlike Node. It is available
+in Chrome 37 and newer, Firefox 32 and newer, and Safari 9 and newer.
+
+* The `options.withCredentials` boolean flag, used to indicate if the browser should send
+cookies or authentication information with a CORS request. Default false.
+
+This module has to make some tradeoffs to support binary data and/or streaming. Generally,
+the module can make a fairly good decision about which underlying browser features to use,
+but sometimes it helps to get a little input from the developer.
+
+* The `options.mode` field passed into `http.request` or `http.get` can take on one of the
+following values:
+  * 'default' (or any falsy value, including `undefined`): Try to provide partial data before
+the request completes, but not at the cost of correctness for binary data or correctness of
+the 'content-type' response header. This mode will also avoid slower code paths whenever
+possible, which is particularly useful when making large requests in a browser like Safari
+that has a weaker JavaScript engine.
+  * 'allow-wrong-content-type': Provides partial data in more cases than 'default', but
+at the expense of causing the 'content-type' response header to be incorrectly reported
+(as 'text/plain; charset=x-user-defined') in some browsers, notably Safari and Chrome 42
+and older. Preserves binary data whenever possible. In some cases the implementation may
+also be a bit slow. This was the default in versions of this module before 1.5.
+  * 'prefer-streaming': Provide data before the request completes even if binary data (anything
+that isn't a single-byte ASCII or UTF8 character) will be corrupted. Of course, this option
+is only safe for text data. May also cause the 'content-type' response header to be
+incorrectly reported (as 'text/plain; charset=x-user-defined').
+  * 'disable-fetch': Force the use of plain XHR regardless of the browser declaring a fetch
+capability. Preserves the correctness of binary data and the 'content-type' response header.
+  * 'prefer-fast': Deprecated; now a synonym for 'default', which has the same performance
+characteristics as this mode did in versions before 1.5.
+
+* `options.requestTimeout` allows setting a timeout in millisecionds for XHR and fetch (if
+supported by the browser). This is a limit on how long the entire process takes from
+beginning to end. Note that this is not the same as the node `setTimeout` functions,
+which apply to pauses in data transfer over the underlying socket, or the node `timeout`
+option, which applies to opening the connection.
+
+### Features missing compared to Node
+
+* `http.Agent` is only a stub
+* The 'socket', 'connect', 'upgrade', and 'continue' events on `http.ClientRequest`.
+* Any operations, other than `request.setTimeout`, that operate directly on the underlying
+socket.
+* Any options that are disallowed for security reasons. This includes setting or getting
+certain headers.
+* `message.httpVersion`
+* `message.rawHeaders` is modified by the browser, and may not quite match what is sent by
+the server.
+* `message.trailers` and `message.rawTrailers` will remain empty.
+* Redirects are followed silently by the browser, so it isn't possible to access the 301/302
+redirect pages.
+
+## Example
+
+``` js
+http.get('/bundle.js', function (res) {
+	var div = document.getElementById('result');
+	div.innerHTML += 'GET /beep<br>';
+
+	res.on('data', function (buf) {
+		div.innerHTML += buf;
+	});
+
+	res.on('end', function () {
+		div.innerHTML += '<br>__END__';
+	});
+})
+```
+
+## Running tests
+
+There are two sets of tests: the tests that run in Node (found in `test/node`) and the tests
+that run in the browser (found in `test/browser`). Normally the browser tests run on
+[Sauce Labs](http://saucelabs.com/).
+
+Running `npm test` will run both sets of tests, but in order for the Sauce Labs tests to run
+you will need to sign up for an account (free for open source projects) and put the
+credentials in a [`.airtaprc` file](https://github.com/airtap/airtap/blob/master/doc/airtaprc.md).
+You will also need to run a [Sauce Connect Proxy](https://wiki.saucelabs.com/display/DOCS/Sauce+Connect+Proxy)
+with the same credentials.
+
+To run just the Node tests, run `npm run test-node`.
+
+To run the browser tests locally, run `npm run test-browser-local` and point your browser to
+the link shown in your terminal.
+
+## License
+
+MIT. Copyright (C) John Hiesey and other contributors.

package/node_modules/stream-http/index.js

@@ -0,0 +1,85 @@
+var ClientRequest = require('./lib/request')
+var response = require('./lib/response')
+var extend = require('xtend')
+var statusCodes = require('builtin-status-codes')
+var url = require('url')
+
+var http = exports
+
+http.request = function (opts, cb) {
+	if (typeof opts === 'string')
+		opts = url.parse(opts)
+	else
+		opts = extend(opts)
+
+	// Normally, the page is loaded from http or https, so not specifying a protocol
+	// will result in a (valid) protocol-relative url. However, this won't work if
+	// the protocol is something else, like 'file:'
+	var defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''
+
+	var protocol = opts.protocol || defaultProtocol
+	var host = opts.hostname || opts.host
+	var port = opts.port
+	var path = opts.path || '/'
+
+	// Necessary for IPv6 addresses
+	if (host && host.indexOf(':') !== -1)
+		host = '[' + host + ']'
+
+	// This may be a relative url. The browser should always be able to interpret it correctly.
+	opts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path
+	opts.method = (opts.method || 'GET').toUpperCase()
+	opts.headers = opts.headers || {}
+
+	// Also valid opts.auth, opts.mode
+
+	var req = new ClientRequest(opts)
+	if (cb)
+		req.on('response', cb)
+	return req
+}
+
+http.get = function get (opts, cb) {
+	var req = http.request(opts, cb)
+	req.end()
+	return req
+}
+
+http.ClientRequest = ClientRequest
+http.IncomingMessage = response.IncomingMessage
+
+http.Agent = function () {}
+http.Agent.defaultMaxSockets = 4
+
+http.globalAgent = new http.Agent()
+
+http.STATUS_CODES = statusCodes
+
+http.METHODS = [
+	'CHECKOUT',
+	'CONNECT',
+	'COPY',
+	'DELETE',
+	'GET',
+	'HEAD',
+	'LOCK',
+	'M-SEARCH',
+	'MERGE',
+	'MKACTIVITY',
+	'MKCOL',
+	'MOVE',
+	'NOTIFY',
+	'OPTIONS',
+	'PATCH',
+	'POST',
+	'PROPFIND',
+	'PROPPATCH',
+	'PURGE',
+	'PUT',
+	'REPORT',
+	'SEARCH',
+	'SUBSCRIBE',
+	'TRACE',
+	'UNLOCK',
+	'UNSUBSCRIBE'
+]

package/node_modules/stream-http/lib/capability.js

@@ -0,0 +1,59 @@
+exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)
+
+exports.writableStream = isFunction(global.WritableStream)
+
+exports.abortController = isFunction(global.AbortController)
+
+// The xhr request to example.com may violate some restrictive CSP configurations,
+// so if we're running in a browser that supports `fetch`, avoid calling getXHR()
+// and assume support for certain features below.
+var xhr
+function getXHR () {
+	// Cache the xhr value
+	if (xhr !== undefined) return xhr
+
+	if (global.XMLHttpRequest) {
+		xhr = new global.XMLHttpRequest()
+		// If XDomainRequest is available (ie only, where xhr might not work
+		// cross domain), use the page location. Otherwise use example.com
+		// Note: this doesn't actually make an http request.
+		try {
+			xhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')
+		} catch(e) {
+			xhr = null
+		}
+	} else {
+		// Service workers don't have XHR
+		xhr = null
+	}
+	return xhr
+}
+
+function checkTypeSupport (type) {
+	var xhr = getXHR()
+	if (!xhr) return false
+	try {
+		xhr.responseType = type
+		return xhr.responseType === type
+	} catch (e) {}
+	return false
+}
+
+// If fetch is supported, then arraybuffer will be supported too. Skip calling
+// checkTypeSupport(), since that calls getXHR().
+exports.arraybuffer = exports.fetch || checkTypeSupport('arraybuffer')
+
+// These next two tests unavoidably show warnings in Chrome. Since fetch will always
+// be used if it's available, just return false for these to avoid the warnings.
+exports.msstream = !exports.fetch && checkTypeSupport('ms-stream')
+exports.mozchunkedarraybuffer = !exports.fetch && checkTypeSupport('moz-chunked-arraybuffer')
+
+// If fetch is supported, then overrideMimeType will be supported too. Skip calling
+// getXHR().
+exports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)
+
+function isFunction (value) {
+	return typeof value === 'function'
+}
+
+xhr = null // Help gc