text:
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define(factory);
	else if(typeof exports === 'object')
		exports["mach"] = factory();
	else
		root["mach"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;
/******/
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var EXTENSIONS = [];

	/*!
	 * mach - HTTP for JavaScript
	 * https://github.com/mjackson/mach
	 */
	var mach = module.exports = {

	  version: __webpack_require__(1),
	  Connection: __webpack_require__(2),
	  Header: __webpack_require__(3),
	  Location: __webpack_require__(4),
	  Message: __webpack_require__(5),

	  extend: function extend() {
	    var extension;
	    for (var i = 0, len = arguments.length; i < len; ++i) {
	      extension = arguments[i];

	      if (EXTENSIONS.indexOf(extension) === -1) {
	        EXTENSIONS.push(extension);
	        extension(mach);
	      }
	    }
	  }

	};

	mach.extend(__webpack_require__(6));

/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	/**
	 * The current version of mach.
	 */
	module.exports = "1.3.5";

/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	/* jshint -W058 */
	var d = __webpack_require__(18);
	var isBinary = __webpack_require__(20).isBinary;
	var decodeBase64 = __webpack_require__(7);
	var encodeBase64 = __webpack_require__(8);
	var stringifyQuery = __webpack_require__(9);
	var Promise = __webpack_require__(10);
	var Location = __webpack_require__(4);
	var Message = __webpack_require__(5);

	function locationPropertyAlias(name) {
	  return d.gs(function () {
	    return this.location[name];
	  }, function (value) {
	    this.location[name] = value;
	  });
	}

	function defaultErrorHandler(error) {
	  if (typeof console !== "undefined" && console.error) {
	    console.error(error && error.stack || error);
	  } else {
	    throw error; // Don't silently swallow errors!
	  }
	}

	function defaultCloseHandler() {}

	function defaultApp(conn) {
	  conn.status = 404;
	  conn.response.contentType = "text/plain";
	  conn.response.content = "Not found: " + conn.method + " " + conn.path;
	}

	/**
	 * An HTTP connection that acts as the asynchronous primitive for
	 * the duration of the request/response cycle.
	 *
	 * Important features are:
	 *
	 * - request        A Message representing the request being made. In
	 *                  a server environment, this is an "incoming" message
	 *                  that was probably generated by a web browser or some
	 *                  other consumer. In a client environment, this is an
	 *                  "outgoing" message that we send to a remote server.
	 * - response       A Message representing the response to the request.
	 *                  In a server environment, this is an "outgoing" message
	 *                  that will be sent back to the client. In a client
	 *                  environment, this is the response that was received
	 *                  from the remote server.
	 * - method         The HTTP method that the request uses
	 * - location       The URL of the request. In a server environment, this
	 *                  is derived from the URL path used in the request as
	 *                  well as a combination of the Host, X-Forwarded-* and
	 *                  other relevant headers.
	 * - version        The version of HTTP used in the request
	 * - status         The HTTP status code of the response
	 * - statusText     The HTTP status text that corresponds to the status
	 * - responseText   This is a special property that contains the entire
	 *                  content of the response. It is present by default when
	 *                  making client requests for convenience, but may also be
	 *                  disabled when you need to stream the response.
	 *
	 * Options may be any of the following:
	 *
	 * - content        The request content, defaults to ""
	 * - headers        The request headers, defaults to {}
	 * - method         The request HTTP method, defaults to "GET"
	 * - location/url   The request Location or URL
	 * - params         The request params
	 * - onError        A function that is called when there is an error
	 * - onClose        A function that is called when the request closes
	 *
	 * The options may also be a URL string to specify the URL.
	 */
	function Connection(options) {
	  options = options || {};

	  var location;
	  if (typeof options === "string") {
	    location = options; // options may be a URL string.
	  } else if (options.location || options.url) {
	    location = options.location || options.url;
	  } else if (typeof window === "object") {
	    location = window.location.href;
	  }

	  this.location = location;
	  this.version = options.version || "1.1";
	  this.method = options.method;

	  this.onError = (options.onError || defaultErrorHandler).bind(this);
	  this.onClose = (options.onClose || defaultCloseHandler).bind(this);
	  this.request = new Message(options.content, options.headers);
	  this.response = new Message();

	  // Params may be given as an object.
	  if (options.params) {
	    if (this.method === "GET" || this.method === "HEAD") {
	      this.query = options.params;
	    } else {
	      this.request.contentType = "application/x-www-form-urlencoded";
	      this.request.content = stringifyQuery(options.params);
	    }
	  }

	  this.withCredentials = options.withCredentials || false;
	  this.remoteHost = options.remoteHost || null;
	  this.remoteUser = options.remoteUser || null;
	  this.basename = "";

	  this.responseText = null;
	  this.status = 200;
	}

	Object.defineProperties(Connection.prototype, {

	  /**
	   * The method used in the request.
	   */
	  method: d.gs(function () {
	    return this._method;
	  }, function (value) {
	    this._method = typeof value === "string" ? value.toUpperCase() : "GET";
	  }),

	  /**
	   * The Location of the request.
	   */
	  location: d.gs(function () {
	    return this._location;
	  }, function (value) {
	    this._location = value instanceof Location ? value : new Location(value);
	  }),

	  href: locationPropertyAlias("href"),
	  protocol: locationPropertyAlias("protocol"),
	  host: locationPropertyAlias("host"),
	  hostname: locationPropertyAlias("hostname"),
	  port: locationPropertyAlias("port"),
	  search: locationPropertyAlias("search"),
	  queryString: locationPropertyAlias("queryString"),
	  query: locationPropertyAlias("query"),

	  /**
	   * True if the request uses SSL, false otherwise.
	   */
	  isSSL: d.gs(function () {
	    return this.protocol === "https:";
	  }),

	  /**
	   * The username:password used in the request, an empty string
	   * if no auth was provided.
	   */
	  auth: d.gs(function () {
	    var header = this.request.headers.Authorization;

	    if (header) {
	      var parts = header.split(" ", 2);
	      var scheme = parts[0];

	      if (scheme.toLowerCase() === "basic") return decodeBase64(parts[1]);

	      return header;
	    }

	    return this.location.auth;
	  }, function (value) {
	    var headers = this.request.headers;

	    if (value && typeof value === "string") {
	      headers.Authorization = "Basic " + encodeBase64(value);
	    } else {
	      delete headers.Authorization;
	    }
	  }),

	  /**
	   * The portion of the original URL path that is still relevant
	   * for request processing.
	   */
	  pathname: d.gs(function () {
	    return this.location.pathname.replace(this.basename, "") || "/";
	  }, function (value) {
	    this.location.pathname = this.basename + value;
	  }),

	  /**
	   * The URL path with query string.
	   */
	  path: d.gs(function () {
	    return this.pathname + this.search;
	  }, function (value) {
	    this.location.path = this.basename + value;
	  }),

	  /**
	   * Calls the given `app` with this connection as the only argument.
	   * as the first argument and returns a promise for a Response.
	   */
	  call: d(function (app) {
	    app = app || defaultApp;

	    var conn = this;

	    try {
	      return Promise.resolve(app(conn)).then(function (value) {
	        if (value == null) return;

	        if (typeof value === "number") {
	          conn.status = value;
	        } else if (typeof value === "string" || isBinary(value) || typeof value.pipe === "function") {
	          conn.response.content = value;
	        } else {
	          if (value.headers != null) conn.response.headers = value.headers;

	          if (value.content != null) conn.response.content = value.content;

	          if (value.status != null) conn.status = value.status;
	        }
	      });
	    } catch (error) {
	      return Promise.reject(error);
	    }
	  })

	});

	module.exports = Connection;

/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };

	var _classCallCheck = function (instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } };

	var normalizeHeaderName = __webpack_require__(11);

	var Header = (function () {
	  function Header(name, value) {
	    _classCallCheck(this, Header);

	    this.name = name;
	    this.value = value;
	  }

	  _prototypeProperties(Header, null, {
	    name: {
	      get: function () {
	        return this._name;
	      },
	      set: function (value) {
	        this._name = normalizeHeaderName(value);
	      },
	      configurable: true
	    },
	    toString: {
	      value: function toString() {
	        return this.name + ": " + this.value;
	      },
	      writable: true,
	      configurable: true
	    }
	  });

	  return Header;
	})();

	module.exports = Header;

/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var d = __webpack_require__(18);
	var mergeQuery = __webpack_require__(12);
	var stringifyQuery = __webpack_require__(9);
	var parseQuery = __webpack_require__(13);
	var parseURL = __webpack_require__(16);

	/**
	 * Standard ports for HTTP protocols.
	 */
	var STANDARD_PORTS = {
	  "http:": "80",
	  "https:": "443"
	};

	function propertyAlias(propertyName, defaultValue) {
	  return d.gs(function () {
	    return this.properties[propertyName] || (defaultValue == null ? null : defaultValue);
	  }, function (value) {
	    this.properties[propertyName] = value;
	  });
	}

	// Order is important here. Later properties take priority.
	var PROPERTY_NAMES = ["protocol", "auth", "hostname", "port", "host", "pathname", "search", "queryString", "query", "path"];

	function setProperties(location, properties) {
	  var propertyName;
	  for (var i = 0, len = PROPERTY_NAMES.length; i < len; ++i) {
	    propertyName = PROPERTY_NAMES[i];

	    if (properties.hasOwnProperty(propertyName) && propertyName in location) location[propertyName] = properties[propertyName];
	  }
	}

	/**
	 * A URL location, analogous to window.location.
	 *
	 * Options may be any of the following:
	 *
	 * - protocol
	 * - auth
	 * - hostname
	 * - port
	 * - host (overrides hostname and port)
	 * - pathname
	 * - search
	 * - queryString (overrides search)
	 * - query (overrides queryString/search)
	 * - path (overrides pathname and query/queryString/search)
	 *
	 * Alternatively, options may be a URL string.
	 */
	function Location(options) {
	  this.properties = {};

	  if (typeof options === "string") {
	    this.href = options;
	  } else if (options) {
	    setProperties(this, options);
	  }
	}

	Object.defineProperties(Location.prototype, {

	  /**
	   * Creates and returns a new Location with the path and query of
	   * the given location appended.
	   */
	  concat: d(function (location) {
	    if (!(location instanceof Location)) location = new Location(location);

	    var pathname = this.pathname;
	    var extraPathname = location.pathname;

	    if (extraPathname !== "/") pathname = pathname.replace(/\/*$/, "/") + extraPathname.replace(/^\/*/, "");

	    var query = mergeQuery(this.query, location.query);

	    return new Location({
	      protocol: location.protocol || this.protocol,
	      auth: location.auth || this.auth,
	      hostname: location.hostname || this.hostname,
	      port: location.port || this.port,
	      pathname: pathname,
	      query: query
	    });
	  }),

	  /**
	   * The full URL.
	   */
	  href: d.gs(function () {
	    var auth = this.auth;
	    var host = this.host;
	    var path = this.path;

	    return host ? this.protocol + "//" + (auth ? auth + "@" : "") + host + path : path;
	  }, function (value) {
	    var parsed = parseURL(value);

	    setProperties(this, {
	      protocol: parsed.protocol,
	      auth: parsed.auth,
	      hostname: parsed.hostname,
	      port: parsed.port,
	      pathname: parsed.pathname,
	      search: parsed.search
	    });
	  }),

	  /**
	   * The portion of the URL that denotes the protocol, including the
	   * trailing colon (e.g. "http:" or "https:").
	   */
	  protocol: propertyAlias("protocol"),

	  /**
	   * The username:password used in the URL, if any.
	   */
	  auth: propertyAlias("auth", ""),

	  /**
	   * The full name of the host, including the port number when using
	   * a non-standard port.
	   */
	  host: d.gs(function () {
	    var protocol = this.protocol;
	    var host = this.hostname;
	    var port = this.port;

	    if (port != null && port !== STANDARD_PORTS[protocol]) host += ":" + port;

	    return host;
	  }, function (value) {
	    var index;

	    if (typeof value === "string" && (index = value.indexOf(":")) !== -1) {
	      this.hostname = value.substring(0, index);
	      this.port = value.substring(index + 1);
	    } else {
	      this.hostname = value;
	      this.port = null;
	    }
	  }),

	  /**
	   * The name of the host without the port.
	   */
	  hostname: propertyAlias("hostname"),

	  /**
	   * The port number as a string.
	   */
	  port: d.gs(function () {
	    return this.properties.port || (this.protocol ? STANDARD_PORTS[this.protocol] : null);
	  }, function (value) {
	    this.properties.port = value ? String(value) : null;
	  }),

	  /**
	   * The URL path without the query string.
	   */
	  pathname: propertyAlias("pathname", "/"),

	  /**
	   * The URL path with query string.
	   */
	  path: d.gs(function () {
	    return this.pathname + this.search;
	  }, function (value) {
	    var index;

	    if (typeof value === "string" && (index = value.indexOf("?")) !== -1) {
	      this.pathname = value.substring(0, index);
	      this.search = value.substring(index);
	    } else {
	      this.pathname = value;
	      this.search = null;
	    }
	  }),

	  /**
	   * The query string, including the preceeding ?.
	   */
	  search: propertyAlias("search", ""),

	  /**
	   * The query string of the URL, without the preceeding ?.
	   */
	  queryString: d.gs(function () {
	    return this.search.substring(1);
	  }, function (value) {
	    this.search = value && "?" + value;
	  }),

	  /**
	   * An object of data in the query string.
	   */
	  query: d.gs(function () {
	    return parseQuery(this.queryString);
	  }, function (value) {
	    this.queryString = stringifyQuery(value);
	  }),

	  toJSON: d(function () {
	    return this.href;
	  }),

	  toString: d(function () {
	    return this.href;
	  })

	});

	module.exports = Location;

