Commit project

node_modules/connect/LICENSE

@@ -0,0 +1,25 @@
+(The MIT License)
+
+Copyright (c) 2010 Sencha Inc.
+Copyright (c) 2011 LearnBoost
+Copyright (c) 2011-2014 TJ Holowaychuk
+Copyright (c) 2015 Douglas Christopher Wilson
+
+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.

node_modules/connect/README.md

@@ -0,0 +1,295 @@
+# Connect
+
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+[![Gratipay][gratipay-image]][gratipay-url]
+
+  Connect is an extensible HTTP server framework for [node](http://nodejs.org) using "plugins" known as _middleware_.
+
+```js
+var connect = require('connect');
+var http = require('http');
+
+var app = connect();
+
+// gzip/deflate outgoing responses
+var compression = require('compression');
+app.use(compression());
+
+// store session state in browser cookie
+var cookieSession = require('cookie-session');
+app.use(cookieSession({
+    keys: ['secret1', 'secret2']
+}));
+
+// parse urlencoded request bodies into req.body
+var bodyParser = require('body-parser');
+app.use(bodyParser.urlencoded({extended: false}));
+
+// respond to all requests
+app.use(function(req, res){
+  res.end('Hello from Connect!\n');
+});
+
+//create node.js http server and listen on port
+http.createServer(app).listen(3000);
+```
+
+## Getting Started
+
+Connect is a simple framework to glue together various "middleware" to handle requests.
+
+### Install Connect
+
+```sh
+$ npm install connect
+```
+
+### Create an app
+
+The main component is a Connect "app". This will store all the middleware
+added and is, itself, a function.
+
+```js
+var app = connect();
+```
+
+### Use middleware
+
+The core of Connect is "using" middleware. Middleware are added as a "stack"
+where incoming requests will execute each middleware one-by-one until a middleware
+does not call `next()` within it.
+
+```js
+app.use(function middleware1(req, res, next) {
+  // middleware 1
+  next();
+});
+app.use(function middleware2(req, res, next) {
+  // middleware 2
+  next();
+});
+```
+
+### Mount middleware
+
+The `.use()` method also takes an optional path string that is matched against
+the beginning of the incoming request URL. This allows for basic routing.
+
+```js
+app.use('/foo', function fooMiddleware(req, res, next) {
+  // req.url starts with "/foo"
+  next();
+});
+app.use('/bar', function barMiddleware(req, res, next) {
+  // req.url starts with "/bar"
+  next();
+});
+```
+
+### Error middleware
+
+There are special cases of "error-handling" middleware. There are middleware
+where the function takes exactly 4 arguments. When a middleware passes an error
+to `next`, the app will proceed to look for the error middleware that was declared
+after that middleware and invoke it, skipping any error middleware above that
+middleware and any non-error middleware below.
+
+```js
+// regular middleware
+app.use(function (req, res, next) {
+  // i had an error
+  next(new Error('boom!'));
+});
+
+// error middleware for errors that occurred in middleware
+// declared before this
+app.use(function onerror(err, req, res, next) {
+  // an error occurred!
+});
+```
+
+### Create a server from the app
+
+The last step is to actually use the Connect app in a server. The `.listen()` method
+is a convenience to start a HTTP server (and is identical to the `http.Server`'s `listen`
+method in the version of Node.js you are running).
+
+```js
+var server = app.listen(port);
+```
+
+The app itself is really just a function with three arguments, so it can also be handed
+to `.createServer()` in Node.js.
+
+```js
+var server = http.createServer(app);
+```
+
+## Middleware
+
+These middleware and libraries are officially supported by the Connect/Express team:
+
+  - [body-parser](https://www.npmjs.com/package/body-parser) - previous `bodyParser`, `json`, and `urlencoded`. You may also be interested in:
+    - [body](https://www.npmjs.com/package/body)
+    - [co-body](https://www.npmjs.com/package/co-body)
+    - [raw-body](https://www.npmjs.com/package/raw-body)
+  - [compression](https://www.npmjs.com/package/compression) - previously `compress`
+  - [connect-timeout](https://www.npmjs.com/package/connect-timeout) - previously `timeout`
+  - [cookie-parser](https://www.npmjs.com/package/cookie-parser) - previously `cookieParser`
+  - [cookie-session](https://www.npmjs.com/package/cookie-session) - previously `cookieSession`
+  - [csurf](https://www.npmjs.com/package/csurf) - previously `csrf`
+  - [errorhandler](https://www.npmjs.com/package/errorhandler) - previously `error-handler`
+  - [express-session](https://www.npmjs.com/package/express-session) - previously `session`
+  - [method-override](https://www.npmjs.com/package/method-override) - previously `method-override`
+  - [morgan](https://www.npmjs.com/package/morgan) - previously `logger`
+  - [response-time](https://www.npmjs.com/package/response-time) - previously `response-time`
+  - [serve-favicon](https://www.npmjs.com/package/serve-favicon) - previously `favicon`
+  - [serve-index](https://www.npmjs.com/package/serve-index) - previously `directory`
+  - [serve-static](https://www.npmjs.com/package/serve-static) - previously `static`
+  - [vhost](https://www.npmjs.com/package/vhost) - previously `vhost`
+
+Most of these are exact ports of their Connect 2.x equivalents. The primary exception is `cookie-session`.
+
+Some middleware previously included with Connect are no longer supported by the Connect/Express team, are replaced by an alternative module, or should be superseded by a better module. Use one of these alternatives instead:
+
+  - `cookieParser`
+    - [cookies](https://www.npmjs.com/package/cookies) and [keygrip](https://www.npmjs.com/package/keygrip)
+  - `limit`
+    - [raw-body](https://www.npmjs.com/package/raw-body)
+  - `multipart`
+    - [connect-multiparty](https://www.npmjs.com/package/connect-multiparty)
+    - [connect-busboy](https://www.npmjs.com/package/connect-busboy)
+  - `query`
+    - [qs](https://www.npmjs.com/package/qs)
+  - `staticCache`
+    - [st](https://www.npmjs.com/package/st)
+    - [connect-static](https://www.npmjs.com/package/connect-static)
+
+Checkout [http-framework](https://github.com/Raynos/http-framework/wiki/Modules) for many other compatible middleware!
+
+## API
+
+The Connect API is very minimalist, enough to create an app and add a chain
+of middleware.
+
+When the `connect` module is required, a function is returned that will construct
+a new app when called.
+
+```js
+// require module
+var connect = require('connect')
+
+// create app
+var app = connect()
+```
+
+### app(req, res[, next])
+
+The `app` itself is a function. This is just an alias to `app.handle`.
+
+### app.handle(req, res[, out])
+
+Calling the function will run the middleware stack against the given Node.js
+http request (`req`) and response (`res`) objects. An optional function `out`
+can be provided that will be called if the request (or error) was not handled
+by the middleware stack.
+
+### app.listen([...])
+
+Start the app listening for requests. This method will internally create a Node.js
+HTTP server and call `.listen()` on it.
+
+This is an alias to the `server.listen()` method in the version of Node.js running,
+so consult the Node.js documentation for all the different variations. The most
+common signature is [`app.listen(port)`](https://nodejs.org/dist/latest-v6.x/docs/api/http.html#http_server_listen_port_hostname_backlog_callback).
+
+### app.use(fn)
+
+Use a function on the app, where the function represents a middleware. The function
+will be invoked for every request in the order that `app.use` is called. The function
+is called with three arguments:
+
+```js
+app.use(function (req, res, next) {
+  // req is the Node.js http request object
+  // res is the Node.js http response object
+  // next is a function to call to invoke the next middleware
+})
+```
+
+In addition to a plan function, the `fn` argument can also be a Node.js HTTP server
+instance or another Connect app instance.
+
+### app.use(route, fn)
+
+Use a function on the app, where the function represents a middleware. The function
+will be invoked for every request in which the URL (`req.url` property) starts with
+the given `route` string in the order that `app.use` is called. The function is
+called with three arguments:
+
+```js
+app.use('/foo', function (req, res, next) {
+  // req is the Node.js http request object
+  // res is the Node.js http response object
+  // next is a function to call to invoke the next middleware
+})
+```
+
+In addition to a plan function, the `fn` argument can also be a Node.js HTTP server
+instance or another Connect app instance.
+
+The `route` is always terminated at a path separator (`/`) or a dot (`.`) character.
+This means the given routes `/foo/` and `/foo` are the same and both will match requests
+with the URLs `/foo`, `/foo/`, `/foo/bar`, and `/foo.bar`, but not match a request with
+the URL `/foobar`.
+
+The `route` is matched in a case-insensitive manor.
+
+In order to make middleware easier to write to be agnostic of the `route`, when the
+`fn` is invoked, the `req.url` will be altered to remove the `route` part (and the
+original will be available as `req.originalUrl`). For example, if `fn` is used at the
+route `/foo`, the request for `/foo/bar` will invoke `fn` with `req.url === '/bar'`
+and `req.originalUrl === '/foo/bar'`.
+
+## Running Tests
+
+```bash
+npm install
+npm test
+```
+
+## People
+
+The Connect project would not be the same without all the people involved.
+
+The original author of Connect is [TJ Holowaychuk](https://github.com/tj) [![TJ's Gratipay][gratipay-image-visionmedia]][gratipay-url-visionmedia]
+
+The current lead maintainer is [Douglas Christopher Wilson](https://github.com/dougwilson) [![Doug's Gratipay][gratipay-image-dougwilson]][gratipay-url-dougwilson]
+
+[List of all contributors](https://github.comsenchalabs/connect/graphs/contributors)
+
+## Node Compatibility
+
+  - Connect `< 1.x` - node `0.2`
+  - Connect `1.x` - node `0.4`
+  - Connect `< 2.8` - node `0.6`
+  - Connect `>= 2.8 < 3` - node `0.8`
+  - Connect `>= 3` - node `0.10`, `0.12`, `4.x`, `5.x`, `6.x`, `7.x`; io.js `1.x`, `2.x`, `3.x`
+
+## License
+
+[MIT](LICENSE)
+
+[npm-image]: https://img.shields.io/npm/v/connect.svg
+[npm-url]: https://npmjs.org/package/connect
+[travis-image]: https://img.shields.io/travis/senchalabs/connect/master.svg
+[travis-url]: https://travis-ci.org/senchalabs/connect
+[coveralls-image]: https://img.shields.io/coveralls/senchalabs/connect/master.svg
+[coveralls-url]: https://coveralls.io/r/senchalabs/connect
+[downloads-image]: https://img.shields.io/npm/dm/connect.svg
+[downloads-url]: https://npmjs.org/package/connect
+[gratipay-image]: https://img.shields.io/gratipay/dougwilson.svg
+[gratipay-url]: https://www.gratipay.com/dougwilson/

node_modules/connect/SECURITY.md

@@ -0,0 +1,43 @@
+# Security Policies and Procedures
+
+This document outlines security procedures and general policies for the Connect
+project.
+
+  * [Reporting a Bug](#reporting-a-bug)
+  * [Disclosure Policy](#disclosure-policy)
+  * [Comments on this Policy](#comments-on-this-policy)
+
+## Reporting a Bug
+
+The Connect team and community take all security bugs in Connect seriously.
+Thank you for improving the security of Connect. We appreciate your efforts and
+responsible disclosure and will make every effort to acknowledge your
+contributions.
+
+Report security bugs by emailing the lead maintainer in the README.md file.
+
+The lead maintainer will acknowledge your email within 48 hours, and will send a
+more detailed response within 48 hours indicating the next steps in handling
+your report. After the initial reply to your report, the security team will
+endeavor to keep you informed of the progress towards a fix and full
+announcement, and may ask for additional information or guidance.
+
+Report security bugs in third-party modules to the person or team maintaining
+the module. You can also report a vulnerability through the
+[Node Security Project](https://nodesecurity.io/report).
+
+## Disclosure Policy
+
+When the security team receives a security bug report, they will assign it to a
+primary handler. This person will coordinate the fix and release process,
+involving the following steps:
+
+  * Confirm the problem and determine the affected versions.
+  * Audit code to find any potential similar problems.
+  * Prepare fixes for all releases still under maintenance. These fixes will be
+    released as fast as possible to npm.
+
+## Comments on this Policy
+
+If you have suggestions on how this process could be improved please submit a
+pull request.

node_modules/connect/index.js

@@ -0,0 +1,283 @@
+/*!
+ * connect
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var debug = require('debug')('connect:dispatcher');
+var EventEmitter = require('events').EventEmitter;
+var finalhandler = require('finalhandler');
+var http = require('http');
+var merge = require('utils-merge');
+var parseUrl = require('parseurl');
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = createServer;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var env = process.env.NODE_ENV || 'development';
+var proto = {};
+
+/* istanbul ignore next */
+var defer = typeof setImmediate === 'function'
+  ? setImmediate
+  : function(fn){ process.nextTick(fn.bind.apply(fn, arguments)) }
+
+/**
+ * Create a new connect server.
+ *
+ * @return {function}
+ * @public
+ */
+
+function createServer() {
+  function app(req, res, next){ app.handle(req, res, next); }
+  merge(app, proto);
+  merge(app, EventEmitter.prototype);
+  app.route = '/';
+  app.stack = [];
+  return app;
+}
+
+/**
+ * Utilize the given middleware `handle` to the given `route`,
+ * defaulting to _/_. This "route" is the mount-point for the
+ * middleware, when given a value other than _/_ the middleware
+ * is only effective when that segment is present in the request's
+ * pathname.
+ *
+ * For example if we were to mount a function at _/admin_, it would
+ * be invoked on _/admin_, and _/admin/settings_, however it would
+ * not be invoked for _/_, or _/posts_.
+ *
+ * @param {String|Function|Server} route, callback or server
+ * @param {Function|Server} callback or server
+ * @return {Server} for chaining
+ * @public
+ */
+
+proto.use = function use(route, fn) {
+  var handle = fn;
+  var path = route;
+
+  // default route to '/'
+  if (typeof route !== 'string') {
+    handle = route;
+    path = '/';
+  }
+
+  // wrap sub-apps
+  if (typeof handle.handle === 'function') {
+    var server = handle;
+    server.route = path;
+    handle = function (req, res, next) {
+      server.handle(req, res, next);
+    };
+  }
+
+  // wrap vanilla http.Servers
+  if (handle instanceof http.Server) {
+    handle = handle.listeners('request')[0];
+  }
+
+  // strip trailing slash
+  if (path[path.length - 1] === '/') {
+    path = path.slice(0, -1);
+  }
+
+  // add the middleware
+  debug('use %s %s', path || '/', handle.name || 'anonymous');
+  this.stack.push({ route: path, handle: handle });
+
+  return this;
+};
+
+/**
+ * Handle server requests, punting them down
+ * the middleware stack.
+ *
+ * @private
+ */
+
+proto.handle = function handle(req, res, out) {
+  var index = 0;
+  var protohost = getProtohost(req.url) || '';
+  var removed = '';
+  var slashAdded = false;
+  var stack = this.stack;
+
+  // final function handler
+  var done = out || finalhandler(req, res, {
+    env: env,
+    onerror: logerror
+  });
+
+  // store the original URL
+  req.originalUrl = req.originalUrl || req.url;
+
+  function next(err) {
+    if (slashAdded) {
+      req.url = req.url.substr(1);
+      slashAdded = false;
+    }
+
+    if (removed.length !== 0) {
+      req.url = protohost + removed + req.url.substr(protohost.length);
+      removed = '';
+    }
+
+    // next callback
+    var layer = stack[index++];
+
+    // all done
+    if (!layer) {
+      defer(done, err);
+      return;
+    }
+
+    // route data
+    var path = parseUrl(req).pathname || '/';
+    var route = layer.route;
+
+    // skip this layer if the route doesn't match
+    if (path.toLowerCase().substr(0, route.length) !== route.toLowerCase()) {
+      return next(err);
+    }
+
+    // skip if route match does not border "/", ".", or end
+    var c = path[route.length];
+    if (c !== undefined && '/' !== c && '.' !== c) {
+      return next(err);
+    }
+
+    // trim off the part of the url that matches the route
+    if (route.length !== 0 && route !== '/') {
+      removed = route;
+      req.url = protohost + req.url.substr(protohost.length + removed.length);
+
+      // ensure leading slash
+      if (!protohost && req.url[0] !== '/') {
+        req.url = '/' + req.url;
+        slashAdded = true;
+      }
+    }
+
+    // call the layer handle
+    call(layer.handle, route, err, req, res, next);
+  }
+
+  next();
+};
+
+/**
+ * Listen for connections.
+ *
+ * This method takes the same arguments
+ * as node's `http.Server#listen()`.
+ *
+ * HTTP and HTTPS:
+ *
+ * If you run your application both as HTTP
+ * and HTTPS you may wrap them individually,
+ * since your Connect "server" is really just
+ * a JavaScript `Function`.
+ *
+ *      var connect = require('connect')
+ *        , http = require('http')
+ *        , https = require('https');
+ *
+ *      var app = connect();
+ *
+ *      http.createServer(app).listen(80);
+ *      https.createServer(options, app).listen(443);
+ *
+ * @return {http.Server}
+ * @api public
+ */
+
+proto.listen = function listen() {
+  var server = http.createServer(this);
+  return server.listen.apply(server, arguments);
+};
+
+/**
+ * Invoke a route handle.
+ * @private
+ */
+
+function call(handle, route, err, req, res, next) {
+  var arity = handle.length;
+  var error = err;
+  var hasError = Boolean(err);
+
+  debug('%s %s : %s', handle.name || '<anonymous>', route, req.originalUrl);
+
+  try {
+    if (hasError && arity === 4) {
+      // error-handling middleware
+      handle(err, req, res, next);
+      return;
+    } else if (!hasError && arity < 4) {
+      // request-handling middleware
+      handle(req, res, next);
+      return;
+    }
+  } catch (e) {
+    // replace the error
+    error = e;
+  }
+
+  // continue
+  next(error);
+}
+
+/**
+ * Log error using console.error.
+ *
+ * @param {Error} err
+ * @private
+ */
+
+function logerror(err) {
+  if (env !== 'test') console.error(err.stack || err.toString());
+}
+
+/**
+ * Get get protocol + host for a URL.
+ *
+ * @param {string} url
+ * @private
+ */
+
+function getProtohost(url) {
+  if (url.length === 0 || url[0] === '/') {
+    return undefined;
+  }
+
+  var searchIndex = url.indexOf('?');
+  var pathLength = searchIndex !== -1
+    ? searchIndex
+    : url.length;
+  var fqdnIndex = url.substr(0, pathLength).indexOf('://');
+
+  return fqdnIndex !== -1
+    ? url.substr(0, url.indexOf('/', 3 + fqdnIndex))
+    : undefined;
+}

node_modules/connect/package.json

@@ -0,0 +1,96 @@
+{
+  "_args": [
+    [
+      "connect@3.6.5",
+      "/Users/rodrigopinto/Documents/Development/ClusterSystems/cluster-server"
+    ]
+  ],
+  "_from": "connect@3.6.5",
+  "_id": "connect@3.6.5",
+  "_inBundle": false,
+  "_integrity": "sha1-+43ee6B2OHfQ7J352sC0tA5yx9o=",
+  "_location": "/connect",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "connect@3.6.5",
+    "name": "connect",
+    "escapedName": "connect",
+    "rawSpec": "3.6.5",
+    "saveSpec": null,
+    "fetchSpec": "3.6.5"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/connect/-/connect-3.6.5.tgz",
+  "_spec": "3.6.5",
+  "_where": "/Users/rodrigopinto/Documents/Development/ClusterSystems/cluster-server",
+  "author": {
+    "name": "TJ Holowaychuk",
+    "email": "tj@vision-media.ca",
+    "url": "http://tjholowaychuk.com"
+  },
+  "bugs": {
+    "url": "https://github.com/senchalabs/connect/issues"
+  },
+  "contributors": [
+    {
+      "name": "Douglas Christopher Wilson",
+      "email": "doug@somethingdoug.com"
+    },
+    {
+      "name": "Jonathan Ong",
+      "email": "me@jongleberry.com"
+    },
+    {
+      "name": "Tim Caswell",
+      "email": "tim@creationix.com"
+    }
+  ],
+  "dependencies": {
+    "debug": "2.6.9",
+    "finalhandler": "1.0.6",
+    "parseurl": "~1.3.2",
+    "utils-merge": "1.0.1"
+  },
+  "description": "High performance middleware framework",
+  "devDependencies": {
+    "eslint": "2.13.1",
+    "mocha": "3.5.3",
+    "nyc": "10.3.2",
+    "supertest": "2.0.0"
+  },
+  "engines": {
+    "node": ">= 0.10.0"
+  },
+  "files": [
+    "LICENSE",
+    "HISTORY.md",
+    "README.md",
+    "SECURITY.md",
+    "index.js"
+  ],
+  "homepage": "https://github.com/senchalabs/connect#readme",
+  "keywords": [
+    "framework",
+    "web",
+    "middleware",
+    "connect",
+    "rack"
+  ],
+  "license": "MIT",
+  "name": "connect",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/senchalabs/connect.git"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "test": "mocha --require test/support/env --reporter spec --bail --check-leaks test/",
+    "test-cov": "nyc --reporter=text npm test",
+    "test-travis": "nyc --reporter=html --reporter=text npm test"
+  },
+  "version": "3.6.5"
+}