modified: README.md

* Add CODEOWNERS file

.dockerignore

@@ -0,0 +1,8 @@
+Dockerfile
+.git
+npm-debug.log
+node_modules
+*.swp
+*.swo
+data
+*.DS_Store

.eslintignore

@@ -0,0 +1,2 @@
+**/*.min.js
+config.js

.eslintrc.json

@@ -0,0 +1,25 @@
+{
+    "env": {
+        "es6": true,
+        "node": true
+    },
+    "extends": "eslint:recommended",
+    "rules": {
+        "indent": [
+            "error",
+            2
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ]
+    }
+}

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @toptal/site-acquisition-eng

.github/workflows/close-inactive.yaml

@@ -0,0 +1,30 @@
+name: Close inactive issues and PRs
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "30 1 * * *"
+
+jobs:
+  close-stale:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - uses: actions/stale@v3
+        with:
+          days-before-stale: 30
+          days-before-close: 14
+          stale-issue-label: "stale"
+          stale-pr-label: "stale"
+
+          exempt-issue-labels: backlog,triage,nostale
+          exempt-pr-labels: backlog,triage,nostale
+
+          stale-pr-message: "This PR is stale because it has been open for 30 days with no activity."
+          close-pr-message: "This PR was closed because it has been inactive for 14 days since being marked as stale."
+
+          stale-issue-message: "This issue is stale because it has been open for 30 days with no activity."
+          close-issue-message: "This issue was closed because it has been inactive for 14 days since being marked as stale."
+
+          repo-token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,5 +1,7 @@
 npm-debug.log
+node_modules
 *.swp
 *.swo
 data
 *.DS_Store
+docker-compose.override.yml

Dockerfile

@@ -0,0 +1,68 @@
+FROM node:14.8.0-stretch
+
+RUN mkdir -p /usr/src/app && \
+    chown node:node /usr/src/app
+
+USER node:node
+
+WORKDIR /usr/src/app
+
+COPY --chown=node:node . .
+
+RUN npm install && \
+    npm install redis@0.8.1 && \
+    npm install pg@4.1.1 && \
+    npm install memcached@2.2.2 && \
+    npm install aws-sdk@2.738.0 && \
+    npm install rethinkdbdash@2.3.31
+
+ENV STORAGE_TYPE=memcached \
+    STORAGE_HOST=127.0.0.1 \
+    STORAGE_PORT=11211\
+    STORAGE_EXPIRE_SECONDS=2592000\
+    STORAGE_DB=2 \
+    STORAGE_AWS_BUCKET= \
+    STORAGE_AWS_REGION= \
+    STORAGE_USENAME= \
+    STORAGE_PASSWORD= \
+    STORAGE_FILEPATH=
+
+ENV LOGGING_LEVEL=verbose \
+    LOGGING_TYPE=Console \
+    LOGGING_COLORIZE=true
+
+ENV HOST=0.0.0.0\
+    PORT=7777\
+    KEY_LENGTH=10\
+    MAX_LENGTH=400000\
+    STATIC_MAX_AGE=86400\
+    RECOMPRESS_STATIC_ASSETS=true
+
+ENV KEYGENERATOR_TYPE=phonetic \
+    KEYGENERATOR_KEYSPACE=
+
+ENV RATELIMITS_NORMAL_TOTAL_REQUESTS=500\
+    RATELIMITS_NORMAL_EVERY_MILLISECONDS=60000 \
+    RATELIMITS_WHITELIST_TOTAL_REQUESTS= \
+    RATELIMITS_WHITELIST_EVERY_MILLISECONDS=  \
+    # comma separated list for the whitelisted \
+    RATELIMITS_WHITELIST=example1.whitelist,example2.whitelist \
+    \
+    RATELIMITS_BLACKLIST_TOTAL_REQUESTS= \
+    RATELIMITS_BLACKLIST_EVERY_MILLISECONDS= \
+    # comma separated list for the blacklisted \
+    RATELIMITS_BLACKLIST=example1.blacklist,example2.blacklist
+ENV DOCUMENTS=about=./about.md
+
+EXPOSE ${PORT}
+STOPSIGNAL SIGINT
+ENTRYPOINT [ "bash", "docker-entrypoint.sh" ]
+
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s \
+    --retries=3 CMD [ "sh", "-c", "echo -n 'curl localhost:7777... '; \
+    (\
+        curl -sf localhost:7777 > /dev/null\
+    ) && echo OK || (\
+        echo Fail && exit 2\
+    )"]
+CMD ["npm", "start"]

Procfile

@@ -0,0 +1 @@
+web: node server.js

README.md

@@ -1,6 +1,6 @@
 # Haste
 
-Haste is an open-source pastebin software written in node.js, which is easily
+haste is an open-source pastebin software written in node.js, which is easily
 installable in any network.  It can be backed by either redis or filesystem,
 and has a very easy adapter interface for other stores.  A publicly available
 version can be found at [hastebin.com](http://hastebin.com)
@@ -31,21 +31,31 @@ STDOUT.  Check the README there for more details and usages.
 1.  Download the package, and expand it
 2.  Explore the settings inside of config.js, but the defaults should be good
 3.  `npm install`
-4.  `npm start`
+4.  `npm start` (you may specify an optional `<config-path>` as well)
 
 ## Settings
 
 * `host` - the host the server runs on (default localhost)
 * `port` - the port the server runs on (default 7777)
 * `keyLength` - the length of the keys to user (default 10)
-* `maxLength` - maximum length of a paste (default none)
+* `maxLength` - maximum length of a paste (default 400000)
 * `staticMaxAge` - max age for static assets (86400)
-* `recompressStatisAssets` - whether or not to compile static js assets (true)
+* `recompressStaticAssets` - whether or not to compile static js assets (true)
 * `documents` - static documents to serve (ex: http://hastebin.com/about.com)
   in addition to static assets.  These will never expire.
 * `storage` - storage options (see below)
 * `logging` - logging preferences
 * `keyGenerator` - key generator options (see below)
+* `rateLimits` - settings for rate limiting (see below)
+
+## Rate Limiting
+
+When present, the `rateLimits` option enables built-in rate limiting courtesy
+of `connect-ratelimit`.  Any of the options supported by that library can be
+used and set in `config.js`.
+
+See the README for [connect-ratelimit](https://github.com/dharmafly/connect-ratelimit)
+for more information!
 
 ## Key Generation
 
@@ -55,7 +65,7 @@ Attempts to generate phonetic keys, similar to `pwgen`
 
 ``` json
 {
-	"type": "phonetic"
+  "type": "phonetic"
 }
 ```
 
@@ -65,7 +75,7 @@ Generates a random key
 
 ``` json
 {
-	"type": "random",
+  "type": "random",
   "keyspace": "abcdef"
 }
 ```
@@ -82,16 +92,19 @@ something like:
 
 ``` json
 {
-	"path": "./data",
-	"type": "file"
+  "path": "./data",
+  "type": "file"
 }
 ```
 
-Where `path` represents where you want the files stored
+where `path` represents where you want the files stored.
+
+File storage currently does not support paste expiration, you can follow [#191](https://github.com/seejohnrun/haste-server/issues/191) for status updates.
 
 ### Redis
 
-To use redis storage you must install the redis package in npm
+To use redis storage you must install the `redis` package in npm, and have
+`redis-server` running on the machine.
 
 `npm install redis`
 
@@ -99,32 +112,83 @@ Once you've done that, your config section should look like:
 
 ``` json
 {
-	"type": "redis",
-	"host": "localhost",
-	"port": 6379,
-	"db": 2
+  "type": "redis",
+  "host": "localhost",
+  "port": 6379,
+  "db": 2
+}
+```
+
+You can also set an `expire` option to the number of seconds to expire keys in.
+This is off by default, but will constantly kick back expirations on each view
+or post.
+
+All of which are optional except `type` with very logical default values.
+
+If your Redis server is configured for password authentification, use the `password` field.
+
+### Postgres
+
+To use postgres storage you must install the `pg` package in npm
+
+`npm install pg`
+
+Once you've done that, your config section should look like:
+
+``` json
+{
+  "type": "postgres",
+  "connectionUrl": "postgres://user:password@host:5432/database"
 }
 ```
 
+You can also just set the environment variable for `DATABASE_URL` to your database connection url.
+
+You will have to manually add a table to your postgres database:
+
+`create table entries (id serial primary key, key varchar(255) not null, value text not null, expiration int, unique(key));`
+
 You can also set an `expire` option to the number of seconds to expire keys in.
 This is off by default, but will constantly kick back expirations on each view
 or post.
 
 All of which are optional except `type` with very logical default values.
 
+### MongoDB
+
+To use mongodb storage you must install the 'mongodb' package in npm
+
+`npm install mongodb`
+
+Once you've done that, your config section should look like:
+
+``` json
+{
+  "type": "mongo",
+  "connectionUrl": "mongodb://localhost:27017/database"
+}
+```
+
+You can also just set the environment variable for `DATABASE_URL` to your database connection url.
+
+Unlike with postgres you do NOT have to create the table in your mongo database prior to running.
+
+You can also set an `expire` option to the number of seconds to expire keys in.
+This is off by default, but will constantly kick back expirations on each view or post.
+
 ### Memcached
 
-To use memcached storage you must install the `memcache` package via npm
+To use memcache storage you must install the `memcached` package via npm
 
-`npm install memcache`
+`npm install memcached`
 
 Once you've done that, your config section should look like:
 
 ``` json
 {
-	"type": "memcached",
-	"host": "127.0.0.1",
-	"port": 11211
+  "type": "memcached",
+  "host": "127.0.0.1",
+  "port": 11211
 }
 ```
 
@@ -134,6 +198,161 @@ forward on GETs.
 
 All of which are optional except `type` with very logical default values.
 
+### RethinkDB
+
+To use the RethinkDB storage system, you must install the `rethinkdbdash` package via npm
+
+`npm install rethinkdbdash`
+
+Once you've done that, your config section should look like this:
+
+``` json
+{
+  "type": "rethinkdb",
+  "host": "127.0.0.1",
+  "port": 28015,
+  "db": "haste"
+}
+```
+
+In order for this to work, the database must be pre-created before the script is ran.
+Also, you must create an `uploads` table, which will store all the data for uploads.
+
+You can optionally add the `user` and `password` properties to use a user system.
+
+### Google Datastore
+
+To use the Google Datastore storage system, you must install the `@google-cloud/datastore` package via npm
+
+`npm install @google-cloud/datastore`
+
+Once you've done that, your config section should look like this:
+
+``` json
+{
+  "type": "google-datastore"
+}
+```
+
+Authentication is handled automatically by [Google Cloud service account credentials](https://cloud.google.com/docs/authentication/getting-started), by providing authentication details to the GOOGLE_APPLICATION_CREDENTIALS environmental variable.
+
+### Amazon S3
+
+To use [Amazon S3](https://aws.amazon.com/s3/) as a storage system, you must
+install the `aws-sdk` package via npm:
+
+`npm install aws-sdk`
+
+Once you've done that, your config section should look like this:
+
+```json
+{
+  "type": "amazon-s3",
+  "bucket": "your-bucket-name",
+  "region": "us-east-1"
+}
+```
+
+Authentication is handled automatically by the client. Check
+[Amazon's documentation](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-node.html)
+for more information. You will need to grant your role these permissions to
+your bucket:
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Action": [
+                "s3:GetObject",
+                "s3:PutObject"
+            ],
+            "Effect": "Allow",
+            "Resource": "arn:aws:s3:::your-bucket-name-goes-here/*"
+        }
+    ]
+}
+```
+
+## Docker
+
+### Build image
+
+```bash
+docker build --tag haste-server .
+```
+
+### Run container
+
+For this example we will run haste-server, and connect it to a redis server
+
+```bash
+docker run --name haste-server-container --env STORAGE_TYPE=redis --env STORAGE_HOST=redis-server --env STORAGE_PORT=6379 haste-server
+```
+
+### Use docker-compose example
+
+There is an example `docker-compose.yml` which runs haste-server together with memcached
+
+```bash
+docker-compose up
+```
+
+### Configuration
+
+The docker image is configured using environmental variables as you can see in the example above.
+
+Here is a list of all the environment variables
+
+### Storage
+
+|          Name          | Default value |                                                  Description                                                  |
+| :--------------------: | :-----------: | :-----------------------------------------------------------------------------------------------------------: |
+|      STORAGE_TYPE      |   memcached   |    Type of storage . Accepted values: "memcached","redis","postgres","rethinkdb", "amazon-s3", and "file"     |
+|      STORAGE_HOST      |   127.0.0.1   |                 Storage host. Applicable for types: memcached, redis, postgres, and rethinkdb                 |
+|      STORAGE_PORT      |     11211     |           Port on the storage host. Applicable for types: memcached, redis, postgres, and rethinkdb           |
+| STORAGE_EXPIRE_SECONDS |    2592000    | Number of seconds to expire keys in. Applicable for types. Redis, postgres, memcached. `expire` option to the |
+|       STORAGE_DB       |       2       |                    The name of the database. Applicable for redis, postgres, and rethinkdb                    |
+|    STORAGE_PASSWORD    |               |                       Password for database. Applicable for redis, postges, rethinkdb .                       |
+|    STORAGE_USERNAME    |               |                           Database username. Applicable for postgres, and rethinkdb                           |
+|   STORAGE_AWS_BUCKET   |               |                          Applicable for amazon-s3. This is the name of the S3 bucket                          |
+|   STORAGE_AWS_REGION   |               |                      Applicable for amazon-s3. The region in which the bucket is located                      |
+|    STORAGE_FILEPATH    |               |                            Path to file to save data to. Applicable for type file                             |
+
+### Logging
+
+|       Name        | Default value | Description |
+| :---------------: | :-----------: | :---------: |
+|   LOGGING_LEVEL   |    verbose    |             |
+|   LOGGING_TYPE=   |    Console    |
+| LOGGING_COLORIZE= |     true      |
+
+### Basics
+
+|           Name           |  Default value   |                                        Description                                        |
+| :----------------------: | :--------------: | :---------------------------------------------------------------------------------------: |
+|           HOST           |     0.0.0.0      |                         The hostname which the server answers on                          |
+|           PORT           |       7777       |                          The port on which the server is running                          |
+|        KEY_LENGTH        |        10        |                              the length of the keys to user                               |
+|        MAX_LENGTH        |      400000      |                                 maximum length of a paste                                 |
+|      STATIC_MAX_AGE      |      86400       |                                 max age for static assets                                 |
+| RECOMPRESS_STATIC_ASSETS |       true       |                        whether or not to compile static js assets                         |
+|    KEYGENERATOR_TYPE     |     phonetic     |             Type of key generator. Acceptable values: "phonetic", or "random"             |
+|  KEYGENERATOR_KEYSPACE   |                  |                  keySpace argument is a string of acceptable characters                   |
+|        DOCUMENTS         | about=./about.md | Comma separated list of static documents to serve. ex: \n about=./about.md,home=./home.md |
+
+### Rate limits
+
+|                 Name                 |             Default value             |                                       Description                                        |
+| :----------------------------------: | :-----------------------------------: | :--------------------------------------------------------------------------------------: |
+|   RATELIMITS_NORMAL_TOTAL_REQUESTS   |                  500                  | By default anyone uncategorized will be subject to 500 requests in the defined timespan. |
+| RATELIMITS_NORMAL_EVERY_MILLISECONDS |                 60000                 |             The timespan to allow the total requests for uncategorized users             |
+| RATELIMITS_WHITELIST_TOTAL_REQUESTS  |                                       |      By default client names in the whitelist will not have their requests limited.      |
+|  RATELIMITS_WHITELIST_EVERY_SECONDS  |                                       |      By default client names in the whitelist will not have their requests limited.      |
+|         RATELIMITS_WHITELIST         | example1.whitelist,example2.whitelist |           Comma separated list of the clients which are in the whitelist pool            |
+| RATELIMITS_BLACKLIST_TOTAL_REQUESTS  |                                       |    By default client names in the blacklist will be subject to 0 requests per hours.     |
+|  RATELIMITS_BLACKLIST_EVERY_SECONDS  |                                       |     By default client names in the blacklist will be subject to 0 requests per hours     |
+|         RATELIMITS_BLACKLIST         | example1.blacklist,example2.blacklist |           Comma separated list of the clients which are in the blacklistpool.            |
 
 ## Author
 
@@ -143,7 +362,7 @@ John Crepezzi <john.crepezzi@gmail.com>
 
 (The MIT License)
 
-Copyright © 2011 John Crepezzi
+Copyright © 2011-2012 John Crepezzi
 
 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

about.md

@@ -15,17 +15,17 @@ To make a new entry, click "New" (or type 'control + n')
 
 ## From the Console
 
-Most of the time I want to show you some text, its coming from my current
+Most of the time I want to show you some text, it's coming from my current
 console session.  We should make it really easy to take code from the console
 and send it to people.
 
-`cat something | haste` # http://hastebin.com/1238193
+`cat something | haste` # https://hastebin.com/1238193
 
 You can even take this a step further, and cut out the last step of copying the
 URL with:
 
 * osx: `cat something | haste | pbcopy`
-* linux: `cat something | haste | xsel`
+* linux: `cat something | haste | xsel -b`
 * windows: check out [WinHaste](https://github.com/ajryan/WinHaste)
 
 After running that, the STDOUT output of `cat something` will show up at a URL
@@ -38,7 +38,8 @@ right now.
 
 ## Duration
 
-Pastes will stay for 30 days from their last view.
+Pastes will stay for 30 days from their last view.  They may be removed earlier
+and without notice.
 
 ## Privacy
 
@@ -49,7 +50,7 @@ pastes.
 
 ## Open Source
 
-Haste can easily be installed behind your network, and its all open source!
+Haste can easily be installed behind your network, and it's all open source!
 
 * [haste-client](https://github.com/seejohnrun/haste-client)
 * [haste-server](https://github.com/seejohnrun/haste-server)

config.js

@@ -1,6 +1,6 @@
 {
 
-  "host": "localhost",
+  "host": "0.0.0.0",
   "port": 7777,
 
   "keyLength": 10,
@@ -23,9 +23,17 @@
     "type": "phonetic"
   },
 
+  "rateLimits": {
+    "categories": {
+      "normal": {
+        "totalRequests": 500,
+        "every": 60000
+      }
+    }
+  },
+
   "storage": {
-    "type": "file",
-    "path": "./data"
+    "type": "file"
   },
 
   "documents": {

docker-compose.yaml

@@ -0,0 +1,12 @@
+version: '3.0'
+services:
+  haste-server:
+    build: .
+    environment:
+      - STORAGE_TYPE=memcached
+      - STORAGE_HOST=memcached
+      - STORAGE_PORT=11211
+    ports:
+      - 7777:7777
+  memcached:
+    image: memcached:latest

docker-entrypoint.js

@@ -0,0 +1,108 @@
+const {
+  HOST,
+  PORT,
+  KEY_LENGTH,
+  MAX_LENGTH,
+  STATIC_MAX_AGE,
+  RECOMPRESS_STATIC_ASSETS,
+  STORAGE_TYPE,
+  STORAGE_HOST,
+  STORAGE_PORT,
+  STORAGE_EXPIRE_SECONDS,
+  STORAGE_DB,
+  STORAGE_AWS_BUCKET,
+  STORAGE_AWS_REGION,
+  STORAGE_PASSWORD,
+  STORAGE_USERNAME,
+  STORAGE_FILEPATH,
+  LOGGING_LEVEL,
+  LOGGING_TYPE,
+  LOGGING_COLORIZE,
+  KEYGENERATOR_TYPE,
+  KEY_GENERATOR_KEYSPACE,
+  RATE_LIMITS_NORMAL_TOTAL_REQUESTS,
+  RATE_LIMITS_NORMAL_EVERY_MILLISECONDS,
+  RATE_LIMITS_WHITELIST_TOTAL_REQUESTS,
+  RATE_LIMITS_WHITELIST_EVERY_MILLISECONDS,
+  RATE_LIMITS_WHITELIST,
+  RATE_LIMITS_BLACKLIST_TOTAL_REQUESTS,
+  RATE_LIMITS_BLACKLIST_EVERY_MILLISECONDS,
+  RATE_LIMITS_BLACKLIST,
+  DOCUMENTS,
+} = process.env;
+
+const config = {
+  host: HOST,
+  port: Number(PORT),
+
+  keyLength: Number(KEY_LENGTH),
+
+  maxLength: Number(MAX_LENGTH),
+
+  staticMaxAge: Number(STATIC_MAX_AGE),
+
+  recompressStaticAssets: RECOMPRESS_STATIC_ASSETS,
+
+  logging: [
+    {
+      level: LOGGING_LEVEL,
+      type: LOGGING_TYPE,
+      colorize: LOGGING_COLORIZE,
+    },
+  ],
+
+  keyGenerator: {
+    type: KEYGENERATOR_TYPE,
+    keyspace: KEY_GENERATOR_KEYSPACE,
+  },
+
+  rateLimits: {
+    whitelist: RATE_LIMITS_WHITELIST ? RATE_LIMITS_WHITELIST.split(",") : [],
+    blacklist: RATE_LIMITS_BLACKLIST ? RATE_LIMITS_BLACKLIST.split(",") : [],
+    categories: {
+      normal: {
+        totalRequests: RATE_LIMITS_NORMAL_TOTAL_REQUESTS,
+        every: RATE_LIMITS_NORMAL_EVERY_MILLISECONDS,
+      },
+      whitelist:
+        RATE_LIMITS_WHITELIST_EVERY_MILLISECONDS ||
+        RATE_LIMITS_WHITELIST_TOTAL_REQUESTS
+          ? {
+              totalRequests: RATE_LIMITS_WHITELIST_TOTAL_REQUESTS,
+              every: RATE_LIMITS_WHITELIST_EVERY_MILLISECONDS,
+            }
+          : null,
+      blacklist:
+        RATE_LIMITS_BLACKLIST_EVERY_MILLISECONDS ||
+        RATE_LIMITS_BLACKLIST_TOTAL_REQUESTS
+          ? {
+              totalRequests: RATE_LIMITS_WHITELIST_TOTAL_REQUESTS,
+              every: RATE_LIMITS_BLACKLIST_EVERY_MILLISECONDS,
+            }
+          : null,
+    },
+  },
+
+  storage: {
+    type: STORAGE_TYPE,
+    host: STORAGE_HOST,
+    port: Number(STORAGE_PORT),
+    expire: Number(STORAGE_EXPIRE_SECONDS),
+    bucket: STORAGE_AWS_BUCKET,
+    region: STORAGE_AWS_REGION,
+    connectionUrl: `postgres://${STORAGE_USERNAME}:${STORAGE_PASSWORD}@${STORAGE_HOST}:${STORAGE_PORT}/${STORAGE_DB}`,
+    db: STORAGE_DB,
+    user: STORAGE_USERNAME,
+    password: STORAGE_PASSWORD,
+    path: STORAGE_FILEPATH,
+  },
+
+  documents: DOCUMENTS
+    ? DOCUMENTS.split(",").reduce((acc, item) => {
+        const keyAndValueArray = item.replace(/\s/g, "").split("=");
+        return { ...acc, [keyAndValueArray[0]]: keyAndValueArray[1] };
+      }, {})
+    : null,
+};
+
+console.log(JSON.stringify(config));

docker-entrypoint.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# We use this file to translate environmental variables to .env files used by the application
+
+set -e
+
+node ./docker-entrypoint.js > ./config.js
+
+exec "$@"

lib/document_handler.js

@@ -1,4 +1,5 @@
 var winston = require('winston');
+var Busboy = require('busboy');
 
 // For handling serving stored documents
 
@@ -15,47 +16,68 @@ var DocumentHandler = function(options) {
 DocumentHandler.defaultKeyLength = 10;
 
 // Handle retrieving a document
-DocumentHandler.prototype.handleGet = function(key, response, skipExpire) {
+DocumentHandler.prototype.handleGet = function(request, response, config) {
+  const key = request.params.id.split('.')[0];
+  const skipExpire = !!config.documents[key];
+
   this.store.get(key, function(ret) {
     if (ret) {
       winston.verbose('retrieved document', { key: key });
       response.writeHead(200, { 'content-type': 'application/json' });
-      response.end(JSON.stringify({ data: ret, key: key }));
+      if (request.method === 'HEAD') {
+        response.end();
+      } else {
+        response.end(JSON.stringify({ data: ret, key: key }));
+      }
     }
     else {
       winston.warn('document not found', { key: key });
       response.writeHead(404, { 'content-type': 'application/json' });
-      response.end(JSON.stringify({ message: 'Document not found.' }));
+      if (request.method === 'HEAD') {
+        response.end();
+      } else {
+        response.end(JSON.stringify({ message: 'Document not found.' }));
+      }
     }
   }, skipExpire);
 };
 
 // Handle retrieving the raw version of a document
-DocumentHandler.prototype.handleRawGet = function(key, response, skipExpire) {
+DocumentHandler.prototype.handleRawGet = function(request, response, config) {
+  const key = request.params.id.split('.')[0];
+  const skipExpire = !!config.documents[key];
+
   this.store.get(key, function(ret) {
     if (ret) {
       winston.verbose('retrieved raw document', { key: key });
-      response.writeHead(200, { 'content-type': 'text/plain' });
-      response.end(ret);
+      response.writeHead(200, { 'content-type': 'text/plain; charset=UTF-8' });
+      if (request.method === 'HEAD') {
+        response.end();
+      } else {
+        response.end(ret);
+      }
     }
     else {
       winston.warn('raw document not found', { key: key });
       response.writeHead(404, { 'content-type': 'application/json' });
-      response.end(JSON.stringify({ message: 'Document not found.' }));
+      if (request.method === 'HEAD') {
+        response.end();
+      } else {
+        response.end(JSON.stringify({ message: 'Document not found.' }));
+      }
     }
   }, skipExpire);
 };
 
 // Handle adding a new Document
-DocumentHandler.prototype.handlePost = function(request, response) {
+DocumentHandler.prototype.handlePost = function (request, response) {
   var _this = this;
   var buffer = '';
   var cancelled = false;
-  request.on('data', function(data) {
-    if (!buffer) {
-      response.writeHead(200, { 'content-type': 'application/json' });
-    }
-    buffer += data.toString();
+
+  // What to do when done
+  var onSuccess = function () {
+    // Check length
     if (_this.maxLength && buffer.length > _this.maxLength) {
       cancelled = true;
       winston.warn('document >maxLength', { maxLength: _this.maxLength });
@@ -63,14 +85,14 @@ DocumentHandler.prototype.handlePost = function(request, response) {
       response.end(
         JSON.stringify({ message: 'Document exceeds maximum length.' })
       );
+      return;
     }
-  });
-  request.on('end', function(end) {
-    if (cancelled) return;
-    _this.chooseKey(function(key) {
-      _this.store.set(key, buffer, function(res) {
+    // And then save if we should
+    _this.chooseKey(function (key) {
+      _this.store.set(key, buffer, function (res) {
         if (res) {
           winston.verbose('added document', { key: key });
+          response.writeHead(200, { 'content-type': 'application/json' });
           response.end(JSON.stringify({ key: key }));
         }
         else {
@@ -80,12 +102,37 @@ DocumentHandler.prototype.handlePost = function(request, response) {
         }
       });
     });
-  });
-  request.on('error', function(error) {
-    winston.error('connection error: ' + error.message);
-    response.writeHead(500, { 'content-type': 'application/json' });
-    response.end(JSON.stringify({ message: 'Connection error.' }));
-  });
+  };
+
+  // If we should, parse a form to grab the data
+  var ct = request.headers['content-type'];
+  if (ct && ct.split(';')[0] === 'multipart/form-data') {
+    var busboy = new Busboy({ headers: request.headers });
+    busboy.on('field', function (fieldname, val) {
+      if (fieldname === 'data') {
+        buffer = val;
+      }
+    });
+    busboy.on('finish', function () {
+      onSuccess();
+    });
+    request.pipe(busboy);
+  // Otherwise, use our own and just grab flat data from POST body
+  } else {
+    request.on('data', function (data) {
+      buffer += data.toString();
+    });
+    request.on('end', function () {
+      if (cancelled) { return; }
+      onSuccess();
+    });
+    request.on('error', function (error) {
+      winston.error('connection error: ' + error.message);
+      response.writeHead(500, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ message: 'Connection error.' }));
+      cancelled = true;
+    });
+  }
 };
 
 // Keep choosing keys until one isn't taken
@@ -98,7 +145,7 @@ DocumentHandler.prototype.chooseKey = function(callback) {
     } else {
       callback(key);
     }
-  });
+  }, true); // Don't bump expirations when key searching
 };
 
 DocumentHandler.prototype.acceptableKey = function() {

lib/document_stores/amazon-s3.js

@@ -0,0 +1,56 @@
+/*global require,module,process*/
+
+var AWS = require('aws-sdk');
+var winston = require('winston');
+
+var AmazonS3DocumentStore = function(options) {
+  this.expire = options.expire;
+  this.bucket = options.bucket;
+  this.client = new AWS.S3({region: options.region});
+};
+
+AmazonS3DocumentStore.prototype.get = function(key, callback, skipExpire) {
+  var _this = this;
+
+  var req = {
+    Bucket: _this.bucket,
+    Key: key
+  };
+
+  _this.client.getObject(req, function(err, data) {
+    if(err) {
+      callback(false);
+    }
+    else {
+      callback(data.Body.toString('utf-8'));
+      if (_this.expire && !skipExpire) {
+        winston.warn('amazon s3 store cannot set expirations on keys');
+      }
+    }
+  });
+}
+
+AmazonS3DocumentStore.prototype.set = function(key, data, callback, skipExpire) {
+  var _this = this;
+
+  var req = {
+    Bucket: _this.bucket,
+    Key: key,
+    Body: data,
+    ContentType: 'text/plain'
+  };
+
+  _this.client.putObject(req, function(err, data) {
+    if (err) {
+      callback(false);
+    }
+    else {
+      callback(true);
+      if (_this.expire && !skipExpire) {
+        winston.warn('amazon s3 store cannot set expirations on keys');
+      }
+    }
+  });
+}
+
+module.exports = AmazonS3DocumentStore;