/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var bodec = __webpack_require__(20);
	var d = __webpack_require__(18);
	var Stream = __webpack_require__(19);
	var bufferStream = __webpack_require__(14);
	var normalizeHeaderName = __webpack_require__(11);
	var parseCookie = __webpack_require__(15);
	var parseQuery = __webpack_require__(13);

	/**
	 * The default content to use for new messages.
	 */
	var DEFAULT_CONTENT = bodec.fromString("");

	/**
	 * The default maximum length (in bytes) to use in Message#parseContent.
	 */
	var DEFAULT_MAX_CONTENT_LENGTH = Math.pow(2, 20); // 1M

	var HEADERS_LINE_SEPARATOR = /\r?\n/;
	var HEADER_SEPARATOR = ": ";

	function defaultParser(message, maxLength) {
	  return message.stringifyContent(maxLength);
	}

	/**
	 * An HTTP message.
	 */
	function Message(content, headers) {
	  this.headers = headers;
	  this.content = content;
	}

	Object.defineProperties(Message, {

	  PARSERS: d({
	    enumerable: true,
	    value: {
	      "application/json": function (message, maxLength) {
	        return message.stringifyContent(maxLength).then(JSON.parse);
	      },
	      "application/x-www-form-urlencoded": function (message, maxLength) {
	        return message.stringifyContent(maxLength).then(parseQuery);
	      }
	    }
	  })

	});

	Object.defineProperties(Message.prototype, {

	  /**
	   * The headers of this message as { headerName, value }.
	   */
	  headers: d.gs(function () {
	    return this._headers;
	  }, function (value) {
	    this._headers = {};

	    if (typeof value === "string") {
	      value.split(HEADERS_LINE_SEPARATOR).forEach(function (line) {
	        var index = line.indexOf(HEADER_SEPARATOR);

	        if (index === -1) {
	          this.addHeader(line, true);
	        } else {
	          this.addHeader(line.substring(0, index), line.substring(index + HEADER_SEPARATOR.length));
	        }
	      }, this);
	    } else if (value != null) {
	      for (var headerName in value) if (value.hasOwnProperty(headerName)) this.addHeader(headerName, value[headerName]);
	    }
	  }),

	  /**
	   * Returns the value of the header with the given name.
	   */
	  getHeader: d(function (headerName) {
	    return this.headers[normalizeHeaderName(headerName)];
	  }),

	  /**
	   * Sets the value of the header with the given name.
	   */
	  setHeader: d(function (headerName, value) {
	    this.headers[normalizeHeaderName(headerName)] = value;
	  }),

	  /**
	   * Adds the value to the header with the given name.
	   */
	  addHeader: d(function (headerName, value) {
	    headerName = normalizeHeaderName(headerName);

	    var headers = this.headers;
	    if (headerName in headers) {
	      if (Array.isArray(headers[headerName])) {
	        headers[headerName].push(value);
	      } else {
	        headers[headerName] = [headers[headerName], value];
	      }
	    } else {
	      headers[headerName] = value;
	    }
	  }),

	  /**
	   * An object containing cookies in this message, keyed by name.
	   */
	  cookies: d.gs(function () {
	    if (!this._cookies) {
	      var header = this.headers.Cookie;

	      if (header) {
	        var cookies = parseCookie(header);

	        // From RFC 2109:
	        // If multiple cookies satisfy the criteria above, they are ordered in
	        // the Cookie header such that those with more specific Path attributes
	        // precede those with less specific. Ordering with respect to other
	        // attributes (e.g., Domain) is unspecified.
	        for (var cookieName in cookies) if (Array.isArray(cookies[cookieName])) cookies[cookieName] = cookies[cookieName][0] || "";

	        this._cookies = cookies;
	      } else {
	        this._cookies = {};
	      }
	    }

	    return this._cookies;
	  }),

	  /**
	   * Gets/sets the value of the Content-Type header.
	   */
	  contentType: d.gs(function () {
	    return this.headers["Content-Type"];
	  }, function (value) {
	    this.headers["Content-Type"] = value;
	  }),

	  /**
	   * The media type (type/subtype) portion of the Content-Type header without any
	   * media type parameters. e.g. when Content-Type is "text/plain;charset=utf-8",
	   * the mediaType is "text/plain".
	   *
	   * See http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
	   */
	  mediaType: d.gs(function () {
	    var contentType = this.contentType,
	        match;
	    return contentType && (match = contentType.match(/^([^;,]+)/)) ? match[1].toLowerCase() : null;
	  }, function (value) {
	    this.contentType = value + (this.charset ? ";charset=" + this.charset : "");
	  }),

	  /**
	   * Returns the character set used to encode the content of this message. e.g.
	   * when Content-Type is "text/plain;charset=utf-8", charset is "utf-8".
	   *
	   * See http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.4
	   */
	  charset: d.gs(function () {
	    var contentType = this.contentType,
	        match;
	    return contentType && (match = contentType.match(/\bcharset=([\w-]+)/)) ? match[1] : null;
	  }, function (value) {
	    this.contentType = this.mediaType + (value ? ";charset=" + value : "");
	  }),

	  /**
	   * The content of this message as a binary stream.
	   */
	  content: d.gs(function () {
	    return this._content;
	  }, function (value) {
	    if (value == null) value = DEFAULT_CONTENT;

	    if (value instanceof Stream) {
	      this._content = value;
	      value.pause();
	    } else {
	      this._content = new Stream(value);
	    }

	    delete this._bufferedContent;
	  }),

	  /**
	   * True if the content of this message is buffered, false otherwise.
	   */
	  isBuffered: d.gs(function () {
	    return this._bufferedContent != null;
	  }),

	  /**
	   * Returns a binary representation of the content of this message up to
	   * the given length. This is useful in applications that need to access the
	   * entire message body at once, instead of as a stream.
	   *
	   * Note: 0 is a valid value for maxLength. It means "no limit".
	   */
	  bufferContent: d(function (maxLength) {
	    if (this._bufferedContent == null) this._bufferedContent = bufferStream(this.content, maxLength);

	    return this._bufferedContent;
	  }),

	  /**
	   * Returns the content of this message up to the given length as a string
	   * with the given encoding.
	   *
	   * Note: 0 is a valid value for maxLength. It means "no limit".
	   */
	  stringifyContent: d(function (maxLength, encoding) {
	    encoding = encoding || this.charset;

	    return this.bufferContent(maxLength).then(function (chunk) {
	      return bodec.toString(chunk, encoding);
	    });
	  }),

	  /**
	   * Returns a promise for an object of data contained in the content body.
	   *
	   * The maxLength argument specifies the maximum length (in bytes) that the
	   * parser will accept. If the content stream exceeds the maximum length, the
	   * promise is rejected with a MaxLengthExceededError. The appropriate response
	   * to send to the client in this case is 413 Request Entity Too Large, but
	   * many HTTP clients including most web browsers may not understand it.
	   *
	   * Note: 0 is a valid value for maxLength. It means "no limit".
	   */
	  parseContent: d(function (maxLength) {
	    if (this._parsedContent) return this._parsedContent;

	    if (typeof maxLength !== "number") maxLength = DEFAULT_MAX_CONTENT_LENGTH;

	    var parser = Message.PARSERS[this.mediaType] || defaultParser;
	    this._parsedContent = parser(this, maxLength);

	    return this._parsedContent;
	  })

	});

	module.exports = Message;

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	/**
	 * The default extension for browser environments.
	 */
	module.exports = function (mach) {
	  mach.extend(__webpack_require__(17));
	};

/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	module.exports = __webpack_require__(20).decodeBase64;

/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	module.exports = __webpack_require__(20).encodeBase64;

/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	module.exports = __webpack_require__(25).stringify;

/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var Promise = __webpack_require__(28);

	if (false) require("when/monitor")(Promise);

	module.exports = Promise;

/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var IrregularHeaderNames = __webpack_require__(21);

	/**
	 * Normalizes HTTP header names according to RFC 2616.
	 */
	function normalizeHeaderName(headerName) {
	  headerName = headerName.toLowerCase();

	  if (headerName in IrregularHeaderNames) {
	    return IrregularHeaderNames[headerName];
	  }return headerName.replace(/(^|-)([a-z])/g, function (match, dash, letter) {
	    return dash + letter.toUpperCase();
	  });
	}

	module.exports = normalizeHeaderName;

/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	module.exports = __webpack_require__(26).merge;

/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	module.exports = __webpack_require__(25).parse;

/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var bodec = __webpack_require__(20);
	var Promise = __webpack_require__(10);
	var MaxLengthExceededError = __webpack_require__(22);

	/**
	 * Returns a promise for a buffer of all content in the given stream up to
	 * the given maximum length.
	 */
	function bufferStream(stream, maxLength) {
	  maxLength = maxLength || Infinity;

	  if (!stream.readable) throw new Error("Cannot buffer stream that is not readable");

	  return new Promise(function (resolve, reject) {
	    var chunks = [];
	    var length = 0;

	    stream.on("error", reject);

	    stream.on("data", function (chunk) {
	      length += chunk.length;

	      if (length > maxLength) {
	        reject(new MaxLengthExceededError(maxLength));
	      } else {
	        chunks.push(chunk);
	      }
	    });

	    stream.on("end", function () {
	      resolve(bodec.join(chunks));
	    });

	    if (typeof stream.resume === "function") stream.resume();
	  });
	}

	module.exports = bufferStream;

