the-rbx-binary 1.4.2

package/utils/node_modules/delayed-stream/Readme.md

@@ -0,0 +1,141 @@
+# delayed-stream
+
+Buffers events from a stream until you are ready to handle them.
+
+## Installation
+
+``` bash
+npm install delayed-stream
+```
+
+## Usage
+
+The following example shows how to write a http echo server that delays its
+response by 1000 ms.
+
+``` javascript
+var DelayedStream = require('delayed-stream');
+var http = require('http');
+
+http.createServer(function(req, res) {
+  var delayed = DelayedStream.create(req);
+
+  setTimeout(function() {
+    res.writeHead(200);
+    delayed.pipe(res);
+  }, 1000);
+});
+```
+
+If you are not using `Stream#pipe`, you can also manually release the buffered
+events by calling `delayedStream.resume()`:
+
+``` javascript
+var delayed = DelayedStream.create(req);
+
+setTimeout(function() {
+  // Emit all buffered events and resume underlaying source
+  delayed.resume();
+}, 1000);
+```
+
+## Implementation
+
+In order to use this meta stream properly, here are a few things you should
+know about the implementation.
+
+### Event Buffering / Proxying
+
+All events of the `source` stream are hijacked by overwriting the `source.emit`
+method. Until node implements a catch-all event listener, this is the only way.
+
+However, delayed-stream still continues to emit all events it captures on the
+`source`, regardless of whether you have released the delayed stream yet or
+not.
+
+Upon creation, delayed-stream captures all `source` events and stores them in
+an internal event buffer. Once `delayedStream.release()` is called, all
+buffered events are emitted on the `delayedStream`, and the event buffer is
+cleared. After that, delayed-stream merely acts as a proxy for the underlaying
+source.
+
+### Error handling
+
+Error events on `source` are buffered / proxied just like any other events.
+However, `delayedStream.create` attaches a no-op `'error'` listener to the
+`source`. This way you only have to handle errors on the `delayedStream`
+object, rather than in two places.
+
+### Buffer limits
+
+delayed-stream provides a `maxDataSize` property that can be used to limit
+the amount of data being buffered. In order to protect you from bad `source`
+streams that don't react to `source.pause()`, this feature is enabled by
+default.
+
+## API
+
+### DelayedStream.create(source, [options])
+
+Returns a new `delayedStream`. Available options are:
+
+* `pauseStream`
+* `maxDataSize`
+
+The description for those properties can be found below.
+
+### delayedStream.source
+
+The `source` stream managed by this object. This is useful if you are
+passing your `delayedStream` around, and you still want to access properties
+on the `source` object.
+
+### delayedStream.pauseStream = true
+
+Whether to pause the underlaying `source` when calling
+`DelayedStream.create()`. Modifying this property afterwards has no effect.
+
+### delayedStream.maxDataSize = 1024 * 1024
+
+The amount of data to buffer before emitting an `error`.
+
+If the underlaying source is emitting `Buffer` objects, the `maxDataSize`
+refers to bytes.
+
+If the underlaying source is emitting JavaScript strings, the size refers to
+characters.
+
+If you know what you are doing, you can set this property to `Infinity` to
+disable this feature. You can also modify this property during runtime.
+
+### delayedStream.dataSize = 0
+
+The amount of data buffered so far.
+
+### delayedStream.readable
+
+An ECMA5 getter that returns the value of `source.readable`.
+
+### delayedStream.resume()
+
+If the `delayedStream` has not been released so far, `delayedStream.release()`
+is called.
+
+In either case, `source.resume()` is called.
+
+### delayedStream.pause()
+
+Calls `source.pause()`.
+
+### delayedStream.pipe(dest)
+
+Calls `delayedStream.resume()` and then proxies the arguments to `source.pipe`.
+
+### delayedStream.release()
+
+Emits and clears all events that have been buffered up so far. This does not
+resume the underlaying source, use `delayedStream.resume()` instead.
+
+## License
+
+delayed-stream is licensed under the MIT license.

package/utils/node_modules/delayed-stream/lib/delayed_stream.js