lib/document_stores/google-datastore.js

@@ -0,0 +1,89 @@
+/*global require,module,process*/
+
+const Datastore = require('@google-cloud/datastore');
+const winston = require('winston');
+
+class GoogleDatastoreDocumentStore {
+
+  // Create a new store with options
+  constructor(options) {
+    this.kind = "Haste";
+    this.expire = options.expire;
+    this.datastore = new Datastore();
+  }
+
+  // Save file in a key
+  set(key, data, callback, skipExpire) {
+    var expireTime = (skipExpire || this.expire === undefined) ? null : new Date(Date.now() + this.expire * 1000);
+
+    var taskKey = this.datastore.key([this.kind, key])
+    var task = {
+      key: taskKey,
+      data: [
+        {
+          name: 'value',
+          value: data,
+          excludeFromIndexes: true
+        },
+        {
+          name: 'expiration',
+          value: expireTime
+        }
+      ]
+    };
+
+    this.datastore.insert(task).then(() => {
+      callback(true);
+    })
+    .catch(err => {
+      callback(false);
+    });
+  }
+
+  // Get a file from a key
+  get(key, callback, skipExpire) {
+    var taskKey = this.datastore.key([this.kind, key])
+
+    this.datastore.get(taskKey).then((entity) => {
+      if (skipExpire || entity[0]["expiration"] == null) {
+        callback(entity[0]["value"]);
+      }
+      else {
+        // check for expiry
+        if (entity[0]["expiration"] < new Date()) {
+          winston.info("document expired", {key: key, expiration: entity[0]["expiration"], check: new Date(null)});
+          callback(false);
+        }
+        else {
+          // update expiry
+          var task = {
+            key: taskKey,
+            data: [
+              {
+                name: 'value',
+                value: entity[0]["value"],
+                excludeFromIndexes: true
+              },
+              {
+                name: 'expiration',
+                value: new Date(Date.now() + this.expire * 1000)
+              }
+            ]
+          };
+          this.datastore.update(task).then(() => {
+          })
+          .catch(err => {
+            winston.error("failed to update expiration", {error: err});
+          });
+          callback(entity[0]["value"]);
+        }
+      }
+    })
+    .catch(err => {
+        winston.error("Error retrieving value from Google Datastore", {error: err});
+        callback(false);
+    });
+  }
+}
+
+module.exports = GoogleDatastoreDocumentStore;

lib/document_stores/memcached.js

