';
+}
+
+/**
+ * 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'
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/errorHandler.js b/appshell/node-core/thirdparty/connect/lib/middleware/errorHandler.js
new file mode 100644
index 000000000..4a84edca0
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/errorHandler.js
@@ -0,0 +1,86 @@
+/*!
+ * Connect - errorHandler
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('../utils')
+ , fs = require('fs');
+
+// environment
+
+var env = process.env.NODE_ENV || 'development';
+
+/**
+ * Error handler:
+ *
+ * Development error handler, providing stack traces
+ * and error message responses for requests accepting text, html,
+ * or json.
+ *
+ * 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.
+ *
+ * @return {Function}
+ * @api public
+ */
+
+exports = module.exports = function errorHandler(){
+ return function errorHandler(err, req, res, next){
+ if (err.status) res.statusCode = err.status;
+ if (res.statusCode < 400) res.statusCode = 500;
+ if ('test' != env) console.error(err.stack);
+ 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 '
' + v + '
'; }).join('');
+ html = html
+ .replace('{style}', style)
+ .replace('{stack}', stack)
+ .replace('{title}', exports.title)
+ .replace('{statusCode}', res.statusCode)
+ .replace(/\{error\}/g, utils.escape(err.toString()));
+ res.setHeader('Content-Type', 'text/html; charset=utf-8');
+ res.end(html);
+ });
+ });
+ // json
+ } else if (~accept.indexOf('json')) {
+ var error = { message: err.message, stack: err.stack };
+ for (var prop in err) error[prop] = err[prop];
+ var json = JSON.stringify({ error: error });
+ res.setHeader('Content-Type', 'application/json');
+ res.end(json);
+ // plain text
+ } else {
+ res.writeHead(res.statusCode, { 'Content-Type': 'text/plain' });
+ res.end(err.stack);
+ }
+ };
+};
+
+/**
+ * Template title, framework authors may override this value.
+ */
+
+exports.title = 'Connect';
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/favicon.js b/appshell/node-core/thirdparty/connect/lib/middleware/favicon.js
new file mode 100644
index 000000000..ef543544c
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/favicon.js
@@ -0,0 +1,80 @@
+/*!
+ * Connect - favicon
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('fs')
+ , utils = require('../utils');
+
+/**
+ * Favicon:
+ *
+ * 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:
+ *
+ * Serve default favicon:
+ *
+ * connect()
+ * .use(connect.favicon())
+ *
+ * Serve favicon before logging for brevity:
+ *
+ * connect()
+ * .use(connect.favicon())
+ * .use(connect.logger('dev'))
+ *
+ * Serve custom favicon:
+ *
+ * connect()
+ * .use(connect.favicon('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
+ , icon; // favicon cache
+
+ 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();
+ }
+ };
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/json.js b/appshell/node-core/thirdparty/connect/lib/middleware/json.js
new file mode 100644
index 000000000..f5bb1fd55
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/json.js
@@ -0,0 +1,79 @@
+
+/*!
+ * Connect - json
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('../utils')
+ , _limit = require('./limit');
+
+/**
+ * JSON:
+ *
+ * Parse JSON request bodies, providing the
+ * parsed object as `req.body`.
+ *
+ * Options:
+ *
+ * - `strict` when `false` anything `JSON.parse()` accepts will be parsed
+ * - `reviver` used as the second "reviver" argument for JSON.parse
+ * - `limit` byte limit [1mb]
+ *
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+
+exports = module.exports = function(options){
+ var options = options || {}
+ , strict = options.strict !== false;
+
+ var limit = _limit(options.limit || '1mb');
+
+ return function json(req, res, next) {
+ if (req._body) return next();
+ req.body = req.body || {};
+
+ if (!utils.hasBody(req)) return next();
+
+ // check Content-Type
+ if (!exports.regexp.test(utils.mime(req))) return next();
+
+ // flag as parsed
+ req._body = true;
+
+ // parse
+ limit(req, res, function(err){
+ if (err) return next(err);
+ var buf = '';
+ req.setEncoding('utf8');
+ req.on('data', function(chunk){ buf += chunk });
+ req.on('end', function(){
+ var first = buf.trim()[0];
+
+ if (0 == buf.length) {
+ return next(utils.error(400, 'invalid json, empty body'));
+ }
+
+ if (strict && '{' != first && '[' != first) return next(utils.error(400, 'invalid json'));
+ try {
+ req.body = JSON.parse(buf, options.reviver);
+ } catch (err){
+ err.body = buf;
+ err.status = 400;
+ return next(err);
+ }
+ next();
+ });
+ });
+ };
+};
+
+exports.regexp = /^application\/([\w!#\$%&\*`\-\.\^~]*\+)?json$/i;
+
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/limit.js b/appshell/node-core/thirdparty/connect/lib/middleware/limit.js
new file mode 100644
index 000000000..09bd1c47c
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/limit.js
@@ -0,0 +1,78 @@
+
+/*!
+ * Connect - limit
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('../utils'),
+ brokenPause = utils.brokenPause;
+
+/**
+ * Limit:
+ *
+ * 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.
+ *
+ * connect()
+ * .use(connect.limit('5.5mb'))
+ * .use(handleImageUpload)
+ *
+ * @param {Number|String} bytes
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function limit(bytes){
+ if ('string' == typeof bytes) bytes = utils.parseBytes(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;
+
+ // self-awareness
+ if (req._limit) return next();
+ req._limit = true;
+
+ // limit by content-length
+ if (len && len > bytes) return next(utils.error(413));
+
+ // limit
+ if (brokenPause) {
+ listen();
+ } else {
+ req.on('newListener', function handler(event) {
+ if (event !== 'data') return;
+
+ req.removeListener('newListener', handler);
+ // Start listening at the end of the current loop
+ // otherwise the request will be consumed too early.
+ // Sideaffect is `limit` will miss the first chunk,
+ // but that's not a big deal.
+ // Unfortunately, the tests don't have large enough
+ // request bodies to test this.
+ process.nextTick(listen);
+ });
+ };
+
+ next();
+
+ function listen() {
+ req.on('data', function(chunk) {
+ received += Buffer.isBuffer(chunk)
+ ? chunk.length :
+ Buffer.byteLength(chunk);
+
+ if (received > bytes) req.destroy();
+ });
+ };
+ };
+};
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/logger.js b/appshell/node-core/thirdparty/connect/lib/middleware/logger.js
new file mode 100644
index 000000000..7e8824885
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/logger.js
@@ -0,0 +1,339 @@
+/*!
+ * Connect - logger
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var bytes = require('bytes');
+
+/*!
+ * Log buffer.
+ */
+
+var buf = [];
+
+/*!
+ * Default log buffer duration.
+ */
+
+var defaultBufferDuration = 1000;
+
+/**
+ * Logger:
+ *
+ * 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({ immediate: true, format: 'dev' })
+ * connect.logger(':method :url - :referrer')
+ * connect.logger(':req[content-type] -> :res[content-type]')
+ * connect.logger(function(tokens, 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(''));
+ buf.length = 0;
+ }
+ }, interval);
+
+ // swap the stream
+ stream = {
+ write: function(str){
+ buf.push(str);
+ }
+ };
+ }
+
+ return function logger(req, res, next) {
+ req._startTime = new Date;
+
+ // immediate
+ if (immediate) {
+ var line = fmt(exports, req, res);
+ if (null == line) return;
+ stream.write(line + '\n');
+ // proxy end to output logging
+ } else {
+ 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');
+ };
+ }
+
+
+ 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
+ , len = parseInt(res.getHeader('Content-Length'), 10)
+ , color = 32;
+
+ if (status >= 500) color = 31
+ else if (status >= 400) color = 33
+ else if (status >= 300) color = 36;
+
+ len = isNaN(len)
+ ? ''
+ : len = ' - ' + bytes(len);
+
+ return '\x1b[90m' + req.method
+ + ' ' + req.originalUrl + ' '
+ + '\x1b[' + color + 'm' + res.statusCode
+ + ' \x1b[90m'
+ + (new Date - req._startTime)
+ + 'ms' + len
+ + '\x1b[0m';
+});
+
+/**
+ * request url
+ */
+
+exports.token('url', function(req){
+ return req.originalUrl || req.url;
+});
+
+/**
+ * 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){
+ if (req.ip) return req.ip;
+ var sock = req.socket;
+ if (sock.socket) return sock.socket.remoteAddress;
+ return sock.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()];
+});
+
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/methodOverride.js b/appshell/node-core/thirdparty/connect/lib/middleware/methodOverride.js
new file mode 100644
index 000000000..9ce493999
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/methodOverride.js
@@ -0,0 +1,59 @@
+
+/*!
+ * Connect - methodOverride
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var methods = require('methods');
+
+/**
+ * Method Override:
+ *
+ * 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) {
+ var method;
+ req.originalMethod = req.originalMethod || req.method;
+
+ // req.body
+ if (req.body && key in req.body) {
+ method = req.body[key].toLowerCase();
+ delete req.body[key];
+ }
+
+ // check X-HTTP-Method-Override
+ if (req.headers['x-http-method-override']) {
+ method = req.headers['x-http-method-override'].toLowerCase();
+ }
+
+ // replace
+ if (supports(method)) req.method = method.toUpperCase();
+
+ next();
+ };
+};
+
+/**
+ * Check if node supports `method`.
+ */
+
+function supports(method) {
+ return ~methods.indexOf(method);
+}
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/multipart.js b/appshell/node-core/thirdparty/connect/lib/middleware/multipart.js
new file mode 100644
index 000000000..5344db261
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/multipart.js
@@ -0,0 +1,158 @@
+/*!
+ * Connect - multipart
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var multiparty = require('multiparty')
+ , _limit = require('./limit')
+ , utils = require('../utils')
+ , qs = require('qs');
+
+/**
+ * Multipart:
+ *
+ * Parse multipart/form-data request bodies,
+ * providing the parsed object as `req.body`
+ * and `req.files`.
+ *
+ * Configuration:
+ *
+ * The options passed are merged with [multiparty](https://github.com/superjoe30/node-multiparty)'s
+ * `Form` object, allowing you to configure the upload directory,
+ * size limits, etc. For example if you wish to change the upload dir do the following.
+ *
+ * app.use(connect.multipart({ uploadDir: path }));
+ *
+ * Options:
+ *
+ * - `limit` byte limit defaulting to [100mb]
+ * - `defer` defers processing and exposes the multiparty form object as `req.form`.
+ * `next()` is called without waiting for the form's "end" event.
+ * This option is useful if you need to bind to the "progress" or "part" events, for example.
+ *
+ * Temporary Files:
+ *
+ * By default temporary files are used, stored in `os.tmpDir()`. These
+ * are not automatically garbage collected, you are in charge of moving them
+ * or deleting them. When `defer` is not used and these files are created you
+ * may refernce them via the `req.files` object.
+ *
+ * req.files.images.forEach(function(file){
+ * console.log(' uploaded : %s %skb : %s', file.originalFilename, file.size / 1024 | 0, file.path);
+ * });
+ *
+ * It is highly recommended to monitor and clean up tempfiles in any production
+ * environment, you may use tools like [reap](https://github.com/visionmedia/reap)
+ * to do so.
+ *
+ * Streaming:
+ *
+ * When `defer` is used files are _not_ streamed to tmpfiles, you may
+ * access them via the "part" events and stream them accordingly:
+ *
+ * req.form.on('part', function(part){
+ * // transfer to s3 etc
+ * console.log('upload %s %s', part.name, part.filename);
+ * var out = fs.createWriteStream('/tmp/' + part.filename);
+ * part.pipe(out);
+ * });
+ *
+ * req.form.on('close', function(){
+ * res.end('uploaded!');
+ * });
+ *
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+
+exports = module.exports = function(options){
+ options = options || {};
+
+ var limit = _limit(options.limit || '100mb');
+
+ return function multipart(req, res, next) {
+ if (req._body) return next();
+ req.body = req.body || {};
+ req.files = req.files || {};
+
+ if (!utils.hasBody(req)) return next();
+
+ // ignore GET
+ if ('GET' == req.method || 'HEAD' == req.method) return next();
+
+ // check Content-Type
+ if ('multipart/form-data' != utils.mime(req)) return next();
+
+ // flag as parsed
+ req._body = true;
+
+ // parse
+ limit(req, res, function(err){
+ if (err) return next(err);
+
+ var form = new multiparty.Form
+ , 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);
+ });
+
+ if (!options.defer) {
+ form.on('file', function(name, val){
+ val.name = val.originalFilename;
+ ondata(name, val, files);
+ });
+ }
+
+ form.on('error', function(err){
+ if (!options.defer) {
+ err.status = 400;
+ next(err);
+ }
+ done = true;
+ });
+
+ form.on('close', function(){
+ if (done) return;
+ try {
+ req.body = qs.parse(data);
+ req.files = qs.parse(files);
+ } catch (err) {
+ form.emit('error', err);
+ return;
+ }
+ if (!options.defer) next();
+ });
+
+ form.parse(req);
+
+ if (options.defer) {
+ req.form = form;
+ next();
+ }
+ });
+ }
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/query.js b/appshell/node-core/thirdparty/connect/lib/middleware/query.js
new file mode 100644
index 000000000..93fc5d347
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/query.js
@@ -0,0 +1,46 @@
+/*!
+ * Connect - query
+ * Copyright(c) 2011 TJ Holowaychuk
+ * Copyright(c) 2011 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var qs = require('qs')
+ , parse = require('../utils').parseUrl;
+
+/**
+ * Query:
+ *
+ * Automatically parse the query-string when available,
+ * populating the `req.query` object.
+ *
+ * Examples:
+ *
+ * connect()
+ * .use(connect.query())
+ * .use(function(req, res){
+ * res.end(JSON.stringify(req.query));
+ * });
+ *
+ * The `options` passed are provided to qs.parse function.
+ *
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function query(options){
+ return function query(req, res, next){
+ if (!req.query) {
+ req.query = ~req.url.indexOf('?')
+ ? qs.parse(parse(req).query, options)
+ : {};
+ }
+
+ next();
+ };
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/responseTime.js b/appshell/node-core/thirdparty/connect/lib/middleware/responseTime.js
new file mode 100644
index 000000000..62abc0494
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/responseTime.js
@@ -0,0 +1,32 @@
+
+/*!
+ * Connect - responseTime
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Reponse time:
+ *
+ * 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 start = new Date;
+
+ if (res._responseTime) return next();
+ res._responseTime = true;
+
+ res.on('header', function(){
+ var duration = new Date - start;
+ res.setHeader('X-Response-Time', duration + 'ms');
+ });
+
+ next();
+ };
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/session.js b/appshell/node-core/thirdparty/connect/lib/middleware/session.js
new file mode 100644
index 000000000..a10729539
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/session.js
@@ -0,0 +1,355 @@
+/*!
+ * Connect - session
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Session = require('./session/session')
+ , debug = require('debug')('connect:session')
+ , MemoryStore = require('./session/memory')
+ , signature = require('cookie-signature')
+ , Cookie = require('./session/cookie')
+ , Store = require('./session/store')
+ , utils = require('./../utils')
+ , uid = require('uid2')
+ , parse = utils.parseUrl
+ , crc32 = require('buffer-crc32');
+
+// 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 will not scale past a single process.';
+
+/**
+ * Session:
+ *
+ * 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()](cookieParser.html)
+ * middleware _before_ `session()`.
+ *
+ * Examples:
+ *
+ * connect()
+ * .use(connect.cookieParser())
+ * .use(connect.session({ secret: 'keyboard cat', key: 'sid', cookie: { secure: true }}))
+ *
+ * Options:
+ *
+ * - `key` cookie name defaulting to `connect.sid`
+ * - `store` session store instance
+ * - `secret` session cookie is signed with this secret to prevent tampering
+ * - `cookie` session cookie settings, defaulting to `{ path: '/', httpOnly: true, maxAge: null }`
+ * - `proxy` trust the reverse proxy when setting secure cookies (via "x-forwarded-proto")
+ *
+ * Cookie option:
+ *
+ * By default `cookie.maxAge` is `null`, meaning no "expires" parameter is set
+ * so the cookie becomes a browser-session cookie. When the user closes the
+ * browser the cookie (and session) will be removed.
+ *
+ * ## 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()
+ * .use(connect.favicon())
+ * .use(connect.cookieParser())
+ * .use(connect.session({ secret: 'keyboard cat', cookie: { maxAge: 60000 }}))
+ * .use(function(req, res, next){
+ * var sess = req.session;
+ * if (sess.views) {
+ * res.setHeader('Content-Type', 'text/html');
+ * res.write('
views: ' + sess.views + '
');
+ * res.write('
expires in: ' + (sess.cookie.maxAge / 1000) + 's
');
+ * 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` property. 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 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'
+ , store = options.store || new MemoryStore
+ , cookie = options.cookie || {}
+ , trustProxy = options.proxy
+ , storeReady = true;
+
+ // notify user that this store is not
+ // meant for a production environment
+ if ('production' == env && store instanceof MemoryStore) {
+ console.warn(warning);
+ }
+
+ // generates the new session
+ store.generate = function(req){
+ req.sessionID = uid(24);
+ req.session = new Session(req);
+ req.session.cookie = new Cookie(cookie);
+ };
+
+ store.on('disconnect', function(){ storeReady = false; });
+ store.on('connect', function(){ storeReady = true; });
+
+ return function session(req, res, next) {
+ // self-awareness
+ if (req.session) return next();
+
+ // Handle connection as if there is no session if
+ // the store has temporarily disconnected etc
+ if (!storeReady) return debug('store is disconnected'), next();
+
+ // pathname mismatch
+ if (0 != req.originalUrl.indexOf(cookie.path || '/')) return next();
+
+ // backwards compatibility for signed cookies
+ // req.secret is passed from the cookie parser middleware
+ var secret = options.secret || req.secret;
+
+ // ensure secret is available or bail
+ if (!secret) throw new Error('`secret` option required for sessions');
+
+ // parse url
+ var originalHash
+ , originalId;
+
+ // expose store
+ req.sessionStore = store;
+
+ // grab the session cookie value and check the signature
+ var rawCookie = req.cookies[key];
+
+ // get signedCookies for backwards compat with signed cookies
+ var unsignedCookie = req.signedCookies[key];
+
+ if (!unsignedCookie && rawCookie) {
+ unsignedCookie = utils.parseSignedCookie(rawCookie, secret);
+ }
+
+ // set-cookie
+ res.on('header', function(){
+ if (!req.session) return;
+ var cookie = req.session.cookie
+ , proto = (req.headers['x-forwarded-proto'] || '').split(',')[0].toLowerCase().trim()
+ , tls = req.connection.encrypted || (trustProxy && 'https' == proto)
+ , isNew = unsignedCookie != req.sessionID;
+
+ // only send secure cookies via https
+ if (cookie.secure && !tls) return debug('not secured');
+
+ // long expires, handle expiry server-side
+ if (!isNew && cookie.hasLongExpires) return debug('already set cookie');
+
+ // browser-session length cookie
+ if (null == cookie.expires) {
+ if (!isNew) return debug('already set browser-session cookie');
+ // compare hashes and ids
+ } else if (originalHash == hash(req.session) && originalId == req.session.id) {
+ return debug('unmodified session');
+ }
+
+ var val = 's:' + signature.sign(req.sessionID, secret);
+ val = cookie.serialize(key, val);
+ debug('set-cookie %s', val);
+ res.setHeader('Set-Cookie', val);
+ });
+
+ // proxy end() to commit the session
+ var end = res.end;
+ res.end = function(data, encoding){
+ res.end = end;
+ if (!req.session) return res.end(data, encoding);
+ debug('saving');
+ req.session.resetMaxAge();
+ req.session.save(function(err){
+ if (err) console.error(err.stack);
+ debug('saved');
+ res.end(data, encoding);
+ });
+ };
+
+ // generate the session
+ function generate() {
+ store.generate(req);
+ }
+
+ // get the sessionID from the cookie
+ req.sessionID = unsignedCookie;
+
+ // generate a session if the browser doesn't send a sessionID
+ if (!req.sessionID) {
+ debug('no SID sent, generating session');
+ generate();
+ next();
+ return;
+ }
+
+ // generate the session object
+ var pause = utils.pause(req);
+ debug('fetching %s', req.sessionID);
+ 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) {
+ debug('error %j', err);
+ if ('ENOENT' == err.code) {
+ generate();
+ next();
+ } else {
+ next(err);
+ }
+ // no session
+ } else if (!sess) {
+ debug('no session found');
+ generate();
+ next();
+ // populate req.session
+ } else {
+ debug('session found');
+ store.createSession(req, sess);
+ originalId = req.sessionID;
+ originalHash = hash(sess);
+ next();
+ }
+ });
+ };
+};
+
+/**
+ * Hash the given `sess` object omitting changes
+ * to `.cookie`.
+ *
+ * @param {Object} sess
+ * @return {String}
+ * @api private
+ */
+
+function hash(sess) {
+ return crc32.signed(JSON.stringify(sess, function(key, val){
+ if ('cookie' != key) return val;
+ }));
+}
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/session/cookie.js b/appshell/node-core/thirdparty/connect/lib/middleware/session/cookie.js
new file mode 100644
index 000000000..cdce2a5e6
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/session/cookie.js
@@ -0,0 +1,140 @@
+
+/*!
+ * Connect - session - Cookie
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('../../utils')
+ , cookie = require('cookie');
+
+/**
+ * Initialize a new `Cookie` with the given `options`.
+ *
+ * @param {IncomingMessage} req
+ * @param {Object} options
+ * @api private
+ */
+
+var Cookie = module.exports = function Cookie(options) {
+ this.path = '/';
+ this.maxAge = null;
+ this.httpOnly = true;
+ 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
+ }
+ },
+
+ /**
+ * Check if the cookie has a reasonably large max-age.
+ *
+ * @return {Boolean}
+ * @api private
+ */
+
+ get hasLongExpires() {
+ var week = 604800000;
+ return this.maxAge > (4 * week);
+ },
+
+ /**
+ * Return a serialized cookie string.
+ *
+ * @return {String}
+ * @api public
+ */
+
+ serialize: function(name, val){
+ return cookie.serialize(name, val, this.data);
+ },
+
+ /**
+ * Return JSON representation of this cookie.
+ *
+ * @return {Object}
+ * @api private
+ */
+
+ toJSON: function(){
+ return this.data;
+ }
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/session/memory.js b/appshell/node-core/thirdparty/connect/lib/middleware/session/memory.js
new file mode 100644
index 000000000..fb9393928
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/session/memory.js
@@ -0,0 +1,129 @@
+
+/*!
+ * Connect - session - MemoryStore
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Store = require('./store');
+
+/**
+ * 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);
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/session/session.js b/appshell/node-core/thirdparty/connect/lib/middleware/session/session.js
new file mode 100644
index 000000000..0dd4b4007
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/session/session.js
@@ -0,0 +1,116 @@
+
+/*!
+ * Connect - session - Session
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('../../utils');
+
+/**
+ * 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);
+};
+
+/**
+ * Update 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.resetMaxAge();
+};
+
+/**
+ * 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 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;
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/session/store.js b/appshell/node-core/thirdparty/connect/lib/middleware/session/store.js
new file mode 100644
index 000000000..54294cbdf
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/session/store.js
@@ -0,0 +1,84 @@
+
+/*!
+ * 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');
+
+/**
+ * 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);
+ 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){
+ var expires = sess.cookie.expires
+ , orig = sess.cookie.originalMaxAge;
+ 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);
+ return req.session;
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/static.js b/appshell/node-core/thirdparty/connect/lib/middleware/static.js
new file mode 100644
index 000000000..7762ac135
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/static.js
@@ -0,0 +1,95 @@
+/*!
+ * Connect - static
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var send = require('send')
+ , utils = require('../utils')
+ , parse = utils.parseUrl
+ , url = require('url');
+
+/**
+ * Static:
+ *
+ * Static file server with the given `root` path.
+ *
+ * Examples:
+ *
+ * var oneDay = 86400000;
+ *
+ * connect()
+ * .use(connect.static(__dirname + '/public'))
+ *
+ * connect()
+ * .use(connect.static(__dirname + '/public', { maxAge: oneDay }))
+ *
+ * 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. defaults to true
+ * - `index` Default file name, defaults to 'index.html'
+ *
+ * @param {String} root
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+
+exports = module.exports = function(root, options){
+ options = options || {};
+
+ // root required
+ if (!root) throw new Error('static() root path required');
+
+ // default redirect
+ var redirect = false !== options.redirect;
+
+ return function staticMiddleware(req, res, next) {
+ if ('GET' != req.method && 'HEAD' != req.method) return next();
+ var path = parse(req).pathname;
+ var pause = utils.pause(req);
+
+ function resume() {
+ next();
+ pause.resume();
+ }
+
+ function directory() {
+ if (!redirect) return resume();
+ var pathname = url.parse(req.originalUrl).pathname;
+ res.statusCode = 303;
+ res.setHeader('Location', pathname + '/');
+ res.end('Redirecting to ' + utils.escape(pathname) + '/');
+ }
+
+ function error(err) {
+ if (404 == err.status) return resume();
+ next(err);
+ }
+
+ send(req, path)
+ .maxage(options.maxAge || 0)
+ .root(root)
+ .index(options.index || 'index.html')
+ .hidden(options.hidden)
+ .on('error', error)
+ .on('directory', directory)
+ .pipe(res);
+ };
+};
+
+/**
+ * Expose mime module.
+ *
+ * If you wish to extend the mime table use this
+ * reference to the "mime" module in the npm registry.
+ */
+
+exports.mime = send.mime;
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/staticCache.js b/appshell/node-core/thirdparty/connect/lib/middleware/staticCache.js
new file mode 100644
index 000000000..7354a8ffd
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/staticCache.js
@@ -0,0 +1,231 @@
+
+/*!
+ * Connect - staticCache
+ * Copyright(c) 2011 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('../utils')
+ , Cache = require('../cache')
+ , fresh = require('fresh');
+
+/**
+ * Static cache:
+ *
+ * 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 {Object} options
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function staticCache(options){
+ var options = options || {}
+ , cache = new Cache(options.maxObjects || 128)
+ , maxlen = options.maxLength || 1024 * 256;
+
+ console.warn('connect.staticCache() is deprecated and will be removed in 3.0');
+ console.warn('use varnish or similar reverse proxy caches.');
+
+ return function staticCache(req, res, next){
+ var key = cacheKey(req)
+ , ranges = req.headers.range
+ , hasCookies = req.headers.cookie
+ , hit = cache.get(key);
+
+ // cache static
+ // TODO: change from staticCache() -> cache()
+ // and make this work for any request
+ req.on('static', function(stream){
+ var headers = res._headers
+ , cc = utils.parseCacheControl(headers['cache-control'] || '')
+ , contentLength = headers['content-length']
+ , hit;
+
+ // dont cache set-cookie responses
+ if (headers['set-cookie']) return hasCookies = true;
+
+ // dont cache when cookies are present
+ if (hasCookies) return;
+
+ // ignore larger files
+ if (!contentLength || contentLength > maxlen) return;
+
+ // don't cache partial files
+ if (headers['content-range']) return;
+
+ // dont cache items we shouldn't be
+ // TODO: real support for must-revalidate / no-cache
+ if ( cc['no-cache']
+ || cc['no-store']
+ || cc['private']
+ || cc['must-revalidate']) return;
+
+ // if already in cache then validate
+ if (hit = cache.get(key)){
+ if (headers.etag == hit[0].etag) {
+ hit[0].date = new Date;
+ return;
+ } else {
+ cache.remove(key);
+ }
+ }
+
+ // validation notifiactions don't contain a steam
+ if (null == stream) return;
+
+ // add the cache object
+ var arr = [];
+
+ // store the chunks
+ stream.on('data', function(chunk){
+ arr.push(chunk);
+ });
+
+ // flag it as complete
+ stream.on('end', function(){
+ var cacheEntry = cache.add(key);
+ delete headers['x-cache']; // Clean up (TODO: others)
+ cacheEntry.push(200);
+ cacheEntry.push(headers);
+ cacheEntry.push.apply(cacheEntry, arr);
+ });
+ });
+
+ if (req.method == 'GET' || req.method == 'HEAD') {
+ if (ranges) {
+ next();
+ } else if (!hasCookies && hit && !mustRevalidate(req, hit)) {
+ res.setHeader('X-Cache', 'HIT');
+ respondFromCache(req, res, hit);
+ } else {
+ res.setHeader('X-Cache', 'MISS');
+ next();
+ }
+ } else {
+ next();
+ }
+ }
+};
+
+/**
+ * Respond with the provided cached value.
+ * TODO: Assume 200 code, that's iffy.
+ *
+ * @param {Object} req
+ * @param {Object} res
+ * @param {Object} cacheEntry
+ * @return {String}
+ * @api private
+ */
+
+function respondFromCache(req, res, cacheEntry) {
+ var status = cacheEntry[0]
+ , headers = utils.merge({}, cacheEntry[1])
+ , content = cacheEntry.slice(2);
+
+ headers.age = (new Date - new Date(headers.date)) / 1000 || 0;
+
+ switch (req.method) {
+ case 'HEAD':
+ res.writeHead(status, headers);
+ res.end();
+ break;
+ case 'GET':
+ if (utils.conditionalGET(req) && fresh(req.headers, headers)) {
+ headers['content-length'] = 0;
+ res.writeHead(304, headers);
+ res.end();
+ } else {
+ res.writeHead(status, headers);
+
+ function write() {
+ while (content.length) {
+ if (false === res.write(content.shift())) {
+ res.once('drain', write);
+ return;
+ }
+ }
+ res.end();
+ }
+
+ write();
+ }
+ break;
+ default:
+ // This should never happen.
+ res.writeHead(500, '');
+ res.end();
+ }
+}
+
+/**
+ * Determine whether or not a cached value must be revalidated.
+ *
+ * @param {Object} req
+ * @param {Object} cacheEntry
+ * @return {String}
+ * @api private
+ */
+
+function mustRevalidate(req, cacheEntry) {
+ var cacheHeaders = cacheEntry[1]
+ , reqCC = utils.parseCacheControl(req.headers['cache-control'] || '')
+ , cacheCC = utils.parseCacheControl(cacheHeaders['cache-control'] || '')
+ , cacheAge = (new Date - new Date(cacheHeaders.date)) / 1000 || 0;
+
+ if ( cacheCC['no-cache']
+ || cacheCC['must-revalidate']
+ || cacheCC['proxy-revalidate']) return true;
+
+ if (reqCC['no-cache']) return true;
+
+ if (null != reqCC['max-age']) return reqCC['max-age'] < cacheAge;
+
+ if (null != cacheCC['max-age']) return cacheCC['max-age'] < cacheAge;
+
+ return false;
+}
+
+/**
+ * The key to use in the cache. For now, this is the URL path and query.
+ *
+ * 'http://example.com?key=value' -> '/?key=value'
+ *
+ * @param {Object} req
+ * @return {String}
+ * @api private
+ */
+
+function cacheKey(req) {
+ return utils.parseUrl(req).path;
+}
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/timeout.js b/appshell/node-core/thirdparty/connect/lib/middleware/timeout.js
new file mode 100644
index 000000000..5496c024e
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/timeout.js
@@ -0,0 +1,55 @@
+/*!
+ * Connect - timeout
+ * Ported from https://github.com/LearnBoost/connect-timeout
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var debug = require('debug')('connect:timeout');
+
+/**
+ * Timeout:
+ *
+ * Times out the request in `ms`, defaulting to `5000`. The
+ * method `req.clearTimeout()` is added to revert this behaviour
+ * programmatically within your application's middleware, routes, etc.
+ *
+ * The timeout error is passed to `next()` so that you may customize
+ * the response behaviour. This error has the `.timeout` property as
+ * well as `.status == 503`.
+ *
+ * @param {Number} ms
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function timeout(ms) {
+ ms = ms || 5000;
+
+ return function(req, res, next) {
+ var id = setTimeout(function(){
+ req.emit('timeout', ms);
+ }, ms);
+
+ req.on('timeout', function(){
+ if (res.headerSent) return debug('response started, cannot timeout');
+ var err = new Error('Response timeout');
+ err.timeout = ms;
+ err.status = 503;
+ next(err);
+ });
+
+ req.clearTimeout = function(){
+ clearTimeout(id);
+ };
+
+ res.on('header', function(){
+ clearTimeout(id);
+ });
+
+ next();
+ };
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/urlencoded.js b/appshell/node-core/thirdparty/connect/lib/middleware/urlencoded.js
new file mode 100644
index 000000000..bb73a3a81
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/urlencoded.js
@@ -0,0 +1,76 @@
+
+/*!
+ * Connect - urlencoded
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('../utils')
+ , _limit = require('./limit')
+ , qs = require('qs');
+
+/**
+ * noop middleware.
+ */
+
+function noop(req, res, next) {
+ next();
+}
+
+/**
+ * Urlencoded:
+ *
+ * Parse x-ww-form-urlencoded request bodies,
+ * providing the parsed object as `req.body`.
+ *
+ * Options:
+ *
+ * - `limit` byte limit [1mb]
+ *
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+
+exports = module.exports = function(options){
+ options = options || {};
+
+ var limit = _limit(options.limit || '1mb');
+
+ return function urlencoded(req, res, next) {
+ if (req._body) return next();
+ req.body = req.body || {};
+
+ if (!utils.hasBody(req)) return next();
+
+ // check Content-Type
+ if ('application/x-www-form-urlencoded' != utils.mime(req)) return next();
+
+ // flag as parsed
+ req._body = true;
+
+ // parse
+ limit(req, res, function(err){
+ if (err) return next(err);
+ var buf = '';
+ req.setEncoding('utf8');
+ req.on('data', function(chunk){ buf += chunk });
+ req.on('end', function(){
+ try {
+ req.body = buf.length
+ ? qs.parse(buf, options)
+ : {};
+ } catch (err){
+ err.body = buf;
+ return next(err);
+ }
+ next();
+ });
+ });
+ }
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/middleware/vhost.js b/appshell/node-core/thirdparty/connect/lib/middleware/vhost.js
new file mode 100644
index 000000000..abbb0500a
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/middleware/vhost.js
@@ -0,0 +1,40 @@
+
+/*!
+ * Connect - vhost
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Vhost:
+ *
+ * Setup vhost for the given `hostname` and `server`.
+ *
+ * connect()
+ * .use(connect.vhost('foo.com', fooApp))
+ * .use(connect.vhost('bar.com', barApp))
+ * .use(connect.vhost('*.com', mainApp))
+ *
+ * The `server` may be a Connect server or
+ * a regular Node `http.Server`.
+ *
+ * @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(/[^*\w]/g, '\\$&').replace(/[*]/g, '(?:.*?)') + '$', 'i');
+ 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 (!regexp.test(host)) return next();
+ if ('function' == typeof server) return server(req, res, next);
+ server.emit('request', req, res);
+ };
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/patch.js b/appshell/node-core/thirdparty/connect/lib/patch.js
new file mode 100644
index 000000000..7cf001255
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/patch.js
@@ -0,0 +1,79 @@
+
+/*!
+ * Connect
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var http = require('http')
+ , res = http.ServerResponse.prototype
+ , setHeader = res.setHeader
+ , _renderHeaders = res._renderHeaders
+ , writeHead = res.writeHead;
+
+// apply only once
+
+if (!res._hasConnectPatch) {
+
+ /**
+ * Provide a public "header sent" flag
+ * until node does.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+
+ res.__defineGetter__('headerSent', function(){
+ return this._header;
+ });
+
+ /**
+ * 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 to emit "header" event.
+ */
+
+ res._renderHeaders = function(){
+ if (!this._emittedHeader) this.emit('header');
+ this._emittedHeader = true;
+ return _renderHeaders.call(this);
+ };
+
+ res.writeHead = function(){
+ if (!this._emittedHeader) this.emit('header');
+ this._emittedHeader = true;
+ return writeHead.apply(this, arguments);
+ };
+
+ res._hasConnectPatch = true;
+}
diff --git a/appshell/node-core/thirdparty/connect/lib/proto.js b/appshell/node-core/thirdparty/connect/lib/proto.js
new file mode 100644
index 000000000..6fadf8fd3
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/proto.js
@@ -0,0 +1,230 @@
+
+/*!
+ * Connect - HTTPServer
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var http = require('http')
+ , utils = require('./utils')
+ , debug = require('debug')('connect:dispatcher');
+
+// prototype
+
+var app = module.exports = {};
+
+// environment
+
+var env = process.env.NODE_ENV || 'development';
+
+/**
+ * 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_.
+ *
+ * Examples:
+ *
+ * var app = connect();
+ * app.use(connect.favicon());
+ * app.use(connect.logger());
+ * app.use(connect.static(__dirname + '/public'));
+ *
+ * If we wanted to prefix static files with _/public_, we could
+ * "mount" the `static()` middleware:
+ *
+ * app.use('/public', connect.static(__dirname + '/public'));
+ *
+ * This api is chainable, so the following is valid:
+ *
+ * connect()
+ * .use(connect.favicon())
+ * .use(connect.logger())
+ * .use(connect.static(__dirname + '/public'))
+ * .listen(3000);
+ *
+ * @param {String|Function|Server} route, callback or server
+ * @param {Function|Server} callback or server
+ * @return {Server} for chaining
+ * @api public
+ */
+
+app.use = function(route, fn){
+ // default route to '/'
+ if ('string' != typeof route) {
+ fn = route;
+ route = '/';
+ }
+
+ // wrap sub-apps
+ if ('function' == typeof fn.handle) {
+ var server = fn;
+ fn.route = route;
+ fn = function(req, res, next){
+ server.handle(req, res, next);
+ };
+ }
+
+ // wrap vanilla http.Servers
+ if (fn instanceof http.Server) {
+ fn = fn.listeners('request')[0];
+ }
+
+ // strip trailing slash
+ if ('/' == route[route.length - 1]) {
+ route = route.slice(0, -1);
+ }
+
+ // add the middleware
+ debug('use %s %s', route || '/', fn.name || 'anonymous');
+ this.stack.push({ route: route, handle: fn });
+
+ return this;
+};
+
+/**
+ * Handle server requests, punting them down
+ * the middleware stack.
+ *
+ * @api private
+ */
+
+app.handle = function(req, res, out) {
+ var stack = this.stack
+ , fqdn = ~req.url.indexOf('://')
+ , removed = ''
+ , slashAdded = false
+ , index = 0;
+
+ function next(err) {
+ var layer, path, status, c;
+
+ if (slashAdded) {
+ req.url = req.url.substr(1);
+ slashAdded = false;
+ }
+
+ req.url = removed + req.url;
+ req.originalUrl = req.originalUrl || req.url;
+ removed = '';
+
+ // next callback
+ layer = stack[index++];
+
+ // all done
+ if (!layer || res.headerSent) {
+ // delegate to parent
+ if (out) return out(err);
+
+ // unhandled error
+ if (err) {
+ // default to 500
+ if (res.statusCode < 400) res.statusCode = 500;
+ debug('default %s', res.statusCode);
+
+ // respect err.status
+ if (err.status) res.statusCode = err.status;
+
+ // production gets a basic error message
+ var msg = 'production' == env
+ ? http.STATUS_CODES[res.statusCode]
+ : err.stack || err.toString();
+
+ // log to stderr in a non-test env
+ if ('test' != env) console.error(err.stack || err.toString());
+ if (res.headerSent) return req.socket.destroy();
+ res.setHeader('Content-Type', 'text/plain');
+ res.setHeader('Content-Length', Buffer.byteLength(msg));
+ if ('HEAD' == req.method) return res.end();
+ res.end(msg);
+ } else {
+ debug('default 404');
+ res.statusCode = 404;
+ res.setHeader('Content-Type', 'text/plain');
+ if ('HEAD' == req.method) return res.end();
+ res.end('Cannot ' + utils.escape(req.method) + ' ' + utils.escape(req.originalUrl));
+ }
+ return;
+ }
+
+ try {
+ path = utils.parseUrl(req).pathname;
+ if (undefined == path) path = '/';
+
+ // skip this layer if the route doesn't match.
+ if (0 != path.toLowerCase().indexOf(layer.route.toLowerCase())) 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 (!fqdn && '/' != req.url[0]) {
+ req.url = '/' + req.url;
+ slashAdded = true;
+ }
+
+ debug('%s %s : %s', layer.handle.name || 'anonymous', layer.route, req.originalUrl);
+ 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) {
+ next(e);
+ }
+ }
+ next();
+};
+
+/**
+ * Listen for connections.
+ *
+ * This method takes the same arguments
+ * as node's `http.Server#listen()`.
+ *
+ * HTTP and HTTPS:
+ *
+ * If you run your application both as HTTP
+ * and HTTPS you may wrap them individually,
+ * since your Connect "server" is really just
+ * a JavaScript `Function`.
+ *
+ * var connect = require('connect')
+ * , http = require('http')
+ * , https = require('https');
+ *
+ * var app = connect();
+ *
+ * http.createServer(app).listen(80);
+ * https.createServer(options, app).listen(443);
+ *
+ * @return {http.Server}
+ * @api public
+ */
+
+app.listen = function(){
+ var server = http.createServer(this);
+ return server.listen.apply(server, arguments);
+};
diff --git a/appshell/node-core/thirdparty/connect/lib/public/directory.html b/appshell/node-core/thirdparty/connect/lib/public/directory.html
new file mode 100644
index 000000000..2d6370421
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/public/directory.html
@@ -0,0 +1,81 @@
+
+
+
+
+ listing directory {directory}
+
+
+
+
+
+
+
{linked-path}
+ {files}
+
+
+
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/lib/public/error.html b/appshell/node-core/thirdparty/connect/lib/public/error.html
new file mode 100644
index 000000000..a6d3fafd8
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/public/error.html
@@ -0,0 +1,14 @@
+
+
+
+ {error}
+
+
+
+
+
{title}
+
{statusCode} {error}
+
{stack}
+
+
+
diff --git a/appshell/node-core/thirdparty/connect/lib/public/favicon.ico b/appshell/node-core/thirdparty/connect/lib/public/favicon.ico
new file mode 100644
index 000000000..895fc96a7
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/favicon.ico differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page.png
new file mode 100644
index 000000000..03ddd799f
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_add.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_add.png
new file mode 100644
index 000000000..d5bfa0719
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_add.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_attach.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_attach.png
new file mode 100644
index 000000000..89ee2da07
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_attach.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_code.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_code.png
new file mode 100644
index 000000000..f7ea90419
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_code.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_copy.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_copy.png
new file mode 100644
index 000000000..195dc6d6c
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_copy.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_delete.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_delete.png
new file mode 100644
index 000000000..3141467c6
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_delete.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_edit.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_edit.png
new file mode 100644
index 000000000..046811ed7
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_edit.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_error.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_error.png
new file mode 100644
index 000000000..f07f449a4
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_error.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_excel.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_excel.png
new file mode 100644
index 000000000..eb6158eb5
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_excel.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_find.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_find.png
new file mode 100644
index 000000000..2f193889f
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_find.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_gear.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_gear.png
new file mode 100644
index 000000000..8e83281c5
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_gear.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_go.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_go.png
new file mode 100644
index 000000000..80fe1ed0c
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_go.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_green.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_green.png
new file mode 100644
index 000000000..de8e003f9
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_green.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_key.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_key.png
new file mode 100644
index 000000000..d6626cb09
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_key.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_lightning.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_lightning.png
new file mode 100644
index 000000000..7e568703d
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_lightning.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_link.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_link.png
new file mode 100644
index 000000000..312eab091
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_link.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_paintbrush.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_paintbrush.png
new file mode 100644
index 000000000..246a2f0b4
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_paintbrush.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_paste.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_paste.png
new file mode 100644
index 000000000..968f073fd
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_paste.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_red.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_red.png
new file mode 100644
index 000000000..0b18247da
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_red.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_refresh.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_refresh.png
new file mode 100644
index 000000000..cf347c7d4
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_refresh.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_save.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_save.png
new file mode 100644
index 000000000..caea546af
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_save.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white.png
new file mode 100644
index 000000000..8b8b1ca00
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_acrobat.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_acrobat.png
new file mode 100644
index 000000000..8f8095e46
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_acrobat.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_actionscript.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_actionscript.png
new file mode 100644
index 000000000..159b24075
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_actionscript.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_add.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_add.png
new file mode 100644
index 000000000..aa23dde37
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_add.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_c.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_c.png
new file mode 100644
index 000000000..34a05cccf
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_c.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_camera.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_camera.png
new file mode 100644
index 000000000..f501a593a
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_camera.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_cd.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_cd.png
new file mode 100644
index 000000000..848bdaf3f
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_cd.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_code.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_code.png
new file mode 100644
index 000000000..0c76bd129
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_code.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_code_red.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_code_red.png
new file mode 100644
index 000000000..87a691450
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_code_red.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_coldfusion.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_coldfusion.png
new file mode 100644
index 000000000..c66011fb0
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_coldfusion.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_compressed.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_compressed.png
new file mode 100644
index 000000000..2b6b1007f
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_compressed.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_copy.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_copy.png
new file mode 100644
index 000000000..a9f31a278
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_copy.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_cplusplus.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_cplusplus.png
new file mode 100644
index 000000000..a87cf847c
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_cplusplus.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_csharp.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_csharp.png
new file mode 100644
index 000000000..ffb8fc932
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_csharp.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_cup.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_cup.png
new file mode 100644
index 000000000..0a7d6f4a6
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_cup.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_database.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_database.png
new file mode 100644
index 000000000..bddba1f98
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_database.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_delete.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_delete.png
new file mode 100644
index 000000000..af1ecaf29
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_delete.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_dvd.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_dvd.png
new file mode 100644
index 000000000..4cc537af0
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_dvd.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_edit.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_edit.png
new file mode 100644
index 000000000..b93e77600
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_edit.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_error.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_error.png
new file mode 100644
index 000000000..9fc5a0a10
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_error.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_excel.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_excel.png
new file mode 100644
index 000000000..b977d7e52
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_excel.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_find.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_find.png
new file mode 100644
index 000000000..581843637
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_find.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_flash.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_flash.png
new file mode 100644
index 000000000..5769120b1
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_flash.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_freehand.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_freehand.png
new file mode 100644
index 000000000..8d719df52
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_freehand.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_gear.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_gear.png
new file mode 100644
index 000000000..106f5aa36
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_gear.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_get.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_get.png
new file mode 100644
index 000000000..e4a1ecba1
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_get.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_go.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_go.png
new file mode 100644
index 000000000..7e62a924b
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_go.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_h.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_h.png
new file mode 100644
index 000000000..e902abb07
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_h.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_horizontal.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_horizontal.png
new file mode 100644
index 000000000..1d2d0a498
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_horizontal.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_key.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_key.png
new file mode 100644
index 000000000..d61648452
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_key.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_lightning.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_lightning.png
new file mode 100644
index 000000000..7215d1e8b
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_lightning.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_link.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_link.png
new file mode 100644
index 000000000..bf7bd1c9b
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_link.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_magnify.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_magnify.png
new file mode 100644
index 000000000..f6b74cc40
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_magnify.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_medal.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_medal.png
new file mode 100644
index 000000000..d3fffb6d9
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_medal.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_office.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_office.png
new file mode 100644
index 000000000..a65bcb3e1
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_office.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_paint.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_paint.png
new file mode 100644
index 000000000..23a37b891
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_paint.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_paintbrush.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_paintbrush.png
new file mode 100644
index 000000000..f907e44b3
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_paintbrush.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_paste.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_paste.png
new file mode 100644
index 000000000..5b2cbb3fd
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_paste.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_php.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_php.png
new file mode 100644
index 000000000..7868a2594
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_php.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_picture.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_picture.png
new file mode 100644
index 000000000..134b66936
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_picture.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_powerpoint.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_powerpoint.png
new file mode 100644
index 000000000..c4eff0387
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_powerpoint.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_put.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_put.png
new file mode 100644
index 000000000..884ffd6f0
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_put.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_ruby.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_ruby.png
new file mode 100644
index 000000000..f59b7c436
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_ruby.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_stack.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_stack.png
new file mode 100644
index 000000000..44084add7
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_stack.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_star.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_star.png
new file mode 100644
index 000000000..3a1441c9a
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_star.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_swoosh.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_swoosh.png
new file mode 100644
index 000000000..e7708292a
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_swoosh.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_text.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_text.png
new file mode 100644
index 000000000..813f712f7
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_text.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_text_width.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_text_width.png
new file mode 100644
index 000000000..d9cf13256
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_text_width.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_tux.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_tux.png
new file mode 100644
index 000000000..52699bfee
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_tux.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_vector.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_vector.png
new file mode 100644
index 000000000..4a05955b3
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_vector.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_visualstudio.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_visualstudio.png
new file mode 100644
index 000000000..a0a433dfb
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_visualstudio.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_width.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_width.png
new file mode 100644
index 000000000..1eb880947
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_width.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_word.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_word.png
new file mode 100644
index 000000000..ae8ecbf47
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_word.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_world.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_world.png
new file mode 100644
index 000000000..6ed2490ed
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_world.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_wrench.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_wrench.png
new file mode 100644
index 000000000..fecadd08a
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_wrench.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_zip.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_zip.png
new file mode 100644
index 000000000..fd4bbccdf
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_white_zip.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_word.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_word.png
new file mode 100644
index 000000000..834cdfaf4
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_word.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/icons/page_world.png b/appshell/node-core/thirdparty/connect/lib/public/icons/page_world.png
new file mode 100644
index 000000000..b8895ddec
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/lib/public/icons/page_world.png differ
diff --git a/appshell/node-core/thirdparty/connect/lib/public/style.css b/appshell/node-core/thirdparty/connect/lib/public/style.css
new file mode 100644
index 000000000..32b650710
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/public/style.css
@@ -0,0 +1,141 @@
+body {
+ margin: 0;
+ padding: 80px 100px;
+ font: 13px "Helvetica Neue", "Lucida Grande", "Arial";
+ background: #ECE9E9 -webkit-gradient(linear, 0% 0%, 0% 100%, from(#fff), to(#ECE9E9));
+ background: #ECE9E9 -moz-linear-gradient(top, #fff, #ECE9E9);
+ background-repeat: no-repeat;
+ color: #555;
+ -webkit-font-smoothing: antialiased;
+}
+h1, h2, h3 {
+ margin: 0;
+ font-size: 22px;
+ color: #343434;
+}
+h1 em, h2 em {
+ padding: 0 5px;
+ font-weight: normal;
+}
+h1 {
+ font-size: 60px;
+}
+h2 {
+ margin-top: 10px;
+}
+h3 {
+ margin: 5px 0 10px 0;
+ padding-bottom: 5px;
+ border-bottom: 1px solid #eee;
+ font-size: 18px;
+}
+ul {
+ margin: 0;
+ padding: 0;
+}
+ul li {
+ margin: 5px 0;
+ padding: 3px 8px;
+ list-style: none;
+}
+ul li:hover {
+ cursor: pointer;
+ color: #2e2e2e;
+}
+ul li .path {
+ padding-left: 5px;
+ font-weight: bold;
+}
+ul li .line {
+ padding-right: 5px;
+ font-style: italic;
+}
+ul li:first-child .path {
+ padding-left: 0;
+}
+p {
+ line-height: 1.5;
+}
+a {
+ color: #555;
+ text-decoration: none;
+}
+a:hover {
+ color: #303030;
+}
+#stacktrace {
+ margin-top: 15px;
+}
+.directory h1 {
+ margin-bottom: 15px;
+ font-size: 18px;
+}
+ul#files {
+ width: 100%;
+ height: 500px;
+}
+ul#files li {
+ padding: 0;
+}
+ul#files li img {
+ position: absolute;
+ top: 5px;
+ left: 5px;
+}
+ul#files li a {
+ position: relative;
+ display: block;
+ margin: 1px;
+ width: 30%;
+ height: 25px;
+ line-height: 25px;
+ text-indent: 8px;
+ float: left;
+ border: 1px solid transparent;
+ -webkit-border-radius: 5px;
+ -moz-border-radius: 5px;
+ border-radius: 5px;
+ overflow: hidden;
+ text-overflow: ellipsis;
+}
+ul#files li a.icon {
+ text-indent: 25px;
+}
+ul#files li a:focus,
+ul#files li a:hover {
+ outline: none;
+ background: rgba(255,255,255,0.65);
+ border: 1px solid #ececec;
+}
+ul#files li a.highlight {
+ -webkit-transition: background .4s ease-in-out;
+ background: #ffff4f;
+ border-color: #E9DC51;
+}
+#search {
+ display: block;
+ position: fixed;
+ top: 20px;
+ right: 20px;
+ width: 90px;
+ -webkit-transition: width ease 0.2s, opacity ease 0.4s;
+ -moz-transition: width ease 0.2s, opacity ease 0.4s;
+ -webkit-border-radius: 32px;
+ -moz-border-radius: 32px;
+ -webkit-box-shadow: inset 0px 0px 3px rgba(0, 0, 0, 0.25), inset 0px 1px 3px rgba(0, 0, 0, 0.7), 0px 1px 0px rgba(255, 255, 255, 0.03);
+ -moz-box-shadow: inset 0px 0px 3px rgba(0, 0, 0, 0.25), inset 0px 1px 3px rgba(0, 0, 0, 0.7), 0px 1px 0px rgba(255, 255, 255, 0.03);
+ -webkit-font-smoothing: antialiased;
+ text-align: left;
+ font: 13px "Helvetica Neue", Arial, sans-serif;
+ padding: 4px 10px;
+ border: none;
+ background: transparent;
+ margin-bottom: 0;
+ outline: none;
+ opacity: 0.7;
+ color: #888;
+}
+#search:focus {
+ width: 120px;
+ opacity: 1.0;
+}
diff --git a/appshell/node-core/thirdparty/connect/lib/utils.js b/appshell/node-core/thirdparty/connect/lib/utils.js
new file mode 100644
index 000000000..d52009a9a
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/lib/utils.js
@@ -0,0 +1,386 @@
+
+/*!
+ * Connect - utils
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var http = require('http')
+ , crypto = require('crypto')
+ , parse = require('url').parse
+ , signature = require('cookie-signature')
+ , nodeVersion = process.versions.node.split('.');
+
+// pause is broken in node < 0.10
+exports.brokenPause = parseInt(nodeVersion[0], 10) === 0
+ && parseInt(nodeVersion[1], 10) < 10;
+
+/**
+ * Return `true` if the request has a body, otherwise return `false`.
+ *
+ * @param {IncomingMessage} req
+ * @return {Boolean}
+ * @api private
+ */
+
+exports.hasBody = function(req) {
+ var encoding = 'transfer-encoding' in req.headers;
+ var length = 'content-length' in req.headers && req.headers['content-length'] !== '0';
+ return encoding || length;
+};
+
+/**
+ * Extract the mime type from the given request's
+ * _Content-Type_ header.
+ *
+ * @param {IncomingMessage} req
+ * @return {String}
+ * @api private
+ */
+
+exports.mime = function(req) {
+ var str = req.headers['content-type'] || '';
+ return str.split(';')[0];
+};
+
+/**
+ * Generate an `Error` from the given status `code`
+ * and optional `msg`.
+ *
+ * @param {Number} code
+ * @param {String} msg
+ * @return {Error}
+ * @api private
+ */
+
+exports.error = function(code, msg){
+ var err = new Error(msg || http.STATUS_CODES[code]);
+ err.status = code;
+ return err;
+};
+
+/**
+ * Return md5 hash of the given string and optional encoding,
+ * defaulting to hex.
+ *
+ * utils.md5('wahoo');
+ * // => "e493298061761236c96b02ea6aa8a2ad"
+ *
+ * @param {String} str
+ * @param {String} encoding
+ * @return {String}
+ * @api private
+ */
+
+exports.md5 = function(str, encoding){
+ return crypto
+ .createHash('md5')
+ .update(str)
+ .digest(encoding || 'hex');
+};
+
+/**
+ * Merge object b with object a.
+ *
+ * var a = { foo: 'bar' }
+ * , b = { bar: 'baz' };
+ *
+ * utils.merge(a, b);
+ * // => { foo: 'bar', bar: 'baz' }
+ *
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object}
+ * @api private
+ */
+
+exports.merge = function(a, b){
+ if (a && b) {
+ for (var key in b) {
+ a[key] = b[key];
+ }
+ }
+ return a;
+};
+
+/**
+ * Escape the given string of `html`.
+ *
+ * @param {String} html
+ * @return {String}
+ * @api private
+ */
+
+exports.escape = function(html){
+ return String(html)
+ .replace(/&(?!\w+;)/g, '&')
+ .replace(//g, '>')
+ .replace(/"/g, '"');
+};
+
+/**
+ * Sign the given `val` with `secret`.
+ *
+ * @param {String} val
+ * @param {String} secret
+ * @return {String}
+ * @api private
+ */
+
+exports.sign = function(val, secret){
+ console.warn('do not use utils.sign(), use https://github.com/visionmedia/node-cookie-signature')
+ return val + '.' + crypto
+ .createHmac('sha256', secret)
+ .update(val)
+ .digest('base64')
+ .replace(/=+$/, '');
+};
+
+/**
+ * Unsign and decode the given `val` with `secret`,
+ * returning `false` if the signature is invalid.
+ *
+ * @param {String} val
+ * @param {String} secret
+ * @return {String|Boolean}
+ * @api private
+ */
+
+exports.unsign = function(val, secret){
+ console.warn('do not use utils.unsign(), use https://github.com/visionmedia/node-cookie-signature')
+ var str = val.slice(0, val.lastIndexOf('.'));
+ return exports.sign(str, secret) == val
+ ? str
+ : false;
+};
+
+/**
+ * Parse signed cookies, returning an object
+ * containing the decoded key/value pairs,
+ * while removing the signed key from `obj`.
+ *
+ * @param {Object} obj
+ * @return {Object}
+ * @api private
+ */
+
+exports.parseSignedCookies = function(obj, secret){
+ var ret = {};
+ Object.keys(obj).forEach(function(key){
+ var val = obj[key];
+ if (0 == val.indexOf('s:')) {
+ val = signature.unsign(val.slice(2), secret);
+ if (val) {
+ ret[key] = val;
+ delete obj[key];
+ }
+ }
+ });
+ return ret;
+};
+
+/**
+ * Parse a signed cookie string, return the decoded value
+ *
+ * @param {String} str signed cookie string
+ * @param {String} secret
+ * @return {String} decoded value
+ * @api private
+ */
+
+exports.parseSignedCookie = function(str, secret){
+ return 0 == str.indexOf('s:')
+ ? signature.unsign(str.slice(2), secret)
+ : str;
+};
+
+/**
+ * Parse JSON cookies.
+ *
+ * @param {Object} obj
+ * @return {Object}
+ * @api private
+ */
+
+exports.parseJSONCookies = function(obj){
+ Object.keys(obj).forEach(function(key){
+ var val = obj[key];
+ var res = exports.parseJSONCookie(val);
+ if (res) obj[key] = res;
+ });
+ return obj;
+};
+
+/**
+ * Parse JSON cookie string
+ *
+ * @param {String} str
+ * @return {Object} Parsed object or null if not json cookie
+ * @api private
+ */
+
+exports.parseJSONCookie = function(str) {
+ if (0 == str.indexOf('j:')) {
+ try {
+ return JSON.parse(str.slice(2));
+ } catch (err) {
+ // no op
+ }
+ }
+};
+
+/**
+ * Pause `data` and `end` events on the given `obj`.
+ * Middleware performing async tasks _should_ utilize
+ * this utility (or similar), to re-emit data once
+ * the async operation has completed, otherwise these
+ * events may be lost. Pause is only required for
+ * node versions less than 10, and is replaced with
+ * noop's otherwise.
+ *
+ * var pause = utils.pause(req);
+ * fs.readFile(path, function(){
+ * next();
+ * pause.resume();
+ * });
+ *
+ * @param {Object} obj
+ * @return {Object}
+ * @api private
+ */
+
+exports.pause = exports.brokenPause
+ ? require('pause')
+ : function () {
+ return {
+ end: noop,
+ resume: noop
+ }
+ }
+
+/**
+ * Strip `Content-*` headers from `res`.
+ *
+ * @param {ServerResponse} res
+ * @api private
+ */
+
+exports.removeContentHeaders = function(res){
+ Object.keys(res._headers).forEach(function(field){
+ if (0 == field.indexOf('content')) {
+ res.removeHeader(field);
+ }
+ });
+};
+
+/**
+ * Check if `req` is a conditional GET request.
+ *
+ * @param {IncomingMessage} req
+ * @return {Boolean}
+ * @api private
+ */
+
+exports.conditionalGET = function(req) {
+ return req.headers['if-modified-since']
+ || req.headers['if-none-match'];
+};
+
+/**
+ * Respond with 401 "Unauthorized".
+ *
+ * @param {ServerResponse} res
+ * @param {String} realm
+ * @api private
+ */
+
+exports.unauthorized = function(res, realm) {
+ res.statusCode = 401;
+ res.setHeader('WWW-Authenticate', 'Basic realm="' + realm + '"');
+ res.end('Unauthorized');
+};
+
+/**
+ * Respond with 304 "Not Modified".
+ *
+ * @param {ServerResponse} res
+ * @param {Object} headers
+ * @api private
+ */
+
+exports.notModified = function(res) {
+ exports.removeContentHeaders(res);
+ res.statusCode = 304;
+ res.end();
+};
+
+/**
+ * Return an ETag in the form of `"-"`
+ * from the given `stat`.
+ *
+ * @param {Object} stat
+ * @return {String}
+ * @api private
+ */
+
+exports.etag = function(stat) {
+ return '"' + stat.size + '-' + Number(stat.mtime) + '"';
+};
+
+/**
+ * Parse the given Cache-Control `str`.
+ *
+ * @param {String} str
+ * @return {Object}
+ * @api private
+ */
+
+exports.parseCacheControl = function(str){
+ var directives = str.split(',')
+ , obj = {};
+
+ for(var i = 0, len = directives.length; i < len; i++) {
+ var parts = directives[i].split('=')
+ , key = parts.shift().trim()
+ , val = parseInt(parts.shift(), 10);
+
+ obj[key] = isNaN(val) ? true : val;
+ }
+
+ return obj;
+};
+
+/**
+ * Parse the `req` url with memoization.
+ *
+ * @param {ServerRequest} req
+ * @return {Object}
+ * @api private
+ */
+
+exports.parseUrl = function(req){
+ var parsed = req._parsedUrl;
+ if (parsed && parsed.href == req.url) {
+ return parsed;
+ } else {
+ return req._parsedUrl = parse(req.url);
+ }
+};
+
+/**
+ * Parse byte `size` string.
+ *
+ * @param {String} size
+ * @return {Number}
+ * @api private
+ */
+
+exports.parseBytes = require('bytes');
+
+function noop() {}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/.npmignore
new file mode 100644
index 000000000..b512c09d4
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/.npmignore
@@ -0,0 +1 @@
+node_modules
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/.travis.yml b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/.travis.yml
new file mode 100644
index 000000000..7a902e8c8
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/.travis.yml
@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+ - 0.6
+ - 0.8
+notifications:
+ email:
+ recipients:
+ - brianloveswords@gmail.com
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/README.md b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/README.md
new file mode 100644
index 000000000..0d9d8b835
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/README.md
@@ -0,0 +1,47 @@
+# buffer-crc32
+
+[](http://travis-ci.org/brianloveswords/buffer-crc32)
+
+crc32 that works with binary data and fancy character sets, outputs
+buffer, signed or unsigned data and has tests.
+
+Derived from the sample CRC implementation in the PNG specification: http://www.w3.org/TR/PNG/#D-CRCAppendix
+
+# install
+```
+npm install buffer-crc32
+```
+
+# example
+```js
+var crc32 = require('buffer-crc32');
+// works with buffers
+var buf = Buffer([0x00, 0x73, 0x75, 0x70, 0x20, 0x62, 0x72, 0x6f, 0x00])
+crc32(buf) // ->
+
+// has convenience methods for getting signed or unsigned ints
+crc32.signed(buf) // -> -1805997238
+crc32.unsigned(buf) // -> 2488970058
+
+// will cast to buffer if given a string, so you can
+// directly use foreign characters safely
+crc32('自動販売機') // ->
+
+// and works in append mode too
+var partialCrc = crc32('hey');
+var partialCrc = crc32(' ', partialCrc);
+var partialCrc = crc32('sup', partialCrc);
+var partialCrc = crc32(' ', partialCrc);
+var finalCrc = crc32('bros', partialCrc); // ->
+```
+
+# tests
+This was tested against the output of zlib's crc32 method. You can run
+the tests with`npm test` (requires tap)
+
+# see also
+https://github.com/alexgorbatchev/node-crc, `crc.buffer.crc32` also
+supports buffer inputs and return unsigned ints (thanks @tjholowaychuk).
+
+# license
+MIT/X11
diff --git a/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/index.js b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/index.js
new file mode 100644
index 000000000..e29ce3ebc
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/index.js
@@ -0,0 +1,88 @@
+var Buffer = require('buffer').Buffer;
+
+var CRC_TABLE = [
+ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+ 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
+ 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
+ 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+ 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
+ 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+ 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+ 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+ 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+ 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
+ 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
+ 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+ 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+ 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+ 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
+ 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+ 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
+ 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+ 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+ 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+ 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+ 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+ 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
+ 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+ 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+ 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
+ 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+ 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+ 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
+ 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+ 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+ 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+ 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
+ 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
+ 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+ 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+ 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+ 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+ 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
+ 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+ 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
+ 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+ 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+ 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+ 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+ 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+ 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
+ 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+ 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+ 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
+ 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
+ 0x2d02ef8d
+];
+
+function bufferizeInt(num) {
+ var tmp = Buffer(4);
+ tmp.writeInt32BE(num, 0);
+ return tmp;
+}
+
+function _crc32(buf, previous) {
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ if (Buffer.isBuffer(previous)) {
+ previous = previous.readUInt32BE(0);
+ }
+ var crc = ~~previous ^ -1;
+ for (var n = 0; n < buf.length; n++) {
+ crc = CRC_TABLE[(crc ^ buf[n]) & 0xff] ^ (crc >>> 8);
+ }
+ return (crc ^ -1);
+}
+
+function crc32() {
+ return bufferizeInt(_crc32.apply(null, arguments));
+}
+crc32.signed = function () {
+ return _crc32.apply(null, arguments);
+};
+crc32.unsigned = function () {
+ return _crc32.apply(null, arguments) >>> 0;
+};
+
+module.exports = crc32;
diff --git a/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/package.json b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/package.json
new file mode 100644
index 000000000..4bb469a04
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/package.json
@@ -0,0 +1,39 @@
+{
+ "author": {
+ "name": "Brian J. Brennan",
+ "email": "brianloveswords@gmail.com",
+ "url": "http://bjb.io"
+ },
+ "name": "buffer-crc32",
+ "description": "A pure javascript CRC32 algorithm that plays nice with binary data",
+ "version": "0.2.1",
+ "contributors": [
+ {
+ "name": "Vladimir Kuznetsov"
+ }
+ ],
+ "homepage": "https://github.com/brianloveswords/buffer-crc32",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/brianloveswords/buffer-crc32.git"
+ },
+ "main": "index.js",
+ "scripts": {
+ "test": "./node_modules/.bin/tap tests/*.test.js"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "tap": "~0.2.5"
+ },
+ "optionalDependencies": {},
+ "engines": {
+ "node": "*"
+ },
+ "readme": "# buffer-crc32\n\n[](http://travis-ci.org/brianloveswords/buffer-crc32)\n\ncrc32 that works with binary data and fancy character sets, outputs\nbuffer, signed or unsigned data and has tests.\n\nDerived from the sample CRC implementation in the PNG specification: http://www.w3.org/TR/PNG/#D-CRCAppendix\n\n# install\n```\nnpm install buffer-crc32\n```\n\n# example\n```js\nvar crc32 = require('buffer-crc32');\n// works with buffers\nvar buf = Buffer([0x00, 0x73, 0x75, 0x70, 0x20, 0x62, 0x72, 0x6f, 0x00])\ncrc32(buf) // -> \n\n// has convenience methods for getting signed or unsigned ints\ncrc32.signed(buf) // -> -1805997238\ncrc32.unsigned(buf) // -> 2488970058\n\n// will cast to buffer if given a string, so you can\n// directly use foreign characters safely\ncrc32('自動販売機') // -> \n\n// and works in append mode too\nvar partialCrc = crc32('hey');\nvar partialCrc = crc32(' ', partialCrc);\nvar partialCrc = crc32('sup', partialCrc);\nvar partialCrc = crc32(' ', partialCrc);\nvar finalCrc = crc32('bros', partialCrc); // -> \n```\n\n# tests\nThis was tested against the output of zlib's crc32 method. You can run\nthe tests with`npm test` (requires tap)\n\n# see also\nhttps://github.com/alexgorbatchev/node-crc, `crc.buffer.crc32` also\nsupports buffer inputs and return unsigned ints (thanks @tjholowaychuk).\n\n# license\nMIT/X11\n",
+ "readmeFilename": "README.md",
+ "bugs": {
+ "url": "https://github.com/brianloveswords/buffer-crc32/issues"
+ },
+ "_id": "buffer-crc32@0.2.1",
+ "_from": "buffer-crc32@0.2.1"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/tests/crc.test.js b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/tests/crc.test.js
new file mode 100644
index 000000000..bb0f9efcc
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/buffer-crc32/tests/crc.test.js
@@ -0,0 +1,89 @@
+var crc32 = require('..');
+var test = require('tap').test;
+
+test('simple crc32 is no problem', function (t) {
+ var input = Buffer('hey sup bros');
+ var expected = Buffer([0x47, 0xfa, 0x55, 0x70]);
+ t.same(crc32(input), expected);
+ t.end();
+});
+
+test('another simple one', function (t) {
+ var input = Buffer('IEND');
+ var expected = Buffer([0xae, 0x42, 0x60, 0x82]);
+ t.same(crc32(input), expected);
+ t.end();
+});
+
+test('slightly more complex', function (t) {
+ var input = Buffer([0x00, 0x00, 0x00]);
+ var expected = Buffer([0xff, 0x41, 0xd9, 0x12]);
+ t.same(crc32(input), expected);
+ t.end();
+});
+
+test('complex crc32 gets calculated like a champ', function (t) {
+ var input = Buffer('शीर्षक');
+ var expected = Buffer([0x17, 0xb8, 0xaf, 0xf1]);
+ t.same(crc32(input), expected);
+ t.end();
+});
+
+test('casts to buffer if necessary', function (t) {
+ var input = 'शीर्षक';
+ var expected = Buffer([0x17, 0xb8, 0xaf, 0xf1]);
+ t.same(crc32(input), expected);
+ t.end();
+});
+
+test('can do signed', function (t) {
+ var input = 'ham sandwich';
+ var expected = -1891873021;
+ t.same(crc32.signed(input), expected);
+ t.end();
+});
+
+test('can do unsigned', function (t) {
+ var input = 'bear sandwich';
+ var expected = 3711466352;
+ t.same(crc32.unsigned(input), expected);
+ t.end();
+});
+
+
+test('simple crc32 in append mode', function (t) {
+ var input = [Buffer('hey'), Buffer(' '), Buffer('sup'), Buffer(' '), Buffer('bros')];
+ var expected = Buffer([0x47, 0xfa, 0x55, 0x70]);
+ for (var crc = 0, i = 0; i < input.length; i++) {
+ crc = crc32(input[i], crc);
+ }
+ t.same(crc, expected);
+ t.end();
+});
+
+
+test('can do signed in append mode', function (t) {
+ var input1 = 'ham';
+ var input2 = ' ';
+ var input3 = 'sandwich';
+ var expected = -1891873021;
+
+ var crc = crc32.signed(input1);
+ crc = crc32.signed(input2, crc);
+ crc = crc32.signed(input3, crc);
+
+ t.same(crc, expected);
+ t.end();
+});
+
+test('can do unsigned in append mode', function (t) {
+ var input1 = 'bear san';
+ var input2 = 'dwich';
+ var expected = 3711466352;
+
+ var crc = crc32.unsigned(input1);
+ crc = crc32.unsigned(input2, crc);
+ t.same(crc, expected);
+ t.end();
+});
+
diff --git a/appshell/node-core/thirdparty/connect/node_modules/bytes/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/bytes/.npmignore
new file mode 100644
index 000000000..9daeafb98
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/bytes/.npmignore
@@ -0,0 +1 @@
+test
diff --git a/appshell/node-core/thirdparty/connect/node_modules/bytes/History.md b/appshell/node-core/thirdparty/connect/node_modules/bytes/History.md
new file mode 100644
index 000000000..1332808c8
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/bytes/History.md
@@ -0,0 +1,10 @@
+
+0.2.0 / 2012-10-28
+==================
+
+ * bytes(200).should.eql('200b')
+
+0.1.0 / 2012-07-04
+==================
+
+ * add bytes to string conversion [yields]
diff --git a/appshell/node-core/thirdparty/connect/node_modules/bytes/Readme.md b/appshell/node-core/thirdparty/connect/node_modules/bytes/Readme.md
new file mode 100644
index 000000000..9325d5bf4
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/bytes/Readme.md
@@ -0,0 +1,51 @@
+# node-bytes
+
+ Byte string parser / formatter.
+
+## Example:
+
+```js
+bytes('1kb')
+// => 1024
+
+bytes('2mb')
+// => 2097152
+
+bytes('1gb')
+// => 1073741824
+
+bytes(1073741824)
+// => 1gb
+```
+
+## Installation
+
+```
+$ npm install bytes
+$ component install visionmedia/bytes.js
+```
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+
+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.
diff --git a/appshell/node-core/thirdparty/connect/node_modules/bytes/component.json b/appshell/node-core/thirdparty/connect/node_modules/bytes/component.json
new file mode 100644
index 000000000..76a6057b0
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/bytes/component.json
@@ -0,0 +1,7 @@
+{
+ "name": "bytes",
+ "description": "byte size string parser / serializer",
+ "keywords": ["bytes", "utility"],
+ "version": "0.1.0",
+ "scripts": ["index.js"]
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/bytes/index.js b/appshell/node-core/thirdparty/connect/node_modules/bytes/index.js
new file mode 100644
index 000000000..70b2e01a4
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/bytes/index.js
@@ -0,0 +1,39 @@
+
+/**
+ * Parse byte `size` string.
+ *
+ * @param {String} size
+ * @return {Number}
+ * @api public
+ */
+
+module.exports = function(size) {
+ if ('number' == typeof size) return convert(size);
+ var parts = size.match(/^(\d+(?:\.\d+)?) *(kb|mb|gb)$/)
+ , n = parseFloat(parts[1])
+ , type = parts[2];
+
+ var map = {
+ kb: 1 << 10
+ , mb: 1 << 20
+ , gb: 1 << 30
+ };
+
+ return map[type] * n;
+};
+
+/**
+ * convert bytes into string.
+ *
+ * @param {Number} b - bytes to convert
+ * @return {String}
+ * @api public
+ */
+
+function convert (b) {
+ var gb = 1 << 30, mb = 1 << 20, kb = 1 << 10;
+ if (b >= gb) return (Math.round(b / gb * 100) / 100) + 'gb';
+ if (b >= mb) return (Math.round(b / mb * 100) / 100) + 'mb';
+ if (b >= kb) return (Math.round(b / kb * 100) / 100) + 'kb';
+ return b + 'b';
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/bytes/package.json b/appshell/node-core/thirdparty/connect/node_modules/bytes/package.json
new file mode 100644
index 000000000..0db9bc90d
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/bytes/package.json
@@ -0,0 +1,20 @@
+{
+ "name": "bytes",
+ "author": {
+ "name": "TJ Holowaychuk",
+ "email": "tj@vision-media.ca",
+ "url": "http://tjholowaychuk.com"
+ },
+ "description": "byte size string parser / serializer",
+ "version": "0.2.0",
+ "main": "index.js",
+ "dependencies": {},
+ "devDependencies": {
+ "mocha": "*",
+ "should": "*"
+ },
+ "readme": "# node-bytes\n\n Byte string parser / formatter.\n\n## Example:\n\n```js\nbytes('1kb')\n// => 1024\n\nbytes('2mb')\n// => 2097152\n\nbytes('1gb')\n// => 1073741824\n\nbytes(1073741824)\n// => 1gb\n```\n\n## Installation\n\n```\n$ npm install bytes\n$ component install visionmedia/bytes.js\n```\n\n## License \n\n(The MIT License)\n\nCopyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n",
+ "readmeFilename": "Readme.md",
+ "_id": "bytes@0.2.0",
+ "_from": "bytes@0.2.0"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/.npmignore
new file mode 100644
index 000000000..f1250e584
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/.npmignore
@@ -0,0 +1,4 @@
+support
+test
+examples
+*.sock
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/History.md b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/History.md
new file mode 100644
index 000000000..9e3017998
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/History.md
@@ -0,0 +1,11 @@
+
+1.0.1 / 2013-04-15
+==================
+
+ * Revert "Changed underlying HMAC algo. to sha512."
+ * Revert "Fix for timing attacks on MAC verification."
+
+0.0.1 / 2010-01-03
+==================
+
+ * Initial release
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/Readme.md b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/Readme.md
new file mode 100644
index 000000000..2559e841b
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/Readme.md
@@ -0,0 +1,42 @@
+
+# cookie-signature
+
+ Sign and unsign cookies.
+
+## Example
+
+```js
+var cookie = require('cookie-signature');
+
+var val = cookie.sign('hello', 'tobiiscool');
+val.should.equal('hello.DGDUkGlIkCzPz+C0B064FNgHdEjox7ch8tOBGslZ5QI');
+
+var val = cookie.sign('hello', 'tobiiscool');
+cookie.unsign(val, 'tobiiscool').should.equal('hello');
+cookie.unsign(val, 'luna').should.be.false;
+```
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2012 LearnBoost <tj@learnboost.com>
+
+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.
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/index.js b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/index.js
new file mode 100644
index 000000000..ed62814e6
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/index.js
@@ -0,0 +1,42 @@
+
+/**
+ * Module dependencies.
+ */
+
+var crypto = require('crypto');
+
+/**
+ * Sign the given `val` with `secret`.
+ *
+ * @param {String} val
+ * @param {String} secret
+ * @return {String}
+ * @api private
+ */
+
+exports.sign = function(val, secret){
+ if ('string' != typeof val) throw new TypeError('cookie required');
+ if ('string' != typeof secret) throw new TypeError('secret required');
+ return val + '.' + crypto
+ .createHmac('sha256', secret)
+ .update(val)
+ .digest('base64')
+ .replace(/\=+$/, '');
+};
+
+/**
+ * Unsign and decode the given `val` with `secret`,
+ * returning `false` if the signature is invalid.
+ *
+ * @param {String} val
+ * @param {String} secret
+ * @return {String|Boolean}
+ * @api private
+ */
+
+exports.unsign = function(val, secret){
+ if ('string' != typeof val) throw new TypeError('cookie required');
+ if ('string' != typeof secret) throw new TypeError('secret required');
+ var str = val.slice(0, val.lastIndexOf('.'));
+ return exports.sign(str, secret) == val ? str : false;
+};
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/package.json b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/package.json
new file mode 100644
index 000000000..83bea32ca
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie-signature/package.json
@@ -0,0 +1,24 @@
+{
+ "name": "cookie-signature",
+ "version": "1.0.1",
+ "description": "Sign and unsign cookies",
+ "keywords": [
+ "cookie",
+ "sign",
+ "unsign"
+ ],
+ "author": {
+ "name": "TJ Holowaychuk",
+ "email": "tj@learnboost.com"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "mocha": "*",
+ "should": "*"
+ },
+ "main": "index",
+ "readme": "\n# cookie-signature\n\n Sign and unsign cookies.\n\n## Example\n\n```js\nvar cookie = require('cookie-signature');\n\nvar val = cookie.sign('hello', 'tobiiscool');\nval.should.equal('hello.DGDUkGlIkCzPz+C0B064FNgHdEjox7ch8tOBGslZ5QI');\n\nvar val = cookie.sign('hello', 'tobiiscool');\ncookie.unsign(val, 'tobiiscool').should.equal('hello');\ncookie.unsign(val, 'luna').should.be.false;\n```\n\n## License \n\n(The MIT License)\n\nCopyright (c) 2012 LearnBoost <tj@learnboost.com>\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",
+ "readmeFilename": "Readme.md",
+ "_id": "cookie-signature@1.0.1",
+ "_from": "cookie-signature@1.0.1"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/cookie/.npmignore
new file mode 100644
index 000000000..3c3629e64
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie/.npmignore
@@ -0,0 +1 @@
+node_modules
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie/.travis.yml b/appshell/node-core/thirdparty/connect/node_modules/cookie/.travis.yml
new file mode 100644
index 000000000..9400c1188
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie/.travis.yml
@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+ - "0.6"
+ - "0.8"
+ - "0.10"
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie/LICENSE b/appshell/node-core/thirdparty/connect/node_modules/cookie/LICENSE
new file mode 100644
index 000000000..249d9def9
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie/LICENSE
@@ -0,0 +1,9 @@
+// MIT License
+
+Copyright (C) Roman Shtylman
+
+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.
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie/README.md b/appshell/node-core/thirdparty/connect/node_modules/cookie/README.md
new file mode 100644
index 000000000..5187ed1cc
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie/README.md
@@ -0,0 +1,44 @@
+# cookie [](http://travis-ci.org/shtylman/node-cookie) #
+
+cookie is a basic cookie parser and serializer. It doesn't make assumptions about how you are going to deal with your cookies. It basically just provides a way to read and write the HTTP cookie headers.
+
+See [RFC6265](http://tools.ietf.org/html/rfc6265) for details about the http header for cookies.
+
+## how?
+
+```
+npm install cookie
+```
+
+```javascript
+var cookie = require('cookie');
+
+var hdr = cookie.serialize('foo', 'bar');
+// hdr = 'foo=bar';
+
+var cookies = cookie.parse('foo=bar; cat=meow; dog=ruff');
+// cookies = { foo: 'bar', cat: 'meow', dog: 'ruff' };
+```
+
+## more
+
+The serialize function takes a third parameter, an object, to set cookie options. See the RFC for valid values.
+
+### path
+> cookie path
+
+### expires
+> absolute expiration date for the cookie (Date object)
+
+### maxAge
+> relative max age of the cookie from when the client receives it (seconds)
+
+### domain
+> domain for the cookie
+
+### secure
+> true or false
+
+### httpOnly
+> true or false
+
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie/index.js b/appshell/node-core/thirdparty/connect/node_modules/cookie/index.js
new file mode 100644
index 000000000..16bdb65dd
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie/index.js
@@ -0,0 +1,70 @@
+
+/// Serialize the a name value pair into a cookie string suitable for
+/// http headers. An optional options object specified cookie parameters
+///
+/// serialize('foo', 'bar', { httpOnly: true })
+/// => "foo=bar; httpOnly"
+///
+/// @param {String} name
+/// @param {String} val
+/// @param {Object} options
+/// @return {String}
+var serialize = function(name, val, opt){
+ opt = opt || {};
+ var enc = opt.encode || encode;
+ var pairs = [name + '=' + enc(val)];
+
+ if (opt.maxAge) pairs.push('Max-Age=' + opt.maxAge);
+ if (opt.domain) pairs.push('Domain=' + opt.domain);
+ if (opt.path) pairs.push('Path=' + opt.path);
+ if (opt.expires) pairs.push('Expires=' + opt.expires.toUTCString());
+ if (opt.httpOnly) pairs.push('HttpOnly');
+ if (opt.secure) pairs.push('Secure');
+
+ return pairs.join('; ');
+};
+
+/// Parse the given cookie header string into an object
+/// The object has the various cookies as keys(names) => values
+/// @param {String} str
+/// @return {Object}
+var parse = function(str, opt) {
+ opt = opt || {};
+ var obj = {}
+ var pairs = str.split(/[;,] */);
+ var dec = opt.decode || decode;
+
+ pairs.forEach(function(pair) {
+ var eq_idx = pair.indexOf('=')
+
+ // skip things that don't look like key=value
+ if (eq_idx < 0) {
+ return;
+ }
+
+ var key = pair.substr(0, eq_idx).trim()
+ var val = pair.substr(++eq_idx, pair.length).trim();
+
+ // quoted values
+ if ('"' == val[0]) {
+ val = val.slice(1, -1);
+ }
+
+ // only assign once
+ if (undefined == obj[key]) {
+ try {
+ obj[key] = dec(val);
+ } catch (e) {
+ obj[key] = val;
+ }
+ }
+ });
+
+ return obj;
+};
+
+var encode = encodeURIComponent;
+var decode = decodeURIComponent;
+
+module.exports.serialize = serialize;
+module.exports.parse = parse;
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie/package.json b/appshell/node-core/thirdparty/connect/node_modules/cookie/package.json
new file mode 100644
index 000000000..7f6da52e2
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie/package.json
@@ -0,0 +1,40 @@
+{
+ "author": {
+ "name": "Roman Shtylman",
+ "email": "shtylman@gmail.com"
+ },
+ "name": "cookie",
+ "description": "cookie parsing and serialization",
+ "version": "0.1.0",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/shtylman/node-cookie.git"
+ },
+ "keywords": [
+ "cookie",
+ "cookies"
+ ],
+ "main": "index.js",
+ "scripts": {
+ "test": "mocha"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "mocha": "1.x.x"
+ },
+ "optionalDependencies": {},
+ "engines": {
+ "node": "*"
+ },
+ "readme": "# cookie [](http://travis-ci.org/shtylman/node-cookie) #\n\ncookie is a basic cookie parser and serializer. It doesn't make assumptions about how you are going to deal with your cookies. It basically just provides a way to read and write the HTTP cookie headers.\n\nSee [RFC6265](http://tools.ietf.org/html/rfc6265) for details about the http header for cookies.\n\n## how?\n\n```\nnpm install cookie\n```\n\n```javascript\nvar cookie = require('cookie');\n\nvar hdr = cookie.serialize('foo', 'bar');\n// hdr = 'foo=bar';\n\nvar cookies = cookie.parse('foo=bar; cat=meow; dog=ruff');\n// cookies = { foo: 'bar', cat: 'meow', dog: 'ruff' };\n```\n\n## more\n\nThe serialize function takes a third parameter, an object, to set cookie options. See the RFC for valid values.\n\n### path\n> cookie path\n\n### expires\n> absolute expiration date for the cookie (Date object)\n\n### maxAge\n> relative max age of the cookie from when the client receives it (seconds)\n\n### domain\n> domain for the cookie\n\n### secure\n> true or false\n\n### httpOnly\n> true or false\n\n",
+ "readmeFilename": "README.md",
+ "bugs": {
+ "url": "https://github.com/shtylman/node-cookie/issues"
+ },
+ "_id": "cookie@0.1.0",
+ "dist": {
+ "shasum": "90eb469ddce905c866de687efc43131d8801f9d0"
+ },
+ "_from": "cookie@0.1.0",
+ "_resolved": "https://registry.npmjs.org/cookie/-/cookie-0.1.0.tgz"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie/test/mocha.opts b/appshell/node-core/thirdparty/connect/node_modules/cookie/test/mocha.opts
new file mode 100644
index 000000000..e2bfcc5ac
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie/test/mocha.opts
@@ -0,0 +1 @@
+--ui qunit
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie/test/parse.js b/appshell/node-core/thirdparty/connect/node_modules/cookie/test/parse.js
new file mode 100644
index 000000000..c6c27a20b
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie/test/parse.js
@@ -0,0 +1,44 @@
+
+var assert = require('assert');
+
+var cookie = require('..');
+
+suite('parse');
+
+test('basic', function() {
+ assert.deepEqual({ foo: 'bar' }, cookie.parse('foo=bar'));
+ assert.deepEqual({ foo: '123' }, cookie.parse('foo=123'));
+});
+
+test('ignore spaces', function() {
+ assert.deepEqual({ FOO: 'bar', baz: 'raz' },
+ cookie.parse('FOO = bar; baz = raz'));
+});
+
+test('escaping', function() {
+ assert.deepEqual({ foo: 'bar=123456789&name=Magic+Mouse' },
+ cookie.parse('foo="bar=123456789&name=Magic+Mouse"'));
+
+ assert.deepEqual({ email: ' ",;/' },
+ cookie.parse('email=%20%22%2c%3b%2f'));
+});
+
+test('ignore escaping error and return original value', function() {
+ assert.deepEqual({ foo: '%1', bar: 'bar' }, cookie.parse('foo=%1;bar=bar'));
+});
+
+test('ignore non values', function() {
+ assert.deepEqual({ foo: '%1', bar: 'bar' }, cookie.parse('foo=%1;bar=bar;HttpOnly;Secure'));
+});
+
+test('unencoded', function() {
+ assert.deepEqual({ foo: 'bar=123456789&name=Magic+Mouse' },
+ cookie.parse('foo="bar=123456789&name=Magic+Mouse"',{
+ decode: function(value) { return value; }
+ }));
+
+ assert.deepEqual({ email: '%20%22%2c%3b%2f' },
+ cookie.parse('email=%20%22%2c%3b%2f',{
+ decode: function(value) { return value; }
+ }));
+})
diff --git a/appshell/node-core/thirdparty/connect/node_modules/cookie/test/serialize.js b/appshell/node-core/thirdparty/connect/node_modules/cookie/test/serialize.js
new file mode 100644
index 000000000..86bb8c935
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/cookie/test/serialize.js
@@ -0,0 +1,64 @@
+// builtin
+var assert = require('assert');
+
+var cookie = require('..');
+
+suite('serialize');
+
+test('basic', function() {
+ assert.equal('foo=bar', cookie.serialize('foo', 'bar'));
+ assert.equal('foo=bar%20baz', cookie.serialize('foo', 'bar baz'));
+});
+
+test('path', function() {
+ assert.equal('foo=bar; Path=/', cookie.serialize('foo', 'bar', {
+ path: '/'
+ }));
+});
+
+test('secure', function() {
+ assert.equal('foo=bar; Secure', cookie.serialize('foo', 'bar', {
+ secure: true
+ }));
+
+ assert.equal('foo=bar', cookie.serialize('foo', 'bar', {
+ secure: false
+ }));
+});
+
+test('domain', function() {
+ assert.equal('foo=bar; Domain=example.com', cookie.serialize('foo', 'bar', {
+ domain: 'example.com'
+ }));
+});
+
+test('httpOnly', function() {
+ assert.equal('foo=bar; HttpOnly', cookie.serialize('foo', 'bar', {
+ httpOnly: true
+ }));
+});
+
+test('maxAge', function() {
+ assert.equal('foo=bar; Max-Age=1000', cookie.serialize('foo', 'bar', {
+ maxAge: 1000
+ }));
+});
+
+test('escaping', function() {
+ assert.deepEqual('cat=%2B%20', cookie.serialize('cat', '+ '));
+});
+
+test('parse->serialize', function() {
+
+ assert.deepEqual({ cat: 'foo=123&name=baz five' }, cookie.parse(
+ cookie.serialize('cat', 'foo=123&name=baz five')));
+
+ assert.deepEqual({ cat: ' ";/' }, cookie.parse(
+ cookie.serialize('cat', ' ";/')));
+});
+
+test('unencoded', function() {
+ assert.deepEqual('cat=+ ', cookie.serialize('cat', '+ ', {
+ encode: function(value) { return value; }
+ }));
+})
diff --git a/appshell/node-core/thirdparty/connect/node_modules/fresh/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/fresh/.npmignore
new file mode 100644
index 000000000..9daeafb98
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/fresh/.npmignore
@@ -0,0 +1 @@
+test
diff --git a/appshell/node-core/thirdparty/connect/node_modules/fresh/History.md b/appshell/node-core/thirdparty/connect/node_modules/fresh/History.md
new file mode 100644
index 000000000..60a2903f9
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/fresh/History.md
@@ -0,0 +1,5 @@
+
+0.2.0 / 2013-08-11
+==================
+
+ * fix: return false for no-cache
diff --git a/appshell/node-core/thirdparty/connect/node_modules/fresh/Readme.md b/appshell/node-core/thirdparty/connect/node_modules/fresh/Readme.md
new file mode 100644
index 000000000..61366c577
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/fresh/Readme.md
@@ -0,0 +1,57 @@
+
+# node-fresh
+
+ HTTP response freshness testing
+
+## fresh(req, res)
+
+ Check freshness of `req` and `res` headers.
+
+ When the cache is "fresh" __true__ is returned,
+ otherwise __false__ is returned to indicate that
+ the cache is now stale.
+
+## Example:
+
+```js
+var req = { 'if-none-match': 'tobi' };
+var res = { 'etag': 'luna' };
+fresh(req, res);
+// => false
+
+var req = { 'if-none-match': 'tobi' };
+var res = { 'etag': 'tobi' };
+fresh(req, res);
+// => true
+```
+
+## Installation
+
+```
+$ npm install fresh
+```
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+
+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.
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/fresh/index.js b/appshell/node-core/thirdparty/connect/node_modules/fresh/index.js
new file mode 100644
index 000000000..9c3f47d1e
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/fresh/index.js
@@ -0,0 +1,53 @@
+
+/**
+ * Expose `fresh()`.
+ */
+
+module.exports = fresh;
+
+/**
+ * Check freshness of `req` and `res` headers.
+ *
+ * When the cache is "fresh" __true__ is returned,
+ * otherwise __false__ is returned to indicate that
+ * the cache is now stale.
+ *
+ * @param {Object} req
+ * @param {Object} res
+ * @return {Boolean}
+ * @api public
+ */
+
+function fresh(req, res) {
+ // defaults
+ var etagMatches = true;
+ var notModified = true;
+
+ // fields
+ var modifiedSince = req['if-modified-since'];
+ var noneMatch = req['if-none-match'];
+ var lastModified = res['last-modified'];
+ var etag = res['etag'];
+ var cc = req['cache-control'];
+
+ // unconditional request
+ if (!modifiedSince && !noneMatch) return false;
+
+ // check for no-cache cache request directive
+ if (cc && cc.indexOf('no-cache') !== -1) return false;
+
+ // parse if-none-match
+ if (noneMatch) noneMatch = noneMatch.split(/ *, */);
+
+ // if-none-match
+ if (noneMatch) etagMatches = ~noneMatch.indexOf(etag) || '*' == noneMatch[0];
+
+ // if-modified-since
+ if (modifiedSince) {
+ modifiedSince = new Date(modifiedSince);
+ lastModified = new Date(lastModified);
+ notModified = lastModified <= modifiedSince;
+ }
+
+ return !! (etagMatches && notModified);
+}
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/fresh/package.json b/appshell/node-core/thirdparty/connect/node_modules/fresh/package.json
new file mode 100644
index 000000000..76a8131c5
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/fresh/package.json
@@ -0,0 +1,31 @@
+{
+ "name": "fresh",
+ "author": {
+ "name": "TJ Holowaychuk",
+ "email": "tj@vision-media.ca",
+ "url": "http://tjholowaychuk.com"
+ },
+ "description": "HTTP response freshness testing",
+ "version": "0.2.0",
+ "main": "index.js",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/visionmedia/node-fresh.git"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "mocha": "*",
+ "should": "*"
+ },
+ "readme": "\n# node-fresh\n\n HTTP response freshness testing\n\n## fresh(req, res)\n\n Check freshness of `req` and `res` headers.\n\n When the cache is \"fresh\" __true__ is returned,\n otherwise __false__ is returned to indicate that\n the cache is now stale.\n\n## Example:\n\n```js\nvar req = { 'if-none-match': 'tobi' };\nvar res = { 'etag': 'luna' };\nfresh(req, res);\n// => false\n\nvar req = { 'if-none-match': 'tobi' };\nvar res = { 'etag': 'tobi' };\nfresh(req, res);\n// => true\n```\n\n## Installation\n\n```\n$ npm install fresh\n```\n\n## License \n\n(The MIT License)\n\nCopyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",
+ "readmeFilename": "Readme.md",
+ "bugs": {
+ "url": "https://github.com/visionmedia/node-fresh/issues"
+ },
+ "_id": "fresh@0.2.0",
+ "dist": {
+ "shasum": "bfd9402cf3df12c4a4c310c79f99a3dde13d34a7"
+ },
+ "_from": "fresh@0.2.0",
+ "_resolved": "https://registry.npmjs.org/fresh/-/fresh-0.2.0.tgz"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/methods/index.js b/appshell/node-core/thirdparty/connect/node_modules/methods/index.js
new file mode 100644
index 000000000..297d02233
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/methods/index.js
@@ -0,0 +1,26 @@
+
+module.exports = [
+ 'get'
+ , 'post'
+ , 'put'
+ , 'head'
+ , 'delete'
+ , 'options'
+ , 'trace'
+ , 'copy'
+ , 'lock'
+ , 'mkcol'
+ , 'move'
+ , 'propfind'
+ , 'proppatch'
+ , 'unlock'
+ , 'report'
+ , 'mkactivity'
+ , 'checkout'
+ , 'merge'
+ , 'm-search'
+ , 'notify'
+ , 'subscribe'
+ , 'unsubscribe'
+ , 'patch'
+];
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/methods/package.json b/appshell/node-core/thirdparty/connect/node_modules/methods/package.json
new file mode 100644
index 000000000..f867a8b57
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/methods/package.json
@@ -0,0 +1,20 @@
+{
+ "name": "methods",
+ "version": "0.0.1",
+ "description": "HTTP methods that node supports",
+ "main": "index.js",
+ "scripts": {
+ "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "keywords": [
+ "http",
+ "methods"
+ ],
+ "author": {
+ "name": "TJ Holowaychuk"
+ },
+ "license": "MIT",
+ "readme": "ERROR: No README data found!",
+ "_id": "methods@0.0.1",
+ "_from": "methods@0.0.1"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/.jshintrc b/appshell/node-core/thirdparty/connect/node_modules/multiparty/.jshintrc
new file mode 100644
index 000000000..a93b50cfb
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/.jshintrc
@@ -0,0 +1,70 @@
+{
+ // Settings
+ "passfail" : false, // Stop on first error.
+ "maxerr" : 100, // Maximum errors before stopping.
+
+
+ // Predefined globals whom JSHint will ignore.
+ "browser" : false, // Standard browser globals e.g. `window`, `document`.
+
+ "node" : true,
+ "rhino" : false,
+ "couch" : false,
+ "wsh" : false, // Windows Scripting Host.
+
+ "jquery" : false,
+ "prototypejs" : false,
+ "mootools" : false,
+ "dojo" : false,
+
+
+ "predef" : [
+ "describe", "it", "before", "after"
+ ],
+
+ // Development.
+ "debug" : true, // Allow debugger statements e.g. browser breakpoints.
+ "devel" : true, // Allow development statements e.g. `console.log();`.
+
+
+ // EcmaScript 5.
+ "es5" : true, // Allow EcmaScript 5 syntax.
+ "strict" : false, // Require `use strict` pragma in every file.
+ "globalstrict" : true, // Allow global "use strict" (also enables 'strict').
+
+
+ // The Good Parts.
+ "asi" : true, // Tolerate Automatic Semicolon Insertion (no semicolons).
+ "laxbreak" : false, // Tolerate unsafe line breaks e.g. `return [\n] x` without semicolons.
+ "laxcomma" : true,
+ "bitwise" : false, // Prohibit bitwise operators (&, |, ^, etc.).
+ "boss" : true, // Tolerate assignments inside if, for & while. Usually conditions & loops are for comparison, not assignments.
+ "curly" : false, // Require {} for every new block or scope.
+ "eqeqeq" : true, // Require triple equals i.e. `===`.
+ "eqnull" : true, // Tolerate use of `== null`.
+ "evil" : false, // Tolerate use of `eval`.
+ "expr" : false, // Tolerate `ExpressionStatement` as Programs.
+ "forin" : false, // Prohibt `for in` loops without `hasOwnProperty`.
+ "immed" : true, // Require immediate invocations to be wrapped in parens e.g. `( function(){}() );`
+ "latedef" : false, // Prohibit variable use before definition.
+ "loopfunc" : false, // Allow functions to be defined within loops.
+ "noarg" : true, // Prohibit use of `arguments.caller` and `arguments.callee`.
+ "regexp" : false, // Prohibit `.` and `[^...]` in regular expressions.
+ "regexdash" : false, // Tolerate unescaped last dash i.e. `[-...]`.
+ "scripturl" : false, // Tolerate script-targeted URLs.
+ "shadow" : false, // Allows re-define variables later in code e.g. `var x=1; x=2;`.
+ "supernew" : false, // Tolerate `new function () { ... };` and `new Object;`.
+ "undef" : true, // Require all non-global variables be declared before they are used.
+
+
+ // Persone styling prefrences.
+ "newcap" : true, // Require capitalization of all constructor functions e.g. `new F()`.
+ "noempty" : true, // Prohibit use of empty blocks.
+ "nonew" : true, // Prohibit use of constructors for side-effects.
+ "nomen" : false, // Prohibit use of initial or trailing underbars in names.
+ "onevar" : false, // Allow only one `var` statement per function.
+ "plusplus" : false, // Prohibit use of `++` & `--`.
+ "sub" : false, // Tolerate all forms of subscript notation besides dot notation e.g. `dict['key']` instead of `dict.key`.
+ "trailing" : true, // Prohibit trailing whitespaces.
+ "white" : false // Check against strict whitespace and indentation rules.
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/multiparty/.npmignore
new file mode 100644
index 000000000..07e6e472c
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/.npmignore
@@ -0,0 +1 @@
+/node_modules
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/.travis.yml b/appshell/node-core/thirdparty/connect/node_modules/multiparty/.travis.yml
new file mode 100644
index 000000000..0a927dbb8
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/.travis.yml
@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+ - "0.8"
+ - "0.9"
+ - "0.10"
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/CHANGELOG.md b/appshell/node-core/thirdparty/connect/node_modules/multiparty/CHANGELOG.md
new file mode 100644
index 000000000..ea8761c2d
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/CHANGELOG.md
@@ -0,0 +1,169 @@
+### 2.1.6
+
+ * expose `hash` as an option to `Form`. (thanks wookiehangover)
+
+### 2.1.5
+
+ * fix possible 'close' event before all temp files are done
+
+### 2.1.4
+
+ * fix crash for invalid requests
+
+### 2.1.3
+
+ * add `file.size`
+
+### 2.1.2
+
+ * proper backpressure support
+ * update s3 example
+
+### 2.1.1
+
+ * fix uploads larger than 2KB
+ * fix both s3 and upload example
+ * add part.byteCount and part.byteOffset
+
+### 2.1.0 (recalled)
+
+ * Complete rewrite. See README for changes and new API.
+
+### v1.0.13
+
+* Only update hash if update method exists (Sven Lito)
+* According to travis v0.10 needs to go quoted (Sven Lito)
+* Bumping build node versions (Sven Lito)
+* Additional fix for empty requests (Eugene Girshov)
+* Change the default to 1000, to match the new Node behaviour. (OrangeDog)
+* Add ability to control maxKeys in the querystring parser. (OrangeDog)
+* Adjust test case to work with node 0.9.x (Eugene Girshov)
+* Update package.json (Sven Lito)
+* Path adjustment according to eb4468b (Markus Ast)
+
+### v1.0.12
+
+* Emit error on aborted connections (Eugene Girshov)
+* Add support for empty requests (Eugene Girshov)
+* Fix name/filename handling in Content-Disposition (jesperp)
+* Tolerate malformed closing boundary in multipart (Eugene Girshov)
+* Ignore preamble in multipart messages (Eugene Girshov)
+* Add support for application/json (Mike Frey, Carlos Rodriguez)
+* Add support for Base64 encoding (Elmer Bulthuis)
+* Add File#toJSON (TJ Holowaychuk)
+* Remove support for Node.js 0.4 & 0.6 (Andrew Kelley)
+* Documentation improvements (Sven Lito, Andre Azevedo)
+* Add support for application/octet-stream (Ion Lupascu, Chris Scribner)
+* Use os.tmpDir() to get tmp directory (Andrew Kelley)
+* Improve package.json (Andrew Kelley, Sven Lito)
+* Fix benchmark script (Andrew Kelley)
+* Fix scope issue in incoming_forms (Sven Lito)
+* Fix file handle leak on error (OrangeDog)
+
+### v1.0.11
+
+* Calculate checksums for incoming files (sreuter)
+* Add definition parameters to "IncomingForm" as an argument (Math-)
+
+### v1.0.10
+
+* Make parts to be proper Streams (Matt Robenolt)
+
+### v1.0.9
+
+* Emit progress when content length header parsed (Tim Koschützki)
+* Fix Readme syntax due to GitHub changes (goob)
+* Replace references to old 'sys' module in Readme with 'util' (Peter Sugihara)
+
+### v1.0.8
+
+* Strip potentially unsafe characters when using `keepExtensions: true`.
+* Switch to utest / urun for testing
+* Add travis build
+
+### v1.0.7
+
+* Remove file from package that was causing problems when installing on windows. (#102)
+* Fix typos in Readme (Jason Davies).
+
+### v1.0.6
+
+* Do not default to the default to the field name for file uploads where
+ filename="".
+
+### v1.0.5
+
+* Support filename="" in multipart parts
+* Explain unexpected end() errors in parser better
+
+**Note:** Starting with this version, formidable emits 'file' events for empty
+file input fields. Previously those were incorrectly emitted as regular file
+input fields with value = "".
+
+### v1.0.4
+
+* Detect a good default tmp directory regardless of platform. (#88)
+
+### v1.0.3
+
+* Fix problems with utf8 characters (#84) / semicolons in filenames (#58)
+* Small performance improvements
+* New test suite and fixture system
+
+### v1.0.2
+
+* Exclude node\_modules folder from git
+* Implement new `'aborted'` event
+* Fix files in example folder to work with recent node versions
+* Make gently a devDependency
+
+[See Commits](https://github.com/felixge/node-formidable/compare/v1.0.1...v1.0.2)
+
+### v1.0.1
+
+* Fix package.json to refer to proper main directory. (#68, Dean Landolt)
+
+[See Commits](https://github.com/felixge/node-formidable/compare/v1.0.0...v1.0.1)
+
+### v1.0.0
+
+* Add support for multipart boundaries that are quoted strings. (Jeff Craig)
+
+This marks the beginning of development on version 2.0 which will include
+several architectural improvements.
+
+[See Commits](https://github.com/felixge/node-formidable/compare/v0.9.11...v1.0.0)
+
+### v0.9.11
+
+* Emit `'progress'` event when receiving data, regardless of parsing it. (Tim Koschützki)
+* Use [W3C FileAPI Draft](http://dev.w3.org/2006/webapi/FileAPI/) properties for File class
+
+**Important:** The old property names of the File class will be removed in a
+future release.
+
+[See Commits](https://github.com/felixge/node-formidable/compare/v0.9.10...v0.9.11)
+
+### Older releases
+
+These releases were done before starting to maintain the above Changelog:
+
+* [v0.9.10](https://github.com/felixge/node-formidable/compare/v0.9.9...v0.9.10)
+* [v0.9.9](https://github.com/felixge/node-formidable/compare/v0.9.8...v0.9.9)
+* [v0.9.8](https://github.com/felixge/node-formidable/compare/v0.9.7...v0.9.8)
+* [v0.9.7](https://github.com/felixge/node-formidable/compare/v0.9.6...v0.9.7)
+* [v0.9.6](https://github.com/felixge/node-formidable/compare/v0.9.5...v0.9.6)
+* [v0.9.5](https://github.com/felixge/node-formidable/compare/v0.9.4...v0.9.5)
+* [v0.9.4](https://github.com/felixge/node-formidable/compare/v0.9.3...v0.9.4)
+* [v0.9.3](https://github.com/felixge/node-formidable/compare/v0.9.2...v0.9.3)
+* [v0.9.2](https://github.com/felixge/node-formidable/compare/v0.9.1...v0.9.2)
+* [v0.9.1](https://github.com/felixge/node-formidable/compare/v0.9.0...v0.9.1)
+* [v0.9.0](https://github.com/felixge/node-formidable/compare/v0.8.0...v0.9.0)
+* [v0.9.0](https://github.com/felixge/node-formidable/compare/v0.8.0...v0.9.0)
+* [v0.9.0](https://github.com/felixge/node-formidable/compare/v0.8.0...v0.9.0)
+* [v0.9.0](https://github.com/felixge/node-formidable/compare/v0.8.0...v0.9.0)
+* [v0.9.0](https://github.com/felixge/node-formidable/compare/v0.8.0...v0.9.0)
+* [v0.9.0](https://github.com/felixge/node-formidable/compare/v0.8.0...v0.9.0)
+* [v0.9.0](https://github.com/felixge/node-formidable/compare/v0.8.0...v0.9.0)
+* [v0.9.0](https://github.com/felixge/node-formidable/compare/v0.8.0...v0.9.0)
+* [v0.1.0](https://github.com/felixge/node-formidable/commits/v0.1.0)
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/LICENSE b/appshell/node-core/thirdparty/connect/node_modules/multiparty/LICENSE
new file mode 100644
index 000000000..38d3c9cf4
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/LICENSE
@@ -0,0 +1,7 @@
+Copyright (C) 2011 Felix Geisendörfer
+
+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.
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/README.md b/appshell/node-core/thirdparty/connect/node_modules/multiparty/README.md
new file mode 100644
index 000000000..a4ba327a7
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/README.md
@@ -0,0 +1,163 @@
+[](https://travis-ci.org/superjoe30/node-multiparty)
+# multiparty
+
+Parse http requests with content-type `multipart/form-data`, also known as file uploads.
+
+### Why the fork?
+
+ * This module uses the Node.js v0.10 streams properly, *even in Node.js v0.8*
+ * It will not create a temp file for you unless you want it to.
+ * Counts bytes and does math to help you figure out the `Content-Length` of
+ each part.
+ * You can easily stream uploads to s3 with
+ [knox](https://github.com/LearnBoost/knox), for [example](examples/s3.js).
+ * Less bugs. This code is simpler, has all deprecated functionality removed,
+ has cleaner tests, and does not try to do anything beyond multipart stream
+ parsing.
+
+## Installation
+
+```
+npm install multiparty
+```
+
+## Usage
+
+ * See [examples](examples).
+ * Using express or connect? See [connect-multiparty](https://github.com/superjoe30/connect-multiparty)
+
+Parse an incoming `multipart/form-data` request.
+
+```js
+var multiparty = require('multiparty')
+ , http = require('http')
+ , util = require('util')
+
+http.createServer(function(req, res) {
+ if (req.url === '/upload' && req.method === 'POST') {
+ // parse a file upload
+ var form = new multiparty.Form();
+
+ form.parse(req, function(err, fields, files) {
+ res.writeHead(200, {'content-type': 'text/plain'});
+ res.write('received upload:\n\n');
+ res.end(util.inspect({fields: fields, files: files}));
+ });
+
+ return;
+ }
+
+ // show a file upload form
+ res.writeHead(200, {'content-type': 'text/html'});
+ res.end(
+ ''
+ );
+}).listen(8080);
+```
+
+## API
+
+### multiparty.Form
+```js
+var form = new multiparty.Form(options)
+```
+Creates a new form. Options:
+
+ * `encoding` - sets encoding for the incoming form fields. Defaults to `utf8`.
+ * `maxFieldSize` - Limits the amount of memory a field (not a file) can
+ allocate in bytes. If this value is exceeded, an `error` event is emitted.
+ The default size is 2MB.
+ * `maxFields` - Limits the number of fields that will be parsed before
+ emitting an `error` event. A file counts as a field in this case.
+ Defaults to 1000.
+ * `autoFields` - Enables `field` events. This is automatically set to `true`
+ if you add a `field` listener.
+ * `autoFiles` - Enables `file` events. This is automatically set to `true`
+ if you add a `file` listener.
+ * `uploadDir` - Only relevant when `autoFiles` is `true`. The directory for
+ placing file uploads in. You can move them later using `fs.rename()`.
+ Defaults to `os.tmpDir()`.
+ * `hash` - Only relevant when `autoFiles` is `true`. If you want checksums
+ calculated for incoming files, set this to either `sha1` or `md5`.
+ Defaults to off.
+
+#### form.parse(request, [cb])
+
+Parses an incoming node.js `request` containing form data. If `cb` is
+provided, `autoFields` and `autoFiles` are set to `true` and all fields and
+files are collected and passed to the callback:
+
+```js
+form.parse(req, function(err, fields, files) {
+ // ...
+});
+```
+
+#### form.bytesReceived
+
+The amount of bytes received for this form so far.
+
+#### form.bytesExpected
+
+The expected number of bytes in this form.
+
+### Events
+
+#### 'error' (err)
+
+You definitely want to handle this event. If not your server *will* crash when
+users submit bogus multipart requests!
+
+#### 'part' (part)
+
+Emitted when a part is encountered in the request. `part` is a
+`ReadableStream`. It also has the following properties:
+
+ * `headers` - the headers for this part. For example, you may be interested
+ in `content-type`.
+ * `name` - the field name for this part
+ * `filename` - only if the part is an incoming file
+ * `byteOffset` - the byte offset of this part in the request body
+ * `byteCount` - assuming that this is the last part in the request,
+ this is the size of this part in bytes. You could use this, for
+ example, to set the `Content-Length` header if uploading to S3.
+ If the part had a `Content-Length` header then that value is used
+ here instead.
+
+#### 'aborted'
+
+Emitted when the request is aborted. This event will be followed shortly
+by an `error` event. In practice you do not need to handle this event.
+
+#### 'progress' (bytesReceived, bytesExpected)
+
+#### 'close'
+
+Emitted after all parts have been parsed and emitted. Not emitted if an `error`
+event is emitted. This is typically when you would send your response.
+
+#### 'file' (name, file)
+
+**By default multiparty will not touch your hard drive.** But if you add this
+listener, multiparty automatically sets `form.autoFiles` to `true` and will
+stream uploads to disk for you.
+
+ * `name` - the field name for this file
+ * `file` - an object with these properties:
+ - `originalFilename` - the filename that the user reports for the file
+ - `path` - the absolute path of the uploaded file on disk
+ - `headers` - the HTTP headers that were sent along with this file
+ - `size` - size of the file in bytes
+
+If you set the `form.hash` option, then `file` will also contain a `hash`
+property which is the checksum of the file.
+
+#### 'field' (name, value)
+
+ * `name` - field name
+ * `value` - string field value
+
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/examples/azureblobstorage.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/examples/azureblobstorage.js
new file mode 100644
index 000000000..1c1f921dc
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/examples/azureblobstorage.js
@@ -0,0 +1,41 @@
+var http = require('http')
+ , util = require('util')
+ , multiparty = require('../')
+ , azure = require('azure')
+ , PORT = process.env.PORT || 27372
+
+var server = http.createServer(function(req, res) {
+ if (req.url === '/') {
+ res.writeHead(200, {'content-type': 'text/html'});
+ res.end(
+ ''
+ );
+ } else if (req.url === '/upload') {
+
+ var blobService = azure.createBlobService();
+ var form = new multiparty.Form();
+ form.on('part', function(part) {
+ if (!part.filename) return;
+
+ var size = part.byteCount - part.byteOffset;
+ var name = part.filename;
+ var container = 'blobContainerName';
+
+ blobService.createBlockBlobFromStream(container, name, part, size, function(error) {
+ if (error) {
+ // error handling
+ }
+ });
+ });
+ form.parse(req);
+
+ res.send('File uploaded successfully');
+
+});
+server.listen(PORT, function() {
+ console.info('listening on http://0.0.0.0:'+PORT+'/');
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/examples/s3.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/examples/s3.js
new file mode 100644
index 000000000..60617ba2c
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/examples/s3.js
@@ -0,0 +1,74 @@
+var http = require('http')
+ , util = require('util')
+ , multiparty = require('../')
+ , knox = require('knox')
+ , Batch = require('batch')
+ , PORT = process.env.PORT || 27372
+
+var s3Client = knox.createClient({
+ secure: false,
+ key: process.env.S3_KEY,
+ secret: process.env.S3_SECRET,
+ bucket: process.env.S3_BUCKET,
+});
+
+var server = http.createServer(function(req, res) {
+ if (req.url === '/') {
+ res.writeHead(200, {'content-type': 'text/html'});
+ res.end(
+ ''
+ );
+ } else if (req.url === '/upload') {
+ var headers = {
+ 'x-amz-acl': 'public-read',
+ };
+ var form = new multiparty.Form();
+ var batch = new Batch();
+ batch.push(function(cb) {
+ form.on('field', function(name, value) {
+ if (name === 'path') {
+ var destPath = value;
+ if (destPath[0] !== '/') destPath = '/' + destPath;
+ cb(null, destPath);
+ }
+ });
+ });
+ batch.push(function(cb) {
+ form.on('part', function(part) {
+ if (! part.filename) return;
+ cb(null, part);
+ });
+ });
+ batch.end(function(err, results) {
+ if (err) throw err;
+ form.removeListener('close', onEnd);
+ var destPath = results[0]
+ , part = results[1];
+
+ headers['Content-Length'] = part.byteCount;
+ s3Client.putStream(part, destPath, headers, function(err, s3Response) {
+ if (err) throw err;
+ res.statusCode = s3Response.statusCode;
+ s3Response.pipe(res);
+ console.log("https://s3.amazonaws.com/" + process.env.S3_BUCKET + destPath);
+ });
+ });
+ form.on('close', onEnd);
+ form.parse(req);
+
+ } else {
+ res.writeHead(404, {'content-type': 'text/plain'});
+ res.end('404');
+ }
+
+ function onEnd() {
+ throw new Error("no uploaded file");
+ }
+});
+server.listen(PORT, function() {
+ console.info('listening on http://0.0.0.0:'+PORT+'/');
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/examples/upload.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/examples/upload.js
new file mode 100644
index 000000000..5dd392684
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/examples/upload.js
@@ -0,0 +1,37 @@
+var http = require('http')
+ , util = require('util')
+ , multiparty = require('../')
+ , PORT = process.env.PORT || 27372
+
+var server = http.createServer(function(req, res) {
+ if (req.url === '/') {
+ res.writeHead(200, {'content-type': 'text/html'});
+ res.end(
+ ''
+ );
+ } else if (req.url === '/upload') {
+ var form = new multiparty.Form();
+
+ form.parse(req, function(err, fields, files) {
+ if (err) {
+ res.writeHead(400, {'content-type': 'text/plain'});
+ res.end("invalid request: " + err.message);
+ return;
+ }
+ res.writeHead(200, {'content-type': 'text/plain'});
+ res.write('received fields:\n\n '+util.inspect(fields));
+ res.write('\n\n');
+ res.end('received files:\n\n '+util.inspect(files));
+ });
+ } else {
+ res.writeHead(404, {'content-type': 'text/plain'});
+ res.end('404');
+ }
+});
+server.listen(PORT, function() {
+ console.info('listening on http://0.0.0.0:'+PORT+'/');
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/index.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/index.js
new file mode 100755
index 000000000..c96ef3a51
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/index.js
@@ -0,0 +1,596 @@
+exports.Form = Form;
+
+var stream = require('readable-stream')
+ , util = require('util')
+ , fs = require('fs')
+ , crypto = require('crypto')
+ , path = require('path')
+ , os = require('os')
+ , assert = require('assert')
+ , StringDecoder = require('string_decoder').StringDecoder
+ , StreamCounter = require('stream-counter')
+
+var START = 0
+ , START_BOUNDARY = 1
+ , HEADER_FIELD_START = 2
+ , HEADER_FIELD = 3
+ , HEADER_VALUE_START = 4
+ , HEADER_VALUE = 5
+ , HEADER_VALUE_ALMOST_DONE = 6
+ , HEADERS_ALMOST_DONE = 7
+ , PART_DATA_START = 8
+ , PART_DATA = 9
+ , PART_END = 10
+ , END = 11
+
+ , LF = 10
+ , CR = 13
+ , SPACE = 32
+ , HYPHEN = 45
+ , COLON = 58
+ , A = 97
+ , Z = 122
+
+var CONTENT_TYPE_RE = /^multipart\/(form-data|related);\s+boundary=(?:"([^"]+)"|([^;]+))$/i;
+var FILE_EXT_RE = /(\.[_\-a-zA-Z0-9]{0,16}).*/;
+var LAST_BOUNDARY_SUFFIX_LEN = 4; // --\r\n
+
+util.inherits(Form, stream.Writable);
+function Form(options) {
+ var self = this;
+ stream.Writable.call(self);
+
+ options = options || {};
+
+ self.error = null;
+ self.finished = false;
+
+ self.autoFields = !!options.autoFields;
+ self.autoFiles = !!options.autoFields;
+
+ self.maxFields = options.maxFields || 1000;
+ self.maxFieldsSize = options.maxFieldsSize || 2 * 1024 * 1024;
+ self.uploadDir = options.uploadDir || os.tmpDir();
+ self.encoding = options.encoding || 'utf8';
+ self.hash = options.hash || false;
+
+ self.bytesReceived = 0;
+ self.bytesExpected = null;
+
+ self.openedFiles = [];
+ self.totalFieldSize = 0;
+ self.totalFieldCount = 0;
+ self.flushing = 0;
+
+ self.backpressure = false;
+ self.writeCbs = [];
+
+ if (options.boundary) setUpParser(self, options.boundary);
+
+ self.on('newListener', function(eventName) {
+ if (eventName === 'file') {
+ self.autoFiles = true;
+ } else if (eventName === 'field') {
+ self.autoFields = true;
+ }
+ });
+}
+
+Form.prototype.parse = function(req, cb) {
+ var self = this;
+
+ // if the user supplies a callback, this implies autoFields and autoFiles
+ if (cb) {
+ self.autoFields = true;
+ self.autoFiles = true;
+ }
+
+ req.on('error', function(err) {
+ error(self, err);
+ });
+ req.on('aborted', function() {
+ self.emit('aborted');
+ error(self, new Error("Request aborted"));
+ });
+
+ self.bytesExpected = getBytesExpected(req.headers);
+
+ var contentType = req.headers['content-type'];
+ if (!contentType) {
+ error(self, new Error('missing content-type header'));
+ return;
+ }
+
+ var m = contentType.match(CONTENT_TYPE_RE);
+ if (!m) {
+ error(self, new Error('unrecognized content-type: ' + contentType));
+ return;
+ }
+ var boundary = m[2] || m[3];
+ setUpParser(self, boundary);
+ req.pipe(self);
+
+ if (cb) {
+ var fields = {}
+ , files = {};
+ self.on('error', function(err) {
+ cb(err);
+ });
+ self.on('field', function(name, value) {
+ fields[name] = value;
+ });
+ self.on('file', function(name, file) {
+ files[name] = file;
+ });
+ self.on('close', function() {
+ cb(null, fields, files);
+ });
+ }
+};
+
+Form.prototype._write = function(buffer, encoding, cb) {
+ var self = this
+ , i = 0
+ , len = buffer.length
+ , prevIndex = self.index
+ , index = self.index
+ , state = self.state
+ , lookbehind = self.lookbehind
+ , boundary = self.boundary
+ , boundaryChars = self.boundaryChars
+ , boundaryLength = self.boundary.length
+ , boundaryEnd = boundaryLength - 1
+ , bufferLength = buffer.length
+ , c
+ , cl
+
+ for (i = 0; i < len; i++) {
+ c = buffer[i];
+ switch (state) {
+ case START:
+ index = 0;
+ state = START_BOUNDARY;
+ /* falls through */
+ case START_BOUNDARY:
+ if (index === boundaryLength - 2) {
+ if (c !== CR) return error(self, new Error("Expected CR Received " + c));
+ index++;
+ break;
+ } else if (index === boundaryLength - 1) {
+ if (c !== LF) return error(self, new Error("Expected LF Received " + c));
+ index = 0;
+ self.onParsePartBegin();
+ state = HEADER_FIELD_START;
+ break;
+ }
+
+ if (c !== boundary[index+2]) index = -2;
+ if (c === boundary[index+2]) index++;
+ break;
+ case HEADER_FIELD_START:
+ state = HEADER_FIELD;
+ self.headerFieldMark = i;
+ index = 0;
+ /* falls through */
+ case HEADER_FIELD:
+ if (c === CR) {
+ self.headerFieldMark = null;
+ state = HEADERS_ALMOST_DONE;
+ break;
+ }
+
+ index++;
+ if (c === HYPHEN) break;
+
+ if (c === COLON) {
+ if (index === 1) {
+ // empty header field
+ error(self, new Error("Empty header field"));
+ return;
+ }
+ self.onParseHeaderField(buffer.slice(self.headerFieldMark, i));
+ self.headerFieldMark = null;
+ state = HEADER_VALUE_START;
+ break;
+ }
+
+ cl = lower(c);
+ if (cl < A || cl > Z) {
+ error(self, new Error("Expected alphabetic character, received " + c));
+ return;
+ }
+ break;
+ case HEADER_VALUE_START:
+ if (c === SPACE) break;
+
+ self.headerValueMark = i;
+ state = HEADER_VALUE;
+ /* falls through */
+ case HEADER_VALUE:
+ if (c === CR) {
+ self.onParseHeaderValue(buffer.slice(self.headerValueMark, i));
+ self.headerValueMark = null;
+ self.onParseHeaderEnd();
+ state = HEADER_VALUE_ALMOST_DONE;
+ }
+ break;
+ case HEADER_VALUE_ALMOST_DONE:
+ if (c !== LF) return error(self, new Error("Expected LF Received " + c));
+ state = HEADER_FIELD_START;
+ break;
+ case HEADERS_ALMOST_DONE:
+ if (c !== LF) return error(self, new Error("Expected LF Received " + c));
+ var err = self.onParseHeadersEnd(i + 1);
+ if (err) return error(self, err);
+ state = PART_DATA_START;
+ break;
+ case PART_DATA_START:
+ state = PART_DATA;
+ self.partDataMark = i;
+ /* falls through */
+ case PART_DATA:
+ prevIndex = index;
+
+ if (index === 0) {
+ // boyer-moore derrived algorithm to safely skip non-boundary data
+ i += boundaryEnd;
+ while (i < bufferLength && !(buffer[i] in boundaryChars)) {
+ i += boundaryLength;
+ }
+ i -= boundaryEnd;
+ c = buffer[i];
+ }
+
+ if (index < boundaryLength) {
+ if (boundary[index] === c) {
+ if (index === 0) {
+ self.onParsePartData(buffer.slice(self.partDataMark, i));
+ self.partDataMark = null;
+ }
+ index++;
+ } else {
+ index = 0;
+ }
+ } else if (index === boundaryLength) {
+ index++;
+ if (c === CR) {
+ // CR = part boundary
+ self.partBoundaryFlag = true;
+ } else if (c === HYPHEN) {
+ // HYPHEN = end boundary
+ self.lastBoundaryFlag = true;
+ } else {
+ index = 0;
+ }
+ } else if (index - 1 === boundaryLength) {
+ if (self.partBoundaryFlag) {
+ index = 0;
+ if (c === LF) {
+ self.partBoundaryFlag = false;
+ self.onParsePartEnd();
+ self.onParsePartBegin();
+ state = HEADER_FIELD_START;
+ break;
+ }
+ } else if (self.lastBoundaryFlag) {
+ if (c === HYPHEN) {
+ self.onParsePartEnd();
+ self.end();
+ state = END;
+ } else {
+ index = 0;
+ }
+ } else {
+ index = 0;
+ }
+ }
+
+ if (index > 0) {
+ // when matching a possible boundary, keep a lookbehind reference
+ // in case it turns out to be a false lead
+ lookbehind[index-1] = c;
+ } else if (prevIndex > 0) {
+ // if our boundary turned out to be rubbish, the captured lookbehind
+ // belongs to partData
+ self.onParsePartData(lookbehind.slice(0, prevIndex));
+ prevIndex = 0;
+ self.partDataMark = i;
+
+ // reconsider the current character even so it interrupted the sequence
+ // it could be the beginning of a new sequence
+ i--;
+ }
+
+ break;
+ case END:
+ break;
+ default:
+ error(self, new Error("Parser has invalid state."));
+ return;
+ }
+ }
+
+ if (self.headerFieldMark != null) {
+ self.onParseHeaderField(buffer.slice(self.headerFieldMark));
+ self.headerFieldMark = 0;
+ }
+ if (self.headerValueMark != null) {
+ self.onParseHeaderValue(buffer.slice(self.headerValueMark));
+ self.headerValueMark = 0;
+ }
+ if (self.partDataMark != null) {
+ self.onParsePartData(buffer.slice(self.partDataMark));
+ self.partDataMark = 0;
+ }
+
+ self.index = index;
+ self.state = state;
+
+ self.bytesReceived += buffer.length;
+ self.emit('progress', self.bytesReceived, self.bytesExpected);
+
+ if (self.backpressure) {
+ self.writeCbs.push(cb);
+ } else {
+ cb();
+ }
+};
+
+Form.prototype.onParsePartBegin = function() {
+ clearPartVars(this);
+}
+
+Form.prototype.onParseHeaderField = function(b) {
+ this.headerField += this.headerFieldDecoder.write(b);
+}
+
+Form.prototype.onParseHeaderValue = function(b) {
+ this.headerValue += this.headerValueDecoder.write(b);
+}
+
+Form.prototype.onParseHeaderEnd = function() {
+ this.headerField = this.headerField.toLowerCase();
+ this.partHeaders[this.headerField] = this.headerValue;
+
+ var m;
+ if (this.headerField === 'content-disposition') {
+ if (m = this.headerValue.match(/\bname="([^"]+)"/i)) {
+ this.partName = m[1];
+ }
+ this.partFilename = parseFilename(this.headerValue);
+ } else if (this.headerField === 'content-transfer-encoding') {
+ this.partTransferEncoding = this.headerValue.toLowerCase();
+ }
+
+ this.headerFieldDecoder = new StringDecoder(this.encoding);
+ this.headerField = '';
+ this.headerValueDecoder = new StringDecoder(this.encoding);
+ this.headerValue = '';
+}
+
+Form.prototype.onParsePartData = function(b) {
+ if (this.partTransferEncoding === 'base64') {
+ this.backpressure = ! this.destStream.write(b.toString('ascii'), 'base64');
+ } else {
+ this.backpressure = ! this.destStream.write(b);
+ }
+}
+
+Form.prototype.onParsePartEnd = function() {
+ if (this.destStream) {
+ flushWriteCbs(this);
+ var s = this.destStream;
+ process.nextTick(function() {
+ s.end();
+ });
+ }
+ clearPartVars(this);
+}
+
+Form.prototype.onParseHeadersEnd = function(offset) {
+ var self = this;
+ switch(self.partTransferEncoding){
+ case 'binary':
+ case '7bit':
+ case '8bit':
+ self.partTransferEncoding = 'binary';
+ break;
+
+ case 'base64': break;
+ default:
+ return new Error("unknown transfer-encoding: " + self.partTransferEncoding);
+ }
+
+ self.destStream = new stream.PassThrough();
+ self.destStream.on('drain', function() {
+ flushWriteCbs(self);
+ });
+ self.destStream.headers = self.partHeaders;
+ self.destStream.name = self.partName;
+ self.destStream.filename = self.partFilename;
+ self.destStream.byteOffset = self.bytesReceived + offset;
+ var partContentLength = self.destStream.headers['content-length'];
+ self.destStream.byteCount = partContentLength ?
+ parseInt(partContentLength, 10) :
+ (self.bytesExpected - self.destStream.byteOffset -
+ self.boundary.length - LAST_BOUNDARY_SUFFIX_LEN);
+ self.totalFieldCount += 1;
+ if (self.totalFieldCount >= self.maxFields) {
+ error(self, new Error("maxFields " + self.maxFields + " exceeded."));
+ return;
+ }
+
+ self.emit('part', self.destStream);
+ if (self.destStream.filename == null && self.autoFields) {
+ handleField(self, self.destStream);
+ } else if (self.destStream.filename != null && self.autoFiles) {
+ handleFile(self, self.destStream);
+ }
+}
+
+function flushWriteCbs(self) {
+ self.writeCbs.forEach(function(cb) {
+ process.nextTick(cb);
+ });
+ self.writeCbs = [];
+ self.backpressure = false;
+}
+
+function getBytesExpected(headers) {
+ var contentLength = headers['content-length'];
+ if (contentLength) {
+ return parseInt(contentLength, 10);
+ } else if (headers['transfer-encoding'] == null) {
+ return 0;
+ } else {
+ return null;
+ }
+}
+
+function error(self, err) {
+ assert.ok(!self.error, err.stack);
+ self.error = err;
+ self.emit('error', err);
+ self.openedFiles.forEach(function(file) {
+ file.ws.destroy();
+ fs.unlink(file.path, function(err) {
+ // this is already an error condition, ignore 2nd error
+ });
+ });
+}
+
+function beginFlush(self) {
+ self.flushing += 1;
+}
+
+function endFlush(self) {
+ self.flushing -= 1;
+ maybeClose(self);
+}
+
+function maybeClose(self) {
+ if (!self.flushing && self.finished && !self.error) {
+ self.emit('close');
+ }
+}
+
+function handleFile(self, fileStream) {
+ beginFlush(self);
+ var file = {
+ originalFilename: fileStream.filename,
+ path: uploadPath(self.uploadDir, fileStream.filename),
+ headers: fileStream.headers,
+ };
+ file.ws = fs.createWriteStream(file.path);
+ self.openedFiles.push(file);
+ fileStream.pipe(file.ws);
+ var counter = new StreamCounter();
+ fileStream.pipe(counter);
+ var hashWorkaroundStream
+ , hash = null;
+ if (self.hash) {
+ // workaround stream because https://github.com/joyent/node/issues/5216
+ hashWorkaroundStream = stream.Writable();
+ hash = crypto.createHash(self.hash);
+ hashWorkaroundStream._write = function(buffer, encoding, callback) {
+ hash.update(buffer);
+ callback();
+ };
+ fileStream.pipe(hashWorkaroundStream);
+ }
+ file.ws.on('error', function(err) {
+ error(self, err);
+ });
+ file.ws.on('close', function() {
+ if (hash) file.hash = hash.digest('hex');
+ file.size = counter.bytes;
+ self.emit('file', fileStream.name, file);
+ endFlush(self);
+ });
+}
+
+function handleField(self, fieldStream) {
+ var value = ''
+ , decoder = new StringDecoder(self.encoding);
+
+ beginFlush(self);
+ fieldStream.on('readable', function() {
+ var buffer = fieldStream.read();
+ self.totalFieldSize += buffer.length;
+ if (self.totalFieldSize > self.maxFieldsSize) {
+ error(self, new Error("maxFieldsSize " + self.maxFieldsSize + " exceeded"));
+ return;
+ }
+ value += decoder.write(buffer);
+ });
+
+ fieldStream.on('end', function() {
+ self.emit('field', fieldStream.name, value);
+ endFlush(self);
+ });
+}
+
+function clearPartVars(self) {
+ self.partHeaders = {};
+ self.partName = null;
+ self.partFilename = null;
+ self.partTransferEncoding = 'binary';
+ self.destStream = null;
+
+ self.headerFieldDecoder = new StringDecoder(self.encoding);
+ self.headerField = "";
+ self.headerValueDecoder = new StringDecoder(self.encoding);
+ self.headerValue = "";
+}
+
+function setUpParser(self, boundary) {
+ self.boundary = new Buffer(boundary.length + 4);
+ self.boundary.write('\r\n--', 0, boundary.length + 4, 'ascii');
+ self.boundary.write(boundary, 4, boundary.length, 'ascii');
+ self.lookbehind = new Buffer(self.boundary.length + 8);
+ self.state = START;
+ self.boundaryChars = {};
+ for (var i = 0; i < self.boundary.length; i++) {
+ self.boundaryChars[self.boundary[i]] = true;
+ }
+
+ self.index = null;
+ self.partBoundaryFlag = false;
+ self.lastBoundaryFlag = false;
+
+ self.on('finish', function() {
+ if ((self.state === HEADER_FIELD_START && self.index === 0) ||
+ (self.state === PART_DATA && self.index === self.boundary.length))
+ {
+ self.onParsePartEnd();
+ } else if (self.state !== END) {
+ error(self, new Error('stream ended unexpectedly'));
+ }
+ self.finished = true;
+ maybeClose(self);
+ });
+}
+
+function uploadPath(baseDir, filename) {
+ var ext = path.extname(filename).replace(FILE_EXT_RE, '$1');
+ var name = process.pid + '-' +
+ (Math.random() * 0x100000000 + 1).toString(36) + ext;
+ return path.join(baseDir, name);
+}
+
+function parseFilename(headerValue) {
+ var m = headerValue.match(/\bfilename="(.*?)"($|; )/i);
+ if (!m) return;
+
+ var filename = m[1].substr(m[1].lastIndexOf('\\') + 1);
+ filename = filename.replace(/%22/g, '"');
+ filename = filename.replace(/&#([\d]{4});/g, function(m, code) {
+ return String.fromCharCode(code);
+ });
+ return filename;
+}
+
+function lower(c) {
+ return c | 0x20;
+}
+
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/LICENSE b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/LICENSE
new file mode 100644
index 000000000..0c44ae716
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) Isaac Z. Schlueter ("Author")
+All rights reserved.
+
+The BSD License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/README.md b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/README.md
new file mode 100644
index 000000000..be976683e
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/README.md
@@ -0,0 +1,768 @@
+# readable-stream
+
+A new class of streams for Node.js
+
+This module provides the new Stream base classes introduced in Node
+v0.10, for use in Node v0.8. You can use it to have programs that
+have to work with node v0.8, while being forward-compatible for v0.10
+and beyond. When you drop support for v0.8, you can remove this
+module, and only use the native streams.
+
+This is almost exactly the same codebase as appears in Node v0.10.
+However:
+
+1. The exported object is actually the Readable class. Decorating the
+ native `stream` module would be global pollution.
+2. In v0.10, you can safely use `base64` as an argument to
+ `setEncoding` in Readable streams. However, in v0.8, the
+ StringDecoder class has no `end()` method, which is problematic for
+ Base64. So, don't use that, because it'll break and be weird.
+
+Other than that, the API is the same as `require('stream')` in v0.10,
+so the API docs are reproduced below.
+
+----------
+
+ Stability: 2 - Unstable
+
+A stream is an abstract interface implemented by various objects in
+Node. For example a request to an HTTP server is a stream, as is
+stdout. Streams are readable, writable, or both. All streams are
+instances of [EventEmitter][]
+
+You can load the Stream base classes by doing `require('stream')`.
+There are base classes provided for Readable streams, Writable
+streams, Duplex streams, and Transform streams.
+
+## Compatibility
+
+In earlier versions of Node, the Readable stream interface was
+simpler, but also less powerful and less useful.
+
+* Rather than waiting for you to call the `read()` method, `'data'`
+ events would start emitting immediately. If you needed to do some
+ I/O to decide how to handle data, then you had to store the chunks
+ in some kind of buffer so that they would not be lost.
+* The `pause()` method was advisory, rather than guaranteed. This
+ meant that you still had to be prepared to receive `'data'` events
+ even when the stream was in a paused state.
+
+In Node v0.10, the Readable class described below was added. For
+backwards compatibility with older Node programs, Readable streams
+switch into "old mode" when a `'data'` event handler is added, or when
+the `pause()` or `resume()` methods are called. The effect is that,
+even if you are not using the new `read()` method and `'readable'`
+event, you no longer have to worry about losing `'data'` chunks.
+
+Most programs will continue to function normally. However, this
+introduces an edge case in the following conditions:
+
+* No `'data'` event handler is added.
+* The `pause()` and `resume()` methods are never called.
+
+For example, consider the following code:
+
+```javascript
+// WARNING! BROKEN!
+net.createServer(function(socket) {
+
+ // we add an 'end' method, but never consume the data
+ socket.on('end', function() {
+ // It will never get here.
+ socket.end('I got your message (but didnt read it)\n');
+ });
+
+}).listen(1337);
+```
+
+In versions of node prior to v0.10, the incoming message data would be
+simply discarded. However, in Node v0.10 and beyond, the socket will
+remain paused forever.
+
+The workaround in this situation is to call the `resume()` method to
+trigger "old mode" behavior:
+
+```javascript
+// Workaround
+net.createServer(function(socket) {
+
+ socket.on('end', function() {
+ socket.end('I got your message (but didnt read it)\n');
+ });
+
+ // start the flow of data, discarding it.
+ socket.resume();
+
+}).listen(1337);
+```
+
+In addition to new Readable streams switching into old-mode, pre-v0.10
+style streams can be wrapped in a Readable class using the `wrap()`
+method.
+
+## Class: stream.Readable
+
+
+
+A `Readable Stream` has the following methods, members, and events.
+
+Note that `stream.Readable` is an abstract class designed to be
+extended with an underlying implementation of the `_read(size)`
+method. (See below.)
+
+### new stream.Readable([options])
+
+* `options` {Object}
+ * `highWaterMark` {Number} The maximum number of bytes to store in
+ the internal buffer before ceasing to read from the underlying
+ resource. Default=16kb
+ * `encoding` {String} If specified, then buffers will be decoded to
+ strings using the specified encoding. Default=null
+ * `objectMode` {Boolean} Whether this stream should behave
+ as a stream of objects. Meaning that stream.read(n) returns
+ a single value instead of a Buffer of size n
+
+In classes that extend the Readable class, make sure to call the
+constructor so that the buffering settings can be properly
+initialized.
+
+### readable.\_read(size)
+
+* `size` {Number} Number of bytes to read asynchronously
+
+Note: **This function should NOT be called directly.** It should be
+implemented by child classes, and called by the internal Readable
+class methods only.
+
+All Readable stream implementations must provide a `_read` method
+to fetch data from the underlying resource.
+
+This method is prefixed with an underscore because it is internal to
+the class that defines it, and should not be called directly by user
+programs. However, you **are** expected to override this method in
+your own extension classes.
+
+When data is available, put it into the read queue by calling
+`readable.push(chunk)`. If `push` returns false, then you should stop
+reading. When `_read` is called again, you should start pushing more
+data.
+
+The `size` argument is advisory. Implementations where a "read" is a
+single call that returns data can use this to know how much data to
+fetch. Implementations where that is not relevant, such as TCP or
+TLS, may ignore this argument, and simply provide data whenever it
+becomes available. There is no need, for example to "wait" until
+`size` bytes are available before calling `stream.push(chunk)`.
+
+### readable.push(chunk)
+
+* `chunk` {Buffer | null | String} Chunk of data to push into the read queue
+* return {Boolean} Whether or not more pushes should be performed
+
+Note: **This function should be called by Readable implementors, NOT
+by consumers of Readable subclasses.** The `_read()` function will not
+be called again until at least one `push(chunk)` call is made. If no
+data is available, then you MAY call `push('')` (an empty string) to
+allow a future `_read` call, without adding any data to the queue.
+
+The `Readable` class works by putting data into a read queue to be
+pulled out later by calling the `read()` method when the `'readable'`
+event fires.
+
+The `push()` method will explicitly insert some data into the read
+queue. If it is called with `null` then it will signal the end of the
+data.
+
+In some cases, you may be wrapping a lower-level source which has some
+sort of pause/resume mechanism, and a data callback. In those cases,
+you could wrap the low-level source object by doing something like
+this:
+
+```javascript
+// source is an object with readStop() and readStart() methods,
+// and an `ondata` member that gets called when it has data, and
+// an `onend` member that gets called when the data is over.
+
+var stream = new Readable();
+
+source.ondata = function(chunk) {
+ // if push() returns false, then we need to stop reading from source
+ if (!stream.push(chunk))
+ source.readStop();
+};
+
+source.onend = function() {
+ stream.push(null);
+};
+
+// _read will be called when the stream wants to pull more data in
+// the advisory size argument is ignored in this case.
+stream._read = function(n) {
+ source.readStart();
+};
+```
+
+### readable.unshift(chunk)
+
+* `chunk` {Buffer | null | String} Chunk of data to unshift onto the read queue
+* return {Boolean} Whether or not more pushes should be performed
+
+This is the corollary of `readable.push(chunk)`. Rather than putting
+the data at the *end* of the read queue, it puts it at the *front* of
+the read queue.
+
+This is useful in certain use-cases where a stream is being consumed
+by a parser, which needs to "un-consume" some data that it has
+optimistically pulled out of the source.
+
+```javascript
+// A parser for a simple data protocol.
+// The "header" is a JSON object, followed by 2 \n characters, and
+// then a message body.
+//
+// Note: This can be done more simply as a Transform stream. See below.
+
+function SimpleProtocol(source, options) {
+ if (!(this instanceof SimpleProtocol))
+ return new SimpleProtocol(options);
+
+ Readable.call(this, options);
+ this._inBody = false;
+ this._sawFirstCr = false;
+
+ // source is a readable stream, such as a socket or file
+ this._source = source;
+
+ var self = this;
+ source.on('end', function() {
+ self.push(null);
+ });
+
+ // give it a kick whenever the source is readable
+ // read(0) will not consume any bytes
+ source.on('readable', function() {
+ self.read(0);
+ });
+
+ this._rawHeader = [];
+ this.header = null;
+}
+
+SimpleProtocol.prototype = Object.create(
+ Readable.prototype, { constructor: { value: SimpleProtocol }});
+
+SimpleProtocol.prototype._read = function(n) {
+ if (!this._inBody) {
+ var chunk = this._source.read();
+
+ // if the source doesn't have data, we don't have data yet.
+ if (chunk === null)
+ return this.push('');
+
+ // check if the chunk has a \n\n
+ var split = -1;
+ for (var i = 0; i < chunk.length; i++) {
+ if (chunk[i] === 10) { // '\n'
+ if (this._sawFirstCr) {
+ split = i;
+ break;
+ } else {
+ this._sawFirstCr = true;
+ }
+ } else {
+ this._sawFirstCr = false;
+ }
+ }
+
+ if (split === -1) {
+ // still waiting for the \n\n
+ // stash the chunk, and try again.
+ this._rawHeader.push(chunk);
+ this.push('');
+ } else {
+ this._inBody = true;
+ var h = chunk.slice(0, split);
+ this._rawHeader.push(h);
+ var header = Buffer.concat(this._rawHeader).toString();
+ try {
+ this.header = JSON.parse(header);
+ } catch (er) {
+ this.emit('error', new Error('invalid simple protocol data'));
+ return;
+ }
+ // now, because we got some extra data, unshift the rest
+ // back into the read queue so that our consumer will see it.
+ var b = chunk.slice(split);
+ this.unshift(b);
+
+ // and let them know that we are done parsing the header.
+ this.emit('header', this.header);
+ }
+ } else {
+ // from there on, just provide the data to our consumer.
+ // careful not to push(null), since that would indicate EOF.
+ var chunk = this._source.read();
+ if (chunk) this.push(chunk);
+ }
+};
+
+// Usage:
+var parser = new SimpleProtocol(source);
+// Now parser is a readable stream that will emit 'header'
+// with the parsed header data.
+```
+
+### readable.wrap(stream)
+
+* `stream` {Stream} An "old style" readable stream
+
+If you are using an older Node library that emits `'data'` events and
+has a `pause()` method that is advisory only, then you can use the
+`wrap()` method to create a Readable stream that uses the old stream
+as its data source.
+
+For example:
+
+```javascript
+var OldReader = require('./old-api-module.js').OldReader;
+var oreader = new OldReader;
+var Readable = require('stream').Readable;
+var myReader = new Readable().wrap(oreader);
+
+myReader.on('readable', function() {
+ myReader.read(); // etc.
+});
+```
+
+### Event: 'readable'
+
+When there is data ready to be consumed, this event will fire.
+
+When this event emits, call the `read()` method to consume the data.
+
+### Event: 'end'
+
+Emitted when the stream has received an EOF (FIN in TCP terminology).
+Indicates that no more `'data'` events will happen. If the stream is
+also writable, it may be possible to continue writing.
+
+### Event: 'data'
+
+The `'data'` event emits either a `Buffer` (by default) or a string if
+`setEncoding()` was used.
+
+Note that adding a `'data'` event listener will switch the Readable
+stream into "old mode", where data is emitted as soon as it is
+available, rather than waiting for you to call `read()` to consume it.
+
+### Event: 'error'
+
+Emitted if there was an error receiving data.
+
+### Event: 'close'
+
+Emitted when the underlying resource (for example, the backing file
+descriptor) has been closed. Not all streams will emit this.
+
+### readable.setEncoding(encoding)
+
+Makes the `'data'` event emit a string instead of a `Buffer`. `encoding`
+can be `'utf8'`, `'utf16le'` (`'ucs2'`), `'ascii'`, or `'hex'`.
+
+The encoding can also be set by specifying an `encoding` field to the
+constructor.
+
+### readable.read([size])
+
+* `size` {Number | null} Optional number of bytes to read.
+* Return: {Buffer | String | null}
+
+Note: **This function SHOULD be called by Readable stream users.**
+
+Call this method to consume data once the `'readable'` event is
+emitted.
+
+The `size` argument will set a minimum number of bytes that you are
+interested in. If not set, then the entire content of the internal
+buffer is returned.
+
+If there is no data to consume, or if there are fewer bytes in the
+internal buffer than the `size` argument, then `null` is returned, and
+a future `'readable'` event will be emitted when more is available.
+
+Calling `stream.read(0)` will always return `null`, and will trigger a
+refresh of the internal buffer, but otherwise be a no-op.
+
+### readable.pipe(destination, [options])
+
+* `destination` {Writable Stream}
+* `options` {Object} Optional
+ * `end` {Boolean} Default=true
+
+Connects this readable stream to `destination` WriteStream. Incoming
+data on this stream gets written to `destination`. Properly manages
+back-pressure so that a slow destination will not be overwhelmed by a
+fast readable stream.
+
+This function returns the `destination` stream.
+
+For example, emulating the Unix `cat` command:
+
+ process.stdin.pipe(process.stdout);
+
+By default `end()` is called on the destination when the source stream
+emits `end`, so that `destination` is no longer writable. Pass `{ end:
+false }` as `options` to keep the destination stream open.
+
+This keeps `writer` open so that "Goodbye" can be written at the
+end.
+
+ reader.pipe(writer, { end: false });
+ reader.on("end", function() {
+ writer.end("Goodbye\n");
+ });
+
+Note that `process.stderr` and `process.stdout` are never closed until
+the process exits, regardless of the specified options.
+
+### readable.unpipe([destination])
+
+* `destination` {Writable Stream} Optional
+
+Undo a previously established `pipe()`. If no destination is
+provided, then all previously established pipes are removed.
+
+### readable.pause()
+
+Switches the readable stream into "old mode", where data is emitted
+using a `'data'` event rather than being buffered for consumption via
+the `read()` method.
+
+Ceases the flow of data. No `'data'` events are emitted while the
+stream is in a paused state.
+
+### readable.resume()
+
+Switches the readable stream into "old mode", where data is emitted
+using a `'data'` event rather than being buffered for consumption via
+the `read()` method.
+
+Resumes the incoming `'data'` events after a `pause()`.
+
+
+## Class: stream.Writable
+
+
+
+A `Writable` Stream has the following methods, members, and events.
+
+Note that `stream.Writable` is an abstract class designed to be
+extended with an underlying implementation of the
+`_write(chunk, encoding, cb)` method. (See below.)
+
+### new stream.Writable([options])
+
+* `options` {Object}
+ * `highWaterMark` {Number} Buffer level when `write()` starts
+ returning false. Default=16kb
+ * `decodeStrings` {Boolean} Whether or not to decode strings into
+ Buffers before passing them to `_write()`. Default=true
+
+In classes that extend the Writable class, make sure to call the
+constructor so that the buffering settings can be properly
+initialized.
+
+### writable.\_write(chunk, encoding, callback)
+
+* `chunk` {Buffer | String} The chunk to be written. Will always
+ be a buffer unless the `decodeStrings` option was set to `false`.
+* `encoding` {String} If the chunk is a string, then this is the
+ encoding type. Ignore chunk is a buffer. Note that chunk will
+ **always** be a buffer unless the `decodeStrings` option is
+ explicitly set to `false`.
+* `callback` {Function} Call this function (optionally with an error
+ argument) when you are done processing the supplied chunk.
+
+All Writable stream implementations must provide a `_write` method to
+send data to the underlying resource.
+
+Note: **This function MUST NOT be called directly.** It should be
+implemented by child classes, and called by the internal Writable
+class methods only.
+
+Call the callback using the standard `callback(error)` pattern to
+signal that the write completed successfully or with an error.
+
+If the `decodeStrings` flag is set in the constructor options, then
+`chunk` may be a string rather than a Buffer, and `encoding` will
+indicate the sort of string that it is. This is to support
+implementations that have an optimized handling for certain string
+data encodings. If you do not explicitly set the `decodeStrings`
+option to `false`, then you can safely ignore the `encoding` argument,
+and assume that `chunk` will always be a Buffer.
+
+This method is prefixed with an underscore because it is internal to
+the class that defines it, and should not be called directly by user
+programs. However, you **are** expected to override this method in
+your own extension classes.
+
+
+### writable.write(chunk, [encoding], [callback])
+
+* `chunk` {Buffer | String} Data to be written
+* `encoding` {String} Optional. If `chunk` is a string, then encoding
+ defaults to `'utf8'`
+* `callback` {Function} Optional. Called when this chunk is
+ successfully written.
+* Returns {Boolean}
+
+Writes `chunk` to the stream. Returns `true` if the data has been
+flushed to the underlying resource. Returns `false` to indicate that
+the buffer is full, and the data will be sent out in the future. The
+`'drain'` event will indicate when the buffer is empty again.
+
+The specifics of when `write()` will return false, is determined by
+the `highWaterMark` option provided to the constructor.
+
+### writable.end([chunk], [encoding], [callback])
+
+* `chunk` {Buffer | String} Optional final data to be written
+* `encoding` {String} Optional. If `chunk` is a string, then encoding
+ defaults to `'utf8'`
+* `callback` {Function} Optional. Called when the final chunk is
+ successfully written.
+
+Call this method to signal the end of the data being written to the
+stream.
+
+### Event: 'drain'
+
+Emitted when the stream's write queue empties and it's safe to write
+without buffering again. Listen for it when `stream.write()` returns
+`false`.
+
+### Event: 'close'
+
+Emitted when the underlying resource (for example, the backing file
+descriptor) has been closed. Not all streams will emit this.
+
+### Event: 'finish'
+
+When `end()` is called and there are no more chunks to write, this
+event is emitted.
+
+### Event: 'pipe'
+
+* `source` {Readable Stream}
+
+Emitted when the stream is passed to a readable stream's pipe method.
+
+### Event 'unpipe'
+
+* `source` {Readable Stream}
+
+Emitted when a previously established `pipe()` is removed using the
+source Readable stream's `unpipe()` method.
+
+## Class: stream.Duplex
+
+
+
+A "duplex" stream is one that is both Readable and Writable, such as a
+TCP socket connection.
+
+Note that `stream.Duplex` is an abstract class designed to be
+extended with an underlying implementation of the `_read(size)`
+and `_write(chunk, encoding, callback)` methods as you would with a Readable or
+Writable stream class.
+
+Since JavaScript doesn't have multiple prototypal inheritance, this
+class prototypally inherits from Readable, and then parasitically from
+Writable. It is thus up to the user to implement both the lowlevel
+`_read(n)` method as well as the lowlevel `_write(chunk, encoding, cb)` method
+on extension duplex classes.
+
+### new stream.Duplex(options)
+
+* `options` {Object} Passed to both Writable and Readable
+ constructors. Also has the following fields:
+ * `allowHalfOpen` {Boolean} Default=true. If set to `false`, then
+ the stream will automatically end the readable side when the
+ writable side ends and vice versa.
+
+In classes that extend the Duplex class, make sure to call the
+constructor so that the buffering settings can be properly
+initialized.
+
+## Class: stream.Transform
+
+A "transform" stream is a duplex stream where the output is causally
+connected in some way to the input, such as a zlib stream or a crypto
+stream.
+
+There is no requirement that the output be the same size as the input,
+the same number of chunks, or arrive at the same time. For example, a
+Hash stream will only ever have a single chunk of output which is
+provided when the input is ended. A zlib stream will either produce
+much smaller or much larger than its input.
+
+Rather than implement the `_read()` and `_write()` methods, Transform
+classes must implement the `_transform()` method, and may optionally
+also implement the `_flush()` method. (See below.)
+
+### new stream.Transform([options])
+
+* `options` {Object} Passed to both Writable and Readable
+ constructors.
+
+In classes that extend the Transform class, make sure to call the
+constructor so that the buffering settings can be properly
+initialized.
+
+### transform.\_transform(chunk, encoding, callback)
+
+* `chunk` {Buffer | String} The chunk to be transformed. Will always
+ be a buffer unless the `decodeStrings` option was set to `false`.
+* `encoding` {String} If the chunk is a string, then this is the
+ encoding type. (Ignore if `decodeStrings` chunk is a buffer.)
+* `callback` {Function} Call this function (optionally with an error
+ argument) when you are done processing the supplied chunk.
+
+Note: **This function MUST NOT be called directly.** It should be
+implemented by child classes, and called by the internal Transform
+class methods only.
+
+All Transform stream implementations must provide a `_transform`
+method to accept input and produce output.
+
+`_transform` should do whatever has to be done in this specific
+Transform class, to handle the bytes being written, and pass them off
+to the readable portion of the interface. Do asynchronous I/O,
+process things, and so on.
+
+Call `transform.push(outputChunk)` 0 or more times to generate output
+from this input chunk, depending on how much data you want to output
+as a result of this chunk.
+
+Call the callback function only when the current chunk is completely
+consumed. Note that there may or may not be output as a result of any
+particular input chunk.
+
+This method is prefixed with an underscore because it is internal to
+the class that defines it, and should not be called directly by user
+programs. However, you **are** expected to override this method in
+your own extension classes.
+
+### transform.\_flush(callback)
+
+* `callback` {Function} Call this function (optionally with an error
+ argument) when you are done flushing any remaining data.
+
+Note: **This function MUST NOT be called directly.** It MAY be implemented
+by child classes, and if so, will be called by the internal Transform
+class methods only.
+
+In some cases, your transform operation may need to emit a bit more
+data at the end of the stream. For example, a `Zlib` compression
+stream will store up some internal state so that it can optimally
+compress the output. At the end, however, it needs to do the best it
+can with what is left, so that the data will be complete.
+
+In those cases, you can implement a `_flush` method, which will be
+called at the very end, after all the written data is consumed, but
+before emitting `end` to signal the end of the readable side. Just
+like with `_transform`, call `transform.push(chunk)` zero or more
+times, as appropriate, and call `callback` when the flush operation is
+complete.
+
+This method is prefixed with an underscore because it is internal to
+the class that defines it, and should not be called directly by user
+programs. However, you **are** expected to override this method in
+your own extension classes.
+
+### Example: `SimpleProtocol` parser
+
+The example above of a simple protocol parser can be implemented much
+more simply by using the higher level `Transform` stream class.
+
+In this example, rather than providing the input as an argument, it
+would be piped into the parser, which is a more idiomatic Node stream
+approach.
+
+```javascript
+function SimpleProtocol(options) {
+ if (!(this instanceof SimpleProtocol))
+ return new SimpleProtocol(options);
+
+ Transform.call(this, options);
+ this._inBody = false;
+ this._sawFirstCr = false;
+ this._rawHeader = [];
+ this.header = null;
+}
+
+SimpleProtocol.prototype = Object.create(
+ Transform.prototype, { constructor: { value: SimpleProtocol }});
+
+SimpleProtocol.prototype._transform = function(chunk, encoding, done) {
+ if (!this._inBody) {
+ // check if the chunk has a \n\n
+ var split = -1;
+ for (var i = 0; i < chunk.length; i++) {
+ if (chunk[i] === 10) { // '\n'
+ if (this._sawFirstCr) {
+ split = i;
+ break;
+ } else {
+ this._sawFirstCr = true;
+ }
+ } else {
+ this._sawFirstCr = false;
+ }
+ }
+
+ if (split === -1) {
+ // still waiting for the \n\n
+ // stash the chunk, and try again.
+ this._rawHeader.push(chunk);
+ } else {
+ this._inBody = true;
+ var h = chunk.slice(0, split);
+ this._rawHeader.push(h);
+ var header = Buffer.concat(this._rawHeader).toString();
+ try {
+ this.header = JSON.parse(header);
+ } catch (er) {
+ this.emit('error', new Error('invalid simple protocol data'));
+ return;
+ }
+ // and let them know that we are done parsing the header.
+ this.emit('header', this.header);
+
+ // now, because we got some extra data, emit this first.
+ this.push(b);
+ }
+ } else {
+ // from there on, just provide the data to our consumer as-is.
+ this.push(b);
+ }
+ done();
+};
+
+var parser = new SimpleProtocol();
+source.pipe(parser)
+
+// Now parser is a readable stream that will emit 'header'
+// with the parsed header data.
+```
+
+
+## Class: stream.PassThrough
+
+This is a trivial implementation of a `Transform` stream that simply
+passes the input bytes across to the output. Its purpose is mainly
+for examples and testing, but there are occasionally use cases where
+it can come in handy.
+
+
+[EventEmitter]: events.html#events_class_events_eventemitter
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/duplex.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/duplex.js
new file mode 100644
index 000000000..ca807af87
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/duplex.js
@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_duplex.js")
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/examples/CAPSLOCKTYPER.JS b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/examples/CAPSLOCKTYPER.JS
new file mode 100644
index 000000000..205a42564
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/examples/CAPSLOCKTYPER.JS
@@ -0,0 +1,32 @@
+var Transform = require('../transform');
+var inherits = require('util').inherits;
+
+// subclass
+function MyStream () {
+ Transform.call(this, {
+ lowWaterMark: 0,
+ encoding: 'utf8'
+ });
+}
+inherits(MyStream, Transform);
+
+MyStream.prototype._transform = function (chunk, outputFn, callback) {
+ outputFn(new Buffer(String(chunk).toUpperCase()));
+ callback();
+};
+
+// use it!
+var s = new MyStream();
+process.stdin.resume();
+process.stdin.pipe(s).pipe(process.stdout);
+if (process.stdin.setRawMode)
+ process.stdin.setRawMode(true);
+process.stdin.on('data', function (c) {
+ c = c.toString();
+ if (c === '\u0003' || c === '\u0004') {
+ process.stdin.pause();
+ s.end();
+ }
+ if (c === '\r')
+ process.stdout.write('\n');
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/examples/typer-fsr.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/examples/typer-fsr.js
new file mode 100644
index 000000000..7e715844b
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/examples/typer-fsr.js
@@ -0,0 +1,15 @@
+var fs = require('fs');
+var FSReadable = require('../fs.js');
+var rst = new FSReadable(__filename);
+
+rst.on('end', function() {
+ process.stdin.pause();
+});
+
+process.stdin.setRawMode(true);
+process.stdin.on('data', function() {
+ var c = rst.read(3);
+ if (!c) return;
+ process.stdout.write(c);
+});
+process.stdin.resume();
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/examples/typer.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/examples/typer.js
new file mode 100644
index 000000000..c16eb6fb0
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/examples/typer.js
@@ -0,0 +1,17 @@
+var fs = require('fs');
+var fst = fs.createReadStream(__filename);
+var Readable = require('../readable.js');
+var rst = new Readable();
+rst.wrap(fst);
+
+rst.on('end', function() {
+ process.stdin.pause();
+});
+
+process.stdin.setRawMode(true);
+process.stdin.on('data', function() {
+ var c = rst.read(3);
+ if (!c) return setTimeout(process.exit, 500)
+ process.stdout.write(c);
+});
+process.stdin.resume();
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/float.patch b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/float.patch
new file mode 100644
index 000000000..0ad71a1f0
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/float.patch
@@ -0,0 +1,68 @@
+diff --git a/lib/_stream_duplex.js b/lib/_stream_duplex.js
+index c5a741c..a2e0d8e 100644
+--- a/lib/_stream_duplex.js
++++ b/lib/_stream_duplex.js
+@@ -26,8 +26,8 @@
+
+ module.exports = Duplex;
+ var util = require('util');
+-var Readable = require('_stream_readable');
+-var Writable = require('_stream_writable');
++var Readable = require('./_stream_readable');
++var Writable = require('./_stream_writable');
+
+ util.inherits(Duplex, Readable);
+
+diff --git a/lib/_stream_passthrough.js b/lib/_stream_passthrough.js
+index a5e9864..330c247 100644
+--- a/lib/_stream_passthrough.js
++++ b/lib/_stream_passthrough.js
+@@ -25,7 +25,7 @@
+
+ module.exports = PassThrough;
+
+-var Transform = require('_stream_transform');
++var Transform = require('./_stream_transform');
+ var util = require('util');
+ util.inherits(PassThrough, Transform);
+
+diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js
+index 2259d2e..e6681ee 100644
+--- a/lib/_stream_readable.js
++++ b/lib/_stream_readable.js
+@@ -23,6 +23,9 @@ module.exports = Readable;
+ Readable.ReadableState = ReadableState;
+
+ var EE = require('events').EventEmitter;
++if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
++ return emitter.listeners(type).length;
++};
+ var Stream = require('stream');
+ var util = require('util');
+ var StringDecoder;
+diff --git a/lib/_stream_transform.js b/lib/_stream_transform.js
+index e925b4b..f08b05e 100644
+--- a/lib/_stream_transform.js
++++ b/lib/_stream_transform.js
+@@ -64,7 +64,7 @@
+
+ module.exports = Transform;
+
+-var Duplex = require('_stream_duplex');
++var Duplex = require('./_stream_duplex');
+ var util = require('util');
+ util.inherits(Transform, Duplex);
+
+diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
+index a26f711..56ca47d 100644
+--- a/lib/_stream_writable.js
++++ b/lib/_stream_writable.js
+@@ -109,7 +109,7 @@ function WritableState(options, stream) {
+ function Writable(options) {
+ // Writable ctor is applied to Duplexes, though they're not
+ // instanceof Writable, they're instanceof Readable.
+- if (!(this instanceof Writable) && !(this instanceof Stream.Duplex))
++ if (!(this instanceof Writable) && !(this instanceof require('./_stream_duplex')))
+ return new Writable(options);
+
+ this._writableState = new WritableState(options, this);
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/fs.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/fs.js
new file mode 100644
index 000000000..a663af86e
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/fs.js
@@ -0,0 +1,1705 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// Maintainers, keep in mind that octal literals are not allowed
+// in strict mode. Use the decimal value and add a comment with
+// the octal value. Example:
+//
+// var mode = 438; /* mode=0666 */
+
+var util = require('util');
+var pathModule = require('path');
+
+var binding = process.binding('fs');
+var constants = process.binding('constants');
+var fs = exports;
+var Stream = require('stream').Stream;
+var EventEmitter = require('events').EventEmitter;
+
+var Readable = require('./lib/_stream_readable.js');
+var Writable = require('./lib/_stream_writable.js');
+
+var kMinPoolSpace = 128;
+var kPoolSize = 40 * 1024;
+
+var O_APPEND = constants.O_APPEND || 0;
+var O_CREAT = constants.O_CREAT || 0;
+var O_DIRECTORY = constants.O_DIRECTORY || 0;
+var O_EXCL = constants.O_EXCL || 0;
+var O_NOCTTY = constants.O_NOCTTY || 0;
+var O_NOFOLLOW = constants.O_NOFOLLOW || 0;
+var O_RDONLY = constants.O_RDONLY || 0;
+var O_RDWR = constants.O_RDWR || 0;
+var O_SYMLINK = constants.O_SYMLINK || 0;
+var O_SYNC = constants.O_SYNC || 0;
+var O_TRUNC = constants.O_TRUNC || 0;
+var O_WRONLY = constants.O_WRONLY || 0;
+
+var isWindows = process.platform === 'win32';
+
+var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+
+function rethrow() {
+ // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
+ // is fairly slow to generate.
+ if (DEBUG) {
+ var backtrace = new Error;
+ return function(err) {
+ if (err) {
+ backtrace.message = err.message;
+ err = backtrace;
+ throw err;
+ }
+ };
+ }
+
+ return function(err) {
+ if (err) {
+ throw err; // Forgot a callback but don't know where? Use NODE_DEBUG=fs
+ }
+ };
+}
+
+function maybeCallback(cb) {
+ return typeof cb === 'function' ? cb : rethrow();
+}
+
+// Ensure that callbacks run in the global context. Only use this function
+// for callbacks that are passed to the binding layer, callbacks that are
+// invoked from JS already run in the proper scope.
+function makeCallback(cb) {
+ if (typeof cb !== 'function') {
+ return rethrow();
+ }
+
+ return function() {
+ return cb.apply(null, arguments);
+ };
+}
+
+function assertEncoding(encoding) {
+ if (encoding && !Buffer.isEncoding(encoding)) {
+ throw new Error('Unknown encoding: ' + encoding);
+ }
+}
+
+function nullCheck(path, callback) {
+ if (('' + path).indexOf('\u0000') !== -1) {
+ var er = new Error('Path must be a string without null bytes.');
+ if (!callback)
+ throw er;
+ process.nextTick(function() {
+ callback(er);
+ });
+ return false;
+ }
+ return true;
+}
+
+fs.Stats = binding.Stats;
+
+fs.Stats.prototype._checkModeProperty = function(property) {
+ return ((this.mode & constants.S_IFMT) === property);
+};
+
+fs.Stats.prototype.isDirectory = function() {
+ return this._checkModeProperty(constants.S_IFDIR);
+};
+
+fs.Stats.prototype.isFile = function() {
+ return this._checkModeProperty(constants.S_IFREG);
+};
+
+fs.Stats.prototype.isBlockDevice = function() {
+ return this._checkModeProperty(constants.S_IFBLK);
+};
+
+fs.Stats.prototype.isCharacterDevice = function() {
+ return this._checkModeProperty(constants.S_IFCHR);
+};
+
+fs.Stats.prototype.isSymbolicLink = function() {
+ return this._checkModeProperty(constants.S_IFLNK);
+};
+
+fs.Stats.prototype.isFIFO = function() {
+ return this._checkModeProperty(constants.S_IFIFO);
+};
+
+fs.Stats.prototype.isSocket = function() {
+ return this._checkModeProperty(constants.S_IFSOCK);
+};
+
+fs.exists = function(path, callback) {
+ if (!nullCheck(path, cb)) return;
+ binding.stat(pathModule._makeLong(path), cb);
+ function cb(err, stats) {
+ if (callback) callback(err ? false : true);
+ }
+};
+
+fs.existsSync = function(path) {
+ try {
+ nullCheck(path);
+ binding.stat(pathModule._makeLong(path));
+ return true;
+ } catch (e) {
+ return false;
+ }
+};
+
+fs.readFile = function(path, encoding_) {
+ var encoding = typeof(encoding_) === 'string' ? encoding_ : null;
+ var callback = maybeCallback(arguments[arguments.length - 1]);
+
+ assertEncoding(encoding);
+
+ // first, stat the file, so we know the size.
+ var size;
+ var buffer; // single buffer with file data
+ var buffers; // list for when size is unknown
+ var pos = 0;
+ var fd;
+
+ fs.open(path, constants.O_RDONLY, 438 /*=0666*/, function(er, fd_) {
+ if (er) return callback(er);
+ fd = fd_;
+
+ fs.fstat(fd, function(er, st) {
+ if (er) return callback(er);
+ size = st.size;
+ if (size === 0) {
+ // the kernel lies about many files.
+ // Go ahead and try to read some bytes.
+ buffers = [];
+ return read();
+ }
+
+ buffer = new Buffer(size);
+ read();
+ });
+ });
+
+ function read() {
+ if (size === 0) {
+ buffer = new Buffer(8192);
+ fs.read(fd, buffer, 0, 8192, -1, afterRead);
+ } else {
+ fs.read(fd, buffer, pos, size - pos, -1, afterRead);
+ }
+ }
+
+ function afterRead(er, bytesRead) {
+ if (er) {
+ return fs.close(fd, function(er2) {
+ return callback(er);
+ });
+ }
+
+ if (bytesRead === 0) {
+ return close();
+ }
+
+ pos += bytesRead;
+ if (size !== 0) {
+ if (pos === size) close();
+ else read();
+ } else {
+ // unknown size, just read until we don't get bytes.
+ buffers.push(buffer.slice(0, bytesRead));
+ read();
+ }
+ }
+
+ function close() {
+ fs.close(fd, function(er) {
+ if (size === 0) {
+ // collected the data into the buffers list.
+ buffer = Buffer.concat(buffers, pos);
+ } else if (pos < size) {
+ buffer = buffer.slice(0, pos);
+ }
+
+ if (encoding) buffer = buffer.toString(encoding);
+ return callback(er, buffer);
+ });
+ }
+};
+
+fs.readFileSync = function(path, encoding) {
+ assertEncoding(encoding);
+
+ var fd = fs.openSync(path, constants.O_RDONLY, 438 /*=0666*/);
+
+ var size;
+ var threw = true;
+ try {
+ size = fs.fstatSync(fd).size;
+ threw = false;
+ } finally {
+ if (threw) fs.closeSync(fd);
+ }
+
+ var pos = 0;
+ var buffer; // single buffer with file data
+ var buffers; // list for when size is unknown
+
+ if (size === 0) {
+ buffers = [];
+ } else {
+ buffer = new Buffer(size);
+ }
+
+ var done = false;
+ while (!done) {
+ var threw = true;
+ try {
+ if (size !== 0) {
+ var bytesRead = fs.readSync(fd, buffer, pos, size - pos);
+ } else {
+ // the kernel lies about many files.
+ // Go ahead and try to read some bytes.
+ buffer = new Buffer(8192);
+ var bytesRead = fs.readSync(fd, buffer, 0, 8192);
+ if (bytesRead) {
+ buffers.push(buffer.slice(0, bytesRead));
+ }
+ }
+ threw = false;
+ } finally {
+ if (threw) fs.closeSync(fd);
+ }
+
+ pos += bytesRead;
+ done = (bytesRead === 0) || (size !== 0 && pos >= size);
+ }
+
+ fs.closeSync(fd);
+
+ if (size === 0) {
+ // data was collected into the buffers list.
+ buffer = Buffer.concat(buffers, pos);
+ } else if (pos < size) {
+ buffer = buffer.slice(0, pos);
+ }
+
+ if (encoding) buffer = buffer.toString(encoding);
+ return buffer;
+};
+
+
+// Used by binding.open and friends
+function stringToFlags(flag) {
+ // Only mess with strings
+ if (typeof flag !== 'string') {
+ return flag;
+ }
+
+ // O_EXCL is mandated by POSIX, Windows supports it too.
+ // Let's add a check anyway, just in case.
+ if (!O_EXCL && ~flag.indexOf('x')) {
+ throw errnoException('ENOSYS', 'fs.open(O_EXCL)');
+ }
+
+ switch (flag) {
+ case 'r' : return O_RDONLY;
+ case 'rs' : return O_RDONLY | O_SYNC;
+ case 'r+' : return O_RDWR;
+ case 'rs+' : return O_RDWR | O_SYNC;
+
+ case 'w' : return O_TRUNC | O_CREAT | O_WRONLY;
+ case 'wx' : // fall through
+ case 'xw' : return O_TRUNC | O_CREAT | O_WRONLY | O_EXCL;
+
+ case 'w+' : return O_TRUNC | O_CREAT | O_RDWR;
+ case 'wx+': // fall through
+ case 'xw+': return O_TRUNC | O_CREAT | O_RDWR | O_EXCL;
+
+ case 'a' : return O_APPEND | O_CREAT | O_WRONLY;
+ case 'ax' : // fall through
+ case 'xa' : return O_APPEND | O_CREAT | O_WRONLY | O_EXCL;
+
+ case 'a+' : return O_APPEND | O_CREAT | O_RDWR;
+ case 'ax+': // fall through
+ case 'xa+': return O_APPEND | O_CREAT | O_RDWR | O_EXCL;
+ }
+
+ throw new Error('Unknown file open flag: ' + flag);
+}
+
+// exported but hidden, only used by test/simple/test-fs-open-flags.js
+Object.defineProperty(exports, '_stringToFlags', {
+ enumerable: false,
+ value: stringToFlags
+});
+
+
+// Yes, the follow could be easily DRYed up but I provide the explicit
+// list to make the arguments clear.
+
+fs.close = function(fd, callback) {
+ binding.close(fd, makeCallback(callback));
+};
+
+fs.closeSync = function(fd) {
+ return binding.close(fd);
+};
+
+function modeNum(m, def) {
+ switch (typeof m) {
+ case 'number': return m;
+ case 'string': return parseInt(m, 8);
+ default:
+ if (def) {
+ return modeNum(def);
+ } else {
+ return undefined;
+ }
+ }
+}
+
+fs.open = function(path, flags, mode, callback) {
+ callback = makeCallback(arguments[arguments.length - 1]);
+ mode = modeNum(mode, 438 /*=0666*/);
+
+ if (!nullCheck(path, callback)) return;
+ binding.open(pathModule._makeLong(path),
+ stringToFlags(flags),
+ mode,
+ callback);
+};
+
+fs.openSync = function(path, flags, mode) {
+ mode = modeNum(mode, 438 /*=0666*/);
+ nullCheck(path);
+ return binding.open(pathModule._makeLong(path), stringToFlags(flags), mode);
+};
+
+fs.read = function(fd, buffer, offset, length, position, callback) {
+ if (!Buffer.isBuffer(buffer)) {
+ // legacy string interface (fd, length, position, encoding, callback)
+ var cb = arguments[4],
+ encoding = arguments[3];
+
+ assertEncoding(encoding);
+
+ position = arguments[2];
+ length = arguments[1];
+ buffer = new Buffer(length);
+ offset = 0;
+
+ callback = function(err, bytesRead) {
+ if (!cb) return;
+
+ var str = (bytesRead > 0) ? buffer.toString(encoding, 0, bytesRead) : '';
+
+ (cb)(err, str, bytesRead);
+ };
+ }
+
+ function wrapper(err, bytesRead) {
+ // Retain a reference to buffer so that it can't be GC'ed too soon.
+ callback && callback(err, bytesRead || 0, buffer);
+ }
+
+ binding.read(fd, buffer, offset, length, position, wrapper);
+};
+
+fs.readSync = function(fd, buffer, offset, length, position) {
+ var legacy = false;
+ if (!Buffer.isBuffer(buffer)) {
+ // legacy string interface (fd, length, position, encoding, callback)
+ legacy = true;
+ var encoding = arguments[3];
+
+ assertEncoding(encoding);
+
+ position = arguments[2];
+ length = arguments[1];
+ buffer = new Buffer(length);
+
+ offset = 0;
+ }
+
+ var r = binding.read(fd, buffer, offset, length, position);
+ if (!legacy) {
+ return r;
+ }
+
+ var str = (r > 0) ? buffer.toString(encoding, 0, r) : '';
+ return [str, r];
+};
+
+fs.write = function(fd, buffer, offset, length, position, callback) {
+ if (!Buffer.isBuffer(buffer)) {
+ // legacy string interface (fd, data, position, encoding, callback)
+ callback = arguments[4];
+ position = arguments[2];
+ assertEncoding(arguments[3]);
+
+ buffer = new Buffer('' + arguments[1], arguments[3]);
+ offset = 0;
+ length = buffer.length;
+ }
+
+ if (!length) {
+ if (typeof callback == 'function') {
+ process.nextTick(function() {
+ callback(undefined, 0);
+ });
+ }
+ return;
+ }
+
+ callback = maybeCallback(callback);
+
+ function wrapper(err, written) {
+ // Retain a reference to buffer so that it can't be GC'ed too soon.
+ callback(err, written || 0, buffer);
+ }
+
+ binding.write(fd, buffer, offset, length, position, wrapper);
+};
+
+fs.writeSync = function(fd, buffer, offset, length, position) {
+ if (!Buffer.isBuffer(buffer)) {
+ // legacy string interface (fd, data, position, encoding)
+ position = arguments[2];
+ assertEncoding(arguments[3]);
+
+ buffer = new Buffer('' + arguments[1], arguments[3]);
+ offset = 0;
+ length = buffer.length;
+ }
+ if (!length) return 0;
+
+ return binding.write(fd, buffer, offset, length, position);
+};
+
+fs.rename = function(oldPath, newPath, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(oldPath, callback)) return;
+ if (!nullCheck(newPath, callback)) return;
+ binding.rename(pathModule._makeLong(oldPath),
+ pathModule._makeLong(newPath),
+ callback);
+};
+
+fs.renameSync = function(oldPath, newPath) {
+ nullCheck(oldPath);
+ nullCheck(newPath);
+ return binding.rename(pathModule._makeLong(oldPath),
+ pathModule._makeLong(newPath));
+};
+
+fs.truncate = function(path, len, callback) {
+ if (typeof path === 'number') {
+ // legacy
+ return fs.ftruncate(path, len, callback);
+ }
+ if (typeof len === 'function') {
+ callback = len;
+ len = 0;
+ } else if (typeof len === 'undefined') {
+ len = 0;
+ }
+ callback = maybeCallback(callback);
+ fs.open(path, 'w', function(er, fd) {
+ if (er) return callback(er);
+ binding.ftruncate(fd, len, function(er) {
+ fs.close(fd, function(er2) {
+ callback(er || er2);
+ });
+ });
+ });
+};
+
+fs.truncateSync = function(path, len) {
+ if (typeof path === 'number') {
+ // legacy
+ return fs.ftruncateSync(path, len);
+ }
+ if (typeof len === 'undefined') {
+ len = 0;
+ }
+ // allow error to be thrown, but still close fd.
+ var fd = fs.openSync(path, 'w');
+ try {
+ var ret = fs.ftruncateSync(fd, len);
+ } finally {
+ fs.closeSync(fd);
+ }
+ return ret;
+};
+
+fs.ftruncate = function(fd, len, callback) {
+ if (typeof len === 'function') {
+ callback = len;
+ len = 0;
+ } else if (typeof len === 'undefined') {
+ len = 0;
+ }
+ binding.ftruncate(fd, len, makeCallback(callback));
+};
+
+fs.ftruncateSync = function(fd, len) {
+ if (typeof len === 'undefined') {
+ len = 0;
+ }
+ return binding.ftruncate(fd, len);
+};
+
+fs.rmdir = function(path, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.rmdir(pathModule._makeLong(path), callback);
+};
+
+fs.rmdirSync = function(path) {
+ nullCheck(path);
+ return binding.rmdir(pathModule._makeLong(path));
+};
+
+fs.fdatasync = function(fd, callback) {
+ binding.fdatasync(fd, makeCallback(callback));
+};
+
+fs.fdatasyncSync = function(fd) {
+ return binding.fdatasync(fd);
+};
+
+fs.fsync = function(fd, callback) {
+ binding.fsync(fd, makeCallback(callback));
+};
+
+fs.fsyncSync = function(fd) {
+ return binding.fsync(fd);
+};
+
+fs.mkdir = function(path, mode, callback) {
+ if (typeof mode === 'function') callback = mode;
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.mkdir(pathModule._makeLong(path),
+ modeNum(mode, 511 /*=0777*/),
+ callback);
+};
+
+fs.mkdirSync = function(path, mode) {
+ nullCheck(path);
+ return binding.mkdir(pathModule._makeLong(path),
+ modeNum(mode, 511 /*=0777*/));
+};
+
+fs.sendfile = function(outFd, inFd, inOffset, length, callback) {
+ binding.sendfile(outFd, inFd, inOffset, length, makeCallback(callback));
+};
+
+fs.sendfileSync = function(outFd, inFd, inOffset, length) {
+ return binding.sendfile(outFd, inFd, inOffset, length);
+};
+
+fs.readdir = function(path, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.readdir(pathModule._makeLong(path), callback);
+};
+
+fs.readdirSync = function(path) {
+ nullCheck(path);
+ return binding.readdir(pathModule._makeLong(path));
+};
+
+fs.fstat = function(fd, callback) {
+ binding.fstat(fd, makeCallback(callback));
+};
+
+fs.lstat = function(path, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.lstat(pathModule._makeLong(path), callback);
+};
+
+fs.stat = function(path, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.stat(pathModule._makeLong(path), callback);
+};
+
+fs.fstatSync = function(fd) {
+ return binding.fstat(fd);
+};
+
+fs.lstatSync = function(path) {
+ nullCheck(path);
+ return binding.lstat(pathModule._makeLong(path));
+};
+
+fs.statSync = function(path) {
+ nullCheck(path);
+ return binding.stat(pathModule._makeLong(path));
+};
+
+fs.readlink = function(path, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.readlink(pathModule._makeLong(path), callback);
+};
+
+fs.readlinkSync = function(path) {
+ nullCheck(path);
+ return binding.readlink(pathModule._makeLong(path));
+};
+
+function preprocessSymlinkDestination(path, type) {
+ if (!isWindows) {
+ // No preprocessing is needed on Unix.
+ return path;
+ } else if (type === 'junction') {
+ // Junctions paths need to be absolute and \\?\-prefixed.
+ return pathModule._makeLong(path);
+ } else {
+ // Windows symlinks don't tolerate forward slashes.
+ return ('' + path).replace(/\//g, '\\');
+ }
+}
+
+fs.symlink = function(destination, path, type_, callback) {
+ var type = (typeof type_ === 'string' ? type_ : null);
+ var callback = makeCallback(arguments[arguments.length - 1]);
+
+ if (!nullCheck(destination, callback)) return;
+ if (!nullCheck(path, callback)) return;
+
+ binding.symlink(preprocessSymlinkDestination(destination, type),
+ pathModule._makeLong(path),
+ type,
+ callback);
+};
+
+fs.symlinkSync = function(destination, path, type) {
+ type = (typeof type === 'string' ? type : null);
+
+ nullCheck(destination);
+ nullCheck(path);
+
+ return binding.symlink(preprocessSymlinkDestination(destination, type),
+ pathModule._makeLong(path),
+ type);
+};
+
+fs.link = function(srcpath, dstpath, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(srcpath, callback)) return;
+ if (!nullCheck(dstpath, callback)) return;
+
+ binding.link(pathModule._makeLong(srcpath),
+ pathModule._makeLong(dstpath),
+ callback);
+};
+
+fs.linkSync = function(srcpath, dstpath) {
+ nullCheck(srcpath);
+ nullCheck(dstpath);
+ return binding.link(pathModule._makeLong(srcpath),
+ pathModule._makeLong(dstpath));
+};
+
+fs.unlink = function(path, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.unlink(pathModule._makeLong(path), callback);
+};
+
+fs.unlinkSync = function(path) {
+ nullCheck(path);
+ return binding.unlink(pathModule._makeLong(path));
+};
+
+fs.fchmod = function(fd, mode, callback) {
+ binding.fchmod(fd, modeNum(mode), makeCallback(callback));
+};
+
+fs.fchmodSync = function(fd, mode) {
+ return binding.fchmod(fd, modeNum(mode));
+};
+
+if (constants.hasOwnProperty('O_SYMLINK')) {
+ fs.lchmod = function(path, mode, callback) {
+ callback = maybeCallback(callback);
+ fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, function(err, fd) {
+ if (err) {
+ callback(err);
+ return;
+ }
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
+ fs.fchmod(fd, mode, function(err) {
+ fs.close(fd, function(err2) {
+ callback(err || err2);
+ });
+ });
+ });
+ };
+
+ fs.lchmodSync = function(path, mode) {
+ var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK);
+
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
+ var err, err2;
+ try {
+ var ret = fs.fchmodSync(fd, mode);
+ } catch (er) {
+ err = er;
+ }
+ try {
+ fs.closeSync(fd);
+ } catch (er) {
+ err2 = er;
+ }
+ if (err || err2) throw (err || err2);
+ return ret;
+ };
+}
+
+
+fs.chmod = function(path, mode, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.chmod(pathModule._makeLong(path),
+ modeNum(mode),
+ callback);
+};
+
+fs.chmodSync = function(path, mode) {
+ nullCheck(path);
+ return binding.chmod(pathModule._makeLong(path), modeNum(mode));
+};
+
+if (constants.hasOwnProperty('O_SYMLINK')) {
+ fs.lchown = function(path, uid, gid, callback) {
+ callback = maybeCallback(callback);
+ fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, function(err, fd) {
+ if (err) {
+ callback(err);
+ return;
+ }
+ fs.fchown(fd, uid, gid, callback);
+ });
+ };
+
+ fs.lchownSync = function(path, uid, gid) {
+ var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK);
+ return fs.fchownSync(fd, uid, gid);
+ };
+}
+
+fs.fchown = function(fd, uid, gid, callback) {
+ binding.fchown(fd, uid, gid, makeCallback(callback));
+};
+
+fs.fchownSync = function(fd, uid, gid) {
+ return binding.fchown(fd, uid, gid);
+};
+
+fs.chown = function(path, uid, gid, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.chown(pathModule._makeLong(path), uid, gid, callback);
+};
+
+fs.chownSync = function(path, uid, gid) {
+ nullCheck(path);
+ return binding.chown(pathModule._makeLong(path), uid, gid);
+};
+
+// converts Date or number to a fractional UNIX timestamp
+function toUnixTimestamp(time) {
+ if (typeof time == 'number') {
+ return time;
+ }
+ if (time instanceof Date) {
+ // convert to 123.456 UNIX timestamp
+ return time.getTime() / 1000;
+ }
+ throw new Error('Cannot parse time: ' + time);
+}
+
+// exported for unit tests, not for public consumption
+fs._toUnixTimestamp = toUnixTimestamp;
+
+fs.utimes = function(path, atime, mtime, callback) {
+ callback = makeCallback(callback);
+ if (!nullCheck(path, callback)) return;
+ binding.utimes(pathModule._makeLong(path),
+ toUnixTimestamp(atime),
+ toUnixTimestamp(mtime),
+ callback);
+};
+
+fs.utimesSync = function(path, atime, mtime) {
+ nullCheck(path);
+ atime = toUnixTimestamp(atime);
+ mtime = toUnixTimestamp(mtime);
+ binding.utimes(pathModule._makeLong(path), atime, mtime);
+};
+
+fs.futimes = function(fd, atime, mtime, callback) {
+ atime = toUnixTimestamp(atime);
+ mtime = toUnixTimestamp(mtime);
+ binding.futimes(fd, atime, mtime, makeCallback(callback));
+};
+
+fs.futimesSync = function(fd, atime, mtime) {
+ atime = toUnixTimestamp(atime);
+ mtime = toUnixTimestamp(mtime);
+ binding.futimes(fd, atime, mtime);
+};
+
+function writeAll(fd, buffer, offset, length, position, callback) {
+ callback = maybeCallback(arguments[arguments.length - 1]);
+
+ // write(fd, buffer, offset, length, position, callback)
+ fs.write(fd, buffer, offset, length, position, function(writeErr, written) {
+ if (writeErr) {
+ fs.close(fd, function() {
+ if (callback) callback(writeErr);
+ });
+ } else {
+ if (written === length) {
+ fs.close(fd, callback);
+ } else {
+ offset += written;
+ length -= written;
+ position += written;
+ writeAll(fd, buffer, offset, length, position, callback);
+ }
+ }
+ });
+}
+
+fs.writeFile = function(path, data, encoding_, callback) {
+ var encoding = (typeof(encoding_) == 'string' ? encoding_ : 'utf8');
+ assertEncoding(encoding);
+
+ callback = maybeCallback(arguments[arguments.length - 1]);
+ fs.open(path, 'w', 438 /*=0666*/, function(openErr, fd) {
+ if (openErr) {
+ if (callback) callback(openErr);
+ } else {
+ var buffer = Buffer.isBuffer(data) ? data : new Buffer('' + data,
+ encoding);
+ writeAll(fd, buffer, 0, buffer.length, 0, callback);
+ }
+ });
+};
+
+fs.writeFileSync = function(path, data, encoding) {
+ assertEncoding(encoding);
+
+ var fd = fs.openSync(path, 'w');
+ if (!Buffer.isBuffer(data)) {
+ data = new Buffer('' + data, encoding || 'utf8');
+ }
+ var written = 0;
+ var length = data.length;
+ try {
+ while (written < length) {
+ written += fs.writeSync(fd, data, written, length - written, written);
+ }
+ } finally {
+ fs.closeSync(fd);
+ }
+};
+
+fs.appendFile = function(path, data, encoding_, callback) {
+ var encoding = (typeof(encoding_) == 'string' ? encoding_ : 'utf8');
+ assertEncoding(encoding);
+
+ callback = maybeCallback(arguments[arguments.length - 1]);
+
+ fs.open(path, 'a', 438 /*=0666*/, function(err, fd) {
+ if (err) return callback(err);
+ var buffer = Buffer.isBuffer(data) ? data : new Buffer('' + data, encoding);
+ writeAll(fd, buffer, 0, buffer.length, null, callback);
+ });
+};
+
+fs.appendFileSync = function(path, data, encoding) {
+ assertEncoding(encoding);
+
+ var fd = fs.openSync(path, 'a');
+ if (!Buffer.isBuffer(data)) {
+ data = new Buffer('' + data, encoding || 'utf8');
+ }
+ var written = 0;
+ var position = null;
+ var length = data.length;
+
+ try {
+ while (written < length) {
+ written += fs.writeSync(fd, data, written, length - written, position);
+ position += written; // XXX not safe with multiple concurrent writers?
+ }
+ } finally {
+ fs.closeSync(fd);
+ }
+};
+
+function errnoException(errorno, syscall) {
+ // TODO make this more compatible with ErrnoException from src/node.cc
+ // Once all of Node is using this function the ErrnoException from
+ // src/node.cc should be removed.
+ var e = new Error(syscall + ' ' + errorno);
+ e.errno = e.code = errorno;
+ e.syscall = syscall;
+ return e;
+}
+
+
+function FSWatcher() {
+ EventEmitter.call(this);
+
+ var self = this;
+ var FSEvent = process.binding('fs_event_wrap').FSEvent;
+ this._handle = new FSEvent();
+ this._handle.owner = this;
+
+ this._handle.onchange = function(status, event, filename) {
+ if (status) {
+ self._handle.close();
+ self.emit('error', errnoException(errno, 'watch'));
+ } else {
+ self.emit('change', event, filename);
+ }
+ };
+}
+util.inherits(FSWatcher, EventEmitter);
+
+FSWatcher.prototype.start = function(filename, persistent) {
+ nullCheck(filename);
+ var r = this._handle.start(pathModule._makeLong(filename), persistent);
+
+ if (r) {
+ this._handle.close();
+ throw errnoException(errno, 'watch');
+ }
+};
+
+FSWatcher.prototype.close = function() {
+ this._handle.close();
+};
+
+fs.watch = function(filename) {
+ nullCheck(filename);
+ var watcher;
+ var options;
+ var listener;
+
+ if ('object' == typeof arguments[1]) {
+ options = arguments[1];
+ listener = arguments[2];
+ } else {
+ options = {};
+ listener = arguments[1];
+ }
+
+ if (options.persistent === undefined) options.persistent = true;
+
+ watcher = new FSWatcher();
+ watcher.start(filename, options.persistent);
+
+ if (listener) {
+ watcher.addListener('change', listener);
+ }
+
+ return watcher;
+};
+
+
+// Stat Change Watchers
+
+function StatWatcher() {
+ EventEmitter.call(this);
+
+ var self = this;
+ this._handle = new binding.StatWatcher();
+
+ // uv_fs_poll is a little more powerful than ev_stat but we curb it for
+ // the sake of backwards compatibility
+ var oldStatus = -1;
+
+ this._handle.onchange = function(current, previous, newStatus) {
+ if (oldStatus === -1 &&
+ newStatus === -1 &&
+ current.nlink === previous.nlink) return;
+
+ oldStatus = newStatus;
+ self.emit('change', current, previous);
+ };
+
+ this._handle.onstop = function() {
+ self.emit('stop');
+ };
+}
+util.inherits(StatWatcher, EventEmitter);
+
+
+StatWatcher.prototype.start = function(filename, persistent, interval) {
+ nullCheck(filename);
+ this._handle.start(pathModule._makeLong(filename), persistent, interval);
+};
+
+
+StatWatcher.prototype.stop = function() {
+ this._handle.stop();
+};
+
+
+var statWatchers = {};
+function inStatWatchers(filename) {
+ return Object.prototype.hasOwnProperty.call(statWatchers, filename) &&
+ statWatchers[filename];
+}
+
+
+fs.watchFile = function(filename) {
+ nullCheck(filename);
+ var stat;
+ var listener;
+
+ var options = {
+ // Poll interval in milliseconds. 5007 is what libev used to use. It's
+ // a little on the slow side but let's stick with it for now to keep
+ // behavioral changes to a minimum.
+ interval: 5007,
+ persistent: true
+ };
+
+ if ('object' == typeof arguments[1]) {
+ options = util._extend(options, arguments[1]);
+ listener = arguments[2];
+ } else {
+ listener = arguments[1];
+ }
+
+ if (!listener) {
+ throw new Error('watchFile requires a listener function');
+ }
+
+ if (inStatWatchers(filename)) {
+ stat = statWatchers[filename];
+ } else {
+ stat = statWatchers[filename] = new StatWatcher();
+ stat.start(filename, options.persistent, options.interval);
+ }
+ stat.addListener('change', listener);
+ return stat;
+};
+
+fs.unwatchFile = function(filename, listener) {
+ nullCheck(filename);
+ if (!inStatWatchers(filename)) return;
+
+ var stat = statWatchers[filename];
+
+ if (typeof listener === 'function') {
+ stat.removeListener('change', listener);
+ } else {
+ stat.removeAllListeners('change');
+ }
+
+ if (stat.listeners('change').length === 0) {
+ stat.stop();
+ statWatchers[filename] = undefined;
+ }
+};
+
+// Realpath
+// Not using realpath(2) because it's bad.
+// See: http://insanecoding.blogspot.com/2007/11/pathmax-simply-isnt.html
+
+var normalize = pathModule.normalize;
+
+// Regexp that finds the next partion of a (partial) path
+// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
+if (isWindows) {
+ var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+} else {
+ var nextPartRe = /(.*?)(?:[\/]+|$)/g;
+}
+
+// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
+if (isWindows) {
+ var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+} else {
+ var splitRootRe = /^[\/]*/;
+}
+
+fs.realpathSync = function realpathSync(p, cache) {
+ // make p is absolute
+ p = pathModule.resolve(p);
+
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return cache[p];
+ }
+
+ var original = p,
+ seenLinks = {},
+ knownHard = {};
+
+ // current character position in p
+ var pos;
+ // the partial path so far, including a trailing slash if any
+ var current;
+ // the partial path without a trailing slash (except when pointing at a root)
+ var base;
+ // the partial path scanned in the previous round, with slash
+ var previous;
+
+ start();
+
+ function start() {
+ // Skip over roots
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = '';
+
+ // On windows, check that the root exists. On unix there is no need.
+ if (isWindows && !knownHard[base]) {
+ fs.lstatSync(base);
+ knownHard[base] = true;
+ }
+ }
+
+ // walk down the path, swapping out linked pathparts for their real
+ // values
+ // NB: p.length changes.
+ while (pos < p.length) {
+ // find the next part
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+
+ // continue if not a symlink
+ if (knownHard[base] || (cache && cache[base] === base)) {
+ continue;
+ }
+
+ var resolvedLink;
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ // some known symbolic link. no need to stat again.
+ resolvedLink = cache[base];
+ } else {
+ var stat = fs.lstatSync(base);
+ if (!stat.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache) cache[base] = base;
+ continue;
+ }
+
+ // read the link if it wasn't read before
+ // dev/ino always return 0 on windows, so skip the check.
+ var linkTarget = null;
+ if (!isWindows) {
+ var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ linkTarget = seenLinks[id];
+ }
+ }
+ if (linkTarget === null) {
+ fs.statSync(base);
+ linkTarget = fs.readlinkSync(base);
+ }
+ resolvedLink = pathModule.resolve(previous, linkTarget);
+ // track this, if given a cache.
+ if (cache) cache[base] = resolvedLink;
+ if (!isWindows) seenLinks[id] = linkTarget;
+ }
+
+ // resolve the link, then start over
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+
+ if (cache) cache[original] = p;
+
+ return p;
+};
+
+
+fs.realpath = function realpath(p, cache, cb) {
+ if (typeof cb !== 'function') {
+ cb = maybeCallback(cache);
+ cache = null;
+ }
+
+ // make p is absolute
+ p = pathModule.resolve(p);
+
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return process.nextTick(cb.bind(null, null, cache[p]));
+ }
+
+ var original = p,
+ seenLinks = {},
+ knownHard = {};
+
+ // current character position in p
+ var pos;
+ // the partial path so far, including a trailing slash if any
+ var current;
+ // the partial path without a trailing slash (except when pointing at a root)
+ var base;
+ // the partial path scanned in the previous round, with slash
+ var previous;
+
+ start();
+
+ function start() {
+ // Skip over roots
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = '';
+
+ // On windows, check that the root exists. On unix there is no need.
+ if (isWindows && !knownHard[base]) {
+ fs.lstat(base, function(err) {
+ if (err) return cb(err);
+ knownHard[base] = true;
+ LOOP();
+ });
+ } else {
+ process.nextTick(LOOP);
+ }
+ }
+
+ // walk down the path, swapping out linked pathparts for their real
+ // values
+ function LOOP() {
+ // stop if scanned past end of path
+ if (pos >= p.length) {
+ if (cache) cache[original] = p;
+ return cb(null, p);
+ }
+
+ // find the next part
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+
+ // continue if not a symlink
+ if (knownHard[base] || (cache && cache[base] === base)) {
+ return process.nextTick(LOOP);
+ }
+
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ // known symbolic link. no need to stat again.
+ return gotResolvedLink(cache[base]);
+ }
+
+ return fs.lstat(base, gotStat);
+ }
+
+ function gotStat(err, stat) {
+ if (err) return cb(err);
+
+ // if not a symlink, skip to the next path part
+ if (!stat.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache) cache[base] = base;
+ return process.nextTick(LOOP);
+ }
+
+ // stat & read the link if not read before
+ // call gotTarget as soon as the link target is known
+ // dev/ino always return 0 on windows, so skip the check.
+ if (!isWindows) {
+ var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ return gotTarget(null, seenLinks[id], base);
+ }
+ }
+ fs.stat(base, function(err) {
+ if (err) return cb(err);
+
+ fs.readlink(base, function(err, target) {
+ if (!isWindows) seenLinks[id] = target;
+ gotTarget(err, target);
+ });
+ });
+ }
+
+ function gotTarget(err, target, base) {
+ if (err) return cb(err);
+
+ var resolvedLink = pathModule.resolve(previous, target);
+ if (cache) cache[base] = resolvedLink;
+ gotResolvedLink(resolvedLink);
+ }
+
+ function gotResolvedLink(resolvedLink) {
+ // resolve the link, then start over
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+};
+
+
+
+var pool;
+
+function allocNewPool() {
+ pool = new Buffer(kPoolSize);
+ pool.used = 0;
+}
+
+
+
+fs.createReadStream = function(path, options) {
+ return new ReadStream(path, options);
+};
+
+util.inherits(ReadStream, Readable);
+fs.ReadStream = ReadStream;
+
+function ReadStream(path, options) {
+ if (!(this instanceof ReadStream))
+ return new ReadStream(path, options);
+
+ // a little bit bigger buffer and water marks by default
+ options = util._extend({
+ bufferSize: 64 * 1024,
+ lowWaterMark: 16 * 1024,
+ highWaterMark: 64 * 1024
+ }, options || {});
+
+ Readable.call(this, options);
+
+ this.path = path;
+ this.fd = options.hasOwnProperty('fd') ? options.fd : null;
+ this.flags = options.hasOwnProperty('flags') ? options.flags : 'r';
+ this.mode = options.hasOwnProperty('mode') ? options.mode : 438; /*=0666*/
+
+ this.start = options.hasOwnProperty('start') ? options.start : undefined;
+ this.end = options.hasOwnProperty('start') ? options.end : undefined;
+ this.pos = undefined;
+
+ if (this.start !== undefined) {
+ if ('number' !== typeof this.start) {
+ throw TypeError('start must be a Number');
+ }
+ if (this.end === undefined) {
+ this.end = Infinity;
+ } else if ('number' !== typeof this.end) {
+ throw TypeError('end must be a Number');
+ }
+
+ if (this.start > this.end) {
+ throw new Error('start must be <= end');
+ }
+
+ this.pos = this.start;
+ }
+
+ if (typeof this.fd !== 'number')
+ this.open();
+
+ this.on('end', function() {
+ this.destroy();
+ });
+}
+
+fs.FileReadStream = fs.ReadStream; // support the legacy name
+
+ReadStream.prototype.open = function() {
+ var self = this;
+ fs.open(this.path, this.flags, this.mode, function(er, fd) {
+ if (er) {
+ self.destroy();
+ self.emit('error', er);
+ return;
+ }
+
+ self.fd = fd;
+ self.emit('open', fd);
+ // start the flow of data.
+ self.read();
+ });
+};
+
+ReadStream.prototype._read = function(n, cb) {
+ if (typeof this.fd !== 'number')
+ return this.once('open', function() {
+ this._read(n, cb);
+ });
+
+ if (this.destroyed)
+ return;
+
+ if (!pool || pool.length - pool.used < kMinPoolSpace) {
+ // discard the old pool. Can't add to the free list because
+ // users might have refernces to slices on it.
+ pool = null;
+ allocNewPool();
+ }
+
+ // Grab another reference to the pool in the case that while we're
+ // in the thread pool another read() finishes up the pool, and
+ // allocates a new one.
+ var thisPool = pool;
+ var toRead = Math.min(pool.length - pool.used, n);
+ var start = pool.used;
+
+ if (this.pos !== undefined)
+ toRead = Math.min(this.end - this.pos + 1, toRead);
+
+ // already read everything we were supposed to read!
+ // treat as EOF.
+ if (toRead <= 0)
+ return cb();
+
+ // the actual read.
+ var self = this;
+ fs.read(this.fd, pool, pool.used, toRead, this.pos, onread);
+
+ // move the pool positions, and internal position for reading.
+ if (this.pos !== undefined)
+ this.pos += toRead;
+ pool.used += toRead;
+
+ function onread(er, bytesRead) {
+ if (er) {
+ self.destroy();
+ return cb(er);
+ }
+
+ var b = null;
+ if (bytesRead > 0)
+ b = thisPool.slice(start, start + bytesRead);
+
+ cb(null, b);
+ }
+};
+
+
+ReadStream.prototype.destroy = function() {
+ if (this.destroyed)
+ return;
+ this.destroyed = true;
+ if ('number' === typeof this.fd)
+ this.close();
+};
+
+
+ReadStream.prototype.close = function(cb) {
+ if (cb)
+ this.once('close', cb);
+ if (this.closed || 'number' !== typeof this.fd) {
+ if ('number' !== typeof this.fd)
+ this.once('open', close);
+ return process.nextTick(this.emit.bind(this, 'close'));
+ }
+ this.closed = true;
+ var self = this;
+ close();
+
+ function close() {
+ fs.close(self.fd, function(er) {
+ if (er)
+ self.emit('error', er);
+ else
+ self.emit('close');
+ });
+ }
+};
+
+
+
+
+fs.createWriteStream = function(path, options) {
+ return new WriteStream(path, options);
+};
+
+util.inherits(WriteStream, Writable);
+fs.WriteStream = WriteStream;
+function WriteStream(path, options) {
+ if (!(this instanceof WriteStream))
+ return new WriteStream(path, options);
+
+ // a little bit bigger buffer and water marks by default
+ options = util._extend({
+ bufferSize: 64 * 1024,
+ lowWaterMark: 16 * 1024,
+ highWaterMark: 64 * 1024
+ }, options || {});
+
+ Writable.call(this, options);
+
+ this.path = path;
+ this.fd = null;
+
+ this.fd = options.hasOwnProperty('fd') ? options.fd : null;
+ this.flags = options.hasOwnProperty('flags') ? options.flags : 'w';
+ this.mode = options.hasOwnProperty('mode') ? options.mode : 438; /*=0666*/
+
+ this.start = options.hasOwnProperty('start') ? options.start : undefined;
+ this.pos = undefined;
+ this.bytesWritten = 0;
+
+ if (this.start !== undefined) {
+ if ('number' !== typeof this.start) {
+ throw TypeError('start must be a Number');
+ }
+ if (this.start < 0) {
+ throw new Error('start must be >= zero');
+ }
+
+ this.pos = this.start;
+ }
+
+ if ('number' !== typeof this.fd)
+ this.open();
+
+ // dispose on finish.
+ this.once('finish', this.close);
+}
+
+fs.FileWriteStream = fs.WriteStream; // support the legacy name
+
+
+WriteStream.prototype.open = function() {
+ fs.open(this.path, this.flags, this.mode, function(er, fd) {
+ if (er) {
+ this.destroy();
+ this.emit('error', er);
+ return;
+ }
+
+ this.fd = fd;
+ this.emit('open', fd);
+ }.bind(this));
+};
+
+
+WriteStream.prototype._write = function(data, cb) {
+ if (!Buffer.isBuffer(data))
+ return this.emit('error', new Error('Invalid data'));
+
+ if (typeof this.fd !== 'number')
+ return this.once('open', this._write.bind(this, data, cb));
+
+ fs.write(this.fd, data, 0, data.length, this.pos, function(er, bytes) {
+ if (er) {
+ this.destroy();
+ return cb(er);
+ }
+ this.bytesWritten += bytes;
+ cb();
+ }.bind(this));
+
+ if (this.pos !== undefined)
+ this.pos += data.length;
+};
+
+
+WriteStream.prototype.destroy = ReadStream.prototype.destroy;
+WriteStream.prototype.close = ReadStream.prototype.close;
+
+// There is no shutdown() for files.
+WriteStream.prototype.destroySoon = WriteStream.prototype.end;
+
+
+// SyncWriteStream is internal. DO NOT USE.
+// Temporary hack for process.stdout and process.stderr when piped to files.
+function SyncWriteStream(fd) {
+ Stream.call(this);
+
+ this.fd = fd;
+ this.writable = true;
+ this.readable = false;
+}
+
+util.inherits(SyncWriteStream, Stream);
+
+
+// Export
+fs.SyncWriteStream = SyncWriteStream;
+
+
+SyncWriteStream.prototype.write = function(data, arg1, arg2) {
+ var encoding, cb;
+
+ // parse arguments
+ if (arg1) {
+ if (typeof arg1 === 'string') {
+ encoding = arg1;
+ cb = arg2;
+ } else if (typeof arg1 === 'function') {
+ cb = arg1;
+ } else {
+ throw new Error('bad arg');
+ }
+ }
+ assertEncoding(encoding);
+
+ // Change strings to buffers. SLOW
+ if (typeof data == 'string') {
+ data = new Buffer(data, encoding);
+ }
+
+ fs.writeSync(this.fd, data, 0, data.length);
+
+ if (cb) {
+ process.nextTick(cb);
+ }
+
+ return true;
+};
+
+
+SyncWriteStream.prototype.end = function(data, arg1, arg2) {
+ if (data) {
+ this.write(data, arg1, arg2);
+ }
+ this.destroy();
+};
+
+
+SyncWriteStream.prototype.destroy = function() {
+ fs.closeSync(this.fd);
+ this.fd = null;
+ this.emit('close');
+ return true;
+};
+
+SyncWriteStream.prototype.destroySoon = SyncWriteStream.prototype.destroy;
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_duplex.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_duplex.js
new file mode 100644
index 000000000..a2e0d8e0d
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_duplex.js
@@ -0,0 +1,69 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+var util = require('util');
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+Object.keys(Writable.prototype).forEach(function(method) {
+ if (!Duplex.prototype[method])
+ Duplex.prototype[method] = Writable.prototype[method];
+});
+
+function Duplex(options) {
+ if (!(this instanceof Duplex))
+ return new Duplex(options);
+
+ Readable.call(this, options);
+ Writable.call(this, options);
+
+ if (options && options.readable === false)
+ this.readable = false;
+
+ if (options && options.writable === false)
+ this.writable = false;
+
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false)
+ this.allowHalfOpen = false;
+
+ this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended)
+ return;
+
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ process.nextTick(this.end.bind(this));
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_passthrough.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_passthrough.js
new file mode 100644
index 000000000..330c247d4
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_passthrough.js
@@ -0,0 +1,41 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+var util = require('util');
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough))
+ return new PassThrough(options);
+
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+ cb(null, chunk);
+};
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_readable.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_readable.js
new file mode 100644
index 000000000..3c9da084a
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_readable.js
@@ -0,0 +1,927 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+module.exports = Readable;
+Readable.ReadableState = ReadableState;
+
+var EE = require('events').EventEmitter;
+if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
+ return emitter.listeners(type).length;
+};
+var Stream = require('stream');
+var util = require('util');
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+function ReadableState(options, stream) {
+ options = options || {};
+
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.buffer = [];
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = false;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
+
+ // In streams that never have any data, and do push(null) right away,
+ // the consumer can miss the 'end' event if they do some I/O before
+ // consuming the stream. So, we don't emit('end') until some reading
+ // happens.
+ this.calledRead = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+
+
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // when piping, we only care about 'readable' events that happen
+ // after read()ing all the bytes and not getting any pushback.
+ this.ranOut = false;
+
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
+
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
+
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder').StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ if (!(this instanceof Readable))
+ return new Readable(options);
+
+ this._readableState = new ReadableState(options, this);
+
+ // legacy
+ this.readable = true;
+
+ Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+ var state = this._readableState;
+
+ if (typeof chunk === 'string' && !state.objectMode) {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = new Buffer(chunk, encoding);
+ encoding = '';
+ }
+ }
+
+ return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function(chunk) {
+ var state = this._readableState;
+ return readableAddChunk(this, state, chunk, '', true);
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+ var er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (chunk === null || chunk === undefined) {
+ state.reading = false;
+ if (!state.ended)
+ onEofChunk(stream, state);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (state.ended && !addToFront) {
+ var e = new Error('stream.push() after EOF');
+ stream.emit('error', e);
+ } else if (state.endEmitted && addToFront) {
+ var e = new Error('stream.unshift() after end event');
+ stream.emit('error', e);
+ } else {
+ if (state.decoder && !addToFront && !encoding)
+ chunk = state.decoder.write(chunk);
+
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) {
+ state.buffer.unshift(chunk);
+ } else {
+ state.reading = false;
+ state.buffer.push(chunk);
+ }
+
+ if (state.needReadable)
+ emitReadable(stream);
+
+ maybeReadMore(stream, state);
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+
+ return needMoreData(state);
+}
+
+
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended &&
+ (state.needReadable ||
+ state.length < state.highWaterMark ||
+ state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder').StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+};
+
+// Don't raise the hwm > 128MB
+var MAX_HWM = 0x800000;
+function roundUpToNextPowerOf2(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2
+ n--;
+ for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+ n++;
+ }
+ return n;
+}
+
+function howMuchToRead(n, state) {
+ if (state.length === 0 && state.ended)
+ return 0;
+
+ if (state.objectMode)
+ return n === 0 ? 0 : 1;
+
+ if (isNaN(n) || n === null) {
+ // only flow one buffer at a time
+ if (state.flowing && state.buffer.length)
+ return state.buffer[0].length;
+ else
+ return state.length;
+ }
+
+ if (n <= 0)
+ return 0;
+
+ // If we're asking for more than the target buffer level,
+ // then raise the water mark. Bump up to the next highest
+ // power of 2, to prevent increasing it excessively in tiny
+ // amounts.
+ if (n > state.highWaterMark)
+ state.highWaterMark = roundUpToNextPowerOf2(n);
+
+ // don't have that much. return null, unless we've ended.
+ if (n > state.length) {
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ } else
+ return state.length;
+ }
+
+ return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+ var state = this._readableState;
+ state.calledRead = true;
+ var nOrig = n;
+
+ if (typeof n !== 'number' || n > 0)
+ state.emittedReadable = false;
+
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 &&
+ state.needReadable &&
+ (state.length >= state.highWaterMark || state.ended)) {
+ emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state);
+
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0)
+ endReadable(this);
+ return null;
+ }
+
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length - n <= state.highWaterMark)
+ doRead = true;
+
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading)
+ doRead = false;
+
+ if (doRead) {
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0)
+ state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ }
+
+ // If _read called its callback synchronously, then `reading`
+ // will be false, and we need to re-evaluate how much data we
+ // can return to the user.
+ if (doRead && !state.reading)
+ n = howMuchToRead(nOrig, state);
+
+ var ret;
+ if (n > 0)
+ ret = fromList(n, state);
+ else
+ ret = null;
+
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
+ }
+
+ state.length -= n;
+
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (state.length === 0 && !state.ended)
+ state.needReadable = true;
+
+ // If we happened to read() exactly the remaining amount in the
+ // buffer, and the EOF has been seen at this point, then make sure
+ // that we emit 'end' on the very next tick.
+ if (state.ended && !state.endEmitted && state.length === 0)
+ endReadable(this);
+
+ return ret;
+};
+
+function chunkInvalid(state, chunk) {
+ var er = null;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode &&
+ !er) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
+
+function onEofChunk(stream, state) {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+ state.ended = true;
+
+ // if we've ended and we have some data left, then emit
+ // 'readable' now to make sure it gets picked up.
+ if (state.length > 0)
+ emitReadable(stream);
+ else
+ endReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (state.emittedReadable)
+ return;
+
+ state.emittedReadable = true;
+ if (state.sync)
+ process.nextTick(function() {
+ emitReadable_(stream);
+ });
+ else
+ emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+ stream.emit('readable');
+}
+
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ process.nextTick(function() {
+ maybeReadMore_(stream, state);
+ });
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended &&
+ state.length < state.highWaterMark) {
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;
+ else
+ len = state.length;
+ }
+ state.readingMore = false;
+}
+
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+ this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+ state.pipesCount += 1;
+
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+ dest !== process.stdout &&
+ dest !== process.stderr;
+
+ var endFn = doEnd ? onend : cleanup;
+ if (state.endEmitted)
+ process.nextTick(endFn);
+ else
+ src.once('end', endFn);
+
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable) {
+ if (readable !== src) return;
+ cleanup();
+ }
+
+ function onend() {
+ dest.end();
+ }
+
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+
+ function cleanup() {
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', cleanup);
+
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (!dest._writableState || dest._writableState.needDrain)
+ ondrain();
+ }
+
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ function onerror(er) {
+ unpipe();
+ dest.removeListener('error', onerror);
+ if (EE.listenerCount(dest, 'error') === 0)
+ dest.emit('error', er);
+ }
+ // This is a brutally ugly hack to make sure that our error handler
+ // is attached before any userland ones. NEVER DO THIS.
+ if (!dest._events.error)
+ dest.on('error', onerror);
+ else if (Array.isArray(dest._events.error))
+ dest._events.error.unshift(onerror);
+ else
+ dest._events.error = [onerror, dest._events.error];
+
+
+
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ src.unpipe(dest);
+ }
+
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
+
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ // the handler that waits for readable events after all
+ // the data gets sucked out in flow.
+ // This would be easier to follow with a .once() handler
+ // in flow(), but that is too slow.
+ this.on('readable', pipeOnReadable);
+
+ state.flowing = true;
+ process.nextTick(function() {
+ flow(src);
+ });
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function() {
+ var dest = this;
+ var state = src._readableState;
+ state.awaitDrain--;
+ if (state.awaitDrain === 0)
+ flow(src);
+ };
+}
+
+function flow(src) {
+ var state = src._readableState;
+ var chunk;
+ state.awaitDrain = 0;
+
+ function write(dest, i, list) {
+ var written = dest.write(chunk);
+ if (false === written) {
+ state.awaitDrain++;
+ }
+ }
+
+ while (state.pipesCount && null !== (chunk = src.read())) {
+
+ if (state.pipesCount === 1)
+ write(state.pipes, 0, null);
+ else
+ state.pipes.forEach(write);
+
+ src.emit('data', chunk);
+
+ // if anyone needs a drain, then we have to wait for that.
+ if (state.awaitDrain > 0)
+ return;
+ }
+
+ // if every destination was unpiped, either before entering this
+ // function, or in the while loop, then stop flowing.
+ //
+ // NB: This is a pretty rare edge case.
+ if (state.pipesCount === 0) {
+ state.flowing = false;
+
+ // if there were data event listeners added, then switch to old mode.
+ if (EE.listenerCount(src, 'data') > 0)
+ emitDataEvents(src);
+ return;
+ }
+
+ // at this point, no one needed a drain, so we just ran out of data
+ // on the next readable event, start it over again.
+ state.ranOut = true;
+}
+
+function pipeOnReadable() {
+ if (this._readableState.ranOut) {
+ this._readableState.ranOut = false;
+ flow(this);
+ }
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+ var state = this._readableState;
+
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0)
+ return this;
+
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes)
+ return this;
+
+ if (!dest)
+ dest = state.pipes;
+
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+ if (dest)
+ dest.emit('unpipe', this);
+ return this;
+ }
+
+ // slow case. multiple pipe destinations.
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++)
+ dests[i].emit('unpipe', this);
+ return this;
+ }
+
+ // try to find the right one.
+ var i = state.pipes.indexOf(dest);
+ if (i === -1)
+ return this;
+
+ state.pipes.splice(i, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1)
+ state.pipes = state.pipes[0];
+
+ dest.emit('unpipe', this);
+
+ return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function(ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+
+ if (ev === 'data' && !this._readableState.flowing)
+ emitDataEvents(this);
+
+ if (ev === 'readable' && this.readable) {
+ var state = this._readableState;
+ if (!state.readableListening) {
+ state.readableListening = true;
+ state.emittedReadable = false;
+ state.needReadable = true;
+ if (!state.reading) {
+ this.read(0);
+ } else if (state.length) {
+ emitReadable(this, state);
+ }
+ }
+ }
+
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+ emitDataEvents(this);
+ this.read(0);
+ this.emit('resume');
+};
+
+Readable.prototype.pause = function() {
+ emitDataEvents(this, true);
+ this.emit('pause');
+};
+
+function emitDataEvents(stream, startPaused) {
+ var state = stream._readableState;
+
+ if (state.flowing) {
+ // https://github.com/isaacs/readable-stream/issues/16
+ throw new Error('Cannot switch to old mode now.');
+ }
+
+ var paused = startPaused || false;
+ var readable = false;
+
+ // convert to an old-style stream.
+ stream.readable = true;
+ stream.pipe = Stream.prototype.pipe;
+ stream.on = stream.addListener = Stream.prototype.on;
+
+ stream.on('readable', function() {
+ readable = true;
+
+ var c;
+ while (!paused && (null !== (c = stream.read())))
+ stream.emit('data', c);
+
+ if (c === null) {
+ readable = false;
+ stream._readableState.needReadable = true;
+ }
+ });
+
+ stream.pause = function() {
+ paused = true;
+ this.emit('pause');
+ };
+
+ stream.resume = function() {
+ paused = false;
+ if (readable)
+ process.nextTick(function() {
+ stream.emit('readable');
+ });
+ else
+ this.read(0);
+ this.emit('resume');
+ };
+
+ // now make it start, just in case it hadn't already.
+ stream.emit('readable');
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+ var state = this._readableState;
+ var paused = false;
+
+ var self = this;
+ stream.on('end', function() {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length)
+ self.push(chunk);
+ }
+
+ self.push(null);
+ });
+
+ stream.on('data', function(chunk) {
+ if (state.decoder)
+ chunk = state.decoder.write(chunk);
+ if (!chunk || !state.objectMode && !chunk.length)
+ return;
+
+ var ret = self.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
+
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (typeof stream[i] === 'function' &&
+ typeof this[i] === 'undefined') {
+ this[i] = function(method) { return function() {
+ return stream[method].apply(stream, arguments);
+ }}(i);
+ }
+ }
+
+ // proxy certain important events.
+ var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+ events.forEach(function(ev) {
+ stream.on(ev, self.emit.bind(self, ev));
+ });
+
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ self._read = function(n) {
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return self;
+};
+
+
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+ var list = state.buffer;
+ var length = state.length;
+ var stringMode = !!state.decoder;
+ var objectMode = !!state.objectMode;
+ var ret;
+
+ // nothing in the list, definitely empty.
+ if (list.length === 0)
+ return null;
+
+ if (length === 0)
+ ret = null;
+ else if (objectMode)
+ ret = list.shift();
+ else if (!n || n >= length) {
+ // read it all, truncate the array.
+ if (stringMode)
+ ret = list.join('');
+ else
+ ret = Buffer.concat(list, length);
+ list.length = 0;
+ } else {
+ // read just some of it.
+ if (n < list[0].length) {
+ // just take a part of the first list item.
+ // slice is the same for buffers and strings.
+ var buf = list[0];
+ ret = buf.slice(0, n);
+ list[0] = buf.slice(n);
+ } else if (n === list[0].length) {
+ // first list is a perfect match
+ ret = list.shift();
+ } else {
+ // complex case.
+ // we have enough to cover it, but it spans past the first buffer.
+ if (stringMode)
+ ret = '';
+ else
+ ret = new Buffer(n);
+
+ var c = 0;
+ for (var i = 0, l = list.length; i < l && c < n; i++) {
+ var buf = list[0];
+ var cpy = Math.min(n - c, buf.length);
+
+ if (stringMode)
+ ret += buf.slice(0, cpy);
+ else
+ buf.copy(ret, c, 0, cpy);
+
+ if (cpy < buf.length)
+ list[0] = buf.slice(cpy);
+ else
+ list.shift();
+
+ c += cpy;
+ }
+ }
+ }
+
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0)
+ throw new Error('endReadable called on non-empty stream');
+
+ if (!state.endEmitted && state.calledRead) {
+ state.ended = true;
+ process.nextTick(function() {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+ });
+ }
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_transform.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_transform.js
new file mode 100644
index 000000000..f08b05e52
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_transform.js
@@ -0,0 +1,205 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+var util = require('util');
+util.inherits(Transform, Duplex);
+
+
+function TransformState(options, stream) {
+ this.afterTransform = function(er, data) {
+ return afterTransform(stream, er, data);
+ };
+
+ this.needTransform = false;
+ this.transforming = false;
+ this.writecb = null;
+ this.writechunk = null;
+}
+
+function afterTransform(stream, er, data) {
+ var ts = stream._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb)
+ return stream.emit('error', new Error('no writecb in Transform class'));
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data !== null && data !== undefined)
+ stream.push(data);
+
+ if (cb)
+ cb(er);
+
+ var rs = stream._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ stream._read(rs.highWaterMark);
+ }
+}
+
+
+function Transform(options) {
+ if (!(this instanceof Transform))
+ return new Transform(options);
+
+ Duplex.call(this, options);
+
+ var ts = this._transformState = new TransformState(options, this);
+
+ // when the writable side finishes, then flush out anything remaining.
+ var stream = this;
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ this.once('finish', function() {
+ if ('function' === typeof this._flush)
+ this._flush(function(er) {
+ done(stream, er);
+ });
+ else
+ done(stream);
+ });
+}
+
+Transform.prototype.push = function(chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+ throw new Error('not implemented');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform ||
+ rs.needReadable ||
+ rs.length < rs.highWaterMark)
+ this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+
+function done(stream, er) {
+ if (er)
+ return stream.emit('error', er);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ var ws = stream._writableState;
+ var rs = stream._readableState;
+ var ts = stream._transformState;
+
+ if (ws.length)
+ throw new Error('calling transform done when ws.length != 0');
+
+ if (ts.transforming)
+ throw new Error('calling transform done when still transforming');
+
+ return stream.push(null);
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_writable.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_writable.js
new file mode 100644
index 000000000..56ca47ddf
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/lib/_stream_writable.js
@@ -0,0 +1,367 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, cb), and it'll handle all
+// the drain event emission and buffering.
+
+module.exports = Writable;
+Writable.WritableState = WritableState;
+
+var util = require('util');
+var assert = require('assert');
+var Stream = require('stream');
+
+util.inherits(Writable, Stream);
+
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+}
+
+function WritableState(options, stream) {
+ options = options || {};
+
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
+
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
+
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
+
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function(er) {
+ onwrite(stream, er);
+ };
+
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
+
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
+
+ this.buffer = [];
+}
+
+function Writable(options) {
+ // Writable ctor is applied to Duplexes, though they're not
+ // instanceof Writable, they're instanceof Readable.
+ if (!(this instanceof Writable) && !(this instanceof require('./_stream_duplex')))
+ return new Writable(options);
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+ this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+
+function writeAfterEnd(stream, state, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ process.nextTick(function() {
+ cb(er);
+ });
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode) {
+ var er = new TypeError('Invalid non-string/buffer chunk');
+ stream.emit('error', er);
+ process.nextTick(function() {
+ cb(er);
+ });
+ valid = false;
+ }
+ return valid;
+}
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ else if (!encoding)
+ encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function')
+ cb = function() {};
+
+ if (state.ended)
+ writeAfterEnd(this, state, cb);
+ else if (validChunk(this, state, chunk, cb))
+ ret = writeOrBuffer(this, state, chunk, encoding, cb);
+
+ return ret;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode &&
+ state.decodeStrings !== false &&
+ typeof chunk === 'string') {
+ chunk = new Buffer(chunk, encoding);
+ }
+ return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+ chunk = decodeChunk(state, chunk, encoding);
+ var len = state.objectMode ? 1 : chunk.length;
+
+ state.length += len;
+
+ var ret = state.length < state.highWaterMark;
+ state.needDrain = !ret;
+
+ if (state.writing)
+ state.buffer.push(new WriteReq(chunk, encoding, cb));
+ else
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ return ret;
+}
+
+function doWrite(stream, state, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ if (sync)
+ process.nextTick(function() {
+ cb(er);
+ });
+ else
+ cb(er);
+
+ stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
+
+ if (er)
+ onwriteError(stream, state, sync, er, cb);
+ else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(stream, state);
+
+ if (!finished && !state.bufferProcessing && state.buffer.length)
+ clearBuffer(stream, state);
+
+ if (sync) {
+ process.nextTick(function() {
+ afterWrite(stream, state, finished, cb);
+ });
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished)
+ onwriteDrain(stream, state);
+ cb();
+ if (finished)
+ finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+}
+
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+
+ for (var c = 0; c < state.buffer.length; c++) {
+ var entry = state.buffer[c];
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ c++;
+ break;
+ }
+ }
+
+ state.bufferProcessing = false;
+ if (c < state.buffer.length)
+ state.buffer = state.buffer.slice(c);
+ else
+ state.buffer.length = 0;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+ cb(new Error('not implemented'));
+};
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (typeof chunk !== 'undefined' && chunk !== null)
+ this.write(chunk, encoding);
+
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished)
+ endWritable(this, state, cb);
+};
+
+
+function needFinish(stream, state) {
+ return (state.ending &&
+ state.length === 0 &&
+ !state.finished &&
+ !state.writing);
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(stream, state);
+ if (need) {
+ state.finished = true;
+ stream.emit('finish');
+ }
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished)
+ process.nextTick(cb);
+ else
+ stream.once('finish', cb);
+ }
+ state.ended = true;
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/package.json b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/package.json
new file mode 100644
index 000000000..76f822e52
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/package.json
@@ -0,0 +1,35 @@
+{
+ "name": "readable-stream",
+ "version": "1.0.17",
+ "description": "An exploration of a new kind of readable streams for Node.js",
+ "main": "readable.js",
+ "dependencies": {},
+ "devDependencies": {
+ "tap": "~0.2.6"
+ },
+ "scripts": {
+ "test": "tap test/simple/*.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/isaacs/readable-stream"
+ },
+ "keywords": [
+ "readable",
+ "stream",
+ "pipe"
+ ],
+ "author": {
+ "name": "Isaac Z. Schlueter",
+ "email": "i@izs.me",
+ "url": "http://blog.izs.me/"
+ },
+ "license": "BSD",
+ "readme": "# readable-stream\n\nA new class of streams for Node.js\n\nThis module provides the new Stream base classes introduced in Node\nv0.10, for use in Node v0.8. You can use it to have programs that\nhave to work with node v0.8, while being forward-compatible for v0.10\nand beyond. When you drop support for v0.8, you can remove this\nmodule, and only use the native streams.\n\nThis is almost exactly the same codebase as appears in Node v0.10.\nHowever:\n\n1. The exported object is actually the Readable class. Decorating the\n native `stream` module would be global pollution.\n2. In v0.10, you can safely use `base64` as an argument to\n `setEncoding` in Readable streams. However, in v0.8, the\n StringDecoder class has no `end()` method, which is problematic for\n Base64. So, don't use that, because it'll break and be weird.\n\nOther than that, the API is the same as `require('stream')` in v0.10,\nso the API docs are reproduced below.\n\n----------\n\n Stability: 2 - Unstable\n\nA stream is an abstract interface implemented by various objects in\nNode. For example a request to an HTTP server is a stream, as is\nstdout. Streams are readable, writable, or both. All streams are\ninstances of [EventEmitter][]\n\nYou can load the Stream base classes by doing `require('stream')`.\nThere are base classes provided for Readable streams, Writable\nstreams, Duplex streams, and Transform streams.\n\n## Compatibility\n\nIn earlier versions of Node, the Readable stream interface was\nsimpler, but also less powerful and less useful.\n\n* Rather than waiting for you to call the `read()` method, `'data'`\n events would start emitting immediately. If you needed to do some\n I/O to decide how to handle data, then you had to store the chunks\n in some kind of buffer so that they would not be lost.\n* The `pause()` method was advisory, rather than guaranteed. This\n meant that you still had to be prepared to receive `'data'` events\n even when the stream was in a paused state.\n\nIn Node v0.10, the Readable class described below was added. For\nbackwards compatibility with older Node programs, Readable streams\nswitch into \"old mode\" when a `'data'` event handler is added, or when\nthe `pause()` or `resume()` methods are called. The effect is that,\neven if you are not using the new `read()` method and `'readable'`\nevent, you no longer have to worry about losing `'data'` chunks.\n\nMost programs will continue to function normally. However, this\nintroduces an edge case in the following conditions:\n\n* No `'data'` event handler is added.\n* The `pause()` and `resume()` methods are never called.\n\nFor example, consider the following code:\n\n```javascript\n// WARNING! BROKEN!\nnet.createServer(function(socket) {\n\n // we add an 'end' method, but never consume the data\n socket.on('end', function() {\n // It will never get here.\n socket.end('I got your message (but didnt read it)\\n');\n });\n\n}).listen(1337);\n```\n\nIn versions of node prior to v0.10, the incoming message data would be\nsimply discarded. However, in Node v0.10 and beyond, the socket will\nremain paused forever.\n\nThe workaround in this situation is to call the `resume()` method to\ntrigger \"old mode\" behavior:\n\n```javascript\n// Workaround\nnet.createServer(function(socket) {\n\n socket.on('end', function() {\n socket.end('I got your message (but didnt read it)\\n');\n });\n\n // start the flow of data, discarding it.\n socket.resume();\n\n}).listen(1337);\n```\n\nIn addition to new Readable streams switching into old-mode, pre-v0.10\nstyle streams can be wrapped in a Readable class using the `wrap()`\nmethod.\n\n## Class: stream.Readable\n\n\n\nA `Readable Stream` has the following methods, members, and events.\n\nNote that `stream.Readable` is an abstract class designed to be\nextended with an underlying implementation of the `_read(size)`\nmethod. (See below.)\n\n### new stream.Readable([options])\n\n* `options` {Object}\n * `highWaterMark` {Number} The maximum number of bytes to store in\n the internal buffer before ceasing to read from the underlying\n resource. Default=16kb\n * `encoding` {String} If specified, then buffers will be decoded to\n strings using the specified encoding. Default=null\n * `objectMode` {Boolean} Whether this stream should behave\n as a stream of objects. Meaning that stream.read(n) returns\n a single value instead of a Buffer of size n\n\nIn classes that extend the Readable class, make sure to call the\nconstructor so that the buffering settings can be properly\ninitialized.\n\n### readable.\\_read(size)\n\n* `size` {Number} Number of bytes to read asynchronously\n\nNote: **This function should NOT be called directly.** It should be\nimplemented by child classes, and called by the internal Readable\nclass methods only.\n\nAll Readable stream implementations must provide a `_read` method\nto fetch data from the underlying resource.\n\nThis method is prefixed with an underscore because it is internal to\nthe class that defines it, and should not be called directly by user\nprograms. However, you **are** expected to override this method in\nyour own extension classes.\n\nWhen data is available, put it into the read queue by calling\n`readable.push(chunk)`. If `push` returns false, then you should stop\nreading. When `_read` is called again, you should start pushing more\ndata.\n\nThe `size` argument is advisory. Implementations where a \"read\" is a\nsingle call that returns data can use this to know how much data to\nfetch. Implementations where that is not relevant, such as TCP or\nTLS, may ignore this argument, and simply provide data whenever it\nbecomes available. There is no need, for example to \"wait\" until\n`size` bytes are available before calling `stream.push(chunk)`.\n\n### readable.push(chunk)\n\n* `chunk` {Buffer | null | String} Chunk of data to push into the read queue\n* return {Boolean} Whether or not more pushes should be performed\n\nNote: **This function should be called by Readable implementors, NOT\nby consumers of Readable subclasses.** The `_read()` function will not\nbe called again until at least one `push(chunk)` call is made. If no\ndata is available, then you MAY call `push('')` (an empty string) to\nallow a future `_read` call, without adding any data to the queue.\n\nThe `Readable` class works by putting data into a read queue to be\npulled out later by calling the `read()` method when the `'readable'`\nevent fires.\n\nThe `push()` method will explicitly insert some data into the read\nqueue. If it is called with `null` then it will signal the end of the\ndata.\n\nIn some cases, you may be wrapping a lower-level source which has some\nsort of pause/resume mechanism, and a data callback. In those cases,\nyou could wrap the low-level source object by doing something like\nthis:\n\n```javascript\n// source is an object with readStop() and readStart() methods,\n// and an `ondata` member that gets called when it has data, and\n// an `onend` member that gets called when the data is over.\n\nvar stream = new Readable();\n\nsource.ondata = function(chunk) {\n // if push() returns false, then we need to stop reading from source\n if (!stream.push(chunk))\n source.readStop();\n};\n\nsource.onend = function() {\n stream.push(null);\n};\n\n// _read will be called when the stream wants to pull more data in\n// the advisory size argument is ignored in this case.\nstream._read = function(n) {\n source.readStart();\n};\n```\n\n### readable.unshift(chunk)\n\n* `chunk` {Buffer | null | String} Chunk of data to unshift onto the read queue\n* return {Boolean} Whether or not more pushes should be performed\n\nThis is the corollary of `readable.push(chunk)`. Rather than putting\nthe data at the *end* of the read queue, it puts it at the *front* of\nthe read queue.\n\nThis is useful in certain use-cases where a stream is being consumed\nby a parser, which needs to \"un-consume\" some data that it has\noptimistically pulled out of the source.\n\n```javascript\n// A parser for a simple data protocol.\n// The \"header\" is a JSON object, followed by 2 \\n characters, and\n// then a message body.\n//\n// Note: This can be done more simply as a Transform stream. See below.\n\nfunction SimpleProtocol(source, options) {\n if (!(this instanceof SimpleProtocol))\n return new SimpleProtocol(options);\n\n Readable.call(this, options);\n this._inBody = false;\n this._sawFirstCr = false;\n\n // source is a readable stream, such as a socket or file\n this._source = source;\n\n var self = this;\n source.on('end', function() {\n self.push(null);\n });\n\n // give it a kick whenever the source is readable\n // read(0) will not consume any bytes\n source.on('readable', function() {\n self.read(0);\n });\n\n this._rawHeader = [];\n this.header = null;\n}\n\nSimpleProtocol.prototype = Object.create(\n Readable.prototype, { constructor: { value: SimpleProtocol }});\n\nSimpleProtocol.prototype._read = function(n) {\n if (!this._inBody) {\n var chunk = this._source.read();\n\n // if the source doesn't have data, we don't have data yet.\n if (chunk === null)\n return this.push('');\n\n // check if the chunk has a \\n\\n\n var split = -1;\n for (var i = 0; i < chunk.length; i++) {\n if (chunk[i] === 10) { // '\\n'\n if (this._sawFirstCr) {\n split = i;\n break;\n } else {\n this._sawFirstCr = true;\n }\n } else {\n this._sawFirstCr = false;\n }\n }\n\n if (split === -1) {\n // still waiting for the \\n\\n\n // stash the chunk, and try again.\n this._rawHeader.push(chunk);\n this.push('');\n } else {\n this._inBody = true;\n var h = chunk.slice(0, split);\n this._rawHeader.push(h);\n var header = Buffer.concat(this._rawHeader).toString();\n try {\n this.header = JSON.parse(header);\n } catch (er) {\n this.emit('error', new Error('invalid simple protocol data'));\n return;\n }\n // now, because we got some extra data, unshift the rest\n // back into the read queue so that our consumer will see it.\n var b = chunk.slice(split);\n this.unshift(b);\n\n // and let them know that we are done parsing the header.\n this.emit('header', this.header);\n }\n } else {\n // from there on, just provide the data to our consumer.\n // careful not to push(null), since that would indicate EOF.\n var chunk = this._source.read();\n if (chunk) this.push(chunk);\n }\n};\n\n// Usage:\nvar parser = new SimpleProtocol(source);\n// Now parser is a readable stream that will emit 'header'\n// with the parsed header data.\n```\n\n### readable.wrap(stream)\n\n* `stream` {Stream} An \"old style\" readable stream\n\nIf you are using an older Node library that emits `'data'` events and\nhas a `pause()` method that is advisory only, then you can use the\n`wrap()` method to create a Readable stream that uses the old stream\nas its data source.\n\nFor example:\n\n```javascript\nvar OldReader = require('./old-api-module.js').OldReader;\nvar oreader = new OldReader;\nvar Readable = require('stream').Readable;\nvar myReader = new Readable().wrap(oreader);\n\nmyReader.on('readable', function() {\n myReader.read(); // etc.\n});\n```\n\n### Event: 'readable'\n\nWhen there is data ready to be consumed, this event will fire.\n\nWhen this event emits, call the `read()` method to consume the data.\n\n### Event: 'end'\n\nEmitted when the stream has received an EOF (FIN in TCP terminology).\nIndicates that no more `'data'` events will happen. If the stream is\nalso writable, it may be possible to continue writing.\n\n### Event: 'data'\n\nThe `'data'` event emits either a `Buffer` (by default) or a string if\n`setEncoding()` was used.\n\nNote that adding a `'data'` event listener will switch the Readable\nstream into \"old mode\", where data is emitted as soon as it is\navailable, rather than waiting for you to call `read()` to consume it.\n\n### Event: 'error'\n\nEmitted if there was an error receiving data.\n\n### Event: 'close'\n\nEmitted when the underlying resource (for example, the backing file\ndescriptor) has been closed. Not all streams will emit this.\n\n### readable.setEncoding(encoding)\n\nMakes the `'data'` event emit a string instead of a `Buffer`. `encoding`\ncan be `'utf8'`, `'utf16le'` (`'ucs2'`), `'ascii'`, or `'hex'`.\n\nThe encoding can also be set by specifying an `encoding` field to the\nconstructor.\n\n### readable.read([size])\n\n* `size` {Number | null} Optional number of bytes to read.\n* Return: {Buffer | String | null}\n\nNote: **This function SHOULD be called by Readable stream users.**\n\nCall this method to consume data once the `'readable'` event is\nemitted.\n\nThe `size` argument will set a minimum number of bytes that you are\ninterested in. If not set, then the entire content of the internal\nbuffer is returned.\n\nIf there is no data to consume, or if there are fewer bytes in the\ninternal buffer than the `size` argument, then `null` is returned, and\na future `'readable'` event will be emitted when more is available.\n\nCalling `stream.read(0)` will always return `null`, and will trigger a\nrefresh of the internal buffer, but otherwise be a no-op.\n\n### readable.pipe(destination, [options])\n\n* `destination` {Writable Stream}\n* `options` {Object} Optional\n * `end` {Boolean} Default=true\n\nConnects this readable stream to `destination` WriteStream. Incoming\ndata on this stream gets written to `destination`. Properly manages\nback-pressure so that a slow destination will not be overwhelmed by a\nfast readable stream.\n\nThis function returns the `destination` stream.\n\nFor example, emulating the Unix `cat` command:\n\n process.stdin.pipe(process.stdout);\n\nBy default `end()` is called on the destination when the source stream\nemits `end`, so that `destination` is no longer writable. Pass `{ end:\nfalse }` as `options` to keep the destination stream open.\n\nThis keeps `writer` open so that \"Goodbye\" can be written at the\nend.\n\n reader.pipe(writer, { end: false });\n reader.on(\"end\", function() {\n writer.end(\"Goodbye\\n\");\n });\n\nNote that `process.stderr` and `process.stdout` are never closed until\nthe process exits, regardless of the specified options.\n\n### readable.unpipe([destination])\n\n* `destination` {Writable Stream} Optional\n\nUndo a previously established `pipe()`. If no destination is\nprovided, then all previously established pipes are removed.\n\n### readable.pause()\n\nSwitches the readable stream into \"old mode\", where data is emitted\nusing a `'data'` event rather than being buffered for consumption via\nthe `read()` method.\n\nCeases the flow of data. No `'data'` events are emitted while the\nstream is in a paused state.\n\n### readable.resume()\n\nSwitches the readable stream into \"old mode\", where data is emitted\nusing a `'data'` event rather than being buffered for consumption via\nthe `read()` method.\n\nResumes the incoming `'data'` events after a `pause()`.\n\n\n## Class: stream.Writable\n\n\n\nA `Writable` Stream has the following methods, members, and events.\n\nNote that `stream.Writable` is an abstract class designed to be\nextended with an underlying implementation of the\n`_write(chunk, encoding, cb)` method. (See below.)\n\n### new stream.Writable([options])\n\n* `options` {Object}\n * `highWaterMark` {Number} Buffer level when `write()` starts\n returning false. Default=16kb\n * `decodeStrings` {Boolean} Whether or not to decode strings into\n Buffers before passing them to `_write()`. Default=true\n\nIn classes that extend the Writable class, make sure to call the\nconstructor so that the buffering settings can be properly\ninitialized.\n\n### writable.\\_write(chunk, encoding, callback)\n\n* `chunk` {Buffer | String} The chunk to be written. Will always\n be a buffer unless the `decodeStrings` option was set to `false`.\n* `encoding` {String} If the chunk is a string, then this is the\n encoding type. Ignore chunk is a buffer. Note that chunk will\n **always** be a buffer unless the `decodeStrings` option is\n explicitly set to `false`.\n* `callback` {Function} Call this function (optionally with an error\n argument) when you are done processing the supplied chunk.\n\nAll Writable stream implementations must provide a `_write` method to\nsend data to the underlying resource.\n\nNote: **This function MUST NOT be called directly.** It should be\nimplemented by child classes, and called by the internal Writable\nclass methods only.\n\nCall the callback using the standard `callback(error)` pattern to\nsignal that the write completed successfully or with an error.\n\nIf the `decodeStrings` flag is set in the constructor options, then\n`chunk` may be a string rather than a Buffer, and `encoding` will\nindicate the sort of string that it is. This is to support\nimplementations that have an optimized handling for certain string\ndata encodings. If you do not explicitly set the `decodeStrings`\noption to `false`, then you can safely ignore the `encoding` argument,\nand assume that `chunk` will always be a Buffer.\n\nThis method is prefixed with an underscore because it is internal to\nthe class that defines it, and should not be called directly by user\nprograms. However, you **are** expected to override this method in\nyour own extension classes.\n\n\n### writable.write(chunk, [encoding], [callback])\n\n* `chunk` {Buffer | String} Data to be written\n* `encoding` {String} Optional. If `chunk` is a string, then encoding\n defaults to `'utf8'`\n* `callback` {Function} Optional. Called when this chunk is\n successfully written.\n* Returns {Boolean}\n\nWrites `chunk` to the stream. Returns `true` if the data has been\nflushed to the underlying resource. Returns `false` to indicate that\nthe buffer is full, and the data will be sent out in the future. The\n`'drain'` event will indicate when the buffer is empty again.\n\nThe specifics of when `write()` will return false, is determined by\nthe `highWaterMark` option provided to the constructor.\n\n### writable.end([chunk], [encoding], [callback])\n\n* `chunk` {Buffer | String} Optional final data to be written\n* `encoding` {String} Optional. If `chunk` is a string, then encoding\n defaults to `'utf8'`\n* `callback` {Function} Optional. Called when the final chunk is\n successfully written.\n\nCall this method to signal the end of the data being written to the\nstream.\n\n### Event: 'drain'\n\nEmitted when the stream's write queue empties and it's safe to write\nwithout buffering again. Listen for it when `stream.write()` returns\n`false`.\n\n### Event: 'close'\n\nEmitted when the underlying resource (for example, the backing file\ndescriptor) has been closed. Not all streams will emit this.\n\n### Event: 'finish'\n\nWhen `end()` is called and there are no more chunks to write, this\nevent is emitted.\n\n### Event: 'pipe'\n\n* `source` {Readable Stream}\n\nEmitted when the stream is passed to a readable stream's pipe method.\n\n### Event 'unpipe'\n\n* `source` {Readable Stream}\n\nEmitted when a previously established `pipe()` is removed using the\nsource Readable stream's `unpipe()` method.\n\n## Class: stream.Duplex\n\n\n\nA \"duplex\" stream is one that is both Readable and Writable, such as a\nTCP socket connection.\n\nNote that `stream.Duplex` is an abstract class designed to be\nextended with an underlying implementation of the `_read(size)`\nand `_write(chunk, encoding, callback)` methods as you would with a Readable or\nWritable stream class.\n\nSince JavaScript doesn't have multiple prototypal inheritance, this\nclass prototypally inherits from Readable, and then parasitically from\nWritable. It is thus up to the user to implement both the lowlevel\n`_read(n)` method as well as the lowlevel `_write(chunk, encoding, cb)` method\non extension duplex classes.\n\n### new stream.Duplex(options)\n\n* `options` {Object} Passed to both Writable and Readable\n constructors. Also has the following fields:\n * `allowHalfOpen` {Boolean} Default=true. If set to `false`, then\n the stream will automatically end the readable side when the\n writable side ends and vice versa.\n\nIn classes that extend the Duplex class, make sure to call the\nconstructor so that the buffering settings can be properly\ninitialized.\n\n## Class: stream.Transform\n\nA \"transform\" stream is a duplex stream where the output is causally\nconnected in some way to the input, such as a zlib stream or a crypto\nstream.\n\nThere is no requirement that the output be the same size as the input,\nthe same number of chunks, or arrive at the same time. For example, a\nHash stream will only ever have a single chunk of output which is\nprovided when the input is ended. A zlib stream will either produce\nmuch smaller or much larger than its input.\n\nRather than implement the `_read()` and `_write()` methods, Transform\nclasses must implement the `_transform()` method, and may optionally\nalso implement the `_flush()` method. (See below.)\n\n### new stream.Transform([options])\n\n* `options` {Object} Passed to both Writable and Readable\n constructors.\n\nIn classes that extend the Transform class, make sure to call the\nconstructor so that the buffering settings can be properly\ninitialized.\n\n### transform.\\_transform(chunk, encoding, callback)\n\n* `chunk` {Buffer | String} The chunk to be transformed. Will always\n be a buffer unless the `decodeStrings` option was set to `false`.\n* `encoding` {String} If the chunk is a string, then this is the\n encoding type. (Ignore if `decodeStrings` chunk is a buffer.)\n* `callback` {Function} Call this function (optionally with an error\n argument) when you are done processing the supplied chunk.\n\nNote: **This function MUST NOT be called directly.** It should be\nimplemented by child classes, and called by the internal Transform\nclass methods only.\n\nAll Transform stream implementations must provide a `_transform`\nmethod to accept input and produce output.\n\n`_transform` should do whatever has to be done in this specific\nTransform class, to handle the bytes being written, and pass them off\nto the readable portion of the interface. Do asynchronous I/O,\nprocess things, and so on.\n\nCall `transform.push(outputChunk)` 0 or more times to generate output\nfrom this input chunk, depending on how much data you want to output\nas a result of this chunk.\n\nCall the callback function only when the current chunk is completely\nconsumed. Note that there may or may not be output as a result of any\nparticular input chunk.\n\nThis method is prefixed with an underscore because it is internal to\nthe class that defines it, and should not be called directly by user\nprograms. However, you **are** expected to override this method in\nyour own extension classes.\n\n### transform.\\_flush(callback)\n\n* `callback` {Function} Call this function (optionally with an error\n argument) when you are done flushing any remaining data.\n\nNote: **This function MUST NOT be called directly.** It MAY be implemented\nby child classes, and if so, will be called by the internal Transform\nclass methods only.\n\nIn some cases, your transform operation may need to emit a bit more\ndata at the end of the stream. For example, a `Zlib` compression\nstream will store up some internal state so that it can optimally\ncompress the output. At the end, however, it needs to do the best it\ncan with what is left, so that the data will be complete.\n\nIn those cases, you can implement a `_flush` method, which will be\ncalled at the very end, after all the written data is consumed, but\nbefore emitting `end` to signal the end of the readable side. Just\nlike with `_transform`, call `transform.push(chunk)` zero or more\ntimes, as appropriate, and call `callback` when the flush operation is\ncomplete.\n\nThis method is prefixed with an underscore because it is internal to\nthe class that defines it, and should not be called directly by user\nprograms. However, you **are** expected to override this method in\nyour own extension classes.\n\n### Example: `SimpleProtocol` parser\n\nThe example above of a simple protocol parser can be implemented much\nmore simply by using the higher level `Transform` stream class.\n\nIn this example, rather than providing the input as an argument, it\nwould be piped into the parser, which is a more idiomatic Node stream\napproach.\n\n```javascript\nfunction SimpleProtocol(options) {\n if (!(this instanceof SimpleProtocol))\n return new SimpleProtocol(options);\n\n Transform.call(this, options);\n this._inBody = false;\n this._sawFirstCr = false;\n this._rawHeader = [];\n this.header = null;\n}\n\nSimpleProtocol.prototype = Object.create(\n Transform.prototype, { constructor: { value: SimpleProtocol }});\n\nSimpleProtocol.prototype._transform = function(chunk, encoding, done) {\n if (!this._inBody) {\n // check if the chunk has a \\n\\n\n var split = -1;\n for (var i = 0; i < chunk.length; i++) {\n if (chunk[i] === 10) { // '\\n'\n if (this._sawFirstCr) {\n split = i;\n break;\n } else {\n this._sawFirstCr = true;\n }\n } else {\n this._sawFirstCr = false;\n }\n }\n\n if (split === -1) {\n // still waiting for the \\n\\n\n // stash the chunk, and try again.\n this._rawHeader.push(chunk);\n } else {\n this._inBody = true;\n var h = chunk.slice(0, split);\n this._rawHeader.push(h);\n var header = Buffer.concat(this._rawHeader).toString();\n try {\n this.header = JSON.parse(header);\n } catch (er) {\n this.emit('error', new Error('invalid simple protocol data'));\n return;\n }\n // and let them know that we are done parsing the header.\n this.emit('header', this.header);\n\n // now, because we got some extra data, emit this first.\n this.push(b);\n }\n } else {\n // from there on, just provide the data to our consumer as-is.\n this.push(b);\n }\n done();\n};\n\nvar parser = new SimpleProtocol();\nsource.pipe(parser)\n\n// Now parser is a readable stream that will emit 'header'\n// with the parsed header data.\n```\n\n\n## Class: stream.PassThrough\n\nThis is a trivial implementation of a `Transform` stream that simply\npasses the input bytes across to the output. Its purpose is mainly\nfor examples and testing, but there are occasionally use cases where\nit can come in handy.\n\n\n[EventEmitter]: events.html#events_class_events_eventemitter\n",
+ "readmeFilename": "README.md",
+ "bugs": {
+ "url": "https://github.com/isaacs/readable-stream/issues"
+ },
+ "_id": "readable-stream@1.0.17",
+ "_from": "readable-stream@~1.0.2"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/passthrough.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/passthrough.js
new file mode 100644
index 000000000..27e8d8a55
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/passthrough.js
@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_passthrough.js")
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/readable.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/readable.js
new file mode 100644
index 000000000..4d1ddfc73
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/readable.js
@@ -0,0 +1,6 @@
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/common.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/common.js
new file mode 100644
index 000000000..1dec2e357
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/common.js
@@ -0,0 +1,191 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var path = require('path');
+var assert = require('assert');
+
+exports.testDir = path.dirname(__filename);
+exports.fixturesDir = path.join(exports.testDir, 'fixtures');
+exports.libDir = path.join(exports.testDir, '../lib');
+exports.tmpDir = path.join(exports.testDir, 'tmp');
+exports.PORT = 12346;
+
+if (process.platform === 'win32') {
+ exports.PIPE = '\\\\.\\pipe\\libuv-test';
+} else {
+ exports.PIPE = exports.tmpDir + '/test.sock';
+}
+
+var util = require('util');
+for (var i in util) exports[i] = util[i];
+//for (var i in exports) global[i] = exports[i];
+
+function protoCtrChain(o) {
+ var result = [];
+ for (; o; o = o.__proto__) { result.push(o.constructor); }
+ return result.join();
+}
+
+exports.indirectInstanceOf = function(obj, cls) {
+ if (obj instanceof cls) { return true; }
+ var clsChain = protoCtrChain(cls.prototype);
+ var objChain = protoCtrChain(obj);
+ return objChain.slice(-clsChain.length) === clsChain;
+};
+
+
+exports.ddCommand = function(filename, kilobytes) {
+ if (process.platform === 'win32') {
+ var p = path.resolve(exports.fixturesDir, 'create-file.js');
+ return '"' + process.argv[0] + '" "' + p + '" "' +
+ filename + '" ' + (kilobytes * 1024);
+ } else {
+ return 'dd if=/dev/zero of="' + filename + '" bs=1024 count=' + kilobytes;
+ }
+};
+
+
+exports.spawnPwd = function(options) {
+ var spawn = require('child_process').spawn;
+
+ if (process.platform === 'win32') {
+ return spawn('cmd.exe', ['/c', 'cd'], options);
+ } else {
+ return spawn('pwd', [], options);
+ }
+};
+
+
+// Turn this off if the test should not check for global leaks.
+exports.globalCheck = true;
+
+process.on('exit', function() {
+ if (!exports.globalCheck) return;
+ var knownGlobals = [setTimeout,
+ setInterval,
+ global.setImmediate,
+ clearTimeout,
+ clearInterval,
+ global.clearImmediate,
+ console,
+ Buffer,
+ process,
+ global];
+
+ if (global.errno) {
+ knownGlobals.push(errno);
+ }
+
+ if (global.gc) {
+ knownGlobals.push(gc);
+ }
+
+ if (global.DTRACE_HTTP_SERVER_RESPONSE) {
+ knownGlobals.push(DTRACE_HTTP_SERVER_RESPONSE);
+ knownGlobals.push(DTRACE_HTTP_SERVER_REQUEST);
+ knownGlobals.push(DTRACE_HTTP_CLIENT_RESPONSE);
+ knownGlobals.push(DTRACE_HTTP_CLIENT_REQUEST);
+ knownGlobals.push(DTRACE_NET_STREAM_END);
+ knownGlobals.push(DTRACE_NET_SERVER_CONNECTION);
+ knownGlobals.push(DTRACE_NET_SOCKET_READ);
+ knownGlobals.push(DTRACE_NET_SOCKET_WRITE);
+ }
+ if (global.COUNTER_NET_SERVER_CONNECTION) {
+ knownGlobals.push(COUNTER_NET_SERVER_CONNECTION);
+ knownGlobals.push(COUNTER_NET_SERVER_CONNECTION_CLOSE);
+ knownGlobals.push(COUNTER_HTTP_SERVER_REQUEST);
+ knownGlobals.push(COUNTER_HTTP_SERVER_RESPONSE);
+ knownGlobals.push(COUNTER_HTTP_CLIENT_REQUEST);
+ knownGlobals.push(COUNTER_HTTP_CLIENT_RESPONSE);
+ }
+
+ if (global.ArrayBuffer) {
+ knownGlobals.push(ArrayBuffer);
+ knownGlobals.push(Int8Array);
+ knownGlobals.push(Uint8Array);
+ knownGlobals.push(Uint8ClampedArray);
+ knownGlobals.push(Int16Array);
+ knownGlobals.push(Uint16Array);
+ knownGlobals.push(Int32Array);
+ knownGlobals.push(Uint32Array);
+ knownGlobals.push(Float32Array);
+ knownGlobals.push(Float64Array);
+ knownGlobals.push(DataView);
+ }
+
+ for (var x in global) {
+ var found = false;
+
+ for (var y in knownGlobals) {
+ if (global[x] === knownGlobals[y]) {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found) {
+ console.error('Unknown global: %s', x);
+ assert.ok(false, 'Unknown global found');
+ }
+ }
+});
+
+
+var mustCallChecks = [];
+
+
+function runCallChecks() {
+ var failed = mustCallChecks.filter(function(context) {
+ return context.actual !== context.expected;
+ });
+
+ failed.forEach(function(context) {
+ console.log('Mismatched %s function calls. Expected %d, actual %d.',
+ context.name,
+ context.expected,
+ context.actual);
+ console.log(context.stack.split('\n').slice(2).join('\n'));
+ });
+
+ if (failed.length) process.exit(1);
+}
+
+
+exports.mustCall = function(fn, expected) {
+ if (typeof expected !== 'number') expected = 1;
+
+ var context = {
+ expected: expected,
+ actual: 0,
+ stack: (new Error).stack,
+ name: fn.name || ''
+ };
+
+ // add the exit listener only once to avoid listener leak warnings
+ if (mustCallChecks.length === 0) process.on('exit', runCallChecks);
+
+ mustCallChecks.push(context);
+
+ return function() {
+ context.actual++;
+ return fn.apply(this, arguments);
+ };
+};
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/fixtures/x1024.txt b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/fixtures/x1024.txt
new file mode 100644
index 000000000..c6a9d2f1a
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/fixtures/x1024.txt
@@ -0,0 +1 @@
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-basic.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-basic.js
new file mode 100644
index 000000000..edc3811ed
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-basic.js
@@ -0,0 +1,475 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+
+var common = require('../common.js');
+var R = require('../../lib/_stream_readable');
+var assert = require('assert');
+
+var util = require('util');
+var EE = require('events').EventEmitter;
+
+function TestReader(n) {
+ R.apply(this);
+ this._buffer = new Buffer(n || 100);
+ this._buffer.fill('x');
+ this._pos = 0;
+ this._bufs = 10;
+}
+
+util.inherits(TestReader, R);
+
+TestReader.prototype.read = function(n) {
+ if (n === 0) return null;
+ var max = this._buffer.length - this._pos;
+ n = n || max;
+ n = Math.max(n, 0);
+ var toRead = Math.min(n, max);
+ if (toRead === 0) {
+ // simulate the read buffer filling up with some more bytes some time
+ // in the future.
+ setTimeout(function() {
+ this._pos = 0;
+ this._bufs -= 1;
+ if (this._bufs <= 0) {
+ // read them all!
+ if (!this.ended) {
+ this.emit('end');
+ this.ended = true;
+ }
+ } else {
+ this.emit('readable');
+ }
+ }.bind(this), 10);
+ return null;
+ }
+
+ var ret = this._buffer.slice(this._pos, this._pos + toRead);
+ this._pos += toRead;
+ return ret;
+};
+
+/////
+
+function TestWriter() {
+ EE.apply(this);
+ this.received = [];
+ this.flush = false;
+}
+
+util.inherits(TestWriter, EE);
+
+TestWriter.prototype.write = function(c) {
+ this.received.push(c.toString());
+ this.emit('write', c);
+ return true;
+};
+
+TestWriter.prototype.end = function(c) {
+ if (c) this.write(c);
+ this.emit('end', this.received);
+};
+
+////////
+
+// tiny node-tap lookalike.
+var tests = [];
+var count = 0;
+
+function test(name, fn) {
+ count++;
+ tests.push([name, fn]);
+}
+
+function run() {
+ var next = tests.shift();
+ if (!next)
+ return console.error('ok');
+
+ var name = next[0];
+ var fn = next[1];
+ console.log('# %s', name);
+ fn({
+ same: assert.deepEqual,
+ ok: assert,
+ equal: assert.equal,
+ end: function () {
+ count--;
+ run();
+ }
+ });
+}
+
+// ensure all tests have run
+process.on("exit", function () {
+ assert.equal(count, 0);
+});
+
+process.nextTick(run);
+
+
+test('a most basic test', function(t) {
+ var r = new TestReader(20);
+
+ var reads = [];
+ var expect = [ 'x',
+ 'xx',
+ 'xxx',
+ 'xxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxxxxx',
+ 'xxxxxxxxx',
+ 'xxx',
+ 'xxxxxxxxxxxx',
+ 'xxxxxxxx',
+ 'xxxxxxxxxxxxxxx',
+ 'xxxxx',
+ 'xxxxxxxxxxxxxxxxxx',
+ 'xx',
+ 'xxxxxxxxxxxxxxxxxxxx',
+ 'xxxxxxxxxxxxxxxxxxxx',
+ 'xxxxxxxxxxxxxxxxxxxx',
+ 'xxxxxxxxxxxxxxxxxxxx',
+ 'xxxxxxxxxxxxxxxxxxxx' ];
+
+ r.on('end', function() {
+ t.same(reads, expect);
+ t.end();
+ });
+
+ var readSize = 1;
+ function flow() {
+ var res;
+ while (null !== (res = r.read(readSize++))) {
+ reads.push(res.toString());
+ }
+ r.once('readable', flow);
+ }
+
+ flow();
+});
+
+test('pipe', function(t) {
+ var r = new TestReader(5);
+
+ var expect = [ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx' ]
+
+ var w = new TestWriter;
+ var flush = true;
+
+ w.on('end', function(received) {
+ t.same(received, expect);
+ t.end();
+ });
+
+ r.pipe(w);
+});
+
+
+
+[1,2,3,4,5,6,7,8,9].forEach(function(SPLIT) {
+ test('unpipe', function(t) {
+ var r = new TestReader(5);
+
+ // unpipe after 3 writes, then write to another stream instead.
+ var expect = [ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx' ];
+ expect = [ expect.slice(0, SPLIT), expect.slice(SPLIT) ];
+
+ var w = [ new TestWriter(), new TestWriter() ];
+
+ var writes = SPLIT;
+ w[0].on('write', function() {
+ if (--writes === 0) {
+ r.unpipe();
+ t.equal(r._readableState.pipes, null);
+ w[0].end();
+ r.pipe(w[1]);
+ t.equal(r._readableState.pipes, w[1]);
+ }
+ });
+
+ var ended = 0;
+
+ var ended0 = false;
+ var ended1 = false;
+ w[0].on('end', function(results) {
+ t.equal(ended0, false);
+ ended0 = true;
+ ended++;
+ t.same(results, expect[0]);
+ });
+
+ w[1].on('end', function(results) {
+ t.equal(ended1, false);
+ ended1 = true;
+ ended++;
+ t.equal(ended, 2);
+ t.same(results, expect[1]);
+ t.end();
+ });
+
+ r.pipe(w[0]);
+ });
+});
+
+
+// both writers should get the same exact data.
+test('multipipe', function(t) {
+ var r = new TestReader(5);
+ var w = [ new TestWriter, new TestWriter ];
+
+ var expect = [ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx' ];
+
+ var c = 2;
+ w[0].on('end', function(received) {
+ t.same(received, expect, 'first');
+ if (--c === 0) t.end();
+ });
+ w[1].on('end', function(received) {
+ t.same(received, expect, 'second');
+ if (--c === 0) t.end();
+ });
+
+ r.pipe(w[0]);
+ r.pipe(w[1]);
+});
+
+
+[1,2,3,4,5,6,7,8,9].forEach(function(SPLIT) {
+ test('multi-unpipe', function(t) {
+ var r = new TestReader(5);
+
+ // unpipe after 3 writes, then write to another stream instead.
+ var expect = [ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx',
+ 'xxxxx' ];
+ expect = [ expect.slice(0, SPLIT), expect.slice(SPLIT) ];
+
+ var w = [ new TestWriter(), new TestWriter(), new TestWriter() ];
+
+ var writes = SPLIT;
+ w[0].on('write', function() {
+ if (--writes === 0) {
+ r.unpipe();
+ w[0].end();
+ r.pipe(w[1]);
+ }
+ });
+
+ var ended = 0;
+
+ w[0].on('end', function(results) {
+ ended++;
+ t.same(results, expect[0]);
+ });
+
+ w[1].on('end', function(results) {
+ ended++;
+ t.equal(ended, 2);
+ t.same(results, expect[1]);
+ t.end();
+ });
+
+ r.pipe(w[0]);
+ r.pipe(w[2]);
+ });
+});
+
+test('back pressure respected', function (t) {
+ function noop() {}
+
+ var r = new R({ objectMode: true });
+ r._read = noop;
+ var counter = 0;
+ r.push(["one"]);
+ r.push(["two"]);
+ r.push(["three"]);
+ r.push(["four"]);
+ r.push(null);
+
+ var w1 = new R();
+ w1.write = function (chunk) {
+ assert.equal(chunk[0], "one");
+ w1.emit("close");
+ process.nextTick(function () {
+ r.pipe(w2);
+ r.pipe(w3);
+ })
+ };
+ w1.end = noop;
+
+ r.pipe(w1);
+
+ var expected = ["two", "two", "three", "three", "four", "four"];
+
+ var w2 = new R();
+ w2.write = function (chunk) {
+ assert.equal(chunk[0], expected.shift());
+ assert.equal(counter, 0);
+
+ counter++;
+
+ if (chunk[0] === "four") {
+ return true;
+ }
+
+ setTimeout(function () {
+ counter--;
+ w2.emit("drain");
+ }, 10);
+
+ return false;
+ }
+ w2.end = noop;
+
+ var w3 = new R();
+ w3.write = function (chunk) {
+ assert.equal(chunk[0], expected.shift());
+ assert.equal(counter, 1);
+
+ counter++;
+
+ if (chunk[0] === "four") {
+ return true;
+ }
+
+ setTimeout(function () {
+ counter--;
+ w3.emit("drain");
+ }, 50);
+
+ return false;
+ };
+ w3.end = function () {
+ assert.equal(counter, 2);
+ assert.equal(expected.length, 0);
+ t.end();
+ };
+});
+
+test('read(0) for ended streams', function (t) {
+ var r = new R();
+ var written = false;
+ var ended = false;
+ r._read = function (n) {};
+
+ r.push(new Buffer("foo"));
+ r.push(null);
+
+ var v = r.read(0);
+
+ assert.equal(v, null);
+
+ var w = new R();
+
+ w.write = function (buffer) {
+ written = true;
+ assert.equal(ended, false);
+ assert.equal(buffer.toString(), "foo")
+ };
+
+ w.end = function () {
+ ended = true;
+ assert.equal(written, true);
+ t.end();
+ };
+
+ r.pipe(w);
+})
+
+test('sync _read ending', function (t) {
+ var r = new R();
+ var called = false;
+ r._read = function (n) {
+ r.push(null);
+ };
+
+ r.once('end', function () {
+ called = true;
+ })
+
+ r.read();
+
+ process.nextTick(function () {
+ assert.equal(called, true);
+ t.end();
+ })
+});
+
+test('adding readable triggers data flow', function(t) {
+ var r = new R({ highWaterMark: 5 });
+ var onReadable = false;
+ var readCalled = 0;
+
+ r._read = function(n) {
+ if (readCalled++ === 2)
+ r.push(null);
+ else
+ r.push(new Buffer('asdf'));
+ };
+
+ var called = false;
+ r.on('readable', function() {
+ onReadable = true;
+ r.read();
+ });
+
+ r.on('end', function() {
+ t.equal(readCalled, 3);
+ t.ok(onReadable);
+ t.end();
+ });
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-compatibility.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-compatibility.js
new file mode 100644
index 000000000..4de76b577
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-compatibility.js
@@ -0,0 +1,50 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+
+var common = require('../common.js');
+var R = require('../../lib/_stream_readable');
+var assert = require('assert');
+
+var util = require('util');
+var EE = require('events').EventEmitter;
+
+var ondataCalled = 0;
+
+function TestReader() {
+ R.apply(this);
+ this._buffer = new Buffer(100);
+ this._buffer.fill('x');
+
+ this.on('data', function() {
+ ondataCalled++;
+ });
+}
+
+util.inherits(TestReader, R);
+
+TestReader.prototype._read = function(n) {
+ this.push(this._buffer);
+ this._buffer = new Buffer(0);
+};
+
+var reader = new TestReader();
+assert.equal(ondataCalled, 1);
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-finish-pipe.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-finish-pipe.js
new file mode 100644
index 000000000..6a7e41e5b
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-finish-pipe.js
@@ -0,0 +1,41 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var common = require('../common.js');
+var stream = require('../../readable');
+var Buffer = require('buffer').Buffer;
+
+var r = new stream.Readable();
+r._read = function(size) {
+ r.push(new Buffer(size));
+};
+
+var w = new stream.Writable();
+w._write = function(data, encoding, cb) {
+ cb(null);
+};
+
+r.pipe(w);
+
+// This might sound unrealistic, but it happens in net.js. When
+// `socket.allowHalfOpen === false`, EOF will cause `.destroySoon()` call which
+// ends the writable side of net.Socket.
+w.end();
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-large-read-stall.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-large-read-stall.js
new file mode 100644
index 000000000..6da70e888
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-large-read-stall.js
@@ -0,0 +1,82 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var common = require('../common.js');
+var assert = require('assert');
+
+// If everything aligns so that you do a read(n) of exactly the
+// remaining buffer, then make sure that 'end' still emits.
+
+var READSIZE = 100;
+var PUSHSIZE = 20;
+var PUSHCOUNT = 1000;
+var HWM = 50;
+
+var Readable = require('../../readable').Readable;
+var r = new Readable({
+ highWaterMark: HWM
+});
+var rs = r._readableState;
+
+r._read = push;
+
+r.on('readable', function() {
+ console.error('>> readable');
+ do {
+ console.error(' > read(%d)', READSIZE);
+ var ret = r.read(READSIZE);
+ console.error(' < %j (%d remain)', ret && ret.length, rs.length);
+ } while (ret && ret.length === READSIZE);
+
+ console.error('<< after read()',
+ ret && ret.length,
+ rs.needReadable,
+ rs.length);
+});
+
+var endEmitted = false;
+r.on('end', function() {
+ endEmitted = true;
+ console.error('end');
+});
+
+var pushes = 0;
+function push() {
+ if (pushes > PUSHCOUNT)
+ return;
+
+ if (pushes++ === PUSHCOUNT) {
+ console.error(' push(EOF)');
+ return r.push(null);
+ }
+
+ console.error(' push #%d', pushes);
+ if (r.push(new Buffer(PUSHSIZE)))
+ setTimeout(push);
+}
+
+// start the flow
+var ret = r.read(0);
+
+process.on('exit', function() {
+ assert.equal(pushes, PUSHCOUNT + 1);
+ assert(endEmitted);
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-objects.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-objects.js
new file mode 100644
index 000000000..cd23539f3
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-objects.js
@@ -0,0 +1,348 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+
+var common = require('../common.js');
+var Readable = require('../../lib/_stream_readable');
+var Writable = require('../../lib/_stream_writable');
+var assert = require('assert');
+
+// tiny node-tap lookalike.
+var tests = [];
+var count = 0;
+
+function test(name, fn) {
+ count++;
+ tests.push([name, fn]);
+}
+
+function run() {
+ var next = tests.shift();
+ if (!next)
+ return console.error('ok');
+
+ var name = next[0];
+ var fn = next[1];
+ console.log('# %s', name);
+ fn({
+ same: assert.deepEqual,
+ equal: assert.equal,
+ end: function() {
+ count--;
+ run();
+ }
+ });
+}
+
+// ensure all tests have run
+process.on('exit', function() {
+ assert.equal(count, 0);
+});
+
+process.nextTick(run);
+
+function toArray(callback) {
+ var stream = new Writable({ objectMode: true });
+ var list = [];
+ stream.write = function(chunk) {
+ list.push(chunk);
+ };
+
+ stream.end = function() {
+ callback(list);
+ };
+
+ return stream;
+}
+
+function fromArray(list) {
+ var r = new Readable({ objectMode: true });
+ r._read = noop;
+ list.forEach(function(chunk) {
+ r.push(chunk);
+ });
+ r.push(null);
+
+ return r;
+}
+
+function noop() {}
+
+test('can read objects from stream', function(t) {
+ var r = fromArray([{ one: '1'}, { two: '2' }]);
+
+ var v1 = r.read();
+ var v2 = r.read();
+ var v3 = r.read();
+
+ assert.deepEqual(v1, { one: '1' });
+ assert.deepEqual(v2, { two: '2' });
+ assert.deepEqual(v3, null);
+
+ t.end();
+});
+
+test('can pipe objects into stream', function(t) {
+ var r = fromArray([{ one: '1'}, { two: '2' }]);
+
+ r.pipe(toArray(function(list) {
+ assert.deepEqual(list, [
+ { one: '1' },
+ { two: '2' }
+ ]);
+
+ t.end();
+ }));
+});
+
+test('read(n) is ignored', function(t) {
+ var r = fromArray([{ one: '1'}, { two: '2' }]);
+
+ var value = r.read(2);
+
+ assert.deepEqual(value, { one: '1' });
+
+ t.end();
+});
+
+test('can read objects from _read (sync)', function(t) {
+ var r = new Readable({ objectMode: true });
+ var list = [{ one: '1'}, { two: '2' }];
+ r._read = function(n) {
+ var item = list.shift();
+ r.push(item || null);
+ };
+
+ r.pipe(toArray(function(list) {
+ assert.deepEqual(list, [
+ { one: '1' },
+ { two: '2' }
+ ]);
+
+ t.end();
+ }));
+});
+
+test('can read objects from _read (async)', function(t) {
+ var r = new Readable({ objectMode: true });
+ var list = [{ one: '1'}, { two: '2' }];
+ r._read = function(n) {
+ var item = list.shift();
+ process.nextTick(function() {
+ r.push(item || null);
+ });
+ };
+
+ r.pipe(toArray(function(list) {
+ assert.deepEqual(list, [
+ { one: '1' },
+ { two: '2' }
+ ]);
+
+ t.end();
+ }));
+});
+
+test('can read strings as objects', function(t) {
+ var r = new Readable({
+ objectMode: true
+ });
+ r._read = noop;
+ var list = ['one', 'two', 'three'];
+ list.forEach(function(str) {
+ r.push(str);
+ });
+ r.push(null);
+
+ r.pipe(toArray(function(array) {
+ assert.deepEqual(array, list);
+
+ t.end();
+ }));
+});
+
+test('read(0) for object streams', function(t) {
+ var r = new Readable({
+ objectMode: true
+ });
+ r._read = noop;
+
+ r.push('foobar');
+ r.push(null);
+
+ var v = r.read(0);
+
+ r.pipe(toArray(function(array) {
+ assert.deepEqual(array, ['foobar']);
+
+ t.end();
+ }));
+});
+
+test('falsey values', function(t) {
+ var r = new Readable({
+ objectMode: true
+ });
+ r._read = noop;
+
+ r.push(false);
+ r.push(0);
+ r.push('');
+ r.push(null);
+
+ r.pipe(toArray(function(array) {
+ assert.deepEqual(array, [false, 0, '']);
+
+ t.end();
+ }));
+});
+
+test('high watermark _read', function(t) {
+ var r = new Readable({
+ highWaterMark: 6,
+ objectMode: true
+ });
+ var calls = 0;
+ var list = ['1', '2', '3', '4', '5', '6', '7', '8'];
+
+ r._read = function(n) {
+ calls++;
+ };
+
+ list.forEach(function(c) {
+ r.push(c);
+ });
+
+ var v = r.read();
+
+ assert.equal(calls, 0);
+ assert.equal(v, '1');
+
+ var v2 = r.read();
+
+ assert.equal(calls, 1);
+ assert.equal(v2, '2');
+
+ t.end();
+});
+
+test('high watermark push', function(t) {
+ var r = new Readable({
+ highWaterMark: 6,
+ objectMode: true
+ });
+ r._read = function(n) {};
+ for (var i = 0; i < 6; i++) {
+ var bool = r.push(i);
+ assert.equal(bool, i === 5 ? false : true);
+ }
+
+ t.end();
+});
+
+test('can write objects to stream', function(t) {
+ var w = new Writable({ objectMode: true });
+
+ w._write = function(chunk, encoding, cb) {
+ assert.deepEqual(chunk, { foo: 'bar' });
+ cb();
+ };
+
+ w.on('finish', function() {
+ t.end();
+ });
+
+ w.write({ foo: 'bar' });
+ w.end();
+});
+
+test('can write multiple objects to stream', function(t) {
+ var w = new Writable({ objectMode: true });
+ var list = [];
+
+ w._write = function(chunk, encoding, cb) {
+ list.push(chunk);
+ cb();
+ };
+
+ w.on('finish', function() {
+ assert.deepEqual(list, [0, 1, 2, 3, 4]);
+
+ t.end();
+ });
+
+ w.write(0);
+ w.write(1);
+ w.write(2);
+ w.write(3);
+ w.write(4);
+ w.end();
+});
+
+test('can write strings as objects', function(t) {
+ var w = new Writable({
+ objectMode: true
+ });
+ var list = [];
+
+ w._write = function(chunk, encoding, cb) {
+ list.push(chunk);
+ process.nextTick(cb);
+ };
+
+ w.on('finish', function() {
+ assert.deepEqual(list, ['0', '1', '2', '3', '4']);
+
+ t.end();
+ });
+
+ w.write('0');
+ w.write('1');
+ w.write('2');
+ w.write('3');
+ w.write('4');
+ w.end();
+});
+
+test('buffers finish until cb is called', function(t) {
+ var w = new Writable({
+ objectMode: true
+ });
+ var called = false;
+
+ w._write = function(chunk, encoding, cb) {
+ assert.equal(chunk, 'foo');
+
+ process.nextTick(function() {
+ called = true;
+ cb();
+ });
+ };
+
+ w.on('finish', function() {
+ assert.equal(called, true);
+
+ t.end();
+ });
+
+ w.write('foo');
+ w.end();
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-pipe-error-handling.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-pipe-error-handling.js
new file mode 100644
index 000000000..823dae2c0
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-pipe-error-handling.js
@@ -0,0 +1,105 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var common = require('../common');
+var assert = require('assert');
+var stream = require('../../readable');
+
+(function testErrorListenerCatches() {
+ var count = 1000;
+
+ var source = new stream.Readable();
+ source._read = function(n) {
+ n = Math.min(count, n);
+ count -= n;
+ source.push(new Buffer(n));
+ };
+
+ var unpipedDest;
+ source.unpipe = function(dest) {
+ unpipedDest = dest;
+ stream.Readable.prototype.unpipe.call(this, dest);
+ };
+
+ var dest = new stream.Writable();
+ dest._write = function(chunk, encoding, cb) {
+ cb();
+ };
+
+ source.pipe(dest);
+
+ var gotErr = null;
+ dest.on('error', function(err) {
+ gotErr = err;
+ });
+
+ var unpipedSource;
+ dest.on('unpipe', function(src) {
+ unpipedSource = src;
+ });
+
+ var err = new Error('This stream turned into bacon.');
+ dest.emit('error', err);
+ assert.strictEqual(gotErr, err);
+ assert.strictEqual(unpipedSource, source);
+ assert.strictEqual(unpipedDest, dest);
+})();
+
+(function testErrorWithoutListenerThrows() {
+ var count = 1000;
+
+ var source = new stream.Readable();
+ source._read = function(n) {
+ n = Math.min(count, n);
+ count -= n;
+ source.push(new Buffer(n));
+ };
+
+ var unpipedDest;
+ source.unpipe = function(dest) {
+ unpipedDest = dest;
+ stream.Readable.prototype.unpipe.call(this, dest);
+ };
+
+ var dest = new stream.Writable();
+ dest._write = function(chunk, encoding, cb) {
+ cb();
+ };
+
+ source.pipe(dest);
+
+ var unpipedSource;
+ dest.on('unpipe', function(src) {
+ unpipedSource = src;
+ });
+
+ var err = new Error('This stream turned into bacon.');
+
+ var gotErr = null;
+ try {
+ dest.emit('error', err);
+ } catch (e) {
+ gotErr = e;
+ }
+ assert.strictEqual(gotErr, err);
+ assert.strictEqual(unpipedSource, source);
+ assert.strictEqual(unpipedDest, dest);
+})();
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-push.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-push.js
new file mode 100644
index 000000000..e85f785d9
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-push.js
@@ -0,0 +1,138 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var common = require('../common.js');
+var stream = require('../../readable');
+var Readable = stream.Readable;
+var Writable = stream.Writable;
+var assert = require('assert');
+
+var util = require('util');
+var EE = require('events').EventEmitter;
+
+
+// a mock thing a bit like the net.Socket/tcp_wrap.handle interaction
+
+var stream = new Readable({
+ highWaterMark: 16,
+ encoding: 'utf8'
+});
+
+var source = new EE;
+
+stream._read = function() {
+ console.error('stream._read');
+ readStart();
+};
+
+var ended = false;
+stream.on('end', function() {
+ ended = true;
+});
+
+source.on('data', function(chunk) {
+ var ret = stream.push(chunk);
+ console.error('data', stream._readableState.length);
+ if (!ret)
+ readStop();
+});
+
+source.on('end', function() {
+ stream.push(null);
+});
+
+var reading = false;
+
+function readStart() {
+ console.error('readStart');
+ reading = true;
+}
+
+function readStop() {
+ console.error('readStop');
+ reading = false;
+ process.nextTick(function() {
+ var r = stream.read();
+ if (r !== null)
+ writer.write(r);
+ });
+}
+
+var writer = new Writable({
+ decodeStrings: false
+});
+
+var written = [];
+
+var expectWritten =
+ [ 'asdfgasdfgasdfgasdfg',
+ 'asdfgasdfgasdfgasdfg',
+ 'asdfgasdfgasdfgasdfg',
+ 'asdfgasdfgasdfgasdfg',
+ 'asdfgasdfgasdfgasdfg',
+ 'asdfgasdfgasdfgasdfg' ];
+
+writer._write = function(chunk, encoding, cb) {
+ console.error('WRITE %s', chunk);
+ written.push(chunk);
+ process.nextTick(cb);
+};
+
+writer.on('finish', finish);
+
+
+// now emit some chunks.
+
+var chunk = "asdfg";
+
+var set = 0;
+readStart();
+data();
+function data() {
+ assert(reading);
+ source.emit('data', chunk);
+ assert(reading);
+ source.emit('data', chunk);
+ assert(reading);
+ source.emit('data', chunk);
+ assert(reading);
+ source.emit('data', chunk);
+ assert(!reading);
+ if (set++ < 5)
+ setTimeout(data, 10);
+ else
+ end();
+}
+
+function finish() {
+ console.error('finish');
+ assert.deepEqual(written, expectWritten);
+ console.log('ok');
+}
+
+function end() {
+ source.emit('end');
+ assert(!reading);
+ writer.end(stream.read());
+ setTimeout(function() {
+ assert(ended);
+ });
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-read-sync-stack.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-read-sync-stack.js
new file mode 100644
index 000000000..7e86eec53
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-read-sync-stack.js
@@ -0,0 +1,54 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var common = require('../common');
+var assert = require('assert');
+var Readable = require('../../readable').Readable;
+var r = new Readable();
+var N = 256 * 1024;
+
+// Go ahead and allow the pathological case for this test.
+// Yes, it's an infinite loop, that's the point.
+process.maxTickDepth = N + 2;
+
+var reads = 0;
+r._read = function(n) {
+ var chunk = reads++ === N ? null : new Buffer(1);
+ r.push(chunk);
+};
+
+r.on('readable', function onReadable() {
+ if (!(r._readableState.length % 256))
+ console.error('readable', r._readableState.length);
+ r.read(N * 2);
+});
+
+var ended = false;
+r.on('end', function onEnd() {
+ ended = true;
+});
+
+r.read(0);
+
+process.on('exit', function() {
+ assert(ended);
+ console.log('ok');
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-empty-buffer-no-eof.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-empty-buffer-no-eof.js
new file mode 100644
index 000000000..1b067f53b
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-empty-buffer-no-eof.js
@@ -0,0 +1,119 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var common = require('../common');
+var assert = require('assert');
+
+var Readable = require('../../readable').Readable;
+
+test1();
+if (!/^v0\.[0-8]\./.test(process.version))
+ test2();
+
+function test1() {
+ var r = new Readable();
+
+ // should not end when we get a Buffer(0) or '' as the _read result
+ // that just means that there is *temporarily* no data, but to go
+ // ahead and try again later.
+ //
+ // note that this is very unusual. it only works for crypto streams
+ // because the other side of the stream will call read(0) to cycle
+ // data through openssl. that's why we set the timeouts to call
+ // r.read(0) again later, otherwise there is no more work being done
+ // and the process just exits.
+
+ var buf = new Buffer(5);
+ buf.fill('x');
+ var reads = 5;
+ r._read = function(n) {
+ switch (reads--) {
+ case 0:
+ return r.push(null); // EOF
+ case 1:
+ return r.push(buf);
+ case 2:
+ setTimeout(r.read.bind(r, 0), 10);
+ return r.push(new Buffer(0)); // Not-EOF!
+ case 3:
+ setTimeout(r.read.bind(r, 0), 10);
+ return process.nextTick(function() {
+ return r.push(new Buffer(0));
+ });
+ case 4:
+ setTimeout(r.read.bind(r, 0), 10);
+ return setTimeout(function() {
+ return r.push(new Buffer(0));
+ });
+ case 5:
+ return setTimeout(function() {
+ return r.push(buf);
+ });
+ default:
+ throw new Error('unreachable');
+ }
+ };
+
+ var results = [];
+ function flow() {
+ var chunk;
+ while (null !== (chunk = r.read()))
+ results.push(chunk + '');
+ }
+ r.on('readable', flow);
+ r.on('end', function() {
+ results.push('EOF');
+ });
+ flow();
+
+ process.on('exit', function() {
+ assert.deepEqual(results, [ 'xxxxx', 'xxxxx', 'EOF' ]);
+ console.log('ok');
+ });
+}
+
+function test2() {
+ var r = new Readable({ encoding: 'base64' });
+ var reads = 5;
+ r._read = function(n) {
+ if (!reads--)
+ return r.push(null); // EOF
+ else
+ return r.push(new Buffer('x'));
+ };
+
+ var results = [];
+ function flow() {
+ var chunk;
+ while (null !== (chunk = r.read()))
+ results.push(chunk + '');
+ }
+ r.on('readable', flow);
+ r.on('end', function() {
+ results.push('EOF');
+ });
+ flow();
+
+ process.on('exit', function() {
+ assert.deepEqual(results, [ 'eHh4', 'eHg=', 'EOF' ]);
+ console.log('ok');
+ });
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-from-list.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-from-list.js
new file mode 100644
index 000000000..04a96f537
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-from-list.js
@@ -0,0 +1,120 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var assert = require('assert');
+var common = require('../common.js');
+var fromList = require('../../lib/_stream_readable')._fromList;
+
+// tiny node-tap lookalike.
+var tests = [];
+var count = 0;
+
+function test(name, fn) {
+ count++;
+ tests.push([name, fn]);
+}
+
+function run() {
+ var next = tests.shift();
+ if (!next)
+ return console.error('ok');
+
+ var name = next[0];
+ var fn = next[1];
+ console.log('# %s', name);
+ fn({
+ same: assert.deepEqual,
+ equal: assert.equal,
+ end: function () {
+ count--;
+ run();
+ }
+ });
+}
+
+// ensure all tests have run
+process.on("exit", function () {
+ assert.equal(count, 0);
+});
+
+process.nextTick(run);
+
+
+
+test('buffers', function(t) {
+ // have a length
+ var len = 16;
+ var list = [ new Buffer('foog'),
+ new Buffer('bark'),
+ new Buffer('bazy'),
+ new Buffer('kuel') ];
+
+ // read more than the first element.
+ var ret = fromList(6, { buffer: list, length: 16 });
+ t.equal(ret.toString(), 'foogba');
+
+ // read exactly the first element.
+ ret = fromList(2, { buffer: list, length: 10 });
+ t.equal(ret.toString(), 'rk');
+
+ // read less than the first element.
+ ret = fromList(2, { buffer: list, length: 8 });
+ t.equal(ret.toString(), 'ba');
+
+ // read more than we have.
+ ret = fromList(100, { buffer: list, length: 6 });
+ t.equal(ret.toString(), 'zykuel');
+
+ // all consumed.
+ t.same(list, []);
+
+ t.end();
+});
+
+test('strings', function(t) {
+ // have a length
+ var len = 16;
+ var list = [ 'foog',
+ 'bark',
+ 'bazy',
+ 'kuel' ];
+
+ // read more than the first element.
+ var ret = fromList(6, { buffer: list, length: 16, decoder: true });
+ t.equal(ret, 'foogba');
+
+ // read exactly the first element.
+ ret = fromList(2, { buffer: list, length: 10, decoder: true });
+ t.equal(ret, 'rk');
+
+ // read less than the first element.
+ ret = fromList(2, { buffer: list, length: 8, decoder: true });
+ t.equal(ret, 'ba');
+
+ // read more than we have.
+ ret = fromList(100, { buffer: list, length: 6, decoder: true });
+ t.equal(ret, 'zykuel');
+
+ // all consumed.
+ t.same(list, []);
+
+ t.end();
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-legacy-drain.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-legacy-drain.js
new file mode 100644
index 000000000..c6cbc7d6b
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-legacy-drain.js
@@ -0,0 +1,75 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var common = require('../common');
+var assert = require('assert');
+
+var Stream = require('../../readable');
+var Readable = Stream.Readable;
+
+var r = new Readable();
+var N = 256;
+var reads = 0;
+r._read = function(n) {
+ return r.push(++reads === N ? null : new Buffer(1));
+};
+
+var rended = false;
+r.on('end', function() {
+ rended = true;
+});
+
+var w = new Stream();
+w.writable = true;
+var writes = 0;
+var buffered = 0;
+w.write = function(c) {
+ writes += c.length;
+ buffered += c.length;
+ process.nextTick(drain);
+ return false;
+};
+
+function drain() {
+ assert(buffered <= 2);
+ buffered = 0;
+ w.emit('drain');
+}
+
+
+var wended = false;
+w.end = function() {
+ wended = true;
+};
+
+// Just for kicks, let's mess with the drain count.
+// This verifies that even if it gets negative in the
+// pipe() cleanup function, we'll still function properly.
+r.on('readable', function() {
+ w.emit('drain');
+});
+
+r.pipe(w);
+process.on('exit', function() {
+ assert(rended);
+ assert(wended);
+ console.error('ok');
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-non-empty-end.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-non-empty-end.js
new file mode 100644
index 000000000..c971898c1
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-readable-non-empty-end.js
@@ -0,0 +1,78 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var assert = require('assert');
+var common = require('../common.js');
+var Readable = require('../../lib/_stream_readable');
+
+var len = 0;
+var chunks = new Array(10);
+for (var i = 1; i <= 10; i++) {
+ chunks[i-1] = new Buffer(i);
+ len += i;
+}
+
+var test = new Readable();
+var n = 0;
+test._read = function(size) {
+ var chunk = chunks[n++];
+ setTimeout(function() {
+ test.push(chunk);
+ });
+};
+
+test.on('end', thrower);
+function thrower() {
+ throw new Error('this should not happen!');
+}
+
+var bytesread = 0;
+test.on('readable', function() {
+ var b = len - bytesread - 1;
+ var res = test.read(b);
+ if (res) {
+ bytesread += res.length;
+ console.error('br=%d len=%d', bytesread, len);
+ setTimeout(next);
+ }
+ test.read(0);
+});
+test.read(0);
+
+function next() {
+ // now let's make 'end' happen
+ test.removeListener('end', thrower);
+
+ var endEmitted = false;
+ process.on('exit', function() {
+ assert(endEmitted, 'end should be emitted by now');
+ });
+ test.on('end', function() {
+ endEmitted = true;
+ });
+
+ // one to get the last byte
+ var r = test.read();
+ assert(r);
+ assert.equal(r.length, 1);
+ r = test.read();
+ assert.equal(r, null);
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-set-encoding.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-set-encoding.js
new file mode 100644
index 000000000..602acd6d4
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-set-encoding.js
@@ -0,0 +1,312 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+
+var common = require('../common.js');
+var assert = require('assert');
+var R = require('../../lib/_stream_readable');
+var util = require('util');
+
+// tiny node-tap lookalike.
+var tests = [];
+var count = 0;
+
+function test(name, fn) {
+ count++;
+ tests.push([name, fn]);
+}
+
+function run() {
+ var next = tests.shift();
+ if (!next)
+ return console.error('ok');
+
+ var name = next[0];
+ var fn = next[1];
+ console.log('# %s', name);
+ fn({
+ same: assert.deepEqual,
+ equal: assert.equal,
+ end: function () {
+ count--;
+ run();
+ }
+ });
+}
+
+// ensure all tests have run
+process.on("exit", function () {
+ assert.equal(count, 0);
+});
+
+process.nextTick(run);
+
+/////
+
+util.inherits(TestReader, R);
+
+function TestReader(n, opts) {
+ R.call(this, opts);
+
+ this.pos = 0;
+ this.len = n || 100;
+}
+
+TestReader.prototype._read = function(n) {
+ setTimeout(function() {
+
+ if (this.pos >= this.len) {
+ return this.push(null);
+ }
+
+ n = Math.min(n, this.len - this.pos);
+ if (n <= 0) {
+ return this.push(null);
+ }
+
+ this.pos += n;
+ var ret = new Buffer(n);
+ ret.fill('a');
+
+ console.log("this.push(ret)", ret)
+
+ return this.push(ret);
+ }.bind(this), 1);
+};
+
+test('setEncoding utf8', function(t) {
+ var tr = new TestReader(100);
+ tr.setEncoding('utf8');
+ var out = [];
+ var expect =
+ [ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa' ];
+
+ tr.on('readable', function flow() {
+ var chunk;
+ while (null !== (chunk = tr.read(10)))
+ out.push(chunk);
+ });
+
+ tr.on('end', function() {
+ t.same(out, expect);
+ t.end();
+ });
+
+ // just kick it off.
+ tr.emit('readable');
+});
+
+
+test('setEncoding hex', function(t) {
+ var tr = new TestReader(100);
+ tr.setEncoding('hex');
+ var out = [];
+ var expect =
+ [ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161' ];
+
+ tr.on('readable', function flow() {
+ var chunk;
+ while (null !== (chunk = tr.read(10)))
+ out.push(chunk);
+ });
+
+ tr.on('end', function() {
+ t.same(out, expect);
+ t.end();
+ });
+
+ // just kick it off.
+ tr.emit('readable');
+});
+
+test('setEncoding hex with read(13)', function(t) {
+ var tr = new TestReader(100);
+ tr.setEncoding('hex');
+ var out = [];
+ var expect =
+ [ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "16161" ];
+
+ tr.on('readable', function flow() {
+ console.log("readable once")
+ var chunk;
+ while (null !== (chunk = tr.read(13)))
+ out.push(chunk);
+ });
+
+ tr.on('end', function() {
+ console.log("END")
+ t.same(out, expect);
+ t.end();
+ });
+
+ // just kick it off.
+ tr.emit('readable');
+});
+
+test('encoding: utf8', function(t) {
+ var tr = new TestReader(100, { encoding: 'utf8' });
+ var out = [];
+ var expect =
+ [ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa',
+ 'aaaaaaaaaa' ];
+
+ tr.on('readable', function flow() {
+ var chunk;
+ while (null !== (chunk = tr.read(10)))
+ out.push(chunk);
+ });
+
+ tr.on('end', function() {
+ t.same(out, expect);
+ t.end();
+ });
+
+ // just kick it off.
+ tr.emit('readable');
+});
+
+
+test('encoding: hex', function(t) {
+ var tr = new TestReader(100, { encoding: 'hex' });
+ var out = [];
+ var expect =
+ [ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161',
+ '6161616161' ];
+
+ tr.on('readable', function flow() {
+ var chunk;
+ while (null !== (chunk = tr.read(10)))
+ out.push(chunk);
+ });
+
+ tr.on('end', function() {
+ t.same(out, expect);
+ t.end();
+ });
+
+ // just kick it off.
+ tr.emit('readable');
+});
+
+test('encoding: hex with read(13)', function(t) {
+ var tr = new TestReader(100, { encoding: 'hex' });
+ var out = [];
+ var expect =
+ [ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "1616161616161",
+ "6161616161616",
+ "16161" ];
+
+ tr.on('readable', function flow() {
+ var chunk;
+ while (null !== (chunk = tr.read(13)))
+ out.push(chunk);
+ });
+
+ tr.on('end', function() {
+ t.same(out, expect);
+ t.end();
+ });
+
+ // just kick it off.
+ tr.emit('readable');
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-transform.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-transform.js
new file mode 100644
index 000000000..5804c39d8
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-transform.js
@@ -0,0 +1,435 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var assert = require('assert');
+var common = require('../common.js');
+var PassThrough = require('../../lib/_stream_passthrough');
+var Transform = require('../../lib/_stream_transform');
+
+// tiny node-tap lookalike.
+var tests = [];
+var count = 0;
+
+function test(name, fn) {
+ count++;
+ tests.push([name, fn]);
+}
+
+function run() {
+ var next = tests.shift();
+ if (!next)
+ return console.error('ok');
+
+ var name = next[0];
+ var fn = next[1];
+ console.log('# %s', name);
+ fn({
+ same: assert.deepEqual,
+ equal: assert.equal,
+ ok: assert,
+ end: function () {
+ count--;
+ run();
+ }
+ });
+}
+
+// ensure all tests have run
+process.on("exit", function () {
+ assert.equal(count, 0);
+});
+
+process.nextTick(run);
+
+/////
+
+test('writable side consumption', function(t) {
+ var tx = new Transform({
+ highWaterMark: 10
+ });
+
+ var transformed = 0;
+ tx._transform = function(chunk, encoding, cb) {
+ transformed += chunk.length;
+ tx.push(chunk);
+ cb();
+ };
+
+ for (var i = 1; i <= 10; i++) {
+ tx.write(new Buffer(i));
+ }
+ tx.end();
+
+ t.equal(tx._readableState.length, 10);
+ t.equal(transformed, 10);
+ t.equal(tx._transformState.writechunk.length, 5);
+ t.same(tx._writableState.buffer.map(function(c) {
+ return c.chunk.length;
+ }), [6, 7, 8, 9, 10]);
+
+ t.end();
+});
+
+test('passthrough', function(t) {
+ var pt = new PassThrough();
+
+ pt.write(new Buffer('foog'));
+ pt.write(new Buffer('bark'));
+ pt.write(new Buffer('bazy'));
+ pt.write(new Buffer('kuel'));
+ pt.end();
+
+ t.equal(pt.read(5).toString(), 'foogb');
+ t.equal(pt.read(5).toString(), 'arkba');
+ t.equal(pt.read(5).toString(), 'zykue');
+ t.equal(pt.read(5).toString(), 'l');
+ t.end();
+});
+
+test('simple transform', function(t) {
+ var pt = new Transform;
+ pt._transform = function(c, e, cb) {
+ var ret = new Buffer(c.length);
+ ret.fill('x');
+ pt.push(ret);
+ cb();
+ };
+
+ pt.write(new Buffer('foog'));
+ pt.write(new Buffer('bark'));
+ pt.write(new Buffer('bazy'));
+ pt.write(new Buffer('kuel'));
+ pt.end();
+
+ t.equal(pt.read(5).toString(), 'xxxxx');
+ t.equal(pt.read(5).toString(), 'xxxxx');
+ t.equal(pt.read(5).toString(), 'xxxxx');
+ t.equal(pt.read(5).toString(), 'x');
+ t.end();
+});
+
+test('async passthrough', function(t) {
+ var pt = new Transform;
+ pt._transform = function(chunk, encoding, cb) {
+ setTimeout(function() {
+ pt.push(chunk);
+ cb();
+ }, 10);
+ };
+
+ pt.write(new Buffer('foog'));
+ pt.write(new Buffer('bark'));
+ pt.write(new Buffer('bazy'));
+ pt.write(new Buffer('kuel'));
+ pt.end();
+
+ pt.on('finish', function() {
+ t.equal(pt.read(5).toString(), 'foogb');
+ t.equal(pt.read(5).toString(), 'arkba');
+ t.equal(pt.read(5).toString(), 'zykue');
+ t.equal(pt.read(5).toString(), 'l');
+ t.end();
+ });
+});
+
+test('assymetric transform (expand)', function(t) {
+ var pt = new Transform;
+
+ // emit each chunk 2 times.
+ pt._transform = function(chunk, encoding, cb) {
+ setTimeout(function() {
+ pt.push(chunk);
+ setTimeout(function() {
+ pt.push(chunk);
+ cb();
+ }, 10)
+ }, 10);
+ };
+
+ pt.write(new Buffer('foog'));
+ pt.write(new Buffer('bark'));
+ pt.write(new Buffer('bazy'));
+ pt.write(new Buffer('kuel'));
+ pt.end();
+
+ pt.on('finish', function() {
+ t.equal(pt.read(5).toString(), 'foogf');
+ t.equal(pt.read(5).toString(), 'oogba');
+ t.equal(pt.read(5).toString(), 'rkbar');
+ t.equal(pt.read(5).toString(), 'kbazy');
+ t.equal(pt.read(5).toString(), 'bazyk');
+ t.equal(pt.read(5).toString(), 'uelku');
+ t.equal(pt.read(5).toString(), 'el');
+ t.end();
+ });
+});
+
+test('assymetric transform (compress)', function(t) {
+ var pt = new Transform;
+
+ // each output is the first char of 3 consecutive chunks,
+ // or whatever's left.
+ pt.state = '';
+
+ pt._transform = function(chunk, encoding, cb) {
+ if (!chunk)
+ chunk = '';
+ var s = chunk.toString();
+ setTimeout(function() {
+ this.state += s.charAt(0);
+ if (this.state.length === 3) {
+ pt.push(new Buffer(this.state));
+ this.state = '';
+ }
+ cb();
+ }.bind(this), 10);
+ };
+
+ pt._flush = function(cb) {
+ // just output whatever we have.
+ pt.push(new Buffer(this.state));
+ this.state = '';
+ cb();
+ };
+
+ pt.write(new Buffer('aaaa'));
+ pt.write(new Buffer('bbbb'));
+ pt.write(new Buffer('cccc'));
+ pt.write(new Buffer('dddd'));
+ pt.write(new Buffer('eeee'));
+ pt.write(new Buffer('aaaa'));
+ pt.write(new Buffer('bbbb'));
+ pt.write(new Buffer('cccc'));
+ pt.write(new Buffer('dddd'));
+ pt.write(new Buffer('eeee'));
+ pt.write(new Buffer('aaaa'));
+ pt.write(new Buffer('bbbb'));
+ pt.write(new Buffer('cccc'));
+ pt.write(new Buffer('dddd'));
+ pt.end();
+
+ // 'abcdeabcdeabcd'
+ pt.on('finish', function() {
+ t.equal(pt.read(5).toString(), 'abcde');
+ t.equal(pt.read(5).toString(), 'abcde');
+ t.equal(pt.read(5).toString(), 'abcd');
+ t.end();
+ });
+});
+
+
+test('passthrough event emission', function(t) {
+ var pt = new PassThrough();
+ var emits = 0;
+ pt.on('readable', function() {
+ var state = pt._readableState;
+ console.error('>>> emit readable %d', emits);
+ emits++;
+ });
+
+ var i = 0;
+
+ pt.write(new Buffer('foog'));
+
+ console.error('need emit 0');
+ pt.write(new Buffer('bark'));
+
+ console.error('should have emitted readable now 1 === %d', emits);
+ t.equal(emits, 1);
+
+ t.equal(pt.read(5).toString(), 'foogb');
+ t.equal(pt.read(5) + '', 'null');
+
+ console.error('need emit 1');
+
+ pt.write(new Buffer('bazy'));
+ console.error('should have emitted, but not again');
+ pt.write(new Buffer('kuel'));
+
+ console.error('should have emitted readable now 2 === %d', emits);
+ t.equal(emits, 2);
+
+ t.equal(pt.read(5).toString(), 'arkba');
+ t.equal(pt.read(5).toString(), 'zykue');
+ t.equal(pt.read(5), null);
+
+ console.error('need emit 2');
+
+ pt.end();
+
+ t.equal(emits, 3);
+
+ t.equal(pt.read(5).toString(), 'l');
+ t.equal(pt.read(5), null);
+
+ console.error('should not have emitted again');
+ t.equal(emits, 3);
+ t.end();
+});
+
+test('passthrough event emission reordered', function(t) {
+ var pt = new PassThrough;
+ var emits = 0;
+ pt.on('readable', function() {
+ console.error('emit readable', emits)
+ emits++;
+ });
+
+ pt.write(new Buffer('foog'));
+ console.error('need emit 0');
+ pt.write(new Buffer('bark'));
+ console.error('should have emitted readable now 1 === %d', emits);
+ t.equal(emits, 1);
+
+ t.equal(pt.read(5).toString(), 'foogb');
+ t.equal(pt.read(5), null);
+
+ console.error('need emit 1');
+ pt.once('readable', function() {
+ t.equal(pt.read(5).toString(), 'arkba');
+
+ t.equal(pt.read(5), null);
+
+ console.error('need emit 2');
+ pt.once('readable', function() {
+ t.equal(pt.read(5).toString(), 'zykue');
+ t.equal(pt.read(5), null);
+ pt.once('readable', function() {
+ t.equal(pt.read(5).toString(), 'l');
+ t.equal(pt.read(5), null);
+ t.equal(emits, 4);
+ t.end();
+ });
+ pt.end();
+ });
+ pt.write(new Buffer('kuel'));
+ });
+
+ pt.write(new Buffer('bazy'));
+});
+
+test('passthrough facaded', function(t) {
+ console.error('passthrough facaded');
+ var pt = new PassThrough;
+ var datas = [];
+ pt.on('data', function(chunk) {
+ datas.push(chunk.toString());
+ });
+
+ pt.on('end', function() {
+ t.same(datas, ['foog', 'bark', 'bazy', 'kuel']);
+ t.end();
+ });
+
+ pt.write(new Buffer('foog'));
+ setTimeout(function() {
+ pt.write(new Buffer('bark'));
+ setTimeout(function() {
+ pt.write(new Buffer('bazy'));
+ setTimeout(function() {
+ pt.write(new Buffer('kuel'));
+ setTimeout(function() {
+ pt.end();
+ }, 10);
+ }, 10);
+ }, 10);
+ }, 10);
+});
+
+test('object transform (json parse)', function(t) {
+ console.error('json parse stream');
+ var jp = new Transform({ objectMode: true });
+ jp._transform = function(data, encoding, cb) {
+ try {
+ jp.push(JSON.parse(data));
+ cb();
+ } catch (er) {
+ cb(er);
+ }
+ };
+
+ // anything except null/undefined is fine.
+ // those are "magic" in the stream API, because they signal EOF.
+ var objects = [
+ { foo: 'bar' },
+ 100,
+ "string",
+ { nested: { things: [ { foo: 'bar' }, 100, "string" ] } }
+ ];
+
+ var ended = false;
+ jp.on('end', function() {
+ ended = true;
+ });
+
+ objects.forEach(function(obj) {
+ jp.write(JSON.stringify(obj));
+ var res = jp.read();
+ t.same(res, obj);
+ });
+
+ jp.end();
+
+ process.nextTick(function() {
+ t.ok(ended);
+ t.end();
+ })
+});
+
+test('object transform (json stringify)', function(t) {
+ console.error('json parse stream');
+ var js = new Transform({ objectMode: true });
+ js._transform = function(data, encoding, cb) {
+ try {
+ js.push(JSON.stringify(data));
+ cb();
+ } catch (er) {
+ cb(er);
+ }
+ };
+
+ // anything except null/undefined is fine.
+ // those are "magic" in the stream API, because they signal EOF.
+ var objects = [
+ { foo: 'bar' },
+ 100,
+ "string",
+ { nested: { things: [ { foo: 'bar' }, 100, "string" ] } }
+ ];
+
+ var ended = false;
+ js.on('end', function() {
+ ended = true;
+ });
+
+ objects.forEach(function(obj) {
+ js.write(obj);
+ var res = js.read();
+ t.equal(res, JSON.stringify(obj));
+ });
+
+ js.end();
+
+ process.nextTick(function() {
+ t.ok(ended);
+ t.end();
+ })
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-unpipe-drain.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-unpipe-drain.js
new file mode 100644
index 000000000..a3b539454
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-unpipe-drain.js
@@ -0,0 +1,76 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+
+var common = require('../common.js');
+var assert = require('assert');
+var stream = require('../../readable');
+var crypto = require('crypto');
+
+var util = require('util');
+
+function TestWriter() {
+ stream.Writable.call(this);
+}
+util.inherits(TestWriter, stream.Writable);
+
+TestWriter.prototype._write = function (buffer, encoding, callback) {
+ console.log('write called');
+ // super slow write stream (callback never called)
+};
+
+var dest = new TestWriter();
+
+function TestReader(id) {
+ stream.Readable.call(this);
+ this.reads = 0;
+}
+util.inherits(TestReader, stream.Readable);
+
+TestReader.prototype._read = function (size) {
+ this.reads += 1;
+ this.push(crypto.randomBytes(size));
+};
+
+var src1 = new TestReader();
+var src2 = new TestReader();
+
+src1.pipe(dest);
+
+src1.once('readable', function () {
+ process.nextTick(function () {
+
+ src2.pipe(dest);
+
+ src2.once('readable', function () {
+ process.nextTick(function () {
+
+ src1.unpipe(dest);
+ });
+ });
+ });
+});
+
+
+process.on('exit', function () {
+ assert.equal(src1.reads, 2);
+ assert.equal(src2.reads, 2);
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-unpipe-leak.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-unpipe-leak.js
new file mode 100644
index 000000000..6882f2093
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-unpipe-leak.js
@@ -0,0 +1,74 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+
+var common = require('../common.js');
+var assert = require('assert');
+var stream = require('../../readable');
+
+var chunk = new Buffer('hallo');
+
+var util = require('util');
+
+function TestWriter() {
+ stream.Writable.call(this);
+}
+util.inherits(TestWriter, stream.Writable);
+
+TestWriter.prototype._write = function(buffer, encoding, callback) {
+ callback(null);
+};
+
+var dest = new TestWriter();
+
+// Set this high so that we'd trigger a nextTick warning
+// and/or RangeError if we do maybeReadMore wrong.
+function TestReader() {
+ stream.Readable.call(this, { highWaterMark: 0x10000 });
+}
+util.inherits(TestReader, stream.Readable);
+
+TestReader.prototype._read = function(size) {
+ this.push(chunk);
+};
+
+var src = new TestReader();
+
+for (var i = 0; i < 10; i++) {
+ src.pipe(dest);
+ src.unpipe(dest);
+}
+
+assert.equal(src.listeners('end').length, 0);
+assert.equal(src.listeners('readable').length, 0);
+
+assert.equal(dest.listeners('unpipe').length, 0);
+assert.equal(dest.listeners('drain').length, 0);
+assert.equal(dest.listeners('error').length, 0);
+assert.equal(dest.listeners('close').length, 0);
+assert.equal(dest.listeners('finish').length, 0);
+
+console.error(src._readableState);
+process.on('exit', function() {
+ assert(src._readableState.length >= src._readableState.highWaterMark);
+ src._readableState.buffer.length = 0;
+ console.error(src._readableState);
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-writable.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-writable.js
new file mode 100644
index 000000000..a60e65cd8
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/test/simple/test-stream2-writable.js
@@ -0,0 +1,328 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var common = require('../common.js');
+var W = require('../../lib/_stream_writable');
+var D = require('../../lib/_stream_duplex');
+var assert = require('assert');
+
+var util = require('util');
+util.inherits(TestWriter, W);
+
+function TestWriter() {
+ W.apply(this, arguments);
+ this.buffer = [];
+ this.written = 0;
+}
+
+TestWriter.prototype._write = function(chunk, encoding, cb) {
+ // simulate a small unpredictable latency
+ setTimeout(function() {
+ this.buffer.push(chunk.toString());
+ this.written += chunk.length;
+ cb();
+ }.bind(this), Math.floor(Math.random() * 10));
+};
+
+var chunks = new Array(50);
+for (var i = 0; i < chunks.length; i++) {
+ chunks[i] = new Array(i + 1).join('x');
+}
+
+// tiny node-tap lookalike.
+var tests = [];
+var count = 0;
+
+function test(name, fn) {
+ count++;
+ tests.push([name, fn]);
+}
+
+function run() {
+ var next = tests.shift();
+ if (!next)
+ return console.error('ok');
+
+ var name = next[0];
+ var fn = next[1];
+ console.log('# %s', name);
+ fn({
+ same: assert.deepEqual,
+ equal: assert.equal,
+ end: function () {
+ count--;
+ run();
+ }
+ });
+}
+
+// ensure all tests have run
+process.on("exit", function () {
+ assert.equal(count, 0);
+});
+
+process.nextTick(run);
+
+test('write fast', function(t) {
+ var tw = new TestWriter({
+ highWaterMark: 100
+ });
+
+ tw.on('finish', function() {
+ t.same(tw.buffer, chunks, 'got chunks in the right order');
+ t.end();
+ });
+
+ chunks.forEach(function(chunk) {
+ // screw backpressure. Just buffer it all up.
+ tw.write(chunk);
+ });
+ tw.end();
+});
+
+test('write slow', function(t) {
+ var tw = new TestWriter({
+ highWaterMark: 100
+ });
+
+ tw.on('finish', function() {
+ t.same(tw.buffer, chunks, 'got chunks in the right order');
+ t.end();
+ });
+
+ var i = 0;
+ (function W() {
+ tw.write(chunks[i++]);
+ if (i < chunks.length)
+ setTimeout(W, 10);
+ else
+ tw.end();
+ })();
+});
+
+test('write backpressure', function(t) {
+ var tw = new TestWriter({
+ highWaterMark: 50
+ });
+
+ var drains = 0;
+
+ tw.on('finish', function() {
+ t.same(tw.buffer, chunks, 'got chunks in the right order');
+ t.equal(drains, 17);
+ t.end();
+ });
+
+ tw.on('drain', function() {
+ drains++;
+ });
+
+ var i = 0;
+ (function W() {
+ do {
+ var ret = tw.write(chunks[i++]);
+ } while (ret !== false && i < chunks.length);
+
+ if (i < chunks.length) {
+ assert(tw._writableState.length >= 50);
+ tw.once('drain', W);
+ } else {
+ tw.end();
+ }
+ })();
+});
+
+test('write bufferize', function(t) {
+ var tw = new TestWriter({
+ highWaterMark: 100
+ });
+
+ var encodings =
+ [ 'hex',
+ 'utf8',
+ 'utf-8',
+ 'ascii',
+ 'binary',
+ 'base64',
+ 'ucs2',
+ 'ucs-2',
+ 'utf16le',
+ 'utf-16le',
+ undefined ];
+
+ tw.on('finish', function() {
+ t.same(tw.buffer, chunks, 'got the expected chunks');
+ });
+
+ chunks.forEach(function(chunk, i) {
+ var enc = encodings[ i % encodings.length ];
+ chunk = new Buffer(chunk);
+ tw.write(chunk.toString(enc), enc);
+ });
+ t.end();
+});
+
+test('write no bufferize', function(t) {
+ var tw = new TestWriter({
+ highWaterMark: 100,
+ decodeStrings: false
+ });
+
+ tw._write = function(chunk, encoding, cb) {
+ assert(typeof chunk === 'string');
+ chunk = new Buffer(chunk, encoding);
+ return TestWriter.prototype._write.call(this, chunk, encoding, cb);
+ };
+
+ var encodings =
+ [ 'hex',
+ 'utf8',
+ 'utf-8',
+ 'ascii',
+ 'binary',
+ 'base64',
+ 'ucs2',
+ 'ucs-2',
+ 'utf16le',
+ 'utf-16le',
+ undefined ];
+
+ tw.on('finish', function() {
+ t.same(tw.buffer, chunks, 'got the expected chunks');
+ });
+
+ chunks.forEach(function(chunk, i) {
+ var enc = encodings[ i % encodings.length ];
+ chunk = new Buffer(chunk);
+ tw.write(chunk.toString(enc), enc);
+ });
+ t.end();
+});
+
+test('write callbacks', function (t) {
+ var callbacks = chunks.map(function(chunk, i) {
+ return [i, function(er) {
+ callbacks._called[i] = chunk;
+ }];
+ }).reduce(function(set, x) {
+ set['callback-' + x[0]] = x[1];
+ return set;
+ }, {});
+ callbacks._called = [];
+
+ var tw = new TestWriter({
+ highWaterMark: 100
+ });
+
+ tw.on('finish', function() {
+ process.nextTick(function() {
+ t.same(tw.buffer, chunks, 'got chunks in the right order');
+ t.same(callbacks._called, chunks, 'called all callbacks');
+ t.end();
+ });
+ });
+
+ chunks.forEach(function(chunk, i) {
+ tw.write(chunk, callbacks['callback-' + i]);
+ });
+ tw.end();
+});
+
+test('end callback', function (t) {
+ var tw = new TestWriter();
+ tw.end(function () {
+ t.end();
+ });
+});
+
+test('end callback with chunk', function (t) {
+ var tw = new TestWriter();
+ tw.end(new Buffer('hello world'), function () {
+ t.end();
+ });
+});
+
+test('end callback with chunk and encoding', function (t) {
+ var tw = new TestWriter();
+ tw.end('hello world', 'ascii', function () {
+ t.end();
+ });
+});
+
+test('end callback after .write() call', function (t) {
+ var tw = new TestWriter();
+ tw.write(new Buffer('hello world'));
+ tw.end(function () {
+ t.end();
+ });
+});
+
+test('encoding should be ignored for buffers', function(t) {
+ var tw = new W();
+ var hex = '018b5e9a8f6236ffe30e31baf80d2cf6eb';
+ tw._write = function(chunk, encoding, cb) {
+ t.equal(chunk.toString('hex'), hex);
+ t.end();
+ };
+ var buf = new Buffer(hex, 'hex');
+ tw.write(buf, 'binary');
+});
+
+test('writables are not pipable', function(t) {
+ var w = new W();
+ w._write = function() {};
+ var gotError = false;
+ w.on('error', function(er) {
+ gotError = true;
+ });
+ w.pipe(process.stdout);
+ assert(gotError);
+ t.end();
+});
+
+test('duplexes are pipable', function(t) {
+ var d = new D();
+ d._read = function() {};
+ d._write = function() {};
+ var gotError = false;
+ d.on('error', function(er) {
+ gotError = true;
+ });
+ d.pipe(process.stdout);
+ assert(!gotError);
+ t.end();
+});
+
+test('end(chunk) two times is an error', function(t) {
+ var w = new W();
+ w._write = function() {};
+ var gotError = false;
+ w.on('error', function(er) {
+ gotError = true;
+ t.equal(er.message, 'write after end');
+ });
+ w.end('this is the end');
+ w.end('and so is this');
+ process.nextTick(function() {
+ assert(gotError);
+ t.end();
+ });
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/transform.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/transform.js
new file mode 100644
index 000000000..5d482f078
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/transform.js
@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_transform.js")
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/writable.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/writable.js
new file mode 100644
index 000000000..e1e9efdf3
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/writable.js
@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_writable.js")
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/zlib.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/zlib.js
new file mode 100644
index 000000000..a30ca2091
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/readable-stream/zlib.js
@@ -0,0 +1,452 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var Transform = require('./lib/_stream_transform.js');
+
+var binding = process.binding('zlib');
+var util = require('util');
+var assert = require('assert').ok;
+
+// zlib doesn't provide these, so kludge them in following the same
+// const naming scheme zlib uses.
+binding.Z_MIN_WINDOWBITS = 8;
+binding.Z_MAX_WINDOWBITS = 15;
+binding.Z_DEFAULT_WINDOWBITS = 15;
+
+// fewer than 64 bytes per chunk is stupid.
+// technically it could work with as few as 8, but even 64 bytes
+// is absurdly low. Usually a MB or more is best.
+binding.Z_MIN_CHUNK = 64;
+binding.Z_MAX_CHUNK = Infinity;
+binding.Z_DEFAULT_CHUNK = (16 * 1024);
+
+binding.Z_MIN_MEMLEVEL = 1;
+binding.Z_MAX_MEMLEVEL = 9;
+binding.Z_DEFAULT_MEMLEVEL = 8;
+
+binding.Z_MIN_LEVEL = -1;
+binding.Z_MAX_LEVEL = 9;
+binding.Z_DEFAULT_LEVEL = binding.Z_DEFAULT_COMPRESSION;
+
+// expose all the zlib constants
+Object.keys(binding).forEach(function(k) {
+ if (k.match(/^Z/)) exports[k] = binding[k];
+});
+
+// translation table for return codes.
+exports.codes = {
+ Z_OK: binding.Z_OK,
+ Z_STREAM_END: binding.Z_STREAM_END,
+ Z_NEED_DICT: binding.Z_NEED_DICT,
+ Z_ERRNO: binding.Z_ERRNO,
+ Z_STREAM_ERROR: binding.Z_STREAM_ERROR,
+ Z_DATA_ERROR: binding.Z_DATA_ERROR,
+ Z_MEM_ERROR: binding.Z_MEM_ERROR,
+ Z_BUF_ERROR: binding.Z_BUF_ERROR,
+ Z_VERSION_ERROR: binding.Z_VERSION_ERROR
+};
+
+Object.keys(exports.codes).forEach(function(k) {
+ exports.codes[exports.codes[k]] = k;
+});
+
+exports.Deflate = Deflate;
+exports.Inflate = Inflate;
+exports.Gzip = Gzip;
+exports.Gunzip = Gunzip;
+exports.DeflateRaw = DeflateRaw;
+exports.InflateRaw = InflateRaw;
+exports.Unzip = Unzip;
+
+exports.createDeflate = function(o) {
+ return new Deflate(o);
+};
+
+exports.createInflate = function(o) {
+ return new Inflate(o);
+};
+
+exports.createDeflateRaw = function(o) {
+ return new DeflateRaw(o);
+};
+
+exports.createInflateRaw = function(o) {
+ return new InflateRaw(o);
+};
+
+exports.createGzip = function(o) {
+ return new Gzip(o);
+};
+
+exports.createGunzip = function(o) {
+ return new Gunzip(o);
+};
+
+exports.createUnzip = function(o) {
+ return new Unzip(o);
+};
+
+
+// Convenience methods.
+// compress/decompress a string or buffer in one step.
+exports.deflate = function(buffer, callback) {
+ zlibBuffer(new Deflate(), buffer, callback);
+};
+
+exports.gzip = function(buffer, callback) {
+ zlibBuffer(new Gzip(), buffer, callback);
+};
+
+exports.deflateRaw = function(buffer, callback) {
+ zlibBuffer(new DeflateRaw(), buffer, callback);
+};
+
+exports.unzip = function(buffer, callback) {
+ zlibBuffer(new Unzip(), buffer, callback);
+};
+
+exports.inflate = function(buffer, callback) {
+ zlibBuffer(new Inflate(), buffer, callback);
+};
+
+exports.gunzip = function(buffer, callback) {
+ zlibBuffer(new Gunzip(), buffer, callback);
+};
+
+exports.inflateRaw = function(buffer, callback) {
+ zlibBuffer(new InflateRaw(), buffer, callback);
+};
+
+function zlibBuffer(engine, buffer, callback) {
+ var buffers = [];
+ var nread = 0;
+
+ engine.on('error', onError);
+ engine.on('end', onEnd);
+
+ engine.end(buffer);
+ flow();
+
+ function flow() {
+ var chunk;
+ while (null !== (chunk = engine.read())) {
+ buffers.push(chunk);
+ nread += chunk.length;
+ }
+ engine.once('readable', flow);
+ }
+
+ function onError(err) {
+ engine.removeListener('end', onEnd);
+ engine.removeListener('readable', flow);
+ callback(err);
+ }
+
+ function onEnd() {
+ var buf = Buffer.concat(buffers, nread);
+ buffers = [];
+ callback(null, buf);
+ }
+}
+
+
+// generic zlib
+// minimal 2-byte header
+function Deflate(opts) {
+ if (!(this instanceof Deflate)) return new Deflate(opts);
+ Zlib.call(this, opts, binding.DEFLATE);
+}
+
+function Inflate(opts) {
+ if (!(this instanceof Inflate)) return new Inflate(opts);
+ Zlib.call(this, opts, binding.INFLATE);
+}
+
+
+
+// gzip - bigger header, same deflate compression
+function Gzip(opts) {
+ if (!(this instanceof Gzip)) return new Gzip(opts);
+ Zlib.call(this, opts, binding.GZIP);
+}
+
+function Gunzip(opts) {
+ if (!(this instanceof Gunzip)) return new Gunzip(opts);
+ Zlib.call(this, opts, binding.GUNZIP);
+}
+
+
+
+// raw - no header
+function DeflateRaw(opts) {
+ if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts);
+ Zlib.call(this, opts, binding.DEFLATERAW);
+}
+
+function InflateRaw(opts) {
+ if (!(this instanceof InflateRaw)) return new InflateRaw(opts);
+ Zlib.call(this, opts, binding.INFLATERAW);
+}
+
+
+// auto-detect header.
+function Unzip(opts) {
+ if (!(this instanceof Unzip)) return new Unzip(opts);
+ Zlib.call(this, opts, binding.UNZIP);
+}
+
+
+// the Zlib class they all inherit from
+// This thing manages the queue of requests, and returns
+// true or false if there is anything in the queue when
+// you call the .write() method.
+
+function Zlib(opts, mode) {
+ this._opts = opts = opts || {};
+ this._chunkSize = opts.chunkSize || exports.Z_DEFAULT_CHUNK;
+
+ Transform.call(this, opts);
+
+ // means a different thing there.
+ this._readableState.chunkSize = null;
+
+ if (opts.chunkSize) {
+ if (opts.chunkSize < exports.Z_MIN_CHUNK ||
+ opts.chunkSize > exports.Z_MAX_CHUNK) {
+ throw new Error('Invalid chunk size: ' + opts.chunkSize);
+ }
+ }
+
+ if (opts.windowBits) {
+ if (opts.windowBits < exports.Z_MIN_WINDOWBITS ||
+ opts.windowBits > exports.Z_MAX_WINDOWBITS) {
+ throw new Error('Invalid windowBits: ' + opts.windowBits);
+ }
+ }
+
+ if (opts.level) {
+ if (opts.level < exports.Z_MIN_LEVEL ||
+ opts.level > exports.Z_MAX_LEVEL) {
+ throw new Error('Invalid compression level: ' + opts.level);
+ }
+ }
+
+ if (opts.memLevel) {
+ if (opts.memLevel < exports.Z_MIN_MEMLEVEL ||
+ opts.memLevel > exports.Z_MAX_MEMLEVEL) {
+ throw new Error('Invalid memLevel: ' + opts.memLevel);
+ }
+ }
+
+ if (opts.strategy) {
+ if (opts.strategy != exports.Z_FILTERED &&
+ opts.strategy != exports.Z_HUFFMAN_ONLY &&
+ opts.strategy != exports.Z_RLE &&
+ opts.strategy != exports.Z_FIXED &&
+ opts.strategy != exports.Z_DEFAULT_STRATEGY) {
+ throw new Error('Invalid strategy: ' + opts.strategy);
+ }
+ }
+
+ if (opts.dictionary) {
+ if (!Buffer.isBuffer(opts.dictionary)) {
+ throw new Error('Invalid dictionary: it should be a Buffer instance');
+ }
+ }
+
+ this._binding = new binding.Zlib(mode);
+
+ var self = this;
+ this._hadError = false;
+ this._binding.onerror = function(message, errno) {
+ // there is no way to cleanly recover.
+ // continuing only obscures problems.
+ self._binding = null;
+ self._hadError = true;
+
+ var error = new Error(message);
+ error.errno = errno;
+ error.code = exports.codes[errno];
+ self.emit('error', error);
+ };
+
+ this._binding.init(opts.windowBits || exports.Z_DEFAULT_WINDOWBITS,
+ opts.level || exports.Z_DEFAULT_COMPRESSION,
+ opts.memLevel || exports.Z_DEFAULT_MEMLEVEL,
+ opts.strategy || exports.Z_DEFAULT_STRATEGY,
+ opts.dictionary);
+
+ this._buffer = new Buffer(this._chunkSize);
+ this._offset = 0;
+ this._closed = false;
+
+ this.once('end', this.close);
+}
+
+util.inherits(Zlib, Transform);
+
+Zlib.prototype.reset = function reset() {
+ return this._binding.reset();
+};
+
+Zlib.prototype._flush = function(output, callback) {
+ var rs = this._readableState;
+ var self = this;
+ this._transform(null, output, function(er) {
+ if (er)
+ return callback(er);
+
+ // now a weird thing happens... it could be that you called flush
+ // but everything had already actually been consumed, but it wasn't
+ // enough to get over the Readable class's lowWaterMark.
+ // In that case, we emit 'readable' now to make sure it's consumed.
+ if (rs.length &&
+ rs.length < rs.lowWaterMark &&
+ !rs.ended &&
+ rs.needReadable)
+ self.emit('readable');
+
+ callback();
+ });
+};
+
+Zlib.prototype.flush = function(callback) {
+ var ws = this._writableState;
+ var ts = this._transformState;
+
+ if (ws.writing) {
+ ws.needDrain = true;
+ var self = this;
+ this.once('drain', function() {
+ self._flush(ts.output, callback);
+ });
+ return;
+ }
+
+ this._flush(ts.output, callback || function() {});
+};
+
+Zlib.prototype.close = function(callback) {
+ if (callback)
+ process.nextTick(callback);
+
+ if (this._closed)
+ return;
+
+ this._closed = true;
+
+ this._binding.close();
+
+ var self = this;
+ process.nextTick(function() {
+ self.emit('close');
+ });
+};
+
+Zlib.prototype._transform = function(chunk, output, cb) {
+ var flushFlag;
+ var ws = this._writableState;
+ var ending = ws.ending || ws.ended;
+ var last = ending && (!chunk || ws.length === chunk.length);
+
+ if (chunk !== null && !Buffer.isBuffer(chunk))
+ return cb(new Error('invalid input'));
+
+ // If it's the last chunk, or a final flush, we use the Z_FINISH flush flag.
+ // If it's explicitly flushing at some other time, then we use
+ // Z_FULL_FLUSH. Otherwise, use Z_NO_FLUSH for maximum compression
+ // goodness.
+ if (last)
+ flushFlag = binding.Z_FINISH;
+ else if (chunk === null)
+ flushFlag = binding.Z_FULL_FLUSH;
+ else
+ flushFlag = binding.Z_NO_FLUSH;
+
+ var availInBefore = chunk && chunk.length;
+ var availOutBefore = this._chunkSize - this._offset;
+ var inOff = 0;
+
+ var req = this._binding.write(flushFlag,
+ chunk, // in
+ inOff, // in_off
+ availInBefore, // in_len
+ this._buffer, // out
+ this._offset, //out_off
+ availOutBefore); // out_len
+
+ req.buffer = chunk;
+ req.callback = callback;
+
+ var self = this;
+ function callback(availInAfter, availOutAfter, buffer) {
+ if (self._hadError)
+ return;
+
+ var have = availOutBefore - availOutAfter;
+ assert(have >= 0, 'have should not go down');
+
+ if (have > 0) {
+ var out = self._buffer.slice(self._offset, self._offset + have);
+ self._offset += have;
+ // serve some output to the consumer.
+ output(out);
+ }
+
+ // exhausted the output buffer, or used all the input create a new one.
+ if (availOutAfter === 0 || self._offset >= self._chunkSize) {
+ availOutBefore = self._chunkSize;
+ self._offset = 0;
+ self._buffer = new Buffer(self._chunkSize);
+ }
+
+ if (availOutAfter === 0) {
+ // Not actually done. Need to reprocess.
+ // Also, update the availInBefore to the availInAfter value,
+ // so that if we have to hit it a third (fourth, etc.) time,
+ // it'll have the correct byte counts.
+ inOff += (availInBefore - availInAfter);
+ availInBefore = availInAfter;
+
+ var newReq = self._binding.write(flushFlag,
+ chunk,
+ inOff,
+ availInBefore,
+ self._buffer,
+ self._offset,
+ self._chunkSize);
+ newReq.callback = callback; // this same function
+ newReq.buffer = chunk;
+ return;
+ }
+
+ // finished with the chunk.
+ cb();
+ }
+};
+
+util.inherits(Deflate, Zlib);
+util.inherits(Inflate, Zlib);
+util.inherits(Gzip, Zlib);
+util.inherits(Gunzip, Zlib);
+util.inherits(DeflateRaw, Zlib);
+util.inherits(InflateRaw, Zlib);
+util.inherits(Unzip, Zlib);
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/.npmignore
new file mode 100644
index 000000000..07e6e472c
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/.npmignore
@@ -0,0 +1 @@
+/node_modules
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/README.md b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/README.md
new file mode 100644
index 000000000..8d6a1928f
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/README.md
@@ -0,0 +1,14 @@
+# stream-counter
+
+Keep track of how many bytes have been written to a stream.
+
+## Usage
+
+```js
+var StreamCounter = require('stream-counter');
+var counter = new StreamCounter();
+counter.on('progress', function() {
+ console.log("progress", counter.bytes);
+});
+fs.createReadStream('foo.txt').pipe(counter);
+```
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/index.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/index.js
new file mode 100644
index 000000000..c490c2dbe
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/index.js
@@ -0,0 +1,16 @@
+module.exports = ByteCounter;
+
+var Writable = require('readable-stream').Writable;
+var util = require('util');
+
+util.inherits(ByteCounter, Writable);
+function ByteCounter(options) {
+ Writable.call(this, options);
+ this.bytes = 0;
+}
+
+ByteCounter.prototype._write = function(chunk, encoding, cb) {
+ this.bytes += chunk.length;
+ this.emit('progress');
+ cb();
+};
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/package.json b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/package.json
new file mode 100644
index 000000000..e57f396ec
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/package.json
@@ -0,0 +1,35 @@
+{
+ "name": "stream-counter",
+ "version": "0.1.0",
+ "description": "keeps track of how many bytes have been written to a stream",
+ "main": "index.js",
+ "scripts": {
+ "test": "node test/test.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/superjoe30/node-stream-counter.git"
+ },
+ "author": {
+ "name": "Andrew Kelley",
+ "email": "superjoe30@gmail.com"
+ },
+ "license": "BSD",
+ "engines": {
+ "node": ">=0.8.0"
+ },
+ "dependencies": {
+ "readable-stream": "~1.0.2"
+ },
+ "readme": "# stream-counter\n\nKeep track of how many bytes have been written to a stream.\n\n## Usage\n\n```js\nvar StreamCounter = require('stream-counter');\nvar counter = new StreamCounter();\ncounter.on('progress', function() {\n console.log(\"progress\", counter.bytes);\n});\nfs.createReadStream('foo.txt').pipe(counter);\n```\n",
+ "readmeFilename": "README.md",
+ "bugs": {
+ "url": "https://github.com/superjoe30/node-stream-counter/issues"
+ },
+ "_id": "stream-counter@0.1.0",
+ "dist": {
+ "shasum": "07934d4cd814e5930853f5934b0559861fa5732f"
+ },
+ "_from": "stream-counter@~0.1.0",
+ "_resolved": "https://registry.npmjs.org/stream-counter/-/stream-counter-0.1.0.tgz"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/test/test.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/test/test.js
new file mode 100644
index 000000000..0da95660a
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/test/test.js
@@ -0,0 +1,20 @@
+var ByteCounter = require('../');
+var fs = require('fs');
+var path = require('path');
+var assert = require('assert');
+
+var counter = new ByteCounter();
+var remainingTests = 2;
+counter.once('progress', function() {
+ assert.strictEqual(counter.bytes, 5);
+ remainingTests -= 1;
+});
+var is = fs.createReadStream(path.join(__dirname, 'test.txt'));
+is.pipe(counter);
+is.on('end', function() {
+ remainingTests -= 1;
+ assert.strictEqual(counter.bytes, 5);
+});
+process.on('exit', function() {
+ assert.strictEqual(remainingTests, 0);
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/test/test.txt b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/test/test.txt
new file mode 100644
index 000000000..81c545efe
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/node_modules/stream-counter/test/test.txt
@@ -0,0 +1 @@
+1234
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/package.json b/appshell/node-core/thirdparty/connect/node_modules/multiparty/package.json
new file mode 100644
index 000000000..573a354cb
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/package.json
@@ -0,0 +1,46 @@
+{
+ "name": "multiparty",
+ "version": "2.1.8",
+ "description": "multipart/form-data parser which supports streaming",
+ "repository": {
+ "type": "git",
+ "url": "git@github.com:superjoe30/node-multiparty.git"
+ },
+ "keywords": [
+ "file",
+ "upload",
+ "formidable",
+ "stream",
+ "s3"
+ ],
+ "devDependencies": {
+ "findit": "0.1.1",
+ "hashish": "0.0.4",
+ "mocha": "~1.8.2",
+ "request": "~2.16.6",
+ "mkdirp": "~0.3.5",
+ "superagent": "~0.14.1"
+ },
+ "scripts": {
+ "test": "mocha --reporter spec --recursive test/test.js"
+ },
+ "engines": {
+ "node": ">=0.8.0"
+ },
+ "license": "MIT",
+ "dependencies": {
+ "readable-stream": "~1.0.2",
+ "stream-counter": "~0.1.0"
+ },
+ "readme": "[](https://travis-ci.org/superjoe30/node-multiparty)\n# multiparty\n\nParse http requests with content-type `multipart/form-data`, also known as file uploads.\n\n### Why the fork?\n\n * This module uses the Node.js v0.10 streams properly, *even in Node.js v0.8*\n * It will not create a temp file for you unless you want it to.\n * Counts bytes and does math to help you figure out the `Content-Length` of\n each part.\n * You can easily stream uploads to s3 with\n [knox](https://github.com/LearnBoost/knox), for [example](examples/s3.js).\n * Less bugs. This code is simpler, has all deprecated functionality removed,\n has cleaner tests, and does not try to do anything beyond multipart stream\n parsing.\n\n## Installation\n\n```\nnpm install multiparty\n```\n\n## Usage\n\n * See [examples](examples).\n * Using express or connect? See [connect-multiparty](https://github.com/superjoe30/connect-multiparty)\n\nParse an incoming `multipart/form-data` request.\n\n```js\nvar multiparty = require('multiparty')\n , http = require('http')\n , util = require('util')\n\nhttp.createServer(function(req, res) {\n if (req.url === '/upload' && req.method === 'POST') {\n // parse a file upload\n var form = new multiparty.Form();\n\n form.parse(req, function(err, fields, files) {\n res.writeHead(200, {'content-type': 'text/plain'});\n res.write('received upload:\\n\\n');\n res.end(util.inspect({fields: fields, files: files}));\n });\n\n return;\n }\n\n // show a file upload form\n res.writeHead(200, {'content-type': 'text/html'});\n res.end(\n ''\n );\n}).listen(8080);\n```\n\n## API\n\n### multiparty.Form\n```js\nvar form = new multiparty.Form(options)\n```\nCreates a new form. Options:\n\n * `encoding` - sets encoding for the incoming form fields. Defaults to `utf8`.\n * `maxFieldSize` - Limits the amount of memory a field (not a file) can\n allocate in bytes. If this value is exceeded, an `error` event is emitted.\n The default size is 2MB.\n * `maxFields` - Limits the number of fields that will be parsed before\n emitting an `error` event. A file counts as a field in this case.\n Defaults to 1000.\n * `autoFields` - Enables `field` events. This is automatically set to `true`\n if you add a `field` listener.\n * `autoFiles` - Enables `file` events. This is automatically set to `true`\n if you add a `file` listener.\n * `uploadDir` - Only relevant when `autoFiles` is `true`. The directory for\n placing file uploads in. You can move them later using `fs.rename()`.\n Defaults to `os.tmpDir()`.\n * `hash` - Only relevant when `autoFiles` is `true`. If you want checksums\n calculated for incoming files, set this to either `sha1` or `md5`.\n Defaults to off.\n\n#### form.parse(request, [cb])\n\nParses an incoming node.js `request` containing form data. If `cb` is\nprovided, `autoFields` and `autoFiles` are set to `true` and all fields and\nfiles are collected and passed to the callback:\n\n```js\nform.parse(req, function(err, fields, files) {\n // ...\n});\n```\n\n#### form.bytesReceived\n\nThe amount of bytes received for this form so far.\n\n#### form.bytesExpected\n\nThe expected number of bytes in this form.\n\n### Events\n\n#### 'error' (err)\n\nYou definitely want to handle this event. If not your server *will* crash when\nusers submit bogus multipart requests!\n\n#### 'part' (part)\n\nEmitted when a part is encountered in the request. `part` is a\n`ReadableStream`. It also has the following properties:\n\n * `headers` - the headers for this part. For example, you may be interested\n in `content-type`.\n * `name` - the field name for this part\n * `filename` - only if the part is an incoming file\n * `byteOffset` - the byte offset of this part in the request body\n * `byteCount` - assuming that this is the last part in the request,\n this is the size of this part in bytes. You could use this, for\n example, to set the `Content-Length` header if uploading to S3.\n If the part had a `Content-Length` header then that value is used\n here instead.\n\n#### 'aborted'\n\nEmitted when the request is aborted. This event will be followed shortly\nby an `error` event. In practice you do not need to handle this event.\n\n#### 'progress' (bytesReceived, bytesExpected)\n\n#### 'close'\n\nEmitted after all parts have been parsed and emitted. Not emitted if an `error`\nevent is emitted. This is typically when you would send your response.\n\n#### 'file' (name, file)\n\n**By default multiparty will not touch your hard drive.** But if you add this\nlistener, multiparty automatically sets `form.autoFiles` to `true` and will\nstream uploads to disk for you. \n\n * `name` - the field name for this file\n * `file` - an object with these properties:\n - `originalFilename` - the filename that the user reports for the file\n - `path` - the absolute path of the uploaded file on disk\n - `headers` - the HTTP headers that were sent along with this file\n - `size` - size of the file in bytes\n\nIf you set the `form.hash` option, then `file` will also contain a `hash`\nproperty which is the checksum of the file.\n\n#### 'field' (name, value)\n\n * `name` - field name\n * `value` - string field value\n\n",
+ "readmeFilename": "README.md",
+ "bugs": {
+ "url": "https://github.com/superjoe30/node-multiparty/issues"
+ },
+ "_id": "multiparty@2.1.8",
+ "dist": {
+ "shasum": "25946d5f81f720b7c40574578e8a3c87e41a95e2"
+ },
+ "_from": "multiparty@2.1.8",
+ "_resolved": "https://registry.npmjs.org/multiparty/-/multiparty-2.1.8.tgz"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/bench-multipart-parser.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/bench-multipart-parser.js
new file mode 100644
index 000000000..ee5dbad4d
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/bench-multipart-parser.js
@@ -0,0 +1,76 @@
+var assert = require('assert')
+ , Form = require('../').Form
+ , boundary = '-----------------------------168072824752491622650073'
+ , mb = 100
+ , buffer = createMultipartBuffer(boundary, mb * 1024 * 1024)
+
+var callbacks = {
+ partBegin: -1,
+ partEnd: -1,
+ headerField: -1,
+ headerValue: -1,
+ partData: -1,
+ end: -1,
+};
+
+var form = new Form({ boundary: boundary });
+
+hijack('onParseHeaderField', function() {
+ callbacks.headerField++;
+});
+
+hijack('onParseHeaderValue', function() {
+ callbacks.headerValue++;
+});
+
+hijack('onParsePartBegin', function() {
+ callbacks.partBegin++;
+});
+
+hijack('onParsePartData', function() {
+ callbacks.partData++;
+});
+
+hijack('onParsePartEnd', function() {
+ callbacks.partEnd++;
+});
+
+form.on('finish', function() {
+ callbacks.end++;
+});
+
+var start = new Date();
+form.write(buffer, function(err) {
+ var duration = new Date() - start;
+ assert.ifError(err);
+ var mbPerSec = (mb / (duration / 1000)).toFixed(2);
+ console.log(mbPerSec+' mb/sec');
+});
+
+process.on('exit', function() {
+ for (var k in callbacks) {
+ assert.equal(0, callbacks[k], k+' count off by '+callbacks[k]);
+ }
+});
+
+function createMultipartBuffer(boundary, size) {
+ var head =
+ '--'+boundary+'\r\n' +
+ 'content-disposition: form-data; name="field1"\r\n' +
+ '\r\n'
+ , tail = '\r\n--'+boundary+'--\r\n'
+ , buffer = new Buffer(size);
+
+ buffer.write(head, 'ascii', 0);
+ buffer.write(tail, 'ascii', buffer.length - tail.length);
+ return buffer;
+}
+
+function hijack(name, fn) {
+ var oldFn = form[name];
+ form[name] = function() {
+ fn();
+ return oldFn.apply(this, arguments);
+ };
+}
+
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/beta-sticker-1.png b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/beta-sticker-1.png
new file mode 100644
index 000000000..20b1a7f17
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/beta-sticker-1.png differ
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/binaryfile.tar.gz b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/binaryfile.tar.gz
new file mode 100644
index 000000000..4a85af7a1
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/binaryfile.tar.gz differ
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/blank.gif b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/blank.gif
new file mode 100755
index 000000000..75b945d25
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/blank.gif differ
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/funkyfilename.txt b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/funkyfilename.txt
new file mode 100644
index 000000000..e7a4785e0
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/funkyfilename.txt
@@ -0,0 +1 @@
+I am a text file with a funky name!
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/menu_separator.png b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/menu_separator.png
new file mode 100644
index 000000000..1c16a71ed
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/menu_separator.png differ
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/pf1y5.png b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/pf1y5.png
new file mode 100644
index 000000000..44d601759
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/pf1y5.png differ
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/plain.txt b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/plain.txt
new file mode 100644
index 000000000..9b6903e26
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/file/plain.txt
@@ -0,0 +1 @@
+I am a plain text file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/beta-sticker-1.png.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/beta-sticker-1.png.http
new file mode 100644
index 000000000..7bfc6dcca
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/beta-sticker-1.png.http
@@ -0,0 +1,12 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
+Content-Length: 2483
+
+--\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
+Content-Disposition: form-data; name="sticker"; filename="beta-sticker-1.png"
+Content-Type: image/png
+Content-Transfer-Encoding: base64
+
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
+--\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/binaryfile.tar.gz.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/binaryfile.tar.gz.http
new file mode 100644
index 000000000..28b1d0e69
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/binaryfile.tar.gz.http
@@ -0,0 +1,12 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
+Content-Length: 676
+
+--\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
+Content-Disposition: form-data; name="file"; filename="binaryfile.tar.gz"
+Content-Type: application/x-gzip
+Content-Transfer-Encoding: base64
+
+H4sIAGiNIU8AA+3R0W6CMBQGYK59iobLZantRDG73osUOGqnFNJWM2N897UghG1ZdmWWLf93U/jP4bRAq8q92hJ/dY1J7kQEqyyLq8yXYrp2ltkqkTKXYiEykYc++ZTLVcLEvQ40dXReWcYSV1pdnL/v+6n+R11mjKVG1ZQ+s3TT2FpXqjhQ+hjzE1mnGxNLkgu+7tOKWjIVmVKTC6XL9ZaeXj4VQhwKWzL+cI4zwgQuuhkh3mhTad/Hkssh3im3027X54JnQ360R/M19OT8kC7SEN7Ooi2VvrEfznHQRWzl83gxttZKmzGehzPRW/+W8X+3fvL8sFet9sS6m3EIma02071MU3Uf9KHrmV1/+y8DAAAAAAAAAAAAAAAAAAAAAMB/9A6txIuJACgAAA==
+--\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/blank.gif.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/blank.gif.http
new file mode 100644
index 000000000..cf54956dc
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/blank.gif.http
@@ -0,0 +1,12 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
+Content-Length: 323
+
+--\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
+Content-Disposition: form-data; name="file"; filename="blank.gif"
+Content-Type: image/gif
+Content-Transfer-Encoding: base64
+
+R0lGODlhAQABAJH/AP///wAAAMDAwAAAACH5BAEAAAIALAAAAAABAAEAAAICVAEAOw==
+--\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/menu_seperator.png.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/menu_seperator.png.http
new file mode 100644
index 000000000..3fd5085e7
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/menu_seperator.png.http
@@ -0,0 +1,12 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
+Content-Length: 1509
+
+--\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
+Content-Disposition: form-data; name="image"; filename="menu_separator.png"
+Content-Type: image/png
+Content-Transfer-Encoding: base64
+
+iVBORw0KGgoAAAANSUhEUgAAAAIAAAAYCAIAAABfmbuOAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyJpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6MDcxODNBNzJERDcyMTFFMUFBOEVFNDQzOTA0MDJDMjQiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6MDcxODNBNzNERDcyMTFFMUFBOEVFNDQzOTA0MDJDMjQiPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDowNzE4M0E3MERENzIxMUUxQUE4RUU0NDM5MDQwMkMyNCIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDowNzE4M0E3MURENzIxMUUxQUE4RUU0NDM5MDQwMkMyNCIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/Pmvhbb8AAAAXSURBVHjaYnHk9PON8WJiAIPBSwEEGAAPrgG+VozFWgAAAABJRU5ErkJggg==
+--\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/pf1y5.png.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/pf1y5.png.http
new file mode 100644
index 000000000..20c2c2dfc
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/pf1y5.png.http differ
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/plain.txt.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/plain.txt.http
new file mode 100644
index 000000000..230b2054e
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/encoding/plain.txt.http
@@ -0,0 +1,13 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=----TLV0SrKD4z1TRxRhAPUvZ
+Content-Length: 221
+
+------TLV0SrKD4z1TRxRhAPUvZ
+Content-Disposition: form-data; name="file"; filename="plain.txt"
+Content-Type: text/plain
+Content-Transfer-Encoding: 7bit
+
+I am a plain text file
+
+------TLV0SrKD4z1TRxRhAPUvZ--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/no-filename/filename-name.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/no-filename/filename-name.http
new file mode 100644
index 000000000..e449156bd
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/no-filename/filename-name.http
@@ -0,0 +1,13 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=----WebKitFormBoundarytyE4wkKlZ5CQJVTG
+Content-Length: 1000
+
+------WebKitFormBoundarytyE4wkKlZ5CQJVTG
+Content-Disposition: form-data; filename="plain.txt"; name="upload"
+Content-Type: text/plain
+
+I am a plain text file
+
+------WebKitFormBoundarytyE4wkKlZ5CQJVTG--
+
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/no-filename/generic.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/no-filename/generic.http
new file mode 100644
index 000000000..c051d852c
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/no-filename/generic.http
@@ -0,0 +1,13 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=----WebKitFormBoundarytyE4wkKlZ5CQJVTG
+Content-Length: 1000
+
+------WebKitFormBoundarytyE4wkKlZ5CQJVTG
+Content-Disposition: form-data; name="upload"; filename=""
+Content-Type: text/plain
+
+I am a plain text file
+
+------WebKitFormBoundarytyE4wkKlZ5CQJVTG--
+
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/preamble/crlf.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/preamble/crlf.http
new file mode 100644
index 000000000..1357950a8
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/preamble/crlf.http
@@ -0,0 +1,13 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=----TLV0SrKD4z1TRxRhAPUvZ
+Content-Length: 184
+
+
+------TLV0SrKD4z1TRxRhAPUvZ
+Content-Disposition: form-data; name="upload"; filename="plain.txt"
+Content-Type: text/plain
+
+I am a plain text file
+
+------TLV0SrKD4z1TRxRhAPUvZ--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/preamble/preamble.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/preamble/preamble.http
new file mode 100644
index 000000000..ab490a360
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/preamble/preamble.http
@@ -0,0 +1,13 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=----TLV0SrKD4z1TRxRhAPUvZ
+Content-Length: 226
+
+This is a preamble which should be ignored
+------TLV0SrKD4z1TRxRhAPUvZ
+Content-Disposition: form-data; name="upload"; filename="plain.txt"
+Content-Type: text/plain
+
+I am a plain text file
+
+------TLV0SrKD4z1TRxRhAPUvZ--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/info.md b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/info.md
new file mode 100644
index 000000000..3c9dbe3dd
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/info.md
@@ -0,0 +1,3 @@
+* Opera does not allow submitting this file, it shows a warning to the
+ user that the file could not be found instead. Tested in 9.8, 11.51 on OSX.
+ Reported to Opera on 08.09.2011 (tracking email DSK-346009@bugs.opera.com).
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/osx-chrome-13.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/osx-chrome-13.http
new file mode 100644
index 000000000..6dec0d38c
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/osx-chrome-13.http
@@ -0,0 +1,26 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Connection: keep-alive
+Referer: http://localhost:8080/
+Content-Length: 383
+Cache-Control: max-age=0
+Origin: http://localhost:8080
+User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.220 Safari/535.1
+Content-Type: multipart/form-data; boundary=----WebKitFormBoundarytyE4wkKlZ5CQJVTG
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Encoding: gzip,deflate,sdch
+Accept-Language: en-US,en;q=0.8
+Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3
+Cookie: jqCookieJar_tablesorter=%7B%22showListTable%22%3A%5B%5B5%2C1%5D%2C%5B1%2C0%5D%5D%7D
+
+------WebKitFormBoundarytyE4wkKlZ5CQJVTG
+Content-Disposition: form-data; name="title"
+
+Weird filename
+------WebKitFormBoundarytyE4wkKlZ5CQJVTG
+Content-Disposition: form-data; name="upload"; filename=": \ ? % * | %22 < > . ? ; ' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt"
+Content-Type: text/plain
+
+I am a text file with a funky name!
+
+------WebKitFormBoundarytyE4wkKlZ5CQJVTG--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/osx-firefox-3.6.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/osx-firefox-3.6.http
new file mode 100644
index 000000000..76ff2b34a
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/osx-firefox-3.6.http
@@ -0,0 +1,24 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; en-US; rv:1.9.2.22) Gecko/20110902 Firefox/3.6.22
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-us,en;q=0.5
+Accept-Encoding: gzip,deflate
+Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
+Keep-Alive: 115
+Connection: keep-alive
+Referer: http://localhost:8080/
+Content-Type: multipart/form-data; boundary=---------------------------9849436581144108930470211272
+Content-Length: 438
+
+-----------------------------9849436581144108930470211272
+Content-Disposition: form-data; name="title"
+
+Weird filename
+-----------------------------9849436581144108930470211272
+Content-Disposition: form-data; name="upload"; filename=": \ ? % * | " < > . ☃ ; ' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt"
+Content-Type: text/plain
+
+I am a text file with a funky name!
+
+-----------------------------9849436581144108930470211272--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/osx-safari-5.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/osx-safari-5.http
new file mode 100644
index 000000000..b3652d90e
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/osx-safari-5.http
@@ -0,0 +1,23 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Origin: http://localhost:8080
+Content-Length: 383
+User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_8; en-us) AppleWebKit/533.21.1 (KHTML, like Gecko) Version/5.0.5 Safari/533.21.1
+Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryQJZ1gvhvdgfisJPJ
+Accept: application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5
+Referer: http://localhost:8080/
+Accept-Language: en-us
+Accept-Encoding: gzip, deflate
+Connection: keep-alive
+
+------WebKitFormBoundaryQJZ1gvhvdgfisJPJ
+Content-Disposition: form-data; name="title"
+
+Weird filename
+------WebKitFormBoundaryQJZ1gvhvdgfisJPJ
+Content-Disposition: form-data; name="upload"; filename=": \ ? % * | %22 < > . ? ; ' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt"
+Content-Type: text/plain
+
+I am a text file with a funky name!
+
+------WebKitFormBoundaryQJZ1gvhvdgfisJPJ--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-chrome-12.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-chrome-12.http
new file mode 100644
index 000000000..ef8d1d602
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-chrome-12.http
@@ -0,0 +1,24 @@
+POST /upload HTTP/1.1
+Host: 192.168.56.1:8080
+Connection: keep-alive
+Referer: http://192.168.56.1:8080/
+Content-Length: 344
+Cache-Control: max-age=0
+Origin: http://192.168.56.1:8080
+User-Agent: Mozilla/5.0 (Windows NT 5.1) AppleWebKit/534.30 (KHTML, like Gecko) Chrome/12.0.742.122 Safari/534.30
+Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryEvqBNplR3ByrwQPa
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Encoding: gzip,deflate,sdch
+Accept-Language: de-DE,de;q=0.8,en-US;q=0.6,en;q=0.4
+Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3
+
+------WebKitFormBoundaryEvqBNplR3ByrwQPa
+Content-Disposition: form-data; name="title"
+
+Weird filename
+------WebKitFormBoundaryEvqBNplR3ByrwQPa
+Content-Disposition: form-data; name="upload"; filename=" ? % * | %22 < > . ? ; ' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt"
+Content-Type: text/plain
+
+
+------WebKitFormBoundaryEvqBNplR3ByrwQPa--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-ie-7.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-ie-7.http
new file mode 100644
index 000000000..4befdc711
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-ie-7.http
@@ -0,0 +1,22 @@
+POST /upload HTTP/1.1
+Accept: image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, */*
+Referer: http://192.168.56.1:8080/
+Accept-Language: de
+User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)
+Content-Type: multipart/form-data; boundary=---------------------------7db1fe232017c
+Accept-Encoding: gzip, deflate
+Host: 192.168.56.1:8080
+Content-Length: 368
+Connection: Keep-Alive
+Cache-Control: no-cache
+
+-----------------------------7db1fe232017c
+Content-Disposition: form-data; name="title"
+
+Weird filename
+-----------------------------7db1fe232017c
+Content-Disposition: form-data; name="upload"; filename=" ? % * | " < > . ☃ ; ' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt"
+Content-Type: application/octet-stream
+
+
+-----------------------------7db1fe232017c--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-ie-8.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-ie-8.http
new file mode 100644
index 000000000..9c1c53305
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-ie-8.http
@@ -0,0 +1,22 @@
+POST /upload HTTP/1.1
+Accept: image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, */*
+Referer: http://192.168.56.1:8080/
+Accept-Language: de
+User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)
+Content-Type: multipart/form-data; boundary=---------------------------7db3a8372017c
+Accept-Encoding: gzip, deflate
+Host: 192.168.56.1:8080
+Content-Length: 368
+Connection: Keep-Alive
+Cache-Control: no-cache
+
+-----------------------------7db3a8372017c
+Content-Disposition: form-data; name="title"
+
+Weird filename
+-----------------------------7db3a8372017c
+Content-Disposition: form-data; name="upload"; filename=" ? % * | " < > . ☃ ; ' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt"
+Content-Type: application/octet-stream
+
+
+-----------------------------7db3a8372017c--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-safari-5.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-safari-5.http
new file mode 100644
index 000000000..2b7bacb52
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/special-chars-in-filename/xp-safari-5.http
@@ -0,0 +1,22 @@
+POST /upload HTTP/1.1
+Host: 192.168.56.1:8080
+Referer: http://192.168.56.1:8080/
+Accept: application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5
+Accept-Language: en-US
+Origin: http://192.168.56.1:8080
+User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/533.19.4 (KHTML, like Gecko) Version/5.0.3 Safari/533.19.4
+Accept-Encoding: gzip, deflate
+Content-Type: multipart/form-data; boundary=----WebKitFormBoundarykmaWSUbu697WN9TM
+Content-Length: 344
+Connection: keep-alive
+
+------WebKitFormBoundarykmaWSUbu697WN9TM
+Content-Disposition: form-data; name="title"
+
+Weird filename
+------WebKitFormBoundarykmaWSUbu697WN9TM
+Content-Disposition: form-data; name="upload"; filename=" ? % * | %22 < > . ? ; ' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt"
+Content-Type: text/plain
+
+
+------WebKitFormBoundarykmaWSUbu697WN9TM--
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/workarounds/missing-hyphens1.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/workarounds/missing-hyphens1.http
new file mode 100644
index 000000000..31ea39594
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/workarounds/missing-hyphens1.http
@@ -0,0 +1,12 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=----TLV0SrKD4z1TRxRhAPUvZ
+Content-Length: 178
+
+------TLV0SrKD4z1TRxRhAPUvZ
+Content-Disposition: form-data; name="upload"; filename="plain.txt"
+Content-Type: text/plain
+
+I am a plain text file
+
+------TLV0SrKD4z1TRxRhAPUvZ
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/workarounds/missing-hyphens2.http b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/workarounds/missing-hyphens2.http
new file mode 100644
index 000000000..515f519c2
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/http/workarounds/missing-hyphens2.http
@@ -0,0 +1,12 @@
+POST /upload HTTP/1.1
+Host: localhost:8080
+Content-Type: multipart/form-data; boundary=----TLV0SrKD4z1TRxRhAPUvZ
+Content-Length: 180
+
+------TLV0SrKD4z1TRxRhAPUvZ
+Content-Disposition: form-data; name="upload"; filename="plain.txt"
+Content-Type: text/plain
+
+I am a plain text file
+
+------TLV0SrKD4z1TRxRhAPUvZ
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/encoding.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/encoding.js
new file mode 100644
index 000000000..1ade96568
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/encoding.js
@@ -0,0 +1,69 @@
+module.exports['menu_seperator.png.http'] = [
+ {
+ type: 'file',
+ name: 'image',
+ filename: 'menu_separator.png',
+ fixture: 'menu_separator.png',
+ sha1: 'c845ca3ea794be298f2a1b79769b71939eaf4e54',
+ size: 931,
+ }
+];
+
+module.exports['beta-sticker-1.png.http'] = [
+ {
+ type: 'file',
+ name: 'sticker',
+ filename: 'beta-sticker-1.png',
+ fixture: 'beta-sticker-1.png',
+ sha1: '6abbcffd12b4ada5a6a084fe9e4584f846331bc4',
+ size: 1660,
+ }
+];
+
+module.exports['blank.gif.http'] = [
+ {
+ type: 'file',
+ name: 'file',
+ filename: 'blank.gif',
+ fixture: 'blank.gif',
+ sha1: 'a1fdee122b95748d81cee426d717c05b5174fe96',
+ size: 49,
+ }
+];
+
+module.exports['binaryfile.tar.gz.http'] = [
+ {
+ type: 'file',
+ name: 'file',
+ filename: 'binaryfile.tar.gz',
+ fixture: 'binaryfile.tar.gz',
+ sha1: 'cfabe13b348e5e69287d677860880c52a69d2155',
+ size: 301,
+ }
+];
+
+module.exports['plain.txt.http'] = [
+ {
+ type: 'file',
+ name: 'file',
+ filename: 'plain.txt',
+ fixture: 'plain.txt',
+ sha1: 'b31d07bac24ac32734de88b3687dddb10e976872',
+ size: 23,
+ }
+];
+
+module.exports['pf1y5.png.http'] = [
+ {
+ type: 'field',
+ name: 'path',
+ },
+ {
+ type: 'file',
+ name: 'upload',
+ filename: 'pf1y5.png',
+ fixture: 'pf1y5.png',
+ sha1: '805cc640c5b182e86f2b5c8ebf34ecf063cd34fd',
+ size: 768323,
+ }
+];
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/no-filename.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/no-filename.js
new file mode 100644
index 000000000..f03b4f01d
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/no-filename.js
@@ -0,0 +1,9 @@
+module.exports['generic.http'] = [
+ {type: 'file', name: 'upload', filename: '', fixture: 'plain.txt',
+ sha1: 'b31d07bac24ac32734de88b3687dddb10e976872'},
+];
+
+module.exports['filename-name.http'] = [
+ {type: 'file', name: 'upload', filename: 'plain.txt', fixture: 'plain.txt',
+ sha1: 'b31d07bac24ac32734de88b3687dddb10e976872'},
+];
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/preamble.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/preamble.js
new file mode 100644
index 000000000..d2e4cfdb2
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/preamble.js
@@ -0,0 +1,9 @@
+module.exports['crlf.http'] = [
+ {type: 'file', name: 'upload', filename: 'plain.txt', fixture: 'plain.txt',
+ sha1: 'b31d07bac24ac32734de88b3687dddb10e976872'},
+];
+
+module.exports['preamble.http'] = [
+ {type: 'file', name: 'upload', filename: 'plain.txt', fixture: 'plain.txt',
+ sha1: 'b31d07bac24ac32734de88b3687dddb10e976872'},
+];
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/special-chars-in-filename.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/special-chars-in-filename.js
new file mode 100644
index 000000000..aa0b79f34
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/special-chars-in-filename.js
@@ -0,0 +1,30 @@
+var properFilename = 'funkyfilename.txt';
+
+function expect(filename) {
+ return [
+ {
+ type: 'field',
+ name: 'title',
+ value: 'Weird filename',
+ },
+ {
+ type: 'file',
+ name: 'upload',
+ filename: filename,
+ fixture: properFilename,
+ },
+ ];
+}
+
+var webkit = " ? % * | \" < > . ? ; ' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt";
+var ffOrIe = " ? % * | \" < > . ☃ ; ' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt";
+
+module.exports = {
+ 'osx-chrome-13.http' : expect(webkit),
+ 'osx-firefox-3.6.http' : expect(ffOrIe),
+ 'osx-safari-5.http' : expect(webkit),
+ 'xp-chrome-12.http' : expect(webkit),
+ 'xp-ie-7.http' : expect(ffOrIe),
+ 'xp-ie-8.http' : expect(ffOrIe),
+ 'xp-safari-5.http' : expect(webkit),
+};
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/workarounds.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/workarounds.js
new file mode 100644
index 000000000..e59c5b265
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/js/workarounds.js
@@ -0,0 +1,8 @@
+module.exports['missing-hyphens1.http'] = [
+ {type: 'file', name: 'upload', filename: 'plain.txt', fixture: 'plain.txt',
+ sha1: 'b31d07bac24ac32734de88b3687dddb10e976872'},
+];
+module.exports['missing-hyphens2.http'] = [
+ {type: 'file', name: 'upload', filename: 'plain.txt', fixture: 'plain.txt',
+ sha1: 'b31d07bac24ac32734de88b3687dddb10e976872'},
+];
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/multi_video.upload b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/multi_video.upload
new file mode 100644
index 000000000..9c82ba366
Binary files /dev/null and b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/multi_video.upload differ
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/multipart.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/multipart.js
new file mode 100644
index 000000000..a4761699e
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/fixture/multipart.js
@@ -0,0 +1,72 @@
+exports['rfc1867'] =
+ { boundary: 'AaB03x',
+ raw:
+ '--AaB03x\r\n'+
+ 'content-disposition: form-data; name="field1"\r\n'+
+ '\r\n'+
+ 'Joe Blow\r\nalmost tricked you!\r\n'+
+ '--AaB03x\r\n'+
+ 'content-disposition: form-data; name="pics"; filename="file1.txt"\r\n'+
+ 'Content-Type: text/plain\r\n'+
+ '\r\n'+
+ '... contents of file1.txt ...\r\r\n'+
+ '--AaB03x--\r\n',
+ parts:
+ [ { headers: {
+ 'content-disposition': 'form-data; name="field1"',
+ },
+ data: 'Joe Blow\r\nalmost tricked you!',
+ },
+ { headers: {
+ 'content-disposition': 'form-data; name="pics"; filename="file1.txt"',
+ 'Content-Type': 'text/plain',
+ },
+ data: '... contents of file1.txt ...\r',
+ }
+ ]
+ };
+
+exports['noTrailing\r\n'] =
+ { boundary: 'AaB03x',
+ raw:
+ '--AaB03x\r\n'+
+ 'content-disposition: form-data; name="field1"\r\n'+
+ '\r\n'+
+ 'Joe Blow\r\nalmost tricked you!\r\n'+
+ '--AaB03x\r\n'+
+ 'content-disposition: form-data; name="pics"; filename="file1.txt"\r\n'+
+ 'Content-Type: text/plain\r\n'+
+ '\r\n'+
+ '... contents of file1.txt ...\r\r\n'+
+ '--AaB03x--',
+ parts:
+ [ { headers: {
+ 'content-disposition': 'form-data; name="field1"',
+ },
+ data: 'Joe Blow\r\nalmost tricked you!',
+ },
+ { headers: {
+ 'content-disposition': 'form-data; name="pics"; filename="file1.txt"',
+ 'Content-Type': 'text/plain',
+ },
+ data: '... contents of file1.txt ...\r',
+ }
+ ]
+ };
+
+exports['emptyHeader'] =
+ { boundary: 'AaB03x',
+ raw:
+ '--AaB03x\r\n'+
+ 'content-disposition: form-data; name="field1"\r\n'+
+ ': foo\r\n'+
+ '\r\n'+
+ 'Joe Blow\r\nalmost tricked you!\r\n'+
+ '--AaB03x\r\n'+
+ 'content-disposition: form-data; name="pics"; filename="file1.txt"\r\n'+
+ 'Content-Type: text/plain\r\n'+
+ '\r\n'+
+ '... contents of file1.txt ...\r\r\n'+
+ '--AaB03x--\r\n',
+ expectError: true,
+ };
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/record.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/record.js
new file mode 100644
index 000000000..9f1cef86f
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/record.js
@@ -0,0 +1,47 @@
+var http = require('http');
+var fs = require('fs');
+var connections = 0;
+
+var server = http.createServer(function(req, res) {
+ var socket = req.socket;
+ console.log('Request: %s %s -> %s', req.method, req.url, socket.filename);
+
+ req.on('end', function() {
+ if (req.url !== '/') {
+ res.end(JSON.stringify({
+ method: req.method,
+ url: req.url,
+ filename: socket.filename,
+ }));
+ return;
+ }
+
+ res.writeHead(200, {'content-type': 'text/html'});
+ res.end(
+ ''
+ );
+ });
+});
+
+server.on('connection', function(socket) {
+ connections++;
+
+ socket.id = connections;
+ socket.filename = 'connection-' + socket.id + '.http';
+ socket.file = fs.createWriteStream(socket.filename);
+ socket.pipe(socket.file);
+
+ console.log('--> %s', socket.filename);
+ socket.on('close', function() {
+ console.log('<-- %s', socket.filename);
+ });
+});
+
+var port = process.env.PORT || 8080;
+server.listen(port, function() {
+ console.log('Recording connections on port %s', port);
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-connection-aborted.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-connection-aborted.js
new file mode 100644
index 000000000..bd83e1d6b
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-connection-aborted.js
@@ -0,0 +1,27 @@
+var assert = require('assert');
+var http = require('http');
+var net = require('net');
+var multiparty = require('../../');
+
+var server = http.createServer(function (req, res) {
+ var form = new multiparty.Form();
+ var aborted_received = false;
+ form.on('aborted', function () {
+ aborted_received = true;
+ });
+ form.on('error', function () {
+ assert(aborted_received, 'Error event should follow aborted');
+ server.close();
+ });
+ form.on('end', function () {
+ throw new Error('Unexpected "end" event');
+ });
+ form.parse(req);
+}).listen(0, 'localhost', function () {
+ var client = net.connect(server.address().port);
+ client.write(
+ "POST / HTTP/1.1\r\n" +
+ "Content-Length: 70\r\n" +
+ "Content-Type: multipart/form-data; boundary=foo\r\n\r\n");
+ client.end();
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-content-transfer-encoding.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-content-transfer-encoding.js
new file mode 100644
index 000000000..35e5a1f84
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-content-transfer-encoding.js
@@ -0,0 +1,52 @@
+var assert = require('assert')
+ , multiparty = require('../../')
+ , http = require('http')
+ , path = require('path')
+ , TMP_PATH = path.join(__dirname, '..', 'tmp')
+
+var server = http.createServer(function(req, res) {
+ var form = new multiparty.Form();
+ form.uploadDir = TMP_PATH;
+ form.on('close', function () {
+ throw new Error('Unexpected "close" event');
+ });
+ form.on('end', function () {
+ throw new Error('Unexpected "end" event');
+ });
+ form.on('error', function (e) {
+ res.writeHead(500);
+ res.end(e.message);
+ });
+ form.parse(req);
+});
+
+server.listen(0, function() {
+ var body =
+ '--foo\r\n' +
+ 'Content-Disposition: form-data; name="file1"; filename="file1"\r\n' +
+ 'Content-Type: application/octet-stream\r\n' +
+ '\r\nThis is the first file\r\n' +
+ '--foo\r\n' +
+ 'Content-Type: application/octet-stream\r\n' +
+ 'Content-Disposition: form-data; name="file2"; filename="file2"\r\n' +
+ 'Content-Transfer-Encoding: unknown\r\n' +
+ '\r\nThis is the second file\r\n' +
+ '--foo--\r\n';
+
+ var req = http.request({
+ method: 'POST',
+ port: server.address().port,
+ headers: {
+ 'Content-Length': body.length,
+ 'Content-Type': 'multipart/form-data; boundary=foo'
+ }
+ });
+ req.on('response', function (res) {
+ assert.equal(res.statusCode, 500);
+ res.on('data', function () {});
+ res.on('end', function () {
+ server.close();
+ });
+ });
+ req.end(body);
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-invalid.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-invalid.js
new file mode 100644
index 000000000..ede541da5
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-invalid.js
@@ -0,0 +1,35 @@
+var superagent = require('superagent')
+ , multiparty = require('../../')
+ , http = require('http')
+
+var server = http.createServer(function(req, resp) {
+ var form = new multiparty.Form();
+
+ var errCount = 0;
+ form.on('error', function(err) {
+ errCount += 1;
+ resp.end();
+ });
+ form.on('file', function(name, file) {
+ });
+ form.on('field', function(name, file) {
+ });
+
+ form.parse(req);
+});
+server.listen(function() {
+ var url = 'http://localhost:' + server.address().port + '/'
+ var req = superagent.post(url)
+ req.set('Content-Type', 'multipart/form-data; boundary=foo')
+ req.write('--foo\r\n')
+ req.write('Content-filename="foo.txt"\r\n')
+ req.write('\r\n')
+ req.write('some text here')
+ req.write('Content-Disposition: form-data; name="text"; filename="bar.txt"\r\n')
+ req.write('\r\n')
+ req.write('some more text stuff')
+ req.write('\r\n--foo--')
+ req.end(function(err, resp) {
+ server.close();
+ });
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-issue-4.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-issue-4.js
new file mode 100644
index 000000000..66b2a6900
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-issue-4.js
@@ -0,0 +1,51 @@
+var http = require('http')
+ , multiparty = require('../../')
+ , assert = require('assert')
+ , superagent = require('superagent')
+ , path = require('path')
+
+var server = http.createServer(function(req, res) {
+ assert.strictEqual(req.url, '/upload');
+ assert.strictEqual(req.method, 'POST');
+
+ var form = new multiparty.Form({autoFields:true,autoFiles:true});
+
+ form.on('error', function(err) {
+ console.log(err);
+ });
+
+ form.on('close', function() {
+ });
+
+ var fileCount = 0;
+ form.on('file', function(name, file) {
+ fileCount += 1;
+ });
+
+ form.parse(req, function(err, fields, files) {
+ var objFileCount = 0;
+ for (var file in files) {
+ objFileCount += 1;
+ }
+ // multiparty does NOT try to do intelligent things based on
+ // the part name.
+ assert.strictEqual(fileCount, 2);
+ assert.strictEqual(objFileCount, 1);
+ res.end();
+ });
+});
+server.listen(function() {
+ var url = 'http://localhost:' + server.address().port + '/upload';
+ var req = superagent.post(url);
+ req.attach('files[]', fixture('pf1y5.png'), 'SOG2.JPG');
+ req.attach('files[]', fixture('binaryfile.tar.gz'), 'BenF364_LIB353.zip');
+ req.end(function(err, resp) {
+ assert.ifError(err);
+ resp.on('end', function() {
+ server.close();
+ });
+ });
+});
+function fixture(name) {
+ return path.join(__dirname, '..', 'fixture', 'file', name)
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-issue-46.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-issue-46.js
new file mode 100644
index 000000000..676b87094
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/standalone/test-issue-46.js
@@ -0,0 +1,49 @@
+var http = require('http'),
+ multiparty = require('../../'),
+ request = require('request'),
+ assert = require('assert');
+
+var host = 'localhost';
+
+var index = [
+ ''
+].join("\n");
+
+var server = http.createServer(function(req, res) {
+
+ // Show a form for testing purposes.
+ if (req.method === 'GET') {
+ res.writeHead(200, {'content-type': 'text/html'});
+ res.end(index);
+ return;
+ }
+
+ // Parse form and write results to response.
+ var form = new multiparty.Form();
+ form.parse(req, function(err, fields, files) {
+ res.writeHead(200, {'content-type': 'text/plain'});
+ res.write(JSON.stringify({err: err, fields: fields, files: files}));
+ res.end();
+ });
+
+}).listen(0, host, function() {
+
+ //console.log("Server up and running...");
+
+ var server = this,
+ url = 'http://' + host + ':' + server.address().port;
+
+ var parts = [
+ {'Content-Disposition': 'form-data; name="foo"', 'body': 'bar'}
+ ]
+
+ var req = request({method: 'POST', url: url, multipart: parts}, function(e, res, body) {
+ var obj = JSON.parse(body);
+ assert.equal("bar", obj.fields.foo);
+ server.close();
+ });
+
+});
diff --git a/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/test.js b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/test.js
new file mode 100644
index 000000000..199d5cddc
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/multiparty/test/test.js
@@ -0,0 +1,117 @@
+var spawn = require('child_process').spawn
+ , findit = require('findit')
+ , path = require('path')
+ , hashish = require('hashish')
+ , fs = require('fs')
+ , http = require('http')
+ , net = require('net')
+ , assert = require('assert')
+ , multiparty = require('../')
+ , mkdirp = require('mkdirp')
+ , STANDALONE_PATH = path.join(__dirname, 'standalone')
+ , server = http.createServer()
+ , PORT = 13532
+ , FIXTURE_PATH = path.join(__dirname, 'fixture')
+ , TMP_PATH = path.join(__dirname, 'tmp')
+
+mkdirp.sync(TMP_PATH);
+
+describe("fixtures", function() {
+ before(function(done) {
+ server.listen(PORT, done);
+ });
+ var fixtures = [];
+ findit
+ .sync(path.join(FIXTURE_PATH, 'js'))
+ .forEach(function(jsPath) {
+ if (!/\.js$/.test(jsPath)) return;
+ var group = path.basename(jsPath, '.js');
+ hashish.forEach(require(jsPath), function(fixture, name) {
+ it(group + '/' + name, createTest({
+ name : group + '/' + name,
+ fixture : fixture,
+ }));
+ });
+ });
+});
+
+describe("standalone", function() {
+ findit
+ .sync(STANDALONE_PATH)
+ .forEach(function(jsPath) {
+ if (!/\.js$/.test(jsPath)) return;
+ it(path.basename(jsPath, '.js'), function(done) {
+ var child = spawn(process.execPath, [jsPath], { stdio: 'inherit' });
+ child.on('error', function(err) {
+ done(err);
+ });
+ child.on('exit', function(code) {
+ if (code) return done(new Error("exited with code " + code));
+ done();
+ });
+ });
+ });
+});
+
+function createTest(fixture) {
+ var name = fixture.name;
+ fixture = fixture.fixture;
+ return function(done) {
+ uploadFixture(name, function(err, parts) {
+ if (err) return done(err);
+ fixture.forEach(function(expectedPart, i) {
+ var parsedPart = parts[i];
+ assert.equal(parsedPart.type, expectedPart.type);
+ assert.equal(parsedPart.name, expectedPart.name);
+
+ if (parsedPart.type === 'file') {
+ var file = parsedPart.value;
+ assert.equal(file.originalFilename, expectedPart.filename);
+ if(expectedPart.sha1) assert.strictEqual(file.hash, expectedPart.sha1);
+ if(expectedPart.size) assert.strictEqual(file.size, expectedPart.size);
+ }
+ });
+ done();
+ });
+ };
+
+}
+
+function uploadFixture(name, cb) {
+ server.once('request', function(req, res) {
+ var parts = [];
+ var form = new multiparty.Form({
+ autoFields: true,
+ autoFiles: true,
+ });
+ form.uploadDir = TMP_PATH;
+ form.hash = "sha1";
+
+ form.on('error', callback);
+ form.on('file', function(name, value) {
+ parts.push({type: 'file', name: name, value: value});
+ });
+ form.on('field', function(name, value) {
+ parts.push({type: 'field', name: name, value: value});
+ });
+ form.on('close', function() {
+ res.end('OK');
+ callback(null, parts);
+ });
+ form.parse(req);
+
+ function callback() {
+ var realCallback = cb;
+ cb = function() {};
+ realCallback.apply(null, arguments);
+ }
+ });
+
+ var socket = net.createConnection(PORT);
+ var file = fs.createReadStream(FIXTURE_PATH + '/http/' + name);
+
+ file.pipe(socket, {end: false});
+ socket.on('data', function () {
+ socket.end();
+ });
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/pause/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/pause/.npmignore
new file mode 100644
index 000000000..f1250e584
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/pause/.npmignore
@@ -0,0 +1,4 @@
+support
+test
+examples
+*.sock
diff --git a/appshell/node-core/thirdparty/connect/node_modules/pause/History.md b/appshell/node-core/thirdparty/connect/node_modules/pause/History.md
new file mode 100644
index 000000000..c8aa68fa8
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/pause/History.md
@@ -0,0 +1,5 @@
+
+0.0.1 / 2010-01-03
+==================
+
+ * Initial release
diff --git a/appshell/node-core/thirdparty/connect/node_modules/pause/Readme.md b/appshell/node-core/thirdparty/connect/node_modules/pause/Readme.md
new file mode 100644
index 000000000..1cdd68a2a
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/pause/Readme.md
@@ -0,0 +1,29 @@
+
+# pause
+
+ Pause streams...
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+
+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.
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/pause/index.js b/appshell/node-core/thirdparty/connect/node_modules/pause/index.js
new file mode 100644
index 000000000..1b7b37948
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/pause/index.js
@@ -0,0 +1,29 @@
+
+module.exports = function(obj){
+ var onData
+ , onEnd
+ , events = [];
+
+ // buffer data
+ obj.on('data', onData = function(data, encoding){
+ events.push(['data', data, encoding]);
+ });
+
+ // buffer end
+ obj.on('end', onEnd = function(data, encoding){
+ events.push(['end', data, encoding]);
+ });
+
+ return {
+ end: function(){
+ obj.removeListener('data', onData);
+ obj.removeListener('end', onEnd);
+ },
+ resume: function(){
+ this.end();
+ for (var i = 0, len = events.length; i < len; ++i) {
+ obj.emit.apply(obj, events[i]);
+ }
+ }
+ };
+};
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/pause/package.json b/appshell/node-core/thirdparty/connect/node_modules/pause/package.json
new file mode 100644
index 000000000..73cfe4009
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/pause/package.json
@@ -0,0 +1,20 @@
+{
+ "name": "pause",
+ "version": "0.0.1",
+ "description": "Pause streams...",
+ "keywords": [],
+ "author": {
+ "name": "TJ Holowaychuk",
+ "email": "tj@vision-media.ca"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "mocha": "*",
+ "should": "*"
+ },
+ "main": "index",
+ "readme": "\n# pause\n\n Pause streams...\n\n## License \n\n(The MIT License)\n\nCopyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",
+ "readmeFilename": "Readme.md",
+ "_id": "pause@0.0.1",
+ "_from": "pause@0.0.1"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/qs/.gitmodules b/appshell/node-core/thirdparty/connect/node_modules/qs/.gitmodules
new file mode 100644
index 000000000..49e31dac7
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/qs/.gitmodules
@@ -0,0 +1,6 @@
+[submodule "support/expresso"]
+ path = support/expresso
+ url = git://github.com/visionmedia/expresso.git
+[submodule "support/should"]
+ path = support/should
+ url = git://github.com/visionmedia/should.js.git
diff --git a/appshell/node-core/thirdparty/connect/node_modules/qs/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/qs/.npmignore
new file mode 100644
index 000000000..e85ce2afa
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/qs/.npmignore
@@ -0,0 +1,7 @@
+test
+.travis.yml
+benchmark.js
+component.json
+examples.js
+History.md
+Makefile
diff --git a/appshell/node-core/thirdparty/connect/node_modules/qs/Readme.md b/appshell/node-core/thirdparty/connect/node_modules/qs/Readme.md
new file mode 100644
index 000000000..27e54a4af
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/qs/Readme.md
@@ -0,0 +1,58 @@
+# node-querystring
+
+ query string parser for node and the browser supporting nesting, as it was removed from `0.3.x`, so this library provides the previous and commonly desired behaviour (and twice as fast). Used by [express](http://expressjs.com), [connect](http://senchalabs.github.com/connect) and others.
+
+## Installation
+
+ $ npm install qs
+
+## Examples
+
+```js
+var qs = require('qs');
+
+qs.parse('user[name][first]=Tobi&user[email]=tobi@learnboost.com');
+// => { user: { name: { first: 'Tobi' }, email: 'tobi@learnboost.com' } }
+
+qs.stringify({ user: { name: 'Tobi', email: 'tobi@learnboost.com' }})
+// => user[name]=Tobi&user[email]=tobi%40learnboost.com
+```
+
+## Testing
+
+Install dev dependencies:
+
+ $ npm install -d
+
+and execute:
+
+ $ make test
+
+browser:
+
+ $ open test/browser/index.html
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2010 TJ Holowaychuk <tj@vision-media.ca>
+
+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.
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/qs/index.js b/appshell/node-core/thirdparty/connect/node_modules/qs/index.js
new file mode 100644
index 000000000..590491e31
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/qs/index.js
@@ -0,0 +1,387 @@
+/**
+ * Object#toString() ref for stringify().
+ */
+
+var toString = Object.prototype.toString;
+
+/**
+ * Object#hasOwnProperty ref
+ */
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/**
+ * Array#indexOf shim.
+ */
+
+var indexOf = typeof Array.prototype.indexOf === 'function'
+ ? function(arr, el) { return arr.indexOf(el); }
+ : function(arr, el) {
+ for (var i = 0; i < arr.length; i++) {
+ if (arr[i] === el) return i;
+ }
+ return -1;
+ };
+
+/**
+ * Array.isArray shim.
+ */
+
+var isArray = Array.isArray || function(arr) {
+ return toString.call(arr) == '[object Array]';
+};
+
+/**
+ * Object.keys shim.
+ */
+
+var objectKeys = Object.keys || function(obj) {
+ var ret = [];
+ for (var key in obj) ret.push(key);
+ return ret;
+};
+
+/**
+ * Array#forEach shim.
+ */
+
+var forEach = typeof Array.prototype.forEach === 'function'
+ ? function(arr, fn) { return arr.forEach(fn); }
+ : function(arr, fn) {
+ for (var i = 0; i < arr.length; i++) fn(arr[i]);
+ };
+
+/**
+ * Array#reduce shim.
+ */
+
+var reduce = function(arr, fn, initial) {
+ if (typeof arr.reduce === 'function') return arr.reduce(fn, initial);
+ var res = initial;
+ for (var i = 0; i < arr.length; i++) res = fn(res, arr[i]);
+ return res;
+};
+
+/**
+ * Create a nullary object if possible
+ */
+
+function createObject() {
+ return Object.create
+ ? Object.create(null)
+ : {};
+}
+
+/**
+ * Cache non-integer test regexp.
+ */
+
+var isint = /^[0-9]+$/;
+
+function promote(parent, key) {
+ if (parent[key].length == 0) return parent[key] = createObject();
+ var t = createObject();
+ for (var i in parent[key]) {
+ if (hasOwnProperty.call(parent[key], i)) {
+ t[i] = parent[key][i];
+ }
+ }
+ parent[key] = t;
+ return t;
+}
+
+function parse(parts, parent, key, val) {
+ var part = parts.shift();
+ // end
+ if (!part) {
+ if (isArray(parent[key])) {
+ parent[key].push(val);
+ } else if ('object' == typeof parent[key]) {
+ parent[key] = val;
+ } else if ('undefined' == typeof parent[key]) {
+ parent[key] = val;
+ } else {
+ parent[key] = [parent[key], val];
+ }
+ // array
+ } else {
+ var obj = parent[key] = parent[key] || [];
+ if (']' == part) {
+ if (isArray(obj)) {
+ if ('' != val) obj.push(val);
+ } else if ('object' == typeof obj) {
+ obj[objectKeys(obj).length] = val;
+ } else {
+ obj = parent[key] = [parent[key], val];
+ }
+ // prop
+ } else if (~indexOf(part, ']')) {
+ part = part.substr(0, part.length - 1);
+ if (!isint.test(part) && isArray(obj)) obj = promote(parent, key);
+ parse(parts, obj, part, val);
+ // key
+ } else {
+ if (!isint.test(part) && isArray(obj)) obj = promote(parent, key);
+ parse(parts, obj, part, val);
+ }
+ }
+}
+
+/**
+ * Merge parent key/val pair.
+ */
+
+function merge(parent, key, val){
+ if (~indexOf(key, ']')) {
+ var parts = key.split('[')
+ , len = parts.length
+ , last = len - 1;
+ parse(parts, parent, 'base', val);
+ // optimize
+ } else {
+ if (!isint.test(key) && isArray(parent.base)) {
+ var t = createObject();
+ for (var k in parent.base) t[k] = parent.base[k];
+ parent.base = t;
+ }
+ set(parent.base, key, val);
+ }
+
+ return parent;
+}
+
+/**
+ * Compact sparse arrays.
+ */
+
+function compact(obj) {
+ if ('object' != typeof obj) return obj;
+
+ if (isArray(obj)) {
+ var ret = [];
+
+ for (var i in obj) {
+ if (hasOwnProperty.call(obj, i)) {
+ ret.push(obj[i]);
+ }
+ }
+
+ return ret;
+ }
+
+ for (var key in obj) {
+ obj[key] = compact(obj[key]);
+ }
+
+ return obj;
+}
+
+/**
+ * Restore Object.prototype.
+ * see pull-request #58
+ */
+
+function restoreProto(obj) {
+ if (!Object.create) return obj;
+ if (isArray(obj)) return obj;
+ if (obj && 'object' != typeof obj) return obj;
+
+ for (var key in obj) {
+ if (hasOwnProperty.call(obj, key)) {
+ obj[key] = restoreProto(obj[key]);
+ }
+ }
+
+ obj.__proto__ = Object.prototype;
+ return obj;
+}
+
+/**
+ * Parse the given obj.
+ */
+
+function parseObject(obj){
+ var ret = { base: {} };
+
+ forEach(objectKeys(obj), function(name){
+ merge(ret, name, obj[name]);
+ });
+
+ return compact(ret.base);
+}
+
+/**
+ * Parse the given str.
+ */
+
+function parseString(str){
+ var ret = reduce(String(str).split('&'), function(ret, pair){
+ var eql = indexOf(pair, '=')
+ , brace = lastBraceInKey(pair)
+ , key = pair.substr(0, brace || eql)
+ , val = pair.substr(brace || eql, pair.length)
+ , val = val.substr(indexOf(val, '=') + 1, val.length);
+
+ // ?foo
+ if ('' == key) key = pair, val = '';
+ if ('' == key) return ret;
+
+ return merge(ret, decode(key), decode(val));
+ }, { base: createObject() }).base;
+
+ return restoreProto(compact(ret));
+}
+
+/**
+ * Parse the given query `str` or `obj`, returning an object.
+ *
+ * @param {String} str | {Object} obj
+ * @return {Object}
+ * @api public
+ */
+
+exports.parse = function(str){
+ if (null == str || '' == str) return {};
+ return 'object' == typeof str
+ ? parseObject(str)
+ : parseString(str);
+};
+
+/**
+ * Turn the given `obj` into a query string
+ *
+ * @param {Object} obj
+ * @return {String}
+ * @api public
+ */
+
+var stringify = exports.stringify = function(obj, prefix) {
+ if (isArray(obj)) {
+ return stringifyArray(obj, prefix);
+ } else if ('[object Object]' == toString.call(obj)) {
+ return stringifyObject(obj, prefix);
+ } else if ('string' == typeof obj) {
+ return stringifyString(obj, prefix);
+ } else {
+ return prefix + '=' + encodeURIComponent(String(obj));
+ }
+};
+
+/**
+ * Stringify the given `str`.
+ *
+ * @param {String} str
+ * @param {String} prefix
+ * @return {String}
+ * @api private
+ */
+
+function stringifyString(str, prefix) {
+ if (!prefix) throw new TypeError('stringify expects an object');
+ return prefix + '=' + encodeURIComponent(str);
+}
+
+/**
+ * Stringify the given `arr`.
+ *
+ * @param {Array} arr
+ * @param {String} prefix
+ * @return {String}
+ * @api private
+ */
+
+function stringifyArray(arr, prefix) {
+ var ret = [];
+ if (!prefix) throw new TypeError('stringify expects an object');
+ for (var i = 0; i < arr.length; i++) {
+ ret.push(stringify(arr[i], prefix + '[' + i + ']'));
+ }
+ return ret.join('&');
+}
+
+/**
+ * Stringify the given `obj`.
+ *
+ * @param {Object} obj
+ * @param {String} prefix
+ * @return {String}
+ * @api private
+ */
+
+function stringifyObject(obj, prefix) {
+ var ret = []
+ , keys = objectKeys(obj)
+ , key;
+
+ for (var i = 0, len = keys.length; i < len; ++i) {
+ key = keys[i];
+ if ('' == key) continue;
+ if (null == obj[key]) {
+ ret.push(encodeURIComponent(key) + '=');
+ } else {
+ ret.push(stringify(obj[key], prefix
+ ? prefix + '[' + encodeURIComponent(key) + ']'
+ : encodeURIComponent(key)));
+ }
+ }
+
+ return ret.join('&');
+}
+
+/**
+ * Set `obj`'s `key` to `val` respecting
+ * the weird and wonderful syntax of a qs,
+ * where "foo=bar&foo=baz" becomes an array.
+ *
+ * @param {Object} obj
+ * @param {String} key
+ * @param {String} val
+ * @api private
+ */
+
+function set(obj, key, val) {
+ var v = obj[key];
+ if (undefined === v) {
+ obj[key] = val;
+ } else if (isArray(v)) {
+ v.push(val);
+ } else {
+ obj[key] = [v, val];
+ }
+}
+
+/**
+ * Locate last brace in `str` within the key.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function lastBraceInKey(str) {
+ var len = str.length
+ , brace
+ , c;
+ for (var i = 0; i < len; ++i) {
+ c = str[i];
+ if (']' == c) brace = false;
+ if ('[' == c) brace = true;
+ if ('=' == c && !brace) return i;
+ }
+}
+
+/**
+ * Decode `str`.
+ *
+ * @param {String} str
+ * @return {String}
+ * @api private
+ */
+
+function decode(str) {
+ try {
+ return decodeURIComponent(str.replace(/\+/g, ' '));
+ } catch (err) {
+ return str;
+ }
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/qs/package.json b/appshell/node-core/thirdparty/connect/node_modules/qs/package.json
new file mode 100644
index 000000000..c11401b16
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/qs/package.json
@@ -0,0 +1,37 @@
+{
+ "name": "qs",
+ "description": "querystring parser",
+ "version": "0.6.5",
+ "keywords": [
+ "query string",
+ "parser",
+ "component"
+ ],
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/visionmedia/node-querystring.git"
+ },
+ "devDependencies": {
+ "mocha": "*",
+ "expect.js": "*"
+ },
+ "scripts": {
+ "test": "make test"
+ },
+ "author": {
+ "name": "TJ Holowaychuk",
+ "email": "tj@vision-media.ca",
+ "url": "http://tjholowaychuk.com"
+ },
+ "main": "index",
+ "engines": {
+ "node": "*"
+ },
+ "readme": "# node-querystring\n\n query string parser for node and the browser supporting nesting, as it was removed from `0.3.x`, so this library provides the previous and commonly desired behaviour (and twice as fast). Used by [express](http://expressjs.com), [connect](http://senchalabs.github.com/connect) and others.\n\n## Installation\n\n $ npm install qs\n\n## Examples\n\n```js\nvar qs = require('qs');\n\nqs.parse('user[name][first]=Tobi&user[email]=tobi@learnboost.com');\n// => { user: { name: { first: 'Tobi' }, email: 'tobi@learnboost.com' } }\n\nqs.stringify({ user: { name: 'Tobi', email: 'tobi@learnboost.com' }})\n// => user[name]=Tobi&user[email]=tobi%40learnboost.com\n```\n\n## Testing\n\nInstall dev dependencies:\n\n $ npm install -d\n\nand execute:\n\n $ make test\n\nbrowser:\n\n $ open test/browser/index.html\n\n## License \n\n(The MIT License)\n\nCopyright (c) 2010 TJ Holowaychuk <tj@vision-media.ca>\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",
+ "readmeFilename": "Readme.md",
+ "bugs": {
+ "url": "https://github.com/visionmedia/node-querystring/issues"
+ },
+ "_id": "qs@0.6.5",
+ "_from": "qs@0.6.5"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/send/.npmignore
new file mode 100644
index 000000000..f1250e584
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/.npmignore
@@ -0,0 +1,4 @@
+support
+test
+examples
+*.sock
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/History.md b/appshell/node-core/thirdparty/connect/node_modules/send/History.md
new file mode 100644
index 000000000..55c4af745
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/History.md
@@ -0,0 +1,40 @@
+
+0.1.4 / 2013-08-11
+==================
+
+ * update fresh
+
+0.1.3 / 2013-07-08
+==================
+
+ * Revert "Fix fd leak"
+
+0.1.2 / 2013-07-03
+==================
+
+ * Fix fd leak
+
+0.1.0 / 2012-08-25
+==================
+
+ * add options parameter to send() that is passed to fs.createReadStream() [kanongil]
+
+0.0.4 / 2012-08-16
+==================
+
+ * allow custom "Accept-Ranges" definition
+
+0.0.3 / 2012-07-16
+==================
+
+ * fix normalization of the root directory. Closes #3
+
+0.0.2 / 2012-07-09
+==================
+
+ * add passing of req explicitly for now (YUCK)
+
+0.0.1 / 2010-01-03
+==================
+
+ * Initial release
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/Readme.md b/appshell/node-core/thirdparty/connect/node_modules/send/Readme.md
new file mode 100644
index 000000000..ea7b23410
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/Readme.md
@@ -0,0 +1,128 @@
+# send
+
+ Send is Connect's `static()` extracted for generalized use, a streaming static file
+ server supporting partial responses (Ranges), conditional-GET negotiation, high test coverage, and granular events which may be leveraged to take appropriate actions in your application or framework.
+
+## Installation
+
+ $ npm install send
+
+## Examples
+
+ Small:
+
+```js
+var http = require('http');
+var send = require('send');
+
+var app = http.createServer(function(req, res){
+ send(req, req.url).pipe(res);
+}).listen(3000);
+```
+
+ Serving from a root directory with custom error-handling:
+
+```js
+var http = require('http');
+var send = require('send');
+var url = require('url');
+
+var app = http.createServer(function(req, res){
+ // your custom error-handling logic:
+ function error(err) {
+ res.statusCode = err.status || 500;
+ res.end(err.message);
+ }
+
+ // your custom directory handling logic:
+ function redirect() {
+ res.statusCode = 301;
+ res.setHeader('Location', req.url + '/');
+ res.end('Redirecting to ' + req.url + '/');
+ }
+
+ // transfer arbitrary files from within
+ // /www/example.com/public/*
+ send(req, url.parse(req.url).pathname)
+ .root('/www/example.com/public')
+ .on('error', error)
+ .on('directory', redirect)
+ .pipe(res);
+}).listen(3000);
+```
+
+## API
+
+### Events
+
+ - `error` an error occurred `(err)`
+ - `directory` a directory was requested
+ - `file` a file was requested `(path, stat)`
+ - `stream` file streaming has started `(stream)`
+ - `end` streaming has completed
+
+### .root(dir)
+
+ Serve files relative to `path`. Aliased as `.from(dir)`.
+
+### .index(path)
+
+ By default send supports "index.html" files, to disable this
+ invoke `.index(false)` or to supply a new index pass a string.
+
+### .maxage(ms)
+
+ Provide a max-age in milliseconds for http caching, defaults to 0.
+
+### .hidden(bool)
+
+ Enable or disable transfer of hidden files, defaults to false.
+
+## Error-handling
+
+ By default when no `error` listeners are present an automatic response will be made, otherwise you have full control over the response, aka you may show a 5xx page etc.
+
+## Caching
+
+ It does _not_ perform internal caching, you should use a reverse proxy cache such
+ as Varnish for this, or those fancy things called CDNs. If your application is small enough that it would benefit from single-node memory caching, it's small enough that it does not need caching at all ;).
+
+## Debugging
+
+ To enable `debug()` instrumentation output export __DEBUG__:
+
+```
+$ DEBUG=send node app
+```
+
+## Running tests
+
+```
+$ npm install
+$ make test
+```
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+
+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.
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/index.js b/appshell/node-core/thirdparty/connect/node_modules/send/index.js
new file mode 100644
index 000000000..f17158d85
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/index.js
@@ -0,0 +1,2 @@
+
+module.exports = require('./lib/send');
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/lib/send.js b/appshell/node-core/thirdparty/connect/node_modules/send/lib/send.js
new file mode 100644
index 000000000..a3d94a69d
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/lib/send.js
@@ -0,0 +1,474 @@
+
+/**
+ * Module dependencies.
+ */
+
+var debug = require('debug')('send')
+ , parseRange = require('range-parser')
+ , Stream = require('stream')
+ , mime = require('mime')
+ , fresh = require('fresh')
+ , path = require('path')
+ , http = require('http')
+ , fs = require('fs')
+ , basename = path.basename
+ , normalize = path.normalize
+ , join = path.join
+ , utils = require('./utils');
+
+/**
+ * Expose `send`.
+ */
+
+exports = module.exports = send;
+
+/**
+ * Expose mime module.
+ */
+
+exports.mime = mime;
+
+/**
+ * Return a `SendStream` for `req` and `path`.
+ *
+ * @param {Request} req
+ * @param {String} path
+ * @param {Object} options
+ * @return {SendStream}
+ * @api public
+ */
+
+function send(req, path, options) {
+ return new SendStream(req, path, options);
+}
+
+/**
+ * Initialize a `SendStream` with the given `path`.
+ *
+ * Events:
+ *
+ * - `error` an error occurred
+ * - `stream` file streaming has started
+ * - `end` streaming has completed
+ * - `directory` a directory was requested
+ *
+ * @param {Request} req
+ * @param {String} path
+ * @param {Object} options
+ * @api private
+ */
+
+function SendStream(req, path, options) {
+ var self = this;
+ this.req = req;
+ this.path = path;
+ this.options = options || {};
+ this.maxage(0);
+ this.hidden(false);
+ this.index('index.html');
+}
+
+/**
+ * Inherits from `Stream.prototype`.
+ */
+
+SendStream.prototype.__proto__ = Stream.prototype;
+
+/**
+ * Enable or disable "hidden" (dot) files.
+ *
+ * @param {Boolean} path
+ * @return {SendStream}
+ * @api public
+ */
+
+SendStream.prototype.hidden = function(val){
+ debug('hidden %s', val);
+ this._hidden = val;
+ return this;
+};
+
+/**
+ * Set index `path`, set to a falsy
+ * value to disable index support.
+ *
+ * @param {String|Boolean} path
+ * @return {SendStream}
+ * @api public
+ */
+
+SendStream.prototype.index = function(path){
+ debug('index %s', path);
+ this._index = path;
+ return this;
+};
+
+/**
+ * Set root `path`.
+ *
+ * @param {String} path
+ * @return {SendStream}
+ * @api public
+ */
+
+SendStream.prototype.root =
+SendStream.prototype.from = function(path){
+ this._root = normalize(path);
+ return this;
+};
+
+/**
+ * Set max-age to `ms`.
+ *
+ * @param {Number} ms
+ * @return {SendStream}
+ * @api public
+ */
+
+SendStream.prototype.maxage = function(ms){
+ if (Infinity == ms) ms = 60 * 60 * 24 * 365 * 1000;
+ debug('max-age %d', ms);
+ this._maxage = ms;
+ return this;
+};
+
+/**
+ * Emit error with `status`.
+ *
+ * @param {Number} status
+ * @api private
+ */
+
+SendStream.prototype.error = function(status, err){
+ var res = this.res;
+ var msg = http.STATUS_CODES[status];
+ err = err || new Error(msg);
+ err.status = status;
+ if (this.listeners('error').length) return this.emit('error', err);
+ res.statusCode = err.status;
+ res.end(msg);
+};
+
+/**
+ * Check if the pathname is potentially malicious.
+ *
+ * @return {Boolean}
+ * @api private
+ */
+
+SendStream.prototype.isMalicious = function(){
+ return !this._root && ~this.path.indexOf('..');
+};
+
+/**
+ * Check if the pathname ends with "/".
+ *
+ * @return {Boolean}
+ * @api private
+ */
+
+SendStream.prototype.hasTrailingSlash = function(){
+ return '/' == this.path[this.path.length - 1];
+};
+
+/**
+ * Check if the basename leads with ".".
+ *
+ * @return {Boolean}
+ * @api private
+ */
+
+SendStream.prototype.hasLeadingDot = function(){
+ return '.' == basename(this.path)[0];
+};
+
+/**
+ * Check if this is a conditional GET request.
+ *
+ * @return {Boolean}
+ * @api private
+ */
+
+SendStream.prototype.isConditionalGET = function(){
+ return this.req.headers['if-none-match']
+ || this.req.headers['if-modified-since'];
+};
+
+/**
+ * Strip content-* header fields.
+ *
+ * @api private
+ */
+
+SendStream.prototype.removeContentHeaderFields = function(){
+ var res = this.res;
+ Object.keys(res._headers).forEach(function(field){
+ if (0 == field.indexOf('content')) {
+ res.removeHeader(field);
+ }
+ });
+};
+
+/**
+ * Respond with 304 not modified.
+ *
+ * @api private
+ */
+
+SendStream.prototype.notModified = function(){
+ var res = this.res;
+ debug('not modified');
+ this.removeContentHeaderFields();
+ res.statusCode = 304;
+ res.end();
+};
+
+/**
+ * Check if the request is cacheable, aka
+ * responded with 2xx or 304 (see RFC 2616 section 14.2{5,6}).
+ *
+ * @return {Boolean}
+ * @api private
+ */
+
+SendStream.prototype.isCachable = function(){
+ var res = this.res;
+ return (res.statusCode >= 200 && res.statusCode < 300) || 304 == res.statusCode;
+};
+
+/**
+ * Handle stat() error.
+ *
+ * @param {Error} err
+ * @api private
+ */
+
+SendStream.prototype.onStatError = function(err){
+ var notfound = ['ENOENT', 'ENAMETOOLONG', 'ENOTDIR'];
+ if (~notfound.indexOf(err.code)) return this.error(404, err);
+ this.error(500, err);
+};
+
+/**
+ * Check if the cache is fresh.
+ *
+ * @return {Boolean}
+ * @api private
+ */
+
+SendStream.prototype.isFresh = function(){
+ return fresh(this.req.headers, this.res._headers);
+};
+
+/**
+ * Redirect to `path`.
+ *
+ * @param {String} path
+ * @api private
+ */
+
+SendStream.prototype.redirect = function(path){
+ if (this.listeners('directory').length) return this.emit('directory');
+ var res = this.res;
+ path += '/';
+ res.statusCode = 301;
+ res.setHeader('Location', path);
+ res.end('Redirecting to ' + utils.escape(path));
+};
+
+/**
+ * Pipe to `res.
+ *
+ * @param {Stream} res
+ * @return {Stream} res
+ * @api public
+ */
+
+SendStream.prototype.pipe = function(res){
+ var self = this
+ , args = arguments
+ , path = this.path
+ , root = this._root;
+
+ // references
+ this.res = res;
+
+ // invalid request uri
+ path = utils.decode(path);
+ if (-1 == path) return this.error(400);
+
+ // null byte(s)
+ if (~path.indexOf('\0')) return this.error(400);
+
+ // join / normalize from optional root dir
+ if (root) path = normalize(join(this._root, path));
+
+ // ".." is malicious without "root"
+ if (this.isMalicious()) return this.error(403);
+
+ // malicious path
+ if (root && 0 != path.indexOf(root)) return this.error(403);
+
+ // hidden file support
+ if (!this._hidden && this.hasLeadingDot()) return this.error(404);
+
+ // index file support
+ if (this._index && this.hasTrailingSlash()) path += this._index;
+
+ debug('stat "%s"', path);
+ fs.stat(path, function(err, stat){
+ if (err) return self.onStatError(err);
+ if (stat.isDirectory()) return self.redirect(self.path);
+ self.emit('file', path, stat);
+ self.send(path, stat);
+ });
+
+ return res;
+};
+
+/**
+ * Transfer `path`.
+ *
+ * @param {String} path
+ * @api public
+ */
+
+SendStream.prototype.send = function(path, stat){
+ var options = this.options;
+ var len = stat.size;
+ var res = this.res;
+ var req = this.req;
+ var ranges = req.headers.range;
+ var offset = options.start || 0;
+
+ // set header fields
+ this.setHeader(stat);
+
+ // set content-type
+ this.type(path);
+
+ // conditional GET support
+ if (this.isConditionalGET()
+ && this.isCachable()
+ && this.isFresh()) {
+ return this.notModified();
+ }
+
+ // adjust len to start/end options
+ len = Math.max(0, len - offset);
+ if (options.end !== undefined) {
+ var bytes = options.end - offset + 1;
+ if (len > bytes) len = bytes;
+ }
+
+ // Range support
+ if (ranges) {
+ ranges = parseRange(len, ranges);
+
+ // unsatisfiable
+ if (-1 == ranges) {
+ res.setHeader('Content-Range', 'bytes */' + stat.size);
+ return this.error(416);
+ }
+
+ // valid (syntactically invalid ranges are treated as a regular response)
+ if (-2 != ranges) {
+ options.start = offset + ranges[0].start;
+ options.end = offset + ranges[0].end;
+
+ // Content-Range
+ res.statusCode = 206;
+ res.setHeader('Content-Range', 'bytes '
+ + ranges[0].start
+ + '-'
+ + ranges[0].end
+ + '/'
+ + len);
+ len = options.end - options.start + 1;
+ }
+ }
+
+ // content-length
+ res.setHeader('Content-Length', len);
+
+ // HEAD support
+ if ('HEAD' == req.method) return res.end();
+
+ this.stream(path, options);
+};
+
+/**
+ * Stream `path` to the response.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @api private
+ */
+
+SendStream.prototype.stream = function(path, options){
+ // TODO: this is all lame, refactor meeee
+ var self = this;
+ var res = this.res;
+ var req = this.req;
+
+ // pipe
+ var stream = fs.createReadStream(path, options);
+ this.emit('stream', stream);
+ stream.pipe(res);
+
+ // socket closed, done with the fd
+ req.on('close', stream.destroy.bind(stream));
+
+ // error handling code-smell
+ stream.on('error', function(err){
+ // no hope in responding
+ if (res._header) {
+ console.error(err.stack);
+ req.destroy();
+ return;
+ }
+
+ // 500
+ err.status = 500;
+ self.emit('error', err);
+ });
+
+ // end
+ stream.on('end', function(){
+ self.emit('end');
+ });
+};
+
+/**
+ * Set content-type based on `path`
+ * if it hasn't been explicitly set.
+ *
+ * @param {String} path
+ * @api private
+ */
+
+SendStream.prototype.type = function(path){
+ var res = this.res;
+ if (res.getHeader('Content-Type')) return;
+ var type = mime.lookup(path);
+ var charset = mime.charsets.lookup(type);
+ debug('content-type %s', type);
+ res.setHeader('Content-Type', type + (charset ? '; charset=' + charset : ''));
+};
+
+/**
+ * Set reaponse header fields, most
+ * fields may be pre-defined.
+ *
+ * @param {Object} stat
+ * @api private
+ */
+
+SendStream.prototype.setHeader = function(stat){
+ var res = this.res;
+ if (!res.getHeader('Accept-Ranges')) res.setHeader('Accept-Ranges', 'bytes');
+ if (!res.getHeader('ETag')) res.setHeader('ETag', utils.etag(stat));
+ if (!res.getHeader('Date')) res.setHeader('Date', new Date().toUTCString());
+ if (!res.getHeader('Cache-Control')) res.setHeader('Cache-Control', 'public, max-age=' + (this._maxage / 1000));
+ if (!res.getHeader('Last-Modified')) res.setHeader('Last-Modified', stat.mtime.toUTCString());
+};
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/lib/utils.js b/appshell/node-core/thirdparty/connect/node_modules/send/lib/utils.js
new file mode 100644
index 000000000..950e5a2c1
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/lib/utils.js
@@ -0,0 +1,47 @@
+
+/**
+ * Return an ETag in the form of `"-"`
+ * from the given `stat`.
+ *
+ * @param {Object} stat
+ * @return {String}
+ * @api private
+ */
+
+exports.etag = function(stat) {
+ return '"' + stat.size + '-' + Number(stat.mtime) + '"';
+};
+
+/**
+ * decodeURIComponent.
+ *
+ * Allows V8 to only deoptimize this fn instead of all
+ * of send().
+ *
+ * @param {String} path
+ * @api private
+ */
+
+exports.decode = function(path){
+ try {
+ return decodeURIComponent(path);
+ } catch (err) {
+ return -1;
+ }
+};
+
+/**
+ * Escape the given string of `html`.
+ *
+ * @param {String} html
+ * @return {String}
+ * @api private
+ */
+
+exports.escape = function(html){
+ return String(html)
+ .replace(/&(?!\w+;)/g, '&')
+ .replace(//g, '>')
+ .replace(/"/g, '"');
+};
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/LICENSE b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/LICENSE
new file mode 100644
index 000000000..451fc4550
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2010 Benjamin Thomas, Robert Kieffer
+
+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.
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/README.md b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/README.md
new file mode 100644
index 000000000..6ca19bd1e
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/README.md
@@ -0,0 +1,66 @@
+# mime
+
+Comprehensive MIME type mapping API. Includes all 600+ types and 800+ extensions defined by the Apache project, plus additional types submitted by the node.js community.
+
+## Install
+
+Install with [npm](http://github.com/isaacs/npm):
+
+ npm install mime
+
+## API - Queries
+
+### mime.lookup(path)
+Get the mime type associated with a file, if no mime type is found `application/octet-stream` is returned. Performs a case-insensitive lookup using the extension in `path` (the substring after the last '/' or '.'). E.g.
+
+ var mime = require('mime');
+
+ mime.lookup('/path/to/file.txt'); // => 'text/plain'
+ mime.lookup('file.txt'); // => 'text/plain'
+ mime.lookup('.TXT'); // => 'text/plain'
+ mime.lookup('htm'); // => 'text/html'
+
+### mime.default_type
+Sets the mime type returned when `mime.lookup` fails to find the extension searched for. (Default is `application/octet-stream`.)
+
+### mime.extension(type)
+Get the default extension for `type`
+
+ mime.extension('text/html'); // => 'html'
+ mime.extension('application/octet-stream'); // => 'bin'
+
+### mime.charsets.lookup()
+
+Map mime-type to charset
+
+ mime.charsets.lookup('text/plain'); // => 'UTF-8'
+
+(The logic for charset lookups is pretty rudimentary. Feel free to suggest improvements.)
+
+## API - Defining Custom Types
+
+The following APIs allow you to add your own type mappings within your project. If you feel a type should be included as part of node-mime, see [requesting new types](https://github.com/broofa/node-mime/wiki/Requesting-New-Types).
+
+### mime.define()
+
+Add custom mime/extension mappings
+
+ mime.define({
+ 'text/x-some-format': ['x-sf', 'x-sft', 'x-sfml'],
+ 'application/x-my-type': ['x-mt', 'x-mtt'],
+ // etc ...
+ });
+
+ mime.lookup('x-sft'); // => 'text/x-some-format'
+
+The first entry in the extensions array is returned by `mime.extension()`. E.g.
+
+ mime.extension('text/x-some-format'); // => 'x-sf'
+
+### mime.load(filepath)
+
+Load mappings from an Apache ".types" format file
+
+ mime.load('./my_project.types');
+
+The .types file format is simple - See the `types` dir for examples.
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/mime.js b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/mime.js
new file mode 100644
index 000000000..48be0c5e4
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/mime.js
@@ -0,0 +1,114 @@
+var path = require('path');
+var fs = require('fs');
+
+function Mime() {
+ // Map of extension -> mime type
+ this.types = Object.create(null);
+
+ // Map of mime type -> extension
+ this.extensions = Object.create(null);
+}
+
+/**
+ * Define mimetype -> extension mappings. Each key is a mime-type that maps
+ * to an array of extensions associated with the type. The first extension is
+ * used as the default extension for the type.
+ *
+ * e.g. mime.define({'audio/ogg', ['oga', 'ogg', 'spx']});
+ *
+ * @param map (Object) type definitions
+ */
+Mime.prototype.define = function (map) {
+ for (var type in map) {
+ var exts = map[type];
+
+ for (var i = 0; i < exts.length; i++) {
+ if (process.env.DEBUG_MIME && this.types[exts]) {
+ console.warn(this._loading.replace(/.*\//, ''), 'changes "' + exts[i] + '" extension type from ' +
+ this.types[exts] + ' to ' + type);
+ }
+
+ this.types[exts[i]] = type;
+ }
+
+ // Default extension is the first one we encounter
+ if (!this.extensions[type]) {
+ this.extensions[type] = exts[0];
+ }
+ }
+};
+
+/**
+ * Load an Apache2-style ".types" file
+ *
+ * This may be called multiple times (it's expected). Where files declare
+ * overlapping types/extensions, the last file wins.
+ *
+ * @param file (String) path of file to load.
+ */
+Mime.prototype.load = function(file) {
+
+ this._loading = file;
+ // Read file and split into lines
+ var map = {},
+ content = fs.readFileSync(file, 'ascii'),
+ lines = content.split(/[\r\n]+/);
+
+ lines.forEach(function(line) {
+ // Clean up whitespace/comments, and split into fields
+ var fields = line.replace(/\s*#.*|^\s*|\s*$/g, '').split(/\s+/);
+ map[fields.shift()] = fields;
+ });
+
+ this.define(map);
+
+ this._loading = null;
+};
+
+/**
+ * Lookup a mime type based on extension
+ */
+Mime.prototype.lookup = function(path, fallback) {
+ var ext = path.replace(/.*[\.\/\\]/, '').toLowerCase();
+
+ return this.types[ext] || fallback || this.default_type;
+};
+
+/**
+ * Return file extension associated with a mime type
+ */
+Mime.prototype.extension = function(mimeType) {
+ var type = mimeType.match(/^\s*([^;\s]*)(?:;|\s|$)/)[1].toLowerCase();
+ return this.extensions[type];
+};
+
+// Default instance
+var mime = new Mime();
+
+// Load local copy of
+// http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types
+mime.load(path.join(__dirname, 'types/mime.types'));
+
+// Load additional types from node.js community
+mime.load(path.join(__dirname, 'types/node.types'));
+
+// Default type
+mime.default_type = mime.lookup('bin');
+
+//
+// Additional API specific to the default instance
+//
+
+mime.Mime = Mime;
+
+/**
+ * Lookup a charset based on mime type.
+ */
+mime.charsets = {
+ lookup: function(mimeType, fallback) {
+ // Assume text types are utf8
+ return (/^text\//).test(mimeType) ? 'UTF-8' : fallback;
+ }
+};
+
+module.exports = mime;
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/package.json b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/package.json
new file mode 100644
index 000000000..4e7b0fdb2
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/package.json
@@ -0,0 +1,35 @@
+{
+ "author": {
+ "name": "Robert Kieffer",
+ "email": "robert@broofa.com",
+ "url": "http://github.com/broofa"
+ },
+ "contributors": [
+ {
+ "name": "Benjamin Thomas",
+ "email": "benjamin@benjaminthomas.org",
+ "url": "http://github.com/bentomas"
+ }
+ ],
+ "dependencies": {},
+ "description": "A comprehensive library for mime-type mapping",
+ "devDependencies": {},
+ "keywords": [
+ "util",
+ "mime"
+ ],
+ "main": "mime.js",
+ "name": "mime",
+ "repository": {
+ "url": "https://github.com/broofa/node-mime",
+ "type": "git"
+ },
+ "version": "1.2.11",
+ "readme": "# mime\n\nComprehensive MIME type mapping API. Includes all 600+ types and 800+ extensions defined by the Apache project, plus additional types submitted by the node.js community.\n\n## Install\n\nInstall with [npm](http://github.com/isaacs/npm):\n\n npm install mime\n\n## API - Queries\n\n### mime.lookup(path)\nGet the mime type associated with a file, if no mime type is found `application/octet-stream` is returned. Performs a case-insensitive lookup using the extension in `path` (the substring after the last '/' or '.'). E.g.\n\n var mime = require('mime');\n\n mime.lookup('/path/to/file.txt'); // => 'text/plain'\n mime.lookup('file.txt'); // => 'text/plain'\n mime.lookup('.TXT'); // => 'text/plain'\n mime.lookup('htm'); // => 'text/html'\n\n### mime.default_type\nSets the mime type returned when `mime.lookup` fails to find the extension searched for. (Default is `application/octet-stream`.)\n\n### mime.extension(type)\nGet the default extension for `type`\n\n mime.extension('text/html'); // => 'html'\n mime.extension('application/octet-stream'); // => 'bin'\n\n### mime.charsets.lookup()\n\nMap mime-type to charset\n\n mime.charsets.lookup('text/plain'); // => 'UTF-8'\n\n(The logic for charset lookups is pretty rudimentary. Feel free to suggest improvements.)\n\n## API - Defining Custom Types\n\nThe following APIs allow you to add your own type mappings within your project. If you feel a type should be included as part of node-mime, see [requesting new types](https://github.com/broofa/node-mime/wiki/Requesting-New-Types).\n\n### mime.define()\n\nAdd custom mime/extension mappings\n\n mime.define({\n 'text/x-some-format': ['x-sf', 'x-sft', 'x-sfml'],\n 'application/x-my-type': ['x-mt', 'x-mtt'],\n // etc ...\n });\n\n mime.lookup('x-sft'); // => 'text/x-some-format'\n\nThe first entry in the extensions array is returned by `mime.extension()`. E.g.\n\n mime.extension('text/x-some-format'); // => 'x-sf'\n\n### mime.load(filepath)\n\nLoad mappings from an Apache \".types\" format file\n\n mime.load('./my_project.types');\n\nThe .types file format is simple - See the `types` dir for examples.\n",
+ "readmeFilename": "README.md",
+ "bugs": {
+ "url": "https://github.com/broofa/node-mime/issues"
+ },
+ "_id": "mime@1.2.11",
+ "_from": "mime@~1.2.9"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/test.js b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/test.js
new file mode 100644
index 000000000..2cda1c7ad
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/test.js
@@ -0,0 +1,84 @@
+/**
+ * Usage: node test.js
+ */
+
+var mime = require('./mime');
+var assert = require('assert');
+var path = require('path');
+
+function eq(a, b) {
+ console.log('Test: ' + a + ' === ' + b);
+ assert.strictEqual.apply(null, arguments);
+}
+
+console.log(Object.keys(mime.extensions).length + ' types');
+console.log(Object.keys(mime.types).length + ' extensions\n');
+
+//
+// Test mime lookups
+//
+
+eq('text/plain', mime.lookup('text.txt')); // normal file
+eq('text/plain', mime.lookup('TEXT.TXT')); // uppercase
+eq('text/plain', mime.lookup('dir/text.txt')); // dir + file
+eq('text/plain', mime.lookup('.text.txt')); // hidden file
+eq('text/plain', mime.lookup('.txt')); // nameless
+eq('text/plain', mime.lookup('txt')); // extension-only
+eq('text/plain', mime.lookup('/txt')); // extension-less ()
+eq('text/plain', mime.lookup('\\txt')); // Windows, extension-less
+eq('application/octet-stream', mime.lookup('text.nope')); // unrecognized
+eq('fallback', mime.lookup('text.fallback', 'fallback')); // alternate default
+
+//
+// Test extensions
+//
+
+eq('txt', mime.extension(mime.types.text));
+eq('html', mime.extension(mime.types.htm));
+eq('bin', mime.extension('application/octet-stream'));
+eq('bin', mime.extension('application/octet-stream '));
+eq('html', mime.extension(' text/html; charset=UTF-8'));
+eq('html', mime.extension('text/html; charset=UTF-8 '));
+eq('html', mime.extension('text/html; charset=UTF-8'));
+eq('html', mime.extension('text/html ; charset=UTF-8'));
+eq('html', mime.extension('text/html;charset=UTF-8'));
+eq('html', mime.extension('text/Html;charset=UTF-8'));
+eq(undefined, mime.extension('unrecognized'));
+
+//
+// Test node.types lookups
+//
+
+eq('application/font-woff', mime.lookup('file.woff'));
+eq('application/octet-stream', mime.lookup('file.buffer'));
+eq('audio/mp4', mime.lookup('file.m4a'));
+eq('font/opentype', mime.lookup('file.otf'));
+
+//
+// Test charsets
+//
+
+eq('UTF-8', mime.charsets.lookup('text/plain'));
+eq(undefined, mime.charsets.lookup(mime.types.js));
+eq('fallback', mime.charsets.lookup('application/octet-stream', 'fallback'));
+
+//
+// Test for overlaps between mime.types and node.types
+//
+
+var apacheTypes = new mime.Mime(), nodeTypes = new mime.Mime();
+apacheTypes.load(path.join(__dirname, 'types/mime.types'));
+nodeTypes.load(path.join(__dirname, 'types/node.types'));
+
+var keys = [].concat(Object.keys(apacheTypes.types))
+ .concat(Object.keys(nodeTypes.types));
+keys.sort();
+for (var i = 1; i < keys.length; i++) {
+ if (keys[i] == keys[i-1]) {
+ console.warn('Warning: ' +
+ 'node.types defines ' + keys[i] + '->' + nodeTypes.types[keys[i]] +
+ ', mime.types defines ' + keys[i] + '->' + apacheTypes.types[keys[i]]);
+ }
+}
+
+console.log('\nOK');
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/types/mime.types b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/types/mime.types
new file mode 100644
index 000000000..da8cd6918
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/types/mime.types
@@ -0,0 +1,1588 @@
+# This file maps Internet media types to unique file extension(s).
+# Although created for httpd, this file is used by many software systems
+# and has been placed in the public domain for unlimited redisribution.
+#
+# The table below contains both registered and (common) unregistered types.
+# A type that has no unique extension can be ignored -- they are listed
+# here to guide configurations toward known types and to make it easier to
+# identify "new" types. File extensions are also commonly used to indicate
+# content languages and encodings, so choose them carefully.
+#
+# Internet media types should be registered as described in RFC 4288.
+# The registry is at .
+#
+# MIME type (lowercased) Extensions
+# ============================================ ==========
+# application/1d-interleaved-parityfec
+# application/3gpp-ims+xml
+# application/activemessage
+application/andrew-inset ez
+# application/applefile
+application/applixware aw
+application/atom+xml atom
+application/atomcat+xml atomcat
+# application/atomicmail
+application/atomsvc+xml atomsvc
+# application/auth-policy+xml
+# application/batch-smtp
+# application/beep+xml
+# application/calendar+xml
+# application/cals-1840
+# application/ccmp+xml
+application/ccxml+xml ccxml
+application/cdmi-capability cdmia
+application/cdmi-container cdmic
+application/cdmi-domain cdmid
+application/cdmi-object cdmio
+application/cdmi-queue cdmiq
+# application/cea-2018+xml
+# application/cellml+xml
+# application/cfw
+# application/cnrp+xml
+# application/commonground
+# application/conference-info+xml
+# application/cpl+xml
+# application/csta+xml
+# application/cstadata+xml
+application/cu-seeme cu
+# application/cybercash
+application/davmount+xml davmount
+# application/dca-rft
+# application/dec-dx
+# application/dialog-info+xml
+# application/dicom
+# application/dns
+application/docbook+xml dbk
+# application/dskpp+xml
+application/dssc+der dssc
+application/dssc+xml xdssc
+# application/dvcs
+application/ecmascript ecma
+# application/edi-consent
+# application/edi-x12
+# application/edifact
+application/emma+xml emma
+# application/epp+xml
+application/epub+zip epub
+# application/eshop
+# application/example
+application/exi exi
+# application/fastinfoset
+# application/fastsoap
+# application/fits
+application/font-tdpfr pfr
+# application/framework-attributes+xml
+application/gml+xml gml
+application/gpx+xml gpx
+application/gxf gxf
+# application/h224
+# application/held+xml
+# application/http
+application/hyperstudio stk
+# application/ibe-key-request+xml
+# application/ibe-pkg-reply+xml
+# application/ibe-pp-data
+# application/iges
+# application/im-iscomposing+xml
+# application/index
+# application/index.cmd
+# application/index.obj
+# application/index.response
+# application/index.vnd
+application/inkml+xml ink inkml
+# application/iotp
+application/ipfix ipfix
+# application/ipp
+# application/isup
+application/java-archive jar
+application/java-serialized-object ser
+application/java-vm class
+application/javascript js
+application/json json
+application/jsonml+json jsonml
+# application/kpml-request+xml
+# application/kpml-response+xml
+application/lost+xml lostxml
+application/mac-binhex40 hqx
+application/mac-compactpro cpt
+# application/macwriteii
+application/mads+xml mads
+application/marc mrc
+application/marcxml+xml mrcx
+application/mathematica ma nb mb
+# application/mathml-content+xml
+# application/mathml-presentation+xml
+application/mathml+xml mathml
+# application/mbms-associated-procedure-description+xml
+# application/mbms-deregister+xml
+# application/mbms-envelope+xml
+# application/mbms-msk+xml
+# application/mbms-msk-response+xml
+# application/mbms-protection-description+xml
+# application/mbms-reception-report+xml
+# application/mbms-register+xml
+# application/mbms-register-response+xml
+# application/mbms-user-service-description+xml
+application/mbox mbox
+# application/media_control+xml
+application/mediaservercontrol+xml mscml
+application/metalink+xml metalink
+application/metalink4+xml meta4
+application/mets+xml mets
+# application/mikey
+application/mods+xml mods
+# application/moss-keys
+# application/moss-signature
+# application/mosskey-data
+# application/mosskey-request
+application/mp21 m21 mp21
+application/mp4 mp4s
+# application/mpeg4-generic
+# application/mpeg4-iod
+# application/mpeg4-iod-xmt
+# application/msc-ivr+xml
+# application/msc-mixer+xml
+application/msword doc dot
+application/mxf mxf
+# application/nasdata
+# application/news-checkgroups
+# application/news-groupinfo
+# application/news-transmission
+# application/nss
+# application/ocsp-request
+# application/ocsp-response
+application/octet-stream bin dms lrf mar so dist distz pkg bpk dump elc deploy
+application/oda oda
+application/oebps-package+xml opf
+application/ogg ogx
+application/omdoc+xml omdoc
+application/onenote onetoc onetoc2 onetmp onepkg
+application/oxps oxps
+# application/parityfec
+application/patch-ops-error+xml xer
+application/pdf pdf
+application/pgp-encrypted pgp
+# application/pgp-keys
+application/pgp-signature asc sig
+application/pics-rules prf
+# application/pidf+xml
+# application/pidf-diff+xml
+application/pkcs10 p10
+application/pkcs7-mime p7m p7c
+application/pkcs7-signature p7s
+application/pkcs8 p8
+application/pkix-attr-cert ac
+application/pkix-cert cer
+application/pkix-crl crl
+application/pkix-pkipath pkipath
+application/pkixcmp pki
+application/pls+xml pls
+# application/poc-settings+xml
+application/postscript ai eps ps
+# application/prs.alvestrand.titrax-sheet
+application/prs.cww cww
+# application/prs.nprend
+# application/prs.plucker
+# application/prs.rdf-xml-crypt
+# application/prs.xsf+xml
+application/pskc+xml pskcxml
+# application/qsig
+application/rdf+xml rdf
+application/reginfo+xml rif
+application/relax-ng-compact-syntax rnc
+# application/remote-printing
+application/resource-lists+xml rl
+application/resource-lists-diff+xml rld
+# application/riscos
+# application/rlmi+xml
+application/rls-services+xml rs
+application/rpki-ghostbusters gbr
+application/rpki-manifest mft
+application/rpki-roa roa
+# application/rpki-updown
+application/rsd+xml rsd
+application/rss+xml rss
+application/rtf rtf
+# application/rtx
+# application/samlassertion+xml
+# application/samlmetadata+xml
+application/sbml+xml sbml
+application/scvp-cv-request scq
+application/scvp-cv-response scs
+application/scvp-vp-request spq
+application/scvp-vp-response spp
+application/sdp sdp
+# application/set-payment
+application/set-payment-initiation setpay
+# application/set-registration
+application/set-registration-initiation setreg
+# application/sgml
+# application/sgml-open-catalog
+application/shf+xml shf
+# application/sieve
+# application/simple-filter+xml
+# application/simple-message-summary
+# application/simplesymbolcontainer
+# application/slate
+# application/smil
+application/smil+xml smi smil
+# application/soap+fastinfoset
+# application/soap+xml
+application/sparql-query rq
+application/sparql-results+xml srx
+# application/spirits-event+xml
+application/srgs gram
+application/srgs+xml grxml
+application/sru+xml sru
+application/ssdl+xml ssdl
+application/ssml+xml ssml
+# application/tamp-apex-update
+# application/tamp-apex-update-confirm
+# application/tamp-community-update
+# application/tamp-community-update-confirm
+# application/tamp-error
+# application/tamp-sequence-adjust
+# application/tamp-sequence-adjust-confirm
+# application/tamp-status-query
+# application/tamp-status-response
+# application/tamp-update
+# application/tamp-update-confirm
+application/tei+xml tei teicorpus
+application/thraud+xml tfi
+# application/timestamp-query
+# application/timestamp-reply
+application/timestamped-data tsd
+# application/tve-trigger
+# application/ulpfec
+# application/vcard+xml
+# application/vemmi
+# application/vividence.scriptfile
+# application/vnd.3gpp.bsf+xml
+application/vnd.3gpp.pic-bw-large plb
+application/vnd.3gpp.pic-bw-small psb
+application/vnd.3gpp.pic-bw-var pvb
+# application/vnd.3gpp.sms
+# application/vnd.3gpp2.bcmcsinfo+xml
+# application/vnd.3gpp2.sms
+application/vnd.3gpp2.tcap tcap
+application/vnd.3m.post-it-notes pwn
+application/vnd.accpac.simply.aso aso
+application/vnd.accpac.simply.imp imp
+application/vnd.acucobol acu
+application/vnd.acucorp atc acutc
+application/vnd.adobe.air-application-installer-package+zip air
+application/vnd.adobe.formscentral.fcdt fcdt
+application/vnd.adobe.fxp fxp fxpl
+# application/vnd.adobe.partial-upload
+application/vnd.adobe.xdp+xml xdp
+application/vnd.adobe.xfdf xfdf
+# application/vnd.aether.imp
+# application/vnd.ah-barcode
+application/vnd.ahead.space ahead
+application/vnd.airzip.filesecure.azf azf
+application/vnd.airzip.filesecure.azs azs
+application/vnd.amazon.ebook azw
+application/vnd.americandynamics.acc acc
+application/vnd.amiga.ami ami
+# application/vnd.amundsen.maze+xml
+application/vnd.android.package-archive apk
+application/vnd.anser-web-certificate-issue-initiation cii
+application/vnd.anser-web-funds-transfer-initiation fti
+application/vnd.antix.game-component atx
+application/vnd.apple.installer+xml mpkg
+application/vnd.apple.mpegurl m3u8
+# application/vnd.arastra.swi
+application/vnd.aristanetworks.swi swi
+application/vnd.astraea-software.iota iota
+application/vnd.audiograph aep
+# application/vnd.autopackage
+# application/vnd.avistar+xml
+application/vnd.blueice.multipass mpm
+# application/vnd.bluetooth.ep.oob
+application/vnd.bmi bmi
+application/vnd.businessobjects rep
+# application/vnd.cab-jscript
+# application/vnd.canon-cpdl
+# application/vnd.canon-lips
+# application/vnd.cendio.thinlinc.clientconf
+application/vnd.chemdraw+xml cdxml
+application/vnd.chipnuts.karaoke-mmd mmd
+application/vnd.cinderella cdy
+# application/vnd.cirpack.isdn-ext
+application/vnd.claymore cla
+application/vnd.cloanto.rp9 rp9
+application/vnd.clonk.c4group c4g c4d c4f c4p c4u
+application/vnd.cluetrust.cartomobile-config c11amc
+application/vnd.cluetrust.cartomobile-config-pkg c11amz
+# application/vnd.collection+json
+# application/vnd.commerce-battelle
+application/vnd.commonspace csp
+application/vnd.contact.cmsg cdbcmsg
+application/vnd.cosmocaller cmc
+application/vnd.crick.clicker clkx
+application/vnd.crick.clicker.keyboard clkk
+application/vnd.crick.clicker.palette clkp
+application/vnd.crick.clicker.template clkt
+application/vnd.crick.clicker.wordbank clkw
+application/vnd.criticaltools.wbs+xml wbs
+application/vnd.ctc-posml pml
+# application/vnd.ctct.ws+xml
+# application/vnd.cups-pdf
+# application/vnd.cups-postscript
+application/vnd.cups-ppd ppd
+# application/vnd.cups-raster
+# application/vnd.cups-raw
+# application/vnd.curl
+application/vnd.curl.car car
+application/vnd.curl.pcurl pcurl
+# application/vnd.cybank
+application/vnd.dart dart
+application/vnd.data-vision.rdz rdz
+application/vnd.dece.data uvf uvvf uvd uvvd
+application/vnd.dece.ttml+xml uvt uvvt
+application/vnd.dece.unspecified uvx uvvx
+application/vnd.dece.zip uvz uvvz
+application/vnd.denovo.fcselayout-link fe_launch
+# application/vnd.dir-bi.plate-dl-nosuffix
+application/vnd.dna dna
+application/vnd.dolby.mlp mlp
+# application/vnd.dolby.mobile.1
+# application/vnd.dolby.mobile.2
+application/vnd.dpgraph dpg
+application/vnd.dreamfactory dfac
+application/vnd.ds-keypoint kpxx
+application/vnd.dvb.ait ait
+# application/vnd.dvb.dvbj
+# application/vnd.dvb.esgcontainer
+# application/vnd.dvb.ipdcdftnotifaccess
+# application/vnd.dvb.ipdcesgaccess
+# application/vnd.dvb.ipdcesgaccess2
+# application/vnd.dvb.ipdcesgpdd
+# application/vnd.dvb.ipdcroaming
+# application/vnd.dvb.iptv.alfec-base
+# application/vnd.dvb.iptv.alfec-enhancement
+# application/vnd.dvb.notif-aggregate-root+xml
+# application/vnd.dvb.notif-container+xml
+# application/vnd.dvb.notif-generic+xml
+# application/vnd.dvb.notif-ia-msglist+xml
+# application/vnd.dvb.notif-ia-registration-request+xml
+# application/vnd.dvb.notif-ia-registration-response+xml
+# application/vnd.dvb.notif-init+xml
+# application/vnd.dvb.pfr
+application/vnd.dvb.service svc
+# application/vnd.dxr
+application/vnd.dynageo geo
+# application/vnd.easykaraoke.cdgdownload
+# application/vnd.ecdis-update
+application/vnd.ecowin.chart mag
+# application/vnd.ecowin.filerequest
+# application/vnd.ecowin.fileupdate
+# application/vnd.ecowin.series
+# application/vnd.ecowin.seriesrequest
+# application/vnd.ecowin.seriesupdate
+# application/vnd.emclient.accessrequest+xml
+application/vnd.enliven nml
+# application/vnd.eprints.data+xml
+application/vnd.epson.esf esf
+application/vnd.epson.msf msf
+application/vnd.epson.quickanime qam
+application/vnd.epson.salt slt
+application/vnd.epson.ssf ssf
+# application/vnd.ericsson.quickcall
+application/vnd.eszigno3+xml es3 et3
+# application/vnd.etsi.aoc+xml
+# application/vnd.etsi.cug+xml
+# application/vnd.etsi.iptvcommand+xml
+# application/vnd.etsi.iptvdiscovery+xml
+# application/vnd.etsi.iptvprofile+xml
+# application/vnd.etsi.iptvsad-bc+xml
+# application/vnd.etsi.iptvsad-cod+xml
+# application/vnd.etsi.iptvsad-npvr+xml
+# application/vnd.etsi.iptvservice+xml
+# application/vnd.etsi.iptvsync+xml
+# application/vnd.etsi.iptvueprofile+xml
+# application/vnd.etsi.mcid+xml
+# application/vnd.etsi.overload-control-policy-dataset+xml
+# application/vnd.etsi.sci+xml
+# application/vnd.etsi.simservs+xml
+# application/vnd.etsi.tsl+xml
+# application/vnd.etsi.tsl.der
+# application/vnd.eudora.data
+application/vnd.ezpix-album ez2
+application/vnd.ezpix-package ez3
+# application/vnd.f-secure.mobile
+application/vnd.fdf fdf
+application/vnd.fdsn.mseed mseed
+application/vnd.fdsn.seed seed dataless
+# application/vnd.ffsns
+# application/vnd.fints
+application/vnd.flographit gph
+application/vnd.fluxtime.clip ftc
+# application/vnd.font-fontforge-sfd
+application/vnd.framemaker fm frame maker book
+application/vnd.frogans.fnc fnc
+application/vnd.frogans.ltf ltf
+application/vnd.fsc.weblaunch fsc
+application/vnd.fujitsu.oasys oas
+application/vnd.fujitsu.oasys2 oa2
+application/vnd.fujitsu.oasys3 oa3
+application/vnd.fujitsu.oasysgp fg5
+application/vnd.fujitsu.oasysprs bh2
+# application/vnd.fujixerox.art-ex
+# application/vnd.fujixerox.art4
+# application/vnd.fujixerox.hbpl
+application/vnd.fujixerox.ddd ddd
+application/vnd.fujixerox.docuworks xdw
+application/vnd.fujixerox.docuworks.binder xbd
+# application/vnd.fut-misnet
+application/vnd.fuzzysheet fzs
+application/vnd.genomatix.tuxedo txd
+# application/vnd.geocube+xml
+application/vnd.geogebra.file ggb
+application/vnd.geogebra.tool ggt
+application/vnd.geometry-explorer gex gre
+application/vnd.geonext gxt
+application/vnd.geoplan g2w
+application/vnd.geospace g3w
+# application/vnd.globalplatform.card-content-mgt
+# application/vnd.globalplatform.card-content-mgt-response
+application/vnd.gmx gmx
+application/vnd.google-earth.kml+xml kml
+application/vnd.google-earth.kmz kmz
+application/vnd.grafeq gqf gqs
+# application/vnd.gridmp
+application/vnd.groove-account gac
+application/vnd.groove-help ghf
+application/vnd.groove-identity-message gim
+application/vnd.groove-injector grv
+application/vnd.groove-tool-message gtm
+application/vnd.groove-tool-template tpl
+application/vnd.groove-vcard vcg
+# application/vnd.hal+json
+application/vnd.hal+xml hal
+application/vnd.handheld-entertainment+xml zmm
+application/vnd.hbci hbci
+# application/vnd.hcl-bireports
+application/vnd.hhe.lesson-player les
+application/vnd.hp-hpgl hpgl
+application/vnd.hp-hpid hpid
+application/vnd.hp-hps hps
+application/vnd.hp-jlyt jlt
+application/vnd.hp-pcl pcl
+application/vnd.hp-pclxl pclxl
+# application/vnd.httphone
+application/vnd.hydrostatix.sof-data sfd-hdstx
+# application/vnd.hzn-3d-crossword
+# application/vnd.ibm.afplinedata
+# application/vnd.ibm.electronic-media
+application/vnd.ibm.minipay mpy
+application/vnd.ibm.modcap afp listafp list3820
+application/vnd.ibm.rights-management irm
+application/vnd.ibm.secure-container sc
+application/vnd.iccprofile icc icm
+application/vnd.igloader igl
+application/vnd.immervision-ivp ivp
+application/vnd.immervision-ivu ivu
+# application/vnd.informedcontrol.rms+xml
+# application/vnd.informix-visionary
+# application/vnd.infotech.project
+# application/vnd.infotech.project+xml
+# application/vnd.innopath.wamp.notification
+application/vnd.insors.igm igm
+application/vnd.intercon.formnet xpw xpx
+application/vnd.intergeo i2g
+# application/vnd.intertrust.digibox
+# application/vnd.intertrust.nncp
+application/vnd.intu.qbo qbo
+application/vnd.intu.qfx qfx
+# application/vnd.iptc.g2.conceptitem+xml
+# application/vnd.iptc.g2.knowledgeitem+xml
+# application/vnd.iptc.g2.newsitem+xml
+# application/vnd.iptc.g2.newsmessage+xml
+# application/vnd.iptc.g2.packageitem+xml
+# application/vnd.iptc.g2.planningitem+xml
+application/vnd.ipunplugged.rcprofile rcprofile
+application/vnd.irepository.package+xml irp
+application/vnd.is-xpr xpr
+application/vnd.isac.fcs fcs
+application/vnd.jam jam
+# application/vnd.japannet-directory-service
+# application/vnd.japannet-jpnstore-wakeup
+# application/vnd.japannet-payment-wakeup
+# application/vnd.japannet-registration
+# application/vnd.japannet-registration-wakeup
+# application/vnd.japannet-setstore-wakeup
+# application/vnd.japannet-verification
+# application/vnd.japannet-verification-wakeup
+application/vnd.jcp.javame.midlet-rms rms
+application/vnd.jisp jisp
+application/vnd.joost.joda-archive joda
+application/vnd.kahootz ktz ktr
+application/vnd.kde.karbon karbon
+application/vnd.kde.kchart chrt
+application/vnd.kde.kformula kfo
+application/vnd.kde.kivio flw
+application/vnd.kde.kontour kon
+application/vnd.kde.kpresenter kpr kpt
+application/vnd.kde.kspread ksp
+application/vnd.kde.kword kwd kwt
+application/vnd.kenameaapp htke
+application/vnd.kidspiration kia
+application/vnd.kinar kne knp
+application/vnd.koan skp skd skt skm
+application/vnd.kodak-descriptor sse
+application/vnd.las.las+xml lasxml
+# application/vnd.liberty-request+xml
+application/vnd.llamagraphics.life-balance.desktop lbd
+application/vnd.llamagraphics.life-balance.exchange+xml lbe
+application/vnd.lotus-1-2-3 123
+application/vnd.lotus-approach apr
+application/vnd.lotus-freelance pre
+application/vnd.lotus-notes nsf
+application/vnd.lotus-organizer org
+application/vnd.lotus-screencam scm
+application/vnd.lotus-wordpro lwp
+application/vnd.macports.portpkg portpkg
+# application/vnd.marlin.drm.actiontoken+xml
+# application/vnd.marlin.drm.conftoken+xml
+# application/vnd.marlin.drm.license+xml
+# application/vnd.marlin.drm.mdcf
+application/vnd.mcd mcd
+application/vnd.medcalcdata mc1
+application/vnd.mediastation.cdkey cdkey
+# application/vnd.meridian-slingshot
+application/vnd.mfer mwf
+application/vnd.mfmp mfm
+application/vnd.micrografx.flo flo
+application/vnd.micrografx.igx igx
+application/vnd.mif mif
+# application/vnd.minisoft-hp3000-save
+# application/vnd.mitsubishi.misty-guard.trustweb
+application/vnd.mobius.daf daf
+application/vnd.mobius.dis dis
+application/vnd.mobius.mbk mbk
+application/vnd.mobius.mqy mqy
+application/vnd.mobius.msl msl
+application/vnd.mobius.plc plc
+application/vnd.mobius.txf txf
+application/vnd.mophun.application mpn
+application/vnd.mophun.certificate mpc
+# application/vnd.motorola.flexsuite
+# application/vnd.motorola.flexsuite.adsi
+# application/vnd.motorola.flexsuite.fis
+# application/vnd.motorola.flexsuite.gotap
+# application/vnd.motorola.flexsuite.kmr
+# application/vnd.motorola.flexsuite.ttc
+# application/vnd.motorola.flexsuite.wem
+# application/vnd.motorola.iprm
+application/vnd.mozilla.xul+xml xul
+application/vnd.ms-artgalry cil
+# application/vnd.ms-asf
+application/vnd.ms-cab-compressed cab
+# application/vnd.ms-color.iccprofile
+application/vnd.ms-excel xls xlm xla xlc xlt xlw
+application/vnd.ms-excel.addin.macroenabled.12 xlam
+application/vnd.ms-excel.sheet.binary.macroenabled.12 xlsb
+application/vnd.ms-excel.sheet.macroenabled.12 xlsm
+application/vnd.ms-excel.template.macroenabled.12 xltm
+application/vnd.ms-fontobject eot
+application/vnd.ms-htmlhelp chm
+application/vnd.ms-ims ims
+application/vnd.ms-lrm lrm
+# application/vnd.ms-office.activex+xml
+application/vnd.ms-officetheme thmx
+# application/vnd.ms-opentype
+# application/vnd.ms-package.obfuscated-opentype
+application/vnd.ms-pki.seccat cat
+application/vnd.ms-pki.stl stl
+# application/vnd.ms-playready.initiator+xml
+application/vnd.ms-powerpoint ppt pps pot
+application/vnd.ms-powerpoint.addin.macroenabled.12 ppam
+application/vnd.ms-powerpoint.presentation.macroenabled.12 pptm
+application/vnd.ms-powerpoint.slide.macroenabled.12 sldm
+application/vnd.ms-powerpoint.slideshow.macroenabled.12 ppsm
+application/vnd.ms-powerpoint.template.macroenabled.12 potm
+# application/vnd.ms-printing.printticket+xml
+application/vnd.ms-project mpp mpt
+# application/vnd.ms-tnef
+# application/vnd.ms-wmdrm.lic-chlg-req
+# application/vnd.ms-wmdrm.lic-resp
+# application/vnd.ms-wmdrm.meter-chlg-req
+# application/vnd.ms-wmdrm.meter-resp
+application/vnd.ms-word.document.macroenabled.12 docm
+application/vnd.ms-word.template.macroenabled.12 dotm
+application/vnd.ms-works wps wks wcm wdb
+application/vnd.ms-wpl wpl
+application/vnd.ms-xpsdocument xps
+application/vnd.mseq mseq
+# application/vnd.msign
+# application/vnd.multiad.creator
+# application/vnd.multiad.creator.cif
+# application/vnd.music-niff
+application/vnd.musician mus
+application/vnd.muvee.style msty
+application/vnd.mynfc taglet
+# application/vnd.ncd.control
+# application/vnd.ncd.reference
+# application/vnd.nervana
+# application/vnd.netfpx
+application/vnd.neurolanguage.nlu nlu
+application/vnd.nitf ntf nitf
+application/vnd.noblenet-directory nnd
+application/vnd.noblenet-sealer nns
+application/vnd.noblenet-web nnw
+# application/vnd.nokia.catalogs
+# application/vnd.nokia.conml+wbxml
+# application/vnd.nokia.conml+xml
+# application/vnd.nokia.isds-radio-presets
+# application/vnd.nokia.iptv.config+xml
+# application/vnd.nokia.landmark+wbxml
+# application/vnd.nokia.landmark+xml
+# application/vnd.nokia.landmarkcollection+xml
+# application/vnd.nokia.n-gage.ac+xml
+application/vnd.nokia.n-gage.data ngdat
+application/vnd.nokia.n-gage.symbian.install n-gage
+# application/vnd.nokia.ncd
+# application/vnd.nokia.pcd+wbxml
+# application/vnd.nokia.pcd+xml
+application/vnd.nokia.radio-preset rpst
+application/vnd.nokia.radio-presets rpss
+application/vnd.novadigm.edm edm
+application/vnd.novadigm.edx edx
+application/vnd.novadigm.ext ext
+# application/vnd.ntt-local.file-transfer
+# application/vnd.ntt-local.sip-ta_remote
+# application/vnd.ntt-local.sip-ta_tcp_stream
+application/vnd.oasis.opendocument.chart odc
+application/vnd.oasis.opendocument.chart-template otc
+application/vnd.oasis.opendocument.database odb
+application/vnd.oasis.opendocument.formula odf
+application/vnd.oasis.opendocument.formula-template odft
+application/vnd.oasis.opendocument.graphics odg
+application/vnd.oasis.opendocument.graphics-template otg
+application/vnd.oasis.opendocument.image odi
+application/vnd.oasis.opendocument.image-template oti
+application/vnd.oasis.opendocument.presentation odp
+application/vnd.oasis.opendocument.presentation-template otp
+application/vnd.oasis.opendocument.spreadsheet ods
+application/vnd.oasis.opendocument.spreadsheet-template ots
+application/vnd.oasis.opendocument.text odt
+application/vnd.oasis.opendocument.text-master odm
+application/vnd.oasis.opendocument.text-template ott
+application/vnd.oasis.opendocument.text-web oth
+# application/vnd.obn
+# application/vnd.oftn.l10n+json
+# application/vnd.oipf.contentaccessdownload+xml
+# application/vnd.oipf.contentaccessstreaming+xml
+# application/vnd.oipf.cspg-hexbinary
+# application/vnd.oipf.dae.svg+xml
+# application/vnd.oipf.dae.xhtml+xml
+# application/vnd.oipf.mippvcontrolmessage+xml
+# application/vnd.oipf.pae.gem
+# application/vnd.oipf.spdiscovery+xml
+# application/vnd.oipf.spdlist+xml
+# application/vnd.oipf.ueprofile+xml
+# application/vnd.oipf.userprofile+xml
+application/vnd.olpc-sugar xo
+# application/vnd.oma-scws-config
+# application/vnd.oma-scws-http-request
+# application/vnd.oma-scws-http-response
+# application/vnd.oma.bcast.associated-procedure-parameter+xml
+# application/vnd.oma.bcast.drm-trigger+xml
+# application/vnd.oma.bcast.imd+xml
+# application/vnd.oma.bcast.ltkm
+# application/vnd.oma.bcast.notification+xml
+# application/vnd.oma.bcast.provisioningtrigger
+# application/vnd.oma.bcast.sgboot
+# application/vnd.oma.bcast.sgdd+xml
+# application/vnd.oma.bcast.sgdu
+# application/vnd.oma.bcast.simple-symbol-container
+# application/vnd.oma.bcast.smartcard-trigger+xml
+# application/vnd.oma.bcast.sprov+xml
+# application/vnd.oma.bcast.stkm
+# application/vnd.oma.cab-address-book+xml
+# application/vnd.oma.cab-feature-handler+xml
+# application/vnd.oma.cab-pcc+xml
+# application/vnd.oma.cab-user-prefs+xml
+# application/vnd.oma.dcd
+# application/vnd.oma.dcdc
+application/vnd.oma.dd2+xml dd2
+# application/vnd.oma.drm.risd+xml
+# application/vnd.oma.group-usage-list+xml
+# application/vnd.oma.pal+xml
+# application/vnd.oma.poc.detailed-progress-report+xml
+# application/vnd.oma.poc.final-report+xml
+# application/vnd.oma.poc.groups+xml
+# application/vnd.oma.poc.invocation-descriptor+xml
+# application/vnd.oma.poc.optimized-progress-report+xml
+# application/vnd.oma.push
+# application/vnd.oma.scidm.messages+xml
+# application/vnd.oma.xcap-directory+xml
+# application/vnd.omads-email+xml
+# application/vnd.omads-file+xml
+# application/vnd.omads-folder+xml
+# application/vnd.omaloc-supl-init
+application/vnd.openofficeorg.extension oxt
+# application/vnd.openxmlformats-officedocument.custom-properties+xml
+# application/vnd.openxmlformats-officedocument.customxmlproperties+xml
+# application/vnd.openxmlformats-officedocument.drawing+xml
+# application/vnd.openxmlformats-officedocument.drawingml.chart+xml
+# application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml
+# application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml
+# application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml
+# application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml
+# application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml
+# application/vnd.openxmlformats-officedocument.extended-properties+xml
+# application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml
+# application/vnd.openxmlformats-officedocument.presentationml.comments+xml
+# application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml
+# application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml
+# application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml
+application/vnd.openxmlformats-officedocument.presentationml.presentation pptx
+# application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml
+# application/vnd.openxmlformats-officedocument.presentationml.presprops+xml
+application/vnd.openxmlformats-officedocument.presentationml.slide sldx
+# application/vnd.openxmlformats-officedocument.presentationml.slide+xml
+# application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml
+# application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml
+application/vnd.openxmlformats-officedocument.presentationml.slideshow ppsx
+# application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml
+# application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml
+# application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml
+# application/vnd.openxmlformats-officedocument.presentationml.tags+xml
+application/vnd.openxmlformats-officedocument.presentationml.template potx
+# application/vnd.openxmlformats-officedocument.presentationml.template.main+xml
+# application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml
+application/vnd.openxmlformats-officedocument.spreadsheetml.sheet xlsx
+# application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml
+application/vnd.openxmlformats-officedocument.spreadsheetml.template xltx
+# application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml
+# application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml
+# application/vnd.openxmlformats-officedocument.theme+xml
+# application/vnd.openxmlformats-officedocument.themeoverride+xml
+# application/vnd.openxmlformats-officedocument.vmldrawing
+# application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml
+application/vnd.openxmlformats-officedocument.wordprocessingml.document docx
+# application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml
+# application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml
+# application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml
+# application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml
+# application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml
+# application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml
+# application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml
+# application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml
+# application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml
+application/vnd.openxmlformats-officedocument.wordprocessingml.template dotx
+# application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml
+# application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml
+# application/vnd.openxmlformats-package.core-properties+xml
+# application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml
+# application/vnd.openxmlformats-package.relationships+xml
+# application/vnd.quobject-quoxdocument
+# application/vnd.osa.netdeploy
+application/vnd.osgeo.mapguide.package mgp
+# application/vnd.osgi.bundle
+application/vnd.osgi.dp dp
+application/vnd.osgi.subsystem esa
+# application/vnd.otps.ct-kip+xml
+application/vnd.palm pdb pqa oprc
+# application/vnd.paos.xml
+application/vnd.pawaafile paw
+application/vnd.pg.format str
+application/vnd.pg.osasli ei6
+# application/vnd.piaccess.application-licence
+application/vnd.picsel efif
+application/vnd.pmi.widget wg
+# application/vnd.poc.group-advertisement+xml
+application/vnd.pocketlearn plf
+application/vnd.powerbuilder6 pbd
+# application/vnd.powerbuilder6-s
+# application/vnd.powerbuilder7
+# application/vnd.powerbuilder7-s
+# application/vnd.powerbuilder75
+# application/vnd.powerbuilder75-s
+# application/vnd.preminet
+application/vnd.previewsystems.box box
+application/vnd.proteus.magazine mgz
+application/vnd.publishare-delta-tree qps
+application/vnd.pvi.ptid1 ptid
+# application/vnd.pwg-multiplexed
+# application/vnd.pwg-xhtml-print+xml
+# application/vnd.qualcomm.brew-app-res
+application/vnd.quark.quarkxpress qxd qxt qwd qwt qxl qxb
+# application/vnd.radisys.moml+xml
+# application/vnd.radisys.msml+xml
+# application/vnd.radisys.msml-audit+xml
+# application/vnd.radisys.msml-audit-conf+xml
+# application/vnd.radisys.msml-audit-conn+xml
+# application/vnd.radisys.msml-audit-dialog+xml
+# application/vnd.radisys.msml-audit-stream+xml
+# application/vnd.radisys.msml-conf+xml
+# application/vnd.radisys.msml-dialog+xml
+# application/vnd.radisys.msml-dialog-base+xml
+# application/vnd.radisys.msml-dialog-fax-detect+xml
+# application/vnd.radisys.msml-dialog-fax-sendrecv+xml
+# application/vnd.radisys.msml-dialog-group+xml
+# application/vnd.radisys.msml-dialog-speech+xml
+# application/vnd.radisys.msml-dialog-transform+xml
+# application/vnd.rainstor.data
+# application/vnd.rapid
+application/vnd.realvnc.bed bed
+application/vnd.recordare.musicxml mxl
+application/vnd.recordare.musicxml+xml musicxml
+# application/vnd.renlearn.rlprint
+application/vnd.rig.cryptonote cryptonote
+application/vnd.rim.cod cod
+application/vnd.rn-realmedia rm
+application/vnd.rn-realmedia-vbr rmvb
+application/vnd.route66.link66+xml link66
+# application/vnd.rs-274x
+# application/vnd.ruckus.download
+# application/vnd.s3sms
+application/vnd.sailingtracker.track st
+# application/vnd.sbm.cid
+# application/vnd.sbm.mid2
+# application/vnd.scribus
+# application/vnd.sealed.3df
+# application/vnd.sealed.csf
+# application/vnd.sealed.doc
+# application/vnd.sealed.eml
+# application/vnd.sealed.mht
+# application/vnd.sealed.net
+# application/vnd.sealed.ppt
+# application/vnd.sealed.tiff
+# application/vnd.sealed.xls
+# application/vnd.sealedmedia.softseal.html
+# application/vnd.sealedmedia.softseal.pdf
+application/vnd.seemail see
+application/vnd.sema sema
+application/vnd.semd semd
+application/vnd.semf semf
+application/vnd.shana.informed.formdata ifm
+application/vnd.shana.informed.formtemplate itp
+application/vnd.shana.informed.interchange iif
+application/vnd.shana.informed.package ipk
+application/vnd.simtech-mindmapper twd twds
+application/vnd.smaf mmf
+# application/vnd.smart.notebook
+application/vnd.smart.teacher teacher
+# application/vnd.software602.filler.form+xml
+# application/vnd.software602.filler.form-xml-zip
+application/vnd.solent.sdkm+xml sdkm sdkd
+application/vnd.spotfire.dxp dxp
+application/vnd.spotfire.sfs sfs
+# application/vnd.sss-cod
+# application/vnd.sss-dtf
+# application/vnd.sss-ntf
+application/vnd.stardivision.calc sdc
+application/vnd.stardivision.draw sda
+application/vnd.stardivision.impress sdd
+application/vnd.stardivision.math smf
+application/vnd.stardivision.writer sdw vor
+application/vnd.stardivision.writer-global sgl
+application/vnd.stepmania.package smzip
+application/vnd.stepmania.stepchart sm
+# application/vnd.street-stream
+application/vnd.sun.xml.calc sxc
+application/vnd.sun.xml.calc.template stc
+application/vnd.sun.xml.draw sxd
+application/vnd.sun.xml.draw.template std
+application/vnd.sun.xml.impress sxi
+application/vnd.sun.xml.impress.template sti
+application/vnd.sun.xml.math sxm
+application/vnd.sun.xml.writer sxw
+application/vnd.sun.xml.writer.global sxg
+application/vnd.sun.xml.writer.template stw
+# application/vnd.sun.wadl+xml
+application/vnd.sus-calendar sus susp
+application/vnd.svd svd
+# application/vnd.swiftview-ics
+application/vnd.symbian.install sis sisx
+application/vnd.syncml+xml xsm
+application/vnd.syncml.dm+wbxml bdm
+application/vnd.syncml.dm+xml xdm
+# application/vnd.syncml.dm.notification
+# application/vnd.syncml.ds.notification
+application/vnd.tao.intent-module-archive tao
+application/vnd.tcpdump.pcap pcap cap dmp
+application/vnd.tmobile-livetv tmo
+application/vnd.trid.tpt tpt
+application/vnd.triscape.mxs mxs
+application/vnd.trueapp tra
+# application/vnd.truedoc
+# application/vnd.ubisoft.webplayer
+application/vnd.ufdl ufd ufdl
+application/vnd.uiq.theme utz
+application/vnd.umajin umj
+application/vnd.unity unityweb
+application/vnd.uoml+xml uoml
+# application/vnd.uplanet.alert
+# application/vnd.uplanet.alert-wbxml
+# application/vnd.uplanet.bearer-choice
+# application/vnd.uplanet.bearer-choice-wbxml
+# application/vnd.uplanet.cacheop
+# application/vnd.uplanet.cacheop-wbxml
+# application/vnd.uplanet.channel
+# application/vnd.uplanet.channel-wbxml
+# application/vnd.uplanet.list
+# application/vnd.uplanet.list-wbxml
+# application/vnd.uplanet.listcmd
+# application/vnd.uplanet.listcmd-wbxml
+# application/vnd.uplanet.signal
+application/vnd.vcx vcx
+# application/vnd.vd-study
+# application/vnd.vectorworks
+# application/vnd.verimatrix.vcas
+# application/vnd.vidsoft.vidconference
+application/vnd.visio vsd vst vss vsw
+application/vnd.visionary vis
+# application/vnd.vividence.scriptfile
+application/vnd.vsf vsf
+# application/vnd.wap.sic
+# application/vnd.wap.slc
+application/vnd.wap.wbxml wbxml
+application/vnd.wap.wmlc wmlc
+application/vnd.wap.wmlscriptc wmlsc
+application/vnd.webturbo wtb
+# application/vnd.wfa.wsc
+# application/vnd.wmc
+# application/vnd.wmf.bootstrap
+# application/vnd.wolfram.mathematica
+# application/vnd.wolfram.mathematica.package
+application/vnd.wolfram.player nbp
+application/vnd.wordperfect wpd
+application/vnd.wqd wqd
+# application/vnd.wrq-hp3000-labelled
+application/vnd.wt.stf stf
+# application/vnd.wv.csp+wbxml
+# application/vnd.wv.csp+xml
+# application/vnd.wv.ssp+xml
+application/vnd.xara xar
+application/vnd.xfdl xfdl
+# application/vnd.xfdl.webform
+# application/vnd.xmi+xml
+# application/vnd.xmpie.cpkg
+# application/vnd.xmpie.dpkg
+# application/vnd.xmpie.plan
+# application/vnd.xmpie.ppkg
+# application/vnd.xmpie.xlim
+application/vnd.yamaha.hv-dic hvd
+application/vnd.yamaha.hv-script hvs
+application/vnd.yamaha.hv-voice hvp
+application/vnd.yamaha.openscoreformat osf
+application/vnd.yamaha.openscoreformat.osfpvg+xml osfpvg
+# application/vnd.yamaha.remote-setup
+application/vnd.yamaha.smaf-audio saf
+application/vnd.yamaha.smaf-phrase spf
+# application/vnd.yamaha.through-ngn
+# application/vnd.yamaha.tunnel-udpencap
+application/vnd.yellowriver-custom-menu cmp
+application/vnd.zul zir zirz
+application/vnd.zzazz.deck+xml zaz
+application/voicexml+xml vxml
+# application/vq-rtcpxr
+# application/watcherinfo+xml
+# application/whoispp-query
+# application/whoispp-response
+application/widget wgt
+application/winhlp hlp
+# application/wita
+# application/wordperfect5.1
+application/wsdl+xml wsdl
+application/wspolicy+xml wspolicy
+application/x-7z-compressed 7z
+application/x-abiword abw
+application/x-ace-compressed ace
+# application/x-amf
+application/x-apple-diskimage dmg
+application/x-authorware-bin aab x32 u32 vox
+application/x-authorware-map aam
+application/x-authorware-seg aas
+application/x-bcpio bcpio
+application/x-bittorrent torrent
+application/x-blorb blb blorb
+application/x-bzip bz
+application/x-bzip2 bz2 boz
+application/x-cbr cbr cba cbt cbz cb7
+application/x-cdlink vcd
+application/x-cfs-compressed cfs
+application/x-chat chat
+application/x-chess-pgn pgn
+application/x-conference nsc
+# application/x-compress
+application/x-cpio cpio
+application/x-csh csh
+application/x-debian-package deb udeb
+application/x-dgc-compressed dgc
+application/x-director dir dcr dxr cst cct cxt w3d fgd swa
+application/x-doom wad
+application/x-dtbncx+xml ncx
+application/x-dtbook+xml dtb
+application/x-dtbresource+xml res
+application/x-dvi dvi
+application/x-envoy evy
+application/x-eva eva
+application/x-font-bdf bdf
+# application/x-font-dos
+# application/x-font-framemaker
+application/x-font-ghostscript gsf
+# application/x-font-libgrx
+application/x-font-linux-psf psf
+application/x-font-otf otf
+application/x-font-pcf pcf
+application/x-font-snf snf
+# application/x-font-speedo
+# application/x-font-sunos-news
+application/x-font-ttf ttf ttc
+application/x-font-type1 pfa pfb pfm afm
+application/font-woff woff
+# application/x-font-vfont
+application/x-freearc arc
+application/x-futuresplash spl
+application/x-gca-compressed gca
+application/x-glulx ulx
+application/x-gnumeric gnumeric
+application/x-gramps-xml gramps
+application/x-gtar gtar
+# application/x-gzip
+application/x-hdf hdf
+application/x-install-instructions install
+application/x-iso9660-image iso
+application/x-java-jnlp-file jnlp
+application/x-latex latex
+application/x-lzh-compressed lzh lha
+application/x-mie mie
+application/x-mobipocket-ebook prc mobi
+application/x-ms-application application
+application/x-ms-shortcut lnk
+application/x-ms-wmd wmd
+application/x-ms-wmz wmz
+application/x-ms-xbap xbap
+application/x-msaccess mdb
+application/x-msbinder obd
+application/x-mscardfile crd
+application/x-msclip clp
+application/x-msdownload exe dll com bat msi
+application/x-msmediaview mvb m13 m14
+application/x-msmetafile wmf wmz emf emz
+application/x-msmoney mny
+application/x-mspublisher pub
+application/x-msschedule scd
+application/x-msterminal trm
+application/x-mswrite wri
+application/x-netcdf nc cdf
+application/x-nzb nzb
+application/x-pkcs12 p12 pfx
+application/x-pkcs7-certificates p7b spc
+application/x-pkcs7-certreqresp p7r
+application/x-rar-compressed rar
+application/x-research-info-systems ris
+application/x-sh sh
+application/x-shar shar
+application/x-shockwave-flash swf
+application/x-silverlight-app xap
+application/x-sql sql
+application/x-stuffit sit
+application/x-stuffitx sitx
+application/x-subrip srt
+application/x-sv4cpio sv4cpio
+application/x-sv4crc sv4crc
+application/x-t3vm-image t3
+application/x-tads gam
+application/x-tar tar
+application/x-tcl tcl
+application/x-tex tex
+application/x-tex-tfm tfm
+application/x-texinfo texinfo texi
+application/x-tgif obj
+application/x-ustar ustar
+application/x-wais-source src
+application/x-x509-ca-cert der crt
+application/x-xfig fig
+application/x-xliff+xml xlf
+application/x-xpinstall xpi
+application/x-xz xz
+application/x-zmachine z1 z2 z3 z4 z5 z6 z7 z8
+# application/x400-bp
+application/xaml+xml xaml
+# application/xcap-att+xml
+# application/xcap-caps+xml
+application/xcap-diff+xml xdf
+# application/xcap-el+xml
+# application/xcap-error+xml
+# application/xcap-ns+xml
+# application/xcon-conference-info-diff+xml
+# application/xcon-conference-info+xml
+application/xenc+xml xenc
+application/xhtml+xml xhtml xht
+# application/xhtml-voice+xml
+application/xml xml xsl
+application/xml-dtd dtd
+# application/xml-external-parsed-entity
+# application/xmpp+xml
+application/xop+xml xop
+application/xproc+xml xpl
+application/xslt+xml xslt
+application/xspf+xml xspf
+application/xv+xml mxml xhvml xvml xvm
+application/yang yang
+application/yin+xml yin
+application/zip zip
+# audio/1d-interleaved-parityfec
+# audio/32kadpcm
+# audio/3gpp
+# audio/3gpp2
+# audio/ac3
+audio/adpcm adp
+# audio/amr
+# audio/amr-wb
+# audio/amr-wb+
+# audio/asc
+# audio/atrac-advanced-lossless
+# audio/atrac-x
+# audio/atrac3
+audio/basic au snd
+# audio/bv16
+# audio/bv32
+# audio/clearmode
+# audio/cn
+# audio/dat12
+# audio/dls
+# audio/dsr-es201108
+# audio/dsr-es202050
+# audio/dsr-es202211
+# audio/dsr-es202212
+# audio/dv
+# audio/dvi4
+# audio/eac3
+# audio/evrc
+# audio/evrc-qcp
+# audio/evrc0
+# audio/evrc1
+# audio/evrcb
+# audio/evrcb0
+# audio/evrcb1
+# audio/evrcwb
+# audio/evrcwb0
+# audio/evrcwb1
+# audio/example
+# audio/fwdred
+# audio/g719
+# audio/g722
+# audio/g7221
+# audio/g723
+# audio/g726-16
+# audio/g726-24
+# audio/g726-32
+# audio/g726-40
+# audio/g728
+# audio/g729
+# audio/g7291
+# audio/g729d
+# audio/g729e
+# audio/gsm
+# audio/gsm-efr
+# audio/gsm-hr-08
+# audio/ilbc
+# audio/ip-mr_v2.5
+# audio/isac
+# audio/l16
+# audio/l20
+# audio/l24
+# audio/l8
+# audio/lpc
+audio/midi mid midi kar rmi
+# audio/mobile-xmf
+audio/mp4 mp4a
+# audio/mp4a-latm
+# audio/mpa
+# audio/mpa-robust
+audio/mpeg mpga mp2 mp2a mp3 m2a m3a
+# audio/mpeg4-generic
+# audio/musepack
+audio/ogg oga ogg spx
+# audio/opus
+# audio/parityfec
+# audio/pcma
+# audio/pcma-wb
+# audio/pcmu-wb
+# audio/pcmu
+# audio/prs.sid
+# audio/qcelp
+# audio/red
+# audio/rtp-enc-aescm128
+# audio/rtp-midi
+# audio/rtx
+audio/s3m s3m
+audio/silk sil
+# audio/smv
+# audio/smv0
+# audio/smv-qcp
+# audio/sp-midi
+# audio/speex
+# audio/t140c
+# audio/t38
+# audio/telephone-event
+# audio/tone
+# audio/uemclip
+# audio/ulpfec
+# audio/vdvi
+# audio/vmr-wb
+# audio/vnd.3gpp.iufp
+# audio/vnd.4sb
+# audio/vnd.audiokoz
+# audio/vnd.celp
+# audio/vnd.cisco.nse
+# audio/vnd.cmles.radio-events
+# audio/vnd.cns.anp1
+# audio/vnd.cns.inf1
+audio/vnd.dece.audio uva uvva
+audio/vnd.digital-winds eol
+# audio/vnd.dlna.adts
+# audio/vnd.dolby.heaac.1
+# audio/vnd.dolby.heaac.2
+# audio/vnd.dolby.mlp
+# audio/vnd.dolby.mps
+# audio/vnd.dolby.pl2
+# audio/vnd.dolby.pl2x
+# audio/vnd.dolby.pl2z
+# audio/vnd.dolby.pulse.1
+audio/vnd.dra dra
+audio/vnd.dts dts
+audio/vnd.dts.hd dtshd
+# audio/vnd.dvb.file
+# audio/vnd.everad.plj
+# audio/vnd.hns.audio
+audio/vnd.lucent.voice lvp
+audio/vnd.ms-playready.media.pya pya
+# audio/vnd.nokia.mobile-xmf
+# audio/vnd.nortel.vbk
+audio/vnd.nuera.ecelp4800 ecelp4800
+audio/vnd.nuera.ecelp7470 ecelp7470
+audio/vnd.nuera.ecelp9600 ecelp9600
+# audio/vnd.octel.sbc
+# audio/vnd.qcelp
+# audio/vnd.rhetorex.32kadpcm
+audio/vnd.rip rip
+# audio/vnd.sealedmedia.softseal.mpeg
+# audio/vnd.vmx.cvsd
+# audio/vorbis
+# audio/vorbis-config
+audio/webm weba
+audio/x-aac aac
+audio/x-aiff aif aiff aifc
+audio/x-caf caf
+audio/x-flac flac
+audio/x-matroska mka
+audio/x-mpegurl m3u
+audio/x-ms-wax wax
+audio/x-ms-wma wma
+audio/x-pn-realaudio ram ra
+audio/x-pn-realaudio-plugin rmp
+# audio/x-tta
+audio/x-wav wav
+audio/xm xm
+chemical/x-cdx cdx
+chemical/x-cif cif
+chemical/x-cmdf cmdf
+chemical/x-cml cml
+chemical/x-csml csml
+# chemical/x-pdb
+chemical/x-xyz xyz
+image/bmp bmp
+image/cgm cgm
+# image/example
+# image/fits
+image/g3fax g3
+image/gif gif
+image/ief ief
+# image/jp2
+image/jpeg jpeg jpg jpe
+# image/jpm
+# image/jpx
+image/ktx ktx
+# image/naplps
+image/png png
+image/prs.btif btif
+# image/prs.pti
+image/sgi sgi
+image/svg+xml svg svgz
+# image/t38
+image/tiff tiff tif
+# image/tiff-fx
+image/vnd.adobe.photoshop psd
+# image/vnd.cns.inf2
+image/vnd.dece.graphic uvi uvvi uvg uvvg
+image/vnd.dvb.subtitle sub
+image/vnd.djvu djvu djv
+image/vnd.dwg dwg
+image/vnd.dxf dxf
+image/vnd.fastbidsheet fbs
+image/vnd.fpx fpx
+image/vnd.fst fst
+image/vnd.fujixerox.edmics-mmr mmr
+image/vnd.fujixerox.edmics-rlc rlc
+# image/vnd.globalgraphics.pgb
+# image/vnd.microsoft.icon
+# image/vnd.mix
+image/vnd.ms-modi mdi
+image/vnd.ms-photo wdp
+image/vnd.net-fpx npx
+# image/vnd.radiance
+# image/vnd.sealed.png
+# image/vnd.sealedmedia.softseal.gif
+# image/vnd.sealedmedia.softseal.jpg
+# image/vnd.svf
+image/vnd.wap.wbmp wbmp
+image/vnd.xiff xif
+image/webp webp
+image/x-3ds 3ds
+image/x-cmu-raster ras
+image/x-cmx cmx
+image/x-freehand fh fhc fh4 fh5 fh7
+image/x-icon ico
+image/x-mrsid-image sid
+image/x-pcx pcx
+image/x-pict pic pct
+image/x-portable-anymap pnm
+image/x-portable-bitmap pbm
+image/x-portable-graymap pgm
+image/x-portable-pixmap ppm
+image/x-rgb rgb
+image/x-tga tga
+image/x-xbitmap xbm
+image/x-xpixmap xpm
+image/x-xwindowdump xwd
+# message/cpim
+# message/delivery-status
+# message/disposition-notification
+# message/example
+# message/external-body
+# message/feedback-report
+# message/global
+# message/global-delivery-status
+# message/global-disposition-notification
+# message/global-headers
+# message/http
+# message/imdn+xml
+# message/news
+# message/partial
+message/rfc822 eml mime
+# message/s-http
+# message/sip
+# message/sipfrag
+# message/tracking-status
+# message/vnd.si.simp
+# model/example
+model/iges igs iges
+model/mesh msh mesh silo
+model/vnd.collada+xml dae
+model/vnd.dwf dwf
+# model/vnd.flatland.3dml
+model/vnd.gdl gdl
+# model/vnd.gs-gdl
+# model/vnd.gs.gdl
+model/vnd.gtw gtw
+# model/vnd.moml+xml
+model/vnd.mts mts
+# model/vnd.parasolid.transmit.binary
+# model/vnd.parasolid.transmit.text
+model/vnd.vtu vtu
+model/vrml wrl vrml
+model/x3d+binary x3db x3dbz
+model/x3d+vrml x3dv x3dvz
+model/x3d+xml x3d x3dz
+# multipart/alternative
+# multipart/appledouble
+# multipart/byteranges
+# multipart/digest
+# multipart/encrypted
+# multipart/example
+# multipart/form-data
+# multipart/header-set
+# multipart/mixed
+# multipart/parallel
+# multipart/related
+# multipart/report
+# multipart/signed
+# multipart/voice-message
+# text/1d-interleaved-parityfec
+text/cache-manifest appcache
+text/calendar ics ifb
+text/css css
+text/csv csv
+# text/directory
+# text/dns
+# text/ecmascript
+# text/enriched
+# text/example
+# text/fwdred
+text/html html htm
+# text/javascript
+text/n3 n3
+# text/parityfec
+text/plain txt text conf def list log in
+# text/prs.fallenstein.rst
+text/prs.lines.tag dsc
+# text/vnd.radisys.msml-basic-layout
+# text/red
+# text/rfc822-headers
+text/richtext rtx
+# text/rtf
+# text/rtp-enc-aescm128
+# text/rtx
+text/sgml sgml sgm
+# text/t140
+text/tab-separated-values tsv
+text/troff t tr roff man me ms
+text/turtle ttl
+# text/ulpfec
+text/uri-list uri uris urls
+text/vcard vcard
+# text/vnd.abc
+text/vnd.curl curl
+text/vnd.curl.dcurl dcurl
+text/vnd.curl.scurl scurl
+text/vnd.curl.mcurl mcurl
+# text/vnd.dmclientscript
+text/vnd.dvb.subtitle sub
+# text/vnd.esmertec.theme-descriptor
+text/vnd.fly fly
+text/vnd.fmi.flexstor flx
+text/vnd.graphviz gv
+text/vnd.in3d.3dml 3dml
+text/vnd.in3d.spot spot
+# text/vnd.iptc.newsml
+# text/vnd.iptc.nitf
+# text/vnd.latex-z
+# text/vnd.motorola.reflex
+# text/vnd.ms-mediapackage
+# text/vnd.net2phone.commcenter.command
+# text/vnd.si.uricatalogue
+text/vnd.sun.j2me.app-descriptor jad
+# text/vnd.trolltech.linguist
+# text/vnd.wap.si
+# text/vnd.wap.sl
+text/vnd.wap.wml wml
+text/vnd.wap.wmlscript wmls
+text/x-asm s asm
+text/x-c c cc cxx cpp h hh dic
+text/x-fortran f for f77 f90
+text/x-java-source java
+text/x-opml opml
+text/x-pascal p pas
+text/x-nfo nfo
+text/x-setext etx
+text/x-sfv sfv
+text/x-uuencode uu
+text/x-vcalendar vcs
+text/x-vcard vcf
+# text/xml
+# text/xml-external-parsed-entity
+# video/1d-interleaved-parityfec
+video/3gpp 3gp
+# video/3gpp-tt
+video/3gpp2 3g2
+# video/bmpeg
+# video/bt656
+# video/celb
+# video/dv
+# video/example
+video/h261 h261
+video/h263 h263
+# video/h263-1998
+# video/h263-2000
+video/h264 h264
+# video/h264-rcdo
+# video/h264-svc
+video/jpeg jpgv
+# video/jpeg2000
+video/jpm jpm jpgm
+video/mj2 mj2 mjp2
+# video/mp1s
+# video/mp2p
+# video/mp2t
+video/mp4 mp4 mp4v mpg4
+# video/mp4v-es
+video/mpeg mpeg mpg mpe m1v m2v
+# video/mpeg4-generic
+# video/mpv
+# video/nv
+video/ogg ogv
+# video/parityfec
+# video/pointer
+video/quicktime qt mov
+# video/raw
+# video/rtp-enc-aescm128
+# video/rtx
+# video/smpte292m
+# video/ulpfec
+# video/vc1
+# video/vnd.cctv
+video/vnd.dece.hd uvh uvvh
+video/vnd.dece.mobile uvm uvvm
+# video/vnd.dece.mp4
+video/vnd.dece.pd uvp uvvp
+video/vnd.dece.sd uvs uvvs
+video/vnd.dece.video uvv uvvv
+# video/vnd.directv.mpeg
+# video/vnd.directv.mpeg-tts
+# video/vnd.dlna.mpeg-tts
+video/vnd.dvb.file dvb
+video/vnd.fvt fvt
+# video/vnd.hns.video
+# video/vnd.iptvforum.1dparityfec-1010
+# video/vnd.iptvforum.1dparityfec-2005
+# video/vnd.iptvforum.2dparityfec-1010
+# video/vnd.iptvforum.2dparityfec-2005
+# video/vnd.iptvforum.ttsavc
+# video/vnd.iptvforum.ttsmpeg2
+# video/vnd.motorola.video
+# video/vnd.motorola.videop
+video/vnd.mpegurl mxu m4u
+video/vnd.ms-playready.media.pyv pyv
+# video/vnd.nokia.interleaved-multimedia
+# video/vnd.nokia.videovoip
+# video/vnd.objectvideo
+# video/vnd.sealed.mpeg1
+# video/vnd.sealed.mpeg4
+# video/vnd.sealed.swf
+# video/vnd.sealedmedia.softseal.mov
+video/vnd.uvvu.mp4 uvu uvvu
+video/vnd.vivo viv
+video/webm webm
+video/x-f4v f4v
+video/x-fli fli
+video/x-flv flv
+video/x-m4v m4v
+video/x-matroska mkv mk3d mks
+video/x-mng mng
+video/x-ms-asf asf asx
+video/x-ms-vob vob
+video/x-ms-wm wm
+video/x-ms-wmv wmv
+video/x-ms-wmx wmx
+video/x-ms-wvx wvx
+video/x-msvideo avi
+video/x-sgi-movie movie
+video/x-smv smv
+x-conference/x-cooltalk ice
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/types/node.types b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/types/node.types
new file mode 100644
index 000000000..55b2cf794
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/mime/types/node.types
@@ -0,0 +1,77 @@
+# What: WebVTT
+# Why: To allow formats intended for marking up external text track resources.
+# http://dev.w3.org/html5/webvtt/
+# Added by: niftylettuce
+text/vtt vtt
+
+# What: Google Chrome Extension
+# Why: To allow apps to (work) be served with the right content type header.
+# http://codereview.chromium.org/2830017
+# Added by: niftylettuce
+application/x-chrome-extension crx
+
+# What: HTC support
+# Why: To properly render .htc files such as CSS3PIE
+# Added by: niftylettuce
+text/x-component htc
+
+# What: HTML5 application cache manifes ('.manifest' extension)
+# Why: De-facto standard. Required by Mozilla browser when serving HTML5 apps
+# per https://developer.mozilla.org/en/offline_resources_in_firefox
+# Added by: louisremi
+text/cache-manifest manifest
+
+# What: node binary buffer format
+# Why: semi-standard extension w/in the node community
+# Added by: tootallnate
+application/octet-stream buffer
+
+# What: The "protected" MP-4 formats used by iTunes.
+# Why: Required for streaming music to browsers (?)
+# Added by: broofa
+application/mp4 m4p
+audio/mp4 m4a
+
+# What: Video format, Part of RFC1890
+# Why: See https://github.com/bentomas/node-mime/pull/6
+# Added by: mjrusso
+video/MP2T ts
+
+# What: EventSource mime type
+# Why: mime type of Server-Sent Events stream
+# http://www.w3.org/TR/eventsource/#text-event-stream
+# Added by: francois2metz
+text/event-stream event-stream
+
+# What: Mozilla App manifest mime type
+# Why: https://developer.mozilla.org/en/Apps/Manifest#Serving_manifests
+# Added by: ednapiranha
+application/x-web-app-manifest+json webapp
+
+# What: Lua file types
+# Why: Googling around shows de-facto consensus on these
+# Added by: creationix (Issue #45)
+text/x-lua lua
+application/x-lua-bytecode luac
+
+# What: Markdown files, as per http://daringfireball.net/projects/markdown/syntax
+# Why: http://stackoverflow.com/questions/10701983/what-is-the-mime-type-for-markdown
+# Added by: avoidwork
+text/x-markdown markdown md mkd
+
+# What: ini files
+# Why: because they're just text files
+# Added by: Matthew Kastor
+text/plain ini
+
+# What: DASH Adaptive Streaming manifest
+# Why: https://developer.mozilla.org/en-US/docs/DASH_Adaptive_Streaming_for_HTML_5_Video
+# Added by: eelcocramer
+application/dash+xml mdp
+
+# What: OpenType font files - http://www.microsoft.com/typography/otspec/
+# Why: Browsers usually ignore the font MIME types and sniff the content,
+# but Chrome, shows a warning if OpenType fonts aren't served with
+# the `font/opentype` MIME type: http://i.imgur.com/8c5RN8M.png.
+# Added by: alrra
+font/opentype otf
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/.npmignore b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/.npmignore
new file mode 100644
index 000000000..9daeafb98
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/.npmignore
@@ -0,0 +1 @@
+test
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/History.md b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/History.md
new file mode 100644
index 000000000..82df7b1e4
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/History.md
@@ -0,0 +1,15 @@
+
+0.0.4 / 2012-06-17
+==================
+
+ * changed: ret -1 for unsatisfiable and -2 when invalid
+
+0.0.3 / 2012-06-17
+==================
+
+ * fix last-byte-pos default to len - 1
+
+0.0.2 / 2012-06-14
+==================
+
+ * add `.type`
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/Readme.md b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/Readme.md
new file mode 100644
index 000000000..b2a67fe83
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/Readme.md
@@ -0,0 +1,28 @@
+
+# node-range-parser
+
+ Range header field parser.
+
+## Example:
+
+```js
+assert(-1 == parse(200, 'bytes=500-20'));
+assert(-2 == parse(200, 'bytes=malformed'));
+parse(200, 'bytes=0-499').should.eql(arr('bytes', [{ start: 0, end: 199 }]));
+parse(1000, 'bytes=0-499').should.eql(arr('bytes', [{ start: 0, end: 499 }]));
+parse(1000, 'bytes=40-80').should.eql(arr('bytes', [{ start: 40, end: 80 }]));
+parse(1000, 'bytes=-500').should.eql(arr('bytes', [{ start: 500, end: 999 }]));
+parse(1000, 'bytes=-400').should.eql(arr('bytes', [{ start: 600, end: 999 }]));
+parse(1000, 'bytes=500-').should.eql(arr('bytes', [{ start: 500, end: 999 }]));
+parse(1000, 'bytes=400-').should.eql(arr('bytes', [{ start: 400, end: 999 }]));
+parse(1000, 'bytes=0-0').should.eql(arr('bytes', [{ start: 0, end: 0 }]));
+parse(1000, 'bytes=-1').should.eql(arr('bytes', [{ start: 999, end: 999 }]));
+parse(1000, 'items=0-5').should.eql(arr('items', [{ start: 0, end: 5 }]));
+parse(1000, 'bytes=40-80,-1').should.eql(arr('bytes', [{ start: 40, end: 80 }, { start: 999, end: 999 }]));
+```
+
+## Installation
+
+```
+$ npm install range-parser
+```
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/index.js b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/index.js
new file mode 100644
index 000000000..9b0f7a8ec
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/index.js
@@ -0,0 +1,49 @@
+
+/**
+ * Parse "Range" header `str` relative to the given file `size`.
+ *
+ * @param {Number} size
+ * @param {String} str
+ * @return {Array}
+ * @api public
+ */
+
+module.exports = function(size, str){
+ var valid = true;
+ var i = str.indexOf('=');
+
+ if (-1 == i) return -2;
+
+ var arr = str.slice(i + 1).split(',').map(function(range){
+ var range = range.split('-')
+ , start = parseInt(range[0], 10)
+ , end = parseInt(range[1], 10);
+
+ // -nnn
+ if (isNaN(start)) {
+ start = size - end;
+ end = size - 1;
+ // nnn-
+ } else if (isNaN(end)) {
+ end = size - 1;
+ }
+
+ // limit last-byte-pos to current length
+ if (end > size - 1) end = size - 1;
+
+ // invalid
+ if (isNaN(start)
+ || isNaN(end)
+ || start > end
+ || start < 0) valid = false;
+
+ return {
+ start: start,
+ end: end
+ };
+ });
+
+ arr.type = str.slice(0, i);
+
+ return valid ? arr : -1;
+};
\ No newline at end of file
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/package.json b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/package.json
new file mode 100644
index 000000000..efdf450a9
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/node_modules/range-parser/package.json
@@ -0,0 +1,20 @@
+{
+ "name": "range-parser",
+ "author": {
+ "name": "TJ Holowaychuk",
+ "email": "tj@vision-media.ca",
+ "url": "http://tjholowaychuk.com"
+ },
+ "description": "Range header field string parser",
+ "version": "0.0.4",
+ "main": "index.js",
+ "dependencies": {},
+ "devDependencies": {
+ "mocha": "*",
+ "should": "*"
+ },
+ "readme": "\n# node-range-parser\n\n Range header field parser.\n\n## Example:\n\n```js\nassert(-1 == parse(200, 'bytes=500-20'));\nassert(-2 == parse(200, 'bytes=malformed'));\nparse(200, 'bytes=0-499').should.eql(arr('bytes', [{ start: 0, end: 199 }]));\nparse(1000, 'bytes=0-499').should.eql(arr('bytes', [{ start: 0, end: 499 }]));\nparse(1000, 'bytes=40-80').should.eql(arr('bytes', [{ start: 40, end: 80 }]));\nparse(1000, 'bytes=-500').should.eql(arr('bytes', [{ start: 500, end: 999 }]));\nparse(1000, 'bytes=-400').should.eql(arr('bytes', [{ start: 600, end: 999 }]));\nparse(1000, 'bytes=500-').should.eql(arr('bytes', [{ start: 500, end: 999 }]));\nparse(1000, 'bytes=400-').should.eql(arr('bytes', [{ start: 400, end: 999 }]));\nparse(1000, 'bytes=0-0').should.eql(arr('bytes', [{ start: 0, end: 0 }]));\nparse(1000, 'bytes=-1').should.eql(arr('bytes', [{ start: 999, end: 999 }]));\nparse(1000, 'items=0-5').should.eql(arr('items', [{ start: 0, end: 5 }]));\nparse(1000, 'bytes=40-80,-1').should.eql(arr('bytes', [{ start: 40, end: 80 }, { start: 999, end: 999 }]));\n```\n\n## Installation\n\n```\n$ npm install range-parser\n```",
+ "readmeFilename": "Readme.md",
+ "_id": "range-parser@0.0.4",
+ "_from": "range-parser@0.0.4"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/send/package.json b/appshell/node-core/thirdparty/connect/node_modules/send/package.json
new file mode 100644
index 000000000..8a20f9d8a
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/send/package.json
@@ -0,0 +1,45 @@
+{
+ "name": "send",
+ "version": "0.1.4",
+ "description": "Better streaming static file server with Range and conditional-GET support",
+ "keywords": [
+ "static",
+ "file",
+ "server"
+ ],
+ "author": {
+ "name": "TJ Holowaychuk",
+ "email": "tj@vision-media.ca"
+ },
+ "dependencies": {
+ "debug": "*",
+ "mime": "~1.2.9",
+ "fresh": "0.2.0",
+ "range-parser": "0.0.4"
+ },
+ "devDependencies": {
+ "mocha": "*",
+ "should": "*",
+ "supertest": "0.0.1",
+ "connect": "2.x"
+ },
+ "scripts": {
+ "test": "make test"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/visionmedia/send.git"
+ },
+ "main": "index",
+ "readme": "# send\n\n Send is Connect's `static()` extracted for generalized use, a streaming static file\n server supporting partial responses (Ranges), conditional-GET negotiation, high test coverage, and granular events which may be leveraged to take appropriate actions in your application or framework.\n\n## Installation\n\n $ npm install send\n\n## Examples\n\n Small:\n\n```js\nvar http = require('http');\nvar send = require('send');\n\nvar app = http.createServer(function(req, res){\n send(req, req.url).pipe(res);\n}).listen(3000);\n```\n\n Serving from a root directory with custom error-handling:\n\n```js\nvar http = require('http');\nvar send = require('send');\nvar url = require('url');\n\nvar app = http.createServer(function(req, res){\n // your custom error-handling logic:\n function error(err) {\n res.statusCode = err.status || 500;\n res.end(err.message);\n }\n\n // your custom directory handling logic:\n function redirect() {\n res.statusCode = 301;\n res.setHeader('Location', req.url + '/');\n res.end('Redirecting to ' + req.url + '/');\n }\n\n // transfer arbitrary files from within\n // /www/example.com/public/*\n send(req, url.parse(req.url).pathname)\n .root('/www/example.com/public')\n .on('error', error)\n .on('directory', redirect)\n .pipe(res);\n}).listen(3000);\n```\n\n## API\n\n### Events\n\n - `error` an error occurred `(err)`\n - `directory` a directory was requested\n - `file` a file was requested `(path, stat)`\n - `stream` file streaming has started `(stream)`\n - `end` streaming has completed\n\n### .root(dir)\n\n Serve files relative to `path`. Aliased as `.from(dir)`.\n\n### .index(path)\n\n By default send supports \"index.html\" files, to disable this\n invoke `.index(false)` or to supply a new index pass a string.\n\n### .maxage(ms)\n\n Provide a max-age in milliseconds for http caching, defaults to 0.\n\n### .hidden(bool)\n\n Enable or disable transfer of hidden files, defaults to false.\n\n## Error-handling\n\n By default when no `error` listeners are present an automatic response will be made, otherwise you have full control over the response, aka you may show a 5xx page etc.\n\n## Caching\n\n It does _not_ perform internal caching, you should use a reverse proxy cache such\n as Varnish for this, or those fancy things called CDNs. If your application is small enough that it would benefit from single-node memory caching, it's small enough that it does not need caching at all ;).\n\n## Debugging\n\n To enable `debug()` instrumentation output export __DEBUG__:\n\n```\n$ DEBUG=send node app\n```\n\n## Running tests\n\n```\n$ npm install\n$ make test\n```\n\n## License \n\n(The MIT License)\n\nCopyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n",
+ "readmeFilename": "Readme.md",
+ "bugs": {
+ "url": "https://github.com/visionmedia/send/issues"
+ },
+ "_id": "send@0.1.4",
+ "dist": {
+ "shasum": "be70d8d1be01de61821af13780b50345a4f71abd"
+ },
+ "_from": "send@0.1.4",
+ "_resolved": "https://registry.npmjs.org/send/-/send-0.1.4.tgz"
+}
diff --git a/appshell/node-core/thirdparty/connect/node_modules/uid2/index.js b/appshell/node-core/thirdparty/connect/node_modules/uid2/index.js
new file mode 100644
index 000000000..d665f5198
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/uid2/index.js
@@ -0,0 +1,49 @@
+/**
+ * Module dependencies
+ */
+
+var crypto = require('crypto');
+
+/**
+ * The size ratio between a base64 string and the equivalent byte buffer
+ */
+
+var ratio = Math.log(64) / Math.log(256);
+
+/**
+ * Make a Base64 string ready for use in URLs
+ *
+ * @param {String}
+ * @returns {String}
+ * @api private
+ */
+
+function urlReady(str) {
+ return str.replace(/\+/g, '_').replace(/\//g, '-');
+}
+
+/**
+ * Generate an Unique Id
+ *
+ * @param {Number} length The number of chars of the uid
+ * @param {Number} cb (optional) Callback for async uid generation
+ * @api public
+ */
+
+function uid(length, cb) {
+ var numbytes = Math.ceil(length * ratio);
+ if (typeof cb === 'undefined') {
+ return urlReady(crypto.randomBytes(numbytes).toString('base64').slice(0, length));
+ } else {
+ crypto.randomBytes(numbytes, function(err, bytes) {
+ if (err) return cb(err);
+ cb(null, urlReady(bytes.toString('base64').slice(0, length)));
+ })
+ }
+}
+
+/**
+ * Exports
+ */
+
+module.exports = uid;
diff --git a/appshell/node-core/thirdparty/connect/node_modules/uid2/package.json b/appshell/node-core/thirdparty/connect/node_modules/uid2/package.json
new file mode 100644
index 000000000..6b606d271
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/node_modules/uid2/package.json
@@ -0,0 +1,16 @@
+{
+ "name": "uid2",
+ "description": "strong uid",
+ "tags": [
+ "uid"
+ ],
+ "version": "0.0.2",
+ "dependencies": {},
+ "readme": "ERROR: No README data found!",
+ "_id": "uid2@0.0.2",
+ "dist": {
+ "shasum": "ec7db9024a0043009b46e99de842e6e9376f7a7f"
+ },
+ "_from": "uid2@0.0.2",
+ "_resolved": "https://registry.npmjs.org/uid2/-/uid2-0.0.2.tgz"
+}
diff --git a/appshell/node-core/thirdparty/connect/package.json b/appshell/node-core/thirdparty/connect/package.json
new file mode 100644
index 000000000..806efdea9
--- /dev/null
+++ b/appshell/node-core/thirdparty/connect/package.json
@@ -0,0 +1,65 @@
+{
+ "name": "connect",
+ "version": "2.9.0",
+ "description": "High performance middleware framework",
+ "keywords": [
+ "framework",
+ "web",
+ "middleware",
+ "connect",
+ "rack"
+ ],
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/senchalabs/connect.git"
+ },
+ "author": {
+ "name": "TJ Holowaychuk",
+ "email": "tj@vision-media.ca",
+ "url": "http://tjholowaychuk.com"
+ },
+ "dependencies": {
+ "qs": "0.6.5",
+ "cookie-signature": "1.0.1",
+ "buffer-crc32": "0.2.1",
+ "cookie": "0.1.0",
+ "send": "0.1.4",
+ "bytes": "0.2.0",
+ "fresh": "0.2.0",
+ "pause": "0.0.1",
+ "uid2": "0.0.2",
+ "debug": "*",
+ "methods": "0.0.1",
+ "multiparty": "2.1.8"
+ },
+ "devDependencies": {
+ "should": "*",
+ "mocha": "*",
+ "jade": "*",
+ "dox": "*"
+ },
+ "licenses": [
+ {
+ "type": "MIT",
+ "url": "https://raw.github.com/senchalabs/connect/master/LICENSE"
+ }
+ ],
+ "main": "index",
+ "engines": {
+ "node": ">= 0.8.0"
+ },
+ "scripts": {
+ "test": "make"
+ },
+ "readme": "[](http://travis-ci.org/senchalabs/connect)\n# Connect\n\n Connect is an extensible HTTP server framework for [node](http://nodejs.org), providing high performance \"plugins\" known as _middleware_.\n\n Connect is bundled with over _20_ commonly used middleware, including\n a logger, session support, cookie parser, and [more](http://senchalabs.github.com/connect). Be sure to view the 2.x [documentation](http://senchalabs.github.com/connect/).\n\n```js\nvar connect = require('connect')\n , http = require('http');\n\nvar app = connect()\n .use(connect.favicon())\n .use(connect.logger('dev'))\n .use(connect.static('public'))\n .use(connect.directory('public'))\n .use(connect.cookieParser())\n .use(connect.session({ secret: 'my secret here' }))\n .use(function(req, res){\n res.end('Hello from Connect!\\n');\n });\n\nhttp.createServer(app).listen(3000);\n```\n\n## Middleware\n\n - [csrf](http://www.senchalabs.org/connect/csrf.html)\n - [basicAuth](http://www.senchalabs.org/connect/basicAuth.html)\n - [bodyParser](http://www.senchalabs.org/connect/bodyParser.html)\n - [json](http://www.senchalabs.org/connect/json.html)\n - [multipart](http://www.senchalabs.org/connect/multipart.html)\n - [urlencoded](http://www.senchalabs.org/connect/urlencoded.html)\n - [cookieParser](http://www.senchalabs.org/connect/cookieParser.html)\n - [directory](http://www.senchalabs.org/connect/directory.html)\n - [compress](http://www.senchalabs.org/connect/compress.html)\n - [errorHandler](http://www.senchalabs.org/connect/errorHandler.html)\n - [favicon](http://www.senchalabs.org/connect/favicon.html)\n - [limit](http://www.senchalabs.org/connect/limit.html)\n - [logger](http://www.senchalabs.org/connect/logger.html)\n - [methodOverride](http://www.senchalabs.org/connect/methodOverride.html)\n - [query](http://www.senchalabs.org/connect/query.html)\n - [responseTime](http://www.senchalabs.org/connect/responseTime.html)\n - [session](http://www.senchalabs.org/connect/session.html)\n - [static](http://www.senchalabs.org/connect/static.html)\n - [staticCache](http://www.senchalabs.org/connect/staticCache.html)\n - [vhost](http://www.senchalabs.org/connect/vhost.html)\n - [subdomains](http://www.senchalabs.org/connect/subdomains.html)\n - [cookieSession](http://www.senchalabs.org/connect/cookieSession.html)\n\n## Running Tests\n\nfirst:\n\n $ npm install -d\n\nthen:\n\n $ make test\n\n## Authors\n\n Below is the output from [git-summary](http://github.com/visionmedia/git-extras).\n\n\n project: connect\n commits: 2033\n active : 301 days\n files : 171\n authors: \n 1414\tTj Holowaychuk 69.6%\n 298\tvisionmedia 14.7%\n 191\tTim Caswell 9.4%\n 51\tTJ Holowaychuk 2.5%\n 10\tRyan Olds 0.5%\n 8\tAstro 0.4%\n 5\tNathan Rajlich 0.2%\n 5\tJakub Nešetřil 0.2%\n 3\tDaniel Dickison 0.1%\n 3\tDavid Rio Deiros 0.1%\n 3\tAlexander Simmerl 0.1%\n 3\tAndreas Lind Petersen 0.1%\n 2\tAaron Heckmann 0.1%\n 2\tJacques Crocker 0.1%\n 2\tFabian Jakobs 0.1%\n 2\tBrian J Brennan 0.1%\n 2\tAdam Malcontenti-Wilson 0.1%\n 2\tGlen Mailer 0.1%\n 2\tJames Campos 0.1%\n 1\tTrent Mick 0.0%\n 1\tTroy Kruthoff 0.0%\n 1\tWei Zhu 0.0%\n 1\tcomerc 0.0%\n 1\tdarobin 0.0%\n 1\tnateps 0.0%\n 1\tMarco Sanson 0.0%\n 1\tArthur Taylor 0.0%\n 1\tAseem Kishore 0.0%\n 1\tBart Teeuwisse 0.0%\n 1\tCameron Howey 0.0%\n 1\tChad Weider 0.0%\n 1\tCraig Barnes 0.0%\n 1\tEran Hammer-Lahav 0.0%\n 1\tGregory McWhirter 0.0%\n 1\tGuillermo Rauch 0.0%\n 1\tJae Kwon 0.0%\n 1\tJakub Nesetril 0.0%\n 1\tJoshua Peek 0.0%\n 1\tJxck 0.0%\n 1\tAJ ONeal 0.0%\n 1\tMichael Hemesath 0.0%\n 1\tMorten Siebuhr 0.0%\n 1\tSamori Gorse 0.0%\n 1\tTom Jensen 0.0%\n\n## Node Compatibility\n\n Connect `< 1.x` is compatible with node 0.2.x\n\n\n Connect `1.x` is compatible with node 0.4.x\n\n\n Connect (_master_) `2.x` is compatible with node 0.6.x\n\n## CLA\n\n [http://sencha.com/cla](http://sencha.com/cla)\n\n## License\n\nView the [LICENSE](https://github.com/senchalabs/connect/blob/master/LICENSE) file. The [Silk](http://www.famfamfam.com/lab/icons/silk/) icons used by the `directory` middleware created by/copyright of [FAMFAMFAM](http://www.famfamfam.com/).\n",
+ "readmeFilename": "Readme.md",
+ "bugs": {
+ "url": "https://github.com/senchalabs/connect/issues"
+ },
+ "_id": "connect@2.9.0",
+ "dist": {
+ "shasum": "dcadf7a2508fd651ee3f1e4900d8cf2131049c07"
+ },
+ "_from": "connect@",
+ "_resolved": "https://registry.npmjs.org/connect/-/connect-2.9.0.tgz"
+}
 + ')
';
+ classes.push('icon');
+ }
+
+ return '