/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var parseQuery = __webpack_require__(13);

	function parseCookie(cookie) {
	  return parseQuery(cookie, { delimiter: /[;,] */ });
	}

	module.exports = parseCookie;

/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var ORIGIN_MATCHER = /^(https?:)\/\/(?:([^@]+)@)?([^/:]+)(?::(\d+))?/;

	function parseURL(url) {
	  var origin = ORIGIN_MATCHER.exec(url) || {};

	  var anchor = document.createElement("a");
	  anchor.href = url;

	  return {
	    protocol: origin[1] || null,
	    auth: origin[2] || null,
	    hostname: origin[3] || null,
	    port: origin[4] || null,
	    pathname: anchor.pathname,
	    search: anchor.search,
	    hash: anchor.hash
	  };
	}

	module.exports = parseURL;

/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var objectAssign = __webpack_require__(29);
	var sendRequest = __webpack_require__(27);
	var Location = __webpack_require__(4);

	function defaultApp(conn) {
	  return sendRequest(conn, conn.location);
	}

	module.exports = function (mach) {
	  mach.call = __webpack_require__(24);

	  ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT", "TRACE"].forEach(function (method) {
	    var property = method.toLowerCase();

	    mach[property] = function (app, options, modifier) {
	      if (typeof app !== "function") {
	        modifier = options;

	        if (typeof app === "string") {
	          // get(url, modifier)
	          options = { url: app };
	        } else if (app instanceof Location) {
	          // get(location, modifier)
	          options = { location: app };
	        } else {
	          // get(options, modifier)
	          options = objectAssign({}, app || {});
	        }

	        app = defaultApp;
	      } else if (typeof options === "string") {
	        // get(app, url, modifier)
	        options = { url: options };
	      } else if (options instanceof Location) {
	        // get(app, location, modifier)
	        options = { location: options };
	      } else if (typeof options !== "object") {
	        // get(app, modifier)
	        modifier = options;
	        options = {};
	      } else {
	        // get(app, options, modifier)
	        options = objectAssign({}, options || {});
	      }

	      options.method = method;

	      return mach.call(app, options, modifier);
	    };
	  });
	};