@@ -1,45 +1,54 @@
-var memcached = require('memcache');
-var winston = require('winston');
-
-// Create a new store with options
-var MemcachedDocumentStore = function(options) {
-  this.expire = options.expire;
-  if (!MemcachedDocumentStore.client) {
-    MemcachedDocumentStore.connect(options);
+const memcached = require('memcached');
+const winston = require('winston');
+
+class MemcachedDocumentStore {
+
+  // Create a new store with options
+  constructor(options) {
+    this.expire = options.expire;
+
+    const host = options.host || '127.0.0.1';
+    const port = options.port || 11211;
+    const url = `${host}:${port}`;
+    this.connect(url);
+  }
+
+  // Create a connection
+  connect(url) {
+    this.client = new memcached(url);
+
+    winston.info(`connecting to memcached on ${url}`);
+
+    this.client.on('failure', function(error) {
+      winston.info('error connecting to memcached', {error});
+    });
   }
-};
-
-// Create a connection
-MemcachedDocumentStore.connect = function(options) {
-  var host = options.host || '127.0.0.1';
-  var port = options.port || 11211;
-  this.client = new memcached.Client(port, host);
-  this.client.connect();
-  this.client.on('connect', function() {
-    winston.info('connected to memcached on ' + host + ':' + port);
-  });
-  this.client.on('error', function(e) {
-    winston.info('error connecting to memcached', { error: e });
-  });
-};
-
-// Save file in a key
-MemcachedDocumentStore.prototype.set =
-function(key, data, callback, skipExpire) {
-  MemcachedDocumentStore.client.set(key, data, function(err, reply) {
-    err ? callback(false) : callback(true);
-  }, skipExpire ? 0 : this.expire);
-};
-
-// Get a file from a key
-MemcachedDocumentStore.prototype.get = function(key, callback, skipExpire) {
-  var _this = this;
-  MemcachedDocumentStore.client.get(key, function(err, reply) {
-    callback(err ? false : reply);
-    if (_this.expire && !skipExpire) {
-      winston.warn('store does not currently push forward expirations on GET');
-    }
-  });
-};
+
+  // Save file in a key
+  set(key, data, callback, skipExpire) {
+    this.client.set(key, data, skipExpire ? 0 : this.expire || 0, (error) => {
+      callback(!error);
+    });
+  }
+
+  // Get a file from a key
+  get(key, callback, skipExpire) {
+    this.client.get(key, (error, data) => {
+      const value = error ? false : data;
+
+      callback(value);
+
+      // Update the key so that the expiration is pushed forward
+      if (value && !skipExpire) {
+        this.set(key, data, (updateSucceeded) => {
+          if (!updateSucceeded) {
+            winston.error('failed to update expiration on GET', {key});
+          }
+        }, skipExpire);
+      }
+    });
+  }
+
+}
 
 module.exports = MemcachedDocumentStore;

lib/document_stores/mongo.js

@@ -0,0 +1,88 @@
+
+
+var MongoClient = require('mongodb').MongoClient,
+    winston = require('winston');
+
+var MongoDocumentStore = function (options) {
+    this.expire = options.expire;
+    this.connectionUrl = process.env.DATABASE_URl || options.connectionUrl;
+};
+
+MongoDocumentStore.prototype.set = function (key, data, callback, skipExpire) {
+    var now = Math.floor(new Date().getTime() / 1000),
+        that = this;
+
+    this.safeConnect(function (err, db) {
+        if (err)
+            return callback(false);
+        
+        db.collection('entries').update({
+            'entry_id': key,
+            $or: [
+                { expiration: -1 },
+                { expiration: { $gt: now } }
+            ]
+        }, {
+            'entry_id': key,
+            'value': data,
+            'expiration': that.expire && !skipExpire ? that.expire + now : -1
+        }, {
+            upsert: true
+        }, function (err, existing) {
+            if (err) {
+                winston.error('error persisting value to mongodb', { error: err });
+                return callback(false);
+            }
+
+            callback(true);
+        });
+    });
+};
+
+MongoDocumentStore.prototype.get = function (key, callback, skipExpire) {
+    var now = Math.floor(new Date().getTime() / 1000),
+        that = this;
+
+    this.safeConnect(function (err, db) {
+        if (err)
+            return callback(false);
+        
+        db.collection('entries').findOne({
+            'entry_id': key,
+            $or: [
+                { expiration: -1 },
+                { expiration: { $gt: now } }
+            ]
+        }, function (err, entry) {
+            if (err) {
+                winston.error('error persisting value to mongodb', { error: err });
+                return callback(false);
+            }
+
+            callback(entry === null ? false : entry.value);
+
+            if (entry !== null && entry.expiration !== -1 && that.expire && !skipExpire) {
+                db.collection('entries').update({
+                    'entry_id': key
+                }, {
+                    $set: {
+                        'expiration': that.expire + now
+                    }
+                }, function (err, result) { });
+            }
+        });
+    });
+};
+
+MongoDocumentStore.prototype.safeConnect = function (callback) {
+    MongoClient.connect(this.connectionUrl, function (err, db) {
+        if (err) {
+            winston.error('error connecting to mongodb', { error: err });
+            callback(err);
+        } else {
+            callback(undefined, db);
+        }
+    });
+};
+
+module.exports = MongoDocumentStore;

lib/document_stores/postgres.js

@@ -0,0 +1,80 @@
+/*global require,module,process*/
+
+var winston = require('winston');
+const {Pool} = require('pg');
+
+// create table entries (id serial primary key, key varchar(255) not null, value text not null, expiration int, unique(key));
+
+// A postgres document store
+var PostgresDocumentStore = function (options) {
+  this.expireJS = parseInt(options.expire, 10);
+
+  const connectionString = process.env.DATABASE_URL || options.connectionUrl;
+  this.pool = new Pool({connectionString});
+};
+
+PostgresDocumentStore.prototype = {
+
+  // Set a given key
+  set: function (key, data, callback, skipExpire) {
+    var now = Math.floor(new Date().getTime() / 1000);
+    var that = this;
+    this.safeConnect(function (err, client, done) {
+      if (err) { return callback(false); }
+      client.query('INSERT INTO entries (key, value, expiration) VALUES ($1, $2, $3)', [
+        key,
+        data,
+        that.expireJS && !skipExpire ? that.expireJS + now : null
+      ], function (err) {
+        if (err) {
+          winston.error('error persisting value to postgres', { error: err });
+          return callback(false);
+        }
+        callback(true);
+        done();
+      });
+    });
+  },
+
+  // Get a given key's data
+  get: function (key, callback, skipExpire) {
+    var now = Math.floor(new Date().getTime() / 1000);
+    var that = this;
+    this.safeConnect(function (err, client, done) {
+      if (err) { return callback(false); }
+      client.query('SELECT id,value,expiration from entries where KEY = $1 and (expiration IS NULL or expiration > $2)', [key, now], function (err, result) {
+        if (err) {
+          winston.error('error retrieving value from postgres', { error: err });
+          return callback(false);
+        }
+        callback(result.rows.length ? result.rows[0].value : false);
+        if (result.rows.length && that.expireJS && !skipExpire) {
+          client.query('UPDATE entries SET expiration = $1 WHERE ID = $2', [
+            that.expireJS + now,
+            result.rows[0].id
+          ], function (err) {
+            if (!err) {
+              done();
+            }
+          });
+        } else {
+          done();
+        }
+      });
+    });
+  },
+
+  // A connection wrapper
+  safeConnect: function (callback) {
+    this.pool.connect((error, client, done) => {
+      if (error) {
+        winston.error('error connecting to postgres', {error});
+        callback(error);
+      } else {
+        callback(undefined, client, done);
+      }
+    });
+  }
+};
+
+module.exports = PostgresDocumentStore;

lib/document_stores/redis.js

@@ -8,9 +8,13 @@ var winston = require('winston');
 // options[db] - The db to use (default 0)
 // options[expire] - The time to live for each key set (default never)
 
-var RedisDocumentStore = function(options) {
+var RedisDocumentStore = function(options, client) {
   this.expire = options.expire;
-  if (!RedisDocumentStore.client) {
+  if (client) {
+    winston.info('using predefined redis client');
+    RedisDocumentStore.client = client;
+  } else if (!RedisDocumentStore.client) {
+    winston.info('configuring redis');
     RedisDocumentStore.connect(options);
   }
 };
@@ -21,11 +25,20 @@ RedisDocumentStore.connect = function(options) {
   var port = options.port || 6379;
   var index = options.db || 0;
   RedisDocumentStore.client = redis.createClient(port, host);
-  RedisDocumentStore.client.select(index, function(err, reply) {
+  // authenticate if password is provided
+  if (options.password) {
+    RedisDocumentStore.client.auth(options.password);
+  }
+
+  RedisDocumentStore.client.on('error', function(err) {
+    winston.error('redis disconnected', err);
+  });
+
+  RedisDocumentStore.client.select(index, function(err) {
     if (err) {
       winston.error(
         'error connecting to redis index ' + index,
-        { error: err.message }
+        { error: err }
       );
       process.exit(1);
     }
@@ -38,7 +51,7 @@ RedisDocumentStore.connect = function(options) {
 // Save file in a key
 RedisDocumentStore.prototype.set = function(key, data, callback, skipExpire) {
   var _this = this;
-  RedisDocumentStore.client.set(key, data, function(err, reply) {
+  RedisDocumentStore.client.set(key, data, function(err) {
     if (err) {
       callback(false);
     }
@@ -54,7 +67,7 @@ RedisDocumentStore.prototype.set = function(key, data, callback, skipExpire) {
 // Expire a key in expire time if set
 RedisDocumentStore.prototype.setExpiration = function(key) {
   if (this.expire) {
-    RedisDocumentStore.client.expire(key, this.expire, function(err, reply) {
+    RedisDocumentStore.client.expire(key, this.expire, function(err) {
       if (err) {
         winston.error('failed to set expiry on key: ' + key);
       }

lib/document_stores/rethinkdb.js

@@ -0,0 +1,46 @@
+const crypto = require('crypto');
+const rethink = require('rethinkdbdash');
+const winston = require('winston');
+
+const md5 = (str) => {
+  const md5sum = crypto.createHash('md5');
+  md5sum.update(str);
+  return md5sum.digest('hex');
+};
+
+class RethinkDBStore {
+  constructor(options) {
+    this.client = rethink({
+      silent: true,
+      host: options.host || '127.0.0.1',
+      port: options.port || 28015,
+      db: options.db || 'haste',
+      user: options.user || 'admin',
+      password: options.password || ''
+    });
+  }
+
+  set(key, data, callback) {
+    this.client.table('uploads').insert({ id: md5(key), data: data }).run((error) => {
+      if (error) {
+        callback(false);
+        winston.error('failed to insert to table', error);
+        return;
+      }
+      callback(true);
+    });
+  }
+
+  get(key, callback) {
+    this.client.table('uploads').get(md5(key)).run((error, result) => {
+      if (error || !result) {
+        callback(false);
+        if (error) winston.error('failed to insert to table', error);
+        return;
+      }
+      callback(result.data);
+    });
+  }
+}
+
+module.exports = RethinkDBStore;

lib/key_generators/dictionary.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+
+module.exports = class DictionaryGenerator {
+
+  constructor(options, readyCallback) {
+    // Check options format
+    if (!options)      throw Error('No options passed to generator');
+    if (!options.path) throw Error('No dictionary path specified in options');
+
+    // Load dictionary
+    fs.readFile(options.path, 'utf8', (err, data) => {
+      if (err) throw err;
+
+      this.dictionary = data.split(/[\n\r]+/);
+
+      if (readyCallback) readyCallback();
+    });
+  }
+
+  // Generates a dictionary-based key, of keyLength words
+  createKey(keyLength) {
+    let text = '';
+
+    for (let i = 0; i < keyLength; i++) {
+      const index = Math.floor(Math.random() * this.dictionary.length);
+      text += this.dictionary[index];
+    }
+
+    return text;
+  }
+
+};

lib/key_generators/phonetic.js

@@ -1,32 +1,27 @@
 // Draws inspiration from pwgen and http://tools.arantius.com/password
-var PhoneticKeyGenerator = function(options) {
-  // No options
-};
 
-// Generate a phonetic key
-PhoneticKeyGenerator.prototype.createKey = function(keyLength) {
-  var text = '';
-  for (var i = 0; i < keyLength; i++) {
-    text += (i % 2 == 0) ? this.randConsonant() : this.randVowel();
-  }
-  return text;
+const randOf = (collection) => {
+  return () => {
+    return collection[Math.floor(Math.random() * collection.length)];
+  };
 };
 
-PhoneticKeyGenerator.consonants = 'bcdfghjklmnpqrstvwxy';
-PhoneticKeyGenerator.vowels = 'aeiou';
+// Helper methods to get an random vowel or consonant
+const randVowel = randOf('aeiou');
+const randConsonant = randOf('bcdfghjklmnpqrstvwxyz');
 
-// Get an random vowel
-PhoneticKeyGenerator.prototype.randVowel = function() {
-  return PhoneticKeyGenerator.vowels[
-    Math.floor(Math.random() * PhoneticKeyGenerator.vowels.length)
-  ];
-};
+module.exports = class PhoneticKeyGenerator {
 
-// Get an random consonant
-PhoneticKeyGenerator.prototype.randConsonant = function() {
-  return PhoneticKeyGenerator.consonants[
-    Math.floor(Math.random() * PhoneticKeyGenerator.consonants.length)
-  ];
-};
+  // Generate a phonetic key of alternating consonant & vowel
+  createKey(keyLength) {
+    let text = '';
+    const start = Math.round(Math.random());
 
-module.exports = PhoneticKeyGenerator;
+    for (let i = 0; i < keyLength; i++) {
+      text += (i % 2 == start) ? randConsonant() : randVowel();
+    }
+
+    return text;
+  }
+
+};

lib/key_generators/random.js

@@ -1,19 +1,20 @@
-var RandomKeyGenerator = function(options) {
-  if (!options) {
-    options = {};
+module.exports = class RandomKeyGenerator {
+
+  // Initialize a new generator with the given keySpace
+  constructor(options = {}) {
+    this.keyspace = options.keyspace || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
   }
-  this.keyspace = options.keyspace || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-};
 
-// Generate a random key
-RandomKeyGenerator.prototype.createKey = function(keyLength) {
-  var text = '';
-  var index;
-  for (var i = 0; i < keyLength; i++) {
-    index = Math.floor(Math.random() * this.keyspace.length);
-    text += this.keyspace.charAt(index);
+  // Generate a key of the given length
+  createKey(keyLength) {
+    var text = '';
+
+    for (var i = 0; i < keyLength; i++) {
+      const index = Math.floor(Math.random() * this.keyspace.length);
+      text += this.keyspace.charAt(index);
+    }
+
+    return text;
   }
-  return text;
-};
 
-module.exports = RandomKeyGenerator;
+};

node_modules/.bin/_mocha

@@ -1 +0,0 @@
-../mocha/bin/_mocha

node_modules/.bin/mocha

@@ -1 +0,0 @@
-../mocha/bin/mocha

node_modules/.bin/uglifyjs

@@ -1 +0,0 @@
-../uglify-js/bin/uglifyjs

node_modules/connect/.npmignore

@@ -1,11 +0,0 @@
-*.markdown
-*.md
-.git*
-Makefile
-benchmarks/
-docs/
-examples/
-install.sh
-support/
-test/
-.DS_Store

node_modules/connect/LICENSE

@@ -1,24 +0,0 @@
-(The MIT License)
-
-Copyright (c) 2010 Sencha Inc.
-Copyright (c) 2011 LearnBoost
-Copyright (c) 2011 TJ Holowaychuk
-
-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/index.js

@@ -1,2 +0,0 @@
-
-module.exports = require('./lib/connect');

node_modules/connect/lib/cache.js

@@ -1,81 +0,0 @@
-
-/*!
- * Connect - Cache
- * Copyright(c) 2011 Sencha Inc.
- * MIT Licensed
- */
-
-/**
- * Expose `Cache`.
- */
-
-module.exports = Cache;
-
-/**
- * LRU cache store.
- *
- * @param {Number} limit
- * @api private
- */
-
-function Cache(limit) {
-  this.store = {};
-  this.keys = [];
-  this.limit = limit;
-}
-
-/**
- * Touch `key`, promoting the object.
- *
- * @param {String} key
- * @param {Number} i
- * @api private
- */
-
-Cache.prototype.touch = function(key, i){
-  this.keys.splice(i,1);
-  this.keys.push(key);
-};
-
-/**
- * Remove `key`.
- *
- * @param {String} key
- * @api private
- */
-
-Cache.prototype.remove = function(key){
-  delete this.store[key];
-};
-
-/**
- * Get the object stored for `key`.
- *
- * @param {String} key
- * @return {Array}
- * @api private
- */
-
-Cache.prototype.get = function(key){
-  return this.store[key];
-};
-
-/**
- * Add a cache `key`.
- *
- * @param {String} key
- * @return {Array}
- * @api private
- */
-
-Cache.prototype.add = function(key){
-  // initialize store
-  var len = this.keys.push(key);
-
-  // limit reached, invalid LRU
-  if (len > this.limit) this.remove(this.keys.shift());
-
-  var arr = this.store[key] = [];
-  arr.createdAt = new Date;
-  return arr;
-};

node_modules/connect/lib/connect.js

@@ -1,106 +0,0 @@
-
-/*!
- * Connect
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var HTTPServer = require('./http').Server
-  , HTTPSServer = require('./https').Server
-  , fs = require('fs');
-
-// node patches
-
-require('./patch');
-
-// expose createServer() as the module
-
-exports = module.exports = createServer;
-
-/**
- * Framework version.
- */
-
-exports.version = '1.8.5';
-
-/**
- * Initialize a new `connect.HTTPServer` with the middleware
- * passed to this function. When an object is passed _first_,
- * we assume these are the tls options, and return a `connect.HTTPSServer`.
- *
- * Examples:
- *
- * An example HTTP server, accepting several middleware.
- *
- *     var server = connect.createServer(
- *         connect.logger()
- *       , connect.static(__dirname + '/public')
- *     );
- *
- * An HTTPS server, utilizing the same middleware as above.
- *
- *     var server = connect.createServer(
- *         { key: key, cert: cert }
- *       , connect.logger()
- *       , connect.static(__dirname + '/public')
- *     );
- *
- * Alternatively with connect 1.0 we may omit `createServer()`.
- *
- *     connect(
- *         connect.logger()
- *       , connect.static(__dirname + '/public')
- *     ).listen(3000);
- *
- * @param  {Object|Function} ...
- * @return {Server}
- * @api public
- */
-
-function createServer() {
-  if ('object' == typeof arguments[0]) {
-    return new HTTPSServer(arguments[0], Array.prototype.slice.call(arguments, 1));
-  } else {
-    return new HTTPServer(Array.prototype.slice.call(arguments));
-  }
-};
-
-// support connect.createServer()
-
-exports.createServer = createServer;
-
-// auto-load getters
-
-exports.middleware = {};
-
-/**
- * Auto-load bundled middleware with getters.
- */
-
-fs.readdirSync(__dirname + '/middleware').forEach(function(filename){
-  if (/\.js$/.test(filename)) {
-    var name = filename.substr(0, filename.lastIndexOf('.'));
-    exports.middleware.__defineGetter__(name, function(){
-      return require('./middleware/' + name);
-    });
-  }
-});
-
-// expose utils
-
-exports.utils = require('./utils');
-
-// expose getters as first-class exports
-
-exports.utils.merge(exports, exports.middleware);
-
-// expose constructors
-
-exports.HTTPServer = HTTPServer;
-exports.HTTPSServer = HTTPSServer;
-

node_modules/connect/lib/http.js

@@ -1,217 +0,0 @@
-
-/*!
- * Connect - HTTPServer
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var http = require('http')
-  , parse = require('url').parse
-  , assert = require('assert');
-
-// environment
-
-var env = process.env.NODE_ENV || 'development';
-
-/**
- * Initialize a new `Server` with the given `middleware`.
- *
- * Examples:
- *
- *     var server = connect.createServer(
- *         connect.favicon()
- *       , connect.logger()
- *       , connect.static(__dirname + '/public')
- *     );
- *
- * @params {Array} middleware 
- * @return {Server}
- * @api public
- */
-
-var Server = exports.Server = function HTTPServer(middleware) {
-  this.stack = [];
-  middleware.forEach(function(fn){
-    this.use(fn);
-  }, this);
-  http.Server.call(this, this.handle);
-};
-
-/**
- * Inherit from `http.Server.prototype`.
- */
-
-Server.prototype.__proto__ = http.Server.prototype;
-
-/**
- * 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_.
- *
- * This is effectively the same as passing middleware to `connect.createServer()`,
- * however provides a progressive api.
- *
- * Examples:
- *
- *      var server = connect.createServer();
- *      server.use(connect.favicon());
- *      server.use(connect.logger());
- *      server.use(connect.static(__dirname + '/public'));
- *
- * If we wanted to prefix static files with _/public_, we could
- * "mount" the `static()` middleware:
- *
- *      server.use('/public', connect.static(__dirname + '/public'));
- *
- * This api is chainable, meaning the following is valid:
- *
- *      connect.createServer()
- *        .use(connect.favicon())
- *        .use(connect.logger())
- *        .use(connect.static(__dirname + '/public'))
- *        .listen(3000);
- *
- * @param {String|Function} route or handle
- * @param {Function} handle
- * @return {Server}
- * @api public
- */
-
-Server.prototype.use = function(route, handle){
-  this.route = '/';
-
-  // default route to '/'
-  if ('string' != typeof route) {
-    handle = route;
-    route = '/';
-  }
-
-  // wrap sub-apps
-  if ('function' == typeof handle.handle) {
-    var server = handle;
-    server.route = route;
-    handle = function(req, res, next) {
-      server.handle(req, res, next);
-    };
-  }
-
-  // wrap vanilla http.Servers
-  if (handle instanceof http.Server) {
-    handle = handle.listeners('request')[0];
-  }
-
-  // normalize route to not trail with slash
-  if ('/' == route[route.length - 1]) {
-    route = route.substr(0, route.length - 1);
-  }
-
-  // add the middleware
-  this.stack.push({ route: route, handle: handle });
-
-  // allow chaining
-  return this;
-};
-
-/**
- * Handle server requests, punting them down
- * the middleware stack.
- *
- * @api private
- */
-
-Server.prototype.handle = function(req, res, out) {
-  var writeHead = res.writeHead
-    , stack = this.stack
-    , removed = ''
-    , index = 0;
-
-  function next(err) {
-    var layer, path, c;
-    req.url = removed + req.url;
-    req.originalUrl = req.originalUrl || req.url;
-    removed = '';
-
-    layer = stack[index++];
-
-    // all done
-    if (!layer || res.headerSent) {
-      // but wait! we have a parent
-      if (out) return out(err);
-
-      // error
-      if (err) {
-        var msg = 'production' == env
-          ? 'Internal Server Error'
-          : err.stack || err.toString();
-
-        // output to stderr in a non-test env
-        if ('test' != env) console.error(err.stack || err.toString());
-
-        // unable to respond
-        if (res.headerSent) return req.socket.destroy();
-
-        res.statusCode = 500;
-        res.setHeader('Content-Type', 'text/plain');
-        if ('HEAD' == req.method) return res.end();
-        res.end(msg);
-      } else {
-        res.statusCode = 404;
-        res.setHeader('Content-Type', 'text/plain');
-        if ('HEAD' == req.method) return res.end();
-        res.end('Cannot ' + req.method + ' ' + req.url);
-      }
-      return;
-    }
-
-    try {
-      path = parse(req.url).pathname;
-      if (undefined == path) path = '/';
-
-      // skip this layer if the route doesn't match.
-      if (0 != path.indexOf(layer.route)) return next(err);
-
-      c = path[layer.route.length];
-      if (c && '/' != c && '.' != c) return next(err);
-
-      // Call the layer handler
-      // Trim off the part of the url that matches the route
-      removed = layer.route;
-      req.url = req.url.substr(removed.length);
-
-      // Ensure leading slash
-      if ('/' != req.url[0]) req.url = '/' + req.url;
-
-      var arity = layer.handle.length;
-      if (err) {
-        if (arity === 4) {
-          layer.handle(err, req, res, next);
-        } else {
-          next(err);
-        }
-      } else if (arity < 4) {
-        layer.handle(req, res, next);
-      } else {
-        next();
-      }
-    } catch (e) {
-      if (e instanceof assert.AssertionError) {
-        console.error(e.stack + '\n');
-        next(e);
-      } else {
-        next(e);
-      }
-    }
-  }
-  next();
-};

node_modules/connect/lib/https.js

@@ -1,47 +0,0 @@
-
-/*!
- * Connect - HTTPServer
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var HTTPServer = require('./http').Server
-  , https = require('https');
-
-/**
- * Initialize a new `Server` with the given
- *`options` and `middleware`. The HTTPS api
- * is identical to the [HTTP](http.html) server,
- * however TLS `options` must be provided before
- * passing in the optional middleware.
- *
- * @params {Object} options
- * @params {Array} middleawre
- * @return {Server}
- * @api public
- */
-
-var Server = exports.Server = function HTTPSServer(options, middleware) {
-  this.stack = [];
-  middleware.forEach(function(fn){
-    this.use(fn);
-  }, this);
-  https.Server.call(this, options, this.handle);
-};
-
-/**
- * Inherit from `http.Server.prototype`.
- */
-
-Server.prototype.__proto__ = https.Server.prototype;
-
-// mixin HTTPServer methods
-
-Object.keys(HTTPServer.prototype).forEach(function(method){
-  Server.prototype[method] = HTTPServer.prototype[method];
-});

node_modules/connect/lib/index.js

@@ -1,46 +0,0 @@
-
-/**
- * # Connect
- *
- * Connect is a middleware framework for node,
- * shipping with over 11 bundled middleware and a rich choice of
- * [3rd-party middleware](https://github.com/senchalabs/connect/wiki).
- *
- * Installation:
- * 
- *     $ npm install connect
- * 
- * API:
- *
- *  - [connect](connect.html) general
- *  - [http](http.html) http server
- *  - [https](https.html) https server
- *
- * Middleware:
- *
- *  - [logger](middleware-logger.html) request logger with custom format support
- *  - [csrf](middleware-csrf.html) Cross-site request forgery protection
- *  - [basicAuth](middleware-basicAuth.html) basic http authentication
- *  - [bodyParser](middleware-bodyParser.html) extensible request body parser
- *  - [cookieParser](middleware-cookieParser.html) cookie parser
- *  - [session](middleware-session.html) session management support with bundled [MemoryStore](middleware-session-memory.html)
- *  - [compiler](middleware-compiler.html) static asset compiler (sass, less, coffee-script, etc)
- *  - [methodOverride](middleware-methodOverride.html) faux HTTP method support
- *  - [responseTime](middleware-responseTime.html) calculates response-time and exposes via X-Response-Time
- *  - [router](middleware-router.html) provides rich Sinatra / Express-like routing
- *  - [staticCache](middleware-staticCache.html) memory cache layer for the static() middleware
- *  - [static](middleware-static.html) streaming static file server supporting `Range` and more
- *  - [directory](middleware-directory.html) directory listing middleware
- *  - [vhost](middleware-vhost.html) virtual host sub-domain mapping middleware
- *  - [favicon](middleware-favicon.html) efficient favicon server (with default icon)
- *  - [limit](middleware-limit.html) limit the bytesize of request bodies
- *  - [profiler](middleware-profiler.html) request profiler reporting response-time, memory usage, etc
- *  - [query](middleware-query.html) automatic querystring parser, populating `req.query`
- *  - [errorHandler](middleware-errorHandler.html) flexible error handler
- *
- * Internals:
- *
- *  - connect [utilities](utils.html)
- *  - node monkey [patches](patch.html)
- *
- */

node_modules/connect/lib/middleware/basicAuth.js

@@ -1,93 +0,0 @@
-
-/*!
- * Connect - basicAuth
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var utils = require('../utils')
-  , unauthorized = utils.unauthorized
-  , badRequest = utils.badRequest;
-
-/**
- * Enfore basic authentication by providing a `callback(user, pass)`,
- * which must return `true` in order to gain access. Alternatively an async
- * method is provided as well, invoking `callback(user, pass, callback)`. Populates
- * `req.remoteUser`. The final alternative is simply passing username / password
- * strings.
- *
- * Examples:
- *
- *     connect(connect.basicAuth('username', 'password'));
- *
- *     connect(
- *       connect.basicAuth(function(user, pass){
- *         return 'tj' == user & 'wahoo' == pass;
- *       })
- *     );
- *
- *     connect(
- *       connect.basicAuth(function(user, pass, fn){
- *         User.authenticate({ user: user, pass: pass }, fn);
- *       })
- *     );
- *
- * @param {Function|String} callback or username
- * @param {String} realm
- * @api public
- */
-
-module.exports = function basicAuth(callback, realm) {
-  var username, password;
-
-  // user / pass strings
-  if ('string' == typeof callback) {
-    username = callback;
-    password = realm;
-    if ('string' != typeof password) throw new Error('password argument required');
-    realm = arguments[2];
-    callback = function(user, pass){
-      return user == username && pass == password;
-    }
-  }
-
-  realm = realm || 'Authorization Required';
-
-  return function(req, res, next) {
-    var authorization = req.headers.authorization;
-
-    if (req.remoteUser) return next();
-    if (!authorization) return unauthorized(res, realm);
-
-    var parts = authorization.split(' ')
-      , scheme = parts[0]
-      , credentials = new Buffer(parts[1], 'base64').toString().split(':');
-
-    if ('Basic' != scheme) return badRequest(res);
-
-    // async
-    if (callback.length >= 3) {
-      var pause = utils.pause(req);
-      callback(credentials[0], credentials[1], function(err, user){
-        if (err || !user)  return unauthorized(res, realm);
-        req.remoteUser = user;
-        next();
-        pause.resume();
-      });
-    // sync
-    } else {
-      if (callback(credentials[0], credentials[1])) {
-        req.remoteUser = credentials[0];
-        next();
-      } else {
-        unauthorized(res, realm);
-      }
-    }
-  }
-};
-

node_modules/connect/lib/middleware/bodyParser.js

@@ -1,196 +0,0 @@
-
-/*!
- * Connect - bodyParser
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var qs = require('qs')
-  , formidable = require('formidable');
-
-/**
- * Extract the mime type from the given request's
- * _Content-Type_ header.
- *
- * @param  {IncomingMessage} req
- * @return {String}
- * @api private
- */
-
-function mime(req) {
-  var str = req.headers['content-type'] || '';
-  return str.split(';')[0];
-}
-
-/**
- * Parse request bodies.
- *
- * By default _application/json_, _application/x-www-form-urlencoded_,
- * and _multipart/form-data_ are supported, however you may map `connect.bodyParser.parse[contentType]`
- * to a function receiving `(req, options, callback)`.
- *
- * Examples:
- *
- *      connect.createServer(
- *          connect.bodyParser()
- *        , function(req, res) {
- *          res.end('viewing user ' + req.body.user.name);
- *        }
- *      );
- *
- *      $ curl -d 'user[name]=tj' http://localhost/
- *      $ curl -d '{"user":{"name":"tj"}}' -H "Content-Type: application/json" http://localhost/
- *
- * Multipart req.files:
- *
- *   As a security measure files are stored in a separate object, stored
- *   as `req.files`. This prevents attacks that may potentially alter
- *   filenames, and depending on the application gain access to restricted files.
- *
- * Multipart configuration:
- *
- *  The `options` passed are provided to each parser function.
- *  The _multipart/form-data_ parser merges these with formidable's
- *  IncomingForm object, allowing you to tweak the upload directory,
- *  size limits, etc. For example you may wish to retain the file extension
- *  and change the upload directory:
- *
- *      server.use(bodyParser({ uploadDir: '/www/mysite.com/uploads' }));
- *
- *  View [node-formidable](https://github.com/felixge/node-formidable) for more information.
- *
- *  If you wish to use formidable directly within your app, and do not
- *  desire this behaviour for multipart requests simply remove the
- *  parser: 
- *
- *     delete connect.bodyParser.parse['multipart/form-data'];
- *
- *  Or
- *
- *     delete express.bodyParser.parse['multipart/form-data'];
- *
- * @param {Object} options
- * @return {Function}
- * @api public
- */
-
-exports = module.exports = function bodyParser(options){
-  options = options || {};
-  return function bodyParser(req, res, next) {
-    if (req.body) return next();
-    req.body = {};
-
-    if ('GET' == req.method || 'HEAD' == req.method) return next();
-    var parser = exports.parse[mime(req)];
-    if (parser) {
-      parser(req, options, next);
-    } else {
-      next();
-    }
-  }
-};
-
-/**
- * Parsers.
- */
-
-exports.parse = {};
-
-/**
- * Parse application/x-www-form-urlencoded.
- */
-
-exports.parse['application/x-www-form-urlencoded'] = function(req, options, fn){
-  var buf = '';
-  req.setEncoding('utf8');
-  req.on('data', function(chunk){ buf += chunk });
-  req.on('end', function(){
-    try {
-      req.body = buf.length
-        ? qs.parse(buf)
-        : {};
-      fn();
-    } catch (err){
-      fn(err);
-    }
-  });
-};
-
-/**
- * Parse application/json.
- */
-
-exports.parse['application/json'] = function(req, options, fn){
-  var buf = '';
-  req.setEncoding('utf8');
-  req.on('data', function(chunk){ buf += chunk });
-  req.on('end', function(){
-    try {
-      req.body = buf.length
-        ? JSON.parse(buf)
-        : {};
-      fn();
-    } catch (err){
-      fn(err);
-    }
-  });
-};
-
-/**
- * Parse multipart/form-data.
- *
- * TODO: make multiple support optional
- * TODO: revisit "error" flag if it's a formidable bug
- */
-
-exports.parse['multipart/form-data'] = function(req, options, fn){
-  var form = new formidable.IncomingForm
-    , data = {}
-    , files = {}
-    , done;
-
-  Object.keys(options).forEach(function(key){
-    form[key] = options[key];
-  });
-
-  function ondata(name, val, data){
-    if (Array.isArray(data[name])) {
-      data[name].push(val);
-    } else if (data[name]) {
-      data[name] = [data[name], val];
-    } else {
-      data[name] = val;
-    }
-  }
-
-  form.on('field', function(name, val){
-    ondata(name, val, data);
-  });
-
-  form.on('file', function(name, val){
-    ondata(name, val, files);
-  });
-
-  form.on('error', function(err){
-    fn(err);
-    done = true;
-  });
-
-  form.on('end', function(){
-    if (done) return;
-    try {
-      req.body = qs.parse(data);
-      req.files = qs.parse(files);
-      fn();
-    } catch (err) {
-      fn(err);
-    }
-  });
-
-  form.parse(req);
-};

node_modules/connect/lib/middleware/compiler.js

@@ -1,163 +0,0 @@
-
-/*!
- * Connect - compiler
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var fs = require('fs')
-  , path = require('path')
-  , parse = require('url').parse;
-
-/**
- * Require cache.
- */
-
-var cache = {};
-
-/**
- * Setup compiler.
- *
- * Options:
- *
- *   - `src`     Source directory, defaults to **CWD**.
- *   - `dest`    Destination directory, defaults `src`.
- *   - `enable`  Array of enabled compilers.
- *
- * Compilers:
- *
- *   - `sass`   Compiles sass to css
- *   - `less`   Compiles less to css
- *   - `coffeescript`   Compiles coffee to js
- *
- * @param {Object} options
- * @api public
- */
-
-exports = module.exports = function compiler(options){
-  options = options || {};
-
-  var srcDir = options.src || process.cwd()
-    , destDir = options.dest || srcDir
-    , enable = options.enable;
-
-  if (!enable || enable.length === 0) {
-    throw new Error('compiler\'s "enable" option is not set, nothing will be compiled.');
-  }
-
-  return function compiler(req, res, next){
-    if ('GET' != req.method) return next();
-    var pathname = parse(req.url).pathname;
-    for (var i = 0, len = enable.length; i < len; ++i) {
-      var name = enable[i]
-        , compiler = compilers[name];
-      if (compiler.match.test(pathname)) {
-        var src = (srcDir + pathname).replace(compiler.match, compiler.ext)
-          , dest = destDir + pathname;
-
-        // Compare mtimes
-        fs.stat(src, function(err, srcStats){
-          if (err) {
-            if ('ENOENT' == err.code) {
-              next();
-            } else {
-              next(err);
-            }
-          } else {
-            fs.stat(dest, function(err, destStats){
-              if (err) {
-                // Oh snap! it does not exist, compile it
-                if ('ENOENT' == err.code) {
-                  compile();
-                } else {
-                  next(err);
-                }
-              } else {
-                // Source has changed, compile it
-                if (srcStats.mtime > destStats.mtime) {
-                  compile();
-                } else {
-                  // Defer file serving
-                  next();
-                }
-              }
-            });
-          }
-        });
-
-        // Compile to the destination
-        function compile() {
-          fs.readFile(src, 'utf8', function(err, str){
-            if (err) {
-              next(err);
-            } else {
-              compiler.compile(str, function(err, str){
-                if (err) {
-                  next(err);
-                } else {
-                  fs.writeFile(dest, str, 'utf8', function(err){
-                    next(err);
-                  });
-                }
-              });
-            }
-          });
-        }
-        return;
-      }
-    }
-    next();
-  };
-};
-
-/**
- * Bundled compilers:
- *
- *  - [sass](http://github.com/visionmedia/sass.js) to _css_
- *  - [less](http://github.com/cloudhead/less.js) to _css_
- *  - [coffee](http://github.com/jashkenas/coffee-script) to _js_
- */
-
-var compilers = exports.compilers = {
-  sass: {
-    match: /\.css$/,
-    ext: '.sass',
-    compile: function(str, fn){
-      var sass = cache.sass || (cache.sass = require('sass'));
-      try {
-        fn(null, sass.render(str));
-      } catch (err) {
-        fn(err);
-      }
-    }
-  },
-  less: {
-    match: /\.css$/,
-    ext: '.less',
-    compile: function(str, fn){
-      var less = cache.less || (cache.less = require('less'));
-      try {
-        less.render(str, fn);
-      } catch (err) {
-        fn(err);
-      }
-    }
-  },
-  coffeescript: {
-    match: /\.js$/,
-    ext: '.coffee',
-    compile: function(str, fn){
-      var coffee = cache.coffee || (cache.coffee = require('coffee-script'));
-      try {
-        fn(null, coffee.compile(str));
-      } catch (err) {
-        fn(err);
-      }
-    }
-  }
-};

node_modules/connect/lib/middleware/cookieParser.js

@@ -1,46 +0,0 @@
-
-/*!
- * Connect - cookieParser
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var utils = require('./../utils');
-
-/**
- * Parse _Cookie_ header and populate `req.cookies`
- * with an object keyed by the cookie names.
- *
- * Examples:
- *
- *     connect.createServer(
- *         connect.cookieParser()
- *       , function(req, res, next){
- *         res.end(JSON.stringify(req.cookies));
- *       }
- *     );
- *
- * @return {Function}
- * @api public
- */
-
-module.exports = function cookieParser(){
-  return function cookieParser(req, res, next) {
-    var cookie = req.headers.cookie;
-    if (req.cookies) return next();
-    req.cookies = {};
-    if (cookie) {
-      try {
-        req.cookies = utils.parseCookie(cookie);
-      } catch (err) {
-        return next(err);
-      }
-    }
-    next();
-  };
-};

node_modules/connect/lib/middleware/csrf.js

@@ -1,105 +0,0 @@
-
-/*!
- * Connect - csrf
- * Copyright(c) 2011 Sencha Inc.
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var utils = require('../utils')
-  , crypto = require('crypto');
-
-/**
- * CRSF protection middleware.
- *
- * By default this middleware generates a token named "_csrf"
- * which should be added to requests which mutate
- * state, within a hidden form field, query-string etc. This
- * token is validated against the visitor's `req.session._csrf`
- * property which is re-generated per request.
- *
- * The default `value` function checks `req.body` generated
- * by the `bodyParser()` middleware, `req.query` generated
- * by `query()`, and the "X-CSRF-Token" header field.
- *
- * This middleware requires session support, thus should be added
- * somewhere _below_ `session()` and `cookieParser()`.
- *
- * Examples:
- *
- *      var form = '\n\
- *        <form action="/" method="post">\n\
- *          <input type="hidden" name="_csrf" value="{token}" />\n\
- *          <input type="text" name="user[name]" value="{user}" />\n\
- *          <input type="password" name="user[pass]" />\n\
- *          <input type="submit" value="Login" />\n\
- *        </form>\n\
- *      '; 
- *      
- *      connect(
- *          connect.cookieParser()
- *        , connect.session({ secret: 'keyboard cat' })
- *        , connect.bodyParser()
- *        , connect.csrf()
- *      
- *        , function(req, res, next){
- *          if ('POST' != req.method) return next();
- *          req.session.user = req.body.user;
- *          next();
- *        }
- *      
- *        , function(req, res){
- *          res.setHeader('Content-Type', 'text/html');
- *          var body = form
- *            .replace('{token}', req.session._csrf)
- *            .replace('{user}', req.session.user && req.session.user.name || '');
- *          res.end(body);
- *        }
- *      ).listen(3000);
- *
- * Options:
- *
- *    - `value` a function accepting the request, returning the token 
- *
- * @param {Object} options
- * @api public
- */
-
-module.exports = function csrf(options) {
-  var options = options || {}
-    , value = options.value || defaultValue;
-
-  return function(req, res, next){
-    // generate CSRF token
-    var token = req.session._csrf || (req.session._csrf = utils.uid(24));
-
-    // ignore GET (for now)
-    if ('GET' == req.method) return next();
-
-    // determine value
-    var val = value(req);
-
-    // check
-    if (val != token) return utils.forbidden(res);
-    
-    next();
-  }
-};
-
-/**
- * Default value function, checking the `req.body`
- * and `req.query` for the CSRF token.
- *
- * @param {IncomingMessage} req
- * @return {String}
- * @api private
- */
-
-function defaultValue(req) {
-  return (req.body && req.body._csrf)
-    || (req.query && req.query._csrf)
-    || (req.headers['x-csrf-token']);
-}

node_modules/connect/lib/middleware/directory.js

@@ -1,222 +0,0 @@
-
-/*!
- * Connect - directory
- * Copyright(c) 2011 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-// TODO: icon / style for directories
-// TODO: arrow key navigation
-// TODO: make icons extensible
-
-/**
- * Module dependencies.
- */
-
-var fs = require('fs')
-  , parse = require('url').parse
-  , utils = require('../utils')
-  , path = require('path')
-  , normalize = path.normalize
-  , extname = path.extname
-  , join = path.join;
-
-/**
- * Icon cache.
- */
-
-var cache = {};
-
-/**
- * Serve directory listings with the given `root` path.
- *
- * Options:
- *
- *  - `hidden` display hidden (dot) files. Defaults to false.
- *  - `icons`  display icons. Defaults to false.
- *  - `filter` Apply this filter function to files. Defaults to false.
- *
- * @param {String} root
- * @param {Object} options
- * @return {Function}
- * @api public
- */
-
-exports = module.exports = function directory(root, options){
-  options = options || {};
-
-  // root required
-  if (!root) throw new Error('directory() root path required');
-  var hidden = options.hidden
-    , icons = options.icons
-    , filter = options.filter
-    , root = normalize(root);
-
-  return function directory(req, res, next) {
-    var accept = req.headers.accept || 'text/plain'
-      , url = parse(req.url)
-      , dir = decodeURIComponent(url.pathname)
-      , path = normalize(join(root, dir))
-      , originalUrl = parse(req.originalUrl)
-      , originalDir = decodeURIComponent(originalUrl.pathname)
-      , showUp = path != root && path != root + '/';
-
-    // null byte(s)
-    if (~path.indexOf('\0')) return utils.badRequest(res);
-
-    // malicious path
-    if (0 != path.indexOf(root)) return utils.forbidden(res);
-
-    // check if we have a directory
-    fs.stat(path, function(err, stat){
-      if (err) return 'ENOENT' == err.code
-        ? next()
-        : next(err);
-
-      if (!stat.isDirectory()) return next();
-
-      // fetch files
-      fs.readdir(path, function(err, files){
-        if (err) return next(err);
-        if (!hidden) files = removeHidden(files);
-        if (filter) files = files.filter(filter);
-        files.sort();
-        // content-negotiation
-        for (var key in exports) {
-          if (~accept.indexOf(key) || ~accept.indexOf('*/*')) {
-            exports[key](req, res, files, next, originalDir, showUp, icons);
-            return;
-          }
-        }
-        utils.notAcceptable(res);
-      });
-    });
-  };
-};
-
-/**
- * Respond with text/html.
- */
-
-exports.html = function(req, res, files, next, dir, showUp, icons){
-  fs.readFile(__dirname + '/../public/directory.html', 'utf8', function(err, str){
-    if (err) return next(err);
-    fs.readFile(__dirname + '/../public/style.css', 'utf8', function(err, style){
-      if (err) return next(err);
-      if (showUp) files.unshift('..');
-      str = str
-        .replace('{style}', style)
-        .replace('{files}', html(files, dir, icons))
-        .replace('{directory}', dir)
-		.replace('{linked-path}', htmlPath(dir));
-      res.setHeader('Content-Type', 'text/html');
-      res.setHeader('Content-Length', str.length);
-      res.end(str);
-    });
-  });
-};
-
-/**
- * Respond with application/json.
- */
-
-exports.json = function(req, res, files){
-  files = JSON.stringify(files);
-  res.setHeader('Content-Type', 'application/json');
-  res.setHeader('Content-Length', files.length);
-  res.end(files);
-};
-
-/**
- * Respond with text/plain.
- */
-
-exports.plain = function(req, res, files){
-  files = files.join('\n') + '\n';
-  res.setHeader('Content-Type', 'text/plain');
-  res.setHeader('Content-Length', files.length);
-  res.end(files);
-};
-
-/**
- * Map html `dir`, returning a linked path.
- */
-
-function htmlPath(dir) {
-  var curr = [];
-  return dir.split('/').map(function(part){
-    curr.push(part);
-    return '<a href="' + curr.join('/') + '">' + part + '</a>';
-  }).join(' / ');
-}
-
-/**
- * Map html `files`, returning an html unordered list.
- */
-
-function html(files, dir, useIcons) {
-  return '<ul id="files">' + files.map(function(file){
-    var icon = ''
-      , classes = [];
-
-    if (useIcons && '..' != file) {
-      icon = icons[extname(file)] || icons.default;
-      icon = '<img src="data:image/png;base64,' + load(icon) + '" />';
-      classes.push('icon');
-    }
-
-    return '<li><a href="'
-      + join(dir, file)
-      + '" class="'
-      + classes.join(' ') + '"'
-      + ' title="' + file + '">'
-      + icon + file + '</a></li>';
-
-  }).join('\n') + '</ul>';
-}
-
-/**
- * Load and cache the given `icon`.
- *
- * @param {String} icon
- * @return {String}
- * @api private
- */
-
-function load(icon) {
-  if (cache[icon]) return cache[icon];
-  return cache[icon] = fs.readFileSync(__dirname + '/../public/icons/' + icon, 'base64');
-}
-
-/**
- * Filter "hidden" `files`, aka files
- * beginning with a `.`.
- *
- * @param {Array} files
- * @return {Array}
- * @api private
- */
-
-function removeHidden(files) {
-  return files.filter(function(file){
-    return '.' != file[0];
-  });
-}
-
-/**
- * Icon map.
- */
-
-var icons = {
-    '.js': 'page_white_code_red.png'
-  , '.c': 'page_white_c.png'
-  , '.h': 'page_white_h.png'
-  , '.cc': 'page_white_cplusplus.png'
-  , '.php': 'page_white_php.png'
-  , '.rb': 'page_white_ruby.png'
-  , '.cpp': 'page_white_cplusplus.png'
-  , '.swf': 'page_white_flash.png'
-  , '.pdf': 'page_white_acrobat.png'
-  , 'default': 'page_white.png'
-};

node_modules/connect/lib/middleware/errorHandler.js

@@ -1,100 +0,0 @@
-/*!
- * Connect - errorHandler
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var utils = require('../utils')
-  , url = require('url')
-  , fs = require('fs');
-
-/**
- * Flexible error handler, providing (_optional_) stack traces
- * and error message responses for requests accepting text, html,
- * or json.
- *
- * Options:
- *
- *   - `showStack`, `stack` respond with both the error message and stack trace. Defaults to `false`
- *   - `showMessage`, `message`, respond with the exception message only. Defaults to `false`
- *   - `dumpExceptions`, `dump`, dump exceptions to stderr (without terminating the process). Defaults to `false`
- *
- * Text:
- *
- *   By default, and when _text/plain_ is accepted a simple stack trace
- *   or error message will be returned.
- *
- * JSON:
- *
- *   When _application/json_ is accepted, connect will respond with
- *   an object in the form of `{ "error": error }`. 
- *
- * HTML:
- *
- *   When accepted connect will output a nice html stack trace.
- *
- * @param {Object} options
- * @return {Function}
- * @api public
- */
-
-exports = module.exports = function errorHandler(options){
-  options = options || {};
-
-  // defaults
-  var showStack = options.showStack || options.stack
-    , showMessage = options.showMessage || options.message
-    , dumpExceptions = options.dumpExceptions || options.dump
-    , formatUrl = options.formatUrl;
-
-  return function errorHandler(err, req, res, next){
-    res.statusCode = 500;
-    if (dumpExceptions) console.error(err.stack);
-    if (showStack) {
-      var accept = req.headers.accept || '';
-      // html
-      if (~accept.indexOf('html')) {
-        fs.readFile(__dirname + '/../public/style.css', 'utf8', function(e, style){
-          fs.readFile(__dirname + '/../public/error.html', 'utf8', function(e, html){
-            var stack = (err.stack || '')
-              .split('\n').slice(1)
-              .map(function(v){ return '<li>' + v + '</li>'; }).join('');
-              html = html
-                .replace('{style}', style)
-                .replace('{stack}', stack)
-                .replace('{title}', exports.title)
-                .replace(/\{error\}/g, utils.escape(err.toString()));
-              res.setHeader('Content-Type', 'text/html');
-              res.end(html);
-          });
-        });
-      // json
-      } else if (~accept.indexOf('json')) {
-        var json = JSON.stringify({ error: err });
-        res.setHeader('Content-Type', 'application/json');
-        res.end(json);
-      // plain text
-      } else {
-        res.writeHead(500, { 'Content-Type': 'text/plain' });
-        res.end(err.stack);
-      }
-    } else {
-      var body = showMessage
-        ? err.toString()
-        : 'Internal Server Error';
-      res.setHeader('Content-Type', 'text/plain');
-      res.end(body);
-    }
-  };
-};
-
-/**
- * Template title.
- */
-
-exports.title = 'Connect';

node_modules/connect/lib/middleware/favicon.js

@@ -1,76 +0,0 @@
-
-/*!
- * Connect - favicon
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var fs = require('fs')
-  , utils = require('../utils');
-
-/**
- * Favicon cache.
- */
-
-var icon;
-
-/**
- * By default serves the connect favicon, or the favicon
- * located by the given `path`.
- *
- * Options:
- *
- *   - `maxAge`  cache-control max-age directive, defaulting to 1 day
- *
- * Examples:
- *
- *     connect.createServer(
- *       connect.favicon()    
- *     );
- *
- *     connect.createServer(
- *       connect.favicon(__dirname + '/public/favicon.ico')    
- *     );
- *
- * @param {String} path
- * @param {Object} options
- * @return {Function}
- * @api public
- */
-
-module.exports = function favicon(path, options){
-  var options = options || {}
-    , path = path || __dirname + '/../public/favicon.ico'
-    , maxAge = options.maxAge || 86400000;
-
-  return function favicon(req, res, next){
-    if ('/favicon.ico' == req.url) {
-      if (icon) {
-        res.writeHead(200, icon.headers);
-        res.end(icon.body);
-      } else {
-        fs.readFile(path, function(err, buf){
-          if (err) return next(err);
-          icon = {
-            headers: {
-                'Content-Type': 'image/x-icon'
-              , 'Content-Length': buf.length
-              , 'ETag': '"' + utils.md5(buf) + '"'
-              , 'Cache-Control': 'public, max-age=' + (maxAge / 1000)
-            },
-            body: buf
-          };
-          res.writeHead(200, icon.headers);
-          res.end(icon.body);
-        });
-      }
-    } else {
-      next();
-    }
-  };
-};

node_modules/connect/lib/middleware/limit.js

@@ -1,82 +0,0 @@
-
-/*!
- * Connect - limit
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Limit request bodies to the given size in `bytes`.
- *
- * A string representation of the bytesize may also be passed,
- * for example "5mb", "200kb", "1gb", etc.
- *
- * Examples:
- *
- *     var server = connect(
- *       connect.limit('5.5mb')
- *     ).listen(3000);
- *
- * TODO: pause EV_READ
- *
- * @param {Number|String} bytes
- * @return {Function}
- * @api public
- */
-
-module.exports = function limit(bytes){
-  if ('string' == typeof bytes) bytes = parse(bytes);
-  if ('number' != typeof bytes) throw new Error('limit() bytes required');
-  return function limit(req, res, next){
-    var received = 0
-      , len = req.headers['content-length']
-        ? parseInt(req.headers['content-length'], 10)
-        : null;
-
-    // deny the request
-    function deny() {
-      req.destroy();
-    }
-
-    // self-awareness
-    if (req._limit) return next();
-    req._limit = true;
-
-    // limit by content-length
-    if (len && len > bytes) {
-      res.statusCode = 413;
-      res.end('Request Entity Too Large');
-      return;
-    }
-
-    // limit
-    req.on('data', function(chunk){
-      received += chunk.length;
-      if (received > bytes) deny();
-    });
-
-    next();
-  };
-};
-
-/**
- * Parse byte `size` string.
- *
- * @param {String} size
- * @return {Number}
- * @api private
- */
-
-function parse(size) {
-  var parts = size.match(/^(\d+(?:\.\d+)?) *(kb|mb|gb)$/)
-    , n = parseFloat(parts[1])
-    , type = parts[2];
-
-  var map = {
-      kb: 1024
-    , mb: 1024 * 1024
-    , gb: 1024 * 1024 * 1024
-  };
-
-  return map[type] * n;
-}

node_modules/connect/lib/middleware/logger.js

@@ -1,299 +0,0 @@
-
-/*!
- * Connect - logger
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Log buffer.
- */
-
-var buf = [];
-
-/**
- * Default log buffer duration.
- */
-
-var defaultBufferDuration = 1000;
-
-/**
- * Log requests with the given `options` or a `format` string.
- *
- * Options:
- *
- *   - `format`  Format string, see below for tokens
- *   - `stream`  Output stream, defaults to _stdout_
- *   - `buffer`  Buffer duration, defaults to 1000ms when _true_
- *   - `immediate`  Write log line on request instead of response (for response times)
- *
- * Tokens:
- *
- *   - `:req[header]` ex: `:req[Accept]`
- *   - `:res[header]` ex: `:res[Content-Length]`
- *   - `:http-version`
- *   - `:response-time`
- *   - `:remote-addr`
- *   - `:date`
- *   - `:method`
- *   - `:url`
- *   - `:referrer`
- *   - `:user-agent`
- *   - `:status`
- *
- * Formats:
- *
- *   Pre-defined formats that ship with connect:
- *
- *    - `default` ':remote-addr - - [:date] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"'
- *    - `short` ':remote-addr - :method :url HTTP/:http-version :status :res[content-length] - :response-time ms'
- *    - `tiny`  ':method :url :status :res[content-length] - :response-time ms'
- *    - `dev` concise output colored by response status for development use
- *
- * Examples:
- *
- *      connect.logger() // default
- *      connect.logger('short')
- *      connect.logger('tiny')
- *      connect.logger('dev')
- *      connect.logger(':method :url - :referrer')
- *      connect.logger(':req[content-type] -> :res[content-type]')
- *      connect.logger(function(req, res){ return 'some format string' })
- *
- * Defining Tokens:
- *
- *   To define a token, simply invoke `connect.logger.token()` with the
- *   name and a callback function. The value returned is then available
- *   as ":type" in this case.
- *
- *      connect.logger.token('type', function(req, res){ return req.headers['content-type']; })
- *
- * Defining Formats:
- *
- *   All default formats are defined this way, however it's public API as well:
- *
- *       connect.logger.format('name', 'string or function')
- *
- * @param {String|Function|Object} format or options
- * @return {Function}
- * @api public
- */
-
-exports = module.exports = function logger(options) {
-  if ('object' == typeof options) {
-    options = options || {};
-  } else if (options) {
-    options = { format: options };
-  } else {
-    options = {};
-  }
-
-  // output on request instead of response
-  var immediate = options.immediate;
-
-  // format name
-  var fmt = exports[options.format] || options.format || exports.default;
-
-  // compile format
-  if ('function' != typeof fmt) fmt = compile(fmt);
-
-  // options
-  var stream = options.stream || process.stdout
-    , buffer = options.buffer;
-
-  // buffering support
-  if (buffer) {
-    var realStream = stream
-      , interval = 'number' == typeof buffer
-        ? buffer
-        : defaultBufferDuration;
-
-    // flush interval
-    setInterval(function(){
-      if (buf.length) {
-        realStream.write(buf.join(''), 'ascii');
-        buf.length = 0;
-      }
-    }, interval); 
-
-    // swap the stream
-    stream = {
-      write: function(str){
-        buf.push(str);
-      }
-    };
-  }
-
-  return function logger(req, res, next) {
-    req._startTime = new Date;
-
-    // mount safety
-    if (req._logging) return next();
-
-    // flag as logging
-    req._logging = true;
-
-    // immediate
-    if (immediate) {
-      var line = fmt(exports, req, res);
-      if (null == line) return;
-      stream.write(line + '\n', 'ascii');
-    } else {
-      // proxy end to output loggging
-      var end = res.end;
-      res.end = function(chunk, encoding){
-        res.end = end;
-        res.end(chunk, encoding);
-        var line = fmt(exports, req, res);
-        if (null == line) return;
-        stream.write(line + '\n', 'ascii');
-      };
-    }
-
-
-    next();
-  };
-};
-
-/**
- * Compile `fmt` into a function.
- *
- * @param {String} fmt
- * @return {Function}
- * @api private
- */
-
-function compile(fmt) {
-  fmt = fmt.replace(/"/g, '\\"');
-  var js = '  return "' + fmt.replace(/:([-\w]{2,})(?:\[([^\]]+)\])?/g, function(_, name, arg){
-    return '"\n    + (tokens["' + name + '"](req, res, "' + arg + '") || "-") + "';
-  }) + '";'
-  return new Function('tokens, req, res', js);
-};
-
-/**
- * Define a token function with the given `name`,
- * and callback `fn(req, res)`.
- *
- * @param {String} name
- * @param {Function} fn
- * @return {Object} exports for chaining
- * @api public
- */
-
-exports.token = function(name, fn) {
-  exports[name] = fn;
-  return this;
-};
-
-/**
- * Define a `fmt` with the given `name`.
- *
- * @param {String} name
- * @param {String|Function} fmt
- * @return {Object} exports for chaining
- * @api public
- */
-
-exports.format = function(name, str){
-  exports[name] = str;
-  return this;
-};
-
-// default format
-
-exports.format('default', ':remote-addr - - [:date] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"');
-
-// short format
-
-exports.format('short', ':remote-addr - :method :url HTTP/:http-version :status :res[content-length] - :response-time ms');
-
-// tiny format
-
-exports.format('tiny', ':method :url :status :res[content-length] - :response-time ms');
-
-// dev (colored)
-
-exports.format('dev', function(tokens, req, res){
-  var status = res.statusCode
-    , color = 32;
-
-  if (status >= 500) color = 31
-  else if (status >= 400) color = 33
-  else if (status >= 300) color = 36;
-
-  return '\033[90m' + req.method
-    + ' ' + req.originalUrl + ' '
-    + '\033[' + color + 'm' + res.statusCode
-    + ' \033[90m'
-    + (new Date - req._startTime)
-    + 'ms\033[0m';
-});
-
-// request url
-
-exports.token('url', function(req){
-  return req.originalUrl;
-});
-
-// request method
-
-exports.token('method', function(req){
-  return req.method;
-});
-
-// response time in milliseconds
-
-exports.token('response-time', function(req){
-  return new Date - req._startTime;
-});
-
-// UTC date
-
-exports.token('date', function(){
-  return new Date().toUTCString();
-});
-
-// response status code
-
-exports.token('status', function(req, res){
-  return res.statusCode;
-});
-
-// normalized referrer
-
-exports.token('referrer', function(req){
-  return req.headers['referer'] || req.headers['referrer'];
-});
-
-// remote address
-
-exports.token('remote-addr', function(req){
-  return req.socket && (req.socket.remoteAddress || (req.socket.socket && req.socket.socket.remoteAddress));
-});
-
-// HTTP version
-
-exports.token('http-version', function(req){
-  return req.httpVersionMajor + '.' + req.httpVersionMinor;
-});
-
-// UA string
-
-exports.token('user-agent', function(req){
-  return req.headers['user-agent'];
-});
-
-// request header
-
-exports.token('req', function(req, res, field){
-  return req.headers[field.toLowerCase()];
-});
-
-// response header
-
-exports.token('res', function(req, res, field){
-  return (res._headers || {})[field.toLowerCase()];
-});
-

node_modules/connect/lib/middleware/methodOverride.js

@@ -1,38 +0,0 @@
-
-/*!
- * Connect - methodOverride
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Provides faux HTTP method support.
- * 
- * Pass an optional `key` to use when checking for
- * a method override, othewise defaults to _\_method_.
- * The original method is available via `req.originalMethod`.
- *
- * @param {String} key
- * @return {Function}
- * @api public
- */
-
-module.exports = function methodOverride(key){
-  key = key || "_method";
-  return function methodOverride(req, res, next) {
-    req.originalMethod = req.originalMethod || req.method;
-
-    // req.body
-    if (req.body && key in req.body) {
-      req.method = req.body[key].toUpperCase();
-      delete req.body[key];
-    // check X-HTTP-Method-Override
-    } else if (req.headers['x-http-method-override']) {
-      req.method = req.headers['x-http-method-override'].toUpperCase();
-    }
-    
-    next();
-  };
-};
-

node_modules/connect/lib/middleware/profiler.js

@@ -1,100 +0,0 @@
-
-/*!
- * Connect - profiler
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Profile the duration of a request.
- *
- * Typically this middleware should be utilized
- * _above_ all others, as it proxies the `res.end()`
- * method, being first allows it to encapsulate all
- * other middleware.
- *
- * Example Output:
- *
- *      GET /
- *      response time 2ms
- *      memory rss 52.00kb
- *      memory vsize 2.07mb
- *      heap before 3.76mb / 8.15mb
- *      heap after 3.80mb / 8.15mb
- *
- * @api public
- */
-
-module.exports = function profiler(){
-  return function(req, res, next){
-    var end = res.end
-      , start = snapshot();
-
-    // state snapshot
-    function snapshot() {
-      return {
-          mem: process.memoryUsage()
-        , time: new Date
-      };
-    }
-
-    // proxy res.end()
-    res.end = function(data, encoding){
-      res.end = end;
-      res.end(data, encoding);
-      compare(req, start, snapshot())
-    };
-
-    next();
-  }
-};
-
-/**
- * Compare `start` / `end` snapshots.
- *
- * @param {IncomingRequest} req
- * @param {Object} start
- * @param {Object} end
- * @api private
- */
-
-function compare(req, start, end) {
-  console.log();
-  row(req.method, req.url);
-  row('response time:', (end.time - start.time) + 'ms');
-  row('memory rss:', formatBytes(end.mem.rss - start.mem.rss));
-  row('memory vsize:', formatBytes(end.mem.vsize - start.mem.vsize));
-  row('heap before:', formatBytes(start.mem.heapUsed) + ' / ' + formatBytes(start.mem.heapTotal));
-  row('heap after:', formatBytes(end.mem.heapUsed) + ' / ' + formatBytes(end.mem.heapTotal));
-  console.log();
-}
-
-/**
- * Row helper
- *
- * @param {String} key
- * @param {String} val
- * @api private
- */
-
-function row(key, val) {
-  console.log('  \033[90m%s\033[0m \033[36m%s\033[0m', key, val);
-}
-
-/**
- * Format byte-size.
- *
- * @param {Number} bytes
- * @return {String}
- * @api private
- */
-
-function formatBytes(bytes) {
-  var kb = 1024
-    , mb = 1024 * kb
-    , gb = 1024 * mb;
-  if (bytes < kb) return bytes + 'b';
-  if (bytes < mb) return (bytes / kb).toFixed(2) + 'kb';
-  if (bytes < gb) return (bytes / mb).toFixed(2) + 'mb';
-  return (bytes / gb).toFixed(2) + 'gb';
-};

node_modules/connect/lib/middleware/query.js

@@ -1,40 +0,0 @@
-
-/*!
- * Connect - query
- * Copyright(c) 2011 TJ Holowaychuk
- * Copyright(c) 2011 Sencha Inc.
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var qs = require('qs')
-  , parse = require('url').parse;
-
-/**
- * Automatically parse the query-string when available,
- * populating the `req.query` object.
- *
- * Examples:
- *
- *     connect(
- *         connect.query()
- *       , function(req, res){
- *         res.end(JSON.stringify(req.query));
- *       }
- *     ).listen(3000);
- *
- * @return {Function}
- * @api public
- */
-
-module.exports = function query(){
-  return function query(req, res, next){
-    req.query = ~req.url.indexOf('?')
-      ? qs.parse(parse(req.url).query)
-      : {};
-    next();
-  };
-};

node_modules/connect/lib/middleware/responseTime.js

@@ -1,34 +0,0 @@
-
-/*!
- * Connect - responseTime
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Adds the `X-Response-Time` header displaying the response
- * duration in milliseconds.
- *
- * @return {Function}
- * @api public
- */
-
-module.exports = function responseTime(){
-  return function(req, res, next){
-    var writeHead = res.writeHead
-      , start = new Date;
-
-    if (res._responseTime) return next();
-    res._responseTime = true;
-
-    // proxy writeHead to calculate duration
-    res.writeHead = function(status, headers){
-      var duration = new Date - start;
-      res.setHeader('X-Response-Time', duration + 'ms');
-      res.writeHead = writeHead;
-      res.writeHead(status, headers);
-    };
-
-    next();
-  };
-};

node_modules/connect/lib/middleware/router.js

@@ -1,379 +0,0 @@
-
-/*!
- * Connect - router
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var utils = require('../utils')
-  , parse = require('url').parse;
-
-/**
- * Expose router.
- */
-
-exports = module.exports = router;
-
-/**
- * Supported HTTP / WebDAV methods.
- */
-
-var _methods = exports.methods = [
-    'get'
-  , 'post'
-  , 'put'
-  , 'delete'
-  , 'connect'
-  , 'options'
-  , 'trace'
-  , 'copy'
-  , 'lock'
-  , 'mkcol'
-  , 'move'
-  , 'propfind'
-  , 'proppatch'
-  , 'unlock'
-  , 'report'
-  , 'mkactivity'
-  , 'checkout'
-  , 'merge'
-];
-
-/**
- * Provides Sinatra and Express-like routing capabilities.
- *
- * Examples:
- *
- *     connect.router(function(app){
- *       app.get('/user/:id', function(req, res, next){
- *         // populates req.params.id
- *       });
- *       app.put('/user/:id', function(req, res, next){
- *         // populates req.params.id
- *       });
- *     })
- *
- * @param {Function} fn
- * @return {Function}
- * @api public
- */
-
-function router(fn){
-  var self = this
-    , methods = {}
-    , routes = {}
-    , params = {};
-
-  if (!fn) throw new Error('router provider requires a callback function');
-
-  // Generate method functions
-  _methods.forEach(function(method){
-    methods[method] = generateMethodFunction(method.toUpperCase());
-  });
-
-  // Alias del -> delete
-  methods.del = methods.delete;
-
-  // Apply callback to all methods
-  methods.all = function(){
-    var args = arguments;
-    _methods.forEach(function(name){
-      methods[name].apply(this, args);
-    });
-    return self;
-  };
-
-  // Register param callback
-  methods.param = function(name, fn){
-    params[name] = fn;
-  };
-      
-  fn.call(this, methods);
-
-  function generateMethodFunction(name) {
-    var localRoutes = routes[name] = routes[name] || [];
-    return function(path, fn){
-      var keys = []
-        , middleware = [];
-
-      // slice middleware
-      if (arguments.length > 2) {
-        middleware = Array.prototype.slice.call(arguments, 1, arguments.length);
-        fn = middleware.pop();
-        middleware = utils.flatten(middleware);
-      }
-
-      fn.middleware = middleware;
-
-      if (!path) throw new Error(name + ' route requires a path');
-      if (!fn) throw new Error(name + ' route ' + path + ' requires a callback');
-      var regexp = path instanceof RegExp
-        ? path
-        : normalizePath(path, keys);
-      localRoutes.push({
-          fn: fn
-        , path: regexp
-        , keys: keys
-        , orig: path
-        , method: name
-      });
-      return self;
-    };
-  }
-
-  function router(req, res, next){
-    var route
-      , self = this;
-
-    (function pass(i){
-      if (route = match(req, routes, i)) {
-        var i = 0
-          , keys = route.keys;
-
-        req.params = route.params;
-
-        // Param preconditions
-        (function param(err) {
-          try {
-            var key = keys[i++]
-              , val = req.params[key]
-              , fn = params[key];
-
-            if ('route' == err) {
-              pass(req._route_index + 1);
-            // Error
-            } else if (err) {
-              next(err);
-            // Param has callback
-            } else if (fn) {
-              // Return style
-              if (1 == fn.length) {
-                req.params[key] = fn(val);
-                param();
-              // Middleware style
-              } else {
-                fn(req, res, param, val);
-              }
-            // Finished processing params
-            } else if (!key) {
-              // route middleware
-              i = 0;
-              (function nextMiddleware(err){
-                var fn = route.middleware[i++];
-                if ('route' == err) {
-                  pass(req._route_index + 1);
-                } else if (err) {
-                  next(err);
-                } else if (fn) {
-                  fn(req, res, nextMiddleware);
-                } else {
-                  route.call(self, req, res, function(err){
-                    if (err) {
-                      next(err);
-                    } else {
-                      pass(req._route_index + 1);
-                    }
-                  });
-                }
-              })();
-            // More params
-            } else {
-              param();
-            }
-          } catch (err) {
-            next(err);
-          }
-        })();
-      } else if ('OPTIONS' == req.method) {
-        options(req, res, routes);
-      } else {
-        next();
-      }
-    })();
-  };
-
-  router.remove = function(path, method){
-    var fns = router.lookup(path, method);
-    fns.forEach(function(fn){
-      routes[fn.method].splice(fn.index, 1);
-    });
-  };
-
-  router.lookup = function(path, method, ret){
-    ret = ret || [];
-
-    // method specific lookup
-    if (method) {
-      method = method.toUpperCase();
-      if (routes[method]) {
-        routes[method].forEach(function(route, i){
-          if (path == route.orig) {
-            var fn = route.fn;
-            fn.regexp = route.path;
-            fn.keys = route.keys;
-            fn.path = route.orig;
-            fn.method = route.method;
-            fn.index = i;
-            ret.push(fn);
-          }
-        });
-      }
-    // global lookup
-    } else {
-      _methods.forEach(function(method){
-        router.lookup(path, method, ret);
-      });
-    }
-
-    return ret;
-  };
-
-  router.match = function(url, method, ret){
-    var ret = ret || []
-      , i = 0
-      , fn
-      , req;
-
-    // method specific matches
-    if (method) {
-      method = method.toUpperCase();
-      req = { url: url, method: method };
-      while (fn = match(req, routes, i)) {
-        i = req._route_index + 1;
-        ret.push(fn);
-      } 
-    // global matches
-    } else {
-      _methods.forEach(function(method){
-        router.match(url, method, ret);
-      });
-    }
-
-    return ret;
-  };
-
-  return router;
-}
-
-/**
- * Respond to OPTIONS.
- *
- * @param {ServerRequest} req
- * @param {ServerResponse} req
- * @param {Array} routes
- * @api private
- */
-
-function options(req, res, routes) {
-  var pathname = parse(req.url).pathname
-    , body = optionsFor(pathname, routes).join(',');
-  res.writeHead(200, {
-      'Content-Length': body.length
-    , 'Allow': body
-  });
-  res.end(body);
-}
-
-/**
- * Return OPTIONS array for the given `path`, matching `routes`.
- *
- * @param {String} path
- * @param {Array} routes
- * @return {Array}
- * @api private
- */
-
-function optionsFor(path, routes) {
-  return _methods.filter(function(method){
-    var arr = routes[method.toUpperCase()];
-    for (var i = 0, len = arr.length; i < len; ++i) {
-      if (arr[i].path.test(path)) return true;
-    }
-  }).map(function(method){
-    return method.toUpperCase();
-  });
-}
-
-/**
- * Normalize the given path string,
- * returning a regular expression.
- *
- * An empty array should be passed,
- * which will contain the placeholder
- * key names. For example "/user/:id" will
- * then contain ["id"].
- *
- * @param  {String} path
- * @param  {Array} keys
- * @return {RegExp}
- * @api private
- */
-
-function normalizePath(path, keys) {
-  path = path
-    .concat('/?')
-    .replace(/\/\(/g, '(?:/')
-    .replace(/(\/)?(\.)?:(\w+)(?:(\(.*?\)))?(\?)?/g, function(_, slash, format, key, capture, optional){
-      keys.push(key);
-      slash = slash || '';
-      return ''
-        + (optional ? '' : slash)
-        + '(?:'
-        + (optional ? slash : '')
-        + (format || '') + (capture || '([^/]+?)') + ')'
-        + (optional || '');
-    })
-    .replace(/([\/.])/g, '\\$1')
-    .replace(/\*/g, '(.+)');
-  return new RegExp('^' + path + '$', 'i');
-}
-
-/**
- * Attempt to match the given request to
- * one of the routes. When successful
- * a route function is returned.
- *
- * @param  {ServerRequest} req
- * @param  {Object} routes
- * @return {Function}
- * @api private
- */
-
-function match(req, routes, i) {
-  var captures
-    , method = req.method
-    , i = i || 0;
-  if ('HEAD' == method) method = 'GET';
-  if (routes = routes[method]) {
-    var url = parse(req.url)
-      , pathname = url.pathname;
-    for (var len = routes.length; i < len; ++i) {
-      var route = routes[i]
-        , fn = route.fn
-        , path = route.path
-        , keys = fn.keys = route.keys;
-      if (captures = path.exec(pathname)) {
-        fn.method = method;
-        fn.params = [];
-        for (var j = 1, len = captures.length; j < len; ++j) {
-          var key = keys[j-1],
-            val = typeof captures[j] === 'string'
-              ? decodeURIComponent(captures[j])
-              : captures[j];
-          if (key) {
-            fn.params[key] = val;
-          } else {
-            fn.params.push(val);
-          }
-        }
-        req._route_index = i;
-        return fn;
-      }
-    }
-  }
-}

node_modules/connect/lib/middleware/session.js

@@ -1,346 +0,0 @@
-
-/*!
- * Connect - session
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var Session = require('./session/session')
-  , MemoryStore = require('./session/memory')
-  , Cookie = require('./session/cookie')
-  , Store = require('./session/store')
-  , utils = require('./../utils')
-  , parse = require('url').parse
-  , crypto = require('crypto');
-
-// environment
-
-var env = process.env.NODE_ENV;
-
-/**
- * Expose the middleware.
- */
-
-exports = module.exports = session;
-
-/**
- * Expose constructors.
- */
-
-exports.Store = Store;
-exports.Cookie = Cookie;
-exports.Session = Session;
-exports.MemoryStore = MemoryStore;
-
-/**
- * Warning message for `MemoryStore` usage in production.
- */
-
-var warning = 'Warning: connection.session() MemoryStore is not\n'
-  + 'designed for a production environment, as it will leak\n'
-  + 'memory, and obviously only work within a single process.';
-
-/**
- * Default finger-printing function.
- */
-
-function defaultFingerprint(req) {
-  var ua = req.headers['user-agent'] || '';
-  return ua.replace(/;?\schromeframe\/[\d\.]+/, '');
-};
-
-/**
- * Paths to ignore.
- */
-
-exports.ignore = [];
-
-/**
- * Setup session store with the given `options`.
- *
- * Session data is _not_ saved in the cookie itself, however
- * cookies are used, so we must use the [cookieParser()](middleware-cookieParser.html)
- * middleware _before_ `session()`.
- *
- * Examples:
- *
- *     connect.createServer(
- *         connect.cookieParser()
- *       , connect.session({ secret: 'keyboard cat' })
- *     );
- *
- * Options:
- *
- *   - `key`           cookie name defaulting to `connect.sid`
- *   - `store`         Session store instance
- *   - `fingerprint`   Custom fingerprint generating function
- *   - `cookie`        Session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: 14400000 }`
- *   - `secret`        Secret string used to compute hash
- *
- * Ignore Paths:
- *
- *  By default `/favicon.ico` is the only ignored path, all others
- *  will utilize sessions, to manipulate the paths ignored, use
- * `connect.session.ignore.push('/my/path')`. This works for _full_
- *  pathnames only, not segments nor substrings.
- *
- *     connect.session.ignore.push('/robots.txt');
- *
- * ## req.session
- *
- *  To store or access session data, simply use the request property `req.session`,
- *  which is (generally) serialized as JSON by the store, so nested objects 
- *  are typically fine. For example below is a user-specific view counter:
- *
- *       connect(
- *           connect.cookieParser()
- *         , connect.session({ secret: 'keyboard cat', cookie: { maxAge: 60000 }})
- *         , connect.favicon()
- *         , function(req, res, next){
- *           var sess = req.session;
- *           if (sess.views) {
- *             res.setHeader('Content-Type', 'text/html');
- *             res.write('<p>views: ' + sess.views + '</p>');
- *             res.write('<p>expires in: ' + (sess.cookie.maxAge / 1000) + 's</p>');
- *             res.end();
- *             sess.views++;
- *           } else {
- *             sess.views = 1;
- *             res.end('welcome to the session demo. refresh!');
- *           }
- *         }
- *       ).listen(3000);
- *
- * ## Session#regenerate()
- *
- *  To regenerate the session simply invoke the method, once complete
- *  a new SID and `Session` instance will be initialized at `req.session`.
- *
- *      req.session.regenerate(function(err){
- *        // will have a new session here
- *      });
- *
- * ## Session#destroy()
- *
- *  Destroys the session, removing `req.session`, will be re-generated next request.
- *
- *      req.session.destroy(function(err){
- *        // cannot access session here
- *      });
- * 
- * ## Session#reload()
- *
- *  Reloads the session data.
- *
- *      req.session.reload(function(err){
- *        // session updated
- *      });
- *
- * ## Session#save()
- *
- *  Save the session.
- *
- *      req.session.save(function(err){
- *        // session saved
- *      });
- *
- * ## Session#touch()
- *
- *   Updates the `.maxAge`, and `.lastAccess` properties. Typically this is
- *   not necessary to call, as the session middleware does this for you.
- *
- * ## Session#cookie
- *
- *  Each session has a unique cookie object accompany it. This allows
- *  you to alter the session cookie per visitor. For example we can
- *  set `req.session.cookie.expires` to `false` to enable the cookie
- *  to remain for only the duration of the user-agent.
- *
- * ## Session#maxAge
- *
- *  Alternatively `req.session.cookie.maxAge` will return the time
- *  remaining in milliseconds, which we may also re-assign a new value
- *  to adjust the `.expires` property appropriately. The following
- *  are essentially equivalent
- *
- *     var hour = 3600000;
- *     req.session.cookie.expires = new Date(Date.now() + hour);
- *     req.session.cookie.maxAge = hour;
- *
- * For example when `maxAge` is set to `60000` (one minute), and 30 seconds
- * has elapsed it will return `30000` until the current request has completed,
- * at which time `req.session.touch()` is called to update `req.session.lastAccess`,
- * and reset `req.session.maxAge` to its original value.
- *
- *     req.session.cookie.maxAge;
- *     // => 30000
- *
- * Session Store Implementation:
- *
- * Every session store _must_ implement the following methods
- *
- *    - `.get(sid, callback)`
- *    - `.set(sid, session, callback)`
- *    - `.destroy(sid, callback)`
- *
- * Recommended methods include, but are not limited to:
- *
- *    - `.length(callback)`
- *    - `.clear(callback)`
- *
- * For an example implementation view the [connect-redis](http://github.com/visionmedia/connect-redis) repo.
- *
- * @param {Object} options
- * @return {Function}
- * @api public
- */
-
-function session(options){
-  var options = options || {}
-    , key = options.key || 'connect.sid'
-    , secret = options.secret
-    , store = options.store || new MemoryStore
-    , fingerprint = options.fingerprint || defaultFingerprint
-    , cookie = options.cookie;
-
-  // notify user that this store is not
-  // meant for a production environment
-  if ('production' == env && store instanceof MemoryStore) {
-    console.warn(warning);
-  }
-
-  // ensure secret is present
-  if (!secret) {
-    throw new Error('connect.session({ secret: "string" }) required for security');
-  }
-
-  // session hashing function
-  store.hash = function(req, base) {
-    return crypto
-      .createHmac('sha256', secret)
-      .update(base + fingerprint(req))
-      .digest('base64')
-      .replace(/=*$/, '');
-  };
-
-  // generates the new session
-  store.generate = function(req){
-    var base = utils.uid(24);
-    var sessionID = base + '.' + store.hash(req, base);
-    req.sessionID = sessionID;
-    req.session = new Session(req);
-    req.session.cookie = new Cookie(cookie);
-  };
-
-  return function session(req, res, next) {
-    // self-awareness
-    if (req.session) return next();
-
-    // parse url
-    var url = parse(req.url)
-      , path = url.pathname;
-
-    // ignorable paths
-    if (~exports.ignore.indexOf(path)) return next();
-
-    // expose store
-    req.sessionStore = store;
-
-    // proxy writeHead() to Set-Cookie
-    var writeHead = res.writeHead;
-    res.writeHead = function(status, headers){
-      if (req.session) {
-        var cookie = req.session.cookie;
-        // only send secure session cookies when there is a secure connection.
-        // proxySecure is a custom attribute to allow for a reverse proxy
-        // to handle SSL connections and to communicate to connect over HTTP that
-        // the incoming connection is secure.
-        var secured = cookie.secure && (req.connection.encrypted || req.connection.proxySecure);
-        if (secured || !cookie.secure) {
-          res.setHeader('Set-Cookie', cookie.serialize(key, req.sessionID));
-        }
-      }
-
-      res.writeHead = writeHead;
-      return res.writeHead(status, headers);
-    };
-
-    // proxy end() to commit the session
-    var end = res.end;
-    res.end = function(data, encoding){
-      res.end = end;
-      if (req.session) {
-        // HACK: ensure Set-Cookie for implicit writeHead()
-        if (!res._header) res._implicitHeader();
-        req.session.resetMaxAge();
-        req.session.save(function(){
-          res.end(data, encoding);
-        });
-      } else {
-        res.end(data, encoding);
-      }
-    };
-
-    // session hashing
-    function hash(base) {
-      return store.hash(req, base);
-    }
-
-    // generate the session
-    function generate() {
-      store.generate(req);
-    }
-
-    // get the sessionID from the cookie
-    req.sessionID = req.cookies[key];
-
-    // make a new session if the browser doesn't send a sessionID
-    if (!req.sessionID) {
-      generate();
-      next();
-      return;
-    }
-
-    // check the fingerprint
-    var parts = req.sessionID.split('.');
-    if (parts[1] != hash(parts[0])) {
-      generate();
-      next();
-      return;
-    }
-
-    // generate the session object
-    var pause = utils.pause(req);
-    store.get(req.sessionID, function(err, sess){
-      // proxy to resume() events
-      var _next = next;
-      next = function(err){
-        _next(err);
-        pause.resume();
-      }
-
-      // error handling
-      if (err) {
-        if ('ENOENT' == err.code) {
-          generate();
-          next();
-        } else {
-          next(err);
-        }
-      // no session
-      } else if (!sess) {
-        generate();
-        next();
-      // populate req.session
-      } else {
-        store.createSession(req, sess);
-        next();
-      }
-    });
-  };
-};

node_modules/connect/lib/middleware/session/cookie.js

@@ -1,126 +0,0 @@
-
-/*!
- * Connect - session - Cookie
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var utils = require('../../utils');
-
-/**
- * Initialize a new `Cookie` with the given `options`.
- *
- * @param {Object} options
- * @api private
- */
-
-var Cookie = module.exports = function Cookie(options) {
-  this.path = '/';
-  this.httpOnly = true;
-  this.maxAge = 14400000;
-  if (options) utils.merge(this, options);
-  this.originalMaxAge = undefined == this.originalMaxAge
-    ? this.maxAge
-    : this.originalMaxAge;
-};
-
-/**
- * Prototype.
- */
-
-Cookie.prototype = {
-
-  /**
-   * Set expires `date`.
-   *
-   * @param {Date} date
-   * @api public
-   */
-  
-  set expires(date) {
-    this._expires = date;
-    this.originalMaxAge = this.maxAge;
-  },
-
-  /**
-   * Get expires `date`.
-   *
-   * @return {Date}
-   * @api public
-   */
-
-  get expires() {
-    return this._expires;
-  },
-  
-  /**
-   * Set expires via max-age in `ms`.
-   *
-   * @param {Number} ms
-   * @api public
-   */
-  
-  set maxAge(ms) {
-    this.expires = 'number' == typeof ms
-      ? new Date(Date.now() + ms)
-      : ms;
-  },
-
-  /**
-   * Get expires max-age in `ms`.
-   *
-   * @return {Number}
-   * @api public
-   */
-
-  get maxAge() {
-    return this.expires instanceof Date
-      ? this.expires.valueOf() - Date.now()
-      : this.expires;
-  },
-
-  /**
-   * Return cookie data object.
-   *
-   * @return {Object}
-   * @api private
-   */
-
-  get data() {
-    return {
-        originalMaxAge: this.originalMaxAge
-      , expires: this._expires
-      , secure: this.secure
-      , httpOnly: this.httpOnly
-      , domain: this.domain
-      , path: this.path
-    }
-  },
-
-  /**
-   * Return a serialized cookie string.
-   *
-   * @return {String}
-   * @api public
-   */
-
-  serialize: function(name, val){
-    return utils.serializeCookie(name, val, this.data);
-  },
-
-  /**
-   * Return JSON representation of this cookie.
-   *
-   * @return {Object}
-   * @api private
-   */
-  
-  toJSON: function(){
-    return this.data;
-  }
-};

node_modules/connect/lib/middleware/session/memory.js

@@ -1,131 +0,0 @@
-
-/*!
- * Connect - session - MemoryStore
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var Store = require('./store')
-  , utils = require('../../utils')
-  , Session = require('./session');
-
-/**
- * Initialize a new `MemoryStore`.
- *
- * @api public
- */
-
-var MemoryStore = module.exports = function MemoryStore() {
-  this.sessions = {};
-};
-
-/**
- * Inherit from `Store.prototype`.
- */
-
-MemoryStore.prototype.__proto__ = Store.prototype;
-
-/**
- * Attempt to fetch session by the given `sid`.
- *
- * @param {String} sid
- * @param {Function} fn
- * @api public
- */
-
-MemoryStore.prototype.get = function(sid, fn){
-  var self = this;
-  process.nextTick(function(){
-    var expires
-      , sess = self.sessions[sid];
-    if (sess) {
-      sess = JSON.parse(sess);
-      expires = 'string' == typeof sess.cookie.expires
-        ? new Date(sess.cookie.expires)
-        : sess.cookie.expires;
-      if (!expires || new Date < expires) {
-        fn(null, sess);
-      } else {
-        self.destroy(sid, fn);
-      }
-    } else {
-      fn();
-    }
-  });
-};
-
-/**
- * Commit the given `sess` object associated with the given `sid`.
- *
- * @param {String} sid
- * @param {Session} sess
- * @param {Function} fn
- * @api public
- */
-
-MemoryStore.prototype.set = function(sid, sess, fn){
-  var self = this;
-  process.nextTick(function(){
-    self.sessions[sid] = JSON.stringify(sess);
-    fn && fn();
-  });
-};
-
-/**
- * Destroy the session associated with the given `sid`.
- *
- * @param {String} sid
- * @api public
- */
-
-MemoryStore.prototype.destroy = function(sid, fn){
-  var self = this;
-  process.nextTick(function(){
-    delete self.sessions[sid];
-    fn && fn();
-  });
-};
-
-/**
- * Invoke the given callback `fn` with all active sessions.
- *
- * @param {Function} fn
- * @api public
- */
-
-MemoryStore.prototype.all = function(fn){
-  var arr = []
-    , keys = Object.keys(this.sessions);
-  for (var i = 0, len = keys.length; i < len; ++i) {
-    arr.push(this.sessions[keys[i]]);
-  }
-  fn(null, arr);
-};
-
-/**
- * Clear all sessions.
- *
- * @param {Function} fn
- * @api public
- */
-
-MemoryStore.prototype.clear = function(fn){
-  this.sessions = {};
-  fn && fn();
-};
-
-/**
- * Fetch number of sessions.
- *
- * @param {Function} fn
- * @api public
- */
-
-MemoryStore.prototype.length = function(fn){
-  fn(null, Object.keys(this.sessions).length);
-};

node_modules/connect/lib/middleware/session/session.js

@@ -1,137 +0,0 @@
-
-/*!
- * Connect - session - Session
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var utils = require('../../utils')
-  , Cookie = require('./cookie');
-
-/**
- * Create a new `Session` with the given request and `data`.
- *
- * @param {IncomingRequest} req
- * @param {Object} data
- * @api private
- */
-
-var Session = module.exports = function Session(req, data) {
-  Object.defineProperty(this, 'req', { value: req });
-  Object.defineProperty(this, 'id', { value: req.sessionID });
-  if ('object' == typeof data) {
-    utils.merge(this, data);
-  } else {
-    this.lastAccess = Date.now();
-  }
-};
-
-/**
- * Update `.lastAccess` timestamp,
- * and reset `.cookie.maxAge` to prevent
- * the cookie from expiring when the
- * session is still active.
- *
- * @return {Session} for chaining
- * @api public
- */
-
-Session.prototype.touch = function(){
-  return this
-    .resetLastAccess()
-    .resetMaxAge();
-};
-
-/**
- * Update `.lastAccess` timestamp.
- *
- * @return {Session} for chaining
- * @api public
- */
-
-Session.prototype.resetLastAccess = function(){
-  this.lastAccess = Date.now();
-  return this;
-};
-
-/**
- * Reset `.maxAge` to `.originalMaxAge`.
- *
- * @return {Session} for chaining
- * @api public
- */
-
-Session.prototype.resetMaxAge = function(){
-  this.cookie.maxAge = this.cookie.originalMaxAge;
-  return this;
-};
-
-/**
- * Save the session data with optional callback `fn(err)`.
- *
- * @param {Function} fn
- * @return {Session} for chaining
- * @api public
- */
-
-Session.prototype.save = function(fn){
-  this.req.sessionStore.set(this.id, this, fn || function(){});
-  return this;
-};
-
-/**
- * Re-loads the session data _without_ altering
- * the maxAge or lastAccess properties. Invokes the
- * callback `fn(err)`, after which time if no exception
- * has occurred the `req.session` property will be
- * a new `Session` object, although representing the
- * same session.
- *
- * @param {Function} fn
- * @return {Session} for chaining
- * @api public
- */
-
-Session.prototype.reload = function(fn){
-  var req = this.req
-    , store = this.req.sessionStore;
-  store.get(this.id, function(err, sess){
-    if (err) return fn(err);
-    if (!sess) return fn(new Error('failed to load session'));
-    store.createSession(req, sess);
-    fn();
-  });
-  return this;
-};
-
-/**
- * Destroy `this` session.
- *
- * @param {Function} fn
- * @return {Session} for chaining
- * @api public
- */
-
-Session.prototype.destroy = function(fn){
-  delete this.req.session;
-  this.req.sessionStore.destroy(this.id, fn);
-  return this;
-};
-
-/**
- * Regenerate this request's session.
- *
- * @param {Function} fn
- * @return {Session} for chaining
- * @api public
- */
-
-Session.prototype.regenerate = function(fn){
-  this.req.sessionStore.regenerate(this.req, fn);
-  return this;
-};

node_modules/connect/lib/middleware/session/store.js

@@ -1,87 +0,0 @@
-
-/*!
- * Connect - session - Store
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var EventEmitter = require('events').EventEmitter
-  , Session = require('./session')
-  , Cookie = require('./cookie')
-  , utils = require('../../utils');
-
-/**
- * Initialize abstract `Store`.
- *
- * @api private
- */
-
-var Store = module.exports = function Store(options){};
-
-/**
- * Inherit from `EventEmitter.prototype`.
- */
-
-Store.prototype.__proto__ = EventEmitter.prototype;
-
-/**
- * Re-generate the given requests's session.
- *
- * @param {IncomingRequest} req
- * @return {Function} fn
- * @api public
- */
-
-Store.prototype.regenerate = function(req, fn){
-  var self = this;
-  this.destroy(req.sessionID, function(err){
-    self.generate(req);
-    fn(err);
-  });
-};
-
-/**
- * Load a `Session` instance via the given `sid`
- * and invoke the callback `fn(err, sess)`.
- *
- * @param {String} sid
- * @param {Function} fn
- * @api public
- */
-
-Store.prototype.load = function(sid, fn){
-  var self = this;
-  this.get(sid, function(err, sess){
-    if (err) return fn(err);
-    if (!sess) return fn();
-    var req = { sessionID: sid, sessionStore: self };
-    sess = self.createSession(req, sess, false);
-    fn(null, sess);
-  });
-};
-
-/**
- * Create session from JSON `sess` data.
- *
- * @param {IncomingRequest} req
- * @param {Object} sess
- * @return {Session}
- * @api private
- */
-
-Store.prototype.createSession = function(req, sess, update){
-  var expires = sess.cookie.expires
-    , orig = sess.cookie.originalMaxAge
-    , update = null == update ? true : false;
-  sess.cookie = new Cookie(sess.cookie);
-  if ('string' == typeof expires) sess.cookie.expires = new Date(expires);
-  sess.cookie.originalMaxAge = orig;
-  req.session = new Session(req, sess);
-  if (update) req.session.resetLastAccess();
-  return req.session;
-};

node_modules/connect/lib/middleware/static.js

@@ -1,225 +0,0 @@
-
-/*!
- * Connect - staticProvider
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var fs = require('fs')
-  , path = require('path')
-  , join = path.join
-  , basename = path.basename
-  , normalize = path.normalize
-  , utils = require('../utils')
-  , Buffer = require('buffer').Buffer
-  , parse = require('url').parse
-  , mime = require('mime');
-
-/**
- * Static file server with the given `root` path.
- *
- * Examples:
- *
- *     var oneDay = 86400000;
- *
- *     connect(
- *       connect.static(__dirname + '/public')
- *     ).listen(3000);
- *
- *     connect(
- *       connect.static(__dirname + '/public', { maxAge: oneDay })
- *     ).listen(3000);
- *
- * Options:
- *
- *    - `maxAge`   Browser cache maxAge in milliseconds. defaults to 0
- *    - `hidden`   Allow transfer of hidden files. defaults to false
- *    - `redirect`   Redirect to trailing "/" when the pathname is a dir
- *
- * @param {String} root
- * @param {Object} options
- * @return {Function}
- * @api public
- */
-
-exports = module.exports = function static(root, options){
-  options = options || {};
-
-  // root required
-  if (!root) throw new Error('static() root path required');
-  options.root = root;
-
-  return function static(req, res, next) {
-    options.path = req.url;
-    options.getOnly = true;
-    send(req, res, next, options);
-  };
-};
-
-/**
- * Expose mime module.
- */
-
-exports.mime = mime;
-
-/**
- * Respond with 416  "Requested Range Not Satisfiable"
- *
- * @param {ServerResponse} res
- * @api private
- */
-
-function invalidRange(res) {
-  var body = 'Requested Range Not Satisfiable';
-  res.setHeader('Content-Type', 'text/plain');
-  res.setHeader('Content-Length', body.length);
-  res.statusCode = 416;
-  res.end(body);
-}
-
-/**
- * Attempt to tranfer the requseted file to `res`.
- *
- * @param {ServerRequest}
- * @param {ServerResponse}
- * @param {Function} next
- * @param {Object} options
- * @api private
- */
-
-var send = exports.send = function(req, res, next, options){
-  options = options || {};
-  if (!options.path) throw new Error('path required');
-
-  // setup
-  var maxAge = options.maxAge || 0
-    , ranges = req.headers.range
-    , head = 'HEAD' == req.method
-    , get = 'GET' == req.method
-    , root = options.root ? normalize(options.root) : null
-    , redirect = false === options.redirect ? false : true
-    , getOnly = options.getOnly
-    , fn = options.callback
-    , hidden = options.hidden
-    , done;
-
-  // replace next() with callback when available
-  if (fn) next = fn;
-
-  // ignore non-GET requests
-  if (getOnly && !get && !head) return next();
-
-  // parse url
-  var url = parse(options.path)
-    , path = decodeURIComponent(url.pathname)
-    , type;
-
-  // null byte(s)
-  if (~path.indexOf('\0')) return utils.badRequest(res);
-
-  // when root is not given, consider .. malicious
-  if (!root && ~path.indexOf('..')) return utils.forbidden(res);
-
-  // join / normalize from optional root dir
-  path = normalize(join(root, path));
-
-  // malicious path
-  if (root && 0 != path.indexOf(root)) return fn
-    ? fn(new Error('Forbidden'))
-    : utils.forbidden(res);
-
-  // index.html support
-  if (normalize('/') == path[path.length - 1]) path += 'index.html';
-
-  // "hidden" file
-  if (!hidden && '.' == basename(path)[0]) return next();
-
-  fs.stat(path, function(err, stat){
-    // mime type
-    type = mime.lookup(path);
-
-    // ignore ENOENT
-    if (err) {
-      if (fn) return fn(err);
-      return 'ENOENT' == err.code
-        ? next()
-        : next(err);
-    // redirect directory in case index.html is present
-    } else if (stat.isDirectory()) {
-      if (!redirect) return next();
-      res.statusCode = 301;
-      res.setHeader('Location', url.pathname + '/');
-      res.end('Redirecting to ' + url.pathname + '/');
-      return;
-    }
-
-    // header fields
-    if (!res.getHeader('Date')) res.setHeader('Date', new Date().toUTCString());
-    if (!res.getHeader('Cache-Control')) res.setHeader('Cache-Control', 'public, max-age=' + (maxAge / 1000));
-    if (!res.getHeader('Last-Modified')) res.setHeader('Last-Modified', stat.mtime.toUTCString());
-    if (!res.getHeader('ETag')) res.setHeader('ETag', utils.etag(stat));
-    if (!res.getHeader('content-type')) {
-      var charset = mime.charsets.lookup(type);
-      res.setHeader('Content-Type', type + (charset ? '; charset=' + charset : ''));
-    }
-    res.setHeader('Accept-Ranges', 'bytes');
-
-    // conditional GET support
-    if (utils.conditionalGET(req)) {
-      if (!utils.modified(req, res)) {
-        req.emit('static');
-        return utils.notModified(res);
-      }
-    }
-
-    var opts = {};
-    var chunkSize = stat.size;
-
-    // we have a Range request
-    if (ranges) {
-      ranges = utils.parseRange(stat.size, ranges);
-      // valid
-      if (ranges) {
-        // TODO: stream options
-        // TODO: multiple support
-        opts.start = ranges[0].start;
-        opts.end = ranges[0].end;
-        chunkSize = opts.end - opts.start + 1;
-        res.statusCode = 206;
-        res.setHeader('Content-Range', 'bytes '
-          + opts.start
-          + '-'
-          + opts.end
-          + '/'
-          + stat.size);
-      // invalid
-      } else {
-        return fn
-          ? fn(new Error('Requested Range Not Satisfiable'))
-          : invalidRange(res);
-      }
-    }
-
-    res.setHeader('Content-Length', chunkSize);
-
-    // transfer
-    if (head) return res.end();
-
-    // stream
-    var stream = fs.createReadStream(path, opts);
-    req.emit('static', stream);
-    stream.pipe(res);
-
-    // callback
-    if (fn) {
-      function callback(err) { done || fn(err); done = true }
-      req.on('close', callback);
-      stream.on('end', callback);
-    }
-  });
-};

node_modules/connect/lib/middleware/staticCache.js

@@ -1,175 +0,0 @@
-
-/*!
- * Connect - staticCache
- * Copyright(c) 2011 Sencha Inc.
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var http = require('http')
-  , utils = require('../utils')
-  , Cache = require('../cache')
-  , url = require('url')
-  , fs = require('fs');
-
-/**
- * Enables a memory cache layer on top of
- * the `static()` middleware, serving popular
- * static files.
- *
- * By default a maximum of 128 objects are
- * held in cache, with a max of 256k each,
- * totalling ~32mb.
- *
- * A Least-Recently-Used (LRU) cache algo
- * is implemented through the `Cache` object,
- * simply rotating cache objects as they are
- * hit. This means that increasingly popular
- * objects maintain their positions while
- * others get shoved out of the stack and
- * garbage collected.
- *
- * Benchmarks:
- *
- *     static(): 2700 rps
- *     node-static: 5300 rps
- *     static() + staticCache(): 7500 rps
- *
- * Options:
- *
- *   - `maxObjects`  max cache objects [128]
- *   - `maxLength`  max cache object length 256kb
- *
- * @param {Type} name
- * @return {Type}
- * @api public
- */
-
-module.exports = function staticCache(options){
-  var options = options || {}
-    , cache = new Cache(options.maxObjects || 128)
-    , maxlen = options.maxLength || 1024 * 256;
-
-  return function staticCache(req, res, next){
-    var path = url.parse(req.url).pathname
-      , ranges = req.headers.range
-      , hit = cache.get(path)
-      , hitCC
-      , uaCC
-      , header
-      , age;
-
-    // cache static
-    req.on('static', function(stream){
-      var headers = res._headers
-        , cc = utils.parseCacheControl(headers['cache-control'] || '')
-        , contentLength = headers['content-length']
-        , hit;
-
-      // ignore larger files
-      if (!contentLength || contentLength > maxlen) return;
-
-      // dont cache items we shouldn't be
-      if ( cc['no-cache']
-        || cc['no-store']
-        || cc['private']
-        || cc['must-revalidate']) return;
-
-      // if already in cache then validate
-      if (hit = cache.get(path)){
-        if (headers.etag == hit[0].etag) {
-          hit[0].date = new Date;
-          return;
-        } else {
-          cache.remove(path);
-        }
-      }
-
-      // validation notifiactions don't contain a steam
-      if (null == stream) return;
-
-      // add the cache object
-      var arr = cache.add(path);
-      arr.push(headers);
-
-      // store the chunks
-      stream.on('data', function(chunk){
-        arr.push(chunk);
-      });
-
-      // flag it as complete
-      stream.on('end', function(){
-        arr.complete = true;
-      });
-    });
-
-    // cache hit, doesnt support range requests
-    if (hit && hit.complete && !ranges) {
-      header = utils.merge({}, hit[0]);
-      header.Age = age = (new Date - new Date(header.date)) / 1000 | 0;
-      header.date = new Date().toUTCString();
-
-      // parse cache-controls
-      hitCC = utils.parseCacheControl(header['cache-control'] || '');
-      uaCC = utils.parseCacheControl(req.headers['cache-control'] || '');
-
-      // check if we must revalidate(bypass)
-      if (hitCC['no-cache'] || uaCC['no-cache']) return next();
-
-      // check freshness of entity
-      if (isStale(hitCC, age) || isStale(uaCC, age)) return next();
-
-      // conditional GET support
-      if (utils.conditionalGET(req)) {
-        if (!utils.modified(req, res, header)) {
-          header['content-length'] = 0;
-          res.writeHead(304, header);
-          return res.end();
-        }
-      }
-
-      // HEAD support
-      if ('HEAD' == req.method) {
-        header['content-length'] = 0;
-        res.writeHead(200, header);
-        return res.end();
-      }
-
-      // respond with cache
-      res.writeHead(200, header);
-
-      // backpressure
-      function write(i) {
-        var buf = hit[i];
-        if (!buf) return res.end();
-        if (false === res.write(buf)) {
-          res.once('drain', function(){
-            write(++i);
-          });
-        } else {
-          write(++i);
-        }
-      }
-
-      return write(1);
-    }
-
-    next();
-  }
-};
-
-/**
- * Check if cache item is stale
- *
- * @param {Object} cc
- * @param {Number} age
- * @return {Boolean}
- * @api private
- */
-
-function isStale(cc, age) {
-  return cc['max-age'] && cc['max-age'] <= age;
-}

node_modules/connect/lib/middleware/vhost.js

@@ -1,44 +0,0 @@
-
-/*!
- * Connect - vhost
- * Copyright(c) 2010 Sencha Inc.
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Setup vhost for the given `hostname` and `server`.
- *
- * Examples:
- *
- *     connect(
- *       connect.vhost('foo.com',
- *         connect.createServer(...middleware...)
- *       ),
- *       connect.vhost('bar.com',
- *         connect.createServer(...middleware...)
- *       )
- *     );
- *
- * @param {String} hostname
- * @param {Server} server
- * @return {Function}
- * @api public
- */
-
-module.exports = function vhost(hostname, server){
-  if (!hostname) throw new Error('vhost hostname required');
-  if (!server) throw new Error('vhost server required');
-  var regexp = new RegExp('^' + hostname.replace(/[*]/g, '(.*?)') + '$');
-  if (server.onvhost) server.onvhost(hostname);
-  return function vhost(req, res, next){
-    if (!req.headers.host) return next();
-    var host = req.headers.host.split(':')[0];
-    if (req.subdomains = regexp.exec(host)) {
-      req.subdomains = req.subdomains[0].split('.').slice(0, -1);
-      server.emit("request", req, res);
-    } else {
-      next();
-    }
-  };
-};

node_modules/connect/lib/patch.js

@@ -1,79 +0,0 @@
-
-/*!
- * Connect
- * Copyright(c) 2011 TJ Holowaychuk
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var http = require('http')
-  , res = http.OutgoingMessage.prototype;
-
-// original setHeader()
-
-var setHeader = res.setHeader;
-
-// original _renderHeaders()
-
-var _renderHeaders = res._renderHeaders;
-
-if (res._hasConnectPatch) return;
-
-/**
- * Provide a public "header sent" flag
- * until node does.
- *
- * @return {Boolean}
- * @api public
- */
-
-res.__defineGetter__('headerSent', function(){
-  return this._headerSent;
-});
-
-/**
- * Set header `field` to `val`, special-casing
- * the `Set-Cookie` field for multiple support.
- *
- * @param {String} field
- * @param {String} val
- * @api public
- */
-
-res.setHeader = function(field, val){
-  var key = field.toLowerCase()
-    , prev;
-
-  // special-case Set-Cookie
-  if (this._headers && 'set-cookie' == key) {
-    if (prev = this.getHeader(field)) {
-      val = Array.isArray(prev)
-        ? prev.concat(val)
-        : [prev, val];
-    }
-  // charset
-  } else if ('content-type' == key && this.charset) {
-    val += '; charset=' + this.charset;
-  }
-
-  return setHeader.call(this, field, val);
-};
-
-/**
- * Proxy `res.end()` to expose a 'header' event,
- * allowing arbitrary augmentation before the header
- * fields are written to the socket.
- *
- * NOTE: this _only_ supports node's progressive header
- * field API aka `res.setHeader()`.
- */
-
-res._renderHeaders = function(){
-  this.emit('header');
-  return _renderHeaders.call(this);
-};
-
-res._hasConnectPatch = true;

node_modules/connect/lib/public/directory.html

@@ -1,75 +0,0 @@
-<html>
-  <head>
-    <title>listing directory {directory}</title>
-    <style>{style}</style>
-    <script>
-      function $(id){
-        var el = 'string' == typeof id
-          ? document.getElementById(id)
-          : id;
-
-        el.on = function(event, fn){
-          if ('content loaded' == event) event = 'DOMContentLoaded';
-          el.addEventListener(event, fn, false);
-        };
-
-        el.all = function(selector){
-          return $(el.querySelectorAll(selector));
-        };
-
-        el.each = function(fn){
-          for (var i = 0, len = el.length; i < len; ++i) {
-            fn($(el[i]), i);
-          }
-        };
-
-        el.getClasses = function(){
-          return this.getAttribute('class').split(/\s+/);
-        };
-
-        el.addClass = function(name){
-          var classes = this.getAttribute('class');
-          el.setAttribute('class', classes
-            ? classes + ' ' + name
-            : name);
-        };
-
-        el.removeClass = function(name){
-          var classes = this.getClasses().filter(function(curr){
-            return curr != name;
-          });
-          this.setAttribute('class', classes);
-        };
-
-        return el;
-      }
-
-      function search() {
-        var str = $('search').value
-          , links = $('files').all('a');
-
-        links.each(function(link){
-          var text = link.textContent;
-
-          if ('..' == text) return;
-          if (str.length && ~text.indexOf(str)) {
-            link.addClass('highlight');
-          } else {
-            link.removeClass('highlight');
-          }
-        });
-      }
-
-      $(window).on('content loaded', function(){
-        $('search').on('keyup', search);
-      });
-    </script>
-  </head>
-  <body class="directory">
-    <input id="search" type="text" placeholder="Search" autocomplete="off" />
-    <div id="wrapper">
-      <h1>{linked-path}</h1>
-      {files}
-    </div>
-  </body>
-</html>

node_modules/connect/lib/public/error.html

@@ -1,13 +0,0 @@
-<html>
-  <head>
-    <title>{error}</title>
-    <style>{style}</style>
-  </head>
-  <body>
-    <div id="wrapper">
-      <h1>{title}</h1>
-      <h2><em>500</em> {error}</h2>
-      <ul id="stacktrace">{stack}</ul>
-    </div>
-  </body>
-</html>