@@ -0,0 +1,107 @@
+var Stream = require('stream').Stream;
+var util = require('util');
+
+module.exports = DelayedStream;
+function DelayedStream() {
+  this.source = null;
+  this.dataSize = 0;
+  this.maxDataSize = 1024 * 1024;
+  this.pauseStream = true;
+
+  this._maxDataSizeExceeded = false;
+  this._released = false;
+  this._bufferedEvents = [];
+}
+util.inherits(DelayedStream, Stream);
+
+DelayedStream.create = function(source, options) {
+  var delayedStream = new this();
+
+  options = options || {};
+  for (var option in options) {
+    delayedStream[option] = options[option];
+  }
+
+  delayedStream.source = source;
+
+  var realEmit = source.emit;
+  source.emit = function() {
+    delayedStream._handleEmit(arguments);
+    return realEmit.apply(source, arguments);
+  };
+
+  source.on('error', function() {});
+  if (delayedStream.pauseStream) {
+    source.pause();
+  }
+
+  return delayedStream;
+};
+
+Object.defineProperty(DelayedStream.prototype, 'readable', {
+  configurable: true,
+  enumerable: true,
+  get: function() {
+    return this.source.readable;
+  }
+});
+
+DelayedStream.prototype.setEncoding = function() {
+  return this.source.setEncoding.apply(this.source, arguments);
+};
+
+DelayedStream.prototype.resume = function() {
+  if (!this._released) {
+    this.release();
+  }
+
+  this.source.resume();
+};
+
+DelayedStream.prototype.pause = function() {
+  this.source.pause();
+};
+
+DelayedStream.prototype.release = function() {
+  this._released = true;
+
+  this._bufferedEvents.forEach(function(args) {
+    this.emit.apply(this, args);
+  }.bind(this));
+  this._bufferedEvents = [];
+};
+
+DelayedStream.prototype.pipe = function() {
+  var r = Stream.prototype.pipe.apply(this, arguments);
+  this.resume();
+  return r;
+};
+
+DelayedStream.prototype._handleEmit = function(args) {
+  if (this._released) {
+    this.emit.apply(this, args);
+    return;
+  }
+
+  if (args[0] === 'data') {
+    this.dataSize += args[1].length;
+    this._checkIfMaxDataSizeExceeded();
+  }
+
+  this._bufferedEvents.push(args);
+};
+
+DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
+  if (this._maxDataSizeExceeded) {
+    return;
+  }
+
+  if (this.dataSize <= this.maxDataSize) {
+    return;
+  }
+
+  this._maxDataSizeExceeded = true;
+  var message =
+    'DelayedStream#maxDataSize of ' + this.maxDataSize + ' bytes exceeded.'
+  this.emit('error', new Error(message));
+};

package/utils/node_modules/delayed-stream/package.json

@@ -0,0 +1,27 @@
+{
+  "author": "Felix Geisendörfer <felix@debuggable.com> (http://debuggable.com/)",
+  "contributors": [
+    "Mike Atkins <apeherder@gmail.com>"
+  ],
+  "name": "delayed-stream",
+  "description": "Buffers events from a stream until you are ready to handle them.",
+  "license": "MIT",
+  "version": "1.0.0",
+  "homepage": "https://github.com/felixge/node-delayed-stream",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/felixge/node-delayed-stream.git"
+  },
+  "main": "./lib/delayed_stream",
+  "engines": {
+    "node": ">=0.4.0"
+  },
+  "scripts": {
+    "test": "make test"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "fake": "0.2.0",
+    "far": "0.0.1"
+  }
+}

package/utils/node_modules/diskinfo/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Shaun Hevey
+
+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/utils/node_modules/diskinfo/README.md

@@ -0,0 +1,24 @@
+diskinfo
+========
+
+nodejs module to get disk information, will call system command to get drive info. 
+Parse result and load info in array.  
+
+usage
+=====
+
+    var d = require('diskinfo');
+
+    d.getDrives(function(err, aDrives) {
+  
+          for (var i = 0; i < aDrives.length; i++) {
+                console.log('Drive ' + aDrives[i].filesystem);
+                console.log('blocks ' + aDrives[i].blocks);
+                console.log('used ' + aDrives[i].used);
+                console.log('available ' + aDrives[i].available);
+                console.log('capacity ' + aDrives[i].capacity);
+                console.log('mounted ' + aDrives[i].mounted);
+                console.log('-----------------------------------------');
+          }
+  
+    });

package/utils/node_modules/diskinfo/lib/diskinfo.js

