+
+
+
diff --git a/public/lib/shred.bundle.js b/public/lib/shred.bundle.js
new file mode 100644
index 0000000..74d0816
--- /dev/null
+++ b/public/lib/shred.bundle.js
@@ -0,0 +1,2765 @@
+var require = function (file, cwd) {
+ var resolved = require.resolve(file, cwd || '/');
+ var mod = require.modules[resolved];
+ if (!mod) throw new Error(
+ 'Failed to resolve module ' + file + ', tried ' + resolved
+ );
+ var res = mod._cached ? mod._cached : mod();
+ return res;
+}
+
+require.paths = [];
+require.modules = {};
+require.extensions = [".js",".coffee"];
+
+require._core = {
+ 'assert': true,
+ 'events': true,
+ 'fs': true,
+ 'path': true,
+ 'vm': true
+};
+
+require.resolve = (function () {
+ return function (x, cwd) {
+ if (!cwd) cwd = '/';
+
+ if (require._core[x]) return x;
+ var path = require.modules.path();
+ var y = cwd || '.';
+
+ if (x.match(/^(?:\.\.?\/|\/)/)) {
+ var m = loadAsFileSync(path.resolve(y, x))
+ || loadAsDirectorySync(path.resolve(y, x));
+ if (m) return m;
+ }
+
+ var n = loadNodeModulesSync(x, y);
+ if (n) return n;
+
+ throw new Error("Cannot find module '" + x + "'");
+
+ function loadAsFileSync (x) {
+ if (require.modules[x]) {
+ return x;
+ }
+
+ for (var i = 0; i < require.extensions.length; i++) {
+ var ext = require.extensions[i];
+ if (require.modules[x + ext]) return x + ext;
+ }
+ }
+
+ function loadAsDirectorySync (x) {
+ x = x.replace(/\/+$/, '');
+ var pkgfile = x + '/package.json';
+ if (require.modules[pkgfile]) {
+ var pkg = require.modules[pkgfile]();
+ var b = pkg.browserify;
+ if (typeof b === 'object' && b.main) {
+ var m = loadAsFileSync(path.resolve(x, b.main));
+ if (m) return m;
+ }
+ else if (typeof b === 'string') {
+ var m = loadAsFileSync(path.resolve(x, b));
+ if (m) return m;
+ }
+ else if (pkg.main) {
+ var m = loadAsFileSync(path.resolve(x, pkg.main));
+ if (m) return m;
+ }
+ }
+
+ return loadAsFileSync(x + '/index');
+ }
+
+ function loadNodeModulesSync (x, start) {
+ var dirs = nodeModulesPathsSync(start);
+ for (var i = 0; i < dirs.length; i++) {
+ var dir = dirs[i];
+ var m = loadAsFileSync(dir + '/' + x);
+ if (m) return m;
+ var n = loadAsDirectorySync(dir + '/' + x);
+ if (n) return n;
+ }
+
+ var m = loadAsFileSync(x);
+ if (m) return m;
+ }
+
+ function nodeModulesPathsSync (start) {
+ var parts;
+ if (start === '/') parts = [ '' ];
+ else parts = path.normalize(start).split('/');
+
+ var dirs = [];
+ for (var i = parts.length - 1; i >= 0; i--) {
+ if (parts[i] === 'node_modules') continue;
+ var dir = parts.slice(0, i + 1).join('/') + '/node_modules';
+ dirs.push(dir);
+ }
+
+ return dirs;
+ }
+ };
+})();
+
+require.alias = function (from, to) {
+ var path = require.modules.path();
+ var res = null;
+ try {
+ res = require.resolve(from + '/package.json', '/');
+ }
+ catch (err) {
+ res = require.resolve(from, '/');
+ }
+ var basedir = path.dirname(res);
+
+ var keys = (Object.keys || function (obj) {
+ var res = [];
+ for (var key in obj) res.push(key)
+ return res;
+ })(require.modules);
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ if (key.slice(0, basedir.length + 1) === basedir + '/') {
+ var f = key.slice(basedir.length);
+ require.modules[to + f] = require.modules[basedir + f];
+ }
+ else if (key === basedir) {
+ require.modules[to] = require.modules[basedir];
+ }
+ }
+};
+
+require.define = function (filename, fn) {
+ var dirname = require._core[filename]
+ ? ''
+ : require.modules.path().dirname(filename)
+ ;
+
+ var require_ = function (file) {
+ return require(file, dirname)
+ };
+ require_.resolve = function (name) {
+ return require.resolve(name, dirname);
+ };
+ require_.modules = require.modules;
+ require_.define = require.define;
+ var module_ = { exports : {} };
+
+ require.modules[filename] = function () {
+ require.modules[filename]._cached = module_.exports;
+ fn.call(
+ module_.exports,
+ require_,
+ module_,
+ module_.exports,
+ dirname,
+ filename
+ );
+ require.modules[filename]._cached = module_.exports;
+ return module_.exports;
+ };
+};
+
+if (typeof process === 'undefined') process = {};
+
+if (!process.nextTick) process.nextTick = (function () {
+ var queue = [];
+ var canPost = typeof window !== 'undefined'
+ && window.postMessage && window.addEventListener
+ ;
+
+ if (canPost) {
+ window.addEventListener('message', function (ev) {
+ if (ev.source === window && ev.data === 'browserify-tick') {
+ ev.stopPropagation();
+ if (queue.length > 0) {
+ var fn = queue.shift();
+ fn();
+ }
+ }
+ }, true);
+ }
+
+ return function (fn) {
+ if (canPost) {
+ queue.push(fn);
+ window.postMessage('browserify-tick', '*');
+ }
+ else setTimeout(fn, 0);
+ };
+})();
+
+if (!process.title) process.title = 'browser';
+
+if (!process.binding) process.binding = function (name) {
+ if (name === 'evals') return require('vm')
+ else throw new Error('No such module')
+};
+
+if (!process.cwd) process.cwd = function () { return '.' };
+
+require.define("path", function (require, module, exports, __dirname, __filename) {
+ function filter (xs, fn) {
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ if (fn(xs[i], i, xs)) res.push(xs[i]);
+ }
+ return res;
+}
+
+// resolves . and .. elements in a path array with directory names there
+// must be no slashes, empty elements, or device names (c:\) in the array
+// (so also no leading and trailing slashes - it does not distinguish
+// relative and absolute paths)
+function normalizeArray(parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length; i >= 0; i--) {
+ var last = parts[i];
+ if (last == '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+
+ return parts;
+}
+
+// Regex to split a filename into [*, dir, basename, ext]
+// posix version
+var splitPathRe = /^(.+\/(?!$)|\/)?((?:.+?)?(\.[^.]*)?)$/;
+
+// path.resolve([from ...], to)
+// posix version
+exports.resolve = function() {
+var resolvedPath = '',
+ resolvedAbsolute = false;
+
+for (var i = arguments.length; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0)
+ ? arguments[i]
+ : process.cwd();
+
+ // Skip empty and invalid entries
+ if (typeof path !== 'string' || !path) {
+ continue;
+ }
+
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+}
+
+// At this point the path should be resolved to a full absolute path, but
+// handle relative paths to be safe (might happen when process.cwd() fails)
+
+// Normalize the path
+resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+};
+
+// path.normalize(path)
+// posix version
+exports.normalize = function(path) {
+var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.slice(-1) === '/';
+
+// Normalize the path
+path = normalizeArray(filter(path.split('/'), function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+
+ return (isAbsolute ? '/' : '') + path;
+};
+
+
+// posix version
+exports.join = function() {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return exports.normalize(filter(paths, function(p, index) {
+ return p && typeof p === 'string';
+ }).join('/'));
+};
+
+
+exports.dirname = function(path) {
+ var dir = splitPathRe.exec(path)[1] || '';
+ var isWindows = false;
+ if (!dir) {
+ // No dirname
+ return '.';
+ } else if (dir.length === 1 ||
+ (isWindows && dir.length <= 3 && dir.charAt(1) === ':')) {
+ // It is just a slash or a drive letter with a slash
+ return dir;
+ } else {
+ // It is a full dirname, strip trailing slash
+ return dir.substring(0, dir.length - 1);
+ }
+};
+
+
+exports.basename = function(path, ext) {
+ var f = splitPathRe.exec(path)[2] || '';
+ // TODO: make this comparison case-insensitive on windows?
+ if (ext && f.substr(-1 * ext.length) === ext) {
+ f = f.substr(0, f.length - ext.length);
+ }
+ return f;
+};
+
+
+exports.extname = function(path) {
+ return splitPathRe.exec(path)[3] || '';
+};
+
+});
+
+require.define("/shred.js", function (require, module, exports, __dirname, __filename) {
+ // Shred is an HTTP client library intended to simplify the use of Node's
+// built-in HTTP library. In particular, we wanted to make it easier to interact
+// with HTTP-based APIs.
+//
+// See the [examples](./examples.html) for more details.
+
+// Ax is a nice logging library we wrote. You can use any logger, providing it
+// has `info`, `warn`, `debug`, and `error` methods that take a string.
+var Ax = require("ax")
+ , CookieJarLib = require( "cookiejar" )
+ , CookieJar = CookieJarLib.CookieJar
+;
+
+// Shred takes some options, including a logger and request defaults.
+
+var Shred = function(options) {
+ options = (options||{});
+ this.agent = options.agent;
+ this.defaults = options.defaults||{};
+ this.log = options.logger||(new Ax({ level: "info" }));
+ this._sharedCookieJar = new CookieJar();
+ this.logCurl = options.logCurl || false;
+};
+
+// Most of the real work is done in the request and reponse classes.
+
+Shred.Request = require("./shred/request");
+Shred.Response = require("./shred/response");
+
+// The `request` method kicks off a new request, instantiating a new `Request`
+// object and passing along whatever default options we were given.
+
+Shred.prototype = {
+ request: function(options) {
+ options.logger = this.log;
+ options.logCurl = options.logCurl || this.logCurl;
+ options.cookieJar = ( 'cookieJar' in options ) ? options.cookieJar : this._sharedCookieJar; // let them set cookieJar = null
+ options.agent = options.agent || this.agent;
+ // fill in default options
+ for (var key in this.defaults) {
+ if (this.defaults.hasOwnProperty(key) && !options[key]) {
+ options[key] = this.defaults[key]
+ }
+ }
+ return new Shred.Request(options);
+ }
+};
+
+// Define a bunch of convenience methods so that you don't have to include
+// a `method` property in your request options.
+
+"get put post delete".split(" ").forEach(function(method) {
+ Shred.prototype[method] = function(options) {
+ options.method = method;
+ return this.request(options);
+ };
+});
+
+
+module.exports = Shred;
+
+});
+
+require.define("/node_modules/ax/package.json", function (require, module, exports, __dirname, __filename) {
+ module.exports = {"main":"./lib/ax.js"}
+});
+
+require.define("/node_modules/ax/lib/ax.js", function (require, module, exports, __dirname, __filename) {
+ var inspect = require("util").inspect
+ , fs = require("fs")
+;
+
+
+// this is a quick-and-dirty logger. there are other nicer loggers out there
+// but the ones i found were also somewhat involved. this one has a Ruby
+// logger type interface
+//
+// we can easily replace this, provide the info, debug, etc. methods are the
+// same. or, we can change Haiku to use a more standard node.js interface
+
+var format = function(level,message) {
+ var debug = (level=="debug"||level=="error");
+ if (!message) { return message.toString(); }
+ if (typeof(message) == "object") {
+ if (message instanceof Error && debug) {
+ return message.stack;
+ } else {
+ return inspect(message);
+ }
+ } else {
+ return message.toString();
+ }
+};
+
+var noOp = function(message) { return this; }
+var makeLogger = function(level,fn) {
+ return function(message) {
+ this.stream.write(this.format(level, message)+"\n");
+ return this;
+ }
+};
+
+var Logger = function(options) {
+ var logger = this;
+ var options = options||{};
+
+ // Default options
+ options.level = options.level || "info";
+ options.timestamp = options.timestamp || true;
+ options.prefix = options.prefix || "";
+ logger.options = options;
+
+ // Allows a prefix to be added to the message.
+ //
+ // var logger = new Ax({ module: 'Haiku' })
+ // logger.warn('this is going to be awesome!');
+ // //=> Haiku: this is going to be awesome!
+ //
+ if (logger.options.module){
+ logger.options.prefix = logger.options.module;
+ }
+
+ // Write to stderr or a file
+ if (logger.options.file){
+ logger.stream = fs.createWriteStream(logger.options.file, {"flags": "a"});
+ } else {
+ if(process.title === "node")
+ logger.stream = process.stderr;
+ else if(process.title === "browser")
+ logger.stream = function () {
+ // Work around weird console context issue: http://code.google.com/p/chromium/issues/detail?id=48662
+ return console[logger.options.level].apply(console, arguments);
+ };
+ }
+
+ switch(logger.options.level){
+ case 'debug':
+ ['debug', 'info', 'warn'].forEach(function (level) {
+ logger[level] = Logger.writer(level);
+ });
+ case 'info':
+ ['info', 'warn'].forEach(function (level) {
+ logger[level] = Logger.writer(level);
+ });
+ case 'warn':
+ logger.warn = Logger.writer('warn');
+ }
+}
+
+// Used to define logger methods
+Logger.writer = function(level){
+ return function(message){
+ var logger = this;
+
+ if(process.title === "node")
+ logger.stream.write(logger.format(level, message) + '\n');
+ else if(process.title === "browser")
+ logger.stream(logger.format(level, message) + '\n');
+
+ };
+}
+
+
+Logger.prototype = {
+ info: function(){},
+ debug: function(){},
+ warn: function(){},
+ error: Logger.writer('error'),
+ format: function(level, message){
+ if (! message) return '';
+
+ var logger = this
+ , prefix = logger.options.prefix
+ , timestamp = logger.options.timestamp ? " " + (new Date().toISOString()) : ""
+ ;
+
+ return (prefix + timestamp + ": " + message);
+ }
+};
+
+module.exports = Logger;
+
+});
+
+require.define("util", function (require, module, exports, __dirname, __filename) {
+ // todo
+
+});
+
+require.define("fs", function (require, module, exports, __dirname, __filename) {
+ // nothing to see here... no file methods for the browser
+
+});
+
+require.define("/node_modules/cookiejar/package.json", function (require, module, exports, __dirname, __filename) {
+ module.exports = {"main":"cookiejar.js"}
+});
+
+require.define("/node_modules/cookiejar/cookiejar.js", function (require, module, exports, __dirname, __filename) {
+ exports.CookieAccessInfo=CookieAccessInfo=function CookieAccessInfo(domain,path,secure,script) {
+ if(this instanceof CookieAccessInfo) {
+ this.domain=domain||undefined;
+ this.path=path||"/";
+ this.secure=!!secure;
+ this.script=!!script;
+ return this;
+ }
+ else {
+ return new CookieAccessInfo(domain,path,secure,script)
+ }
+}
+
+exports.Cookie=Cookie=function Cookie(cookiestr) {
+ if(cookiestr instanceof Cookie) {
+ return cookiestr;
+ }
+ else {
+ if(this instanceof Cookie) {
+ this.name = null;
+ this.value = null;
+ this.expiration_date = Infinity;
+ this.path = "/";
+ this.domain = null;
+ this.secure = false; //how to define?
+ this.noscript = false; //httponly
+ if(cookiestr) {
+ this.parse(cookiestr)
+ }
+ return this;
+ }
+ return new Cookie(cookiestr)
+ }
+}
+
+Cookie.prototype.toString = function toString() {
+ var str=[this.name+"="+this.value];
+ if(this.expiration_date !== Infinity) {
+ str.push("expires="+(new Date(this.expiration_date)).toGMTString());
+ }
+ if(this.domain) {
+ str.push("domain="+this.domain);
+ }
+ if(this.path) {
+ str.push("path="+this.path);
+ }
+ if(this.secure) {
+ str.push("secure");
+ }
+ if(this.noscript) {
+ str.push("httponly");
+ }
+ return str.join("; ");
+}
+
+Cookie.prototype.toValueString = function toValueString() {
+ return this.name+"="+this.value;
+}
+
+var cookie_str_splitter=/[:](?=\s*[a-zA-Z0-9_\-]+\s*[=])/g
+Cookie.prototype.parse = function parse(str) {
+ if(this instanceof Cookie) {
+ var parts=str.split(";")
+ , pair=parts[0].match(/([^=]+)=((?:.|\n)*)/)
+ , key=pair[1]
+ , value=pair[2];
+ this.name = key;
+ this.value = value;
+
+ for(var i=1;i ", request.method.toUpperCase(),
+ request.url].join(" ")
+ return [ summary, "- Headers:", headers].join("\n");
+};
+
+Request.prototype.format_headers = function () {
+ var array = []
+ var headers = this._headers
+ for (var key in headers) {
+ if (headers.hasOwnProperty(key)) {
+ var value = headers[key]
+ array.push("\t" + key + ": " + value);
+ }
+ }
+ return array.join("\n");
+};
+
+// Allow chainable 'on's: shred.get({ ... }).on( ... ). You can pass in a
+// single function, a pair (event, function), or a hash:
+// { event: function, event: function }
+Request.prototype.on = function (eventOrHash, listener) {
+ var emitter = this.emitter;
+ // Pass in a single argument as a function then make it the default response handler
+ if (arguments.length === 1 && typeof(eventOrHash) === 'function') {
+ emitter.on('response', eventOrHash);
+ } else if (arguments.length === 1 && typeof(eventOrHash) === 'object') {
+ for (var key in eventOrHash) {
+ if (eventOrHash.hasOwnProperty(key)) {
+ emitter.on(key, eventOrHash[key]);
+ }
+ }
+ } else {
+ emitter.on(eventOrHash, listener);
+ }
+ return this;
+};
+
+// Add in the header methods. Again, these ensure we don't get the same header
+// multiple times with different case conventions.
+HeaderMixins.gettersAndSetters(Request);
+
+// `processOptions` is called from the constructor to handle all the work
+// associated with making sure we do our best to ensure we have a valid request.
+
+var processOptions = function(request,options) {
+
+ request.log.debug("Processing request options ..");
+
+ // We'll use `request.emitter` to manage the `on` event handlers.
+ request.emitter = (new Emitter);
+
+ request.agent = options.agent;
+
+ // Set up the handlers ...
+ if (options.on) {
+ for (var key in options.on) {
+ if (options.on.hasOwnProperty(key)) {
+ request.emitter.on(key, options.on[key]);
+ }
+ }
+ }
+
+ // Make sure we were give a URL or a host
+ if (!options.url && !options.host) {
+ request.emitter.emit("request_error",
+ new Error("No url or url options (host, port, etc.)"));
+ return;
+ }
+
+ // Allow for the [use of a proxy](http://www.jmarshall.com/easy/http/#proxies).
+
+ if (options.url) {
+ if (options.proxy) {
+ request.url = options.proxy;
+ request.path = options.url;
+ } else {
+ request.url = options.url;
+ }
+ }
+
+ // Set the remaining options.
+ request.query = options.query||options.parameters||request.query ;
+ request.method = options.method;
+ request.setHeader("user-agent",options.agent||"Shred");
+ request.setHeaders(options.headers);
+
+ if (request.cookieJar) {
+ var cookies = request.cookieJar.getCookies( CookieAccessInfo( request.host, request.path ) );
+ if (cookies.length) {
+ var cookieString = request.getHeader('cookie')||'';
+ for (var cookieIndex = 0; cookieIndex < cookies.length; ++cookieIndex) {
+ if ( cookieString.length && cookieString[ cookieString.length - 1 ] != ';' )
+ {
+ cookieString += ';';
+ }
+ cookieString += cookies[ cookieIndex ].name + '=' + cookies[ cookieIndex ].value + ';';
+ }
+ request.setHeader("cookie", cookieString);
+ }
+ }
+
+ // The content entity can be set either using the `body` or `content` attributes.
+ if (options.body||options.content) {
+ request.content = options.body||options.content;
+ }
+ request.timeout = options.timeout;
+
+};
+
+// `createRequest` is also called by the constructor, after `processOptions`.
+// This actually makes the request and processes the response, so `createRequest`
+// is a bit of a misnomer.
+
+var createRequest = function(request) {
+ var timeout ;
+
+ request.log.debug("Creating request ..");
+ request.log.debug(request);
+
+ var reqParams = {
+ host: request.host,
+ port: request.port,
+ method: request.method,
+ path: request.path + (request.query ? '?'+request.query : ""),
+ headers: request.getHeaders(),
+ // Node's HTTP/S modules will ignore this, but we are using the
+ // browserify-http module in the browser for both HTTP and HTTPS, and this
+ // is how you differentiate the two.
+ scheme: request.scheme,
+ // Use a provided agent. 'Undefined' is the default, which uses a global
+ // agent.
+ agent: request.agent
+ };
+
+ if (request.logCurl) {
+ logCurl(request);
+ }
+
+ var http = request.scheme == "http" ? HTTP : HTTPS;
+
+ // Set up the real request using the selected library. The request won't be
+ // sent until we call `.end()`.
+ request._raw = http.request(reqParams, function(response) {
+ request.log.debug("Received response ..");
+
+ // We haven't timed out and we have a response, so make sure we clear the
+ // timeout so it doesn't fire while we're processing the response.
+ clearTimeout(timeout);
+
+ // Construct a Shred `Response` object from the response. This will stream
+ // the response, thus the need for the callback. We can access the response
+ // entity safely once we're in the callback.
+ response = new Response(response, request, function(response) {
+
+ // Set up some event magic. The precedence is given first to
+ // status-specific handlers, then to responses for a given event, and then
+ // finally to the more general `response` handler. In the last case, we
+ // need to first make sure we're not dealing with a a redirect.
+ var emit = function(event) {
+ var emitter = request.emitter;
+ var textStatus = STATUS_CODES[response.status] ? STATUS_CODES[response.status].toLowerCase() : null;
+ if (emitter.listeners(response.status).length > 0 || emitter.listeners(textStatus).length > 0) {
+ emitter.emit(response.status, response);
+ emitter.emit(textStatus, response);
+ } else {
+ if (emitter.listeners(event).length>0) {
+ emitter.emit(event, response);
+ } else if (!response.isRedirect) {
+ emitter.emit("response", response);
+ //console.warn("Request has no event listener for status code " + response.status);
+ }
+ }
+ };
+
+ // Next, check for a redirect. We simply repeat the request with the URL
+ // given in the `Location` header. We fire a `redirect` event.
+ if (response.isRedirect) {
+ request.log.debug("Redirecting to "
+ + response.getHeader("Location"));
+ request.url = response.getHeader("Location");
+ emit("redirect");
+ createRequest(request);
+
+ // Okay, it's not a redirect. Is it an error of some kind?
+ } else if (response.isError) {
+ emit("error");
+ } else {
+ // It looks like we're good shape. Trigger the `success` event.
+ emit("success");
+ }
+ });
+ });
+
+ // We're still setting up the request. Next, we're going to handle error cases
+ // where we have no response. We don't emit an error event because that event
+ // takes a response. We don't response handlers to have to check for a null
+ // value. However, we [should introduce a different event
+ // type](https://github.com/spire-io/shred/issues/3) for this type of error.
+ request._raw.on("error", function(error) {
+ request.emitter.emit("request_error", error);
+ });
+
+ request._raw.on("socket", function(socket) {
+ request.emitter.emit("socket", socket);
+ });
+
+ // TCP timeouts should also trigger the "response_error" event.
+ request._raw.on('socket', function () {
+ request._raw.socket.on('timeout', function () {
+ // This should trigger the "error" event on the raw request, which will
+ // trigger the "response_error" on the shred request.
+ request._raw.abort();
+ });
+ });
+
+
+ // We're almost there. Next, we need to write the request entity to the
+ // underlying request object.
+ if (request.content) {
+ request.log.debug("Streaming body: '" +
+ request.content.data.slice(0,59) + "' ... ");
+ request._raw.write(request.content.data);
+ }
+
+ // Finally, we need to set up the timeout. We do this last so that we don't
+ // start the clock ticking until the last possible moment.
+ if (request.timeout) {
+ timeout = setTimeout(function() {
+ request.log.debug("Timeout fired, aborting request ...");
+ request._raw.abort();
+ request.emitter.emit("timeout", request);
+ },request.timeout);
+ }
+
+ // The `.end()` method will cause the request to fire. Technically, it might
+ // have already sent the headers and body.
+ request.log.debug("Sending request ...");
+ request._raw.end();
+};
+
+// Logs the curl command for the request.
+var logCurl = function (req) {
+ var headers = req.getHeaders();
+ var headerString = "";
+
+ for (var key in headers) {
+ headerString += '-H "' + key + ": " + headers[key] + '" ';
+ }
+
+ var bodyString = ""
+
+ if (req.content) {
+ bodyString += "-d '" + req.content.body + "' ";
+ }
+
+ var query = req.query ? '?' + req.query : "";
+
+ console.log("curl " +
+ "-X " + req.method.toUpperCase() + " " +
+ req.scheme + "://" + req.host + ":" + req.port + req.path + query + " " +
+ headerString +
+ bodyString
+ );
+};
+
+
+module.exports = Request;
+
+});
+
+require.define("http", function (require, module, exports, __dirname, __filename) {
+ // todo
+
+});
+
+require.define("https", function (require, module, exports, __dirname, __filename) {
+ // todo
+
+});
+
+require.define("/shred/parseUri.js", function (require, module, exports, __dirname, __filename) {
+ // parseUri 1.2.2
+// (c) Steven Levithan
+// MIT License
+
+function parseUri (str) {
+ var o = parseUri.options,
+ m = o.parser[o.strictMode ? "strict" : "loose"].exec(str),
+ uri = {},
+ i = 14;
+
+ while (i--) uri[o.key[i]] = m[i] || "";
+
+ uri[o.q.name] = {};
+ uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
+ if ($1) uri[o.q.name][$1] = $2;
+ });
+
+ return uri;
+};
+
+parseUri.options = {
+ strictMode: false,
+ key: ["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"],
+ q: {
+ name: "queryKey",
+ parser: /(?:^|&)([^&=]*)=?([^&]*)/g
+ },
+ parser: {
+ strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
+ loose: /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+ }
+};
+
+module.exports = parseUri;
+
+});
+
+require.define("events", function (require, module, exports, __dirname, __filename) {
+ if (!process.EventEmitter) process.EventEmitter = function () {};
+
+var EventEmitter = exports.EventEmitter = process.EventEmitter;
+var isArray = typeof Array.isArray === 'function'
+ ? Array.isArray
+ : function (xs) {
+ return Object.toString.call(xs) === '[object Array]'
+ }
+;
+
+// By default EventEmitters will print a warning if more than
+// 10 listeners are added to it. This is a useful default which
+// helps finding memory leaks.
+//
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+var defaultMaxListeners = 10;
+EventEmitter.prototype.setMaxListeners = function(n) {
+ if (!this._events) this._events = {};
+ this._events.maxListeners = n;
+};
+
+
+EventEmitter.prototype.emit = function(type) {
+ // If there is no 'error' event listener then throw.
+ if (type === 'error') {
+ if (!this._events || !this._events.error ||
+ (isArray(this._events.error) && !this._events.error.length))
+ {
+ if (arguments[1] instanceof Error) {
+ throw arguments[1]; // Unhandled 'error' event
+ } else {
+ throw new Error("Uncaught, unspecified 'error' event.");
+ }
+ return false;
+ }
+ }
+
+ if (!this._events) return false;
+ var handler = this._events[type];
+ if (!handler) return false;
+
+ if (typeof handler == 'function') {
+ switch (arguments.length) {
+ // fast cases
+ case 1:
+ handler.call(this);
+ break;
+ case 2:
+ handler.call(this, arguments[1]);
+ break;
+ case 3:
+ handler.call(this, arguments[1], arguments[2]);
+ break;
+ // slower
+ default:
+ var args = Array.prototype.slice.call(arguments, 1);
+ handler.apply(this, args);
+ }
+ return true;
+
+ } else if (isArray(handler)) {
+ var args = Array.prototype.slice.call(arguments, 1);
+
+ var listeners = handler.slice();
+ for (var i = 0, l = listeners.length; i < l; i++) {
+ listeners[i].apply(this, args);
+ }
+ return true;
+
+ } else {
+ return false;
+ }
+};
+
+// EventEmitter is defined in src/node_events.cc
+// EventEmitter.prototype.emit() is also defined there.
+EventEmitter.prototype.addListener = function(type, listener) {
+ if ('function' !== typeof listener) {
+ throw new Error('addListener only takes instances of Function');
+ }
+
+ if (!this._events) this._events = {};
+
+ // To avoid recursion in the case that type == "newListeners"! Before
+ // adding it to the listeners, first emit "newListeners".
+ this.emit('newListener', type, listener);
+
+ if (!this._events[type]) {
+ // Optimize the case of one listener. Don't need the extra array object.
+ this._events[type] = listener;
+ } else if (isArray(this._events[type])) {
+
+ // Check for listener leak
+ if (!this._events[type].warned) {
+ var m;
+ if (this._events.maxListeners !== undefined) {
+ m = this._events.maxListeners;
+ } else {
+ m = defaultMaxListeners;
+ }
+
+ if (m && m > 0 && this._events[type].length > m) {
+ this._events[type].warned = true;
+ console.error('(node) warning: possible EventEmitter memory ' +
+ 'leak detected. %d listeners added. ' +
+ 'Use emitter.setMaxListeners() to increase limit.',
+ this._events[type].length);
+ console.trace();
+ }
+ }
+
+ // If we've already got an array, just append.
+ this._events[type].push(listener);
+ } else {
+ // Adding the second element, need to change to array.
+ this._events[type] = [this._events[type], listener];
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+ var self = this;
+ self.on(type, function g() {
+ self.removeListener(type, g);
+ listener.apply(this, arguments);
+ });
+
+ return this;
+};
+
+EventEmitter.prototype.removeListener = function(type, listener) {
+ if ('function' !== typeof listener) {
+ throw new Error('removeListener only takes instances of Function');
+ }
+
+ // does not use listeners(), so no side effect of creating _events[type]
+ if (!this._events || !this._events[type]) return this;
+
+ var list = this._events[type];
+
+ if (isArray(list)) {
+ var i = list.indexOf(listener);
+ if (i < 0) return this;
+ list.splice(i, 1);
+ if (list.length == 0)
+ delete this._events[type];
+ } else if (this._events[type] === listener) {
+ delete this._events[type];
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ // does not use listeners(), so no side effect of creating _events[type]
+ if (type && this._events && this._events[type]) this._events[type] = null;
+ return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ if (!this._events) this._events = {};
+ if (!this._events[type]) this._events[type] = [];
+ if (!isArray(this._events[type])) {
+ this._events[type] = [this._events[type]];
+ }
+ return this._events[type];
+};
+
+});
+
+require.define("/node_modules/sprintf/package.json", function (require, module, exports, __dirname, __filename) {
+ module.exports = {"main":"./lib/sprintf"}
+});
+
+require.define("/node_modules/sprintf/lib/sprintf.js", function (require, module, exports, __dirname, __filename) {
+ /**
+sprintf() for JavaScript 0.7-beta1
+http://www.diveintojavascript.com/projects/javascript-sprintf
+
+Copyright (c) Alexandru Marasteanu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * 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.
+ * Neither the name of sprintf() for JavaScript nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 Alexandru Marasteanu 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.
+
+
+Changelog:
+2010.11.07 - 0.7-beta1-node
+ - converted it to a node.js compatible module
+
+2010.09.06 - 0.7-beta1
+ - features: vsprintf, support for named placeholders
+ - enhancements: format cache, reduced global namespace pollution
+
+2010.05.22 - 0.6:
+ - reverted to 0.4 and fixed the bug regarding the sign of the number 0
+ Note:
+ Thanks to Raphael Pigulla (http://www.n3rd.org/)
+ who warned me about a bug in 0.5, I discovered that the last update was
+ a regress. I appologize for that.
+
+2010.05.09 - 0.5:
+ - bug fix: 0 is now preceeded with a + sign
+ - bug fix: the sign was not at the right position on padded results (Kamal Abdali)
+ - switched from GPL to BSD license
+
+2007.10.21 - 0.4:
+ - unit test and patch (David Baird)
+
+2007.09.17 - 0.3:
+ - bug fix: no longer throws exception on empty paramenters (Hans Pufal)
+
+2007.09.11 - 0.2:
+ - feature: added argument swapping
+
+2007.04.03 - 0.1:
+ - initial release
+**/
+
+var sprintf = (function() {
+ function get_type(variable) {
+ return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase();
+ }
+ function str_repeat(input, multiplier) {
+ for (var output = []; multiplier > 0; output[--multiplier] = input) {/* do nothing */}
+ return output.join('');
+ }
+
+ var str_format = function() {
+ if (!str_format.cache.hasOwnProperty(arguments[0])) {
+ str_format.cache[arguments[0]] = str_format.parse(arguments[0]);
+ }
+ return str_format.format.call(null, str_format.cache[arguments[0]], arguments);
+ };
+
+ str_format.format = function(parse_tree, argv) {
+ var cursor = 1, tree_length = parse_tree.length, node_type = '', arg, output = [], i, k, match, pad, pad_character, pad_length;
+ for (i = 0; i < tree_length; i++) {
+ node_type = get_type(parse_tree[i]);
+ if (node_type === 'string') {
+ output.push(parse_tree[i]);
+ }
+ else if (node_type === 'array') {
+ match = parse_tree[i]; // convenience purposes only
+ if (match[2]) { // keyword argument
+ arg = argv[cursor];
+ for (k = 0; k < match[2].length; k++) {
+ if (!arg.hasOwnProperty(match[2][k])) {
+ throw(sprintf('[sprintf] property "%s" does not exist', match[2][k]));
+ }
+ arg = arg[match[2][k]];
+ }
+ }
+ else if (match[1]) { // positional argument (explicit)
+ arg = argv[match[1]];
+ }
+ else { // positional argument (implicit)
+ arg = argv[cursor++];
+ }
+
+ if (/[^s]/.test(match[8]) && (get_type(arg) != 'number')) {
+ throw(sprintf('[sprintf] expecting number but found %s', get_type(arg)));
+ }
+ switch (match[8]) {
+ case 'b': arg = arg.toString(2); break;
+ case 'c': arg = String.fromCharCode(arg); break;
+ case 'd': arg = parseInt(arg, 10); break;
+ case 'e': arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential(); break;
+ case 'f': arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg); break;
+ case 'o': arg = arg.toString(8); break;
+ case 's': arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg); break;
+ case 'u': arg = Math.abs(arg); break;
+ case 'x': arg = arg.toString(16); break;
+ case 'X': arg = arg.toString(16).toUpperCase(); break;
+ }
+ arg = (/[def]/.test(match[8]) && match[3] && arg >= 0 ? '+'+ arg : arg);
+ pad_character = match[4] ? match[4] == '0' ? '0' : match[4].charAt(1) : ' ';
+ pad_length = match[6] - String(arg).length;
+ pad = match[6] ? str_repeat(pad_character, pad_length) : '';
+ output.push(match[5] ? arg + pad : pad + arg);
+ }
+ }
+ return output.join('');
+ };
+
+ str_format.cache = {};
+
+ str_format.parse = function(fmt) {
+ var _fmt = fmt, match = [], parse_tree = [], arg_names = 0;
+ while (_fmt) {
+ if ((match = /^[^\x25]+/.exec(_fmt)) !== null) {
+ parse_tree.push(match[0]);
+ }
+ else if ((match = /^\x25{2}/.exec(_fmt)) !== null) {
+ parse_tree.push('%');
+ }
+ else if ((match = /^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(_fmt)) !== null) {
+ if (match[2]) {
+ arg_names |= 1;
+ var field_list = [], replacement_field = match[2], field_match = [];
+ if ((field_match = /^([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
+ if ((field_match = /^\.([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ }
+ else if ((field_match = /^\[(\d+)\]/.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ }
+ else {
+ throw('[sprintf] huh?');
+ }
+ }
+ }
+ else {
+ throw('[sprintf] huh?');
+ }
+ match[2] = field_list;
+ }
+ else {
+ arg_names |= 2;
+ }
+ if (arg_names === 3) {
+ throw('[sprintf] mixing positional and named placeholders is not (yet) supported');
+ }
+ parse_tree.push(match);
+ }
+ else {
+ throw('[sprintf] huh?');
+ }
+ _fmt = _fmt.substring(match[0].length);
+ }
+ return parse_tree;
+ };
+
+ return str_format;
+})();
+
+var vsprintf = function(fmt, argv) {
+ argv.unshift(fmt);
+ return sprintf.apply(null, argv);
+};
+
+exports.sprintf = sprintf;
+exports.vsprintf = vsprintf;
+});
+
+require.define("/shred/response.js", function (require, module, exports, __dirname, __filename) {
+ // The `Response object` encapsulates a Node.js HTTP response.
+
+var Content = require("./content")
+ , HeaderMixins = require("./mixins/headers")
+ , CookieJarLib = require( "cookiejar" )
+ , Cookie = CookieJarLib.Cookie
+;
+
+// Browser doesn't have zlib.
+var zlib = null;
+try {
+ zlib = require('zlib');
+} catch (e) {
+ console.warn("no zlib library");
+}
+
+// Iconv doesn't work in browser
+var Iconv = null;
+try {
+ Iconv = require('iconv-lite');
+} catch (e) {
+ console.warn("no iconv library");
+}
+
+// Construct a `Response` object. You should never have to do this directly. The
+// `Request` object handles this, getting the raw response object and passing it
+// in here, along with the request. The callback allows us to stream the response
+// and then use the callback to let the request know when it's ready.
+var Response = function(raw, request, callback) {
+ var response = this;
+ this._raw = raw;
+
+ // The `._setHeaders` method is "private"; you can't otherwise set headers on
+ // the response.
+ this._setHeaders.call(this,raw.headers);
+
+ // store any cookies
+ if (request.cookieJar && this.getHeader('set-cookie')) {
+ var cookieStrings = this.getHeader('set-cookie');
+ var cookieObjs = []
+ , cookie;
+
+ for (var i = 0; i < cookieStrings.length; i++) {
+ var cookieString = cookieStrings[i];
+ if (!cookieString) {
+ continue;
+ }
+
+ if (!cookieString.match(/domain\=/i)) {
+ cookieString += '; domain=' + request.host;
+ }
+
+ if (!cookieString.match(/path\=/i)) {
+ cookieString += '; path=' + request.path;
+ }
+
+ try {
+ cookie = new Cookie(cookieString);
+ if (cookie) {
+ cookieObjs.push(cookie);
+ }
+ } catch (e) {
+ console.warn("Tried to set bad cookie: " + cookieString);
+ }
+ }
+
+ request.cookieJar.setCookies(cookieObjs);
+ }
+
+ this.request = request;
+ this.client = request.client;
+ this.log = this.request.log;
+
+ // Stream the response content entity and fire the callback when we're done.
+ // Store the incoming data in a array of Buffers which we concatinate into one
+ // buffer at the end. We need to use buffers instead of strings here in order
+ // to preserve binary data.
+ var chunkBuffers = [];
+ var dataLength = 0;
+ raw.on("data", function(chunk) {
+ chunkBuffers.push(chunk);
+ dataLength += chunk.length;
+ });
+ raw.on("end", function() {
+ var body;
+ if (typeof Buffer === 'undefined') {
+ // Just concatinate into a string
+ body = chunkBuffers.join('');
+ } else {
+ // Initialize new buffer and add the chunks one-at-a-time.
+ body = new Buffer(dataLength);
+ for (var i = 0, pos = 0; i < chunkBuffers.length; i++) {
+ chunkBuffers[i].copy(body, pos);
+ pos += chunkBuffers[i].length;
+ }
+ }
+
+ var setBodyAndFinish = function (body) {
+ response._body = new Content({
+ body: body,
+ type: response.getHeader("Content-Type")
+ });
+ callback(response);
+ }
+
+ if (zlib && response.getHeader("Content-Encoding") === 'gzip'){
+ zlib.gunzip(body, function (err, gunzippedBody) {
+ if (Iconv && response.request.encoding){
+ body = Iconv.fromEncoding(gunzippedBody,response.request.encoding);
+ } else {
+ body = gunzippedBody.toString();
+ }
+ setBodyAndFinish(body);
+ })
+ }
+ else{
+ if (response.request.encoding){
+ body = Iconv.fromEncoding(body,response.request.encoding);
+ }
+ setBodyAndFinish(body);
+ }
+ });
+};
+
+// The `Response` object can be pretty overwhelming to view using the built-in
+// Node.js inspect method. We want to make it a bit more manageable. This
+// probably goes [too far in the other
+// direction](https://github.com/spire-io/shred/issues/2).
+
+Response.prototype = {
+ inspect: function() {
+ var response = this;
+ var headers = this.format_headers();
+ var summary = [" ", response.status].join(" ")
+ return [ summary, "- Headers:", headers].join("\n");
+ },
+ format_headers: function () {
+ var array = []
+ var headers = this._headers
+ for (var key in headers) {
+ if (headers.hasOwnProperty(key)) {
+ var value = headers[key]
+ array.push("\t" + key + ": " + value);
+ }
+ }
+ return array.join("\n");
+ }
+};
+
+// `Response` object properties, all of which are read-only:
+Object.defineProperties(Response.prototype, {
+
+// - **status**. The HTTP status code for the response.
+ status: {
+ get: function() { return this._raw.statusCode; },
+ enumerable: true
+ },
+
+// - **content**. The HTTP content entity, if any. Provided as a [content
+// object](./content.html), which will attempt to convert the entity based upon
+// the `content-type` header. The converted value is available as
+// `content.data`. The original raw content entity is available as
+// `content.body`.
+ body: {
+ get: function() { return this._body; }
+ },
+ content: {
+ get: function() { return this.body; },
+ enumerable: true
+ },
+
+// - **isRedirect**. Is the response a redirect? These are responses with 3xx
+// status and a `Location` header.
+ isRedirect: {
+ get: function() {
+ return (this.status>299
+ &&this.status<400
+ &&this.getHeader("Location"));
+ },
+ enumerable: true
+ },
+
+// - **isError**. Is the response an error? These are responses with status of
+// 400 or greater.
+ isError: {
+ get: function() {
+ return (this.status === 0 || this.status > 399)
+ },
+ enumerable: true
+ }
+});
+
+// Add in the [getters for accessing the normalized headers](./headers.js).
+HeaderMixins.getters(Response);
+HeaderMixins.privateSetters(Response);
+
+// Work around Mozilla bug #608735 [https://bugzil.la/608735], which causes
+// getAllResponseHeaders() to return {} if the response is a CORS request.
+// xhr.getHeader still works correctly.
+var getHeader = Response.prototype.getHeader;
+Response.prototype.getHeader = function (name) {
+ return (getHeader.call(this,name) ||
+ (typeof this._raw.getHeader === 'function' && this._raw.getHeader(name)));
+};
+
+module.exports = Response;
+
+});
+
+require.define("/shred/content.js", function (require, module, exports, __dirname, __filename) {
+
+// The purpose of the `Content` object is to abstract away the data conversions
+// to and from raw content entities as strings. For example, you want to be able
+// to pass in a Javascript object and have it be automatically converted into a
+// JSON string if the `content-type` is set to a JSON-based media type.
+// Conversely, you want to be able to transparently get back a Javascript object
+// in the response if the `content-type` is a JSON-based media-type.
+
+// One limitation of the current implementation is that it [assumes the `charset` is UTF-8](https://github.com/spire-io/shred/issues/5).
+
+// The `Content` constructor takes an options object, which *must* have either a
+// `body` or `data` property and *may* have a `type` property indicating the
+// media type. If there is no `type` attribute, a default will be inferred.
+var Content = function(options) {
+ this.body = options.body;
+ this.data = options.data;
+ this.type = options.type;
+};
+
+Content.prototype = {
+ // Treat `toString()` as asking for the `content.body`. That is, the raw content entity.
+ //
+ // toString: function() { return this.body; }
+ //
+ // Commented out, but I've forgotten why. :/
+};
+
+
+// `Content` objects have the following attributes:
+Object.defineProperties(Content.prototype,{
+
+// - **type**. Typically accessed as `content.type`, reflects the `content-type`
+// header associated with the request or response. If not passed as an options
+// to the constructor or set explicitly, it will infer the type the `data`
+// attribute, if possible, and, failing that, will default to `text/plain`.
+ type: {
+ get: function() {
+ if (this._type) {
+ return this._type;
+ } else {
+ if (this._data) {
+ switch(typeof this._data) {
+ case "string": return "text/plain";
+ case "object": return "application/json";
+ }
+ }
+ }
+ return "text/plain";
+ },
+ set: function(value) {
+ this._type = value;
+ return this;
+ },
+ enumerable: true
+ },
+
+// - **data**. Typically accessed as `content.data`, reflects the content entity
+// converted into Javascript data. This can be a string, if the `type` is, say,
+// `text/plain`, but can also be a Javascript object. The conversion applied is
+// based on the `processor` attribute. The `data` attribute can also be set
+// directly, in which case the conversion will be done the other way, to infer
+// the `body` attribute.
+ data: {
+ get: function() {
+ if (this._body) {
+ return this.processor.parser(this._body);
+ } else {
+ return this._data;
+ }
+ },
+ set: function(data) {
+ if (this._body&&data) Errors.setDataWithBody(this);
+ this._data = data;
+ return this;
+ },
+ enumerable: true
+ },
+
+// - **body**. Typically accessed as `content.body`, reflects the content entity
+// as a UTF-8 string. It is the mirror of the `data` attribute. If you set the
+// `data` attribute, the `body` attribute will be inferred and vice-versa. If
+// you attempt to set both, an exception is raised.
+ body: {
+ get: function() {
+ if (this._data) {
+ return this.processor.stringify(this._data);
+ } else {
+ return this.processor.stringify(this._body);
+ }
+ },
+ set: function(body) {
+ if (this._data&&body) Errors.setBodyWithData(this);
+ this._body = body;
+ return this;
+ },
+ enumerable: true
+ },
+
+// - **processor**. The functions that will be used to convert to/from `data` and
+// `body` attributes. You can add processors. The two that are built-in are for
+// `text/plain`, which is basically an identity transformation and
+// `application/json` and other JSON-based media types (including custom media
+// types with `+json`). You can add your own processors. See below.
+ processor: {
+ get: function() {
+ var processor = Content.processors[this.type];
+ if (processor) {
+ return processor;
+ } else {
+ // Return the first processor that matches any part of the
+ // content type. ex: application/vnd.foobar.baz+json will match json.
+ var main = this.type.split(";")[0];
+ var parts = main.split(/\+|\//);
+ for (var i=0, l=parts.length; i < l; i++) {
+ processor = Content.processors[parts[i]]
+ }
+ return processor || {parser:identity,stringify:toString};
+ }
+ },
+ enumerable: true
+ },
+
+// - **length**. Typically accessed as `content.length`, returns the length in
+// bytes of the raw content entity.
+ length: {
+ get: function() {
+ if (typeof Buffer !== 'undefined') {
+ return Buffer.byteLength(this.body);
+ }
+ return this.body.length;
+ }
+ }
+});
+
+Content.processors = {};
+
+// The `registerProcessor` function allows you to add your own processors to
+// convert content entities. Each processor consists of a Javascript object with
+// two properties:
+// - **parser**. The function used to parse a raw content entity and convert it
+// into a Javascript data type.
+// - **stringify**. The function used to convert a Javascript data type into a
+// raw content entity.
+Content.registerProcessor = function(types,processor) {
+
+// You can pass an array of types that will trigger this processor, or just one.
+// We determine the array via duck-typing here.
+ if (types.forEach) {
+ types.forEach(function(type) {
+ Content.processors[type] = processor;
+ });
+ } else {
+ // If you didn't pass an array, we just use what you pass in.
+ Content.processors[types] = processor;
+ }
+};
+
+// Register the identity processor, which is used for text-based media types.
+var identity = function(x) { return x; }
+ , toString = function(x) { return x.toString(); }
+Content.registerProcessor(
+ ["text/html","text/plain","text"],
+ { parser: identity, stringify: toString });
+
+// Register the JSON processor, which is used for JSON-based media types.
+Content.registerProcessor(
+ ["application/json; charset=utf-8","application/json","json"],
+ {
+ parser: function(string) {
+ return JSON.parse(string);
+ },
+ stringify: function(data) {
+ return JSON.stringify(data); }});
+
+// Error functions are defined separately here in an attempt to make the code
+// easier to read.
+var Errors = {
+ setDataWithBody: function(object) {
+ throw new Error("Attempt to set data attribute of a content object " +
+ "when the body attributes was already set.");
+ },
+ setBodyWithData: function(object) {
+ throw new Error("Attempt to set body attribute of a content object " +
+ "when the data attributes was already set.");
+ }
+}
+module.exports = Content;
+
+});
+
+require.define("/shred/mixins/headers.js", function (require, module, exports, __dirname, __filename) {
+ // The header mixins allow you to add HTTP header support to any object. This
+// might seem pointless: why not simply use a hash? The main reason is that, per
+// the [HTTP spec](http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2),
+// headers are case-insensitive. So, for example, `content-type` is the same as
+// `CONTENT-TYPE` which is the same as `Content-Type`. Since there is no way to
+// overload the index operator in Javascript, using a hash to represent the
+// headers means it's possible to have two conflicting values for a single
+// header.
+//
+// The solution to this is to provide explicit methods to set or get headers.
+// This also has the benefit of allowing us to introduce additional variations,
+// including snake case, which we automatically convert to what Matthew King has
+// dubbed "corset case" - the hyphen-separated names with initial caps:
+// `Content-Type`. We use corset-case just in case we're dealing with servers
+// that haven't properly implemented the spec.
+
+// Convert headers to corset-case. **Example:** `CONTENT-TYPE` will be converted
+// to `Content-Type`.
+
+var corsetCase = function(string) {
+ return string.toLowerCase()
+ //.replace("_","-")
+ .replace(/(^|-)(\w)/g,
+ function(s) { return s.toUpperCase(); });
+};
+
+// We suspect that `initializeHeaders` was once more complicated ...
+var initializeHeaders = function(object) {
+ return {};
+};
+
+// Access the `_headers` property using lazy initialization. **Warning:** If you
+// mix this into an object that is using the `_headers` property already, you're
+// going to have trouble.
+var $H = function(object) {
+ return object._headers||(object._headers=initializeHeaders(object));
+};
+
+// Hide the implementations as private functions, separate from how we expose them.
+
+// The "real" `getHeader` function: get the header after normalizing the name.
+var getHeader = function(object,name) {
+ return $H(object)[corsetCase(name)];
+};
+
+// The "real" `getHeader` function: get one or more headers, or all of them
+// if you don't ask for any specifics.
+var getHeaders = function(object,names) {
+ var keys = (names && names.length>0) ? names : Object.keys($H(object));
+ var hash = keys.reduce(function(hash,key) {
+ hash[key] = getHeader(object,key);
+ return hash;
+ },{});
+ // Freeze the resulting hash so you don't mistakenly think you're modifying
+ // the real headers.
+ Object.freeze(hash);
+ return hash;
+};
+
+// The "real" `setHeader` function: set a header, after normalizing the name.
+var setHeader = function(object,name,value) {
+ $H(object)[corsetCase(name)] = value;
+ return object;
+};
+
+// The "real" `setHeaders` function: set multiple headers based on a hash.
+var setHeaders = function(object,hash) {
+ for( var key in hash ) { setHeader(object,key,hash[key]); };
+ return this;
+};
+
+// Here's where we actually bind the functionality to an object. These mixins work by
+// exposing mixin functions. Each function mixes in a specific batch of features.
+module.exports = {
+
+ // Add getters.
+ getters: function(constructor) {
+ constructor.prototype.getHeader = function(name) { return getHeader(this,name); };
+ constructor.prototype.getHeaders = function() { return getHeaders(this,arguments); };
+ },
+ // Add setters but as "private" methods.
+ privateSetters: function(constructor) {
+ constructor.prototype._setHeader = function(key,value) { return setHeader(this,key,value); };
+ constructor.prototype._setHeaders = function(hash) { return setHeaders(this,hash); };
+ },
+ // Add setters.
+ setters: function(constructor) {
+ constructor.prototype.setHeader = function(key,value) { return setHeader(this,key,value); };
+ constructor.prototype.setHeaders = function(hash) { return setHeaders(this,hash); };
+ },
+ // Add both getters and setters.
+ gettersAndSetters: function(constructor) {
+ constructor.prototype.getHeader = function(name) { return getHeader(this,name); };
+ constructor.prototype.getHeaders = function() { return getHeaders(this,arguments); };
+ constructor.prototype.setHeader = function(key,value) { return setHeader(this,key,value); };
+ constructor.prototype.setHeaders = function(hash) { return setHeaders(this,hash); };
+ },
+};
+
+});
+
+require.define("/node_modules/iconv-lite/package.json", function (require, module, exports, __dirname, __filename) {
+ module.exports = {}
+});
+
+require.define("/node_modules/iconv-lite/index.js", function (require, module, exports, __dirname, __filename) {
+ // Module exports
+var iconv = module.exports = {
+ toEncoding: function(str, encoding) {
+ return iconv.getCodec(encoding).toEncoding(str);
+ },
+ fromEncoding: function(buf, encoding) {
+ return iconv.getCodec(encoding).fromEncoding(buf);
+ },
+
+ defaultCharUnicode: '�',
+ defaultCharSingleByte: '?',
+
+ // Get correct codec for given encoding.
+ getCodec: function(encoding) {
+ var enc = encoding || "utf8";
+ var codecOptions = undefined;
+ while (1) {
+ if (getType(enc) === "String")
+ enc = enc.replace(/[- ]/g, "").toLowerCase();
+ var codec = iconv.encodings[enc];
+ var type = getType(codec);
+ if (type === "String") {
+ // Link to other encoding.
+ codecOptions = {originalEncoding: enc};
+ enc = codec;
+ }
+ else if (type === "Object" && codec.type != undefined) {
+ // Options for other encoding.
+ codecOptions = codec;
+ enc = codec.type;
+ }
+ else if (type === "Function")
+ // Codec itself.
+ return codec(codecOptions);
+ else
+ throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '"+enc+"')");
+ }
+ },
+
+ // Define basic encodings
+ encodings: {
+ internal: function(options) {
+ return {
+ toEncoding: function(str) {
+ return new Buffer(ensureString(str), options.originalEncoding);
+ },
+ fromEncoding: function(buf) {
+ return ensureBuffer(buf).toString(options.originalEncoding);
+ }
+ };
+ },
+ utf8: "internal",
+ ucs2: "internal",
+ binary: "internal",
+ ascii: "internal",
+ base64: "internal",
+
+ // Codepage single-byte encodings.
+ singlebyte: function(options) {
+ // Prepare chars if needed
+ if (!options.chars || (options.chars.length !== 128 && options.chars.length !== 256))
+ throw new Error("Encoding '"+options.type+"' has incorrect 'chars' (must be of len 128 or 256)");
+
+ if (options.chars.length === 128)
+ options.chars = asciiString + options.chars;
+
+ if (!options.charsBuf) {
+ options.charsBuf = new Buffer(options.chars, 'ucs2');
+ }
+
+ if (!options.revCharsBuf) {
+ options.revCharsBuf = new Buffer(65536);
+ var defChar = iconv.defaultCharSingleByte.charCodeAt(0);
+ for (var i = 0; i < options.revCharsBuf.length; i++)
+ options.revCharsBuf[i] = defChar;
+ for (var i = 0; i < options.chars.length; i++)
+ options.revCharsBuf[options.chars.charCodeAt(i)] = i;
+ }
+
+ return {
+ toEncoding: function(str) {
+ str = ensureString(str);
+
+ var buf = new Buffer(str.length);
+ var revCharsBuf = options.revCharsBuf;
+ for (var i = 0; i < str.length; i++)
+ buf[i] = revCharsBuf[str.charCodeAt(i)];
+
+ return buf;
+ },
+ fromEncoding: function(buf) {
+ buf = ensureBuffer(buf);
+
+ // Strings are immutable in JS -> we use ucs2 buffer to speed up computations.
+ var charsBuf = options.charsBuf;
+ var newBuf = new Buffer(buf.length*2);
+ var idx1 = 0, idx2 = 0;
+ for (var i = 0, _len = buf.length; i < _len; i++) {
+ idx1 = buf[i]*2; idx2 = i*2;
+ newBuf[idx2] = charsBuf[idx1];
+ newBuf[idx2+1] = charsBuf[idx1+1];
+ }
+ return newBuf.toString('ucs2');
+ }
+ };
+ },
+
+ // Codepage double-byte encodings.
+ table: function(options) {
+ var table = options.table, key, revCharsTable = options.revCharsTable;
+ if (!table) {
+ throw new Error("Encoding '" + options.type +"' has incorect 'table' option");
+ }
+ if(!revCharsTable) {
+ revCharsTable = options.revCharsTable = {};
+ for (key in table) {
+ revCharsTable[table[key]] = parseInt(key);
+ }
+ }
+
+ return {
+ toEncoding: function(str) {
+ str = ensureString(str);
+ var strLen = str.length;
+ var bufLen = strLen;
+ for (var i = 0; i < strLen; i++)
+ if (str.charCodeAt(i) >> 7)
+ bufLen++;
+
+ var newBuf = new Buffer(bufLen), gbkcode, unicode,
+ defaultChar = revCharsTable[iconv.defaultCharUnicode.charCodeAt(0)];
+
+ for (var i = 0, j = 0; i < strLen; i++) {
+ unicode = str.charCodeAt(i);
+ if (unicode >> 7) {
+ gbkcode = revCharsTable[unicode] || defaultChar;
+ newBuf[j++] = gbkcode >> 8; //high byte;
+ newBuf[j++] = gbkcode & 0xFF; //low byte
+ } else {//ascii
+ newBuf[j++] = unicode;
+ }
+ }
+ return newBuf;
+ },
+ fromEncoding: function(buf) {
+ buf = ensureBuffer(buf);
+ var bufLen = buf.length, strLen = 0;
+ for (var i = 0; i < bufLen; i++) {
+ strLen++;
+ if (buf[i] & 0x80) //the high bit is 1, so this byte is gbkcode's high byte.skip next byte
+ i++;
+ }
+ var newBuf = new Buffer(strLen*2), unicode, gbkcode,
+ defaultChar = iconv.defaultCharUnicode.charCodeAt(0);
+
+ for (var i = 0, j = 0; i < bufLen; i++, j+=2) {
+ gbkcode = buf[i];
+ if (gbkcode & 0x80) {
+ gbkcode = (gbkcode << 8) + buf[++i];
+ unicode = table[gbkcode] || defaultChar;
+ } else {
+ unicode = gbkcode;
+ }
+ newBuf[j] = unicode & 0xFF; //low byte
+ newBuf[j+1] = unicode >> 8; //high byte
+ }
+ return newBuf.toString('ucs2');
+ }
+ }
+ }
+ }
+};
+
+// Add aliases to convert functions
+iconv.encode = iconv.toEncoding;
+iconv.decode = iconv.fromEncoding;
+
+// Load other encodings from files in /encodings dir.
+var encodingsDir = __dirname+"/encodings/",
+ fs = require('fs');
+fs.readdirSync(encodingsDir).forEach(function(file) {
+ if(fs.statSync(encodingsDir + file).isDirectory()) return;
+ var encodings = require(encodingsDir + file)
+ for (var key in encodings)
+ iconv.encodings[key] = encodings[key]
+});
+
+// Utilities
+var asciiString = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f'+
+ ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f';
+
+var ensureBuffer = function(buf) {
+ buf = buf || new Buffer(0);
+ return (buf instanceof Buffer) ? buf : new Buffer(buf.toString(), "utf8");
+}
+
+var ensureString = function(str) {
+ str = str || "";
+ return (str instanceof String) ? str : str.toString((str instanceof Buffer) ? 'utf8' : undefined);
+}
+
+var getType = function(obj) {
+ return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
+
+});
+
+require.define("/node_modules/http-browserify/package.json", function (require, module, exports, __dirname, __filename) {
+ module.exports = {"main":"index.js","browserify":"browser.js"}
+});
+
+require.define("/node_modules/http-browserify/browser.js", function (require, module, exports, __dirname, __filename) {
+ var http = module.exports;
+var EventEmitter = require('events').EventEmitter;
+var Request = require('./lib/request');
+
+http.request = function (params, cb) {
+ if (!params) params = {};
+ if (!params.host) params.host = window.location.host.split(':')[0];
+ if (!params.port) params.port = window.location.port;
+
+ var req = new Request(new xhrHttp, params);
+ if (cb) req.on('response', cb);
+ return req;
+};
+
+http.get = function (params, cb) {
+ params.method = 'GET';
+ var req = http.request(params, cb);
+ req.end();
+ return req;
+};
+
+var xhrHttp = (function () {
+ if (typeof window === 'undefined') {
+ throw new Error('no window object present');
+ }
+ else if (window.XMLHttpRequest) {
+ return window.XMLHttpRequest;
+ }
+ else if (window.ActiveXObject) {
+ var axs = [
+ 'Msxml2.XMLHTTP.6.0',
+ 'Msxml2.XMLHTTP.3.0',
+ 'Microsoft.XMLHTTP'
+ ];
+ for (var i = 0; i < axs.length; i++) {
+ try {
+ var ax = new(window.ActiveXObject)(axs[i]);
+ return function () {
+ if (ax) {
+ var ax_ = ax;
+ ax = null;
+ return ax_;
+ }
+ else {
+ return new(window.ActiveXObject)(axs[i]);
+ }
+ };
+ }
+ catch (e) {}
+ }
+ throw new Error('ajax not supported in this browser')
+ }
+ else {
+ throw new Error('ajax not supported in this browser');
+ }
+})();
+
+http.STATUS_CODES = {
+ 100 : 'Continue',
+ 101 : 'Switching Protocols',
+ 102 : 'Processing', // RFC 2518, obsoleted by RFC 4918
+ 200 : 'OK',
+ 201 : 'Created',
+ 202 : 'Accepted',
+ 203 : 'Non-Authoritative Information',
+ 204 : 'No Content',
+ 205 : 'Reset Content',
+ 206 : 'Partial Content',
+ 207 : 'Multi-Status', // RFC 4918
+ 300 : 'Multiple Choices',
+ 301 : 'Moved Permanently',
+ 302 : 'Moved Temporarily',
+ 303 : 'See Other',
+ 304 : 'Not Modified',
+ 305 : 'Use Proxy',
+ 307 : 'Temporary Redirect',
+ 400 : 'Bad Request',
+ 401 : 'Unauthorized',
+ 402 : 'Payment Required',
+ 403 : 'Forbidden',
+ 404 : 'Not Found',
+ 405 : 'Method Not Allowed',
+ 406 : 'Not Acceptable',
+ 407 : 'Proxy Authentication Required',
+ 408 : 'Request Time-out',
+ 409 : 'Conflict',
+ 410 : 'Gone',
+ 411 : 'Length Required',
+ 412 : 'Precondition Failed',
+ 413 : 'Request Entity Too Large',
+ 414 : 'Request-URI Too Large',
+ 415 : 'Unsupported Media Type',
+ 416 : 'Requested Range Not Satisfiable',
+ 417 : 'Expectation Failed',
+ 418 : 'I\'m a teapot', // RFC 2324
+ 422 : 'Unprocessable Entity', // RFC 4918
+ 423 : 'Locked', // RFC 4918
+ 424 : 'Failed Dependency', // RFC 4918
+ 425 : 'Unordered Collection', // RFC 4918
+ 426 : 'Upgrade Required', // RFC 2817
+ 500 : 'Internal Server Error',
+ 501 : 'Not Implemented',
+ 502 : 'Bad Gateway',
+ 503 : 'Service Unavailable',
+ 504 : 'Gateway Time-out',
+ 505 : 'HTTP Version not supported',
+ 506 : 'Variant Also Negotiates', // RFC 2295
+ 507 : 'Insufficient Storage', // RFC 4918
+ 509 : 'Bandwidth Limit Exceeded',
+ 510 : 'Not Extended' // RFC 2774
+};
+
+});
+
+require.define("/node_modules/http-browserify/lib/request.js", function (require, module, exports, __dirname, __filename) {
+ var EventEmitter = require('events').EventEmitter;
+var Response = require('./response');
+var isSafeHeader = require('./isSafeHeader');
+
+var Request = module.exports = function (xhr, params) {
+ var self = this;
+ self.xhr = xhr;
+ self.body = '';
+
+ var uri = params.host + ':' + params.port + (params.path || '/');
+
+ xhr.open(
+ params.method || 'GET',
+ (params.scheme || 'http') + '://' + uri,
+ true
+ );
+
+ if (params.headers) {
+ Object.keys(params.headers).forEach(function (key) {
+ if (!isSafeHeader(key)) return;
+ var value = params.headers[key];
+ if (Array.isArray(value)) {
+ value.forEach(function (v) {
+ xhr.setRequestHeader(key, v);
+ });
+ }
+ else xhr.setRequestHeader(key, value)
+ });
+ }
+
+ var res = new Response(xhr);
+ res.on('ready', function () {
+ self.emit('response', res);
+ });
+
+ xhr.onreadystatechange = function () {
+ res.handle(xhr);
+ };
+};
+
+Request.prototype = new EventEmitter;
+
+Request.prototype.setHeader = function (key, value) {
+ if ((Array.isArray && Array.isArray(value))
+ || value instanceof Array) {
+ for (var i = 0; i < value.length; i++) {
+ this.xhr.setRequestHeader(key, value[i]);
+ }
+ }
+ else {
+ this.xhr.setRequestHeader(key, value);
+ }
+};
+
+Request.prototype.write = function (s) {
+ this.body += s;
+};
+
+Request.prototype.end = function (s) {
+ if (s !== undefined) this.write(s);
+ this.xhr.send(this.body);
+};
+
+});
+
+require.define("/node_modules/http-browserify/lib/response.js", function (require, module, exports, __dirname, __filename) {
+ var EventEmitter = require('events').EventEmitter;
+var isSafeHeader = require('./isSafeHeader');
+
+var Response = module.exports = function (xhr) {
+ this.xhr = xhr;
+ this.offset = 0;
+};
+
+Response.prototype = new EventEmitter;
+
+var capable = {
+ streaming : true,
+ status2 : true
+};
+
+function parseHeaders (xhr) {
+ var lines = xhr.getAllResponseHeaders().split(/\r?\n/);
+ var headers = {};
+ for (var i = 0; i < lines.length; i++) {
+ var line = lines[i];
+ if (line === '') continue;
+
+ var m = line.match(/^([^:]+):\s*(.*)/);
+ if (m) {
+ var key = m[1].toLowerCase(), value = m[2];
+
+ if (headers[key] !== undefined) {
+ if ((Array.isArray && Array.isArray(headers[key]))
+ || headers[key] instanceof Array) {
+ headers[key].push(value);
+ }
+ else {
+ headers[key] = [ headers[key], value ];
+ }
+ }
+ else {
+ headers[key] = value;
+ }
+ }
+ else {
+ headers[line] = true;
+ }
+ }
+ return headers;
+}
+
+Response.prototype.getHeader = function (key) {
+ var header = this.headers ? this.headers[key.toLowerCase()] : null;
+ if (header) return header;
+
+ // Work around Mozilla bug #608735 [https://bugzil.la/608735], which causes
+ // getAllResponseHeaders() to return {} if the response is a CORS request.
+ // xhr.getHeader still works correctly.
+ if (isSafeHeader(key)) {
+ return this.xhr.getResponseHeader(key);
+ }
+ return null;
+};
+
+Response.prototype.handle = function () {
+ var xhr = this.xhr;
+ if (xhr.readyState === 2 && capable.status2) {
+ try {
+ this.statusCode = xhr.status;
+ this.headers = parseHeaders(xhr);
+ }
+ catch (err) {
+ capable.status2 = false;
+ }
+
+ if (capable.status2) {
+ this.emit('ready');
+ }
+ }
+ else if (capable.streaming && xhr.readyState === 3) {
+ try {
+ if (!this.statusCode) {
+ this.statusCode = xhr.status;
+ this.headers = parseHeaders(xhr);
+ this.emit('ready');
+ }
+ }
+ catch (err) {}
+
+ try {
+ this.write();
+ }
+ catch (err) {
+ capable.streaming = false;
+ }
+ }
+ else if (xhr.readyState === 4) {
+ if (!this.statusCode) {
+ this.statusCode = xhr.status;
+ this.emit('ready');
+ }
+ this.write();
+
+ if (xhr.error) {
+ this.emit('error', xhr.responseText);
+ }
+ else this.emit('end');
+ }
+};
+
+Response.prototype.write = function () {
+ var xhr = this.xhr;
+ if (xhr.responseText.length > this.offset) {
+ this.emit('data', xhr.responseText.slice(this.offset));
+ this.offset = xhr.responseText.length;
+ }
+};
+
+});
+
+require.define("/node_modules/http-browserify/lib/isSafeHeader.js", function (require, module, exports, __dirname, __filename) {
+ // Taken from http://dxr.mozilla.org/mozilla/mozilla-central/content/base/src/nsXMLHttpRequest.cpp.html
+var unsafeHeaders = [
+ "accept-charset",
+ "accept-encoding",
+ "access-control-request-headers",
+ "access-control-request-method",
+ "connection",
+ "content-length",
+ "cookie",
+ "cookie2",
+ "content-transfer-encoding",
+ "date",
+ "expect",
+ "host",
+ "keep-alive",
+ "origin",
+ "referer",
+ "set-cookie",
+ "te",
+ "trailer",
+ "transfer-encoding",
+ "upgrade",
+ "user-agent",
+ "via"
+];
+
+module.exports = function (headerName) {
+ if (!headerName) return false;
+ return (unsafeHeaders.indexOf(headerName.toLowerCase()) === -1)
+};
+
+});
+
+require.alias("http-browserify", "/node_modules/http");
+
+require.alias("http-browserify", "/node_modules/https");
\ No newline at end of file
diff --git a/public/lib/shred/content.js b/public/lib/shred/content.js
new file mode 100644
index 0000000..b8051fe
--- /dev/null
+++ b/public/lib/shred/content.js
@@ -0,0 +1,193 @@
+
+// The purpose of the `Content` object is to abstract away the data conversions
+// to and from raw content entities as strings. For example, you want to be able
+// to pass in a Javascript object and have it be automatically converted into a
+// JSON string if the `content-type` is set to a JSON-based media type.
+// Conversely, you want to be able to transparently get back a Javascript object
+// in the response if the `content-type` is a JSON-based media-type.
+
+// One limitation of the current implementation is that it [assumes the `charset` is UTF-8](https://github.com/spire-io/shred/issues/5).
+
+// The `Content` constructor takes an options object, which *must* have either a
+// `body` or `data` property and *may* have a `type` property indicating the
+// media type. If there is no `type` attribute, a default will be inferred.
+var Content = function(options) {
+ this.body = options.body;
+ this.data = options.data;
+ this.type = options.type;
+};
+
+Content.prototype = {
+ // Treat `toString()` as asking for the `content.body`. That is, the raw content entity.
+ //
+ // toString: function() { return this.body; }
+ //
+ // Commented out, but I've forgotten why. :/
+};
+
+
+// `Content` objects have the following attributes:
+Object.defineProperties(Content.prototype,{
+
+// - **type**. Typically accessed as `content.type`, reflects the `content-type`
+// header associated with the request or response. If not passed as an options
+// to the constructor or set explicitly, it will infer the type the `data`
+// attribute, if possible, and, failing that, will default to `text/plain`.
+ type: {
+ get: function() {
+ if (this._type) {
+ return this._type;
+ } else {
+ if (this._data) {
+ switch(typeof this._data) {
+ case "string": return "text/plain";
+ case "object": return "application/json";
+ }
+ }
+ }
+ return "text/plain";
+ },
+ set: function(value) {
+ this._type = value;
+ return this;
+ },
+ enumerable: true
+ },
+
+// - **data**. Typically accessed as `content.data`, reflects the content entity
+// converted into Javascript data. This can be a string, if the `type` is, say,
+// `text/plain`, but can also be a Javascript object. The conversion applied is
+// based on the `processor` attribute. The `data` attribute can also be set
+// directly, in which case the conversion will be done the other way, to infer
+// the `body` attribute.
+ data: {
+ get: function() {
+ if (this._body) {
+ return this.processor.parser(this._body);
+ } else {
+ return this._data;
+ }
+ },
+ set: function(data) {
+ if (this._body&&data) Errors.setDataWithBody(this);
+ this._data = data;
+ return this;
+ },
+ enumerable: true
+ },
+
+// - **body**. Typically accessed as `content.body`, reflects the content entity
+// as a UTF-8 string. It is the mirror of the `data` attribute. If you set the
+// `data` attribute, the `body` attribute will be inferred and vice-versa. If
+// you attempt to set both, an exception is raised.
+ body: {
+ get: function() {
+ if (this._data) {
+ return this.processor.stringify(this._data);
+ } else {
+ return this._body.toString();
+ }
+ },
+ set: function(body) {
+ if (this._data&&body) Errors.setBodyWithData(this);
+ this._body = body;
+ return this;
+ },
+ enumerable: true
+ },
+
+// - **processor**. The functions that will be used to convert to/from `data` and
+// `body` attributes. You can add processors. The two that are built-in are for
+// `text/plain`, which is basically an identity transformation and
+// `application/json` and other JSON-based media types (including custom media
+// types with `+json`). You can add your own processors. See below.
+ processor: {
+ get: function() {
+ var processor = Content.processors[this.type];
+ if (processor) {
+ return processor;
+ } else {
+ // Return the first processor that matches any part of the
+ // content type. ex: application/vnd.foobar.baz+json will match json.
+ var main = this.type.split(";")[0];
+ var parts = main.split(/\+|\//);
+ for (var i=0, l=parts.length; i < l; i++) {
+ processor = Content.processors[parts[i]]
+ }
+ return processor || {parser:identity,stringify:toString};
+ }
+ },
+ enumerable: true
+ },
+
+// - **length**. Typically accessed as `content.length`, returns the length in
+// bytes of the raw content entity.
+ length: {
+ get: function() {
+ if (typeof Buffer !== 'undefined') {
+ return Buffer.byteLength(this.body);
+ }
+ return this.body.length;
+ }
+ }
+});
+
+Content.processors = {};
+
+// The `registerProcessor` function allows you to add your own processors to
+// convert content entities. Each processor consists of a Javascript object with
+// two properties:
+// - **parser**. The function used to parse a raw content entity and convert it
+// into a Javascript data type.
+// - **stringify**. The function used to convert a Javascript data type into a
+// raw content entity.
+Content.registerProcessor = function(types,processor) {
+
+// You can pass an array of types that will trigger this processor, or just one.
+// We determine the array via duck-typing here.
+ if (types.forEach) {
+ types.forEach(function(type) {
+ Content.processors[type] = processor;
+ });
+ } else {
+ // If you didn't pass an array, we just use what you pass in.
+ Content.processors[types] = processor;
+ }
+};
+
+// Register the identity processor, which is used for text-based media types.
+var identity = function(x) { return x; }
+ , toString = function(x) { return x.toString(); }
+Content.registerProcessor(
+ ["text/html","text/plain","text"],
+ { parser: identity, stringify: toString });
+
+// Register the JSON processor, which is used for JSON-based media types.
+Content.registerProcessor(
+ ["application/json; charset=utf-8","application/json","json"],
+ {
+ parser: function(string) {
+ return JSON.parse(string);
+ },
+ stringify: function(data) {
+ return JSON.stringify(data); }});
+
+var qs = require('querystring');
+// Register the post processor, which is used for JSON-based media types.
+Content.registerProcessor(
+ ["application/x-www-form-urlencoded"],
+ { parser : qs.parse, stringify : qs.stringify });
+
+// Error functions are defined separately here in an attempt to make the code
+// easier to read.
+var Errors = {
+ setDataWithBody: function(object) {
+ throw new Error("Attempt to set data attribute of a content object " +
+ "when the body attributes was already set.");
+ },
+ setBodyWithData: function(object) {
+ throw new Error("Attempt to set body attribute of a content object " +
+ "when the data attributes was already set.");
+ }
+}
+module.exports = Content;
\ No newline at end of file
diff --git a/public/lib/swagger-oauth.js b/public/lib/swagger-oauth.js
new file mode 100644
index 0000000..19777eb
--- /dev/null
+++ b/public/lib/swagger-oauth.js
@@ -0,0 +1,218 @@
+var appName;
+var popupMask;
+var popupDialog;
+var clientId;
+var realm;
+
+function handleLogin() {
+ var scopes = [];
+
+ if(window.swaggerUi.api.authSchemes
+ && window.swaggerUi.api.authSchemes.oauth2
+ && window.swaggerUi.api.authSchemes.oauth2.scopes) {
+ scopes = window.swaggerUi.api.authSchemes.oauth2.scopes;
+ }
+
+ if(window.swaggerUi.api
+ && window.swaggerUi.api.info) {
+ appName = window.swaggerUi.api.info.title;
+ }
+
+ if(popupDialog.length > 0)
+ popupDialog = popupDialog.last();
+ else {
+ popupDialog = $(
+ [
+ '
',
+ '
Select OAuth2.0 Scopes
',
+ '
',
+ '
Scopes are used to grant an application different levels of access to data on behalf of the end user. Each API may declare one or more scopes.',
+ 'Learn how to use',
+ '
',
+ '
' + appName + ' API requires the following scopes. Select which ones you want to grant to Swagger UI.
',
+ '
',
+ '
',
+ '',
+ '',
+ '
',
+ '
'].join(''));
+ $(document.body).append(popupDialog);
+
+ popup = popupDialog.find('ul.api-popup-scopes').empty();
+ for (i = 0; i < scopes.length; i ++) {
+ scope = scopes[i];
+ str = '