browsed 0.2.5 → 0.2.6

data/lib/browsed/proxies/proxy-chain-server/node_modules/ms/package.json

@@ -0,0 +1,69 @@
+{
+  "_from": "ms@2.0.0",
+  "_id": "ms@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
+  "_location": "/ms",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "ms@2.0.0",
+    "name": "ms",
+    "escapedName": "ms",
+    "rawSpec": "2.0.0",
+    "saveSpec": null,
+    "fetchSpec": "2.0.0"
+  },
+  "_requiredBy": [
+    "/debug"
+  ],
+  "_resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+  "_shasum": "5608aeadfc00be6c2901df5f9861788de0d597c8",
+  "_spec": "ms@2.0.0",
+  "_where": "/Users/sebastianjohnsson/Programming/Javascript/proxy-chain-server/node_modules/debug",
+  "bugs": {
+    "url": "https://github.com/zeit/ms/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Tiny milisecond conversion utility",
+  "devDependencies": {
+    "eslint": "3.19.0",
+    "expect.js": "0.3.1",
+    "husky": "0.13.3",
+    "lint-staged": "3.4.1",
+    "mocha": "3.4.1"
+  },
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "env": {
+      "node": true,
+      "es6": true
+    }
+  },
+  "files": [
+    "index.js"
+  ],
+  "homepage": "https://github.com/zeit/ms#readme",
+  "license": "MIT",
+  "lint-staged": {
+    "*.js": [
+      "npm run lint",
+      "prettier --single-quote --write",
+      "git add"
+    ]
+  },
+  "main": "./index",
+  "name": "ms",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zeit/ms.git"
+  },
+  "scripts": {
+    "lint": "eslint lib/* bin/*",
+    "precommit": "lint-staged",
+    "test": "mocha tests.js"
+  },
+  "version": "2.0.0"
+}

data/lib/browsed/proxies/proxy-chain-server/node_modules/ms/readme.md