@@ -0,0 +1,142 @@
+/**
+*	diskinfo
+*
+*	Returns disk information array for linux and windows
+*	Tested on centos and windows vista
+*	
+*	@author	Benoit Gauthier <bgauthier075@gmail.com>
+*/
+
+var exec = require('child_process').exec;
+var os = require('os');
+var aDrives = [];
+
+/**
+*	Returns an array of drives or calls callback 
+*
+*	@param 	callback	A callback function that will receive 
+*						the array of drives, set null if no callback 
+*/
+exports.getDrives = function(callback) {
+	
+	switch (os.platform().toLowerCase()) {
+        case 'win32':
+		
+			// Windows 32
+			// Tested on Vista 			
+			
+			// Run command to get list of drives
+			var oProcess = exec(
+				'wmic logicaldisk get Caption,FreeSpace,Size,VolumeSerialNumber,Description  /format:list',
+				function (err, stdout, stderr) {
+					if (err) return callback(err, null);
+					
+					var aLines = stdout.split('\r\r\n');
+					var bNew = false;
+					var sCaption = '', sDescription = '', sFreeSpace = '', sSize = '', sVolume = '';
+					// For each line get information
+					// Format is Key=Value
+					for(var i = 0; i < aLines.length; i++) {						
+						if (aLines[i] != '') {
+							var aTokens = aLines[i].split('=');
+							switch  (aTokens[0]) {
+								case 'Caption':											
+									sCaption = aTokens[1];
+									bNew = true;
+									break;
+								case 'Description':									
+									sDescription = aTokens[1];									
+									break;
+								case 'FreeSpace':
+									sFreeSpace = aTokens[1];
+									break;
+								case 'Size':
+									sSize = aTokens[1];
+									break;
+								case 'VolumeSerialNumber':
+									sVolume = aTokens[1];
+									break;
+							}
+						
+						} else {
+							// Empty line 
+							// If we get an empty line and bNew is true then we have retrieved
+							// all information for one drive, add to array and reset variables
+							if (bNew) {								
+								sSize = parseFloat(sSize);
+								if (isNaN(sSize)) {
+									sSize = 0;
+								}
+								sFreeSpace = parseFloat(sFreeSpace);
+								if (isNaN(sFreeSpace)) {
+									sFreeSpace = 0;
+								}
+								
+								var sUsed = (sSize - sFreeSpace);
+								var sPercent = '0%';
+								if (sSize != '' && parseFloat(sSize) > 0) {
+									sPercent = Math.round((parseFloat(sUsed) / parseFloat(sSize)) * 100) + '%';
+								}
+								aDrives[aDrives.length] = {
+														filesystem:	sDescription,
+														blocks:		sSize,
+														used:		sUsed,
+														available:	sFreeSpace,
+														capacity:	sPercent,
+														mounted:	sCaption
+													  };
+								bNew = false;
+								sCaption = ''; sDescription = ''; sFreeSpace = ''; sSize = ''; sVolume = '';
+							}
+						
+						}
+					}
+					// Check if we have callback 
+					if (callback != null) {
+						callback(null, aDrives);
+					} 
+					return aDrives;
+				}
+			);			
+			
+			break;
+			
+        case 'linux':
+			// Linux 
+			// Tested on CentOS
+        default:
+		
+			// Run command to get list of drives 
+			var oProcess = exec(
+				'df -P | awk \'NR > 1\'',
+				function (err, stdout, stderr) {
+					if (err) return callback(err, null);
+					var aLines = stdout.split('\n');
+					// For each line get drive info and add to array
+					for(var i = 0; i < aLines.length; i++) {					
+						var sLine = aLines[i];
+						if (sLine != '') {
+							sLine = sLine.replace(/ +(?= )/g,'');
+							var aTokens = sLine.split(' ');
+							aDrives[aDrives.length] = {
+														filesystem:	aTokens[0],
+														blocks:		aTokens[1],
+														used:		aTokens[2],
+														available:	aTokens[3],
+														capacity:	aTokens[4],
+														mounted:	aTokens[5]
+													  };
+							
+						}
+					}
+					// Check if we have a callback
+					if (callback != null) {
+						callback(null, aDrives);
+					} 
+					return aDrives;
+				}
+			);				
+		
+    }
+
+}

package/utils/node_modules/diskinfo/package.json