/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {

	var objectAssign = __webpack_require__(29);

	function describeProperty(descriptor) {
	  if (typeof descriptor === 'function')
	    descriptor = { value: descriptor };

	  // Use ES5 defaults.
	  var defaults = {
	    configurable: true,
	    enumerable: false
	  };

	  if (descriptor.get == null && descriptor.set == null)
	    defaults.writable = true;

	  return objectAssign(defaults, descriptor);
	}

	describeProperty.gs = function (get, set) {
	  var descriptor = {
	    get: get
	  };

	  if (typeof set === 'function')
	    descriptor.set = set;

	  return describeProperty(descriptor);
	};

	module.exports = describeProperty;

/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {

	/* jshint -W084 */
	/*!
	 * BufferedStream - A robust stream implementation for node.js and the browser
	 * https://github.com/mjackson/bufferedstream
	 */
	var bodec = __webpack_require__(20);
	var d = __webpack_require__(18);
	var EventEmitter = __webpack_require__(30).EventEmitter;

	/**
	 * The default maximum buffer size.
	 */
	var DEFAULT_MAX_SIZE = Math.pow(2, 16); // 64k

	var BaseClass, async;
	if (typeof window === 'object') {
	  BaseClass = EventEmitter;
	  async = window.setTimeout;
	} else {
	  BaseClass = __webpack_require__(23).Stream;
	  async = process.nextTick;
	}

	function trackSource(dest) {
	  dest.on('pipe', function (source) {
	    if (dest._source)
	      throw new Error('BufferedStream is already piped');

	    dest._source = source;

	    function cleanup() {
	      dest._source = null;
	      source.removeListener('error', cleanup);
	      source.removeListener('end', cleanup);
	    }

	    source.on('error', cleanup);
	    source.on('end', cleanup);
	  });
	}

	function flushSoon(stream) {
	  if (stream._flushing)
	    return;

	  stream._flushing = true;

	  async(function tryToFlush() {
	    if (stream.paused) {
	      stream._flushing = false;
	      return;
	    }

	    flush(stream);

	    if (stream.empty) {
	      stream._flushing = false;
	    } else {
	      async(tryToFlush);
	    }
	  });
	}

	function flush(stream) {
	  if (!stream._chunks)
	    return;

	  var chunk;
	  while (chunk = stream._chunks.shift()) {
	    stream.size -= chunk.length;

	    if (stream.encoding) {
	      stream.emit('data', bodec.toString(chunk, stream.encoding));
	    } else {
	      stream.emit('data', chunk);
	    }

	    // If the stream was paused in a data event handler, break.
	    if (stream.paused)
	      break;
	  }

	  if (stream.ended) {
	    if (!stream.paused) {
	      stream._chunks = null;
	      stream.emit('end');
	    }
	  } else if (stream._wasFull && !stream.full) {
	    stream._wasFull = false;
	    stream.emit('drain');
	  }
	}

	/**
	 * A robust stream implementation for node.js and the browser based on the
	 * initial version of the stream API in Node.js.
	 *
	 * The maxSize determines the number of bytes the buffer can hold before it is
	 * considered "full". Defaults to 64k.
	 *
	 * The source and sourceEncoding arguments may be used to easily wrap this
	 * stream around another, or a simple string. If the source is another stream,
	 * it is piped to this stream. If it's a string or binary data, it is used as
	 * the entire contents of the stream.
	 *
	 * NOTE: The maxSize is a soft limit that is only used to determine when calls
	 * to write will return false, indicating to streams that are writing to this
	 * stream that they should pause. In any case, calls to write will still append
	 * to the buffer so that no data is lost.
	 */
	function BufferedStream(maxSize, source, sourceEncoding) {
	  if (!(this instanceof BufferedStream))
	    return new BufferedStream(maxSize, source, sourceEncoding);

	  BaseClass.call(this);

	  if (typeof maxSize !== 'number') {
	    sourceEncoding = source;
	    source = maxSize;
	    maxSize = DEFAULT_MAX_SIZE;
	  }

	  // Public interface.
	  this.maxSize = maxSize;
	  this.size = 0;
	  this.encoding = null;
	  this.paused = true;
	  this.ended = false;
	  this.readable = true;
	  this.writable = true;

	  this._chunks = [];
	  this._flushing = false;
	  this._wasFull = false;
	  this._source = null;

	  trackSource(this);

	  if (source != null) {
	    if (typeof source.pipe === 'function') {
	      if (typeof source.resume === 'function')
	        source.resume(); // Triggers "old mode" in node v2 streams.

	      source.pipe(this);
	    } else {
	      this.end(source, sourceEncoding);
	    }
	  }
	}

	BufferedStream.prototype = Object.create(BaseClass.prototype, {

	  constructor: d(BufferedStream),

	  /**
	   * A read-only property that is true if this stream has no data to emit.
	   */
	  empty: d.gs(function () {
	    return this._chunks == null || this._chunks.length === 0;
	  }),

	  /**
	   * A read-only property that is true if this stream's buffer is full.
	   */
	  full: d.gs(function () {
	    return this.maxSize < this.size;
	  }),

	  /**
	   * A read-only property that is true if this stream is currently receiving
	   * data from another stream via pipe().
	   */
	  piped: d.gs(function () {
	    return this._source != null;
	  }),

	  /**
	   * Sets this stream's encoding. If an encoding is set, this stream will emit
	   * strings using that encoding. Otherwise, it emits binary objects.
	   *
	   * Valid encodings are "hex", "base64", "utf8", and "utf-8".
	   */
	  setEncoding: d(function (encoding) {
	    this.encoding = encoding;
	  }),

	  /**
	   * Prevents this stream from emitting data events until resume is called.
	   * Note: This does not prevent writes to this stream.
	   */
	  pause: d(function () {
	    this.paused = true;
	  }),

	  /**
	   * Resumes emitting data events.
	   */
	  resume: d(function () {
	    if (this.paused)
	      flushSoon(this);

	    this.paused = false;
	  }),

	  /**
	   * Pipes all data in this stream through to the given destination stream.
	   * By default the destination stream is ended when this one ends. Set the
	   * "end" option to `false` to disable this behavior.
	   *
	   * This function was copied out of node's lib/stream.js and modified for
	   * use in other JavaScript environments.
	   */
	  pipe: d(function (dest, options) {
	    var source = this;

	    function ondata(chunk) {
	      if (dest.writable && false === dest.write(chunk))
	        source.pause();
	    }

	    source.on('data', ondata);

	    function ondrain() {
	      if (source.readable)
	        source.resume();
	    }

	    dest.on('drain', ondrain);

	    var didOnEnd = false;
	    function onend() {
	      if (didOnEnd) return;
	      didOnEnd = true;

	      dest.end();
	    }

	    // If the 'end' option is not supplied, dest.end() will be called when
	    // source gets the 'end' or 'close' events. Only dest.end() once.
	    if (!dest._isStdio && (!options || options.end !== false))
	      source.on('end', onend);

	    // don't leave dangling pipes when there are errors.
	    function onerror(error) {
	      cleanup();
	      if (EventEmitter.listenerCount(this, 'error') === 0)
	        throw error; // Unhandled stream error in pipe.
	    }

	    source.on('error', onerror);
	    dest.on('error', onerror);

	    // remove all the event listeners that were added.
	    function cleanup() {
	      source.removeListener('data', ondata);
	      dest.removeListener('drain', ondrain);

	      source.removeListener('end', onend);

	      source.removeListener('error', onerror);
	      dest.removeListener('error', onerror);

	      source.removeListener('end', cleanup);
	    }

	    source.on('end', cleanup);
	    dest.on('close', cleanup);

	    dest.emit('pipe', source);

	    // Mimic the behavior of node v2 streams where pipe() resumes the flow.
	    // This lets us avoid having to do stream.resume() all over the place.
	    source.resume();

	    // Allow for unix-like usage: A.pipe(B).pipe(C)
	    return dest;
	  }),

	  /**
	   * Writes the given chunk of data to this stream. Returns false if this
	   * stream is full and should not be written to further until drained, true
	   * otherwise.
	   */
	  write: d(function (chunk) {
	    if (!this.writable)
	      throw new Error('BufferedStream is not writable');

	    if (this.ended)
	      throw new Error('BufferedStream is already ended');

	    if (typeof chunk === 'string')
	      chunk = bodec.fromString(chunk, arguments[1]);

	    if (!bodec.isBinary(chunk))
	      throw new Error('BufferedStream only accepts binary data');

	    this._chunks.push(chunk);
	    this.size += chunk.length;

	    flushSoon(this);

	    if (this.full) {
	      this._wasFull = true;
	      return false;
	    }

	    return true;
	  }),

	  /**
	   * Writes the given chunk to this stream and queues the end event to be
	   * called as soon as soon as the stream is empty. Calling write() after
	   * end() is an error.
	   */
	  end: d(function (chunk) {
	    if (this.ended)
	      throw new Error('BufferedStream is already ended');

	    if (chunk != null)
	      this.write(chunk, arguments[1]);

	    this.ended = true;

	    // Trigger the flush cycle one last time to emit
	    // any data that was written before end was called.
	    flushSoon(this);
	  })

	});

	module.exports = BufferedStream;

/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	// This file must be served with UTF-8 encoding for the utf8 codec to work.
	module.exports = {
	  Binary: Uint8Array,
	  // Utility functions
	  isBinary: isBinary,
	  create: create,
	  join: join,

	  // Binary input and output
	  copy: copy,
	  slice: slice,

	  // String input and output
	  toRaw: toRaw,
	  fromRaw: fromRaw,
	  toUnicode: toUnicode,
	  fromUnicode: fromUnicode,
	  toHex: toHex,
	  fromHex: fromHex,
	  toBase64: toBase64,
	  fromBase64: fromBase64,
	  toString: toString,
	  fromString: fromString,

	  // Array input and output
	  toArray: toArray,
	  fromArray: fromArray,

	  // Raw <-> Hex-encoded codec
	  decodeHex: decodeHex,
	  encodeHex: encodeHex,

	  decodeBase64: decodeBase64,
	  encodeBase64: encodeBase64,

	  // Unicode <-> Utf8-encoded-raw codec
	  encodeUtf8: encodeUtf8,
	  decodeUtf8: decodeUtf8,

	  // Hex <-> Nibble codec
	  nibbleToCode: nibbleToCode,
	  codeToNibble: codeToNibble
	};

	function isBinary(value) {
	  return value &&
	      typeof value === "object" &&
	      value instanceof Uint8Array || value.constructor.name === "Uint8Array";
	}

	function create(length) {
	  return new Uint8Array(length);
	}

	function join(chunks) {
	  var length = chunks.length;
	  var total = 0;
	  for (var i = 0; i < length; i++) {
	    total += chunks[i].length;
	  }
	  var binary = create(total);
	  var offset = 0;
	  for (i = 0; i < length; i++) {
	    var chunk = chunks[i];
	    copy(chunk, binary, offset);
	    offset += chunk.length;
	  }
	  return binary;
	}

	function slice(binary, start, end) {
	  if (end === undefined) {
	    end = binary.length;
	    if (start === undefined) start = 0;
	  }
	  return binary.subarray(start, end);
	}

	function copy(source, binary, offset) {
	  var length = source.length;
	  if (offset === undefined) {
	    offset = 0;
	    if (binary === undefined) binary = create(length);
	  }
	  for (var i = 0; i < length; i++) {
	    binary[i + offset] = source[i];
	  }
	  return binary;
	}

	// Like slice, but encode as a hex string
	function toHex(binary, start, end) {
	  var hex = "";
	  if (end === undefined) {
	    end = binary.length;
	    if (start === undefined) start = 0;
	  }
	  for (var i = start; i < end; i++) {
	    var byte = binary[i];
	    hex += String.fromCharCode(nibbleToCode(byte >> 4)) +
	           String.fromCharCode(nibbleToCode(byte & 0xf));
	  }
	  return hex;
	}

	// Like copy, but decode from a hex string
	function fromHex(hex, binary, offset) {
	  var length = hex.length / 2;
	  if (offset === undefined) {
	    offset = 0;
	    if (binary === undefined) binary = create(length);
	  }
	  var j = 0;
	  for (var i = 0; i < length; i++) {
	    binary[offset + i] = (codeToNibble(hex.charCodeAt(j++)) << 4)
	                       |  codeToNibble(hex.charCodeAt(j++));
	  }
	  return binary;
	}

	function toBase64(binary, start, end) {
	  return btoa(toRaw(binary, start, end));
	}

	function fromBase64(base64, binary, offset) {
	  return fromRaw(atob(base64), binary, offset);
	}

	function nibbleToCode(nibble) {
	  nibble |= 0;
	  return (nibble + (nibble < 10 ? 0x30 : 0x57))|0;
	}

	function codeToNibble(code) {
	  code |= 0;
	  return (code - ((code & 0x40) ? 0x57 : 0x30))|0;
	}

	function toUnicode(binary, start, end) {
	  return decodeUtf8(toRaw(binary, start, end));
	}

	function fromUnicode(unicode, binary, offset) {
	  return fromRaw(encodeUtf8(unicode), binary, offset);
	}

	function decodeHex(hex) {
	  var j = 0, l = hex.length;
	  var raw = "";
	  while (j < l) {
	    raw += String.fromCharCode(
	       (codeToNibble(hex.charCodeAt(j++)) << 4)
	      | codeToNibble(hex.charCodeAt(j++))
	    );
	  }
	  return raw;
	}

	function encodeHex(raw) {
	  var hex = "";
	  var length = raw.length;
	  for (var i = 0; i < length; i++) {
	    var byte = raw.charCodeAt(i);
	    hex += String.fromCharCode(nibbleToCode(byte >> 4)) +
	           String.fromCharCode(nibbleToCode(byte & 0xf));
	  }
	  return hex;
	}

	function decodeBase64(base64) {
	  return atob(base64);
	}

	function encodeBase64(raw) {
	  return btoa(raw);
	}

	function decodeUtf8(utf8) {
	  return decodeURIComponent(window.escape(utf8));
	}

	function encodeUtf8(unicode) {
	  return window.unescape(encodeURIComponent(unicode));
	}

	function toRaw(binary, start, end) {
	  var raw = "";
	  if (end === undefined) {
	    end = binary.length;
	    if (start === undefined) start = 0;
	  }
	  for (var i = start; i < end; i++) {
	    raw += String.fromCharCode(binary[i]);
	  }
	  return raw;
	}

	function fromRaw(raw, binary, offset) {
	  var length = raw.length;
	  if (offset === undefined) {
	    offset = 0;
	    if (binary === undefined) binary = create(length);
	  }
	  for (var i = 0; i < length; i++) {
	    binary[offset + i] = raw.charCodeAt(i);
	  }
	  return binary;
	}

	function toArray(binary, start, end) {
	  if (end === undefined) {
	    end = binary.length;
	    if (start === undefined) start = 0;
	  }
	  var length = end - start;
	  var array = new Array(length);
	  for (var i = 0; i < length; i++) {
	    array[i] = binary[i + start];
	  }
	  return array;
	}

	function fromArray(array, binary, offset) {
	  var length = array.length;
	  if (offset === undefined) {
	    offset = 0;
	    if (binary === undefined) binary = create(length);
	  }
	  for (var i = 0; i < length; i++) {
	    binary[offset + i] = array[i];
	  }
	  return binary;
	}

	var toStringCoders = {
	  base64: toBase64,
	  hex: toHex,
	  utf8: toUnicode,
	  'utf-8': toUnicode
	};

	function toString(binary, encoding) {
	  return ((encoding && toStringCoders[encoding]) || toStringCoders.utf8)(binary);
	}

	var fromStringCoders = {
	  base64: fromBase64,
	  hex: fromHex,
	  utf8: fromUnicode,
	  'utf-8': fromUnicode
	};

	function fromString(string, encoding) {
	  return ((encoding && fromStringCoders[encoding]) || fromStringCoders.utf8)(string);
	}

/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	/**
	 * A map of HTTP header names with irregular case.
	 */
	module.exports = ["Content-ID", "Content-MD5", "DNT", "ETag", "P3P", "TE", "WWW-Authenticate", "X-ATT-DeviceId", "X-UA-Compatible", "X-WebKit-CSP", "X-XSS-Protection"].reduce(function (map, headerName) {
	  map[headerName.toLowerCase()] = headerName;
	  return map;
	}, {});

/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var d = __webpack_require__(18);

	/**
	 * An error indicating that some maximum length has been exceeded.
	 */
	function MaxLengthExceededError(maxLength) {
	  Error.call(this);
	  Error.captureStackTrace(this, this.constructor);
	  this.name = this.constructor.name;
	  this.message = "Maximum length exceeded";
	  this.maxLength = maxLength;
	}

	MaxLengthExceededError.prototype = Object.create(Error.prototype, {

	  constructor: d(MaxLengthExceededError)

	});

	module.exports = MaxLengthExceededError;

/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {

	/* (ignored) */

/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var Connection = __webpack_require__(2);
	var Promise = __webpack_require__(10);

	/**
	 * Creates a new Connection using the given options and sends
	 * the request to the given app. Returns a promise for the connection
	 * object when the response is received.
	 *
	 * Options may be any of the Connection options, plus the following:
	 *
	 * - binary     By default the response content is buffered and stored
	 *              in the responseText property of the connection. Set this
	 *              option true to disable this behavior.
	 * - maxLength  The maximum length of the response content to accept.
	 *              This option has no effect when "binary" is true. By
	 *              default there is no maximum length.
	 * - encoding   The encoding to use to decode the response body. This
	 *              option has no effect when "binary" is true. By default
	 *              the encoding is whatever was specified in the Content-Type
	 *              header of the response.
	 *
	 * If a modifier function is provided, it will have a chance to modify
	 * the Connection object immediately before the request is made.
	 */
	function callApp(app, options, modifier) {
	  options = options || {};

	  var c = new Connection(options);

	  return Promise.resolve(modifier ? modifier(c) : c).then(function (conn) {
	    if (conn == null || !(conn instanceof Connection)) conn = c;

	    return conn.call(app).then(function () {
	      if (options.binary) return conn;

	      return conn.response.stringifyContent(options.maxLength, options.encoding).then(function (content) {
	        conn.responseText = content;
	        return conn;
	      });
	    });
	  });
	}

	module.exports = callApp;

/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(31);

/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {

	// Load modules

	// Declare internals

	var internals = {};

	exports.arrayToObject = function (source) {

	    var obj = {};
	    for (var i = 0, il = source.length; i < il; ++i) {
	        if (typeof source[i] !== 'undefined') {

	            obj[i] = source[i];
	        }
	    }

	    return obj;
	};

	exports.merge = function (target, source) {

	    if (!source) {
	        return target;
	    }

	    if (typeof source !== 'object') {
	        if (Array.isArray(target)) {
	            target.push(source);
	        }
	        else {
	            target[source] = true;
	        }

	        return target;
	    }

	    if (typeof target !== 'object') {
	        target = [target].concat(source);
	        return target;
	    }

	    if (Array.isArray(target) &&
	        !Array.isArray(source)) {

	        target = exports.arrayToObject(target);
	    }

	    var keys = Object.keys(source);
	    for (var k = 0, kl = keys.length; k < kl; ++k) {
	        var key = keys[k];
	        var value = source[key];

	        if (!target[key]) {
	            target[key] = value;
	        }
	        else {
	            target[key] = exports.merge(target[key], value);
	        }
	    }

	    return target;
	};

	exports.decode = function (str) {

	    try {
	        return decodeURIComponent(str.replace(/\+/g, ' '));
	    } catch (e) {
	        return str;
	    }
	};

	exports.compact = function (obj, refs) {

	    if (typeof obj !== 'object' ||
	        obj === null) {

	        return obj;
	    }

	    refs = refs || [];
	    var lookup = refs.indexOf(obj);
	    if (lookup !== -1) {
	        return refs[lookup];
	    }

	    refs.push(obj);

	    if (Array.isArray(obj)) {
	        var compacted = [];

	        for (var i = 0, il = obj.length; i < il; ++i) {
	            if (typeof obj[i] !== 'undefined') {
	                compacted.push(obj[i]);
	            }
	        }

	        return compacted;
	    }

	    var keys = Object.keys(obj);
	    for (i = 0, il = keys.length; i < il; ++i) {
	        var key = keys[i];
	        obj[key] = exports.compact(obj[key], refs);
	    }

	    return obj;
	};

	exports.isRegExp = function (obj) {
	    return Object.prototype.toString.call(obj) === '[object RegExp]';
	};

	exports.isBuffer = function (obj) {

	    if (obj === null ||
	        typeof obj === 'undefined') {

	        return false;
	    }

	    return !!(obj.constructor &&
	        obj.constructor.isBuffer &&
	        obj.constructor.isBuffer(obj));
	};

/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	/* jshint -W058 */
	var XMLHttpRequest = window.XMLHttpRequest;
	var Stream = __webpack_require__(19);
	var AbortablePromise = __webpack_require__(32);

	function copyStatusAndHeaders(xhr, conn) {
	  conn.response.headers = xhr.getAllResponseHeaders();
	  conn.status = xhr.status;
	  return conn.status;
	}

	function getContent(xhr) {
	  var type = String(xhr.responseType).toLowerCase();

	  if (type === "blob") {
	    return xhr.responseBlob || xhr.response;
	  }if (type === "arraybuffer") {
	    return xhr.response;
	  }if (typeof VBArray === "function") {
	    return new VBArray(client.responseBody).toArray();
	  } // IE9

	  return xhr.responseText;
	}

	function pipeContent(xhr, stream, offset) {
	  var content = getContent(xhr);

	  if (content != null) {
	    if (content.toString().match(/ArrayBuffer/)) {
	      stream.write(new Uint8Array(content, offset));
	      return content.byteLength;
	    }

	    if (content.length > offset) {
	      stream.write(content.slice(offset));
	      return content.length;
	    }
	  }

	  return offset;
	}

	function enableBinaryContent(xhr) {
	  if ("responseType" in xhr) {
	    xhr.responseType = "arraybuffer"; // XHR2
	  } else if ("overrideMimeType" in xhr) {
	    xhr.overrideMimeType("text/plain; charset=x-user-defined"); // XHR
	  } else {
	    xhr.setRequestHeader("Accept-Charset", "x-user-defined"); // IE9
	  }
	}

	function enableCredentials(xhr) {
	  if ("withCredentials" in xhr) xhr.withCredentials = true;
	}

	var READ_HEADERS_RECEIVED_STATE = true;
	var READ_LOADING_STATE = true;

	function sendRequest(conn, location) {
	  return new AbortablePromise(function (resolve, reject, onAbort) {
	    var xhr = new XMLHttpRequest();
	    xhr.open(conn.method, location.href, true);

	    enableBinaryContent(xhr);

	    if (conn.withCredentials) enableCredentials(xhr);

	    var request = conn.request;
	    var headers = request.headers;

	    if (headers) for (var headerName in headers) if (headers.hasOwnProperty(headerName)) xhr.setRequestHeader(headerName, headers[headerName]);

	    var content = conn.response.content = new Stream();
	    var offset = 0,
	        status;

	    function tryToResolve() {
	      if (!status && (status = copyStatusAndHeaders(xhr, conn)) > 0) resolve(conn);
	    }

	    xhr.onreadystatechange = function () {
	      if (xhr.error) return; // readystatechange triggers before error.

	      if (xhr.readyState === 2 && READ_HEADERS_RECEIVED_STATE) {
	        try {
	          tryToResolve();
	        } catch (error) {
	          READ_HEADERS_RECEIVED_STATE = false;
	        }
	      } else if (xhr.readyState === 3 && READ_LOADING_STATE) {
	        try {
	          tryToResolve();
	          offset = pipeContent(xhr, content, offset);
	        } catch (error) {
	          READ_LOADING_STATE = false;
	        }
	      } else if (xhr.readyState === 4) {
	        tryToResolve();
	        pipeContent(xhr, content, offset);
	        content.end();
	      }
	    };

	    xhr.onerror = function (event) {
	      // Sometimes XHR fails due to CORS constraints. In those cases
	      // we don't have any extra information here, unfortunately.
	      // See http://stackoverflow.com/questions/4844643/is-it-possible-to-trap-cors-errors
	      reject(event.error || new Error("XMLHttpRequest failed"));
	    };

	    onAbort(function () {
	      try {
	        xhr.abort();
	      } catch (error) {}

	      resolve();
	    });

	    request.bufferContent().then(function (chunk) {
	      xhr.send(chunk);
	    }).then(undefined, reject);
	  });
	}

	module.exports = sendRequest;

	// Not a problem.

/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/** @license MIT License (c) copyright 2010-2014 original author or authors */
	/** @author Brian Cavalier */
	/** @author John Hann */

	(function(define) { 'use strict';
	!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {

		var makePromise = __webpack_require__(33);
		var Scheduler = __webpack_require__(34);
		var async = __webpack_require__(35).asap;

		return makePromise({
			scheduler: new Scheduler(async)
		});

	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	})(__webpack_require__(36));

/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	function ToObject(val) {
		if (val == null) {
			throw new TypeError('Object.assign cannot be called with null or undefined');
		}

		return Object(val);
	}

	module.exports = Object.assign || function (target, source) {
		var from;
		var keys;
		var to = ToObject(target);

		for (var s = 1; s < arguments.length; s++) {
			from = arguments[s];
			keys = Object.keys(Object(from));

			for (var i = 0; i < keys.length; i++) {
				to[keys[i]] = from[keys[i]];
			}
		}

		return to;
	};

/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {

	// 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.

	function EventEmitter() {
	  this._events = this._events || {};
	  this._maxListeners = this._maxListeners || undefined;
	}
	module.exports = EventEmitter;

	// Backwards-compat with node 0.10.x
	EventEmitter.EventEmitter = EventEmitter;

	EventEmitter.prototype._events = undefined;
	EventEmitter.prototype._maxListeners = undefined;

	// 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.
	EventEmitter.defaultMaxListeners = 10;

	// Obviously not all Emitters should be limited to 10. This function allows
	// that to be increased. Set to zero for unlimited.
	EventEmitter.prototype.setMaxListeners = function(n) {
	  if (!isNumber(n) || n < 0 || isNaN(n))
	    throw TypeError('n must be a positive number');
	  this._maxListeners = n;
	  return this;
	};

	EventEmitter.prototype.emit = function(type) {
	  var er, handler, len, args, i, listeners;

	  if (!this._events)
	    this._events = {};

	  // If there is no 'error' event listener then throw.
	  if (type === 'error') {
	    if (!this._events.error ||
	        (isObject(this._events.error) && !this._events.error.length)) {
	      er = arguments[1];
	      if (er instanceof Error) {
	        throw er; // Unhandled 'error' event
	      }
	      throw TypeError('Uncaught, unspecified "error" event.');
	    }
	  }

	  handler = this._events[type];

	  if (isUndefined(handler))
	    return false;

	  if (isFunction(handler)) {
	    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:
	        len = arguments.length;
	        args = new Array(len - 1);
	        for (i = 1; i < len; i++)
	          args[i - 1] = arguments[i];
	        handler.apply(this, args);
	    }
	  } else if (isObject(handler)) {
	    len = arguments.length;
	    args = new Array(len - 1);
	    for (i = 1; i < len; i++)
	      args[i - 1] = arguments[i];

	    listeners = handler.slice();
	    len = listeners.length;
	    for (i = 0; i < len; i++)
	      listeners[i].apply(this, args);
	  }

	  return true;
	};

	EventEmitter.prototype.addListener = function(type, listener) {
	  var m;

	  if (!isFunction(listener))
	    throw TypeError('listener must be a function');

	  if (!this._events)
	    this._events = {};

	  // To avoid recursion in the case that type === "newListener"! Before
	  // adding it to the listeners, first emit "newListener".
	  if (this._events.newListener)
	    this.emit('newListener', type,
	              isFunction(listener.listener) ?
	              listener.listener : listener);

	  if (!this._events[type])
	    // Optimize the case of one listener. Don't need the extra array object.
	    this._events[type] = listener;
	  else if (isObject(this._events[type]))
	    // 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];

	  // Check for listener leak
	  if (isObject(this._events[type]) && !this._events[type].warned) {
	    var m;
	    if (!isUndefined(this._maxListeners)) {
	      m = this._maxListeners;
	    } else {
	      m = EventEmitter.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);
	      if (typeof console.trace === 'function') {
	        // not supported in IE 10
	        console.trace();
	      }
	    }
	  }

	  return this;
	};

	EventEmitter.prototype.on = EventEmitter.prototype.addListener;

	EventEmitter.prototype.once = function(type, listener) {
	  if (!isFunction(listener))
	    throw TypeError('listener must be a function');

	  var fired = false;

	  function g() {
	    this.removeListener(type, g);

	    if (!fired) {
	      fired = true;
	      listener.apply(this, arguments);
	    }
	  }

	  g.listener = listener;
	  this.on(type, g);

	  return this;
	};

	// emits a 'removeListener' event iff the listener was removed
	EventEmitter.prototype.removeListener = function(type, listener) {
	  var list, position, length, i;

	  if (!isFunction(listener))
	    throw TypeError('listener must be a function');

	  if (!this._events || !this._events[type])
	    return this;

	  list = this._events[type];
	  length = list.length;
	  position = -1;

	  if (list === listener ||
	      (isFunction(list.listener) && list.listener === listener)) {
	    delete this._events[type];
	    if (this._events.removeListener)
	      this.emit('removeListener', type, listener);

	  } else if (isObject(list)) {
	    for (i = length; i-- > 0;) {
	      if (list[i] === listener ||
	          (list[i].listener && list[i].listener === listener)) {
	        position = i;
	        break;
	      }
	    }

	    if (position < 0)
	      return this;

	    if (list.length === 1) {
	      list.length = 0;
	      delete this._events[type];
	    } else {
	      list.splice(position, 1);
	    }

	    if (this._events.removeListener)
	      this.emit('removeListener', type, listener);
	  }

	  return this;
	};

	EventEmitter.prototype.removeAllListeners = function(type) {
	  var key, listeners;

	  if (!this._events)
	    return this;

	  // not listening for removeListener, no need to emit
	  if (!this._events.removeListener) {
	    if (arguments.length === 0)
	      this._events = {};
	    else if (this._events[type])
	      delete this._events[type];
	    return this;
	  }

	  // emit removeListener for all listeners on all events
	  if (arguments.length === 0) {
	    for (key in this._events) {
	      if (key === 'removeListener') continue;
	      this.removeAllListeners(key);
	    }
	    this.removeAllListeners('removeListener');
	    this._events = {};
	    return this;
	  }

	  listeners = this._events[type];

	  if (isFunction(listeners)) {
	    this.removeListener(type, listeners);
	  } else {
	    // LIFO order
	    while (listeners.length)
	      this.removeListener(type, listeners[listeners.length - 1]);
	  }
	  delete this._events[type];

	  return this;
	};

	EventEmitter.prototype.listeners = function(type) {
	  var ret;
	  if (!this._events || !this._events[type])
	    ret = [];
	  else if (isFunction(this._events[type]))
	    ret = [this._events[type]];
	  else
	    ret = this._events[type].slice();
	  return ret;
	};

	EventEmitter.listenerCount = function(emitter, type) {
	  var ret;
	  if (!emitter._events || !emitter._events[type])
	    ret = 0;
	  else if (isFunction(emitter._events[type]))
	    ret = 1;
	  else
	    ret = emitter._events[type].length;
	  return ret;
	};

	function isFunction(arg) {
	  return typeof arg === 'function';
	}

	function isNumber(arg) {
	  return typeof arg === 'number';
	}

	function isObject(arg) {
	  return typeof arg === 'object' && arg !== null;
	}

	function isUndefined(arg) {
	  return arg === void 0;
	}

/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {

	// Load modules

	var Stringify = __webpack_require__(38);
	var Parse = __webpack_require__(39);

	// Declare internals

	var internals = {};

	module.exports = {
	    stringify: Stringify,
	    parse: Parse
	};

/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var Promise = __webpack_require__(10);

	function makeAbortable(promise, abort) {
	  promise.abort = abort;

	  // Hijack promise.then so it returns an abortable promise.
	  var _then = promise.then;
	  promise.then = function () {
	    return makeAbortable(_then.apply(promise, arguments), abort);
	  };

	  return promise;
	}

	/**
	 * A Promise class with an abort() method that calls the onAbort function
	 * provided by the resolver.
	 *
	 * Example:
	 *
	 *   var promise = new AbortablePromise(function (resolve, reject, onAbort) {
	 *     // Use resolve & reject as you normally would.
	 *     var request = makeRequest( ... , function (error, response) {
	 *       if (error) {
	 *         reject(error);
	 *       } else {
	 *         resolve(response);
	 *       }
	 *     });
	 *
	 *     // Use onAbort to register a promise.abort() function. It is the
	 *     // responsibility of this function to abort the execution of the
	 *     // promise and resolve/reject as needed.
	 *     onAbort(function () {
	 *       request.abort();
	 *       reject(new Error('Request was aborted'));
	 *     });
	 *   });
	 *
	 *   promise.abort(); // Calls the onAbort handler.
	 */
	function AbortablePromise(resolver) {
	  if (typeof resolver !== "function") throw new Error("AbortablePromise needs a resolver function");

	  var abort;
	  var promise = new Promise(function (resolve, reject) {
	    var aborter;

	    abort = function () {
	      if (aborter == null) return;

	      var fn = aborter;
	      aborter = null;

	      try {
	        return fn.apply(this, arguments);
	      } catch (error) {
	        reject(error);
	      }
	    };

	    resolver(function (child) {
	      if (child && typeof child.abort === "function") {
	        aborter = child.abort;
	      } else {
	        aborter = null;
	      }

	      resolve.apply(this, arguments);
	    }, function () {
	      aborter = null;
	      reject.apply(this, arguments);
	    }, function (fn) {
	      if (typeof fn !== "function") throw new Error("onAbort needs a function");

	      aborter = fn;
	    });
	  });

	  return makeAbortable(promise, abort);
	}

	module.exports = AbortablePromise;

/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/** @license MIT License (c) copyright 2010-2014 original author or authors */
	/** @author Brian Cavalier */
	/** @author John Hann */

	(function(define) { 'use strict';
	!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {

		return function makePromise(environment) {

			var tasks = environment.scheduler;
			var emitRejection = initEmitRejection();

			var objectCreate = Object.create ||
				function(proto) {
					function Child() {}
					Child.prototype = proto;
					return new Child();
				};

			/**
			 * Create a promise whose fate is determined by resolver
			 * @constructor
			 * @returns {Promise} promise
			 * @name Promise
			 */
			function Promise(resolver, handler) {
				this._handler = resolver === Handler ? handler : init(resolver);
			}

			/**
			 * Run the supplied resolver
			 * @param resolver
			 * @returns {Pending}
			 */
			function init(resolver) {
				var handler = new Pending();

				try {
					resolver(promiseResolve, promiseReject, promiseNotify);
				} catch (e) {
					promiseReject(e);
				}

				return handler;

				/**
				 * Transition from pre-resolution state to post-resolution state, notifying
				 * all listeners of the ultimate fulfillment or rejection
				 * @param {*} x resolution value
				 */
				function promiseResolve (x) {
					handler.resolve(x);
				}
				/**
				 * Reject this promise with reason, which will be used verbatim
				 * @param {Error|*} reason rejection reason, strongly suggested
				 *   to be an Error type
				 */
				function promiseReject (reason) {
					handler.reject(reason);
				}

				/**
				 * @deprecated
				 * Issue a progress event, notifying all progress listeners
				 * @param {*} x progress event payload to pass to all listeners
				 */
				function promiseNotify (x) {
					handler.notify(x);
				}
			}

			// Creation

			Promise.resolve = resolve;
			Promise.reject = reject;
			Promise.never = never;

			Promise._defer = defer;
			Promise._handler = getHandler;

			/**
			 * Returns a trusted promise. If x is already a trusted promise, it is
			 * returned, otherwise returns a new trusted Promise which follows x.
			 * @param  {*} x
			 * @return {Promise} promise
			 */
			function resolve(x) {
				return isPromise(x) ? x
					: new Promise(Handler, new Async(getHandler(x)));
			}

			/**
			 * Return a reject promise with x as its reason (x is used verbatim)
			 * @param {*} x
			 * @returns {Promise} rejected promise
			 */
			function reject(x) {
				return new Promise(Handler, new Async(new Rejected(x)));
			}

			/**
			 * Return a promise that remains pending forever
			 * @returns {Promise} forever-pending promise.
			 */
			function never() {
				return foreverPendingPromise; // Should be frozen
			}

			/**
			 * Creates an internal {promise, resolver} pair
			 * @private
			 * @returns {Promise}
			 */
			function defer() {
				return new Promise(Handler, new Pending());
			}

			// Transformation and flow control

			/**
			 * Transform this promise's fulfillment value, returning a new Promise
			 * for the transformed result.  If the promise cannot be fulfilled, onRejected
			 * is called with the reason.  onProgress *may* be called with updates toward
			 * this promise's fulfillment.
			 * @param {function=} onFulfilled fulfillment handler
			 * @param {function=} onRejected rejection handler
			 * @param {function=} onProgress @deprecated progress handler
			 * @return {Promise} new promise
			 */
			Promise.prototype.then = function(onFulfilled, onRejected, onProgress) {
				var parent = this._handler;
				var state = parent.join().state();

				if ((typeof onFulfilled !== 'function' && state > 0) ||
					(typeof onRejected !== 'function' && state < 0)) {
					// Short circuit: value will not change, simply share handler
					return new this.constructor(Handler, parent);
				}

				var p = this._beget();
				var child = p._handler;

				parent.chain(child, parent.receiver, onFulfilled, onRejected, onProgress);

				return p;
			};

			/**
			 * If this promise cannot be fulfilled due to an error, call onRejected to
			 * handle the error. Shortcut for .then(undefined, onRejected)
			 * @param {function?} onRejected
			 * @return {Promise}
			 */
			Promise.prototype['catch'] = function(onRejected) {
				return this.then(void 0, onRejected);
			};

			/**
			 * Creates a new, pending promise of the same type as this promise
			 * @private
			 * @returns {Promise}
			 */
			Promise.prototype._beget = function() {
				return begetFrom(this._handler, this.constructor);
			};

			function begetFrom(parent, Promise) {
				var child = new Pending(parent.receiver, parent.join().context);
				return new Promise(Handler, child);
			}

			// Array combinators

			Promise.all = all;
			Promise.race = race;
			Promise._traverse = traverse;

			/**
			 * Return a promise that will fulfill when all promises in the
			 * input array have fulfilled, or will reject when one of the
			 * promises rejects.
			 * @param {array} promises array of promises
			 * @returns {Promise} promise for array of fulfillment values
			 */
			function all(promises) {
				return traverseWith(snd, null, promises);
			}

			/**
			 * Array<Promise<X>> -> Promise<Array<f(X)>>
			 * @private
			 * @param {function} f function to apply to each promise's value
			 * @param {Array} promises array of promises
			 * @returns {Promise} promise for transformed values
			 */
			function traverse(f, promises) {
				return traverseWith(tryCatch2, f, promises);
			}

			function traverseWith(tryMap, f, promises) {
				var handler = typeof f === 'function' ? mapAt : settleAt;

				var resolver = new Pending();
				var pending = promises.length >>> 0;
				var results = new Array(pending);

				for (var i = 0, x; i < promises.length && !resolver.resolved; ++i) {
					x = promises[i];

					if (x === void 0 && !(i in promises)) {
						--pending;
						continue;
					}

					traverseAt(promises, handler, i, x, resolver);
				}

				if(pending === 0) {
					resolver.become(new Fulfilled(results));
				}

				return new Promise(Handler, resolver);

				function mapAt(i, x, resolver) {
					if(!resolver.resolved) {
						traverseAt(promises, settleAt, i, tryMap(f, x, i), resolver);
					}
				}

				function settleAt(i, x, resolver) {
					results[i] = x;
					if(--pending === 0) {
						resolver.become(new Fulfilled(results));
					}
				}
			}

			function traverseAt(promises, handler, i, x, resolver) {
				if (maybeThenable(x)) {
					var h = getHandlerMaybeThenable(x);
					var s = h.state();

					if (s === 0) {
						h.fold(handler, i, void 0, resolver);
					} else if (s > 0) {
						handler(i, h.value, resolver);
					} else {
						resolver.become(h);
						visitRemaining(promises, i+1, h);
					}
				} else {
					handler(i, x, resolver);
				}
			}

			Promise._visitRemaining = visitRemaining;
			function visitRemaining(promises, start, handler) {
				for(var i=start; i<promises.length; ++i) {
					markAsHandled(getHandler(promises[i]), handler);
				}
			}

			function markAsHandled(h, handler) {
				if(h === handler) {
					return;
				}

				var s = h.state();
				if(s === 0) {
					h.visit(h, void 0, h._unreport);
				} else if(s < 0) {
					h._unreport();
				}
			}

			/**
			 * Fulfill-reject competitive race. Return a promise that will settle
			 * to the same state as the earliest input promise to settle.
			 *
			 * WARNING: The ES6 Promise spec requires that race()ing an empty array
			 * must return a promise that is pending forever.  This implementation
			 * returns a singleton forever-pending promise, the same singleton that is
			 * returned by Promise.never(), thus can be checked with ===
			 *
			 * @param {array} promises array of promises to race
			 * @returns {Promise} if input is non-empty, a promise that will settle
			 * to the same outcome as the earliest input promise to settle. if empty
			 * is empty, returns a promise that will never settle.
			 */
			function race(promises) {
				if(typeof promises !== 'object' || promises === null) {
					return reject(new TypeError('non-iterable passed to race()'));
				}

				// Sigh, race([]) is untestable unless we return *something*
				// that is recognizable without calling .then() on it.
				return promises.length === 0 ? never()
					 : promises.length === 1 ? resolve(promises[0])
					 : runRace(promises);
			}

			function runRace(promises) {
				var resolver = new Pending();
				var i, x, h;
				for(i=0; i<promises.length; ++i) {
					x = promises[i];
					if (x === void 0 && !(i in promises)) {
						continue;
					}

					h = getHandler(x);
					if(h.state() !== 0) {
						resolver.become(h);
						visitRemaining(promises, i+1, h);
						break;
					} else {
						h.visit(resolver, resolver.resolve, resolver.reject);
					}
				}
				return new Promise(Handler, resolver);
			}

			// Promise internals
			// Below this, everything is @private

			/**
			 * Get an appropriate handler for x, without checking for cycles
			 * @param {*} x
			 * @returns {object} handler
			 */
			function getHandler(x) {
				if(isPromise(x)) {
					return x._handler.join();
				}
				return maybeThenable(x) ? getHandlerUntrusted(x) : new Fulfilled(x);
			}

			/**
			 * Get a handler for thenable x.
			 * NOTE: You must only call this if maybeThenable(x) == true
			 * @param {object|function|Promise} x
			 * @returns {object} handler
			 */
			function getHandlerMaybeThenable(x) {
				return isPromise(x) ? x._handler.join() : getHandlerUntrusted(x);
			}

			/**
			 * Get a handler for potentially untrusted thenable x
			 * @param {*} x
			 * @returns {object} handler
			 */
			function getHandlerUntrusted(x) {
				try {
					var untrustedThen = x.then;
					return typeof untrustedThen === 'function'
						? new Thenable(untrustedThen, x)
						: new Fulfilled(x);
				} catch(e) {
					return new Rejected(e);
				}
			}

			/**
			 * Handler for a promise that is pending forever
			 * @constructor
			 */
			function Handler() {}

			Handler.prototype.when
				= Handler.prototype.become
				= Handler.prototype.notify // deprecated
				= Handler.prototype.fail
				= Handler.prototype._unreport
				= Handler.prototype._report
				= noop;

			Handler.prototype._state = 0;

			Handler.prototype.state = function() {
				return this._state;
			};

			/**
			 * Recursively collapse handler chain to find the handler
			 * nearest to the fully resolved value.
			 * @returns {object} handler nearest the fully resolved value
			 */
			Handler.prototype.join = function() {
				var h = this;
				while(h.handler !== void 0) {
					h = h.handler;
				}
				return h;
			};

			Handler.prototype.chain = function(to, receiver, fulfilled, rejected, progress) {
				this.when({
					resolver: to,
					receiver: receiver,
					fulfilled: fulfilled,
					rejected: rejected,
					progress: progress
				});
			};

			Handler.prototype.visit = function(receiver, fulfilled, rejected, progress) {
				this.chain(failIfRejected, receiver, fulfilled, rejected, progress);
			};

			Handler.prototype.fold = function(f, z, c, to) {
				this.when(new Fold(f, z, c, to));
			};

			/**
			 * Handler that invokes fail() on any handler it becomes
			 * @constructor
			 */
			function FailIfRejected() {}

			inherit(Handler, FailIfRejected);

			FailIfRejected.prototype.become = function(h) {
				h.fail();
			};

			var failIfRejected = new FailIfRejected();

			/**
			 * Handler that manages a queue of consumers waiting on a pending promise
			 * @constructor
			 */
			function Pending(receiver, inheritedContext) {
				Promise.createContext(this, inheritedContext);

				this.consumers = void 0;
				this.receiver = receiver;
				this.handler = void 0;
				this.resolved = false;
			}

			inherit(Handler, Pending);

			Pending.prototype._state = 0;

			Pending.prototype.resolve = function(x) {
				this.become(getHandler(x));
			};

			Pending.prototype.reject = function(x) {
				if(this.resolved) {
					return;
				}

				this.become(new Rejected(x));
			};

			Pending.prototype.join = function() {
				if (!this.resolved) {
					return this;
				}

				var h = this;

				while (h.handler !== void 0) {
					h = h.handler;
					if (h === this) {
						return this.handler = cycle();
					}
				}

				return h;
			};

			Pending.prototype.run = function() {
				var q = this.consumers;
				var handler = this.handler;
				this.handler = this.handler.join();
				this.consumers = void 0;

				for (var i = 0; i < q.length; ++i) {
					handler.when(q[i]);
				}
			};

			Pending.prototype.become = function(handler) {
				if(this.resolved) {
					return;
				}

				this.resolved = true;
				this.handler = handler;
				if(this.consumers !== void 0) {
					tasks.enqueue(this);
				}

				if(this.context !== void 0) {
					handler._report(this.context);
				}
			};

			Pending.prototype.when = function(continuation) {
				if(this.resolved) {
					tasks.enqueue(new ContinuationTask(continuation, this.handler));
				} else {
					if(this.consumers === void 0) {
						this.consumers = [continuation];
					} else {
						this.consumers.push(continuation);
					}
				}
			};

			/**
			 * @deprecated
			 */
			Pending.prototype.notify = function(x) {
				if(!this.resolved) {
					tasks.enqueue(new ProgressTask(x, this));
				}
			};

			Pending.prototype.fail = function(context) {
				var c = typeof context === 'undefined' ? this.context : context;
				this.resolved && this.handler.join().fail(c);
			};

			Pending.prototype._report = function(context) {
				this.resolved && this.handler.join()._report(context);
			};

			Pending.prototype._unreport = function() {
				this.resolved && this.handler.join()._unreport();
			};

			/**
			 * Wrap another handler and force it into a future stack
			 * @param {object} handler
			 * @constructor
			 */
			function Async(handler) {
				this.handler = handler;
			}

			inherit(Handler, Async);

			Async.prototype.when = function(continuation) {
				tasks.enqueue(new ContinuationTask(continuation, this));
			};

			Async.prototype._report = function(context) {
				this.join()._report(context);
			};

			Async.prototype._unreport = function() {
				this.join()._unreport();
			};

			/**
			 * Handler that wraps an untrusted thenable and assimilates it in a future stack
			 * @param {function} then
			 * @param {{then: function}} thenable
			 * @constructor
			 */
			function Thenable(then, thenable) {
				Pending.call(this);
				tasks.enqueue(new AssimilateTask(then, thenable, this));
			}

			inherit(Pending, Thenable);

			/**
			 * Handler for a fulfilled promise
			 * @param {*} x fulfillment value
			 * @constructor
			 */
			function Fulfilled(x) {
				Promise.createContext(this);
				this.value = x;
			}

			inherit(Handler, Fulfilled);

			Fulfilled.prototype._state = 1;

			Fulfilled.prototype.fold = function(f, z, c, to) {
				runContinuation3(f, z, this, c, to);
			};

			Fulfilled.prototype.when = function(cont) {
				runContinuation1(cont.fulfilled, this, cont.receiver, cont.resolver);
			};

			var errorId = 0;

			/**
			 * Handler for a rejected promise
			 * @param {*} x rejection reason
			 * @constructor
			 */
			function Rejected(x) {
				Promise.createContext(this);

				this.id = ++errorId;
				this.value = x;
				this.handled = false;
				this.reported = false;

				this._report();
			}

			inherit(Handler, Rejected);

			Rejected.prototype._state = -1;

			Rejected.prototype.fold = function(f, z, c, to) {
				to.become(this);
			};

			Rejected.prototype.when = function(cont) {
				if(typeof cont.rejected === 'function') {
					this._unreport();
				}
				runContinuation1(cont.rejected, this, cont.receiver, cont.resolver);
			};

			Rejected.prototype._report = function(context) {
				tasks.afterQueue(new ReportTask(this, context));
			};

			Rejected.prototype._unreport = function() {
				if(this.handled) {
					return;
				}
				this.handled = true;
				tasks.afterQueue(new UnreportTask(this));
			};

			Rejected.prototype.fail = function(context) {
				this.reported = true;
				emitRejection('unhandledRejection', this);
				Promise.onFatalRejection(this, context === void 0 ? this.context : context);
			};

			function ReportTask(rejection, context) {
				this.rejection = rejection;
				this.context = context;
			}

			ReportTask.prototype.run = function() {
				if(!this.rejection.handled && !this.rejection.reported) {
					this.rejection.reported = true;
					emitRejection('unhandledRejection', this.rejection) ||
						Promise.onPotentiallyUnhandledRejection(this.rejection, this.context);
				}
			};

			function UnreportTask(rejection) {
				this.rejection = rejection;
			}

			UnreportTask.prototype.run = function() {
				if(this.rejection.reported) {
					emitRejection('rejectionHandled', this.rejection) ||
						Promise.onPotentiallyUnhandledRejectionHandled(this.rejection);
				}
			};

			// Unhandled rejection hooks
			// By default, everything is a noop

			Promise.createContext
				= Promise.enterContext
				= Promise.exitContext
				= Promise.onPotentiallyUnhandledRejection
				= Promise.onPotentiallyUnhandledRejectionHandled
				= Promise.onFatalRejection
				= noop;

			// Errors and singletons

			var foreverPendingHandler = new Handler();
			var foreverPendingPromise = new Promise(Handler, foreverPendingHandler);

			function cycle() {
				return new Rejected(new TypeError('Promise cycle'));
			}

			// Task runners

			/**
			 * Run a single consumer
			 * @constructor
			 */
			function ContinuationTask(continuation, handler) {
				this.continuation = continuation;
				this.handler = handler;
			}

			ContinuationTask.prototype.run = function() {
				this.handler.join().when(this.continuation);
			};

			/**
			 * Run a queue of progress handlers
			 * @constructor
			 */
			function ProgressTask(value, handler) {
				this.handler = handler;
				this.value = value;
			}

			ProgressTask.prototype.run = function() {
				var q = this.handler.consumers;
				if(q === void 0) {
					return;
				}

				for (var c, i = 0; i < q.length; ++i) {
					c = q[i];
					runNotify(c.progress, this.value, this.handler, c.receiver, c.resolver);
				}
			};

			/**
			 * Assimilate a thenable, sending it's value to resolver
			 * @param {function} then
			 * @param {object|function} thenable
			 * @param {object} resolver
			 * @constructor
			 */
			function AssimilateTask(then, thenable, resolver) {
				this._then = then;
				this.thenable = thenable;
				this.resolver = resolver;
			}

			AssimilateTask.prototype.run = function() {
				var h = this.resolver;
				tryAssimilate(this._then, this.thenable, _resolve, _reject, _notify);

				function _resolve(x) { h.resolve(x); }
				function _reject(x)  { h.reject(x); }
				function _notify(x)  { h.notify(x); }
			};

			function tryAssimilate(then, thenable, resolve, reject, notify) {
				try {
					then.call(thenable, resolve, reject, notify);
				} catch (e) {
					reject(e);
				}
			}

			/**
			 * Fold a handler value with z
			 * @constructor
			 */
			function Fold(f, z, c, to) {
				this.f = f; this.z = z; this.c = c; this.to = to;
				this.resolver = failIfRejected;
				this.receiver = this;
			}

			Fold.prototype.fulfilled = function(x) {
				this.f.call(this.c, this.z, x, this.to);
			};

			Fold.prototype.rejected = function(x) {
				this.to.reject(x);
			};

			Fold.prototype.progress = function(x) {
				this.to.notify(x);
			};

			// Other helpers

			/**
			 * @param {*} x
			 * @returns {boolean} true iff x is a trusted Promise
			 */
			function isPromise(x) {
				return x instanceof Promise;
			}

			/**
			 * Test just enough to rule out primitives, in order to take faster
			 * paths in some code
			 * @param {*} x
			 * @returns {boolean} false iff x is guaranteed *not* to be a thenable
			 */
			function maybeThenable(x) {
				return (typeof x === 'object' || typeof x === 'function') && x !== null;
			}

			function runContinuation1(f, h, receiver, next) {
				if(typeof f !== 'function') {
					return next.become(h);
				}

				Promise.enterContext(h);
				tryCatchReject(f, h.value, receiver, next);
				Promise.exitContext();
			}

			function runContinuation3(f, x, h, receiver, next) {
				if(typeof f !== 'function') {
					return next.become(h);
				}

				Promise.enterContext(h);
				tryCatchReject3(f, x, h.value, receiver, next);
				Promise.exitContext();
			}

			/**
			 * @deprecated
			 */
			function runNotify(f, x, h, receiver, next) {
				if(typeof f !== 'function') {
					return next.notify(x);
				}

				Promise.enterContext(h);
				tryCatchReturn(f, x, receiver, next);
				Promise.exitContext();
			}

			function tryCatch2(f, a, b) {
				try {
					return f(a, b);
				} catch(e) {
					return reject(e);
				}
			}

			/**
			 * Return f.call(thisArg, x), or if it throws return a rejected promise for
			 * the thrown exception
			 */
			function tryCatchReject(f, x, thisArg, next) {
				try {
					next.become(getHandler(f.call(thisArg, x)));
				} catch(e) {
					next.become(new Rejected(e));
				}
			}

			/**
			 * Same as above, but includes the extra argument parameter.
			 */
			function tryCatchReject3(f, x, y, thisArg, next) {
				try {
					f.call(thisArg, x, y, next);
				} catch(e) {
					next.become(new Rejected(e));
				}
			}

			/**
			 * @deprecated
			 * Return f.call(thisArg, x), or if it throws, *return* the exception
			 */
			function tryCatchReturn(f, x, thisArg, next) {
				try {
					next.notify(f.call(thisArg, x));
				} catch(e) {
					next.notify(e);
				}
			}

			function inherit(Parent, Child) {
				Child.prototype = objectCreate(Parent.prototype);
				Child.prototype.constructor = Child;
			}

			function snd(x, y) {
				return y;
			}

			function noop() {}

			function initEmitRejection() {
				/*global process, self, CustomEvent*/
				if(typeof process !== 'undefined' && process !== null
					&& typeof process.emit === 'function') {
					// Returning falsy here means to call the default
					// onPotentiallyUnhandledRejection API.  This is safe even in
					// browserify since process.emit always returns falsy in browserify:
					// https://github.com/defunctzombie/node-process/blob/master/browser.js#L40-L46
					return function(type, rejection) {
						return type === 'unhandledRejection'
							? process.emit(type, rejection.value, rejection)
							: process.emit(type, rejection);
					};
				} else if(typeof self !== 'undefined' && typeof CustomEvent === 'function') {
					return (function(noop, self, CustomEvent) {
						var hasCustomEvent = false;
						try {
							var ev = new CustomEvent('unhandledRejection');
							hasCustomEvent = ev instanceof CustomEvent;
						} catch (e) {}

						return !hasCustomEvent ? noop : function(type, rejection) {
							var ev = new CustomEvent(type, {
								detail: {
									reason: rejection.value,
									key: rejection
								},
								bubbles: false,
								cancelable: true
							});

							return !self.dispatchEvent(ev);
						};
					}(noop, self, CustomEvent));
				}

				return noop;
			}

			return Promise;
		};
	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	}(__webpack_require__(36)));

/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/** @license MIT License (c) copyright 2010-2014 original author or authors */
	/** @author Brian Cavalier */
	/** @author John Hann */

	(function(define) { 'use strict';
	!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {

		// Credit to Twisol (https://github.com/Twisol) for suggesting
		// this type of extensible queue + trampoline approach for next-tick conflation.

		/**
		 * Async task scheduler
		 * @param {function} async function to schedule a single async function
		 * @constructor
		 */
		function Scheduler(async) {
			this._async = async;
			this._running = false;

			this._queue = this;
			this._queueLen = 0;
			this._afterQueue = {};
			this._afterQueueLen = 0;

			var self = this;
			this.drain = function() {
				self._drain();
			};
		}

		/**
		 * Enqueue a task
		 * @param {{ run:function }} task
		 */
		Scheduler.prototype.enqueue = function(task) {
			this._queue[this._queueLen++] = task;
			this.run();
		};

		/**
		 * Enqueue a task to run after the main task queue
		 * @param {{ run:function }} task
		 */
		Scheduler.prototype.afterQueue = function(task) {
			this._afterQueue[this._afterQueueLen++] = task;
			this.run();
		};

		Scheduler.prototype.run = function() {
			if (!this._running) {
				this._running = true;
				this._async(this.drain);
			}
		};

		/**
		 * Drain the handler queue entirely, and then the after queue
		 */
		Scheduler.prototype._drain = function() {
			var i = 0;
			for (; i < this._queueLen; ++i) {
				this._queue[i].run();
				this._queue[i] = void 0;
			}

			this._queueLen = 0;
			this._running = false;

			for (i = 0; i < this._afterQueueLen; ++i) {
				this._afterQueue[i].run();
				this._afterQueue[i] = void 0;
			}

			this._afterQueueLen = 0;
		};

		return Scheduler;

	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	}(__webpack_require__(36)));

/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;var require;/** @license MIT License (c) copyright 2010-2014 original author or authors */
	/** @author Brian Cavalier */
	/** @author John Hann */

	/*global process,document,setTimeout,clearTimeout,MutationObserver,WebKitMutationObserver*/
	(function(define) { 'use strict';
	!(__WEBPACK_AMD_DEFINE_RESULT__ = function(require) {
		/*jshint maxcomplexity:6*/

		// Sniff "best" async scheduling option
		// Prefer process.nextTick or MutationObserver, then check for
		// setTimeout, and finally vertx, since its the only env that doesn't
		// have setTimeout

		var MutationObs;
		var capturedSetTimeout = typeof setTimeout !== 'undefined' && setTimeout;

		// Default env
		var setTimer = function(f, ms) { return setTimeout(f, ms); };
		var clearTimer = function(t) { return clearTimeout(t); };
		var asap = function (f) { return capturedSetTimeout(f, 0); };

		// Detect specific env
		if (isNode()) { // Node
			asap = function (f) { return process.nextTick(f); };

		} else if (MutationObs = hasMutationObserver()) { // Modern browser
			asap = initMutationObserver(MutationObs);

		} else if (!capturedSetTimeout) { // vert.x
			var vertxRequire = require;
			var vertx = __webpack_require__(37);
			setTimer = function (f, ms) { return vertx.setTimer(ms, f); };
			clearTimer = vertx.cancelTimer;
			asap = vertx.runOnLoop || vertx.runOnContext;
		}

		return {
			setTimer: setTimer,
			clearTimer: clearTimer,
			asap: asap
		};

		function isNode () {
			return typeof process !== 'undefined' && process !== null &&
				typeof process.nextTick === 'function';
		}

		function hasMutationObserver () {
			return (typeof MutationObserver === 'function' && MutationObserver) ||
				(typeof WebKitMutationObserver === 'function' && WebKitMutationObserver);
		}

		function initMutationObserver(MutationObserver) {
			var scheduled;
			var node = document.createTextNode('');
			var o = new MutationObserver(run);
			o.observe(node, { characterData: true });

			function run() {
				var f = scheduled;
				scheduled = void 0;
				f();
			}

			var i = 0;
			return function (f) {
				scheduled = f;
				node.data = (i ^= 1);
			};
		}
	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	}(__webpack_require__(36)));

/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = function() { throw new Error("define cannot be used indirect"); };

/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {

	/* (ignored) */

/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {

	// Load modules

	var Utils = __webpack_require__(26);

	// Declare internals

	var internals = {
	    delimiter: '&',
	    indices: true
	};

	internals.stringify = function (obj, prefix, options) {

	    if (Utils.isBuffer(obj)) {
	        obj = obj.toString();
	    }
	    else if (obj instanceof Date) {
	        obj = obj.toISOString();
	    }
	    else if (obj === null) {
	        obj = '';
	    }

	    if (typeof obj === 'string' ||
	        typeof obj === 'number' ||
	        typeof obj === 'boolean') {

	        return [encodeURIComponent(prefix) + '=' + encodeURIComponent(obj)];
	    }

	    var values = [];

	    if (typeof obj === 'undefined') {
	        return values;
	    }

	    var objKeys = Object.keys(obj);
	    for (var i = 0, il = objKeys.length; i < il; ++i) {
	        var key = objKeys[i];
	        if (!options.indices &&
	            Array.isArray(obj)) {

	            values = values.concat(internals.stringify(obj[key], prefix, options));
	        }
	        else {
	            values = values.concat(internals.stringify(obj[key], prefix + '[' + key + ']', options));
	        }
	    }

	    return values;
	};

	module.exports = function (obj, options) {

	    options = options || {};
	    var delimiter = typeof options.delimiter === 'undefined' ? internals.delimiter : options.delimiter;
	    options.indices = typeof options.indices === 'boolean' ? options.indices : internals.indices;

	    var keys = [];

	    if (typeof obj !== 'object' ||
	        obj === null) {

	        return '';
	    }

	    var objKeys = Object.keys(obj);
	    for (var i = 0, il = objKeys.length; i < il; ++i) {
	        var key = objKeys[i];
	        keys = keys.concat(internals.stringify(obj[key], key, options));
	    }

	    return keys.join(delimiter);
	};

/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {

	// Load modules

	var Utils = __webpack_require__(26);

	// Declare internals

	var internals = {
	    delimiter: '&',
	    depth: 5,
	    arrayLimit: 20,
	    parameterLimit: 1000
	};

	internals.parseValues = function (str, options) {

	    var obj = {};
	    var parts = str.split(options.delimiter, options.parameterLimit === Infinity ? undefined : options.parameterLimit);

	    for (var i = 0, il = parts.length; i < il; ++i) {
	        var part = parts[i];
	        var pos = part.indexOf(']=') === -1 ? part.indexOf('=') : part.indexOf(']=') + 1;

	        if (pos === -1) {
	            obj[Utils.decode(part)] = '';
	        }
	        else {
	            var key = Utils.decode(part.slice(0, pos));
	            var val = Utils.decode(part.slice(pos + 1));

	            if (!obj.hasOwnProperty(key)) {
	                obj[key] = val;
	            }
	            else {
	                obj[key] = [].concat(obj[key]).concat(val);
	            }
	        }
	    }

	    return obj;
	};

	internals.parseObject = function (chain, val, options) {

	    if (!chain.length) {
	        return val;
	    }

	    var root = chain.shift();

	    var obj = {};
	    if (root === '[]') {
	        obj = [];
	        obj = obj.concat(internals.parseObject(chain, val, options));
	    }
	    else {
	        var cleanRoot = root[0] === '[' && root[root.length - 1] === ']' ? root.slice(1, root.length - 1) : root;
	        var index = parseInt(cleanRoot, 10);
	        var indexString = '' + index;
	        if (!isNaN(index) &&
	            root !== cleanRoot &&
	            indexString === cleanRoot &&
	            index >= 0 &&
	            index <= options.arrayLimit) {

	            obj = [];
	            obj[index] = internals.parseObject(chain, val, options);
	        }
	        else {
	            obj[cleanRoot] = internals.parseObject(chain, val, options);
	        }
	    }

	    return obj;
	};

	internals.parseKeys = function (key, val, options) {

	    if (!key) {
	        return;
	    }

	    // The regex chunks

	    var parent = /^([^\[\]]*)/;
	    var child = /(\[[^\[\]]*\])/g;

	    // Get the parent

	    var segment = parent.exec(key);

	    // Don't allow them to overwrite object prototype properties

	    if (Object.prototype.hasOwnProperty(segment[1])) {
	        return;
	    }

	    // Stash the parent if it exists

	    var keys = [];
	    if (segment[1]) {
	        keys.push(segment[1]);
	    }

	    // Loop through children appending to the array until we hit depth

	    var i = 0;
	    while ((segment = child.exec(key)) !== null && i < options.depth) {

	        ++i;
	        if (!Object.prototype.hasOwnProperty(segment[1].replace(/\[|\]/g, ''))) {
	            keys.push(segment[1]);
	        }
	    }

	    // If there's a remainder, just add whatever is left

	    if (segment) {
	        keys.push('[' + key.slice(segment.index) + ']');
	    }

	    return internals.parseObject(keys, val, options);
	};

	module.exports = function (str, options) {

	    if (str === '' ||
	        str === null ||
	        typeof str === 'undefined') {

	        return {};
	    }

	    options = options || {};
	    options.delimiter = typeof options.delimiter === 'string' || Utils.isRegExp(options.delimiter) ? options.delimiter : internals.delimiter;
	    options.depth = typeof options.depth === 'number' ? options.depth : internals.depth;
	    options.arrayLimit = typeof options.arrayLimit === 'number' ? options.arrayLimit : internals.arrayLimit;
	    options.parameterLimit = typeof options.parameterLimit === 'number' ? options.parameterLimit : internals.parameterLimit;

	    var tempObj = typeof str === 'string' ? internals.parseValues(str, options) : str;
	    var obj = {};

	    // Iterate over the keys and setup the new object

	    var keys = Object.keys(tempObj);
	    for (var i = 0, il = keys.length; i < il; ++i) {
	        var key = keys[i];
	        var newObj = internals.parseKeys(key, tempObj[key], options);
	        obj = Utils.merge(obj, newObj);
	    }

	    return Utils.compact(obj);
	};

/***/ }
/******/ ])
});