@@ -0,0 +1,51 @@
+# ms
+
+[![Build Status](https://travis-ci.org/zeit/ms.svg?branch=master)](https://travis-ci.org/zeit/ms)
+[![Slack Channel](http://zeit-slackin.now.sh/badge.svg)](https://zeit.chat/)
+
+Use this package to easily convert various time formats to milliseconds.
+
+## Examples
+
+```js
+ms('2 days')  // 172800000
+ms('1d')      // 86400000
+ms('10h')     // 36000000
+ms('2.5 hrs') // 9000000
+ms('2h')      // 7200000
+ms('1m')      // 60000
+ms('5s')      // 5000
+ms('1y')      // 31557600000
+ms('100')     // 100
+```
+
+### Convert from milliseconds
+
+```js
+ms(60000)             // "1m"
+ms(2 * 60000)         // "2m"
+ms(ms('10 hours'))    // "10h"
+```
+
+### Time format written-out
+
+```js
+ms(60000, { long: true })             // "1 minute"
+ms(2 * 60000, { long: true })         // "2 minutes"
+ms(ms('10 hours'), { long: true })    // "10 hours"
+```
+
+## Features
+
+- Works both in [node](https://nodejs.org) and in the browser.
+- If a number is supplied to `ms`, a string with a unit is returned.
+- If a string that contains the number is supplied, it returns it as a number (e.g.: it returns `100` for `'100'`).
+- If you pass a string with a number and a valid unit, the number of equivalent ms is returned.
+
+## Caught a bug?
+
+1. [Fork](https://help.github.com/articles/fork-a-repo/) this repository to your own GitHub account and then [clone](https://help.github.com/articles/cloning-a-repository/) it to your local device
+2. Link the package to the global module directory: `npm link`
+3. Within the module you want to test your local development instance of ms, just link it to the dependencies: `npm link ms`. Instead of the default one from npm, node will now use your clone of ms!
+
+As always, you can run the tests using: `npm test`

data/lib/browsed/proxies/proxy-chain-server/node_modules/portastic/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2015, Alan Hoffmeister <alanhoffmeister@gmail.com>
+
+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.

data/lib/browsed/proxies/proxy-chain-server/node_modules/portastic/README.md

@@ -0,0 +1,148 @@
+# portastic
+[![Coverage Status](https://coveralls.io/repos/alanhoff/node-portastic/badge.svg?branch=master)][0]
+[![Travis](https://travis-ci.org/alanhoff/node-portastic.svg)][1]
+[![Dependencies](https://david-dm.org/alanhoff/node-portastic.svg)][2]
+
+Pure javascript swiss knife for port management. Find open ports, monitor ports
+and other port relates things.
+
+### API
+
+* `portastic.test(port, [interface , [callback]])`
+
+Test if a port is open. If a callback
+is provided it will be called with an `error` parameter and a second parameter
+with a `boolean` that tells if the port is open or not. If a callback is not
+provided the return value will be a promise that will be fullfied with the
+result.
+
+```javascript
+var portastic = require('portastic');
+
+portastic.test(8080)
+  .then(function(isOpen){
+    console.log('Port 8080 is %s', isOpen ? 'open' : 'closed');
+  });
+```
+
+* `portastic.find(options, [interface, [callback]])`
+
+Retrieve a list of open ports between `min` and `max`, if a callback is not
+provided this method will resolve a promise with the results. Options can be:
+
+  * `min` The minimum port number to start with
+  * `max` The maximum port number to scan
+  * `retrieve` How many ports to collect
+
+```javascript
+var portastic = require('portastic');
+
+portastic.find({
+    min: 8000,
+    max: 8080
+  })
+  .then(function(ports){
+    console.log('Ports available between 8000 and 8080 are: %s',
+      ports.join(', '));
+  });
+```
+
+* `portastic.filter(ports..., [interface, [callback]])`
+
+Test a list of ports and return the open ones. If a callback is not provided
+this method will resolve a promise with the results
+
+```javascript
+var portastic = require('portastic');
+
+portastic.filter([8080, 8081, 8082])
+  .then(function(ports){
+    console.log('The available ports are: %s', ports.join(', '));
+  });
+```
+
+* `portastic.Monitor(ports...)`
+
+Monitor is an `EventEmitter` that emits `open` when a monitored port is
+available and `close` when the port has closed.
+
+```javascript
+var portastic = require('portastic');
+var monitor = new portastic.Monitor([8080, 8081, 8082]);
+
+monitor.on('open', function(port){
+  console.log('Port %s is open', port);
+});
+
+monitor.on('close', function(port){
+  console.log('Port %s is closed', port);
+});
+
+setTimeout(function(){
+  monitor.stop(); // Stops the monitoring after 5 seconds
+}, 5000);
+```
+
+### Command line
+
+It's also possible to use `portastic` as a command line utility, you just need
+to install it globally with `npm install -g portastic`. Here is the help command
+output.
+
+```
+
+Usage: portastic [options] [command]
+
+
+Commands:
+
+  test|t <port>                 Test if a port is closed or open
+  find|f [options] <min> <max>  Find ports that are available to use
+  filter|i <ports...>           Find ports that are open whithin a list of ports
+  monitor|m <ports...>          Monitor a list of ports and logs to the terminal when port state had changed
+
+Options:
+
+  -h, --help     output usage information
+  -V, --version  output the version number
+
+```
+
+### Testing
+
+```bash
+git clone git@github.com:alanhoff/node-portastic.git
+cd node-portastic
+npm install && npm test
+```
+
+### Debugging
+
+To see debug messages you must set your enviroment variable `DEBUG` to `*` or
+`portastic:*`, example:
+
+```bash
+DEBUG=portastic:\* npm test
+```
+
+### License (ISC)
+
+```
+Copyright (c) 2015, Alan Hoffmeister <alanhoffmeister@gmail.com>
+
+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.
+```
+
+[0]: https://coveralls.io/github/alanhoff/node-portastic
+[1]: https://travis-ci.org/alanhoff/node-portastic
+[2]: https://david-dm.org/alanhoff/node-portastic

data/lib/browsed/proxies/proxy-chain-server/node_modules/portastic/bin/portastic

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+var portastic = require('../');
+var commander = require('commander');
+var package = require('../package.json');
+commander.version(package.version);
+
+// Test if a port is closed
+commander
+  .command('test <port>')
+  .alias('t')
+  .description('Test if a port is closed or open')
+  .action(function(port) {
+    portastic.test(port)
+      .then(function(result) {
+        console.log('Port %s is %s', port, result ? 'open' : 'closed');
+      });
+  });
+
+// Find available ports
+commander
+  .command('find <min> <max>')
+  .alias('f')
+  .description('Find ports that are available to use')
+  .option('-r, --retrieve', 'How many ports to retrieve')
+  .action(function(min, max, options) {
+    portastic.find({
+      min: min,
+      max: max,
+      retrieve: options.retrieve
+    })
+      .then(function(ports) {
+        console.log('Ports available to use: %s', ports.join(', '));
+      });
+  });
+
+// Filter a list of ports
+commander
+  .command('filter <ports...>')
+  .alias('i')
+  .description('Find ports that are open whithin a list of ports')
+  .action(function(ports) {
+    portastic.filter(ports)
+      .then(function() {
+        console.log('Ports available to use: %s', ports.join(', '));
+      });
+  });
+
+// Monitor ports
+commander
+  .command('monitor <ports...>')
+  .alias('m')
+  .description('Monitor a list of ports and logs to the terminal when port state had changed')
+  .action(function(ports) {
+    var monitor = new portastic.Monitor(ports);
+    monitor.on('open', function(port) {
+      console.log('Port %s is open', port);
+    });
+
+    monitor.on('close', function(port) {
+      console.log('Port %s is closed', port);
+    });
+  });
+
+commander.parse(process.argv);

data/lib/browsed/proxies/proxy-chain-server/node_modules/portastic/history.md

@@ -0,0 +1,7 @@
+### `v1.0.1`
+
+* Fixed callback issues
+
+### `v1.0.0`
+
+* Full code refactoring, tests and integrations

data/lib/browsed/proxies/proxy-chain-server/node_modules/portastic/index.js

@@ -0,0 +1,4 @@
+var portastic = require('./lib/portastic');
+portastic.Monitor = require('./lib/monitor');
+
+module.exports = portastic;

data/lib/browsed/proxies/proxy-chain-server/node_modules/portastic/lib/monitor.js

@@ -0,0 +1,59 @@
+var portastic = require('./portastic');
+var events = require('events');
+var util = require('util');
+
+var Monitor = function(ports, options) {
+  this._ports = ports;
+  this._options = options || {};
+  this._watchers = [];
+
+  if (this._options.autostart === false)
+    return;
+
+  this.start();
+};
+util.inherits(Monitor, events.EventEmitter);
+
+Monitor.prototype.start = function() {
+  if (this._watchers.length)
+    return this.emit('error', new Error('Monitor already started'));
+
+  var that = this;
+  this._ports.forEach(function(port) {
+    that._watchers.push(that._watcher(port));
+  });
+};
+
+Monitor.prototype.stop = function() {
+  this._watchers.forEach(function(watcher) {
+    clearInterval(watcher.intervar);
+  });
+
+  this._watchers = [];
+};
+
+Monitor.prototype._watcher = function(port) {
+  var that = this;
+  var setup = {
+    state: null,
+    interval: setInterval(function() {
+      portastic.test(port)
+        .then(function(open) {
+          if (setup.state === open)
+            return;
+
+          that.emit(open ? 'open' : 'close', port);
+          setup.state = open;
+        })
+        .catch(function(err) {
+          process.nextTick(function() {
+            that.emit('error', err);
+          });
+        });
+    }, that._options.interval || 100)
+  };
+
+  return setup;
+};
+
+module.exports = Monitor;

data/lib/browsed/proxies/proxy-chain-server/node_modules/portastic/lib/portastic.js

@@ -0,0 +1,167 @@
+var bluebird = require('bluebird');
+var net = require('net');
+var debug = require('debug');
+
+module.exports = {
+
+  // Returns a promise that will be resolved with an array of open ports
+  test: bluebird.method(function(port, iface, callback) {
+    var that = this;
+    var log = debug('portastic:test');
+    var def = bluebird.defer();
+
+    // Callback handling
+    def.promise
+      .then(function(ports) {
+        if (!that._callback(callback, [ports]))
+          return ports;
+      })
+      .catch(function(err) {
+        if (!that._callback(callback, [err]))
+          throw err;
+      });
+
+    if (typeof iface !== 'string' && !callback) {
+      callback = iface;
+      iface = null;
+    }
+
+    var server = net.createServer();
+
+    server.on('error', function(err) {
+      if (err.code === 'EADDRINUSE') {
+        log('Port %s was in use', port);
+        return def.resolve(false);
+      }
+
+      def.reject(err);
+    });
+
+    server.on('close', function() {
+      log('TCP server on port %s closed', port);
+      def.resolve(true);
+    });
+
+    log('Trying to test port %s', port);
+    server.listen(port, iface, function(err) {
+      if (err && err.code === 'EADDRINUSE') {
+        log('Port %s was in use', port);
+        return def.resolve(false);
+      }
+
+      if (err)
+        return def.reject(err);
+
+      server.close(function(err) {
+        if (err)
+          return def.reject(err);
+
+        log('Port %s was free', port);
+      });
+    });
+
+    return def.promise;
+  }),
+
+  // Filter ports that are in use
+  filter: bluebird.method(function(ports, iface, callback) {
+    var that = this;
+    var log = debug('portastic:filter');
+    var def = bluebird.defer();
+
+    // Callback handling
+    def.promise
+      .then(function(ports) {
+        if (!that._callback(callback, [ports]))
+          return ports;
+      })
+      .catch(function(err) {
+        if (!that._callback(callback, [err]))
+          throw err;
+      });
+
+    if (typeof iface !== 'string' && !callback) {
+      callback = iface;
+      iface = null;
+    }
+
+    bluebird.all(ports)
+      .filter(function(port) {
+        log('Filtering port %s', port);
+        return that.test(port, iface);
+      })
+      .then(function(free) {
+        def.resolve(free);
+      })
+      .catch(function(err) {
+        def.reject(err);
+      });
+
+    return def.promise;
+  }),
+
+  // Find open ports in a range
+  find: bluebird.method(function(options, iface, callback) {
+    var log = debug('portastic:find');
+    var that = this;
+    var ports = [];
+    var result = [];
+
+    if (typeof iface !== 'string' && !callback) {
+      callback = iface;
+      iface = null;
+    }
+
+    for (var i = options.min; i <= options.max; i++)
+      ports.push(i);
+
+    log('Trying to find open ports between range %s and %s', options.min,
+      options.max);
+
+    var promise = bluebird.resolve(ports)
+      .each(function(port) {
+        return that.test(port, iface)
+          .then(function(open) {
+            if (options.retrieve && result.length >= options.retrieve) {
+              log('Result reached the maximum of %s ports, returning...',
+                options.retrieve);
+              return promise.cancel();
+            }
+
+            if (open) {
+              log('Port %s was open, adding it to the result list', port);
+              log('Pushing port %s to the result list', port);
+              return result.push(port);
+            } else
+              log('Port %s was not open', port);
+          });
+      })
+      .cancellable()
+      .catch(bluebird.CancellationError, function() {
+        return;
+      })
+      .then(function() {
+        if (!that._callback(callback, [ports]))
+          return result;
+      })
+      .catch(function(err) {
+        if (!that._callback(callback, [err]))
+          throw err;
+      });
+
+    return promise;
+  }),
+
+  // Handles callbacks
+  _callback: function(cb, args) {
+    if (cb) {
+      // This will bypass promises errors catching
+      process.nextTick(function() {
+        cb.apply(cb, args);
+      });
+    }
+
+    return !!cb;
+  }
+
+};