@@ -0,0 +1,32 @@
+{
+  "author": "Benoit Gauthier",
+  "name": "diskinfo",
+  "description": "Nodejs module to get drive information, tested on linux centos and windows vista",
+  "version": "0.0.3",
+  "license": "MIT",
+  "main": "./lib/diskinfo.js",
+  "scripts": {   
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BenoitGauthier/diskinfo.git"
+  },
+  "keywords": [
+	"diskinfo",
+    "disk",
+    "disks",
+    "free space",
+    "volumes",
+    "harddisk",
+	"hard drive"
+  ],
+  "main": "./lib/diskinfo",
+  "dependencies": {    
+  },
+  "os": [
+    "linux",
+    "win32"
+  ],
+  "devDependencies": {    
+  }
+}

package/utils/node_modules/diskinfo/test/test.js

@@ -0,0 +1,15 @@
+var d = require('diskinfo');
+
+d.getDrives(function(err, aDrives) {
+
+        for (var i = 0; i < aDrives.length; i++) {
+                console.log('Drive ' + aDrives[i].filesystem);
+                console.log('blocks ' + aDrives[i].blocks);
+                console.log('used ' + aDrives[i].used);
+                console.log('available ' + aDrives[i].available);
+                console.log('capacity ' + aDrives[i].capacity);
+                console.log('mounted ' + aDrives[i].mounted);
+        console.log('-----------------------------------------');
+        }
+
+});

package/utils/node_modules/follow-redirects/LICENSE

@@ -0,0 +1,18 @@
+Copyright 2014–present Olivier Lalonde <olalonde@gmail.com>, James Talmage <james@talmage.io>, Ruben Verborgh
+
+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/utils/node_modules/follow-redirects/README.md

@@ -0,0 +1,155 @@
+## Follow Redirects
+
+Drop-in replacement for Node's `http` and `https` modules that automatically follows redirects.
+
+[![npm version](https://img.shields.io/npm/v/follow-redirects.svg)](https://www.npmjs.com/package/follow-redirects)
+[![Build Status](https://github.com/follow-redirects/follow-redirects/workflows/CI/badge.svg)](https://github.com/follow-redirects/follow-redirects/actions)
+[![Coverage Status](https://coveralls.io/repos/follow-redirects/follow-redirects/badge.svg?branch=master)](https://coveralls.io/r/follow-redirects/follow-redirects?branch=master)
+[![npm downloads](https://img.shields.io/npm/dm/follow-redirects.svg)](https://www.npmjs.com/package/follow-redirects)
+[![Sponsor on GitHub](https://img.shields.io/static/v1?label=Sponsor&message=%F0%9F%92%96&logo=GitHub)](https://github.com/sponsors/RubenVerborgh)
+
+`follow-redirects` provides [request](https://nodejs.org/api/http.html#http_http_request_options_callback) and [get](https://nodejs.org/api/http.html#http_http_get_options_callback)
+ methods that behave identically to those found on the native [http](https://nodejs.org/api/http.html#http_http_request_options_callback) and [https](https://nodejs.org/api/https.html#https_https_request_options_callback)
+ modules, with the exception that they will seamlessly follow redirects.
+
+```javascript
+const { http, https } = require('follow-redirects');
+
+http.get('http://bit.ly/900913', response => {
+  response.on('data', chunk => {
+    console.log(chunk);
+  });
+}).on('error', err => {
+  console.error(err);
+});
+```
+
+You can inspect the final redirected URL through the `responseUrl` property on the `response`.
+If no redirection happened, `responseUrl` is the original request URL.
+
+```javascript
+const request = https.request({
+  host: 'bitly.com',
+  path: '/UHfDGO',
+}, response => {
+  console.log(response.responseUrl);
+  // 'http://duckduckgo.com/robots.txt'
+});
+request.end();
+```
+
+## Options
+### Global options
+Global options are set directly on the `follow-redirects` module:
+
+```javascript
+const followRedirects = require('follow-redirects');
+followRedirects.maxRedirects = 10;
+followRedirects.maxBodyLength = 20 * 1024 * 1024; // 20 MB
+```
+
+The following global options are supported:
+
+- `maxRedirects` (default: `21`) – sets the maximum number of allowed redirects; if exceeded, an error will be emitted.
+
+- `maxBodyLength` (default: 10MB) – sets the maximum size of the request body; if exceeded, an error will be emitted.
+
+### Per-request options
+Per-request options are set by passing an `options` object:
+
+```javascript
+const url = require('url');
+const { http, https } = require('follow-redirects');
+
+const options = url.parse('http://bit.ly/900913');
+options.maxRedirects = 10;
+options.beforeRedirect = (options, response, request) => {
+  // Use this to adjust the request options upon redirecting,
+  // to inspect the latest response headers,
+  // or to cancel the request by throwing an error
+
+  // response.headers = the redirect response headers
+  // response.statusCode = the redirect response code (eg. 301, 307, etc.)
+
+  // request.url = the requested URL that resulted in a redirect
+  // request.headers = the headers in the request that resulted in a redirect
+  // request.method = the method of the request that resulted in a redirect
+  if (options.hostname === "example.com") {
+    options.auth = "user:password";
+  }
+};
+http.request(options);
+```
+
+In addition to the [standard HTTP](https://nodejs.org/api/http.html#http_http_request_options_callback) and [HTTPS options](https://nodejs.org/api/https.html#https_https_request_options_callback),
+the following per-request options are supported:
+- `followRedirects` (default: `true`) – whether redirects should be followed.
+
+- `maxRedirects` (default: `21`) – sets the maximum number of allowed redirects; if exceeded, an error will be emitted.
+
+- `maxBodyLength` (default: 10MB) – sets the maximum size of the request body; if exceeded, an error will be emitted.
+
+- `beforeRedirect` (default: `undefined`) – optionally change the request `options` on redirects, or abort the request by throwing an error.
+
+- `agents` (default: `undefined`) – sets the `agent` option per protocol, since HTTP and HTTPS use different agents. Example value: `{ http: new http.Agent(), https: new https.Agent() }`
+
+- `trackRedirects` (default: `false`) – whether to store the redirected response details into the `redirects` array on the response object.
+
+
+### Advanced usage
+By default, `follow-redirects` will use the Node.js default implementations
+of [`http`](https://nodejs.org/api/http.html)
+and [`https`](https://nodejs.org/api/https.html).
+To enable features such as caching and/or intermediate request tracking,
+you might instead want to wrap `follow-redirects` around custom protocol implementations:
+
+```javascript
+const { http, https } = require('follow-redirects').wrap({
+  http: require('your-custom-http'),
+  https: require('your-custom-https'),
+});
+```
+
+Such custom protocols only need an implementation of the `request` method.
+
+## Browser Usage
+
+Due to the way the browser works,
+the `http` and `https` browser equivalents perform redirects by default.
+
+By requiring `follow-redirects` this way:
+```javascript
+const http = require('follow-redirects/http');
+const https = require('follow-redirects/https');
+```
+you can easily tell webpack and friends to replace
+`follow-redirect` by the built-in versions:
+
+```json
+{
+  "follow-redirects/http"  : "http",
+  "follow-redirects/https" : "https"
+}
+```
+
+## Contributing
+
+Pull Requests are always welcome. Please [file an issue](https://github.com/follow-redirects/follow-redirects/issues)
+ detailing your proposal before you invest your valuable time. Additional features and bug fixes should be accompanied
+ by tests. You can run the test suite locally with a simple `npm test` command.
+
+## Debug Logging
+
+`follow-redirects` uses the excellent [debug](https://www.npmjs.com/package/debug) for logging. To turn on logging
+ set the environment variable `DEBUG=follow-redirects` for debug output from just this module. When running the test
+ suite it is sometimes advantageous to set `DEBUG=*` to see output from the express server as well.
+
+## Authors
+
+- [Ruben Verborgh](https://ruben.verborgh.org/)
+- [Olivier Lalonde](mailto:olalonde@gmail.com)
+- [James Talmage](mailto:james@talmage.io)
+
+## License
+
+[MIT License](https://github.com/follow-redirects/follow-redirects/blob/master/LICENSE)

package/utils/node_modules/follow-redirects/debug.js

@@ -0,0 +1,15 @@
+var debug;
+
+module.exports = function () {
+  if (!debug) {
+    try {
+      /* eslint global-require: off */
+      debug = require("debug")("follow-redirects");
+    }
+    catch (error) { /* */ }
+    if (typeof debug !== "function") {
+      debug = function () { /* */ };
+    }
+  }
+  debug.apply(null, arguments);
+};