text: webpackJsonp([0],[
  /* 0 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(1);
  	__webpack_require__(3);
  	module.exports = __webpack_require__(78);
  
  
  /***/ },
  /* 1 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/*
  		MIT License http://www.opensource.org/licenses/mit-license.php
  		Author Tobias Koppers @sokra
  	*/
  	/*globals window __webpack_hash__ */
  	if(true) {
  		var lastData;
  		var upToDate = function upToDate() {
  			return lastData.indexOf(__webpack_require__.h()) >= 0;
  		};
  		var check = function check() {
  			module.hot.check(true, function(err, updatedModules) {
  				if(err) {
  					if(module.hot.status() in {
  							abort: 1,
  							fail: 1
  						}) {
  						console.warn("[HMR] Cannot apply update. Need to do a full reload!");
  						console.warn("[HMR] " + err.stack || err.message);
  						window.location.reload();
  					} else {
  						console.warn("[HMR] Update failed: " + err.stack || err.message);
  					}
  					return;
  				}
  	
  				if(!updatedModules) {
  					console.warn("[HMR] Cannot find update. Need to do a full reload!");
  					console.warn("[HMR] (Probably because of restarting the webpack-dev-server)");
  					window.location.reload();
  					return;
  				}
  	
  				if(!upToDate()) {
  					check();
  				}
  	
  				__webpack_require__(2)(updatedModules, updatedModules);
  	
  				if(upToDate()) {
  					console.log("[HMR] App is up to date.");
  				}
  	
  			});
  		};
  		var addEventListener = window.addEventListener ? function(eventName, listener) {
  			window.addEventListener(eventName, listener, false);
  		} : function(eventName, listener) {
  			window.attachEvent("on" + eventName, listener);
  		};
  		addEventListener("message", function(event) {
  			if(typeof event.data === "string" && event.data.indexOf("webpackHotUpdate") === 0) {
  				lastData = event.data;
  				if(!upToDate() && module.hot.status() === "idle") {
  					console.log("[HMR] Checking for updates on the server...");
  					check();
  				}
  			}
  		});
  		console.log("[HMR] Waiting for update signal from WDS...");
  	} else {
  		throw new Error("[HMR] Hot Module Replacement is disabled.");
  	}
  
  
  /***/ },
  /* 2 */
  /***/ function(module, exports) {
  
  	/*
  		MIT License http://www.opensource.org/licenses/mit-license.php
  		Author Tobias Koppers @sokra
  	*/
  	module.exports = function(updatedModules, renewedModules) {
  		var unacceptedModules = updatedModules.filter(function(moduleId) {
  			return renewedModules && renewedModules.indexOf(moduleId) < 0;
  		});
  	
  		if(unacceptedModules.length > 0) {
  			console.warn("[HMR] The following modules couldn't be hot updated: (They would need a full reload!)");
  			unacceptedModules.forEach(function(moduleId) {
  				console.warn("[HMR]  - " + moduleId);
  			});
  		}
  	
  		if(!renewedModules || renewedModules.length === 0) {
  			console.log("[HMR] Nothing hot updated.");
  		} else {
  			console.log("[HMR] Updated modules:");
  			renewedModules.forEach(function(moduleId) {
  				console.log("[HMR]  - " + moduleId);
  			});
  		}
  	};
  
  
  /***/ },
  /* 3 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(__resourceQuery) {var url = __webpack_require__(4);
  	var stripAnsi = __webpack_require__(11);
  	var socket = __webpack_require__(13);
  	
  	function getCurrentScriptSource() {
  		// `document.currentScript` is the most accurate way to find the current script,
  		// but is not supported in all browsers.
  		if(document.currentScript)
  			return document.currentScript.getAttribute("src");
  		// Fall back to getting all scripts in the document.
  		var scriptElements = document.scripts || [];
  		var currentScript = scriptElements[scriptElements.length - 1];
  		if(currentScript)
  			return currentScript.getAttribute("src");
  		// Fail as there was no script to use.
  		throw new Error("[WDS] Failed to get current script source");
  	}
  	
  	var urlParts;
  	if(true) {
  		// If this bundle is inlined, use the resource query to get the correct url.
  		urlParts = url.parse(__resourceQuery.substr(1));
  	} else {
  		// Else, get the url from the <script> this file was called with.
  		var scriptHost = getCurrentScriptSource();
  		scriptHost = scriptHost.replace(/\/[^\/]+$/, "");
  		urlParts = url.parse((scriptHost ? scriptHost : "/"), false, true);
  	}
  	
  	var hot = false;
  	var initial = true;
  	var currentHash = "";
  	var logLevel = "info";
  	
  	function log(level, msg) {
  		if(logLevel === "info" && level === "info")
  			return console.log(msg);
  		if(["info", "warning"].indexOf(logLevel) >= 0 && level === "warning")
  			return console.warn(msg);
  		if(["info", "warning", "error"].indexOf(logLevel) >= 0 && level === "error")
  			return console.error(msg);
  	}
  	
  	var onSocketMsg = {
  		hot: function() {
  			hot = true;
  			log("info", "[WDS] Hot Module Replacement enabled.");
  		},
  		invalid: function() {
  			log("info", "[WDS] App updated. Recompiling...");
  		},
  		hash: function(hash) {
  			currentHash = hash;
  		},
  		"still-ok": function() {
  			log("info", "[WDS] Nothing changed.")
  		},
  		"log-level": function(level) {
  			logLevel = level;
  		},
  		ok: function() {
  			if(initial) return initial = false;
  			reloadApp();
  		},
  		warnings: function(warnings) {
  			log("info", "[WDS] Warnings while compiling.");
  			for(var i = 0; i < warnings.length; i++)
  				console.warn(stripAnsi(warnings[i]));
  			if(initial) return initial = false;
  			reloadApp();
  		},
  		errors: function(errors) {
  			log("info", "[WDS] Errors while compiling.");
  			for(var i = 0; i < errors.length; i++)
  				console.error(stripAnsi(errors[i]));
  			if(initial) return initial = false;
  			reloadApp();
  		},
  		"proxy-error": function(errors) {
  			log("info", "[WDS] Proxy error.");
  			for(var i = 0; i < errors.length; i++)
  				log("error", stripAnsi(errors[i]));
  			if(initial) return initial = false;
  		},
  		close: function() {
  			log("error", "[WDS] Disconnected!");
  		}
  	};
  	
  	var hostname = urlParts.hostname;
  	var protocol = urlParts.protocol;
  	
  	if(urlParts.hostname === '0.0.0.0') {
  		// why do we need this check?
  		// hostname n/a for file protocol (example, when using electron, ionic)
  		// see: https://github.com/webpack/webpack-dev-server/pull/384
  		if(window.location.hostname && !!~window.location.protocol.indexOf('http')) {
  			hostname = window.location.hostname;
  		}
  	}
  	
  	// `hostname` can be empty when the script path is relative. In that case, specifying
  	// a protocol would result in an invalid URL.
  	// When https is used in the app, secure websockets are always necessary
  	// because the browser doesn't accept non-secure websockets.
  	if(hostname && (window.location.protocol === "https:" || urlParts.hostname === '0.0.0.0')) {
  		protocol = window.location.protocol;
  	}
  	
  	var socketUrl = url.format({
  		protocol: protocol,
  		auth: urlParts.auth,
  		hostname: hostname,
  		port: (urlParts.port === '0') ? window.location.port : urlParts.port,
  		pathname: urlParts.path == null || urlParts.path === '/' ? "/sockjs-node" : urlParts.path
  	});
  	
  	socket(socketUrl, onSocketMsg);
  	
  	function reloadApp() {
  		if(hot) {
  			log("info", "[WDS] App hot update...");
  			window.postMessage("webpackHotUpdate" + currentHash, "*");
  		} else {
  			log("info", "[WDS] App updated. Reloading...");
  			window.location.reload();
  		}
  	}
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, "?http://localhost:8080"))
  
  /***/ },
  /* 4 */
  /***/ 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.
  	
  	'use strict';
  	
  	var punycode = __webpack_require__(5);
  	var util = __webpack_require__(7);
  	
  	exports.parse = urlParse;
  	exports.resolve = urlResolve;
  	exports.resolveObject = urlResolveObject;
  	exports.format = urlFormat;
  	
  	exports.Url = Url;
  	
  	function Url() {
  	  this.protocol = null;
  	  this.slashes = null;
  	  this.auth = null;
  	  this.host = null;
  	  this.port = null;
  	  this.hostname = null;
  	  this.hash = null;
  	  this.search = null;
  	  this.query = null;
  	  this.pathname = null;
  	  this.path = null;
  	  this.href = null;
  	}
  	
  	// Reference: RFC 3986, RFC 1808, RFC 2396
  	
  	// define these here so at least they only have to be
  	// compiled once on the first module load.
  	var protocolPattern = /^([a-z0-9.+-]+:)/i,
  	    portPattern = /:[0-9]*$/,
  	
  	    // Special case for a simple path URL
  	    simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
  	
  	    // RFC 2396: characters reserved for delimiting URLs.
  	    // We actually just auto-escape these.
  	    delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
  	
  	    // RFC 2396: characters not allowed for various reasons.
  	    unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
  	
  	    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
  	    autoEscape = ['\''].concat(unwise),
  	    // Characters that are never ever allowed in a hostname.
  	    // Note that any invalid chars are also handled, but these
  	    // are the ones that are *expected* to be seen, so we fast-path
  	    // them.
  	    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
  	    hostEndingChars = ['/', '?', '#'],
  	    hostnameMaxLen = 255,
  	    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
  	    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
  	    // protocols that can allow "unsafe" and "unwise" chars.
  	    unsafeProtocol = {
  	      'javascript': true,
  	      'javascript:': true
  	    },
  	    // protocols that never have a hostname.
  	    hostlessProtocol = {
  	      'javascript': true,
  	      'javascript:': true
  	    },
  	    // protocols that always contain a // bit.
  	    slashedProtocol = {
  	      'http': true,
  	      'https': true,
  	      'ftp': true,
  	      'gopher': true,
  	      'file': true,
  	      'http:': true,
  	      'https:': true,
  	      'ftp:': true,
  	      'gopher:': true,
  	      'file:': true
  	    },
  	    querystring = __webpack_require__(8);
  	
  	function urlParse(url, parseQueryString, slashesDenoteHost) {
  	  if (url && util.isObject(url) && url instanceof Url) return url;
  	
  	  var u = new Url;
  	  u.parse(url, parseQueryString, slashesDenoteHost);
  	  return u;
  	}
  	
  	Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
  	  if (!util.isString(url)) {
  	    throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
  	  }
  	
  	  // Copy chrome, IE, opera backslash-handling behavior.
  	  // Back slashes before the query string get converted to forward slashes
  	  // See: https://code.google.com/p/chromium/issues/detail?id=25916
  	  var queryIndex = url.indexOf('?'),
  	      splitter =
  	          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
  	      uSplit = url.split(splitter),
  	      slashRegex = /\\/g;
  	  uSplit[0] = uSplit[0].replace(slashRegex, '/');
  	  url = uSplit.join(splitter);
  	
  	  var rest = url;
  	
  	  // trim before proceeding.
  	  // This is to support parse stuff like "  http://foo.com  \n"
  	  rest = rest.trim();
  	
  	  if (!slashesDenoteHost && url.split('#').length === 1) {
  	    // Try fast path regexp
  	    var simplePath = simplePathPattern.exec(rest);
  	    if (simplePath) {
  	      this.path = rest;
  	      this.href = rest;
  	      this.pathname = simplePath[1];
  	      if (simplePath[2]) {
  	        this.search = simplePath[2];
  	        if (parseQueryString) {
  	          this.query = querystring.parse(this.search.substr(1));
  	        } else {
  	          this.query = this.search.substr(1);
  	        }
  	      } else if (parseQueryString) {
  	        this.search = '';
  	        this.query = {};
  	      }
  	      return this;
  	    }
  	  }
  	
  	  var proto = protocolPattern.exec(rest);
  	  if (proto) {
  	    proto = proto[0];
  	    var lowerProto = proto.toLowerCase();
  	    this.protocol = lowerProto;
  	    rest = rest.substr(proto.length);
  	  }
  	
  	  // figure out if it's got a host
  	  // user@server is *always* interpreted as a hostname, and url
  	  // resolution will treat //foo/bar as host=foo,path=bar because that's
  	  // how the browser resolves relative URLs.
  	  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
  	    var slashes = rest.substr(0, 2) === '//';
  	    if (slashes && !(proto && hostlessProtocol[proto])) {
  	      rest = rest.substr(2);
  	      this.slashes = true;
  	    }
  	  }
  	
  	  if (!hostlessProtocol[proto] &&
  	      (slashes || (proto && !slashedProtocol[proto]))) {
  	
  	    // there's a hostname.
  	    // the first instance of /, ?, ;, or # ends the host.
  	    //
  	    // If there is an @ in the hostname, then non-host chars *are* allowed
  	    // to the left of the last @ sign, unless some host-ending character
  	    // comes *before* the @-sign.
  	    // URLs are obnoxious.
  	    //
  	    // ex:
  	    // http://a@b@c/ => user:a@b host:c
  	    // http://a@b?@c => user:a host:c path:/?@c
  	
  	    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
  	    // Review our test case against browsers more comprehensively.
  	
  	    // find the first instance of any hostEndingChars
  	    var hostEnd = -1;
  	    for (var i = 0; i < hostEndingChars.length; i++) {
  	      var hec = rest.indexOf(hostEndingChars[i]);
  	      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
  	        hostEnd = hec;
  	    }
  	
  	    // at this point, either we have an explicit point where the
  	    // auth portion cannot go past, or the last @ char is the decider.
  	    var auth, atSign;
  	    if (hostEnd === -1) {
  	      // atSign can be anywhere.
  	      atSign = rest.lastIndexOf('@');
  	    } else {
  	      // atSign must be in auth portion.
  	      // http://a@b/c@d => host:b auth:a path:/c@d
  	      atSign = rest.lastIndexOf('@', hostEnd);
  	    }
  	
  	    // Now we have a portion which is definitely the auth.
  	    // Pull that off.
  	    if (atSign !== -1) {
  	      auth = rest.slice(0, atSign);
  	      rest = rest.slice(atSign + 1);
  	      this.auth = decodeURIComponent(auth);
  	    }
  	
  	    // the host is the remaining to the left of the first non-host char
  	    hostEnd = -1;
  	    for (var i = 0; i < nonHostChars.length; i++) {
  	      var hec = rest.indexOf(nonHostChars[i]);
  	      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
  	        hostEnd = hec;
  	    }
  	    // if we still have not hit it, then the entire thing is a host.
  	    if (hostEnd === -1)
  	      hostEnd = rest.length;
  	
  	    this.host = rest.slice(0, hostEnd);
  	    rest = rest.slice(hostEnd);
  	
  	    // pull out port.
  	    this.parseHost();
  	
  	    // we've indicated that there is a hostname,
  	    // so even if it's empty, it has to be present.
  	    this.hostname = this.hostname || '';
  	
  	    // if hostname begins with [ and ends with ]
  	    // assume that it's an IPv6 address.
  	    var ipv6Hostname = this.hostname[0] === '[' &&
  	        this.hostname[this.hostname.length - 1] === ']';
  	
  	    // validate a little.
  	    if (!ipv6Hostname) {
  	      var hostparts = this.hostname.split(/\./);
  	      for (var i = 0, l = hostparts.length; i < l; i++) {
  	        var part = hostparts[i];
  	        if (!part) continue;
  	        if (!part.match(hostnamePartPattern)) {
  	          var newpart = '';
  	          for (var j = 0, k = part.length; j < k; j++) {
  	            if (part.charCodeAt(j) > 127) {
  	              // we replace non-ASCII char with a temporary placeholder
  	              // we need this to make sure size of hostname is not
  	              // broken by replacing non-ASCII by nothing
  	              newpart += 'x';
  	            } else {
  	              newpart += part[j];
  	            }
  	          }
  	          // we test again with ASCII char only
  	          if (!newpart.match(hostnamePartPattern)) {
  	            var validParts = hostparts.slice(0, i);
  	            var notHost = hostparts.slice(i + 1);
  	            var bit = part.match(hostnamePartStart);
  	            if (bit) {
  	              validParts.push(bit[1]);
  	              notHost.unshift(bit[2]);
  	            }
  	            if (notHost.length) {
  	              rest = '/' + notHost.join('.') + rest;
  	            }
  	            this.hostname = validParts.join('.');
  	            break;
  	          }
  	        }
  	      }
  	    }
  	
  	    if (this.hostname.length > hostnameMaxLen) {
  	      this.hostname = '';
  	    } else {
  	      // hostnames are always lower case.
  	      this.hostname = this.hostname.toLowerCase();
  	    }
  	
  	    if (!ipv6Hostname) {
  	      // IDNA Support: Returns a punycoded representation of "domain".
  	      // It only converts parts of the domain name that
  	      // have non-ASCII characters, i.e. it doesn't matter if
  	      // you call it with a domain that already is ASCII-only.
  	      this.hostname = punycode.toASCII(this.hostname);
  	    }
  	
  	    var p = this.port ? ':' + this.port : '';
  	    var h = this.hostname || '';
  	    this.host = h + p;
  	    this.href += this.host;
  	
  	    // strip [ and ] from the hostname
  	    // the host field still retains them, though
  	    if (ipv6Hostname) {
  	      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
  	      if (rest[0] !== '/') {
  	        rest = '/' + rest;
  	      }
  	    }
  	  }
  	
  	  // now rest is set to the post-host stuff.
  	  // chop off any delim chars.
  	  if (!unsafeProtocol[lowerProto]) {
  	
  	    // First, make 100% sure that any "autoEscape" chars get
  	    // escaped, even if encodeURIComponent doesn't think they
  	    // need to be.
  	    for (var i = 0, l = autoEscape.length; i < l; i++) {
  	      var ae = autoEscape[i];
  	      if (rest.indexOf(ae) === -1)
  	        continue;
  	      var esc = encodeURIComponent(ae);
  	      if (esc === ae) {
  	        esc = escape(ae);
  	      }
  	      rest = rest.split(ae).join(esc);
  	    }
  	  }
  	
  	
  	  // chop off from the tail first.
  	  var hash = rest.indexOf('#');
  	  if (hash !== -1) {
  	    // got a fragment string.
  	    this.hash = rest.substr(hash);
  	    rest = rest.slice(0, hash);
  	  }
  	  var qm = rest.indexOf('?');
  	  if (qm !== -1) {
  	    this.search = rest.substr(qm);
  	    this.query = rest.substr(qm + 1);
  	    if (parseQueryString) {
  	      this.query = querystring.parse(this.query);
  	    }
  	    rest = rest.slice(0, qm);
  	  } else if (parseQueryString) {
  	    // no query string, but parseQueryString still requested
  	    this.search = '';
  	    this.query = {};
  	  }
  	  if (rest) this.pathname = rest;
  	  if (slashedProtocol[lowerProto] &&
  	      this.hostname && !this.pathname) {
  	    this.pathname = '/';
  	  }
  	
  	  //to support http.request
  	  if (this.pathname || this.search) {
  	    var p = this.pathname || '';
  	    var s = this.search || '';
  	    this.path = p + s;
  	  }
  	
  	  // finally, reconstruct the href based on what has been validated.
  	  this.href = this.format();
  	  return this;
  	};
  	
  	// format a parsed object into a url string
  	function urlFormat(obj) {
  	  // ensure it's an object, and not a string url.
  	  // If it's an obj, this is a no-op.
  	  // this way, you can call url_format() on strings
  	  // to clean up potentially wonky urls.
  	  if (util.isString(obj)) obj = urlParse(obj);
  	  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
  	  return obj.format();
  	}
  	
  	Url.prototype.format = function() {
  	  var auth = this.auth || '';
  	  if (auth) {
  	    auth = encodeURIComponent(auth);
  	    auth = auth.replace(/%3A/i, ':');
  	    auth += '@';
  	  }
  	
  	  var protocol = this.protocol || '',
  	      pathname = this.pathname || '',
  	      hash = this.hash || '',
  	      host = false,
  	      query = '';
  	
  	  if (this.host) {
  	    host = auth + this.host;
  	  } else if (this.hostname) {
  	    host = auth + (this.hostname.indexOf(':') === -1 ?
  	        this.hostname :
  	        '[' + this.hostname + ']');
  	    if (this.port) {
  	      host += ':' + this.port;
  	    }
  	  }
  	
  	  if (this.query &&
  	      util.isObject(this.query) &&
  	      Object.keys(this.query).length) {
  	    query = querystring.stringify(this.query);
  	  }
  	
  	  var search = this.search || (query && ('?' + query)) || '';
  	
  	  if (protocol && protocol.substr(-1) !== ':') protocol += ':';
  	
  	  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
  	  // unless they had them to begin with.
  	  if (this.slashes ||
  	      (!protocol || slashedProtocol[protocol]) && host !== false) {
  	    host = '//' + (host || '');
  	    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
  	  } else if (!host) {
  	    host = '';
  	  }
  	
  	  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
  	  if (search && search.charAt(0) !== '?') search = '?' + search;
  	
  	  pathname = pathname.replace(/[?#]/g, function(match) {
  	    return encodeURIComponent(match);
  	  });
  	  search = search.replace('#', '%23');
  	
  	  return protocol + host + pathname + search + hash;
  	};
  	
  	function urlResolve(source, relative) {
  	  return urlParse(source, false, true).resolve(relative);
  	}
  	
  	Url.prototype.resolve = function(relative) {
  	  return this.resolveObject(urlParse(relative, false, true)).format();
  	};
  	
  	function urlResolveObject(source, relative) {
  	  if (!source) return relative;
  	  return urlParse(source, false, true).resolveObject(relative);
  	}
  	
  	Url.prototype.resolveObject = function(relative) {
  	  if (util.isString(relative)) {
  	    var rel = new Url();
  	    rel.parse(relative, false, true);
  	    relative = rel;
  	  }
  	
  	  var result = new Url();
  	  var tkeys = Object.keys(this);
  	  for (var tk = 0; tk < tkeys.length; tk++) {
  	    var tkey = tkeys[tk];
  	    result[tkey] = this[tkey];
  	  }
  	
  	  // hash is always overridden, no matter what.
  	  // even href="" will remove it.
  	  result.hash = relative.hash;
  	
  	  // if the relative url is empty, then there's nothing left to do here.
  	  if (relative.href === '') {
  	    result.href = result.format();
  	    return result;
  	  }
  	
  	  // hrefs like //foo/bar always cut to the protocol.
  	  if (relative.slashes && !relative.protocol) {
  	    // take everything except the protocol from relative
  	    var rkeys = Object.keys(relative);
  	    for (var rk = 0; rk < rkeys.length; rk++) {
  	      var rkey = rkeys[rk];
  	      if (rkey !== 'protocol')
  	        result[rkey] = relative[rkey];
  	    }
  	
  	    //urlParse appends trailing / to urls like http://www.example.com
  	    if (slashedProtocol[result.protocol] &&
  	        result.hostname && !result.pathname) {
  	      result.path = result.pathname = '/';
  	    }
  	
  	    result.href = result.format();
  	    return result;
  	  }
  	
  	  if (relative.protocol && relative.protocol !== result.protocol) {
  	    // if it's a known url protocol, then changing
  	    // the protocol does weird things
  	    // first, if it's not file:, then we MUST have a host,
  	    // and if there was a path
  	    // to begin with, then we MUST have a path.
  	    // if it is file:, then the host is dropped,
  	    // because that's known to be hostless.
  	    // anything else is assumed to be absolute.
  	    if (!slashedProtocol[relative.protocol]) {
  	      var keys = Object.keys(relative);
  	      for (var v = 0; v < keys.length; v++) {
  	        var k = keys[v];
  	        result[k] = relative[k];
  	      }
  	      result.href = result.format();
  	      return result;
  	    }
  	
  	    result.protocol = relative.protocol;
  	    if (!relative.host && !hostlessProtocol[relative.protocol]) {
  	      var relPath = (relative.pathname || '').split('/');
  	      while (relPath.length && !(relative.host = relPath.shift()));
  	      if (!relative.host) relative.host = '';
  	      if (!relative.hostname) relative.hostname = '';
  	      if (relPath[0] !== '') relPath.unshift('');
  	      if (relPath.length < 2) relPath.unshift('');
  	      result.pathname = relPath.join('/');
  	    } else {
  	      result.pathname = relative.pathname;
  	    }
  	    result.search = relative.search;
  	    result.query = relative.query;
  	    result.host = relative.host || '';
  	    result.auth = relative.auth;
  	    result.hostname = relative.hostname || relative.host;
  	    result.port = relative.port;
  	    // to support http.request
  	    if (result.pathname || result.search) {
  	      var p = result.pathname || '';
  	      var s = result.search || '';
  	      result.path = p + s;
  	    }
  	    result.slashes = result.slashes || relative.slashes;
  	    result.href = result.format();
  	    return result;
  	  }
  	
  	  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
  	      isRelAbs = (
  	          relative.host ||
  	          relative.pathname && relative.pathname.charAt(0) === '/'
  	      ),
  	      mustEndAbs = (isRelAbs || isSourceAbs ||
  	                    (result.host && relative.pathname)),
  	      removeAllDots = mustEndAbs,
  	      srcPath = result.pathname && result.pathname.split('/') || [],
  	      relPath = relative.pathname && relative.pathname.split('/') || [],
  	      psychotic = result.protocol && !slashedProtocol[result.protocol];
  	
  	  // if the url is a non-slashed url, then relative
  	  // links like ../.. should be able
  	  // to crawl up to the hostname, as well.  This is strange.
  	  // result.protocol has already been set by now.
  	  // Later on, put the first path part into the host field.
  	  if (psychotic) {
  	    result.hostname = '';
  	    result.port = null;
  	    if (result.host) {
  	      if (srcPath[0] === '') srcPath[0] = result.host;
  	      else srcPath.unshift(result.host);
  	    }
  	    result.host = '';
  	    if (relative.protocol) {
  	      relative.hostname = null;
  	      relative.port = null;
  	      if (relative.host) {
  	        if (relPath[0] === '') relPath[0] = relative.host;
  	        else relPath.unshift(relative.host);
  	      }
  	      relative.host = null;
  	    }
  	    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
  	  }
  	
  	  if (isRelAbs) {
  	    // it's absolute.
  	    result.host = (relative.host || relative.host === '') ?
  	                  relative.host : result.host;
  	    result.hostname = (relative.hostname || relative.hostname === '') ?
  	                      relative.hostname : result.hostname;
  	    result.search = relative.search;
  	    result.query = relative.query;
  	    srcPath = relPath;
  	    // fall through to the dot-handling below.
  	  } else if (relPath.length) {
  	    // it's relative
  	    // throw away the existing file, and take the new path instead.
  	    if (!srcPath) srcPath = [];
  	    srcPath.pop();
  	    srcPath = srcPath.concat(relPath);
  	    result.search = relative.search;
  	    result.query = relative.query;
  	  } else if (!util.isNullOrUndefined(relative.search)) {
  	    // just pull out the search.
  	    // like href='?foo'.
  	    // Put this after the other two cases because it simplifies the booleans
  	    if (psychotic) {
  	      result.hostname = result.host = srcPath.shift();
  	      //occationaly the auth can get stuck only in host
  	      //this especially happens in cases like
  	      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
  	      var authInHost = result.host && result.host.indexOf('@') > 0 ?
  	                       result.host.split('@') : false;
  	      if (authInHost) {
  	        result.auth = authInHost.shift();
  	        result.host = result.hostname = authInHost.shift();
  	      }
  	    }
  	    result.search = relative.search;
  	    result.query = relative.query;
  	    //to support http.request
  	    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
  	      result.path = (result.pathname ? result.pathname : '') +
  	                    (result.search ? result.search : '');
  	    }
  	    result.href = result.format();
  	    return result;
  	  }
  	
  	  if (!srcPath.length) {
  	    // no path at all.  easy.
  	    // we've already handled the other stuff above.
  	    result.pathname = null;
  	    //to support http.request
  	    if (result.search) {
  	      result.path = '/' + result.search;
  	    } else {
  	      result.path = null;
  	    }
  	    result.href = result.format();
  	    return result;
  	  }
  	
  	  // if a url ENDs in . or .., then it must get a trailing slash.
  	  // however, if it ends in anything else non-slashy,
  	  // then it must NOT get a trailing slash.
  	  var last = srcPath.slice(-1)[0];
  	  var hasTrailingSlash = (
  	      (result.host || relative.host || srcPath.length > 1) &&
  	      (last === '.' || last === '..') || last === '');
  	
  	  // strip single dots, resolve double dots to parent dir
  	  // if the path tries to go above the root, `up` ends up > 0
  	  var up = 0;
  	  for (var i = srcPath.length; i >= 0; i--) {
  	    last = srcPath[i];
  	    if (last === '.') {
  	      srcPath.splice(i, 1);
  	    } else if (last === '..') {
  	      srcPath.splice(i, 1);
  	      up++;
  	    } else if (up) {
  	      srcPath.splice(i, 1);
  	      up--;
  	    }
  	  }
  	
  	  // if the path is allowed to go above the root, restore leading ..s
  	  if (!mustEndAbs && !removeAllDots) {
  	    for (; up--; up) {
  	      srcPath.unshift('..');
  	    }
  	  }
  	
  	  if (mustEndAbs && srcPath[0] !== '' &&
  	      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
  	    srcPath.unshift('');
  	  }
  	
  	  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
  	    srcPath.push('');
  	  }
  	
  	  var isAbsolute = srcPath[0] === '' ||
  	      (srcPath[0] && srcPath[0].charAt(0) === '/');
  	
  	  // put the host back
  	  if (psychotic) {
  	    result.hostname = result.host = isAbsolute ? '' :
  	                                    srcPath.length ? srcPath.shift() : '';
  	    //occationaly the auth can get stuck only in host
  	    //this especially happens in cases like
  	    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
  	    var authInHost = result.host && result.host.indexOf('@') > 0 ?
  	                     result.host.split('@') : false;
  	    if (authInHost) {
  	      result.auth = authInHost.shift();
  	      result.host = result.hostname = authInHost.shift();
  	    }
  	  }
  	
  	  mustEndAbs = mustEndAbs || (result.host && srcPath.length);
  	
  	  if (mustEndAbs && !isAbsolute) {
  	    srcPath.unshift('');
  	  }
  	
  	  if (!srcPath.length) {
  	    result.pathname = null;
  	    result.path = null;
  	  } else {
  	    result.pathname = srcPath.join('/');
  	  }
  	
  	  //to support request.http
  	  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
  	    result.path = (result.pathname ? result.pathname : '') +
  	                  (result.search ? result.search : '');
  	  }
  	  result.auth = relative.auth || result.auth;
  	  result.slashes = result.slashes || relative.slashes;
  	  result.href = result.format();
  	  return result;
  	};
  	
  	Url.prototype.parseHost = function() {
  	  var host = this.host;
  	  var port = portPattern.exec(host);
  	  if (port) {
  	    port = port[0];
  	    if (port !== ':') {
  	      this.port = port.substr(1);
  	    }
  	    host = host.substr(0, host.length - port.length);
  	  }
  	  if (host) this.hostname = host;
  	};
  
  
  /***/ },
  /* 5 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module, global) {/*! https://mths.be/punycode v1.3.2 by @mathias */
  	;(function(root) {
  	
  		/** Detect free variables */
  		var freeExports = typeof exports == 'object' && exports &&
  			!exports.nodeType && exports;
  		var freeModule = typeof module == 'object' && module &&
  			!module.nodeType && module;
  		var freeGlobal = typeof global == 'object' && global;
  		if (
  			freeGlobal.global === freeGlobal ||
  			freeGlobal.window === freeGlobal ||
  			freeGlobal.self === freeGlobal
  		) {
  			root = freeGlobal;
  		}
  	
  		/**
  		 * The `punycode` object.
  		 * @name punycode
  		 * @type Object
  		 */
  		var punycode,
  	
  		/** Highest positive signed 32-bit float value */
  		maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
  	
  		/** Bootstring parameters */
  		base = 36,
  		tMin = 1,
  		tMax = 26,
  		skew = 38,
  		damp = 700,
  		initialBias = 72,
  		initialN = 128, // 0x80
  		delimiter = '-', // '\x2D'
  	
  		/** Regular expressions */
  		regexPunycode = /^xn--/,
  		regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
  		regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
  	
  		/** Error messages */
  		errors = {
  			'overflow': 'Overflow: input needs wider integers to process',
  			'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
  			'invalid-input': 'Invalid input'
  		},
  	
  		/** Convenience shortcuts */
  		baseMinusTMin = base - tMin,
  		floor = Math.floor,
  		stringFromCharCode = String.fromCharCode,
  	
  		/** Temporary variable */
  		key;
  	
  		/*--------------------------------------------------------------------------*/
  	
  		/**
  		 * A generic error utility function.
  		 * @private
  		 * @param {String} type The error type.
  		 * @returns {Error} Throws a `RangeError` with the applicable error message.
  		 */
  		function error(type) {
  			throw RangeError(errors[type]);
  		}
  	
  		/**
  		 * A generic `Array#map` utility function.
  		 * @private
  		 * @param {Array} array The array to iterate over.
  		 * @param {Function} callback The function that gets called for every array
  		 * item.
  		 * @returns {Array} A new array of values returned by the callback function.
  		 */
  		function map(array, fn) {
  			var length = array.length;
  			var result = [];
  			while (length--) {
  				result[length] = fn(array[length]);
  			}
  			return result;
  		}
  	
  		/**
  		 * A simple `Array#map`-like wrapper to work with domain name strings or email
  		 * addresses.
  		 * @private
  		 * @param {String} domain The domain name or email address.
  		 * @param {Function} callback The function that gets called for every
  		 * character.
  		 * @returns {Array} A new string of characters returned by the callback
  		 * function.
  		 */
  		function mapDomain(string, fn) {
  			var parts = string.split('@');
  			var result = '';
  			if (parts.length > 1) {
  				// In email addresses, only the domain name should be punycoded. Leave
  				// the local part (i.e. everything up to `@`) intact.
  				result = parts[0] + '@';
  				string = parts[1];
  			}
  			// Avoid `split(regex)` for IE8 compatibility. See #17.
  			string = string.replace(regexSeparators, '\x2E');
  			var labels = string.split('.');
  			var encoded = map(labels, fn).join('.');
  			return result + encoded;
  		}
  	
  		/**
  		 * Creates an array containing the numeric code points of each Unicode
  		 * character in the string. While JavaScript uses UCS-2 internally,
  		 * this function will convert a pair of surrogate halves (each of which
  		 * UCS-2 exposes as separate characters) into a single code point,
  		 * matching UTF-16.
  		 * @see `punycode.ucs2.encode`
  		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
  		 * @memberOf punycode.ucs2
  		 * @name decode
  		 * @param {String} string The Unicode input string (UCS-2).
  		 * @returns {Array} The new array of code points.
  		 */
  		function ucs2decode(string) {
  			var output = [],
  			    counter = 0,
  			    length = string.length,
  			    value,
  			    extra;
  			while (counter < length) {
  				value = string.charCodeAt(counter++);
  				if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
  					// high surrogate, and there is a next character
  					extra = string.charCodeAt(counter++);
  					if ((extra & 0xFC00) == 0xDC00) { // low surrogate
  						output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
  					} else {
  						// unmatched surrogate; only append this code unit, in case the next
  						// code unit is the high surrogate of a surrogate pair
  						output.push(value);
  						counter--;
  					}
  				} else {
  					output.push(value);
  				}
  			}
  			return output;
  		}
  	
  		/**
  		 * Creates a string based on an array of numeric code points.
  		 * @see `punycode.ucs2.decode`
  		 * @memberOf punycode.ucs2
  		 * @name encode
  		 * @param {Array} codePoints The array of numeric code points.
  		 * @returns {String} The new Unicode string (UCS-2).
  		 */
  		function ucs2encode(array) {
  			return map(array, function(value) {
  				var output = '';
  				if (value > 0xFFFF) {
  					value -= 0x10000;
  					output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
  					value = 0xDC00 | value & 0x3FF;
  				}
  				output += stringFromCharCode(value);
  				return output;
  			}).join('');
  		}
  	
  		/**
  		 * Converts a basic code point into a digit/integer.
  		 * @see `digitToBasic()`
  		 * @private
  		 * @param {Number} codePoint The basic numeric code point value.
  		 * @returns {Number} The numeric value of a basic code point (for use in
  		 * representing integers) in the range `0` to `base - 1`, or `base` if
  		 * the code point does not represent a value.
  		 */
  		function basicToDigit(codePoint) {
  			if (codePoint - 48 < 10) {
  				return codePoint - 22;
  			}
  			if (codePoint - 65 < 26) {
  				return codePoint - 65;
  			}
  			if (codePoint - 97 < 26) {
  				return codePoint - 97;
  			}
  			return base;
  		}
  	
  		/**
  		 * Converts a digit/integer into a basic code point.
  		 * @see `basicToDigit()`
  		 * @private
  		 * @param {Number} digit The numeric value of a basic code point.
  		 * @returns {Number} The basic code point whose value (when used for
  		 * representing integers) is `digit`, which needs to be in the range
  		 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
  		 * used; else, the lowercase form is used. The behavior is undefined
  		 * if `flag` is non-zero and `digit` has no uppercase form.
  		 */
  		function digitToBasic(digit, flag) {
  			//  0..25 map to ASCII a..z or A..Z
  			// 26..35 map to ASCII 0..9
  			return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
  		}
  	
  		/**
  		 * Bias adaptation function as per section 3.4 of RFC 3492.
  		 * http://tools.ietf.org/html/rfc3492#section-3.4
  		 * @private
  		 */
  		function adapt(delta, numPoints, firstTime) {
  			var k = 0;
  			delta = firstTime ? floor(delta / damp) : delta >> 1;
  			delta += floor(delta / numPoints);
  			for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
  				delta = floor(delta / baseMinusTMin);
  			}
  			return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
  		}
  	
  		/**
  		 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
  		 * symbols.
  		 * @memberOf punycode
  		 * @param {String} input The Punycode string of ASCII-only symbols.
  		 * @returns {String} The resulting string of Unicode symbols.
  		 */
  		function decode(input) {
  			// Don't use UCS-2
  			var output = [],
  			    inputLength = input.length,
  			    out,
  			    i = 0,
  			    n = initialN,
  			    bias = initialBias,
  			    basic,
  			    j,
  			    index,
  			    oldi,
  			    w,
  			    k,
  			    digit,
  			    t,
  			    /** Cached calculation results */
  			    baseMinusT;
  	
  			// Handle the basic code points: let `basic` be the number of input code
  			// points before the last delimiter, or `0` if there is none, then copy
  			// the first basic code points to the output.
  	
  			basic = input.lastIndexOf(delimiter);
  			if (basic < 0) {
  				basic = 0;
  			}
  	
  			for (j = 0; j < basic; ++j) {
  				// if it's not a basic code point
  				if (input.charCodeAt(j) >= 0x80) {
  					error('not-basic');
  				}
  				output.push(input.charCodeAt(j));
  			}
  	
  			// Main decoding loop: start just after the last delimiter if any basic code
  			// points were copied; start at the beginning otherwise.
  	
  			for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
  	
  				// `index` is the index of the next character to be consumed.
  				// Decode a generalized variable-length integer into `delta`,
  				// which gets added to `i`. The overflow checking is easier
  				// if we increase `i` as we go, then subtract off its starting
  				// value at the end to obtain `delta`.
  				for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
  	
  					if (index >= inputLength) {
  						error('invalid-input');
  					}
  	
  					digit = basicToDigit(input.charCodeAt(index++));
  	
  					if (digit >= base || digit > floor((maxInt - i) / w)) {
  						error('overflow');
  					}
  	
  					i += digit * w;
  					t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
  	
  					if (digit < t) {
  						break;
  					}
  	
  					baseMinusT = base - t;
  					if (w > floor(maxInt / baseMinusT)) {
  						error('overflow');
  					}
  	
  					w *= baseMinusT;
  	
  				}
  	
  				out = output.length + 1;
  				bias = adapt(i - oldi, out, oldi == 0);
  	
  				// `i` was supposed to wrap around from `out` to `0`,
  				// incrementing `n` each time, so we'll fix that now:
  				if (floor(i / out) > maxInt - n) {
  					error('overflow');
  				}
  	
  				n += floor(i / out);
  				i %= out;
  	
  				// Insert `n` at position `i` of the output
  				output.splice(i++, 0, n);
  	
  			}
  	
  			return ucs2encode(output);
  		}
  	
  		/**
  		 * Converts a string of Unicode symbols (e.g. a domain name label) to a
  		 * Punycode string of ASCII-only symbols.
  		 * @memberOf punycode
  		 * @param {String} input The string of Unicode symbols.
  		 * @returns {String} The resulting Punycode string of ASCII-only symbols.
  		 */
  		function encode(input) {
  			var n,
  			    delta,
  			    handledCPCount,
  			    basicLength,
  			    bias,
  			    j,
  			    m,
  			    q,
  			    k,
  			    t,
  			    currentValue,
  			    output = [],
  			    /** `inputLength` will hold the number of code points in `input`. */
  			    inputLength,
  			    /** Cached calculation results */
  			    handledCPCountPlusOne,
  			    baseMinusT,
  			    qMinusT;
  	
  			// Convert the input in UCS-2 to Unicode
  			input = ucs2decode(input);
  	
  			// Cache the length
  			inputLength = input.length;
  	
  			// Initialize the state
  			n = initialN;
  			delta = 0;
  			bias = initialBias;
  	
  			// Handle the basic code points
  			for (j = 0; j < inputLength; ++j) {
  				currentValue = input[j];
  				if (currentValue < 0x80) {
  					output.push(stringFromCharCode(currentValue));
  				}
  			}
  	
  			handledCPCount = basicLength = output.length;
  	
  			// `handledCPCount` is the number of code points that have been handled;
  			// `basicLength` is the number of basic code points.
  	
  			// Finish the basic string - if it is not empty - with a delimiter
  			if (basicLength) {
  				output.push(delimiter);
  			}
  	
  			// Main encoding loop:
  			while (handledCPCount < inputLength) {
  	
  				// All non-basic code points < n have been handled already. Find the next
  				// larger one:
  				for (m = maxInt, j = 0; j < inputLength; ++j) {
  					currentValue = input[j];
  					if (currentValue >= n && currentValue < m) {
  						m = currentValue;
  					}
  				}
  	
  				// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
  				// but guard against overflow
  				handledCPCountPlusOne = handledCPCount + 1;
  				if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
  					error('overflow');
  				}
  	
  				delta += (m - n) * handledCPCountPlusOne;
  				n = m;
  	
  				for (j = 0; j < inputLength; ++j) {
  					currentValue = input[j];
  	
  					if (currentValue < n && ++delta > maxInt) {
  						error('overflow');
  					}
  	
  					if (currentValue == n) {
  						// Represent delta as a generalized variable-length integer
  						for (q = delta, k = base; /* no condition */; k += base) {
  							t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
  							if (q < t) {
  								break;
  							}
  							qMinusT = q - t;
  							baseMinusT = base - t;
  							output.push(
  								stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
  							);
  							q = floor(qMinusT / baseMinusT);
  						}
  	
  						output.push(stringFromCharCode(digitToBasic(q, 0)));
  						bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
  						delta = 0;
  						++handledCPCount;
  					}
  				}
  	
  				++delta;
  				++n;
  	
  			}
  			return output.join('');
  		}
  	
  		/**
  		 * Converts a Punycode string representing a domain name or an email address
  		 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
  		 * it doesn't matter if you call it on a string that has already been
  		 * converted to Unicode.
  		 * @memberOf punycode
  		 * @param {String} input The Punycoded domain name or email address to
  		 * convert to Unicode.
  		 * @returns {String} The Unicode representation of the given Punycode
  		 * string.
  		 */
  		function toUnicode(input) {
  			return mapDomain(input, function(string) {
  				return regexPunycode.test(string)
  					? decode(string.slice(4).toLowerCase())
  					: string;
  			});
  		}
  	
  		/**
  		 * Converts a Unicode string representing a domain name or an email address to
  		 * Punycode. Only the non-ASCII parts of the domain name will be converted,
  		 * i.e. it doesn't matter if you call it with a domain that's already in
  		 * ASCII.
  		 * @memberOf punycode
  		 * @param {String} input The domain name or email address to convert, as a
  		 * Unicode string.
  		 * @returns {String} The Punycode representation of the given domain name or
  		 * email address.
  		 */
  		function toASCII(input) {
  			return mapDomain(input, function(string) {
  				return regexNonASCII.test(string)
  					? 'xn--' + encode(string)
  					: string;
  			});
  		}
  	
  		/*--------------------------------------------------------------------------*/
  	
  		/** Define the public API */
  		punycode = {
  			/**
  			 * A string representing the current Punycode.js version number.
  			 * @memberOf punycode
  			 * @type String
  			 */
  			'version': '1.3.2',
  			/**
  			 * An object of methods to convert from JavaScript's internal character
  			 * representation (UCS-2) to Unicode code points, and back.
  			 * @see <https://mathiasbynens.be/notes/javascript-encoding>
  			 * @memberOf punycode
  			 * @type Object
  			 */
  			'ucs2': {
  				'decode': ucs2decode,
  				'encode': ucs2encode
  			},
  			'decode': decode,
  			'encode': encode,
  			'toASCII': toASCII,
  			'toUnicode': toUnicode
  		};
  	
  		/** Expose `punycode` */
  		// Some AMD build optimizers, like r.js, check for specific condition patterns
  		// like the following:
  		if (
  			true
  		) {
  			!(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
  				return punycode;
  			}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  		} else if (freeExports && freeModule) {
  			if (module.exports == freeExports) { // in Node.js or RingoJS v0.8.0+
  				freeModule.exports = punycode;
  			} else { // in Narwhal or RingoJS v0.7.0-
  				for (key in punycode) {
  					punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
  				}
  			}
  		} else { // in Rhino or a web browser
  			root.punycode = punycode;
  		}
  	
  	}(this));
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module), (function() { return this; }())))
  
  /***/ },
  /* 6 */
  /***/ function(module, exports) {
  
  	module.exports = function(module) {
  		if(!module.webpackPolyfill) {
  			module.deprecate = function() {};
  			module.paths = [];
  			// module.parent = undefined by default
  			module.children = [];
  			module.webpackPolyfill = 1;
  		}
  		return module;
  	}
  
  
  /***/ },
  /* 7 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	module.exports = {
  	  isString: function(arg) {
  	    return typeof(arg) === 'string';
  	  },
  	  isObject: function(arg) {
  	    return typeof(arg) === 'object' && arg !== null;
  	  },
  	  isNull: function(arg) {
  	    return arg === null;
  	  },
  	  isNullOrUndefined: function(arg) {
  	    return arg == null;
  	  }
  	};
  
  
  /***/ },
  /* 8 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	exports.decode = exports.parse = __webpack_require__(9);
  	exports.encode = exports.stringify = __webpack_require__(10);
  
  
  /***/ },
  /* 9 */
  /***/ function(module, exports) {
  
  	// 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.
  	
  	'use strict';
  	
  	// If obj.hasOwnProperty has been overridden, then calling
  	// obj.hasOwnProperty(prop) will break.
  	// See: https://github.com/joyent/node/issues/1707
  	function hasOwnProperty(obj, prop) {
  	  return Object.prototype.hasOwnProperty.call(obj, prop);
  	}
  	
  	module.exports = function(qs, sep, eq, options) {
  	  sep = sep || '&';
  	  eq = eq || '=';
  	  var obj = {};
  	
  	  if (typeof qs !== 'string' || qs.length === 0) {
  	    return obj;
  	  }
  	
  	  var regexp = /\+/g;
  	  qs = qs.split(sep);
  	
  	  var maxKeys = 1000;
  	  if (options && typeof options.maxKeys === 'number') {
  	    maxKeys = options.maxKeys;
  	  }
  	
  	  var len = qs.length;
  	  // maxKeys <= 0 means that we should not limit keys count
  	  if (maxKeys > 0 && len > maxKeys) {
  	    len = maxKeys;
  	  }
  	
  	  for (var i = 0; i < len; ++i) {
  	    var x = qs[i].replace(regexp, '%20'),
  	        idx = x.indexOf(eq),
  	        kstr, vstr, k, v;
  	
  	    if (idx >= 0) {
  	      kstr = x.substr(0, idx);
  	      vstr = x.substr(idx + 1);
  	    } else {
  	      kstr = x;
  	      vstr = '';
  	    }
  	
  	    k = decodeURIComponent(kstr);
  	    v = decodeURIComponent(vstr);
  	
  	    if (!hasOwnProperty(obj, k)) {
  	      obj[k] = v;
  	    } else if (Array.isArray(obj[k])) {
  	      obj[k].push(v);
  	    } else {
  	      obj[k] = [obj[k], v];
  	    }
  	  }
  	
  	  return obj;
  	};
  
  
  /***/ },
  /* 10 */
  /***/ function(module, exports) {
  
  	// 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.
  	
  	'use strict';
  	
  	var stringifyPrimitive = function(v) {
  	  switch (typeof v) {
  	    case 'string':
  	      return v;
  	
  	    case 'boolean':
  	      return v ? 'true' : 'false';
  	
  	    case 'number':
  	      return isFinite(v) ? v : '';
  	
  	    default:
  	      return '';
  	  }
  	};
  	
  	module.exports = function(obj, sep, eq, name) {
  	  sep = sep || '&';
  	  eq = eq || '=';
  	  if (obj === null) {
  	    obj = undefined;
  	  }
  	
  	  if (typeof obj === 'object') {
  	    return Object.keys(obj).map(function(k) {
  	      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
  	      if (Array.isArray(obj[k])) {
  	        return obj[k].map(function(v) {
  	          return ks + encodeURIComponent(stringifyPrimitive(v));
  	        }).join(sep);
  	      } else {
  	        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
  	      }
  	    }).join(sep);
  	
  	  }
  	
  	  if (!name) return '';
  	  return encodeURIComponent(stringifyPrimitive(name)) + eq +
  	         encodeURIComponent(stringifyPrimitive(obj));
  	};
  
  
  /***/ },
  /* 11 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	var ansiRegex = __webpack_require__(12)();
  	
  	module.exports = function (str) {
  		return typeof str === 'string' ? str.replace(ansiRegex, '') : str;
  	};
  
  
  /***/ },
  /* 12 */
  /***/ function(module, exports) {
  
  	'use strict';
  	module.exports = function () {
  		return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
  	};
  
  
  /***/ },
  /* 13 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var SockJS = __webpack_require__(14);
  	
  	var retries = 0;
  	var sock = null;
  	
  	function socket(url, handlers) {
  		sock = new SockJS(url);
  	
  		sock.onopen = function() {
  			retries = 0;
  		}
  	
  		sock.onclose = function() {
  			if(retries === 0)
  				handlers.close();
  	
  			// Try to reconnect.
  			sock = null;
  	
  			// After 10 retries stop trying, to prevent logspam.
  			if(retries <= 10) {
  				// Exponentially increase timeout to reconnect.
  				// Respectfully copied from the package `got`.
  				var retryInMs = 1000 * Math.pow(2, retries) + Math.random() * 100;
  				retries += 1;
  	
  				setTimeout(function() {
  					socket(url, handlers);
  				}, retryInMs);
  			}
  		};
  	
  		sock.onmessage = function(e) {
  			// This assumes that all data sent via the websocket is JSON.
  			var msg = JSON.parse(e.data);
  			if(handlers[msg.type])
  				handlers[msg.type](msg.data);
  		};
  	}
  	
  	module.exports = socket;
  
  
  /***/ },
  /* 14 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	var transportList = __webpack_require__(15);
  	
  	module.exports = __webpack_require__(62)(transportList);
  	
  	// TODO can't get rid of this until all servers do
  	if ('_sockjs_onload' in global) {
  	  setTimeout(global._sockjs_onload, 1);
  	}
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 15 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	module.exports = [
  	  // streaming transports
  	  __webpack_require__(16)
  	, __webpack_require__(33)
  	, __webpack_require__(43)
  	, __webpack_require__(45)
  	, __webpack_require__(48)(__webpack_require__(45))
  	
  	  // polling transports
  	, __webpack_require__(55)
  	, __webpack_require__(48)(__webpack_require__(55))
  	, __webpack_require__(57)
  	, __webpack_require__(58)
  	, __webpack_require__(48)(__webpack_require__(57))
  	, __webpack_require__(59)
  	];
  
  
  /***/ },
  /* 16 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var utils = __webpack_require__(18)
  	  , urlUtils = __webpack_require__(21)
  	  , inherits = __webpack_require__(29)
  	  , EventEmitter = __webpack_require__(30).EventEmitter
  	  , WebsocketDriver = __webpack_require__(32)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:websocket');
  	}
  	
  	function WebSocketTransport(transUrl, ignore, options) {
  	  if (!WebSocketTransport.enabled()) {
  	    throw new Error('Transport created when disabled');
  	  }
  	
  	  EventEmitter.call(this);
  	  debug('constructor', transUrl);
  	
  	  var self = this;
  	  var url = urlUtils.addPath(transUrl, '/websocket');
  	  if (url.slice(0, 5) === 'https') {
  	    url = 'wss' + url.slice(5);
  	  } else {
  	    url = 'ws' + url.slice(4);
  	  }
  	  this.url = url;
  	
  	  this.ws = new WebsocketDriver(this.url, [], options);
  	  this.ws.onmessage = function(e) {
  	    debug('message event', e.data);
  	    self.emit('message', e.data);
  	  };
  	  // Firefox has an interesting bug. If a websocket connection is
  	  // created after onunload, it stays alive even when user
  	  // navigates away from the page. In such situation let's lie -
  	  // let's not open the ws connection at all. See:
  	  // https://github.com/sockjs/sockjs-client/issues/28
  	  // https://bugzilla.mozilla.org/show_bug.cgi?id=696085
  	  this.unloadRef = utils.unloadAdd(function() {
  	    debug('unload');
  	    self.ws.close();
  	  });
  	  this.ws.onclose = function(e) {
  	    debug('close event', e.code, e.reason);
  	    self.emit('close', e.code, e.reason);
  	    self._cleanup();
  	  };
  	  this.ws.onerror = function(e) {
  	    debug('error event', e);
  	    self.emit('close', 1006, 'WebSocket connection broken');
  	    self._cleanup();
  	  };
  	}
  	
  	inherits(WebSocketTransport, EventEmitter);
  	
  	WebSocketTransport.prototype.send = function(data) {
  	  var msg = '[' + data + ']';
  	  debug('send', msg);
  	  this.ws.send(msg);
  	};
  	
  	WebSocketTransport.prototype.close = function() {
  	  debug('close');
  	  var ws = this.ws;
  	  this._cleanup();
  	  if (ws) {
  	    ws.close();
  	  }
  	};
  	
  	WebSocketTransport.prototype._cleanup = function() {
  	  debug('_cleanup');
  	  var ws = this.ws;
  	  if (ws) {
  	    ws.onmessage = ws.onclose = ws.onerror = null;
  	  }
  	  utils.unloadDel(this.unloadRef);
  	  this.unloadRef = this.ws = null;
  	  this.removeAllListeners();
  	};
  	
  	WebSocketTransport.enabled = function() {
  	  debug('enabled');
  	  return !!WebsocketDriver;
  	};
  	WebSocketTransport.transportName = 'websocket';
  	
  	// In theory, ws should require 1 round trip. But in chrome, this is
  	// not very stable over SSL. Most likely a ws connection requires a
  	// separate SSL connection, in which case 2 round trips are an
  	// absolute minumum.
  	WebSocketTransport.roundTrips = 2;
  	
  	module.exports = WebSocketTransport;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 17 */,
  /* 18 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	var random = __webpack_require__(19);
  	
  	var onUnload = {}
  	  , afterUnload = false
  	    // detect google chrome packaged apps because they don't allow the 'unload' event
  	  , isChromePackagedApp = global.chrome && global.chrome.app && global.chrome.app.runtime
  	  ;
  	
  	module.exports = {
  	  attachEvent: function(event, listener) {
  	    if (typeof global.addEventListener !== 'undefined') {
  	      global.addEventListener(event, listener, false);
  	    } else if (global.document && global.attachEvent) {
  	      // IE quirks.
  	      // According to: http://stevesouders.com/misc/test-postmessage.php
  	      // the message gets delivered only to 'document', not 'window'.
  	      global.document.attachEvent('on' + event, listener);
  	      // I get 'window' for ie8.
  	      global.attachEvent('on' + event, listener);
  	    }
  	  }
  	
  	, detachEvent: function(event, listener) {
  	    if (typeof global.addEventListener !== 'undefined') {
  	      global.removeEventListener(event, listener, false);
  	    } else if (global.document && global.detachEvent) {
  	      global.document.detachEvent('on' + event, listener);
  	      global.detachEvent('on' + event, listener);
  	    }
  	  }
  	
  	, unloadAdd: function(listener) {
  	    if (isChromePackagedApp) {
  	      return null;
  	    }
  	
  	    var ref = random.string(8);
  	    onUnload[ref] = listener;
  	    if (afterUnload) {
  	      setTimeout(this.triggerUnloadCallbacks, 0);
  	    }
  	    return ref;
  	  }
  	
  	, unloadDel: function(ref) {
  	    if (ref in onUnload) {
  	      delete onUnload[ref];
  	    }
  	  }
  	
  	, triggerUnloadCallbacks: function() {
  	    for (var ref in onUnload) {
  	      onUnload[ref]();
  	      delete onUnload[ref];
  	    }
  	  }
  	};
  	
  	var unloadTriggered = function() {
  	  if (afterUnload) {
  	    return;
  	  }
  	  afterUnload = true;
  	  module.exports.triggerUnloadCallbacks();
  	};
  	
  	// 'unload' alone is not reliable in opera within an iframe, but we
  	// can't use `beforeunload` as IE fires it on javascript: links.
  	if (!isChromePackagedApp) {
  	  module.exports.attachEvent('unload', unloadTriggered);
  	}
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 19 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	/* global crypto:true */
  	var crypto = __webpack_require__(20);
  	
  	// This string has length 32, a power of 2, so the modulus doesn't introduce a
  	// bias.
  	var _randomStringChars = 'abcdefghijklmnopqrstuvwxyz012345';
  	module.exports = {
  	  string: function(length) {
  	    var max = _randomStringChars.length;
  	    var bytes = crypto.randomBytes(length);
  	    var ret = [];
  	    for (var i = 0; i < length; i++) {
  	      ret.push(_randomStringChars.substr(bytes[i] % max, 1));
  	    }
  	    return ret.join('');
  	  }
  	
  	, number: function(max) {
  	    return Math.floor(Math.random() * max);
  	  }
  	
  	, numberString: function(max) {
  	    var t = ('' + (max - 1)).length;
  	    var p = new Array(t + 1).join('0');
  	    return (p + this.number(max)).slice(-t);
  	  }
  	};
  
  
  /***/ },
  /* 20 */
  /***/ function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	if (global.crypto && global.crypto.getRandomValues) {
  	  module.exports.randomBytes = function(length) {
  	    var bytes = new Uint8Array(length);
  	    global.crypto.getRandomValues(bytes);
  	    return bytes;
  	  };
  	} else {
  	  module.exports.randomBytes = function(length) {
  	    var bytes = new Array(length);
  	    for (var i = 0; i < length; i++) {
  	      bytes[i] = Math.floor(Math.random() * 256);
  	    }
  	    return bytes;
  	  };
  	}
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 21 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var URL = __webpack_require__(22);
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:utils:url');
  	}
  	
  	module.exports = {
  	  getOrigin: function(url) {
  	    if (!url) {
  	      return null;
  	    }
  	
  	    var p = new URL(url);
  	    if (p.protocol === 'file:') {
  	      return null;
  	    }
  	
  	    var port = p.port;
  	    if (!port) {
  	      port = (p.protocol === 'https:') ? '443' : '80';
  	    }
  	
  	    return p.protocol + '//' + p.hostname + ':' + port;
  	  }
  	
  	, isOriginEqual: function(a, b) {
  	    var res = this.getOrigin(a) === this.getOrigin(b);
  	    debug('same', a, b, res);
  	    return res;
  	  }
  	
  	, isSchemeEqual: function(a, b) {
  	    return (a.split(':')[0] === b.split(':')[0]);
  	  }
  	
  	, addPath: function (url, path) {
  	    var qs = url.split('?');
  	    return qs[0] + path + (qs[1] ? '?' + qs[1] : '');
  	  }
  	
  	, addQuery: function (url, q) {
  	    return url + (url.indexOf('?') === -1 ? ('?' + q) : ('&' + q));
  	  }
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 22 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var required = __webpack_require__(23)
  	  , lolcation = __webpack_require__(24)
  	  , qs = __webpack_require__(25)
  	  , protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\S\s]*)/i;
  	
  	/**
  	 * These are the parse rules for the URL parser, it informs the parser
  	 * about:
  	 *
  	 * 0. The char it Needs to parse, if it's a string it should be done using
  	 *    indexOf, RegExp using exec and NaN means set as current value.
  	 * 1. The property we should set when parsing this value.
  	 * 2. Indication if it's backwards or forward parsing, when set as number it's
  	 *    the value of extra chars that should be split off.
  	 * 3. Inherit from location if non existing in the parser.
  	 * 4. `toLowerCase` the resulting value.
  	 */
  	var rules = [
  	  ['#', 'hash'],                        // Extract from the back.
  	  ['?', 'query'],                       // Extract from the back.
  	  ['/', 'pathname'],                    // Extract from the back.
  	  ['@', 'auth', 1],                     // Extract from the front.
  	  [NaN, 'host', undefined, 1, 1],       // Set left over value.
  	  [/:(\d+)$/, 'port', undefined, 1],    // RegExp the back.
  	  [NaN, 'hostname', undefined, 1, 1]    // Set left over.
  	];
  	
  	/**
  	 * @typedef ProtocolExtract
  	 * @type Object
  	 * @property {String} protocol Protocol matched in the URL, in lowercase.
  	 * @property {Boolean} slashes `true` if protocol is followed by "//", else `false`.
  	 * @property {String} rest Rest of the URL that is not part of the protocol.
  	 */
  	
  	/**
  	 * Extract protocol information from a URL with/without double slash ("//").
  	 *
  	 * @param {String} address URL we want to extract from.
  	 * @return {ProtocolExtract} Extracted information.
  	 * @api private
  	 */
  	function extractProtocol(address) {
  	  var match = protocolre.exec(address);
  	
  	  return {
  	    protocol: match[1] ? match[1].toLowerCase() : '',
  	    slashes: !!match[2],
  	    rest: match[3]
  	  };
  	}
  	
  	/**
  	 * Resolve a relative URL pathname against a base URL pathname.
  	 *
  	 * @param {String} relative Pathname of the relative URL.
  	 * @param {String} base Pathname of the base URL.
  	 * @return {String} Resolved pathname.
  	 * @api private
  	 */
  	function resolve(relative, base) {
  	  var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/'))
  	    , i = path.length
  	    , last = path[i - 1]
  	    , unshift = false
  	    , up = 0;
  	
  	  while (i--) {
  	    if (path[i] === '.') {
  	      path.splice(i, 1);
  	    } else if (path[i] === '..') {
  	      path.splice(i, 1);
  	      up++;
  	    } else if (up) {
  	      if (i === 0) unshift = true;
  	      path.splice(i, 1);
  	      up--;
  	    }
  	  }
  	
  	  if (unshift) path.unshift('');
  	  if (last === '.' || last === '..') path.push('');
  	
  	  return path.join('/');
  	}
  	
  	/**
  	 * The actual URL instance. Instead of returning an object we've opted-in to
  	 * create an actual constructor as it's much more memory efficient and
  	 * faster and it pleases my OCD.
  	 *
  	 * @constructor
  	 * @param {String} address URL we want to parse.
  	 * @param {Object|String} location Location defaults for relative paths.
  	 * @param {Boolean|Function} parser Parser for the query string.
  	 * @api public
  	 */
  	function URL(address, location, parser) {
  	  if (!(this instanceof URL)) {
  	    return new URL(address, location, parser);
  	  }
  	
  	  var relative, extracted, parse, instruction, index, key
  	    , instructions = rules.slice()
  	    , type = typeof location
  	    , url = this
  	    , i = 0;
  	
  	  //
  	  // The following if statements allows this module two have compatibility with
  	  // 2 different API:
  	  //
  	  // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments
  	  //    where the boolean indicates that the query string should also be parsed.
  	  //
  	  // 2. The `URL` interface of the browser which accepts a URL, object as
  	  //    arguments. The supplied object will be used as default values / fall-back
  	  //    for relative paths.
  	  //
  	  if ('object' !== type && 'string' !== type) {
  	    parser = location;
  	    location = null;
  	  }
  	
  	  if (parser && 'function' !== typeof parser) parser = qs.parse;
  	
  	  location = lolcation(location);
  	
  	  //
  	  // Extract protocol information before running the instructions.
  	  //
  	  extracted = extractProtocol(address || '');
  	  relative = !extracted.protocol && !extracted.slashes;
  	  url.slashes = extracted.slashes || relative && location.slashes;
  	  url.protocol = extracted.protocol || location.protocol || '';
  	  address = extracted.rest;
  	
  	  //
  	  // When the authority component is absent the URL starts with a path
  	  // component.
  	  //
  	  if (!extracted.slashes) instructions[2] = [/(.*)/, 'pathname'];
  	
  	  for (; i < instructions.length; i++) {
  	    instruction = instructions[i];
  	    parse = instruction[0];
  	    key = instruction[1];
  	
  	    if (parse !== parse) {
  	      url[key] = address;
  	    } else if ('string' === typeof parse) {
  	      if (~(index = address.indexOf(parse))) {
  	        if ('number' === typeof instruction[2]) {
  	          url[key] = address.slice(0, index);
  	          address = address.slice(index + instruction[2]);
  	        } else {
  	          url[key] = address.slice(index);
  	          address = address.slice(0, index);
  	        }
  	      }
  	    } else if ((index = parse.exec(address))) {
  	      url[key] = index[1];
  	      address = address.slice(0, index.index);
  	    }
  	
  	    url[key] = url[key] || (
  	      relative && instruction[3] ? location[key] || '' : ''
  	    );
  	
  	    //
  	    // Hostname, host and protocol should be lowercased so they can be used to
  	    // create a proper `origin`.
  	    //
  	    if (instruction[4]) url[key] = url[key].toLowerCase();
  	  }
  	
  	  //
  	  // Also parse the supplied query string in to an object. If we're supplied
  	  // with a custom parser as function use that instead of the default build-in
  	  // parser.
  	  //
  	  if (parser) url.query = parser(url.query);
  	
  	  //
  	  // If the URL is relative, resolve the pathname against the base URL.
  	  //
  	  if (
  	      relative
  	    && location.slashes
  	    && url.pathname.charAt(0) !== '/'
  	    && (url.pathname !== '' || location.pathname !== '')
  	  ) {
  	    url.pathname = resolve(url.pathname, location.pathname);
  	  }
  	
  	  //
  	  // We should not add port numbers if they are already the default port number
  	  // for a given protocol. As the host also contains the port number we're going
  	  // override it with the hostname which contains no port number.
  	  //
  	  if (!required(url.port, url.protocol)) {
  	    url.host = url.hostname;
  	    url.port = '';
  	  }
  	
  	  //
  	  // Parse down the `auth` for the username and password.
  	  //
  	  url.username = url.password = '';
  	  if (url.auth) {
  	    instruction = url.auth.split(':');
  	    url.username = instruction[0] || '';
  	    url.password = instruction[1] || '';
  	  }
  	
  	  url.origin = url.protocol && url.host && url.protocol !== 'file:'
  	    ? url.protocol +'//'+ url.host
  	    : 'null';
  	
  	  //
  	  // The href is just the compiled result.
  	  //
  	  url.href = url.toString();
  	}
  	
  	/**
  	 * This is convenience method for changing properties in the URL instance to
  	 * insure that they all propagate correctly.
  	 *
  	 * @param {String} part          Property we need to adjust.
  	 * @param {Mixed} value          The newly assigned value.
  	 * @param {Boolean|Function} fn  When setting the query, it will be the function
  	 *                               used to parse the query.
  	 *                               When setting the protocol, double slash will be
  	 *                               removed from the final url if it is true.
  	 * @returns {URL}
  	 * @api public
  	 */
  	function set(part, value, fn) {
  	  var url = this;
  	
  	  switch (part) {
  	    case 'query':
  	      if ('string' === typeof value && value.length) {
  	        value = (fn || qs.parse)(value);
  	      }
  	
  	      url[part] = value;
  	      break;
  	
  	    case 'port':
  	      url[part] = value;
  	
  	      if (!required(value, url.protocol)) {
  	        url.host = url.hostname;
  	        url[part] = '';
  	      } else if (value) {
  	        url.host = url.hostname +':'+ value;
  	      }
  	
  	      break;
  	
  	    case 'hostname':
  	      url[part] = value;
  	
  	      if (url.port) value += ':'+ url.port;
  	      url.host = value;
  	      break;
  	
  	    case 'host':
  	      url[part] = value;
  	
  	      if (/:\d+$/.test(value)) {
  	        value = value.split(':');
  	        url.port = value.pop();
  	        url.hostname = value.join(':');
  	      } else {
  	        url.hostname = value;
  	        url.port = '';
  	      }
  	
  	      break;
  	
  	    case 'protocol':
  	      url.protocol = value.toLowerCase();
  	      url.slashes = !fn;
  	      break;
  	
  	    case 'pathname':
  	      url.pathname = value.length && value.charAt(0) !== '/' ? '/' + value : value;
  	
  	      break;
  	
  	    default:
  	      url[part] = value;
  	  }
  	
  	  for (var i = 0; i < rules.length; i++) {
  	    var ins = rules[i];
  	
  	    if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();
  	  }
  	
  	  url.origin = url.protocol && url.host && url.protocol !== 'file:'
  	    ? url.protocol +'//'+ url.host
  	    : 'null';
  	
  	  url.href = url.toString();
  	
  	  return url;
  	};
  	
  	/**
  	 * Transform the properties back in to a valid and full URL string.
  	 *
  	 * @param {Function} stringify Optional query stringify function.
  	 * @returns {String}
  	 * @api public
  	 */
  	function toString(stringify) {
  	  if (!stringify || 'function' !== typeof stringify) stringify = qs.stringify;
  	
  	  var query
  	    , url = this
  	    , protocol = url.protocol;
  	
  	  if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';
  	
  	  var result = protocol + (url.slashes ? '//' : '');
  	
  	  if (url.username) {
  	    result += url.username;
  	    if (url.password) result += ':'+ url.password;
  	    result += '@';
  	  }
  	
  	  result += url.host + url.pathname;
  	
  	  query = 'object' === typeof url.query ? stringify(url.query) : url.query;
  	  if (query) result += '?' !== query.charAt(0) ? '?'+ query : query;
  	
  	  if (url.hash) result += url.hash;
  	
  	  return result;
  	}
  	
  	URL.prototype = { set: set, toString: toString };
  	
  	//
  	// Expose the URL parser and some additional properties that might be useful for
  	// others or testing.
  	//
  	URL.extractProtocol = extractProtocol;
  	URL.location = lolcation;
  	URL.qs = qs;
  	
  	module.exports = URL;
  
  
  /***/ },
  /* 23 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	/**
  	 * Check if we're required to add a port number.
  	 *
  	 * @see https://url.spec.whatwg.org/#default-port
  	 * @param {Number|String} port Port number we need to check
  	 * @param {String} protocol Protocol we need to check against.
  	 * @returns {Boolean} Is it a default port for the given protocol
  	 * @api private
  	 */
  	module.exports = function required(port, protocol) {
  	  protocol = protocol.split(':')[0];
  	  port = +port;
  	
  	  if (!port) return false;
  	
  	  switch (protocol) {
  	    case 'http':
  	    case 'ws':
  	    return port !== 80;
  	
  	    case 'https':
  	    case 'wss':
  	    return port !== 443;
  	
  	    case 'ftp':
  	    return port !== 21;
  	
  	    case 'gopher':
  	    return port !== 70;
  	
  	    case 'file':
  	    return false;
  	  }
  	
  	  return port !== 0;
  	};
  
  
  /***/ },
  /* 24 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	var slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//;
  	
  	/**
  	 * These properties should not be copied or inherited from. This is only needed
  	 * for all non blob URL's as a blob URL does not include a hash, only the
  	 * origin.
  	 *
  	 * @type {Object}
  	 * @private
  	 */
  	var ignore = { hash: 1, query: 1 }
  	  , URL;
  	
  	/**
  	 * The location object differs when your code is loaded through a normal page,
  	 * Worker or through a worker using a blob. And with the blobble begins the
  	 * trouble as the location object will contain the URL of the blob, not the
  	 * location of the page where our code is loaded in. The actual origin is
  	 * encoded in the `pathname` so we can thankfully generate a good "default"
  	 * location from it so we can generate proper relative URL's again.
  	 *
  	 * @param {Object|String} loc Optional default location object.
  	 * @returns {Object} lolcation object.
  	 * @api public
  	 */
  	module.exports = function lolcation(loc) {
  	  loc = loc || global.location || {};
  	  URL = URL || __webpack_require__(22);
  	
  	  var finaldestination = {}
  	    , type = typeof loc
  	    , key;
  	
  	  if ('blob:' === loc.protocol) {
  	    finaldestination = new URL(unescape(loc.pathname), {});
  	  } else if ('string' === type) {
  	    finaldestination = new URL(loc, {});
  	    for (key in ignore) delete finaldestination[key];
  	  } else if ('object' === type) {
  	    for (key in loc) {
  	      if (key in ignore) continue;
  	      finaldestination[key] = loc[key];
  	    }
  	
  	    if (finaldestination.slashes === undefined) {
  	      finaldestination.slashes = slashes.test(loc.href);
  	    }
  	  }
  	
  	  return finaldestination;
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 25 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	var has = Object.prototype.hasOwnProperty;
  	
  	/**
  	 * Simple query string parser.
  	 *
  	 * @param {String} query The query string that needs to be parsed.
  	 * @returns {Object}
  	 * @api public
  	 */
  	function querystring(query) {
  	  var parser = /([^=?&]+)=?([^&]*)/g
  	    , result = {}
  	    , part;
  	
  	  //
  	  // Little nifty parsing hack, leverage the fact that RegExp.exec increments
  	  // the lastIndex property so we can continue executing this loop until we've
  	  // parsed all results.
  	  //
  	  for (;
  	    part = parser.exec(query);
  	    result[decodeURIComponent(part[1])] = decodeURIComponent(part[2])
  	  );
  	
  	  return result;
  	}
  	
  	/**
  	 * Transform a query string to an object.
  	 *
  	 * @param {Object} obj Object that should be transformed.
  	 * @param {String} prefix Optional prefix.
  	 * @returns {String}
  	 * @api public
  	 */
  	function querystringify(obj, prefix) {
  	  prefix = prefix || '';
  	
  	  var pairs = [];
  	
  	  //
  	  // Optionally prefix with a '?' if needed
  	  //
  	  if ('string' !== typeof prefix) prefix = '?';
  	
  	  for (var key in obj) {
  	    if (has.call(obj, key)) {
  	      pairs.push(encodeURIComponent(key) +'='+ encodeURIComponent(obj[key]));
  	    }
  	  }
  	
  	  return pairs.length ? prefix + pairs.join('&') : '';
  	}
  	
  	//
  	// Expose the module.
  	//
  	exports.stringify = querystringify;
  	exports.parse = querystring;
  
  
  /***/ },
  /* 26 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {/**
  	 * This is the web browser implementation of `debug()`.
  	 *
  	 * Expose `debug()` as the module.
  	 */
  	
  	exports = module.exports = __webpack_require__(27);
  	exports.log = log;
  	exports.formatArgs = formatArgs;
  	exports.save = save;
  	exports.load = load;
  	exports.useColors = useColors;
  	exports.storage = 'undefined' != typeof chrome
  	               && 'undefined' != typeof chrome.storage
  	                  ? chrome.storage.local
  	                  : localstorage();
  	
  	/**
  	 * Colors.
  	 */
  	
  	exports.colors = [
  	  'lightseagreen',
  	  'forestgreen',
  	  'goldenrod',
  	  'dodgerblue',
  	  'darkorchid',
  	  'crimson'
  	];
  	
  	/**
  	 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
  	 * and the Firebug extension (any Firefox version) are known
  	 * to support "%c" CSS customizations.
  	 *
  	 * TODO: add a `localStorage` variable to explicitly enable/disable colors
  	 */
  	
  	function useColors() {
  	  // NB: In an Electron preload script, document will be defined but not fully
  	  // initialized. Since we know we're in Chrome, we'll just detect this case
  	  // explicitly
  	  if (typeof window !== 'undefined' && window && typeof window.process !== 'undefined' && window.process.type === 'renderer') {
  	    return true;
  	  }
  	
  	  // is webkit? http://stackoverflow.com/a/16459606/376773
  	  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
  	  return (typeof document !== 'undefined' && document && 'WebkitAppearance' in document.documentElement.style) ||
  	    // is firebug? http://stackoverflow.com/a/398120/376773
  	    (typeof window !== 'undefined' && window && window.console && (console.firebug || (console.exception && console.table))) ||
  	    // is firefox >= v31?
  	    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
  	    (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
  	    // double check webkit in userAgent just in case we are in a worker
  	    (typeof navigator !== 'undefined' && navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
  	}
  	
  	/**
  	 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
  	 */
  	
  	exports.formatters.j = function(v) {
  	  try {
  	    return JSON.stringify(v);
  	  } catch (err) {
  	    return '[UnexpectedJSONParseError]: ' + err.message;
  	  }
  	};
  	
  	
  	/**
  	 * Colorize log arguments if enabled.
  	 *
  	 * @api public
  	 */
  	
  	function formatArgs(args) {
  	  var useColors = this.useColors;
  	
  	  args[0] = (useColors ? '%c' : '')
  	    + this.namespace
  	    + (useColors ? ' %c' : ' ')
  	    + args[0]
  	    + (useColors ? '%c ' : ' ')
  	    + '+' + exports.humanize(this.diff);
  	
  	  if (!useColors) return;
  	
  	  var c = 'color: ' + this.color;
  	  args.splice(1, 0, c, 'color: inherit')
  	
  	  // the final "%c" is somewhat tricky, because there could be other
  	  // arguments passed either before or after the %c, so we need to
  	  // figure out the correct index to insert the CSS into
  	  var index = 0;
  	  var lastC = 0;
  	  args[0].replace(/%[a-zA-Z%]/g, function(match) {
  	    if ('%%' === match) return;
  	    index++;
  	    if ('%c' === match) {
  	      // we only are interested in the *last* %c
  	      // (the user may have provided their own)
  	      lastC = index;
  	    }
  	  });
  	
  	  args.splice(lastC, 0, c);
  	}
  	
  	/**
  	 * Invokes `console.log()` when available.
  	 * No-op when `console.log` is not a "function".
  	 *
  	 * @api public
  	 */
  	
  	function log() {
  	  // this hackery is required for IE8/9, where
  	  // the `console.log` function doesn't have 'apply'
  	  return 'object' === typeof console
  	    && console.log
  	    && Function.prototype.apply.call(console.log, console, arguments);
  	}
  	
  	/**
  	 * Save `namespaces`.
  	 *
  	 * @param {String} namespaces
  	 * @api private
  	 */
  	
  	function save(namespaces) {
  	  try {
  	    if (null == namespaces) {
  	      exports.storage.removeItem('debug');
  	    } else {
  	      exports.storage.debug = namespaces;
  	    }
  	  } catch(e) {}
  	}
  	
  	/**
  	 * Load `namespaces`.
  	 *
  	 * @return {String} returns the previously persisted debug modes
  	 * @api private
  	 */
  	
  	function load() {
  	  try {
  	    return exports.storage.debug;
  	  } catch(e) {}
  	
  	  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
  	  if (typeof process !== 'undefined' && 'env' in process) {
  	    return process.env.DEBUG;
  	  }
  	}
  	
  	/**
  	 * Enable namespaces listed in `localStorage.debug` initially.
  	 */
  	
  	exports.enable(load());
  	
  	/**
  	 * Localstorage attempts to return the localstorage.
  	 *
  	 * This is necessary because safari throws
  	 * when a user disables cookies/localstorage
  	 * and you attempt to access it.
  	 *
  	 * @return {LocalStorage}
  	 * @api private
  	 */
  	
  	function localstorage() {
  	  try {
  	    return window.localStorage;
  	  } catch (e) {}
  	}
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 27 */
  /***/ function(module, exports, __webpack_require__) {
  
  	
  	/**
  	 * This is the common logic for both the Node.js and web browser
  	 * implementations of `debug()`.
  	 *
  	 * Expose `debug()` as the module.
  	 */
  	
  	exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
  	exports.coerce = coerce;
  	exports.disable = disable;
  	exports.enable = enable;
  	exports.enabled = enabled;
  	exports.humanize = __webpack_require__(28);
  	
  	/**
  	 * The currently active debug mode names, and names to skip.
  	 */
  	
  	exports.names = [];
  	exports.skips = [];
  	
  	/**
  	 * Map of special "%n" handling functions, for the debug "format" argument.
  	 *
  	 * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
  	 */
  	
  	exports.formatters = {};
  	
  	/**
  	 * Previous log timestamp.
  	 */
  	
  	var prevTime;
  	
  	/**
  	 * Select a color.
  	 * @param {String} namespace
  	 * @return {Number}
  	 * @api private
  	 */
  	
  	function selectColor(namespace) {
  	  var hash = 0, i;
  	
  	  for (i in namespace) {
  	    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);
  	    hash |= 0; // Convert to 32bit integer
  	  }
  	
  	  return exports.colors[Math.abs(hash) % exports.colors.length];
  	}
  	
  	/**
  	 * Create a debugger with the given `namespace`.
  	 *
  	 * @param {String} namespace
  	 * @return {Function}
  	 * @api public
  	 */
  	
  	function createDebug(namespace) {
  	
  	  function debug() {
  	    // disabled?
  	    if (!debug.enabled) return;
  	
  	    var self = debug;
  	
  	    // set `diff` timestamp
  	    var curr = +new Date();
  	    var ms = curr - (prevTime || curr);
  	    self.diff = ms;
  	    self.prev = prevTime;
  	    self.curr = curr;
  	    prevTime = curr;
  	
  	    // turn the `arguments` into a proper Array
  	    var args = new Array(arguments.length);
  	    for (var i = 0; i < args.length; i++) {
  	      args[i] = arguments[i];
  	    }
  	
  	    args[0] = exports.coerce(args[0]);
  	
  	    if ('string' !== typeof args[0]) {
  	      // anything else let's inspect with %O
  	      args.unshift('%O');
  	    }
  	
  	    // apply any `formatters` transformations
  	    var index = 0;
  	    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
  	      // if we encounter an escaped % then don't increase the array index
  	      if (match === '%%') return match;
  	      index++;
  	      var formatter = exports.formatters[format];
  	      if ('function' === typeof formatter) {
  	        var val = args[index];
  	        match = formatter.call(self, val);
  	
  	        // now we need to remove `args[index]` since it's inlined in the `format`
  	        args.splice(index, 1);
  	        index--;
  	      }
  	      return match;
  	    });
  	
  	    // apply env-specific formatting (colors, etc.)
  	    exports.formatArgs.call(self, args);
  	
  	    var logFn = debug.log || exports.log || console.log.bind(console);
  	    logFn.apply(self, args);
  	  }
  	
  	  debug.namespace = namespace;
  	  debug.enabled = exports.enabled(namespace);
  	  debug.useColors = exports.useColors();
  	  debug.color = selectColor(namespace);
  	
  	  // env-specific initialization logic for debug instances
  	  if ('function' === typeof exports.init) {
  	    exports.init(debug);
  	  }
  	
  	  return debug;
  	}
  	
  	/**
  	 * Enables a debug mode by namespaces. This can include modes
  	 * separated by a colon and wildcards.
  	 *
  	 * @param {String} namespaces
  	 * @api public
  	 */
  	
  	function enable(namespaces) {
  	  exports.save(namespaces);
  	
  	  exports.names = [];
  	  exports.skips = [];
  	
  	  var split = (namespaces || '').split(/[\s,]+/);
  	  var len = split.length;
  	
  	  for (var i = 0; i < len; i++) {
  	    if (!split[i]) continue; // ignore empty strings
  	    namespaces = split[i].replace(/\*/g, '.*?');
  	    if (namespaces[0] === '-') {
  	      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
  	    } else {
  	      exports.names.push(new RegExp('^' + namespaces + '$'));
  	    }
  	  }
  	}
  	
  	/**
  	 * Disable debug output.
  	 *
  	 * @api public
  	 */
  	
  	function disable() {
  	  exports.enable('');
  	}
  	
  	/**
  	 * Returns true if the given mode name is enabled, false otherwise.
  	 *
  	 * @param {String} name
  	 * @return {Boolean}
  	 * @api public
  	 */
  	
  	function enabled(name) {
  	  var i, len;
  	  for (i = 0, len = exports.skips.length; i < len; i++) {
  	    if (exports.skips[i].test(name)) {
  	      return false;
  	    }
  	  }
  	  for (i = 0, len = exports.names.length; i < len; i++) {
  	    if (exports.names[i].test(name)) {
  	      return true;
  	    }
  	  }
  	  return false;
  	}
  	
  	/**
  	 * Coerce `val`.
  	 *
  	 * @param {Mixed} val
  	 * @return {Mixed}
  	 * @api private
  	 */
  	
  	function coerce(val) {
  	  if (val instanceof Error) return val.stack || val.message;
  	  return val;
  	}
  
  
  /***/ },
  /* 28 */
  /***/ function(module, exports) {
  
  	/**
  	 * Helpers.
  	 */
  	
  	var s = 1000
  	var m = s * 60
  	var h = m * 60
  	var d = h * 24
  	var y = d * 365.25
  	
  	/**
  	 * Parse or format the given `val`.
  	 *
  	 * Options:
  	 *
  	 *  - `long` verbose formatting [false]
  	 *
  	 * @param {String|Number} val
  	 * @param {Object} options
  	 * @throws {Error} throw an error if val is not a non-empty string or a number
  	 * @return {String|Number}
  	 * @api public
  	 */
  	
  	module.exports = function (val, options) {
  	  options = options || {}
  	  var type = typeof val
  	  if (type === 'string' && val.length > 0) {
  	    return parse(val)
  	  } else if (type === 'number' && isNaN(val) === false) {
  	    return options.long ?
  				fmtLong(val) :
  				fmtShort(val)
  	  }
  	  throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))
  	}
  	
  	/**
  	 * Parse the given `str` and return milliseconds.
  	 *
  	 * @param {String} str
  	 * @return {Number}
  	 * @api private
  	 */
  	
  	function parse(str) {
  	  str = String(str)
  	  if (str.length > 10000) {
  	    return
  	  }
  	  var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)
  	  if (!match) {
  	    return
  	  }
  	  var n = parseFloat(match[1])
  	  var type = (match[2] || 'ms').toLowerCase()
  	  switch (type) {
  	    case 'years':
  	    case 'year':
  	    case 'yrs':
  	    case 'yr':
  	    case 'y':
  	      return n * y
  	    case 'days':
  	    case 'day':
  	    case 'd':
  	      return n * d
  	    case 'hours':
  	    case 'hour':
  	    case 'hrs':
  	    case 'hr':
  	    case 'h':
  	      return n * h
  	    case 'minutes':
  	    case 'minute':
  	    case 'mins':
  	    case 'min':
  	    case 'm':
  	      return n * m
  	    case 'seconds':
  	    case 'second':
  	    case 'secs':
  	    case 'sec':
  	    case 's':
  	      return n * s
  	    case 'milliseconds':
  	    case 'millisecond':
  	    case 'msecs':
  	    case 'msec':
  	    case 'ms':
  	      return n
  	    default:
  	      return undefined
  	  }
  	}
  	
  	/**
  	 * Short format for `ms`.
  	 *
  	 * @param {Number} ms
  	 * @return {String}
  	 * @api private
  	 */
  	
  	function fmtShort(ms) {
  	  if (ms >= d) {
  	    return Math.round(ms / d) + 'd'
  	  }
  	  if (ms >= h) {
  	    return Math.round(ms / h) + 'h'
  	  }
  	  if (ms >= m) {
  	    return Math.round(ms / m) + 'm'
  	  }
  	  if (ms >= s) {
  	    return Math.round(ms / s) + 's'
  	  }
  	  return ms + 'ms'
  	}
  	
  	/**
  	 * Long format for `ms`.
  	 *
  	 * @param {Number} ms
  	 * @return {String}
  	 * @api private
  	 */
  	
  	function fmtLong(ms) {
  	  return plural(ms, d, 'day') ||
  	    plural(ms, h, 'hour') ||
  	    plural(ms, m, 'minute') ||
  	    plural(ms, s, 'second') ||
  	    ms + ' ms'
  	}
  	
  	/**
  	 * Pluralization helper.
  	 */
  	
  	function plural(ms, n, name) {
  	  if (ms < n) {
  	    return
  	  }
  	  if (ms < n * 1.5) {
  	    return Math.floor(ms / n) + ' ' + name
  	  }
  	  return Math.ceil(ms / n) + ' ' + name + 's'
  	}
  
  
  /***/ },
  /* 29 */
  /***/ function(module, exports) {
  
  	if (typeof Object.create === 'function') {
  	  // implementation from standard node.js 'util' module
  	  module.exports = function inherits(ctor, superCtor) {
  	    ctor.super_ = superCtor
  	    ctor.prototype = Object.create(superCtor.prototype, {
  	      constructor: {
  	        value: ctor,
  	        enumerable: false,
  	        writable: true,
  	        configurable: true
  	      }
  	    });
  	  };
  	} else {
  	  // old school shim for old browsers
  	  module.exports = function inherits(ctor, superCtor) {
  	    ctor.super_ = superCtor
  	    var TempCtor = function () {}
  	    TempCtor.prototype = superCtor.prototype
  	    ctor.prototype = new TempCtor()
  	    ctor.prototype.constructor = ctor
  	  }
  	}
  
  
  /***/ },
  /* 30 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , EventTarget = __webpack_require__(31)
  	  ;
  	
  	function EventEmitter() {
  	  EventTarget.call(this);
  	}
  	
  	inherits(EventEmitter, EventTarget);
  	
  	EventEmitter.prototype.removeAllListeners = function(type) {
  	  if (type) {
  	    delete this._listeners[type];
  	  } else {
  	    this._listeners = {};
  	  }
  	};
  	
  	EventEmitter.prototype.once = function(type, listener) {
  	  var self = this
  	    , fired = false;
  	
  	  function g() {
  	    self.removeListener(type, g);
  	
  	    if (!fired) {
  	      fired = true;
  	      listener.apply(this, arguments);
  	    }
  	  }
  	
  	  this.on(type, g);
  	};
  	
  	EventEmitter.prototype.emit = function() {
  	  var type = arguments[0];
  	  var listeners = this._listeners[type];
  	  if (!listeners) {
  	    return;
  	  }
  	  // equivalent of Array.prototype.slice.call(arguments, 1);
  	  var l = arguments.length;
  	  var args = new Array(l - 1);
  	  for (var ai = 1; ai < l; ai++) {
  	    args[ai - 1] = arguments[ai];
  	  }
  	  for (var i = 0; i < listeners.length; i++) {
  	    listeners[i].apply(this, args);
  	  }
  	};
  	
  	EventEmitter.prototype.on = EventEmitter.prototype.addListener = EventTarget.prototype.addEventListener;
  	EventEmitter.prototype.removeListener = EventTarget.prototype.removeEventListener;
  	
  	module.exports.EventEmitter = EventEmitter;
  
  
  /***/ },
  /* 31 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	/* Simplified implementation of DOM2 EventTarget.
  	 *   http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-EventTarget
  	 */
  	
  	function EventTarget() {
  	  this._listeners = {};
  	}
  	
  	EventTarget.prototype.addEventListener = function(eventType, listener) {
  	  if (!(eventType in this._listeners)) {
  	    this._listeners[eventType] = [];
  	  }
  	  var arr = this._listeners[eventType];
  	  // #4
  	  if (arr.indexOf(listener) === -1) {
  	    // Make a copy so as not to interfere with a current dispatchEvent.
  	    arr = arr.concat([listener]);
  	  }
  	  this._listeners[eventType] = arr;
  	};
  	
  	EventTarget.prototype.removeEventListener = function(eventType, listener) {
  	  var arr = this._listeners[eventType];
  	  if (!arr) {
  	    return;
  	  }
  	  var idx = arr.indexOf(listener);
  	  if (idx !== -1) {
  	    if (arr.length > 1) {
  	      // Make a copy so as not to interfere with a current dispatchEvent.
  	      this._listeners[eventType] = arr.slice(0, idx).concat(arr.slice(idx + 1));
  	    } else {
  	      delete this._listeners[eventType];
  	    }
  	    return;
  	  }
  	};
  	
  	EventTarget.prototype.dispatchEvent = function() {
  	  var event = arguments[0];
  	  var t = event.type;
  	  // equivalent of Array.prototype.slice.call(arguments, 0);
  	  var args = arguments.length === 1 ? [event] : Array.apply(null, arguments);
  	  // TODO: This doesn't match the real behavior; per spec, onfoo get
  	  // their place in line from the /first/ time they're set from
  	  // non-null. Although WebKit bumps it to the end every time it's
  	  // set.
  	  if (this['on' + t]) {
  	    this['on' + t].apply(this, args);
  	  }
  	  if (t in this._listeners) {
  	    // Grab a reference to the listeners list. removeEventListener may alter the list.
  	    var listeners = this._listeners[t];
  	    for (var i = 0; i < listeners.length; i++) {
  	      listeners[i].apply(this, args);
  	    }
  	  }
  	};
  	
  	module.exports = EventTarget;
  
  
  /***/ },
  /* 32 */
  /***/ function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	var Driver = global.WebSocket || global.MozWebSocket;
  	if (Driver) {
  		module.exports = function WebSocketBrowserDriver(url) {
  			return new Driver(url);
  		};
  	} else {
  		module.exports = undefined;
  	}
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 33 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , AjaxBasedTransport = __webpack_require__(34)
  	  , XhrReceiver = __webpack_require__(38)
  	  , XHRCorsObject = __webpack_require__(39)
  	  , XHRLocalObject = __webpack_require__(41)
  	  , browser = __webpack_require__(42)
  	  ;
  	
  	function XhrStreamingTransport(transUrl) {
  	  if (!XHRLocalObject.enabled && !XHRCorsObject.enabled) {
  	    throw new Error('Transport created when disabled');
  	  }
  	  AjaxBasedTransport.call(this, transUrl, '/xhr_streaming', XhrReceiver, XHRCorsObject);
  	}
  	
  	inherits(XhrStreamingTransport, AjaxBasedTransport);
  	
  	XhrStreamingTransport.enabled = function(info) {
  	  if (info.nullOrigin) {
  	    return false;
  	  }
  	  // Opera doesn't support xhr-streaming #60
  	  // But it might be able to #92
  	  if (browser.isOpera()) {
  	    return false;
  	  }
  	
  	  return XHRCorsObject.enabled;
  	};
  	
  	XhrStreamingTransport.transportName = 'xhr-streaming';
  	XhrStreamingTransport.roundTrips = 2; // preflight, ajax
  	
  	// Safari gets confused when a streaming ajax request is started
  	// before onload. This causes the load indicator to spin indefinetely.
  	// Only require body when used in a browser
  	XhrStreamingTransport.needBody = !!global.document;
  	
  	module.exports = XhrStreamingTransport;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 34 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , urlUtils = __webpack_require__(21)
  	  , SenderReceiver = __webpack_require__(35)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:ajax-based');
  	}
  	
  	function createAjaxSender(AjaxObject) {
  	  return function(url, payload, callback) {
  	    debug('create ajax sender', url, payload);
  	    var opt = {};
  	    if (typeof payload === 'string') {
  	      opt.headers = {'Content-type': 'text/plain'};
  	    }
  	    var ajaxUrl = urlUtils.addPath(url, '/xhr_send');
  	    var xo = new AjaxObject('POST', ajaxUrl, payload, opt);
  	    xo.once('finish', function(status) {
  	      debug('finish', status);
  	      xo = null;
  	
  	      if (status !== 200 && status !== 204) {
  	        return callback(new Error('http status ' + status));
  	      }
  	      callback();
  	    });
  	    return function() {
  	      debug('abort');
  	      xo.close();
  	      xo = null;
  	
  	      var err = new Error('Aborted');
  	      err.code = 1000;
  	      callback(err);
  	    };
  	  };
  	}
  	
  	function AjaxBasedTransport(transUrl, urlSuffix, Receiver, AjaxObject) {
  	  SenderReceiver.call(this, transUrl, urlSuffix, createAjaxSender(AjaxObject), Receiver, AjaxObject);
  	}
  	
  	inherits(AjaxBasedTransport, SenderReceiver);
  	
  	module.exports = AjaxBasedTransport;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 35 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , urlUtils = __webpack_require__(21)
  	  , BufferedSender = __webpack_require__(36)
  	  , Polling = __webpack_require__(37)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:sender-receiver');
  	}
  	
  	function SenderReceiver(transUrl, urlSuffix, senderFunc, Receiver, AjaxObject) {
  	  var pollUrl = urlUtils.addPath(transUrl, urlSuffix);
  	  debug(pollUrl);
  	  var self = this;
  	  BufferedSender.call(this, transUrl, senderFunc);
  	
  	  this.poll = new Polling(Receiver, pollUrl, AjaxObject);
  	  this.poll.on('message', function(msg) {
  	    debug('poll message', msg);
  	    self.emit('message', msg);
  	  });
  	  this.poll.once('close', function(code, reason) {
  	    debug('poll close', code, reason);
  	    self.poll = null;
  	    self.emit('close', code, reason);
  	    self.close();
  	  });
  	}
  	
  	inherits(SenderReceiver, BufferedSender);
  	
  	SenderReceiver.prototype.close = function() {
  	  BufferedSender.prototype.close.call(this);
  	  debug('close');
  	  this.removeAllListeners();
  	  if (this.poll) {
  	    this.poll.abort();
  	    this.poll = null;
  	  }
  	};
  	
  	module.exports = SenderReceiver;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 36 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , EventEmitter = __webpack_require__(30).EventEmitter
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:buffered-sender');
  	}
  	
  	function BufferedSender(url, sender) {
  	  debug(url);
  	  EventEmitter.call(this);
  	  this.sendBuffer = [];
  	  this.sender = sender;
  	  this.url = url;
  	}
  	
  	inherits(BufferedSender, EventEmitter);
  	
  	BufferedSender.prototype.send = function(message) {
  	  debug('send', message);
  	  this.sendBuffer.push(message);
  	  if (!this.sendStop) {
  	    this.sendSchedule();
  	  }
  	};
  	
  	// For polling transports in a situation when in the message callback,
  	// new message is being send. If the sending connection was started
  	// before receiving one, it is possible to saturate the network and
  	// timeout due to the lack of receiving socket. To avoid that we delay
  	// sending messages by some small time, in order to let receiving
  	// connection be started beforehand. This is only a halfmeasure and
  	// does not fix the big problem, but it does make the tests go more
  	// stable on slow networks.
  	BufferedSender.prototype.sendScheduleWait = function() {
  	  debug('sendScheduleWait');
  	  var self = this;
  	  var tref;
  	  this.sendStop = function() {
  	    debug('sendStop');
  	    self.sendStop = null;
  	    clearTimeout(tref);
  	  };
  	  tref = setTimeout(function() {
  	    debug('timeout');
  	    self.sendStop = null;
  	    self.sendSchedule();
  	  }, 25);
  	};
  	
  	BufferedSender.prototype.sendSchedule = function() {
  	  debug('sendSchedule', this.sendBuffer.length);
  	  var self = this;
  	  if (this.sendBuffer.length > 0) {
  	    var payload = '[' + this.sendBuffer.join(',') + ']';
  	    this.sendStop = this.sender(this.url, payload, function(err) {
  	      self.sendStop = null;
  	      if (err) {
  	        debug('error', err);
  	        self.emit('close', err.code || 1006, 'Sending error: ' + err);
  	        self.close();
  	      } else {
  	        self.sendScheduleWait();
  	      }
  	    });
  	    this.sendBuffer = [];
  	  }
  	};
  	
  	BufferedSender.prototype._cleanup = function() {
  	  debug('_cleanup');
  	  this.removeAllListeners();
  	};
  	
  	BufferedSender.prototype.close = function() {
  	  debug('close');
  	  this._cleanup();
  	  if (this.sendStop) {
  	    this.sendStop();
  	    this.sendStop = null;
  	  }
  	};
  	
  	module.exports = BufferedSender;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 37 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , EventEmitter = __webpack_require__(30).EventEmitter
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:polling');
  	}
  	
  	function Polling(Receiver, receiveUrl, AjaxObject) {
  	  debug(receiveUrl);
  	  EventEmitter.call(this);
  	  this.Receiver = Receiver;
  	  this.receiveUrl = receiveUrl;
  	  this.AjaxObject = AjaxObject;
  	  this._scheduleReceiver();
  	}
  	
  	inherits(Polling, EventEmitter);
  	
  	Polling.prototype._scheduleReceiver = function() {
  	  debug('_scheduleReceiver');
  	  var self = this;
  	  var poll = this.poll = new this.Receiver(this.receiveUrl, this.AjaxObject);
  	
  	  poll.on('message', function(msg) {
  	    debug('message', msg);
  	    self.emit('message', msg);
  	  });
  	
  	  poll.once('close', function(code, reason) {
  	    debug('close', code, reason, self.pollIsClosing);
  	    self.poll = poll = null;
  	
  	    if (!self.pollIsClosing) {
  	      if (reason === 'network') {
  	        self._scheduleReceiver();
  	      } else {
  	        self.emit('close', code || 1006, reason);
  	        self.removeAllListeners();
  	      }
  	    }
  	  });
  	};
  	
  	Polling.prototype.abort = function() {
  	  debug('abort');
  	  this.removeAllListeners();
  	  this.pollIsClosing = true;
  	  if (this.poll) {
  	    this.poll.abort();
  	  }
  	};
  	
  	module.exports = Polling;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 38 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , EventEmitter = __webpack_require__(30).EventEmitter
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:receiver:xhr');
  	}
  	
  	function XhrReceiver(url, AjaxObject) {
  	  debug(url);
  	  EventEmitter.call(this);
  	  var self = this;
  	
  	  this.bufferPosition = 0;
  	
  	  this.xo = new AjaxObject('POST', url, null);
  	  this.xo.on('chunk', this._chunkHandler.bind(this));
  	  this.xo.once('finish', function(status, text) {
  	    debug('finish', status, text);
  	    self._chunkHandler(status, text);
  	    self.xo = null;
  	    var reason = status === 200 ? 'network' : 'permanent';
  	    debug('close', reason);
  	    self.emit('close', null, reason);
  	    self._cleanup();
  	  });
  	}
  	
  	inherits(XhrReceiver, EventEmitter);
  	
  	XhrReceiver.prototype._chunkHandler = function(status, text) {
  	  debug('_chunkHandler', status);
  	  if (status !== 200 || !text) {
  	    return;
  	  }
  	
  	  for (var idx = -1; ; this.bufferPosition += idx + 1) {
  	    var buf = text.slice(this.bufferPosition);
  	    idx = buf.indexOf('\n');
  	    if (idx === -1) {
  	      break;
  	    }
  	    var msg = buf.slice(0, idx);
  	    if (msg) {
  	      debug('message', msg);
  	      this.emit('message', msg);
  	    }
  	  }
  	};
  	
  	XhrReceiver.prototype._cleanup = function() {
  	  debug('_cleanup');
  	  this.removeAllListeners();
  	};
  	
  	XhrReceiver.prototype.abort = function() {
  	  debug('abort');
  	  if (this.xo) {
  	    this.xo.close();
  	    debug('close');
  	    this.emit('close', null, 'user');
  	    this.xo = null;
  	  }
  	  this._cleanup();
  	};
  	
  	module.exports = XhrReceiver;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 39 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , XhrDriver = __webpack_require__(40)
  	  ;
  	
  	function XHRCorsObject(method, url, payload, opts) {
  	  XhrDriver.call(this, method, url, payload, opts);
  	}
  	
  	inherits(XHRCorsObject, XhrDriver);
  	
  	XHRCorsObject.enabled = XhrDriver.enabled && XhrDriver.supportsCORS;
  	
  	module.exports = XHRCorsObject;
  
  
  /***/ },
  /* 40 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global, process) {'use strict';
  	
  	var EventEmitter = __webpack_require__(30).EventEmitter
  	  , inherits = __webpack_require__(29)
  	  , utils = __webpack_require__(18)
  	  , urlUtils = __webpack_require__(21)
  	  , XHR = global.XMLHttpRequest
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:browser:xhr');
  	}
  	
  	function AbstractXHRObject(method, url, payload, opts) {
  	  debug(method, url);
  	  var self = this;
  	  EventEmitter.call(this);
  	
  	  setTimeout(function () {
  	    self._start(method, url, payload, opts);
  	  }, 0);
  	}
  	
  	inherits(AbstractXHRObject, EventEmitter);
  	
  	AbstractXHRObject.prototype._start = function(method, url, payload, opts) {
  	  var self = this;
  	
  	  try {
  	    this.xhr = new XHR();
  	  } catch (x) {
  	    // intentionally empty
  	  }
  	
  	  if (!this.xhr) {
  	    debug('no xhr');
  	    this.emit('finish', 0, 'no xhr support');
  	    this._cleanup();
  	    return;
  	  }
  	
  	  // several browsers cache POSTs
  	  url = urlUtils.addQuery(url, 't=' + (+new Date()));
  	
  	  // Explorer tends to keep connection open, even after the
  	  // tab gets closed: http://bugs.jquery.com/ticket/5280
  	  this.unloadRef = utils.unloadAdd(function() {
  	    debug('unload cleanup');
  	    self._cleanup(true);
  	  });
  	  try {
  	    this.xhr.open(method, url, true);
  	    if (this.timeout && 'timeout' in this.xhr) {
  	      this.xhr.timeout = this.timeout;
  	      this.xhr.ontimeout = function() {
  	        debug('xhr timeout');
  	        self.emit('finish', 0, '');
  	        self._cleanup(false);
  	      };
  	    }
  	  } catch (e) {
  	    debug('exception', e);
  	    // IE raises an exception on wrong port.
  	    this.emit('finish', 0, '');
  	    this._cleanup(false);
  	    return;
  	  }
  	
  	  if ((!opts || !opts.noCredentials) && AbstractXHRObject.supportsCORS) {
  	    debug('withCredentials');
  	    // Mozilla docs says https://developer.mozilla.org/en/XMLHttpRequest :
  	    // "This never affects same-site requests."
  	
  	    this.xhr.withCredentials = 'true';
  	  }
  	  if (opts && opts.headers) {
  	    for (var key in opts.headers) {
  	      this.xhr.setRequestHeader(key, opts.headers[key]);
  	    }
  	  }
  	
  	  this.xhr.onreadystatechange = function() {
  	    if (self.xhr) {
  	      var x = self.xhr;
  	      var text, status;
  	      debug('readyState', x.readyState);
  	      switch (x.readyState) {
  	      case 3:
  	        // IE doesn't like peeking into responseText or status
  	        // on Microsoft.XMLHTTP and readystate=3
  	        try {
  	          status = x.status;
  	          text = x.responseText;
  	        } catch (e) {
  	          // intentionally empty
  	        }
  	        debug('status', status);
  	        // IE returns 1223 for 204: http://bugs.jquery.com/ticket/1450
  	        if (status === 1223) {
  	          status = 204;
  	        }
  	
  	        // IE does return readystate == 3 for 404 answers.
  	        if (status === 200 && text && text.length > 0) {
  	          debug('chunk');
  	          self.emit('chunk', status, text);
  	        }
  	        break;
  	      case 4:
  	        status = x.status;
  	        debug('status', status);
  	        // IE returns 1223 for 204: http://bugs.jquery.com/ticket/1450
  	        if (status === 1223) {
  	          status = 204;
  	        }
  	        // IE returns this for a bad port
  	        // http://msdn.microsoft.com/en-us/library/windows/desktop/aa383770(v=vs.85).aspx
  	        if (status === 12005 || status === 12029) {
  	          status = 0;
  	        }
  	
  	        debug('finish', status, x.responseText);
  	        self.emit('finish', status, x.responseText);
  	        self._cleanup(false);
  	        break;
  	      }
  	    }
  	  };
  	
  	  try {
  	    self.xhr.send(payload);
  	  } catch (e) {
  	    self.emit('finish', 0, '');
  	    self._cleanup(false);
  	  }
  	};
  	
  	AbstractXHRObject.prototype._cleanup = function(abort) {
  	  debug('cleanup');
  	  if (!this.xhr) {
  	    return;
  	  }
  	  this.removeAllListeners();
  	  utils.unloadDel(this.unloadRef);
  	
  	  // IE needs this field to be a function
  	  this.xhr.onreadystatechange = function() {};
  	  if (this.xhr.ontimeout) {
  	    this.xhr.ontimeout = null;
  	  }
  	
  	  if (abort) {
  	    try {
  	      this.xhr.abort();
  	    } catch (x) {
  	      // intentionally empty
  	    }
  	  }
  	  this.unloadRef = this.xhr = null;
  	};
  	
  	AbstractXHRObject.prototype.close = function() {
  	  debug('close');
  	  this._cleanup(true);
  	};
  	
  	AbstractXHRObject.enabled = !!XHR;
  	// override XMLHttpRequest for IE6/7
  	// obfuscate to avoid firewalls
  	var axo = ['Active'].concat('Object').join('X');
  	if (!AbstractXHRObject.enabled && (axo in global)) {
  	  debug('overriding xmlhttprequest');
  	  XHR = function() {
  	    try {
  	      return new global[axo]('Microsoft.XMLHTTP');
  	    } catch (e) {
  	      return null;
  	    }
  	  };
  	  AbstractXHRObject.enabled = !!new XHR();
  	}
  	
  	var cors = false;
  	try {
  	  cors = 'withCredentials' in new XHR();
  	} catch (ignored) {
  	  // intentionally empty
  	}
  	
  	AbstractXHRObject.supportsCORS = cors;
  	
  	module.exports = AbstractXHRObject;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(17)))
  
  /***/ },
  /* 41 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , XhrDriver = __webpack_require__(40)
  	  ;
  	
  	function XHRLocalObject(method, url, payload /*, opts */) {
  	  XhrDriver.call(this, method, url, payload, {
  	    noCredentials: true
  	  });
  	}
  	
  	inherits(XHRLocalObject, XhrDriver);
  	
  	XHRLocalObject.enabled = XhrDriver.enabled;
  	
  	module.exports = XHRLocalObject;
  
  
  /***/ },
  /* 42 */
  /***/ function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	module.exports = {
  	  isOpera: function() {
  	    return global.navigator &&
  	      /opera/i.test(global.navigator.userAgent);
  	  }
  	
  	, isKonqueror: function() {
  	    return global.navigator &&
  	      /konqueror/i.test(global.navigator.userAgent);
  	  }
  	
  	  // #187 wrap document.domain in try/catch because of WP8 from file:///
  	, hasDomain: function () {
  	    // non-browser client always has a domain
  	    if (!global.document) {
  	      return true;
  	    }
  	
  	    try {
  	      return !!global.document.domain;
  	    } catch (e) {
  	      return false;
  	    }
  	  }
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 43 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , AjaxBasedTransport = __webpack_require__(34)
  	  , XhrReceiver = __webpack_require__(38)
  	  , XDRObject = __webpack_require__(44)
  	  ;
  	
  	// According to:
  	//   http://stackoverflow.com/questions/1641507/detect-browser-support-for-cross-domain-xmlhttprequests
  	//   http://hacks.mozilla.org/2009/07/cross-site-xmlhttprequest-with-cors/
  	
  	function XdrStreamingTransport(transUrl) {
  	  if (!XDRObject.enabled) {
  	    throw new Error('Transport created when disabled');
  	  }
  	  AjaxBasedTransport.call(this, transUrl, '/xhr_streaming', XhrReceiver, XDRObject);
  	}
  	
  	inherits(XdrStreamingTransport, AjaxBasedTransport);
  	
  	XdrStreamingTransport.enabled = function(info) {
  	  if (info.cookie_needed || info.nullOrigin) {
  	    return false;
  	  }
  	  return XDRObject.enabled && info.sameScheme;
  	};
  	
  	XdrStreamingTransport.transportName = 'xdr-streaming';
  	XdrStreamingTransport.roundTrips = 2; // preflight, ajax
  	
  	module.exports = XdrStreamingTransport;
  
  
  /***/ },
  /* 44 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process, global) {'use strict';
  	
  	var EventEmitter = __webpack_require__(30).EventEmitter
  	  , inherits = __webpack_require__(29)
  	  , eventUtils = __webpack_require__(18)
  	  , browser = __webpack_require__(42)
  	  , urlUtils = __webpack_require__(21)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:sender:xdr');
  	}
  	
  	// References:
  	//   http://ajaxian.com/archives/100-line-ajax-wrapper
  	//   http://msdn.microsoft.com/en-us/library/cc288060(v=VS.85).aspx
  	
  	function XDRObject(method, url, payload) {
  	  debug(method, url);
  	  var self = this;
  	  EventEmitter.call(this);
  	
  	  setTimeout(function() {
  	    self._start(method, url, payload);
  	  }, 0);
  	}
  	
  	inherits(XDRObject, EventEmitter);
  	
  	XDRObject.prototype._start = function(method, url, payload) {
  	  debug('_start');
  	  var self = this;
  	  var xdr = new global.XDomainRequest();
  	  // IE caches even POSTs
  	  url = urlUtils.addQuery(url, 't=' + (+new Date()));
  	
  	  xdr.onerror = function() {
  	    debug('onerror');
  	    self._error();
  	  };
  	  xdr.ontimeout = function() {
  	    debug('ontimeout');
  	    self._error();
  	  };
  	  xdr.onprogress = function() {
  	    debug('progress', xdr.responseText);
  	    self.emit('chunk', 200, xdr.responseText);
  	  };
  	  xdr.onload = function() {
  	    debug('load');
  	    self.emit('finish', 200, xdr.responseText);
  	    self._cleanup(false);
  	  };
  	  this.xdr = xdr;
  	  this.unloadRef = eventUtils.unloadAdd(function() {
  	    self._cleanup(true);
  	  });
  	  try {
  	    // Fails with AccessDenied if port number is bogus
  	    this.xdr.open(method, url);
  	    if (this.timeout) {
  	      this.xdr.timeout = this.timeout;
  	    }
  	    this.xdr.send(payload);
  	  } catch (x) {
  	    this._error();
  	  }
  	};
  	
  	XDRObject.prototype._error = function() {
  	  this.emit('finish', 0, '');
  	  this._cleanup(false);
  	};
  	
  	XDRObject.prototype._cleanup = function(abort) {
  	  debug('cleanup', abort);
  	  if (!this.xdr) {
  	    return;
  	  }
  	  this.removeAllListeners();
  	  eventUtils.unloadDel(this.unloadRef);
  	
  	  this.xdr.ontimeout = this.xdr.onerror = this.xdr.onprogress = this.xdr.onload = null;
  	  if (abort) {
  	    try {
  	      this.xdr.abort();
  	    } catch (x) {
  	      // intentionally empty
  	    }
  	  }
  	  this.unloadRef = this.xdr = null;
  	};
  	
  	XDRObject.prototype.close = function() {
  	  debug('close');
  	  this._cleanup(true);
  	};
  	
  	// IE 8/9 if the request target uses the same scheme - #79
  	XDRObject.enabled = !!(global.XDomainRequest && browser.hasDomain());
  	
  	module.exports = XDRObject;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17), (function() { return this; }())))
  
  /***/ },
  /* 45 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , AjaxBasedTransport = __webpack_require__(34)
  	  , EventSourceReceiver = __webpack_require__(46)
  	  , XHRCorsObject = __webpack_require__(39)
  	  , EventSourceDriver = __webpack_require__(47)
  	  ;
  	
  	function EventSourceTransport(transUrl) {
  	  if (!EventSourceTransport.enabled()) {
  	    throw new Error('Transport created when disabled');
  	  }
  	
  	  AjaxBasedTransport.call(this, transUrl, '/eventsource', EventSourceReceiver, XHRCorsObject);
  	}
  	
  	inherits(EventSourceTransport, AjaxBasedTransport);
  	
  	EventSourceTransport.enabled = function() {
  	  return !!EventSourceDriver;
  	};
  	
  	EventSourceTransport.transportName = 'eventsource';
  	EventSourceTransport.roundTrips = 2;
  	
  	module.exports = EventSourceTransport;
  
  
  /***/ },
  /* 46 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , EventEmitter = __webpack_require__(30).EventEmitter
  	  , EventSourceDriver = __webpack_require__(47)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:receiver:eventsource');
  	}
  	
  	function EventSourceReceiver(url) {
  	  debug(url);
  	  EventEmitter.call(this);
  	
  	  var self = this;
  	  var es = this.es = new EventSourceDriver(url);
  	  es.onmessage = function(e) {
  	    debug('message', e.data);
  	    self.emit('message', decodeURI(e.data));
  	  };
  	  es.onerror = function(e) {
  	    debug('error', es.readyState, e);
  	    // ES on reconnection has readyState = 0 or 1.
  	    // on network error it's CLOSED = 2
  	    var reason = (es.readyState !== 2 ? 'network' : 'permanent');
  	    self._cleanup();
  	    self._close(reason);
  	  };
  	}
  	
  	inherits(EventSourceReceiver, EventEmitter);
  	
  	EventSourceReceiver.prototype.abort = function() {
  	  debug('abort');
  	  this._cleanup();
  	  this._close('user');
  	};
  	
  	EventSourceReceiver.prototype._cleanup = function() {
  	  debug('cleanup');
  	  var es = this.es;
  	  if (es) {
  	    es.onmessage = es.onerror = null;
  	    es.close();
  	    this.es = null;
  	  }
  	};
  	
  	EventSourceReceiver.prototype._close = function(reason) {
  	  debug('close', reason);
  	  var self = this;
  	  // Safari and chrome < 15 crash if we close window before
  	  // waiting for ES cleanup. See:
  	  // https://code.google.com/p/chromium/issues/detail?id=89155
  	  setTimeout(function() {
  	    self.emit('close', null, reason);
  	    self.removeAllListeners();
  	  }, 200);
  	};
  	
  	module.exports = EventSourceReceiver;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 47 */
  /***/ function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {module.exports = global.EventSource;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 48 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , IframeTransport = __webpack_require__(49)
  	  , objectUtils = __webpack_require__(54)
  	  ;
  	
  	module.exports = function(transport) {
  	
  	  function IframeWrapTransport(transUrl, baseUrl) {
  	    IframeTransport.call(this, transport.transportName, transUrl, baseUrl);
  	  }
  	
  	  inherits(IframeWrapTransport, IframeTransport);
  	
  	  IframeWrapTransport.enabled = function(url, info) {
  	    if (!global.document) {
  	      return false;
  	    }
  	
  	    var iframeInfo = objectUtils.extend({}, info);
  	    iframeInfo.sameOrigin = true;
  	    return transport.enabled(iframeInfo) && IframeTransport.enabled();
  	  };
  	
  	  IframeWrapTransport.transportName = 'iframe-' + transport.transportName;
  	  IframeWrapTransport.needBody = true;
  	  IframeWrapTransport.roundTrips = IframeTransport.roundTrips + transport.roundTrips - 1; // html, javascript (2) + transport - no CORS (1)
  	
  	  IframeWrapTransport.facadeTransport = transport;
  	
  	  return IframeWrapTransport;
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 49 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	// Few cool transports do work only for same-origin. In order to make
  	// them work cross-domain we shall use iframe, served from the
  	// remote domain. New browsers have capabilities to communicate with
  	// cross domain iframe using postMessage(). In IE it was implemented
  	// from IE 8+, but of course, IE got some details wrong:
  	//    http://msdn.microsoft.com/en-us/library/cc197015(v=VS.85).aspx
  	//    http://stevesouders.com/misc/test-postmessage.php
  	
  	var inherits = __webpack_require__(29)
  	  , JSON3 = __webpack_require__(50)
  	  , EventEmitter = __webpack_require__(30).EventEmitter
  	  , version = __webpack_require__(52)
  	  , urlUtils = __webpack_require__(21)
  	  , iframeUtils = __webpack_require__(53)
  	  , eventUtils = __webpack_require__(18)
  	  , random = __webpack_require__(19)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:transport:iframe');
  	}
  	
  	function IframeTransport(transport, transUrl, baseUrl) {
  	  if (!IframeTransport.enabled()) {
  	    throw new Error('Transport created when disabled');
  	  }
  	  EventEmitter.call(this);
  	
  	  var self = this;
  	  this.origin = urlUtils.getOrigin(baseUrl);
  	  this.baseUrl = baseUrl;
  	  this.transUrl = transUrl;
  	  this.transport = transport;
  	  this.windowId = random.string(8);
  	
  	  var iframeUrl = urlUtils.addPath(baseUrl, '/iframe.html') + '#' + this.windowId;
  	  debug(transport, transUrl, iframeUrl);
  	
  	  this.iframeObj = iframeUtils.createIframe(iframeUrl, function(r) {
  	    debug('err callback');
  	    self.emit('close', 1006, 'Unable to load an iframe (' + r + ')');
  	    self.close();
  	  });
  	
  	  this.onmessageCallback = this._message.bind(this);
  	  eventUtils.attachEvent('message', this.onmessageCallback);
  	}
  	
  	inherits(IframeTransport, EventEmitter);
  	
  	IframeTransport.prototype.close = function() {
  	  debug('close');
  	  this.removeAllListeners();
  	  if (this.iframeObj) {
  	    eventUtils.detachEvent('message', this.onmessageCallback);
  	    try {
  	      // When the iframe is not loaded, IE raises an exception
  	      // on 'contentWindow'.
  	      this.postMessage('c');
  	    } catch (x) {
  	      // intentionally empty
  	    }
  	    this.iframeObj.cleanup();
  	    this.iframeObj = null;
  	    this.onmessageCallback = this.iframeObj = null;
  	  }
  	};
  	
  	IframeTransport.prototype._message = function(e) {
  	  debug('message', e.data);
  	  if (!urlUtils.isOriginEqual(e.origin, this.origin)) {
  	    debug('not same origin', e.origin, this.origin);
  	    return;
  	  }
  	
  	  var iframeMessage;
  	  try {
  	    iframeMessage = JSON3.parse(e.data);
  	  } catch (ignored) {
  	    debug('bad json', e.data);
  	    return;
  	  }
  	
  	  if (iframeMessage.windowId !== this.windowId) {
  	    debug('mismatched window id', iframeMessage.windowId, this.windowId);
  	    return;
  	  }
  	
  	  switch (iframeMessage.type) {
  	  case 's':
  	    this.iframeObj.loaded();
  	    // window global dependency
  	    this.postMessage('s', JSON3.stringify([
  	      version
  	    , this.transport
  	    , this.transUrl
  	    , this.baseUrl
  	    ]));
  	    break;
  	  case 't':
  	    this.emit('message', iframeMessage.data);
  	    break;
  	  case 'c':
  	    var cdata;
  	    try {
  	      cdata = JSON3.parse(iframeMessage.data);
  	    } catch (ignored) {
  	      debug('bad json', iframeMessage.data);
  	      return;
  	    }
  	    this.emit('close', cdata[0], cdata[1]);
  	    this.close();
  	    break;
  	  }
  	};
  	
  	IframeTransport.prototype.postMessage = function(type, data) {
  	  debug('postMessage', type, data);
  	  this.iframeObj.post(JSON3.stringify({
  	    windowId: this.windowId
  	  , type: type
  	  , data: data || ''
  	  }), this.origin);
  	};
  	
  	IframeTransport.prototype.send = function(message) {
  	  debug('send', message);
  	  this.postMessage('m', message);
  	};
  	
  	IframeTransport.enabled = function() {
  	  return iframeUtils.iframeEnabled;
  	};
  	
  	IframeTransport.transportName = 'iframe';
  	IframeTransport.roundTrips = 2;
  	
  	module.exports = IframeTransport;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 50 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module, global) {/*! JSON v3.3.2 | http://bestiejs.github.io/json3 | Copyright 2012-2014, Kit Cambridge | http://kit.mit-license.org */
  	;(function () {
  	  // Detect the `define` function exposed by asynchronous module loaders. The
  	  // strict `define` check is necessary for compatibility with `r.js`.
  	  var isLoader = "function" === "function" && __webpack_require__(51);
  	
  	  // A set of types used to distinguish objects from primitives.
  	  var objectTypes = {
  	    "function": true,
  	    "object": true
  	  };
  	
  	  // Detect the `exports` object exposed by CommonJS implementations.
  	  var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
  	
  	  // Use the `global` object exposed by Node (including Browserify via
  	  // `insert-module-globals`), Narwhal, and Ringo as the default context,
  	  // and the `window` object in browsers. Rhino exports a `global` function
  	  // instead.
  	  var root = objectTypes[typeof window] && window || this,
  	      freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == "object" && global;
  	
  	  if (freeGlobal && (freeGlobal["global"] === freeGlobal || freeGlobal["window"] === freeGlobal || freeGlobal["self"] === freeGlobal)) {
  	    root = freeGlobal;
  	  }
  	
  	  // Public: Initializes JSON 3 using the given `context` object, attaching the
  	  // `stringify` and `parse` functions to the specified `exports` object.
  	  function runInContext(context, exports) {
  	    context || (context = root["Object"]());
  	    exports || (exports = root["Object"]());
  	
  	    // Native constructor aliases.
  	    var Number = context["Number"] || root["Number"],
  	        String = context["String"] || root["String"],
  	        Object = context["Object"] || root["Object"],
  	        Date = context["Date"] || root["Date"],
  	        SyntaxError = context["SyntaxError"] || root["SyntaxError"],
  	        TypeError = context["TypeError"] || root["TypeError"],
  	        Math = context["Math"] || root["Math"],
  	        nativeJSON = context["JSON"] || root["JSON"];
  	
  	    // Delegate to the native `stringify` and `parse` implementations.
  	    if (typeof nativeJSON == "object" && nativeJSON) {
  	      exports.stringify = nativeJSON.stringify;
  	      exports.parse = nativeJSON.parse;
  	    }
  	
  	    // Convenience aliases.
  	    var objectProto = Object.prototype,
  	        getClass = objectProto.toString,
  	        isProperty, forEach, undef;
  	
  	    // Test the `Date#getUTC*` methods. Based on work by @Yaffle.
  	    var isExtended = new Date(-3509827334573292);
  	    try {
  	      // The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical
  	      // results for certain dates in Opera >= 10.53.
  	      isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&
  	        // Safari < 2.0.2 stores the internal millisecond time value correctly,
  	        // but clips the values returned by the date methods to the range of
  	        // signed 32-bit integers ([-2 ** 31, 2 ** 31 - 1]).
  	        isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;
  	    } catch (exception) {}
  	
  	    // Internal: Determines whether the native `JSON.stringify` and `parse`
  	    // implementations are spec-compliant. Based on work by Ken Snyder.
  	    function has(name) {
  	      if (has[name] !== undef) {
  	        // Return cached feature test result.
  	        return has[name];
  	      }
  	      var isSupported;
  	      if (name == "bug-string-char-index") {
  	        // IE <= 7 doesn't support accessing string characters using square
  	        // bracket notation. IE 8 only supports this for primitives.
  	        isSupported = "a"[0] != "a";
  	      } else if (name == "json") {
  	        // Indicates whether both `JSON.stringify` and `JSON.parse` are
  	        // supported.
  	        isSupported = has("json-stringify") && has("json-parse");
  	      } else {
  	        var value, serialized = '{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}';
  	        // Test `JSON.stringify`.
  	        if (name == "json-stringify") {
  	          var stringify = exports.stringify, stringifySupported = typeof stringify == "function" && isExtended;
  	          if (stringifySupported) {
  	            // A test function object with a custom `toJSON` method.
  	            (value = function () {
  	              return 1;
  	            }).toJSON = value;
  	            try {
  	              stringifySupported =
  	                // Firefox 3.1b1 and b2 serialize string, number, and boolean
  	                // primitives as object literals.
  	                stringify(0) === "0" &&
  	                // FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object
  	                // literals.
  	                stringify(new Number()) === "0" &&
  	                stringify(new String()) == '""' &&
  	                // FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or
  	                // does not define a canonical JSON representation (this applies to
  	                // objects with `toJSON` properties as well, *unless* they are nested
  	                // within an object or array).
  	                stringify(getClass) === undef &&
  	                // IE 8 serializes `undefined` as `"undefined"`. Safari <= 5.1.7 and
  	                // FF 3.1b3 pass this test.
  	                stringify(undef) === undef &&
  	                // Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,
  	                // respectively, if the value is omitted entirely.
  	                stringify() === undef &&
  	                // FF 3.1b1, 2 throw an error if the given value is not a number,
  	                // string, array, object, Boolean, or `null` literal. This applies to
  	                // objects with custom `toJSON` methods as well, unless they are nested
  	                // inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`
  	                // methods entirely.
  	                stringify(value) === "1" &&
  	                stringify([value]) == "[1]" &&
  	                // Prototype <= 1.6.1 serializes `[undefined]` as `"[]"` instead of
  	                // `"[null]"`.
  	                stringify([undef]) == "[null]" &&
  	                // YUI 3.0.0b1 fails to serialize `null` literals.
  	                stringify(null) == "null" &&
  	                // FF 3.1b1, 2 halts serialization if an array contains a function:
  	                // `[1, true, getClass, 1]` serializes as "[1,true,],". FF 3.1b3
  	                // elides non-JSON values from objects and arrays, unless they
  	                // define custom `toJSON` methods.
  	                stringify([undef, getClass, null]) == "[null,null,null]" &&
  	                // Simple serialization test. FF 3.1b1 uses Unicode escape sequences
  	                // where character escape codes are expected (e.g., `\b` => `\u0008`).
  	                stringify({ "a": [value, true, false, null, "\x00\b\n\f\r\t"] }) == serialized &&
  	                // FF 3.1b1 and b2 ignore the `filter` and `width` arguments.
  	                stringify(null, value) === "1" &&
  	                stringify([1, 2], null, 1) == "[\n 1,\n 2\n]" &&
  	                // JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly
  	                // serialize extended years.
  	                stringify(new Date(-8.64e15)) == '"-271821-04-20T00:00:00.000Z"' &&
  	                // The milliseconds are optional in ES 5, but required in 5.1.
  	                stringify(new Date(8.64e15)) == '"+275760-09-13T00:00:00.000Z"' &&
  	                // Firefox <= 11.0 incorrectly serializes years prior to 0 as negative
  	                // four-digit years instead of six-digit years. Credits: @Yaffle.
  	                stringify(new Date(-621987552e5)) == '"-000001-01-01T00:00:00.000Z"' &&
  	                // Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond
  	                // values less than 1000. Credits: @Yaffle.
  	                stringify(new Date(-1)) == '"1969-12-31T23:59:59.999Z"';
  	            } catch (exception) {
  	              stringifySupported = false;
  	            }
  	          }
  	          isSupported = stringifySupported;
  	        }
  	        // Test `JSON.parse`.
  	        if (name == "json-parse") {
  	          var parse = exports.parse;
  	          if (typeof parse == "function") {
  	            try {
  	              // FF 3.1b1, b2 will throw an exception if a bare literal is provided.
  	              // Conforming implementations should also coerce the initial argument to
  	              // a string prior to parsing.
  	              if (parse("0") === 0 && !parse(false)) {
  	                // Simple parsing test.
  	                value = parse(serialized);
  	                var parseSupported = value["a"].length == 5 && value["a"][0] === 1;
  	                if (parseSupported) {
  	                  try {
  	                    // Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.
  	                    parseSupported = !parse('"\t"');
  	                  } catch (exception) {}
  	                  if (parseSupported) {
  	                    try {
  	                      // FF 4.0 and 4.0.1 allow leading `+` signs and leading
  	                      // decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow
  	                      // certain octal literals.
  	                      parseSupported = parse("01") !== 1;
  	                    } catch (exception) {}
  	                  }
  	                  if (parseSupported) {
  	                    try {
  	                      // FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal
  	                      // points. These environments, along with FF 3.1b1 and 2,
  	                      // also allow trailing commas in JSON objects and arrays.
  	                      parseSupported = parse("1.") !== 1;
  	                    } catch (exception) {}
  	                  }
  	                }
  	              }
  	            } catch (exception) {
  	              parseSupported = false;
  	            }
  	          }
  	          isSupported = parseSupported;
  	        }
  	      }
  	      return has[name] = !!isSupported;
  	    }
  	
  	    if (!has("json")) {
  	      // Common `[[Class]]` name aliases.
  	      var functionClass = "[object Function]",
  	          dateClass = "[object Date]",
  	          numberClass = "[object Number]",
  	          stringClass = "[object String]",
  	          arrayClass = "[object Array]",
  	          booleanClass = "[object Boolean]";
  	
  	      // Detect incomplete support for accessing string characters by index.
  	      var charIndexBuggy = has("bug-string-char-index");
  	
  	      // Define additional utility methods if the `Date` methods are buggy.
  	      if (!isExtended) {
  	        var floor = Math.floor;
  	        // A mapping between the months of the year and the number of days between
  	        // January 1st and the first of the respective month.
  	        var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
  	        // Internal: Calculates the number of days between the Unix epoch and the
  	        // first day of the given month.
  	        var getDay = function (year, month) {
  	          return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);
  	        };
  	      }
  	
  	      // Internal: Determines if a property is a direct property of the given
  	      // object. Delegates to the native `Object#hasOwnProperty` method.
  	      if (!(isProperty = objectProto.hasOwnProperty)) {
  	        isProperty = function (property) {
  	          var members = {}, constructor;
  	          if ((members.__proto__ = null, members.__proto__ = {
  	            // The *proto* property cannot be set multiple times in recent
  	            // versions of Firefox and SeaMonkey.
  	            "toString": 1
  	          }, members).toString != getClass) {
  	            // Safari <= 2.0.3 doesn't implement `Object#hasOwnProperty`, but
  	            // supports the mutable *proto* property.
  	            isProperty = function (property) {
  	              // Capture and break the object's prototype chain (see section 8.6.2
  	              // of the ES 5.1 spec). The parenthesized expression prevents an
  	              // unsafe transformation by the Closure Compiler.
  	              var original = this.__proto__, result = property in (this.__proto__ = null, this);
  	              // Restore the original prototype chain.
  	              this.__proto__ = original;
  	              return result;
  	            };
  	          } else {
  	            // Capture a reference to the top-level `Object` constructor.
  	            constructor = members.constructor;
  	            // Use the `constructor` property to simulate `Object#hasOwnProperty` in
  	            // other environments.
  	            isProperty = function (property) {
  	              var parent = (this.constructor || constructor).prototype;
  	              return property in this && !(property in parent && this[property] === parent[property]);
  	            };
  	          }
  	          members = null;
  	          return isProperty.call(this, property);
  	        };
  	      }
  	
  	      // Internal: Normalizes the `for...in` iteration algorithm across
  	      // environments. Each enumerated key is yielded to a `callback` function.
  	      forEach = function (object, callback) {
  	        var size = 0, Properties, members, property;
  	
  	        // Tests for bugs in the current environment's `for...in` algorithm. The
  	        // `valueOf` property inherits the non-enumerable flag from
  	        // `Object.prototype` in older versions of IE, Netscape, and Mozilla.
  	        (Properties = function () {
  	          this.valueOf = 0;
  	        }).prototype.valueOf = 0;
  	
  	        // Iterate over a new instance of the `Properties` class.
  	        members = new Properties();
  	        for (property in members) {
  	          // Ignore all properties inherited from `Object.prototype`.
  	          if (isProperty.call(members, property)) {
  	            size++;
  	          }
  	        }
  	        Properties = members = null;
  	
  	        // Normalize the iteration algorithm.
  	        if (!size) {
  	          // A list of non-enumerable properties inherited from `Object.prototype`.
  	          members = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];
  	          // IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable
  	          // properties.
  	          forEach = function (object, callback) {
  	            var isFunction = getClass.call(object) == functionClass, property, length;
  	            var hasProperty = !isFunction && typeof object.constructor != "function" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;
  	            for (property in object) {
  	              // Gecko <= 1.0 enumerates the `prototype` property of functions under
  	              // certain conditions; IE does not.
  	              if (!(isFunction && property == "prototype") && hasProperty.call(object, property)) {
  	                callback(property);
  	              }
  	            }
  	            // Manually invoke the callback for each non-enumerable property.
  	            for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));
  	          };
  	        } else if (size == 2) {
  	          // Safari <= 2.0.4 enumerates shadowed properties twice.
  	          forEach = function (object, callback) {
  	            // Create a set of iterated properties.
  	            var members = {}, isFunction = getClass.call(object) == functionClass, property;
  	            for (property in object) {
  	              // Store each property name to prevent double enumeration. The
  	              // `prototype` property of functions is not enumerated due to cross-
  	              // environment inconsistencies.
  	              if (!(isFunction && property == "prototype") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {
  	                callback(property);
  	              }
  	            }
  	          };
  	        } else {
  	          // No bugs detected; use the standard `for...in` algorithm.
  	          forEach = function (object, callback) {
  	            var isFunction = getClass.call(object) == functionClass, property, isConstructor;
  	            for (property in object) {
  	              if (!(isFunction && property == "prototype") && isProperty.call(object, property) && !(isConstructor = property === "constructor")) {
  	                callback(property);
  	              }
  	            }
  	            // Manually invoke the callback for the `constructor` property due to
  	            // cross-environment inconsistencies.
  	            if (isConstructor || isProperty.call(object, (property = "constructor"))) {
  	              callback(property);
  	            }
  	          };
  	        }
  	        return forEach(object, callback);
  	      };
  	
  	      // Public: Serializes a JavaScript `value` as a JSON string. The optional
  	      // `filter` argument may specify either a function that alters how object and
  	      // array members are serialized, or an array of strings and numbers that
  	      // indicates which properties should be serialized. The optional `width`
  	      // argument may be either a string or number that specifies the indentation
  	      // level of the output.
  	      if (!has("json-stringify")) {
  	        // Internal: A map of control characters and their escaped equivalents.
  	        var Escapes = {
  	          92: "\\\\",
  	          34: '\\"',
  	          8: "\\b",
  	          12: "\\f",
  	          10: "\\n",
  	          13: "\\r",
  	          9: "\\t"
  	        };
  	
  	        // Internal: Converts `value` into a zero-padded string such that its
  	        // length is at least equal to `width`. The `width` must be <= 6.
  	        var leadingZeroes = "000000";
  	        var toPaddedString = function (width, value) {
  	          // The `|| 0` expression is necessary to work around a bug in
  	          // Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== "0"`.
  	          return (leadingZeroes + (value || 0)).slice(-width);
  	        };
  	
  	        // Internal: Double-quotes a string `value`, replacing all ASCII control
  	        // characters (characters with code unit values between 0 and 31) with
  	        // their escaped equivalents. This is an implementation of the
  	        // `Quote(value)` operation defined in ES 5.1 section 15.12.3.
  	        var unicodePrefix = "\\u00";
  	        var quote = function (value) {
  	          var result = '"', index = 0, length = value.length, useCharIndex = !charIndexBuggy || length > 10;
  	          var symbols = useCharIndex && (charIndexBuggy ? value.split("") : value);
  	          for (; index < length; index++) {
  	            var charCode = value.charCodeAt(index);
  	            // If the character is a control character, append its Unicode or
  	            // shorthand escape sequence; otherwise, append the character as-is.
  	            switch (charCode) {
  	              case 8: case 9: case 10: case 12: case 13: case 34: case 92:
  	                result += Escapes[charCode];
  	                break;
  	              default:
  	                if (charCode < 32) {
  	                  result += unicodePrefix + toPaddedString(2, charCode.toString(16));
  	                  break;
  	                }
  	                result += useCharIndex ? symbols[index] : value.charAt(index);
  	            }
  	          }
  	          return result + '"';
  	        };
  	
  	        // Internal: Recursively serializes an object. Implements the
  	        // `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.
  	        var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {
  	          var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;
  	          try {
  	            // Necessary for host object support.
  	            value = object[property];
  	          } catch (exception) {}
  	          if (typeof value == "object" && value) {
  	            className = getClass.call(value);
  	            if (className == dateClass && !isProperty.call(value, "toJSON")) {
  	              if (value > -1 / 0 && value < 1 / 0) {
  	                // Dates are serialized according to the `Date#toJSON` method
  	                // specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15
  	                // for the ISO 8601 date time string format.
  	                if (getDay) {
  	                  // Manually compute the year, month, date, hours, minutes,
  	                  // seconds, and milliseconds if the `getUTC*` methods are
  	                  // buggy. Adapted from @Yaffle's `date-shim` project.
  	                  date = floor(value / 864e5);
  	                  for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);
  	                  for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);
  	                  date = 1 + date - getDay(year, month);
  	                  // The `time` value specifies the time within the day (see ES
  	                  // 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used
  	                  // to compute `A modulo B`, as the `%` operator does not
  	                  // correspond to the `modulo` operation for negative numbers.
  	                  time = (value % 864e5 + 864e5) % 864e5;
  	                  // The hours, minutes, seconds, and milliseconds are obtained by
  	                  // decomposing the time within the day. See section 15.9.1.10.
  	                  hours = floor(time / 36e5) % 24;
  	                  minutes = floor(time / 6e4) % 60;
  	                  seconds = floor(time / 1e3) % 60;
  	                  milliseconds = time % 1e3;
  	                } else {
  	                  year = value.getUTCFullYear();
  	                  month = value.getUTCMonth();
  	                  date = value.getUTCDate();
  	                  hours = value.getUTCHours();
  	                  minutes = value.getUTCMinutes();
  	                  seconds = value.getUTCSeconds();
  	                  milliseconds = value.getUTCMilliseconds();
  	                }
  	                // Serialize extended years correctly.
  	                value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-" : "+") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +
  	                  "-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) +
  	                  // Months, dates, hours, minutes, and seconds should have two
  	                  // digits; milliseconds should have three.
  	                  "T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) +
  	                  // Milliseconds are optional in ES 5.0, but required in 5.1.
  	                  "." + toPaddedString(3, milliseconds) + "Z";
  	              } else {
  	                value = null;
  	              }
  	            } else if (typeof value.toJSON == "function" && ((className != numberClass && className != stringClass && className != arrayClass) || isProperty.call(value, "toJSON"))) {
  	              // Prototype <= 1.6.1 adds non-standard `toJSON` methods to the
  	              // `Number`, `String`, `Date`, and `Array` prototypes. JSON 3
  	              // ignores all `toJSON` methods on these objects unless they are
  	              // defined directly on an instance.
  	              value = value.toJSON(property);
  	            }
  	          }
  	          if (callback) {
  	            // If a replacement function was provided, call it to obtain the value
  	            // for serialization.
  	            value = callback.call(object, property, value);
  	          }
  	          if (value === null) {
  	            return "null";
  	          }
  	          className = getClass.call(value);
  	          if (className == booleanClass) {
  	            // Booleans are represented literally.
  	            return "" + value;
  	          } else if (className == numberClass) {
  	            // JSON numbers must be finite. `Infinity` and `NaN` are serialized as
  	            // `"null"`.
  	            return value > -1 / 0 && value < 1 / 0 ? "" + value : "null";
  	          } else if (className == stringClass) {
  	            // Strings are double-quoted and escaped.
  	            return quote("" + value);
  	          }
  	          // Recursively serialize objects and arrays.
  	          if (typeof value == "object") {
  	            // Check for cyclic structures. This is a linear search; performance
  	            // is inversely proportional to the number of unique nested objects.
  	            for (length = stack.length; length--;) {
  	              if (stack[length] === value) {
  	                // Cyclic structures cannot be serialized by `JSON.stringify`.
  	                throw TypeError();
  	              }
  	            }
  	            // Add the object to the stack of traversed objects.
  	            stack.push(value);
  	            results = [];
  	            // Save the current indentation level and indent one additional level.
  	            prefix = indentation;
  	            indentation += whitespace;
  	            if (className == arrayClass) {
  	              // Recursively serialize array elements.
  	              for (index = 0, length = value.length; index < length; index++) {
  	                element = serialize(index, value, callback, properties, whitespace, indentation, stack);
  	                results.push(element === undef ? "null" : element);
  	              }
  	              result = results.length ? (whitespace ? "[\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "]" : ("[" + results.join(",") + "]")) : "[]";
  	            } else {
  	              // Recursively serialize object members. Members are selected from
  	              // either a user-specified list of property names, or the object
  	              // itself.
  	              forEach(properties || value, function (property) {
  	                var element = serialize(property, value, callback, properties, whitespace, indentation, stack);
  	                if (element !== undef) {
  	                  // According to ES 5.1 section 15.12.3: "If `gap` {whitespace}
  	                  // is not the empty string, let `member` {quote(property) + ":"}
  	                  // be the concatenation of `member` and the `space` character."
  	                  // The "`space` character" refers to the literal space
  	                  // character, not the `space` {width} argument provided to
  	                  // `JSON.stringify`.
  	                  results.push(quote(property) + ":" + (whitespace ? " " : "") + element);
  	                }
  	              });
  	              result = results.length ? (whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}" : ("{" + results.join(",") + "}")) : "{}";
  	            }
  	            // Remove the object from the traversed object stack.
  	            stack.pop();
  	            return result;
  	          }
  	        };
  	
  	        // Public: `JSON.stringify`. See ES 5.1 section 15.12.3.
  	        exports.stringify = function (source, filter, width) {
  	          var whitespace, callback, properties, className;
  	          if (objectTypes[typeof filter] && filter) {
  	            if ((className = getClass.call(filter)) == functionClass) {
  	              callback = filter;
  	            } else if (className == arrayClass) {
  	              // Convert the property names array into a makeshift set.
  	              properties = {};
  	              for (var index = 0, length = filter.length, value; index < length; value = filter[index++], ((className = getClass.call(value)), className == stringClass || className == numberClass) && (properties[value] = 1));
  	            }
  	          }
  	          if (width) {
  	            if ((className = getClass.call(width)) == numberClass) {
  	              // Convert the `width` to an integer and create a string containing
  	              // `width` number of space characters.
  	              if ((width -= width % 1) > 0) {
  	                for (whitespace = "", width > 10 && (width = 10); whitespace.length < width; whitespace += " ");
  	              }
  	            } else if (className == stringClass) {
  	              whitespace = width.length <= 10 ? width : width.slice(0, 10);
  	            }
  	          }
  	          // Opera <= 7.54u2 discards the values associated with empty string keys
  	          // (`""`) only if they are used directly within an object member list
  	          // (e.g., `!("" in { "": 1})`).
  	          return serialize("", (value = {}, value[""] = source, value), callback, properties, whitespace, "", []);
  	        };
  	      }
  	
  	      // Public: Parses a JSON source string.
  	      if (!has("json-parse")) {
  	        var fromCharCode = String.fromCharCode;
  	
  	        // Internal: A map of escaped control characters and their unescaped
  	        // equivalents.
  	        var Unescapes = {
  	          92: "\\",
  	          34: '"',
  	          47: "/",
  	          98: "\b",
  	          116: "\t",
  	          110: "\n",
  	          102: "\f",
  	          114: "\r"
  	        };
  	
  	        // Internal: Stores the parser state.
  	        var Index, Source;
  	
  	        // Internal: Resets the parser state and throws a `SyntaxError`.
  	        var abort = function () {
  	          Index = Source = null;
  	          throw SyntaxError();
  	        };
  	
  	        // Internal: Returns the next token, or `"$"` if the parser has reached
  	        // the end of the source string. A token may be a string, number, `null`
  	        // literal, or Boolean literal.
  	        var lex = function () {
  	          var source = Source, length = source.length, value, begin, position, isSigned, charCode;
  	          while (Index < length) {
  	            charCode = source.charCodeAt(Index);
  	            switch (charCode) {
  	              case 9: case 10: case 13: case 32:
  	                // Skip whitespace tokens, including tabs, carriage returns, line
  	                // feeds, and space characters.
  	                Index++;
  	                break;
  	              case 123: case 125: case 91: case 93: case 58: case 44:
  	                // Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at
  	                // the current position.
  	                value = charIndexBuggy ? source.charAt(Index) : source[Index];
  	                Index++;
  	                return value;
  	              case 34:
  	                // `"` delimits a JSON string; advance to the next character and
  	                // begin parsing the string. String tokens are prefixed with the
  	                // sentinel `@` character to distinguish them from punctuators and
  	                // end-of-string tokens.
  	                for (value = "@", Index++; Index < length;) {
  	                  charCode = source.charCodeAt(Index);
  	                  if (charCode < 32) {
  	                    // Unescaped ASCII control characters (those with a code unit
  	                    // less than the space character) are not permitted.
  	                    abort();
  	                  } else if (charCode == 92) {
  	                    // A reverse solidus (`\`) marks the beginning of an escaped
  	                    // control character (including `"`, `\`, and `/`) or Unicode
  	                    // escape sequence.
  	                    charCode = source.charCodeAt(++Index);
  	                    switch (charCode) {
  	                      case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:
  	                        // Revive escaped control characters.
  	                        value += Unescapes[charCode];
  	                        Index++;
  	                        break;
  	                      case 117:
  	                        // `\u` marks the beginning of a Unicode escape sequence.
  	                        // Advance to the first character and validate the
  	                        // four-digit code point.
  	                        begin = ++Index;
  	                        for (position = Index + 4; Index < position; Index++) {
  	                          charCode = source.charCodeAt(Index);
  	                          // A valid sequence comprises four hexdigits (case-
  	                          // insensitive) that form a single hexadecimal value.
  	                          if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {
  	                            // Invalid Unicode escape sequence.
  	                            abort();
  	                          }
  	                        }
  	                        // Revive the escaped character.
  	                        value += fromCharCode("0x" + source.slice(begin, Index));
  	                        break;
  	                      default:
  	                        // Invalid escape sequence.
  	                        abort();
  	                    }
  	                  } else {
  	                    if (charCode == 34) {
  	                      // An unescaped double-quote character marks the end of the
  	                      // string.
  	                      break;
  	                    }
  	                    charCode = source.charCodeAt(Index);
  	                    begin = Index;
  	                    // Optimize for the common case where a string is valid.
  	                    while (charCode >= 32 && charCode != 92 && charCode != 34) {
  	                      charCode = source.charCodeAt(++Index);
  	                    }
  	                    // Append the string as-is.
  	                    value += source.slice(begin, Index);
  	                  }
  	                }
  	                if (source.charCodeAt(Index) == 34) {
  	                  // Advance to the next character and return the revived string.
  	                  Index++;
  	                  return value;
  	                }
  	                // Unterminated string.
  	                abort();
  	              default:
  	                // Parse numbers and literals.
  	                begin = Index;
  	                // Advance past the negative sign, if one is specified.
  	                if (charCode == 45) {
  	                  isSigned = true;
  	                  charCode = source.charCodeAt(++Index);
  	                }
  	                // Parse an integer or floating-point value.
  	                if (charCode >= 48 && charCode <= 57) {
  	                  // Leading zeroes are interpreted as octal literals.
  	                  if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {
  	                    // Illegal octal literal.
  	                    abort();
  	                  }
  	                  isSigned = false;
  	                  // Parse the integer component.
  	                  for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);
  	                  // Floats cannot contain a leading decimal point; however, this
  	                  // case is already accounted for by the parser.
  	                  if (source.charCodeAt(Index) == 46) {
  	                    position = ++Index;
  	                    // Parse the decimal component.
  	                    for (; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);
  	                    if (position == Index) {
  	                      // Illegal trailing decimal.
  	                      abort();
  	                    }
  	                    Index = position;
  	                  }
  	                  // Parse exponents. The `e` denoting the exponent is
  	                  // case-insensitive.
  	                  charCode = source.charCodeAt(Index);
  	                  if (charCode == 101 || charCode == 69) {
  	                    charCode = source.charCodeAt(++Index);
  	                    // Skip past the sign following the exponent, if one is
  	                    // specified.
  	                    if (charCode == 43 || charCode == 45) {
  	                      Index++;
  	                    }
  	                    // Parse the exponential component.
  	                    for (position = Index; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);
  	                    if (position == Index) {
  	                      // Illegal empty exponent.
  	                      abort();
  	                    }
  	                    Index = position;
  	                  }
  	                  // Coerce the parsed value to a JavaScript number.
  	                  return +source.slice(begin, Index);
  	                }
  	                // A negative sign may only precede numbers.
  	                if (isSigned) {
  	                  abort();
  	                }
  	                // `true`, `false`, and `null` literals.
  	                if (source.slice(Index, Index + 4) == "true") {
  	                  Index += 4;
  	                  return true;
  	                } else if (source.slice(Index, Index + 5) == "false") {
  	                  Index += 5;
  	                  return false;
  	                } else if (source.slice(Index, Index + 4) == "null") {
  	                  Index += 4;
  	                  return null;
  	                }
  	                // Unrecognized token.
  	                abort();
  	            }
  	          }
  	          // Return the sentinel `$` character if the parser has reached the end
  	          // of the source string.
  	          return "$";
  	        };
  	
  	        // Internal: Parses a JSON `value` token.
  	        var get = function (value) {
  	          var results, hasMembers;
  	          if (value == "$") {
  	            // Unexpected end of input.
  	            abort();
  	          }
  	          if (typeof value == "string") {
  	            if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") {
  	              // Remove the sentinel `@` character.
  	              return value.slice(1);
  	            }
  	            // Parse object and array literals.
  	            if (value == "[") {
  	              // Parses a JSON array, returning a new JavaScript array.
  	              results = [];
  	              for (;; hasMembers || (hasMembers = true)) {
  	                value = lex();
  	                // A closing square bracket marks the end of the array literal.
  	                if (value == "]") {
  	                  break;
  	                }
  	                // If the array literal contains elements, the current token
  	                // should be a comma separating the previous element from the
  	                // next.
  	                if (hasMembers) {
  	                  if (value == ",") {
  	                    value = lex();
  	                    if (value == "]") {
  	                      // Unexpected trailing `,` in array literal.
  	                      abort();
  	                    }
  	                  } else {
  	                    // A `,` must separate each array element.
  	                    abort();
  	                  }
  	                }
  	                // Elisions and leading commas are not permitted.
  	                if (value == ",") {
  	                  abort();
  	                }
  	                results.push(get(value));
  	              }
  	              return results;
  	            } else if (value == "{") {
  	              // Parses a JSON object, returning a new JavaScript object.
  	              results = {};
  	              for (;; hasMembers || (hasMembers = true)) {
  	                value = lex();
  	                // A closing curly brace marks the end of the object literal.
  	                if (value == "}") {
  	                  break;
  	                }
  	                // If the object literal contains members, the current token
  	                // should be a comma separator.
  	                if (hasMembers) {
  	                  if (value == ",") {
  	                    value = lex();
  	                    if (value == "}") {
  	                      // Unexpected trailing `,` in object literal.
  	                      abort();
  	                    }
  	                  } else {
  	                    // A `,` must separate each object member.
  	                    abort();
  	                  }
  	                }
  	                // Leading commas are not permitted, object property names must be
  	                // double-quoted strings, and a `:` must separate each property
  	                // name and value.
  	                if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") {
  	                  abort();
  	                }
  	                results[value.slice(1)] = get(lex());
  	              }
  	              return results;
  	            }
  	            // Unexpected token encountered.
  	            abort();
  	          }
  	          return value;
  	        };
  	
  	        // Internal: Updates a traversed object member.
  	        var update = function (source, property, callback) {
  	          var element = walk(source, property, callback);
  	          if (element === undef) {
  	            delete source[property];
  	          } else {
  	            source[property] = element;
  	          }
  	        };
  	
  	        // Internal: Recursively traverses a parsed JSON object, invoking the
  	        // `callback` function for each value. This is an implementation of the
  	        // `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.
  	        var walk = function (source, property, callback) {
  	          var value = source[property], length;
  	          if (typeof value == "object" && value) {
  	            // `forEach` can't be used to traverse an array in Opera <= 8.54
  	            // because its `Object#hasOwnProperty` implementation returns `false`
  	            // for array indices (e.g., `![1, 2, 3].hasOwnProperty("0")`).
  	            if (getClass.call(value) == arrayClass) {
  	              for (length = value.length; length--;) {
  	                update(value, length, callback);
  	              }
  	            } else {
  	              forEach(value, function (property) {
  	                update(value, property, callback);
  	              });
  	            }
  	          }
  	          return callback.call(source, property, value);
  	        };
  	
  	        // Public: `JSON.parse`. See ES 5.1 section 15.12.2.
  	        exports.parse = function (source, callback) {
  	          var result, value;
  	          Index = 0;
  	          Source = "" + source;
  	          result = get(lex());
  	          // If a JSON string contains multiple tokens, it is invalid.
  	          if (lex() != "$") {
  	            abort();
  	          }
  	          // Reset the parser state.
  	          Index = Source = null;
  	          return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[""] = result, value), "", callback) : result;
  	        };
  	      }
  	    }
  	
  	    exports["runInContext"] = runInContext;
  	    return exports;
  	  }
  	
  	  if (freeExports && !isLoader) {
  	    // Export for CommonJS environments.
  	    runInContext(root, freeExports);
  	  } else {
  	    // Export for web browsers and JavaScript engines.
  	    var nativeJSON = root.JSON,
  	        previousJSON = root["JSON3"],
  	        isRestored = false;
  	
  	    var JSON3 = runInContext(root, (root["JSON3"] = {
  	      // Public: Restores the original value of the global `JSON` object and
  	      // returns a reference to the `JSON3` object.
  	      "noConflict": function () {
  	        if (!isRestored) {
  	          isRestored = true;
  	          root.JSON = nativeJSON;
  	          root["JSON3"] = previousJSON;
  	          nativeJSON = previousJSON = null;
  	        }
  	        return JSON3;
  	      }
  	    }));
  	
  	    root.JSON = {
  	      "parse": JSON3.parse,
  	      "stringify": JSON3.stringify
  	    };
  	  }
  	
  	  // Export for asynchronous module loaders.
  	  if (isLoader) {
  	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
  	      return JSON3;
  	    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  	  }
  	}).call(this);
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module), (function() { return this; }())))
  
  /***/ },
  /* 51 */
  /***/ function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {module.exports = __webpack_amd_options__;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, {}))
  
  /***/ },
  /* 52 */
  /***/ function(module, exports) {
  
  	module.exports = '1.1.2';
  
  
  /***/ },
  /* 53 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process, global) {'use strict';
  	
  	var eventUtils = __webpack_require__(18)
  	  , JSON3 = __webpack_require__(50)
  	  , browser = __webpack_require__(42)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:utils:iframe');
  	}
  	
  	module.exports = {
  	  WPrefix: '_jp'
  	, currentWindowId: null
  	
  	, polluteGlobalNamespace: function() {
  	    if (!(module.exports.WPrefix in global)) {
  	      global[module.exports.WPrefix] = {};
  	    }
  	  }
  	
  	, postMessage: function(type, data) {
  	    if (global.parent !== global) {
  	      global.parent.postMessage(JSON3.stringify({
  	        windowId: module.exports.currentWindowId
  	      , type: type
  	      , data: data || ''
  	      }), '*');
  	    } else {
  	      debug('Cannot postMessage, no parent window.', type, data);
  	    }
  	  }
  	
  	, createIframe: function(iframeUrl, errorCallback) {
  	    var iframe = global.document.createElement('iframe');
  	    var tref, unloadRef;
  	    var unattach = function() {
  	      debug('unattach');
  	      clearTimeout(tref);
  	      // Explorer had problems with that.
  	      try {
  	        iframe.onload = null;
  	      } catch (x) {
  	        // intentionally empty
  	      }
  	      iframe.onerror = null;
  	    };
  	    var cleanup = function() {
  	      debug('cleanup');
  	      if (iframe) {
  	        unattach();
  	        // This timeout makes chrome fire onbeforeunload event
  	        // within iframe. Without the timeout it goes straight to
  	        // onunload.
  	        setTimeout(function() {
  	          if (iframe) {
  	            iframe.parentNode.removeChild(iframe);
  	          }
  	          iframe = null;
  	        }, 0);
  	        eventUtils.unloadDel(unloadRef);
  	      }
  	    };
  	    var onerror = function(err) {
  	      debug('onerror', err);
  	      if (iframe) {
  	        cleanup();
  	        errorCallback(err);
  	      }
  	    };
  	    var post = function(msg, origin) {
  	      debug('post', msg, origin);
  	      try {
  	        // When the iframe is not loaded, IE raises an exception
  	        // on 'contentWindow'.
  	        setTimeout(function() {
  	          if (iframe && iframe.contentWindow) {
  	            iframe.contentWindow.postMessage(msg, origin);
  	          }
  	        }, 0);
  	      } catch (x) {
  	        // intentionally empty
  	      }
  	    };
  	
  	    iframe.src = iframeUrl;
  	    iframe.style.display = 'none';
  	    iframe.style.position = 'absolute';
  	    iframe.onerror = function() {
  	      onerror('onerror');
  	    };
  	    iframe.onload = function() {
  	      debug('onload');
  	      // `onload` is triggered before scripts on the iframe are
  	      // executed. Give it few seconds to actually load stuff.
  	      clearTimeout(tref);
  	      tref = setTimeout(function() {
  	        onerror('onload timeout');
  	      }, 2000);
  	    };
  	    global.document.body.appendChild(iframe);
  	    tref = setTimeout(function() {
  	      onerror('timeout');
  	    }, 15000);
  	    unloadRef = eventUtils.unloadAdd(cleanup);
  	    return {
  	      post: post
  	    , cleanup: cleanup
  	    , loaded: unattach
  	    };
  	  }
  	
  	/* eslint no-undef: "off", new-cap: "off" */
  	, createHtmlfile: function(iframeUrl, errorCallback) {
  	    var axo = ['Active'].concat('Object').join('X');
  	    var doc = new global[axo]('htmlfile');
  	    var tref, unloadRef;
  	    var iframe;
  	    var unattach = function() {
  	      clearTimeout(tref);
  	      iframe.onerror = null;
  	    };
  	    var cleanup = function() {
  	      if (doc) {
  	        unattach();
  	        eventUtils.unloadDel(unloadRef);
  	        iframe.parentNode.removeChild(iframe);
  	        iframe = doc = null;
  	        CollectGarbage();
  	      }
  	    };
  	    var onerror = function(r) {
  	      debug('onerror', r);
  	      if (doc) {
  	        cleanup();
  	        errorCallback(r);
  	      }
  	    };
  	    var post = function(msg, origin) {
  	      try {
  	        // When the iframe is not loaded, IE raises an exception
  	        // on 'contentWindow'.
  	        setTimeout(function() {
  	          if (iframe && iframe.contentWindow) {
  	              iframe.contentWindow.postMessage(msg, origin);
  	          }
  	        }, 0);
  	      } catch (x) {
  	        // intentionally empty
  	      }
  	    };
  	
  	    doc.open();
  	    doc.write('<html><s' + 'cript>' +
  	              'document.domain="' + global.document.domain + '";' +
  	              '</s' + 'cript></html>');
  	    doc.close();
  	    doc.parentWindow[module.exports.WPrefix] = global[module.exports.WPrefix];
  	    var c = doc.createElement('div');
  	    doc.body.appendChild(c);
  	    iframe = doc.createElement('iframe');
  	    c.appendChild(iframe);
  	    iframe.src = iframeUrl;
  	    iframe.onerror = function() {
  	      onerror('onerror');
  	    };
  	    tref = setTimeout(function() {
  	      onerror('timeout');
  	    }, 15000);
  	    unloadRef = eventUtils.unloadAdd(cleanup);
  	    return {
  	      post: post
  	    , cleanup: cleanup
  	    , loaded: unattach
  	    };
  	  }
  	};
  	
  	module.exports.iframeEnabled = false;
  	if (global.document) {
  	  // postMessage misbehaves in konqueror 4.6.5 - the messages are delivered with
  	  // huge delay, or not at all.
  	  module.exports.iframeEnabled = (typeof global.postMessage === 'function' ||
  	    typeof global.postMessage === 'object') && (!browser.isKonqueror());
  	}
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17), (function() { return this; }())))
  
  /***/ },
  /* 54 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	module.exports = {
  	  isObject: function(obj) {
  	    var type = typeof obj;
  	    return type === 'function' || type === 'object' && !!obj;
  	  }
  	
  	, extend: function(obj) {
  	    if (!this.isObject(obj)) {
  	      return obj;
  	    }
  	    var source, prop;
  	    for (var i = 1, length = arguments.length; i < length; i++) {
  	      source = arguments[i];
  	      for (prop in source) {
  	        if (Object.prototype.hasOwnProperty.call(source, prop)) {
  	          obj[prop] = source[prop];
  	        }
  	      }
  	    }
  	    return obj;
  	  }
  	};
  
  
  /***/ },
  /* 55 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , HtmlfileReceiver = __webpack_require__(56)
  	  , XHRLocalObject = __webpack_require__(41)
  	  , AjaxBasedTransport = __webpack_require__(34)
  	  ;
  	
  	function HtmlFileTransport(transUrl) {
  	  if (!HtmlfileReceiver.enabled) {
  	    throw new Error('Transport created when disabled');
  	  }
  	  AjaxBasedTransport.call(this, transUrl, '/htmlfile', HtmlfileReceiver, XHRLocalObject);
  	}
  	
  	inherits(HtmlFileTransport, AjaxBasedTransport);
  	
  	HtmlFileTransport.enabled = function(info) {
  	  return HtmlfileReceiver.enabled && info.sameOrigin;
  	};
  	
  	HtmlFileTransport.transportName = 'htmlfile';
  	HtmlFileTransport.roundTrips = 2;
  	
  	module.exports = HtmlFileTransport;
  
  
  /***/ },
  /* 56 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process, global) {'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , iframeUtils = __webpack_require__(53)
  	  , urlUtils = __webpack_require__(21)
  	  , EventEmitter = __webpack_require__(30).EventEmitter
  	  , random = __webpack_require__(19)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:receiver:htmlfile');
  	}
  	
  	function HtmlfileReceiver(url) {
  	  debug(url);
  	  EventEmitter.call(this);
  	  var self = this;
  	  iframeUtils.polluteGlobalNamespace();
  	
  	  this.id = 'a' + random.string(6);
  	  url = urlUtils.addQuery(url, 'c=' + decodeURIComponent(iframeUtils.WPrefix + '.' + this.id));
  	
  	  debug('using htmlfile', HtmlfileReceiver.htmlfileEnabled);
  	  var constructFunc = HtmlfileReceiver.htmlfileEnabled ?
  	      iframeUtils.createHtmlfile : iframeUtils.createIframe;
  	
  	  global[iframeUtils.WPrefix][this.id] = {
  	    start: function() {
  	      debug('start');
  	      self.iframeObj.loaded();
  	    }
  	  , message: function(data) {
  	      debug('message', data);
  	      self.emit('message', data);
  	    }
  	  , stop: function() {
  	      debug('stop');
  	      self._cleanup();
  	      self._close('network');
  	    }
  	  };
  	  this.iframeObj = constructFunc(url, function() {
  	    debug('callback');
  	    self._cleanup();
  	    self._close('permanent');
  	  });
  	}
  	
  	inherits(HtmlfileReceiver, EventEmitter);
  	
  	HtmlfileReceiver.prototype.abort = function() {
  	  debug('abort');
  	  this._cleanup();
  	  this._close('user');
  	};
  	
  	HtmlfileReceiver.prototype._cleanup = function() {
  	  debug('_cleanup');
  	  if (this.iframeObj) {
  	    this.iframeObj.cleanup();
  	    this.iframeObj = null;
  	  }
  	  delete global[iframeUtils.WPrefix][this.id];
  	};
  	
  	HtmlfileReceiver.prototype._close = function(reason) {
  	  debug('_close', reason);
  	  this.emit('close', null, reason);
  	  this.removeAllListeners();
  	};
  	
  	HtmlfileReceiver.htmlfileEnabled = false;
  	
  	// obfuscate to avoid firewalls
  	var axo = ['Active'].concat('Object').join('X');
  	if (axo in global) {
  	  try {
  	    HtmlfileReceiver.htmlfileEnabled = !!new global[axo]('htmlfile');
  	  } catch (x) {
  	    // intentionally empty
  	  }
  	}
  	
  	HtmlfileReceiver.enabled = HtmlfileReceiver.htmlfileEnabled || iframeUtils.iframeEnabled;
  	
  	module.exports = HtmlfileReceiver;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17), (function() { return this; }())))
  
  /***/ },
  /* 57 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , AjaxBasedTransport = __webpack_require__(34)
  	  , XhrReceiver = __webpack_require__(38)
  	  , XHRCorsObject = __webpack_require__(39)
  	  , XHRLocalObject = __webpack_require__(41)
  	  ;
  	
  	function XhrPollingTransport(transUrl) {
  	  if (!XHRLocalObject.enabled && !XHRCorsObject.enabled) {
  	    throw new Error('Transport created when disabled');
  	  }
  	  AjaxBasedTransport.call(this, transUrl, '/xhr', XhrReceiver, XHRCorsObject);
  	}
  	
  	inherits(XhrPollingTransport, AjaxBasedTransport);
  	
  	XhrPollingTransport.enabled = function(info) {
  	  if (info.nullOrigin) {
  	    return false;
  	  }
  	
  	  if (XHRLocalObject.enabled && info.sameOrigin) {
  	    return true;
  	  }
  	  return XHRCorsObject.enabled;
  	};
  	
  	XhrPollingTransport.transportName = 'xhr-polling';
  	XhrPollingTransport.roundTrips = 2; // preflight, ajax
  	
  	module.exports = XhrPollingTransport;
  
  
  /***/ },
  /* 58 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , AjaxBasedTransport = __webpack_require__(34)
  	  , XdrStreamingTransport = __webpack_require__(43)
  	  , XhrReceiver = __webpack_require__(38)
  	  , XDRObject = __webpack_require__(44)
  	  ;
  	
  	function XdrPollingTransport(transUrl) {
  	  if (!XDRObject.enabled) {
  	    throw new Error('Transport created when disabled');
  	  }
  	  AjaxBasedTransport.call(this, transUrl, '/xhr', XhrReceiver, XDRObject);
  	}
  	
  	inherits(XdrPollingTransport, AjaxBasedTransport);
  	
  	XdrPollingTransport.enabled = XdrStreamingTransport.enabled;
  	XdrPollingTransport.transportName = 'xdr-polling';
  	XdrPollingTransport.roundTrips = 2; // preflight, ajax
  	
  	module.exports = XdrPollingTransport;
  
  
  /***/ },
  /* 59 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	// The simplest and most robust transport, using the well-know cross
  	// domain hack - JSONP. This transport is quite inefficient - one
  	// message could use up to one http request. But at least it works almost
  	// everywhere.
  	// Known limitations:
  	//   o you will get a spinning cursor
  	//   o for Konqueror a dumb timer is needed to detect errors
  	
  	var inherits = __webpack_require__(29)
  	  , SenderReceiver = __webpack_require__(35)
  	  , JsonpReceiver = __webpack_require__(60)
  	  , jsonpSender = __webpack_require__(61)
  	  ;
  	
  	function JsonPTransport(transUrl) {
  	  if (!JsonPTransport.enabled()) {
  	    throw new Error('Transport created when disabled');
  	  }
  	  SenderReceiver.call(this, transUrl, '/jsonp', jsonpSender, JsonpReceiver);
  	}
  	
  	inherits(JsonPTransport, SenderReceiver);
  	
  	JsonPTransport.enabled = function() {
  	  return !!global.document;
  	};
  	
  	JsonPTransport.transportName = 'jsonp-polling';
  	JsonPTransport.roundTrips = 1;
  	JsonPTransport.needBody = true;
  	
  	module.exports = JsonPTransport;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 60 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process, global) {'use strict';
  	
  	var utils = __webpack_require__(53)
  	  , random = __webpack_require__(19)
  	  , browser = __webpack_require__(42)
  	  , urlUtils = __webpack_require__(21)
  	  , inherits = __webpack_require__(29)
  	  , EventEmitter = __webpack_require__(30).EventEmitter
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:receiver:jsonp');
  	}
  	
  	function JsonpReceiver(url) {
  	  debug(url);
  	  var self = this;
  	  EventEmitter.call(this);
  	
  	  utils.polluteGlobalNamespace();
  	
  	  this.id = 'a' + random.string(6);
  	  var urlWithId = urlUtils.addQuery(url, 'c=' + encodeURIComponent(utils.WPrefix + '.' + this.id));
  	
  	  global[utils.WPrefix][this.id] = this._callback.bind(this);
  	  this._createScript(urlWithId);
  	
  	  // Fallback mostly for Konqueror - stupid timer, 35 seconds shall be plenty.
  	  this.timeoutId = setTimeout(function() {
  	    debug('timeout');
  	    self._abort(new Error('JSONP script loaded abnormally (timeout)'));
  	  }, JsonpReceiver.timeout);
  	}
  	
  	inherits(JsonpReceiver, EventEmitter);
  	
  	JsonpReceiver.prototype.abort = function() {
  	  debug('abort');
  	  if (global[utils.WPrefix][this.id]) {
  	    var err = new Error('JSONP user aborted read');
  	    err.code = 1000;
  	    this._abort(err);
  	  }
  	};
  	
  	JsonpReceiver.timeout = 35000;
  	JsonpReceiver.scriptErrorTimeout = 1000;
  	
  	JsonpReceiver.prototype._callback = function(data) {
  	  debug('_callback', data);
  	  this._cleanup();
  	
  	  if (this.aborting) {
  	    return;
  	  }
  	
  	  if (data) {
  	    debug('message', data);
  	    this.emit('message', data);
  	  }
  	  this.emit('close', null, 'network');
  	  this.removeAllListeners();
  	};
  	
  	JsonpReceiver.prototype._abort = function(err) {
  	  debug('_abort', err);
  	  this._cleanup();
  	  this.aborting = true;
  	  this.emit('close', err.code, err.message);
  	  this.removeAllListeners();
  	};
  	
  	JsonpReceiver.prototype._cleanup = function() {
  	  debug('_cleanup');
  	  clearTimeout(this.timeoutId);
  	  if (this.script2) {
  	    this.script2.parentNode.removeChild(this.script2);
  	    this.script2 = null;
  	  }
  	  if (this.script) {
  	    var script = this.script;
  	    // Unfortunately, you can't really abort script loading of
  	    // the script.
  	    script.parentNode.removeChild(script);
  	    script.onreadystatechange = script.onerror =
  	        script.onload = script.onclick = null;
  	    this.script = null;
  	  }
  	  delete global[utils.WPrefix][this.id];
  	};
  	
  	JsonpReceiver.prototype._scriptError = function() {
  	  debug('_scriptError');
  	  var self = this;
  	  if (this.errorTimer) {
  	    return;
  	  }
  	
  	  this.errorTimer = setTimeout(function() {
  	    if (!self.loadedOkay) {
  	      self._abort(new Error('JSONP script loaded abnormally (onerror)'));
  	    }
  	  }, JsonpReceiver.scriptErrorTimeout);
  	};
  	
  	JsonpReceiver.prototype._createScript = function(url) {
  	  debug('_createScript', url);
  	  var self = this;
  	  var script = this.script = global.document.createElement('script');
  	  var script2;  // Opera synchronous load trick.
  	
  	  script.id = 'a' + random.string(8);
  	  script.src = url;
  	  script.type = 'text/javascript';
  	  script.charset = 'UTF-8';
  	  script.onerror = this._scriptError.bind(this);
  	  script.onload = function() {
  	    debug('onload');
  	    self._abort(new Error('JSONP script loaded abnormally (onload)'));
  	  };
  	
  	  // IE9 fires 'error' event after onreadystatechange or before, in random order.
  	  // Use loadedOkay to determine if actually errored
  	  script.onreadystatechange = function() {
  	    debug('onreadystatechange', script.readyState);
  	    if (/loaded|closed/.test(script.readyState)) {
  	      if (script && script.htmlFor && script.onclick) {
  	        self.loadedOkay = true;
  	        try {
  	          // In IE, actually execute the script.
  	          script.onclick();
  	        } catch (x) {
  	          // intentionally empty
  	        }
  	      }
  	      if (script) {
  	        self._abort(new Error('JSONP script loaded abnormally (onreadystatechange)'));
  	      }
  	    }
  	  };
  	  // IE: event/htmlFor/onclick trick.
  	  // One can't rely on proper order for onreadystatechange. In order to
  	  // make sure, set a 'htmlFor' and 'event' properties, so that
  	  // script code will be installed as 'onclick' handler for the
  	  // script object. Later, onreadystatechange, manually execute this
  	  // code. FF and Chrome doesn't work with 'event' and 'htmlFor'
  	  // set. For reference see:
  	  //   http://jaubourg.net/2010/07/loading-script-as-onclick-handler-of.html
  	  // Also, read on that about script ordering:
  	  //   http://wiki.whatwg.org/wiki/Dynamic_Script_Execution_Order
  	  if (typeof script.async === 'undefined' && global.document.attachEvent) {
  	    // According to mozilla docs, in recent browsers script.async defaults
  	    // to 'true', so we may use it to detect a good browser:
  	    // https://developer.mozilla.org/en/HTML/Element/script
  	    if (!browser.isOpera()) {
  	      // Naively assume we're in IE
  	      try {
  	        script.htmlFor = script.id;
  	        script.event = 'onclick';
  	      } catch (x) {
  	        // intentionally empty
  	      }
  	      script.async = true;
  	    } else {
  	      // Opera, second sync script hack
  	      script2 = this.script2 = global.document.createElement('script');
  	      script2.text = "try{var a = document.getElementById('" + script.id + "'); if(a)a.onerror();}catch(x){};";
  	      script.async = script2.async = false;
  	    }
  	  }
  	  if (typeof script.async !== 'undefined') {
  	    script.async = true;
  	  }
  	
  	  var head = global.document.getElementsByTagName('head')[0];
  	  head.insertBefore(script, head.firstChild);
  	  if (script2) {
  	    head.insertBefore(script2, head.firstChild);
  	  }
  	};
  	
  	module.exports = JsonpReceiver;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17), (function() { return this; }())))
  
  /***/ },
  /* 61 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process, global) {'use strict';
  	
  	var random = __webpack_require__(19)
  	  , urlUtils = __webpack_require__(21)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:sender:jsonp');
  	}
  	
  	var form, area;
  	
  	function createIframe(id) {
  	  debug('createIframe', id);
  	  try {
  	    // ie6 dynamic iframes with target="" support (thanks Chris Lambacher)
  	    return global.document.createElement('<iframe name="' + id + '">');
  	  } catch (x) {
  	    var iframe = global.document.createElement('iframe');
  	    iframe.name = id;
  	    return iframe;
  	  }
  	}
  	
  	function createForm() {
  	  debug('createForm');
  	  form = global.document.createElement('form');
  	  form.style.display = 'none';
  	  form.style.position = 'absolute';
  	  form.method = 'POST';
  	  form.enctype = 'application/x-www-form-urlencoded';
  	  form.acceptCharset = 'UTF-8';
  	
  	  area = global.document.createElement('textarea');
  	  area.name = 'd';
  	  form.appendChild(area);
  	
  	  global.document.body.appendChild(form);
  	}
  	
  	module.exports = function(url, payload, callback) {
  	  debug(url, payload);
  	  if (!form) {
  	    createForm();
  	  }
  	  var id = 'a' + random.string(8);
  	  form.target = id;
  	  form.action = urlUtils.addQuery(urlUtils.addPath(url, '/jsonp_send'), 'i=' + id);
  	
  	  var iframe = createIframe(id);
  	  iframe.id = id;
  	  iframe.style.display = 'none';
  	  form.appendChild(iframe);
  	
  	  try {
  	    area.value = payload;
  	  } catch (e) {
  	    // seriously broken browsers get here
  	  }
  	  form.submit();
  	
  	  var completed = function(err) {
  	    debug('completed', id, err);
  	    if (!iframe.onerror) {
  	      return;
  	    }
  	    iframe.onreadystatechange = iframe.onerror = iframe.onload = null;
  	    // Opera mini doesn't like if we GC iframe
  	    // immediately, thus this timeout.
  	    setTimeout(function() {
  	      debug('cleaning up', id);
  	      iframe.parentNode.removeChild(iframe);
  	      iframe = null;
  	    }, 500);
  	    area.value = '';
  	    // It is not possible to detect if the iframe succeeded or
  	    // failed to submit our form.
  	    callback(err);
  	  };
  	  iframe.onerror = function() {
  	    debug('onerror', id);
  	    completed();
  	  };
  	  iframe.onload = function() {
  	    debug('onload', id);
  	    completed();
  	  };
  	  iframe.onreadystatechange = function(e) {
  	    debug('onreadystatechange', id, iframe.readyState, e);
  	    if (iframe.readyState === 'complete') {
  	      completed();
  	    }
  	  };
  	  return function() {
  	    debug('aborted', id);
  	    completed(new Error('Aborted'));
  	  };
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17), (function() { return this; }())))
  
  /***/ },
  /* 62 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process, global) {'use strict';
  	
  	__webpack_require__(63);
  	
  	var URL = __webpack_require__(22)
  	  , inherits = __webpack_require__(29)
  	  , JSON3 = __webpack_require__(50)
  	  , random = __webpack_require__(19)
  	  , escape = __webpack_require__(64)
  	  , urlUtils = __webpack_require__(21)
  	  , eventUtils = __webpack_require__(18)
  	  , transport = __webpack_require__(65)
  	  , objectUtils = __webpack_require__(54)
  	  , browser = __webpack_require__(42)
  	  , log = __webpack_require__(66)
  	  , Event = __webpack_require__(67)
  	  , EventTarget = __webpack_require__(31)
  	  , loc = __webpack_require__(68)
  	  , CloseEvent = __webpack_require__(69)
  	  , TransportMessageEvent = __webpack_require__(70)
  	  , InfoReceiver = __webpack_require__(71)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:main');
  	}
  	
  	var transports;
  	
  	// follow constructor steps defined at http://dev.w3.org/html5/websockets/#the-websocket-interface
  	function SockJS(url, protocols, options) {
  	  if (!(this instanceof SockJS)) {
  	    return new SockJS(url, protocols, options);
  	  }
  	  if (arguments.length < 1) {
  	    throw new TypeError("Failed to construct 'SockJS: 1 argument required, but only 0 present");
  	  }
  	  EventTarget.call(this);
  	
  	  this.readyState = SockJS.CONNECTING;
  	  this.extensions = '';
  	  this.protocol = '';
  	
  	  // non-standard extension
  	  options = options || {};
  	  if (options.protocols_whitelist) {
  	    log.warn("'protocols_whitelist' is DEPRECATED. Use 'transports' instead.");
  	  }
  	  this._transportsWhitelist = options.transports;
  	  this._transportOptions = options.transportOptions || {};
  	
  	  var sessionId = options.sessionId || 8;
  	  if (typeof sessionId === 'function') {
  	    this._generateSessionId = sessionId;
  	  } else if (typeof sessionId === 'number') {
  	    this._generateSessionId = function() {
  	      return random.string(sessionId);
  	    };
  	  } else {
  	    throw new TypeError('If sessionId is used in the options, it needs to be a number or a function.');
  	  }
  	
  	  this._server = options.server || random.numberString(1000);
  	
  	  // Step 1 of WS spec - parse and validate the url. Issue #8
  	  var parsedUrl = new URL(url);
  	  if (!parsedUrl.host || !parsedUrl.protocol) {
  	    throw new SyntaxError("The URL '" + url + "' is invalid");
  	  } else if (parsedUrl.hash) {
  	    throw new SyntaxError('The URL must not contain a fragment');
  	  } else if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
  	    throw new SyntaxError("The URL's scheme must be either 'http:' or 'https:'. '" + parsedUrl.protocol + "' is not allowed.");
  	  }
  	
  	  var secure = parsedUrl.protocol === 'https:';
  	  // Step 2 - don't allow secure origin with an insecure protocol
  	  if (loc.protocol === 'https' && !secure) {
  	    throw new Error('SecurityError: An insecure SockJS connection may not be initiated from a page loaded over HTTPS');
  	  }
  	
  	  // Step 3 - check port access - no need here
  	  // Step 4 - parse protocols argument
  	  if (!protocols) {
  	    protocols = [];
  	  } else if (!Array.isArray(protocols)) {
  	    protocols = [protocols];
  	  }
  	
  	  // Step 5 - check protocols argument
  	  var sortedProtocols = protocols.sort();
  	  sortedProtocols.forEach(function(proto, i) {
  	    if (!proto) {
  	      throw new SyntaxError("The protocols entry '" + proto + "' is invalid.");
  	    }
  	    if (i < (sortedProtocols.length - 1) && proto === sortedProtocols[i + 1]) {
  	      throw new SyntaxError("The protocols entry '" + proto + "' is duplicated.");
  	    }
  	  });
  	
  	  // Step 6 - convert origin
  	  var o = urlUtils.getOrigin(loc.href);
  	  this._origin = o ? o.toLowerCase() : null;
  	
  	  // remove the trailing slash
  	  parsedUrl.set('pathname', parsedUrl.pathname.replace(/\/+$/, ''));
  	
  	  // store the sanitized url
  	  this.url = parsedUrl.href;
  	  debug('using url', this.url);
  	
  	  // Step 7 - start connection in background
  	  // obtain server info
  	  // http://sockjs.github.io/sockjs-protocol/sockjs-protocol-0.3.3.html#section-26
  	  this._urlInfo = {
  	    nullOrigin: !browser.hasDomain()
  	  , sameOrigin: urlUtils.isOriginEqual(this.url, loc.href)
  	  , sameScheme: urlUtils.isSchemeEqual(this.url, loc.href)
  	  };
  	
  	  this._ir = new InfoReceiver(this.url, this._urlInfo);
  	  this._ir.once('finish', this._receiveInfo.bind(this));
  	}
  	
  	inherits(SockJS, EventTarget);
  	
  	function userSetCode(code) {
  	  return code === 1000 || (code >= 3000 && code <= 4999);
  	}
  	
  	SockJS.prototype.close = function(code, reason) {
  	  // Step 1
  	  if (code && !userSetCode(code)) {
  	    throw new Error('InvalidAccessError: Invalid code');
  	  }
  	  // Step 2.4 states the max is 123 bytes, but we are just checking length
  	  if (reason && reason.length > 123) {
  	    throw new SyntaxError('reason argument has an invalid length');
  	  }
  	
  	  // Step 3.1
  	  if (this.readyState === SockJS.CLOSING || this.readyState === SockJS.CLOSED) {
  	    return;
  	  }
  	
  	  // TODO look at docs to determine how to set this
  	  var wasClean = true;
  	  this._close(code || 1000, reason || 'Normal closure', wasClean);
  	};
  	
  	SockJS.prototype.send = function(data) {
  	  // #13 - convert anything non-string to string
  	  // TODO this currently turns objects into [object Object]
  	  if (typeof data !== 'string') {
  	    data = '' + data;
  	  }
  	  if (this.readyState === SockJS.CONNECTING) {
  	    throw new Error('InvalidStateError: The connection has not been established yet');
  	  }
  	  if (this.readyState !== SockJS.OPEN) {
  	    return;
  	  }
  	  this._transport.send(escape.quote(data));
  	};
  	
  	SockJS.version = __webpack_require__(52);
  	
  	SockJS.CONNECTING = 0;
  	SockJS.OPEN = 1;
  	SockJS.CLOSING = 2;
  	SockJS.CLOSED = 3;
  	
  	SockJS.prototype._receiveInfo = function(info, rtt) {
  	  debug('_receiveInfo', rtt);
  	  this._ir = null;
  	  if (!info) {
  	    this._close(1002, 'Cannot connect to server');
  	    return;
  	  }
  	
  	  // establish a round-trip timeout (RTO) based on the
  	  // round-trip time (RTT)
  	  this._rto = this.countRTO(rtt);
  	  // allow server to override url used for the actual transport
  	  this._transUrl = info.base_url ? info.base_url : this.url;
  	  info = objectUtils.extend(info, this._urlInfo);
  	  debug('info', info);
  	  // determine list of desired and supported transports
  	  var enabledTransports = transports.filterToEnabled(this._transportsWhitelist, info);
  	  this._transports = enabledTransports.main;
  	  debug(this._transports.length + ' enabled transports');
  	
  	  this._connect();
  	};
  	
  	SockJS.prototype._connect = function() {
  	  for (var Transport = this._transports.shift(); Transport; Transport = this._transports.shift()) {
  	    debug('attempt', Transport.transportName);
  	    if (Transport.needBody) {
  	      if (!global.document.body ||
  	          (typeof global.document.readyState !== 'undefined' &&
  	            global.document.readyState !== 'complete' &&
  	            global.document.readyState !== 'interactive')) {
  	        debug('waiting for body');
  	        this._transports.unshift(Transport);
  	        eventUtils.attachEvent('load', this._connect.bind(this));
  	        return;
  	      }
  	    }
  	
  	    // calculate timeout based on RTO and round trips. Default to 5s
  	    var timeoutMs = (this._rto * Transport.roundTrips) || 5000;
  	    this._transportTimeoutId = setTimeout(this._transportTimeout.bind(this), timeoutMs);
  	    debug('using timeout', timeoutMs);
  	
  	    var transportUrl = urlUtils.addPath(this._transUrl, '/' + this._server + '/' + this._generateSessionId());
  	    var options = this._transportOptions[Transport.transportName];
  	    debug('transport url', transportUrl);
  	    var transportObj = new Transport(transportUrl, this._transUrl, options);
  	    transportObj.on('message', this._transportMessage.bind(this));
  	    transportObj.once('close', this._transportClose.bind(this));
  	    transportObj.transportName = Transport.transportName;
  	    this._transport = transportObj;
  	
  	    return;
  	  }
  	  this._close(2000, 'All transports failed', false);
  	};
  	
  	SockJS.prototype._transportTimeout = function() {
  	  debug('_transportTimeout');
  	  if (this.readyState === SockJS.CONNECTING) {
  	    this._transportClose(2007, 'Transport timed out');
  	  }
  	};
  	
  	SockJS.prototype._transportMessage = function(msg) {
  	  debug('_transportMessage', msg);
  	  var self = this
  	    , type = msg.slice(0, 1)
  	    , content = msg.slice(1)
  	    , payload
  	    ;
  	
  	  // first check for messages that don't need a payload
  	  switch (type) {
  	    case 'o':
  	      this._open();
  	      return;
  	    case 'h':
  	      this.dispatchEvent(new Event('heartbeat'));
  	      debug('heartbeat', this.transport);
  	      return;
  	  }
  	
  	  if (content) {
  	    try {
  	      payload = JSON3.parse(content);
  	    } catch (e) {
  	      debug('bad json', content);
  	    }
  	  }
  	
  	  if (typeof payload === 'undefined') {
  	    debug('empty payload', content);
  	    return;
  	  }
  	
  	  switch (type) {
  	    case 'a':
  	      if (Array.isArray(payload)) {
  	        payload.forEach(function(p) {
  	          debug('message', self.transport, p);
  	          self.dispatchEvent(new TransportMessageEvent(p));
  	        });
  	      }
  	      break;
  	    case 'm':
  	      debug('message', this.transport, payload);
  	      this.dispatchEvent(new TransportMessageEvent(payload));
  	      break;
  	    case 'c':
  	      if (Array.isArray(payload) && payload.length === 2) {
  	        this._close(payload[0], payload[1], true);
  	      }
  	      break;
  	  }
  	};
  	
  	SockJS.prototype._transportClose = function(code, reason) {
  	  debug('_transportClose', this.transport, code, reason);
  	  if (this._transport) {
  	    this._transport.removeAllListeners();
  	    this._transport = null;
  	    this.transport = null;
  	  }
  	
  	  if (!userSetCode(code) && code !== 2000 && this.readyState === SockJS.CONNECTING) {
  	    this._connect();
  	    return;
  	  }
  	
  	  this._close(code, reason);
  	};
  	
  	SockJS.prototype._open = function() {
  	  debug('_open', this._transport.transportName, this.readyState);
  	  if (this.readyState === SockJS.CONNECTING) {
  	    if (this._transportTimeoutId) {
  	      clearTimeout(this._transportTimeoutId);
  	      this._transportTimeoutId = null;
  	    }
  	    this.readyState = SockJS.OPEN;
  	    this.transport = this._transport.transportName;
  	    this.dispatchEvent(new Event('open'));
  	    debug('connected', this.transport);
  	  } else {
  	    // The server might have been restarted, and lost track of our
  	    // connection.
  	    this._close(1006, 'Server lost session');
  	  }
  	};
  	
  	SockJS.prototype._close = function(code, reason, wasClean) {
  	  debug('_close', this.transport, code, reason, wasClean, this.readyState);
  	  var forceFail = false;
  	
  	  if (this._ir) {
  	    forceFail = true;
  	    this._ir.close();
  	    this._ir = null;
  	  }
  	  if (this._transport) {
  	    this._transport.close();
  	    this._transport = null;
  	    this.transport = null;
  	  }
  	
  	  if (this.readyState === SockJS.CLOSED) {
  	    throw new Error('InvalidStateError: SockJS has already been closed');
  	  }
  	
  	  this.readyState = SockJS.CLOSING;
  	  setTimeout(function() {
  	    this.readyState = SockJS.CLOSED;
  	
  	    if (forceFail) {
  	      this.dispatchEvent(new Event('error'));
  	    }
  	
  	    var e = new CloseEvent('close');
  	    e.wasClean = wasClean || false;
  	    e.code = code || 1000;
  	    e.reason = reason;
  	
  	    this.dispatchEvent(e);
  	    this.onmessage = this.onclose = this.onerror = null;
  	    debug('disconnected');
  	  }.bind(this), 0);
  	};
  	
  	// See: http://www.erg.abdn.ac.uk/~gerrit/dccp/notes/ccid2/rto_estimator/
  	// and RFC 2988.
  	SockJS.prototype.countRTO = function(rtt) {
  	  // In a local environment, when using IE8/9 and the `jsonp-polling`
  	  // transport the time needed to establish a connection (the time that pass
  	  // from the opening of the transport to the call of `_dispatchOpen`) is
  	  // around 200msec (the lower bound used in the article above) and this
  	  // causes spurious timeouts. For this reason we calculate a value slightly
  	  // larger than that used in the article.
  	  if (rtt > 100) {
  	    return 4 * rtt; // rto > 400msec
  	  }
  	  return 300 + rtt; // 300msec < rto <= 400msec
  	};
  	
  	module.exports = function(availableTransports) {
  	  transports = transport(availableTransports);
  	  __webpack_require__(76)(SockJS, availableTransports);
  	  return SockJS;
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17), (function() { return this; }())))
  
  /***/ },
  /* 63 */
  /***/ function(module, exports) {
  
  	/* eslint-disable */
  	/* jscs: disable */
  	'use strict';
  	
  	// pulled specific shims from https://github.com/es-shims/es5-shim
  	
  	var ArrayPrototype = Array.prototype;
  	var ObjectPrototype = Object.prototype;
  	var FunctionPrototype = Function.prototype;
  	var StringPrototype = String.prototype;
  	var array_slice = ArrayPrototype.slice;
  	
  	var _toString = ObjectPrototype.toString;
  	var isFunction = function (val) {
  	    return ObjectPrototype.toString.call(val) === '[object Function]';
  	};
  	var isArray = function isArray(obj) {
  	    return _toString.call(obj) === '[object Array]';
  	};
  	var isString = function isString(obj) {
  	    return _toString.call(obj) === '[object String]';
  	};
  	
  	var supportsDescriptors = Object.defineProperty && (function () {
  	    try {
  	        Object.defineProperty({}, 'x', {});
  	        return true;
  	    } catch (e) { /* this is ES3 */
  	        return false;
  	    }
  	}());
  	
  	// Define configurable, writable and non-enumerable props
  	// if they don't exist.
  	var defineProperty;
  	if (supportsDescriptors) {
  	    defineProperty = function (object, name, method, forceAssign) {
  	        if (!forceAssign && (name in object)) { return; }
  	        Object.defineProperty(object, name, {
  	            configurable: true,
  	            enumerable: false,
  	            writable: true,
  	            value: method
  	        });
  	    };
  	} else {
  	    defineProperty = function (object, name, method, forceAssign) {
  	        if (!forceAssign && (name in object)) { return; }
  	        object[name] = method;
  	    };
  	}
  	var defineProperties = function (object, map, forceAssign) {
  	    for (var name in map) {
  	        if (ObjectPrototype.hasOwnProperty.call(map, name)) {
  	          defineProperty(object, name, map[name], forceAssign);
  	        }
  	    }
  	};
  	
  	var toObject = function (o) {
  	    if (o == null) { // this matches both null and undefined
  	        throw new TypeError("can't convert " + o + ' to object');
  	    }
  	    return Object(o);
  	};
  	
  	//
  	// Util
  	// ======
  	//
  	
  	// ES5 9.4
  	// http://es5.github.com/#x9.4
  	// http://jsperf.com/to-integer
  	
  	function toInteger(num) {
  	    var n = +num;
  	    if (n !== n) { // isNaN
  	        n = 0;
  	    } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
  	        n = (n > 0 || -1) * Math.floor(Math.abs(n));
  	    }
  	    return n;
  	}
  	
  	function ToUint32(x) {
  	    return x >>> 0;
  	}
  	
  	//
  	// Function
  	// ========
  	//
  	
  	// ES-5 15.3.4.5
  	// http://es5.github.com/#x15.3.4.5
  	
  	function Empty() {}
  	
  	defineProperties(FunctionPrototype, {
  	    bind: function bind(that) { // .length is 1
  	        // 1. Let Target be the this value.
  	        var target = this;
  	        // 2. If IsCallable(Target) is false, throw a TypeError exception.
  	        if (!isFunction(target)) {
  	            throw new TypeError('Function.prototype.bind called on incompatible ' + target);
  	        }
  	        // 3. Let A be a new (possibly empty) internal list of all of the
  	        //   argument values provided after thisArg (arg1, arg2 etc), in order.
  	        // XXX slicedArgs will stand in for "A" if used
  	        var args = array_slice.call(arguments, 1); // for normal call
  	        // 4. Let F be a new native ECMAScript object.
  	        // 11. Set the [[Prototype]] internal property of F to the standard
  	        //   built-in Function prototype object as specified in 15.3.3.1.
  	        // 12. Set the [[Call]] internal property of F as described in
  	        //   15.3.4.5.1.
  	        // 13. Set the [[Construct]] internal property of F as described in
  	        //   15.3.4.5.2.
  	        // 14. Set the [[HasInstance]] internal property of F as described in
  	        //   15.3.4.5.3.
  	        var binder = function () {
  	
  	            if (this instanceof bound) {
  	                // 15.3.4.5.2 [[Construct]]
  	                // When the [[Construct]] internal method of a function object,
  	                // F that was created using the bind function is called with a
  	                // list of arguments ExtraArgs, the following steps are taken:
  	                // 1. Let target be the value of F's [[TargetFunction]]
  	                //   internal property.
  	                // 2. If target has no [[Construct]] internal method, a
  	                //   TypeError exception is thrown.
  	                // 3. Let boundArgs be the value of F's [[BoundArgs]] internal
  	                //   property.
  	                // 4. Let args be a new list containing the same values as the
  	                //   list boundArgs in the same order followed by the same
  	                //   values as the list ExtraArgs in the same order.
  	                // 5. Return the result of calling the [[Construct]] internal
  	                //   method of target providing args as the arguments.
  	
  	                var result = target.apply(
  	                    this,
  	                    args.concat(array_slice.call(arguments))
  	                );
  	                if (Object(result) === result) {
  	                    return result;
  	                }
  	                return this;
  	
  	            } else {
  	                // 15.3.4.5.1 [[Call]]
  	                // When the [[Call]] internal method of a function object, F,
  	                // which was created using the bind function is called with a
  	                // this value and a list of arguments ExtraArgs, the following
  	                // steps are taken:
  	                // 1. Let boundArgs be the value of F's [[BoundArgs]] internal
  	                //   property.
  	                // 2. Let boundThis be the value of F's [[BoundThis]] internal
  	                //   property.
  	                // 3. Let target be the value of F's [[TargetFunction]] internal
  	                //   property.
  	                // 4. Let args be a new list containing the same values as the
  	                //   list boundArgs in the same order followed by the same
  	                //   values as the list ExtraArgs in the same order.
  	                // 5. Return the result of calling the [[Call]] internal method
  	                //   of target providing boundThis as the this value and
  	                //   providing args as the arguments.
  	
  	                // equiv: target.call(this, ...boundArgs, ...args)
  	                return target.apply(
  	                    that,
  	                    args.concat(array_slice.call(arguments))
  	                );
  	
  	            }
  	
  	        };
  	
  	        // 15. If the [[Class]] internal property of Target is "Function", then
  	        //     a. Let L be the length property of Target minus the length of A.
  	        //     b. Set the length own property of F to either 0 or L, whichever is
  	        //       larger.
  	        // 16. Else set the length own property of F to 0.
  	
  	        var boundLength = Math.max(0, target.length - args.length);
  	
  	        // 17. Set the attributes of the length own property of F to the values
  	        //   specified in 15.3.5.1.
  	        var boundArgs = [];
  	        for (var i = 0; i < boundLength; i++) {
  	            boundArgs.push('$' + i);
  	        }
  	
  	        // XXX Build a dynamic function with desired amount of arguments is the only
  	        // way to set the length property of a function.
  	        // In environments where Content Security Policies enabled (Chrome extensions,
  	        // for ex.) all use of eval or Function costructor throws an exception.
  	        // However in all of these environments Function.prototype.bind exists
  	        // and so this code will never be executed.
  	        var bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this, arguments); }')(binder);
  	
  	        if (target.prototype) {
  	            Empty.prototype = target.prototype;
  	            bound.prototype = new Empty();
  	            // Clean up dangling references.
  	            Empty.prototype = null;
  	        }
  	
  	        // TODO
  	        // 18. Set the [[Extensible]] internal property of F to true.
  	
  	        // TODO
  	        // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
  	        // 20. Call the [[DefineOwnProperty]] internal method of F with
  	        //   arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
  	        //   thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
  	        //   false.
  	        // 21. Call the [[DefineOwnProperty]] internal method of F with
  	        //   arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
  	        //   [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},
  	        //   and false.
  	
  	        // TODO
  	        // NOTE Function objects created using Function.prototype.bind do not
  	        // have a prototype property or the [[Code]], [[FormalParameters]], and
  	        // [[Scope]] internal properties.
  	        // XXX can't delete prototype in pure-js.
  	
  	        // 22. Return F.
  	        return bound;
  	    }
  	});
  	
  	//
  	// Array
  	// =====
  	//
  	
  	// ES5 15.4.3.2
  	// http://es5.github.com/#x15.4.3.2
  	// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
  	defineProperties(Array, { isArray: isArray });
  	
  	
  	var boxedString = Object('a');
  	var splitString = boxedString[0] !== 'a' || !(0 in boxedString);
  	
  	var properlyBoxesContext = function properlyBoxed(method) {
  	    // Check node 0.6.21 bug where third parameter is not boxed
  	    var properlyBoxesNonStrict = true;
  	    var properlyBoxesStrict = true;
  	    if (method) {
  	        method.call('foo', function (_, __, context) {
  	            if (typeof context !== 'object') { properlyBoxesNonStrict = false; }
  	        });
  	
  	        method.call([1], function () {
  	            'use strict';
  	            properlyBoxesStrict = typeof this === 'string';
  	        }, 'x');
  	    }
  	    return !!method && properlyBoxesNonStrict && properlyBoxesStrict;
  	};
  	
  	defineProperties(ArrayPrototype, {
  	    forEach: function forEach(fun /*, thisp*/) {
  	        var object = toObject(this),
  	            self = splitString && isString(this) ? this.split('') : object,
  	            thisp = arguments[1],
  	            i = -1,
  	            length = self.length >>> 0;
  	
  	        // If no callback function or if callback is not a callable function
  	        if (!isFunction(fun)) {
  	            throw new TypeError(); // TODO message
  	        }
  	
  	        while (++i < length) {
  	            if (i in self) {
  	                // Invoke the callback function with call, passing arguments:
  	                // context, property value, property key, thisArg object
  	                // context
  	                fun.call(thisp, self[i], i, object);
  	            }
  	        }
  	    }
  	}, !properlyBoxesContext(ArrayPrototype.forEach));
  	
  	// ES5 15.4.4.14
  	// http://es5.github.com/#x15.4.4.14
  	// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
  	var hasFirefox2IndexOfBug = Array.prototype.indexOf && [0, 1].indexOf(1, 2) !== -1;
  	defineProperties(ArrayPrototype, {
  	    indexOf: function indexOf(sought /*, fromIndex */ ) {
  	        var self = splitString && isString(this) ? this.split('') : toObject(this),
  	            length = self.length >>> 0;
  	
  	        if (!length) {
  	            return -1;
  	        }
  	
  	        var i = 0;
  	        if (arguments.length > 1) {
  	            i = toInteger(arguments[1]);
  	        }
  	
  	        // handle negative indices
  	        i = i >= 0 ? i : Math.max(0, length + i);
  	        for (; i < length; i++) {
  	            if (i in self && self[i] === sought) {
  	                return i;
  	            }
  	        }
  	        return -1;
  	    }
  	}, hasFirefox2IndexOfBug);
  	
  	//
  	// String
  	// ======
  	//
  	
  	// ES5 15.5.4.14
  	// http://es5.github.com/#x15.5.4.14
  	
  	// [bugfix, IE lt 9, firefox 4, Konqueror, Opera, obscure browsers]
  	// Many browsers do not split properly with regular expressions or they
  	// do not perform the split correctly under obscure conditions.
  	// See http://blog.stevenlevithan.com/archives/cross-browser-split
  	// I've tested in many browsers and this seems to cover the deviant ones:
  	//    'ab'.split(/(?:ab)*/) should be ["", ""], not [""]
  	//    '.'.split(/(.?)(.?)/) should be ["", ".", "", ""], not ["", ""]
  	//    'tesst'.split(/(s)*/) should be ["t", undefined, "e", "s", "t"], not
  	//       [undefined, "t", undefined, "e", ...]
  	//    ''.split(/.?/) should be [], not [""]
  	//    '.'.split(/()()/) should be ["."], not ["", "", "."]
  	
  	var string_split = StringPrototype.split;
  	if (
  	    'ab'.split(/(?:ab)*/).length !== 2 ||
  	    '.'.split(/(.?)(.?)/).length !== 4 ||
  	    'tesst'.split(/(s)*/)[1] === 't' ||
  	    'test'.split(/(?:)/, -1).length !== 4 ||
  	    ''.split(/.?/).length ||
  	    '.'.split(/()()/).length > 1
  	) {
  	    (function () {
  	        var compliantExecNpcg = /()??/.exec('')[1] === void 0; // NPCG: nonparticipating capturing group
  	
  	        StringPrototype.split = function (separator, limit) {
  	            var string = this;
  	            if (separator === void 0 && limit === 0) {
  	                return [];
  	            }
  	
  	            // If `separator` is not a regex, use native split
  	            if (_toString.call(separator) !== '[object RegExp]') {
  	                return string_split.call(this, separator, limit);
  	            }
  	
  	            var output = [],
  	                flags = (separator.ignoreCase ? 'i' : '') +
  	                        (separator.multiline  ? 'm' : '') +
  	                        (separator.extended   ? 'x' : '') + // Proposed for ES6
  	                        (separator.sticky     ? 'y' : ''), // Firefox 3+
  	                lastLastIndex = 0,
  	                // Make `global` and avoid `lastIndex` issues by working with a copy
  	                separator2, match, lastIndex, lastLength;
  	            separator = new RegExp(separator.source, flags + 'g');
  	            string += ''; // Type-convert
  	            if (!compliantExecNpcg) {
  	                // Doesn't need flags gy, but they don't hurt
  	                separator2 = new RegExp('^' + separator.source + '$(?!\\s)', flags);
  	            }
  	            /* Values for `limit`, per the spec:
  	             * If undefined: 4294967295 // Math.pow(2, 32) - 1
  	             * If 0, Infinity, or NaN: 0
  	             * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;
  	             * If negative number: 4294967296 - Math.floor(Math.abs(limit))
  	             * If other: Type-convert, then use the above rules
  	             */
  	            limit = limit === void 0 ?
  	                -1 >>> 0 : // Math.pow(2, 32) - 1
  	                ToUint32(limit);
  	            while (match = separator.exec(string)) {
  	                // `separator.lastIndex` is not reliable cross-browser
  	                lastIndex = match.index + match[0].length;
  	                if (lastIndex > lastLastIndex) {
  	                    output.push(string.slice(lastLastIndex, match.index));
  	                    // Fix browsers whose `exec` methods don't consistently return `undefined` for
  	                    // nonparticipating capturing groups
  	                    if (!compliantExecNpcg && match.length > 1) {
  	                        match[0].replace(separator2, function () {
  	                            for (var i = 1; i < arguments.length - 2; i++) {
  	                                if (arguments[i] === void 0) {
  	                                    match[i] = void 0;
  	                                }
  	                            }
  	                        });
  	                    }
  	                    if (match.length > 1 && match.index < string.length) {
  	                        ArrayPrototype.push.apply(output, match.slice(1));
  	                    }
  	                    lastLength = match[0].length;
  	                    lastLastIndex = lastIndex;
  	                    if (output.length >= limit) {
  	                        break;
  	                    }
  	                }
  	                if (separator.lastIndex === match.index) {
  	                    separator.lastIndex++; // Avoid an infinite loop
  	                }
  	            }
  	            if (lastLastIndex === string.length) {
  	                if (lastLength || !separator.test('')) {
  	                    output.push('');
  	                }
  	            } else {
  	                output.push(string.slice(lastLastIndex));
  	            }
  	            return output.length > limit ? output.slice(0, limit) : output;
  	        };
  	    }());
  	
  	// [bugfix, chrome]
  	// If separator is undefined, then the result array contains just one String,
  	// which is the this value (converted to a String). If limit is not undefined,
  	// then the output array is truncated so that it contains no more than limit
  	// elements.
  	// "0".split(undefined, 0) -> []
  	} else if ('0'.split(void 0, 0).length) {
  	    StringPrototype.split = function split(separator, limit) {
  	        if (separator === void 0 && limit === 0) { return []; }
  	        return string_split.call(this, separator, limit);
  	    };
  	}
  	
  	// ECMA-262, 3rd B.2.3
  	// Not an ECMAScript standard, although ECMAScript 3rd Edition has a
  	// non-normative section suggesting uniform semantics and it should be
  	// normalized across all browsers
  	// [bugfix, IE lt 9] IE < 9 substr() with negative value not working in IE
  	var string_substr = StringPrototype.substr;
  	var hasNegativeSubstrBug = ''.substr && '0b'.substr(-1) !== 'b';
  	defineProperties(StringPrototype, {
  	    substr: function substr(start, length) {
  	        return string_substr.call(
  	            this,
  	            start < 0 ? ((start = this.length + start) < 0 ? 0 : start) : start,
  	            length
  	        );
  	    }
  	}, hasNegativeSubstrBug);
  
  
  /***/ },
  /* 64 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var JSON3 = __webpack_require__(50);
  	
  	// Some extra characters that Chrome gets wrong, and substitutes with
  	// something else on the wire.
  	// eslint-disable-next-line no-control-regex
  	var extraEscapable = /[\x00-\x1f\ud800-\udfff\ufffe\uffff\u0300-\u0333\u033d-\u0346\u034a-\u034c\u0350-\u0352\u0357-\u0358\u035c-\u0362\u0374\u037e\u0387\u0591-\u05af\u05c4\u0610-\u0617\u0653-\u0654\u0657-\u065b\u065d-\u065e\u06df-\u06e2\u06eb-\u06ec\u0730\u0732-\u0733\u0735-\u0736\u073a\u073d\u073f-\u0741\u0743\u0745\u0747\u07eb-\u07f1\u0951\u0958-\u095f\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b5c-\u0b5d\u0e38-\u0e39\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f72-\u0f76\u0f78\u0f80-\u0f83\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1939-\u193a\u1a17\u1b6b\u1cda-\u1cdb\u1dc0-\u1dcf\u1dfc\u1dfe\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1fbb\u1fbe\u1fc9\u1fcb\u1fd3\u1fdb\u1fe3\u1feb\u1fee-\u1fef\u1ff9\u1ffb\u1ffd\u2000-\u2001\u20d0-\u20d1\u20d4-\u20d7\u20e7-\u20e9\u2126\u212a-\u212b\u2329-\u232a\u2adc\u302b-\u302c\uaab2-\uaab3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa2d\ufa30-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\ufff0-\uffff]/g
  	  , extraLookup;
  	
  	// This may be quite slow, so let's delay until user actually uses bad
  	// characters.
  	var unrollLookup = function(escapable) {
  	  var i;
  	  var unrolled = {};
  	  var c = [];
  	  for (i = 0; i < 65536; i++) {
  	    c.push( String.fromCharCode(i) );
  	  }
  	  escapable.lastIndex = 0;
  	  c.join('').replace(escapable, function(a) {
  	    unrolled[ a ] = '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
  	    return '';
  	  });
  	  escapable.lastIndex = 0;
  	  return unrolled;
  	};
  	
  	// Quote string, also taking care of unicode characters that browsers
  	// often break. Especially, take care of unicode surrogates:
  	// http://en.wikipedia.org/wiki/Mapping_of_Unicode_characters#Surrogates
  	module.exports = {
  	  quote: function(string) {
  	    var quoted = JSON3.stringify(string);
  	
  	    // In most cases this should be very fast and good enough.
  	    extraEscapable.lastIndex = 0;
  	    if (!extraEscapable.test(quoted)) {
  	      return quoted;
  	    }
  	
  	    if (!extraLookup) {
  	      extraLookup = unrollLookup(extraEscapable);
  	    }
  	
  	    return quoted.replace(extraEscapable, function(a) {
  	      return extraLookup[a];
  	    });
  	  }
  	};
  
  
  /***/ },
  /* 65 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:utils:transport');
  	}
  	
  	module.exports = function(availableTransports) {
  	  return {
  	    filterToEnabled: function(transportsWhitelist, info) {
  	      var transports = {
  	        main: []
  	      , facade: []
  	      };
  	      if (!transportsWhitelist) {
  	        transportsWhitelist = [];
  	      } else if (typeof transportsWhitelist === 'string') {
  	        transportsWhitelist = [transportsWhitelist];
  	      }
  	
  	      availableTransports.forEach(function(trans) {
  	        if (!trans) {
  	          return;
  	        }
  	
  	        if (trans.transportName === 'websocket' && info.websocket === false) {
  	          debug('disabled from server', 'websocket');
  	          return;
  	        }
  	
  	        if (transportsWhitelist.length &&
  	            transportsWhitelist.indexOf(trans.transportName) === -1) {
  	          debug('not in whitelist', trans.transportName);
  	          return;
  	        }
  	
  	        if (trans.enabled(info)) {
  	          debug('enabled', trans.transportName);
  	          transports.main.push(trans);
  	          if (trans.facadeTransport) {
  	            transports.facade.push(trans.facadeTransport);
  	          }
  	        } else {
  	          debug('disabled', trans.transportName);
  	        }
  	      });
  	      return transports;
  	    }
  	  };
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 66 */
  /***/ function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	var logObject = {};
  	['log', 'debug', 'warn'].forEach(function (level) {
  	  var levelExists;
  	
  	  try {
  	    levelExists = global.console && global.console[level] && global.console[level].apply;
  	  } catch(e) {
  	    // do nothing
  	  }
  	
  	  logObject[level] = levelExists ? function () {
  	    return global.console[level].apply(global.console, arguments);
  	  } : (level === 'log' ? function () {} : logObject.log);
  	});
  	
  	module.exports = logObject;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 67 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	function Event(eventType) {
  	  this.type = eventType;
  	}
  	
  	Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
  	  this.type = eventType;
  	  this.bubbles = canBubble;
  	  this.cancelable = cancelable;
  	  this.timeStamp = +new Date();
  	  return this;
  	};
  	
  	Event.prototype.stopPropagation = function() {};
  	Event.prototype.preventDefault = function() {};
  	
  	Event.CAPTURING_PHASE = 1;
  	Event.AT_TARGET = 2;
  	Event.BUBBLING_PHASE = 3;
  	
  	module.exports = Event;
  
  
  /***/ },
  /* 68 */
  /***/ function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  	
  	module.exports = global.location || {
  	  origin: 'http://localhost:80'
  	, protocol: 'http'
  	, host: 'localhost'
  	, port: 80
  	, href: 'http://localhost/'
  	, hash: ''
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 69 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , Event = __webpack_require__(67)
  	  ;
  	
  	function CloseEvent() {
  	  Event.call(this);
  	  this.initEvent('close', false, false);
  	  this.wasClean = false;
  	  this.code = 0;
  	  this.reason = '';
  	}
  	
  	inherits(CloseEvent, Event);
  	
  	module.exports = CloseEvent;
  
  
  /***/ },
  /* 70 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , Event = __webpack_require__(67)
  	  ;
  	
  	function TransportMessageEvent(data) {
  	  Event.call(this);
  	  this.initEvent('message', false, false);
  	  this.data = data;
  	}
  	
  	inherits(TransportMessageEvent, Event);
  	
  	module.exports = TransportMessageEvent;
  
  
  /***/ },
  /* 71 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var EventEmitter = __webpack_require__(30).EventEmitter
  	  , inherits = __webpack_require__(29)
  	  , urlUtils = __webpack_require__(21)
  	  , XDR = __webpack_require__(44)
  	  , XHRCors = __webpack_require__(39)
  	  , XHRLocal = __webpack_require__(41)
  	  , XHRFake = __webpack_require__(72)
  	  , InfoIframe = __webpack_require__(73)
  	  , InfoAjax = __webpack_require__(75)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:info-receiver');
  	}
  	
  	function InfoReceiver(baseUrl, urlInfo) {
  	  debug(baseUrl);
  	  var self = this;
  	  EventEmitter.call(this);
  	
  	  setTimeout(function() {
  	    self.doXhr(baseUrl, urlInfo);
  	  }, 0);
  	}
  	
  	inherits(InfoReceiver, EventEmitter);
  	
  	// TODO this is currently ignoring the list of available transports and the whitelist
  	
  	InfoReceiver._getReceiver = function(baseUrl, url, urlInfo) {
  	  // determine method of CORS support (if needed)
  	  if (urlInfo.sameOrigin) {
  	    return new InfoAjax(url, XHRLocal);
  	  }
  	  if (XHRCors.enabled) {
  	    return new InfoAjax(url, XHRCors);
  	  }
  	  if (XDR.enabled && urlInfo.sameScheme) {
  	    return new InfoAjax(url, XDR);
  	  }
  	  if (InfoIframe.enabled()) {
  	    return new InfoIframe(baseUrl, url);
  	  }
  	  return new InfoAjax(url, XHRFake);
  	};
  	
  	InfoReceiver.prototype.doXhr = function(baseUrl, urlInfo) {
  	  var self = this
  	    , url = urlUtils.addPath(baseUrl, '/info')
  	    ;
  	  debug('doXhr', url);
  	
  	  this.xo = InfoReceiver._getReceiver(baseUrl, url, urlInfo);
  	
  	  this.timeoutRef = setTimeout(function() {
  	    debug('timeout');
  	    self._cleanup(false);
  	    self.emit('finish');
  	  }, InfoReceiver.timeout);
  	
  	  this.xo.once('finish', function(info, rtt) {
  	    debug('finish', info, rtt);
  	    self._cleanup(true);
  	    self.emit('finish', info, rtt);
  	  });
  	};
  	
  	InfoReceiver.prototype._cleanup = function(wasClean) {
  	  debug('_cleanup');
  	  clearTimeout(this.timeoutRef);
  	  this.timeoutRef = null;
  	  if (!wasClean && this.xo) {
  	    this.xo.close();
  	  }
  	  this.xo = null;
  	};
  	
  	InfoReceiver.prototype.close = function() {
  	  debug('close');
  	  this.removeAllListeners();
  	  this._cleanup(false);
  	};
  	
  	InfoReceiver.timeout = 8000;
  	
  	module.exports = InfoReceiver;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 72 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var EventEmitter = __webpack_require__(30).EventEmitter
  	  , inherits = __webpack_require__(29)
  	  ;
  	
  	function XHRFake(/* method, url, payload, opts */) {
  	  var self = this;
  	  EventEmitter.call(this);
  	
  	  this.to = setTimeout(function() {
  	    self.emit('finish', 200, '{}');
  	  }, XHRFake.timeout);
  	}
  	
  	inherits(XHRFake, EventEmitter);
  	
  	XHRFake.prototype.close = function() {
  	  clearTimeout(this.to);
  	};
  	
  	XHRFake.timeout = 2000;
  	
  	module.exports = XHRFake;
  
  
  /***/ },
  /* 73 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process, global) {'use strict';
  	
  	var EventEmitter = __webpack_require__(30).EventEmitter
  	  , inherits = __webpack_require__(29)
  	  , JSON3 = __webpack_require__(50)
  	  , utils = __webpack_require__(18)
  	  , IframeTransport = __webpack_require__(49)
  	  , InfoReceiverIframe = __webpack_require__(74)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:info-iframe');
  	}
  	
  	function InfoIframe(baseUrl, url) {
  	  var self = this;
  	  EventEmitter.call(this);
  	
  	  var go = function() {
  	    var ifr = self.ifr = new IframeTransport(InfoReceiverIframe.transportName, url, baseUrl);
  	
  	    ifr.once('message', function(msg) {
  	      if (msg) {
  	        var d;
  	        try {
  	          d = JSON3.parse(msg);
  	        } catch (e) {
  	          debug('bad json', msg);
  	          self.emit('finish');
  	          self.close();
  	          return;
  	        }
  	
  	        var info = d[0], rtt = d[1];
  	        self.emit('finish', info, rtt);
  	      }
  	      self.close();
  	    });
  	
  	    ifr.once('close', function() {
  	      self.emit('finish');
  	      self.close();
  	    });
  	  };
  	
  	  // TODO this seems the same as the 'needBody' from transports
  	  if (!global.document.body) {
  	    utils.attachEvent('load', go);
  	  } else {
  	    go();
  	  }
  	}
  	
  	inherits(InfoIframe, EventEmitter);
  	
  	InfoIframe.enabled = function() {
  	  return IframeTransport.enabled();
  	};
  	
  	InfoIframe.prototype.close = function() {
  	  if (this.ifr) {
  	    this.ifr.close();
  	  }
  	  this.removeAllListeners();
  	  this.ifr = null;
  	};
  	
  	module.exports = InfoIframe;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17), (function() { return this; }())))
  
  /***/ },
  /* 74 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var inherits = __webpack_require__(29)
  	  , EventEmitter = __webpack_require__(30).EventEmitter
  	  , JSON3 = __webpack_require__(50)
  	  , XHRLocalObject = __webpack_require__(41)
  	  , InfoAjax = __webpack_require__(75)
  	  ;
  	
  	function InfoReceiverIframe(transUrl) {
  	  var self = this;
  	  EventEmitter.call(this);
  	
  	  this.ir = new InfoAjax(transUrl, XHRLocalObject);
  	  this.ir.once('finish', function(info, rtt) {
  	    self.ir = null;
  	    self.emit('message', JSON3.stringify([info, rtt]));
  	  });
  	}
  	
  	inherits(InfoReceiverIframe, EventEmitter);
  	
  	InfoReceiverIframe.transportName = 'iframe-info-receiver';
  	
  	InfoReceiverIframe.prototype.close = function() {
  	  if (this.ir) {
  	    this.ir.close();
  	    this.ir = null;
  	  }
  	  this.removeAllListeners();
  	};
  	
  	module.exports = InfoReceiverIframe;
  
  
  /***/ },
  /* 75 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var EventEmitter = __webpack_require__(30).EventEmitter
  	  , inherits = __webpack_require__(29)
  	  , JSON3 = __webpack_require__(50)
  	  , objectUtils = __webpack_require__(54)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:info-ajax');
  	}
  	
  	function InfoAjax(url, AjaxObject) {
  	  EventEmitter.call(this);
  	
  	  var self = this;
  	  var t0 = +new Date();
  	  this.xo = new AjaxObject('GET', url);
  	
  	  this.xo.once('finish', function(status, text) {
  	    var info, rtt;
  	    if (status === 200) {
  	      rtt = (+new Date()) - t0;
  	      if (text) {
  	        try {
  	          info = JSON3.parse(text);
  	        } catch (e) {
  	          debug('bad json', text);
  	        }
  	      }
  	
  	      if (!objectUtils.isObject(info)) {
  	        info = {};
  	      }
  	    }
  	    self.emit('finish', info, rtt);
  	    self.removeAllListeners();
  	  });
  	}
  	
  	inherits(InfoAjax, EventEmitter);
  	
  	InfoAjax.prototype.close = function() {
  	  this.removeAllListeners();
  	  this.xo.close();
  	};
  	
  	module.exports = InfoAjax;
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 76 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var urlUtils = __webpack_require__(21)
  	  , eventUtils = __webpack_require__(18)
  	  , JSON3 = __webpack_require__(50)
  	  , FacadeJS = __webpack_require__(77)
  	  , InfoIframeReceiver = __webpack_require__(74)
  	  , iframeUtils = __webpack_require__(53)
  	  , loc = __webpack_require__(68)
  	  ;
  	
  	var debug = function() {};
  	if (process.env.NODE_ENV !== 'production') {
  	  debug = __webpack_require__(26)('sockjs-client:iframe-bootstrap');
  	}
  	
  	module.exports = function(SockJS, availableTransports) {
  	  var transportMap = {};
  	  availableTransports.forEach(function(at) {
  	    if (at.facadeTransport) {
  	      transportMap[at.facadeTransport.transportName] = at.facadeTransport;
  	    }
  	  });
  	
  	  // hard-coded for the info iframe
  	  // TODO see if we can make this more dynamic
  	  transportMap[InfoIframeReceiver.transportName] = InfoIframeReceiver;
  	  var parentOrigin;
  	
  	  /* eslint-disable camelcase */
  	  SockJS.bootstrap_iframe = function() {
  	    /* eslint-enable camelcase */
  	    var facade;
  	    iframeUtils.currentWindowId = loc.hash.slice(1);
  	    var onMessage = function(e) {
  	      if (e.source !== parent) {
  	        return;
  	      }
  	      if (typeof parentOrigin === 'undefined') {
  	        parentOrigin = e.origin;
  	      }
  	      if (e.origin !== parentOrigin) {
  	        return;
  	      }
  	
  	      var iframeMessage;
  	      try {
  	        iframeMessage = JSON3.parse(e.data);
  	      } catch (ignored) {
  	        debug('bad json', e.data);
  	        return;
  	      }
  	
  	      if (iframeMessage.windowId !== iframeUtils.currentWindowId) {
  	        return;
  	      }
  	      switch (iframeMessage.type) {
  	      case 's':
  	        var p;
  	        try {
  	          p = JSON3.parse(iframeMessage.data);
  	        } catch (ignored) {
  	          debug('bad json', iframeMessage.data);
  	          break;
  	        }
  	        var version = p[0];
  	        var transport = p[1];
  	        var transUrl = p[2];
  	        var baseUrl = p[3];
  	        debug(version, transport, transUrl, baseUrl);
  	        // change this to semver logic
  	        if (version !== SockJS.version) {
  	          throw new Error('Incompatible SockJS! Main site uses:' +
  	                    ' "' + version + '", the iframe:' +
  	                    ' "' + SockJS.version + '".');
  	        }
  	
  	        if (!urlUtils.isOriginEqual(transUrl, loc.href) ||
  	            !urlUtils.isOriginEqual(baseUrl, loc.href)) {
  	          throw new Error('Can\'t connect to different domain from within an ' +
  	                    'iframe. (' + loc.href + ', ' + transUrl + ', ' + baseUrl + ')');
  	        }
  	        facade = new FacadeJS(new transportMap[transport](transUrl, baseUrl));
  	        break;
  	      case 'm':
  	        facade._send(iframeMessage.data);
  	        break;
  	      case 'c':
  	        if (facade) {
  	          facade._close();
  	        }
  	        facade = null;
  	        break;
  	      }
  	    };
  	
  	    eventUtils.attachEvent('message', onMessage);
  	
  	    // Start
  	    iframeUtils.postMessage('s');
  	  };
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 77 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var JSON3 = __webpack_require__(50)
  	  , iframeUtils = __webpack_require__(53)
  	  ;
  	
  	function FacadeJS(transport) {
  	  this._transport = transport;
  	  transport.on('message', this._transportMessage.bind(this));
  	  transport.on('close', this._transportClose.bind(this));
  	}
  	
  	FacadeJS.prototype._transportClose = function(code, reason) {
  	  iframeUtils.postMessage('c', JSON3.stringify([code, reason]));
  	};
  	FacadeJS.prototype._transportMessage = function(frame) {
  	  iframeUtils.postMessage('t', frame);
  	};
  	FacadeJS.prototype._send = function(data) {
  	  this._transport.send(data);
  	};
  	FacadeJS.prototype._close = function() {
  	  this._transport.close();
  	  this._transport.removeAllListeners();
  	};
  	
  	module.exports = FacadeJS;
  
  
  /***/ },
  /* 78 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(79), RootInstanceProvider = __webpack_require__(87), ReactMount = __webpack_require__(89), React = __webpack_require__(141); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } try { (function () {
  	
  	'use strict';
  	
  	var _react = __webpack_require__(141);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	var _reactDom = __webpack_require__(245);
  	
  	var _containers = __webpack_require__(246);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	var root = document.getElementById('app');
  	(0, _reactDom.render)(_react2.default.createElement(_containers.App, null), root);
  	
  	/* REACT HOT LOADER */ }).call(this); } finally { if (true) { (function () { var foundReactClasses = module.hot.data && module.hot.data.foundReactClasses || false; if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(337); if (makeExportsHot(module, __webpack_require__(141))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error("Cannot apply hot update to " + "index.js" + ": " + err.message); } }); } } module.hot.dispose(function (data) { data.makeHot = module.makeHot; data.foundReactClasses = foundReactClasses; }); })(); } }
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
  
  /***/ },
  /* 79 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	module.exports = __webpack_require__(80);
  
  /***/ },
  /* 80 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var makePatchReactClass = __webpack_require__(81);
  	
  	/**
  	 * Returns a function that, when invoked, patches a React class with a new
  	 * version of itself. To patch different classes, pass different IDs.
  	 */
  	module.exports = function makeMakeHot(getRootInstances, React) {
  	  if (typeof getRootInstances !== 'function') {
  	    throw new Error('Expected getRootInstances to be a function.');
  	  }
  	
  	  var patchers = {};
  	
  	  return function makeHot(NextClass, persistentId) {
  	    persistentId = persistentId || NextClass.displayName || NextClass.name;
  	
  	    if (!persistentId) {
  	      console.error(
  	        'Hot reload is disabled for one of your types. To enable it, pass a ' +
  	        'string uniquely identifying this class within this current module ' +
  	        'as a second parameter to makeHot.'
  	      );
  	      return NextClass;
  	    }
  	
  	    if (!patchers[persistentId]) {
  	      patchers[persistentId] = makePatchReactClass(getRootInstances, React);
  	    }
  	
  	    var patchReactClass = patchers[persistentId];
  	    return patchReactClass(NextClass);
  	  };
  	};
  
  /***/ },
  /* 81 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var makeAssimilatePrototype = __webpack_require__(82),
  	    requestForceUpdateAll = __webpack_require__(83);
  	
  	function hasNonStubTypeProperty(ReactClass) {
  	  if (!ReactClass.hasOwnProperty('type')) {
  	    return false;
  	  }
  	
  	  var descriptor = Object.getOwnPropertyDescriptor(ReactClass, 'type');
  	  if (typeof descriptor.get === 'function') {
  	    return false;
  	  }
  	
  	  return true;
  	}
  	
  	function getPrototype(ReactClass) {
  	  var prototype = ReactClass.prototype,
  	      seemsLegit = prototype && typeof prototype.render === 'function';
  	
  	  if (!seemsLegit && hasNonStubTypeProperty(ReactClass)) {
  	    prototype = ReactClass.type.prototype;
  	  }
  	
  	  return prototype;
  	}
  	
  	/**
  	 * Returns a function that will patch React class with new versions of itself
  	 * on subsequent invocations. Both legacy and ES6 style classes are supported.
  	 */
  	module.exports = function makePatchReactClass(getRootInstances, React) {
  	  var assimilatePrototype = makeAssimilatePrototype(),
  	      FirstClass = null;
  	
  	  return function patchReactClass(NextClass) {
  	    var nextPrototype = getPrototype(NextClass);
  	    assimilatePrototype(nextPrototype);
  	
  	    if (FirstClass) {
  	      requestForceUpdateAll(getRootInstances, React);
  	    }
  	
  	    return FirstClass || (FirstClass = NextClass);
  	  };
  	};
  
  /***/ },
  /* 82 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	/**
  	 * Returns a function that establishes the first prototype passed to it
  	 * as the "source of truth" and patches its methods on subsequent invocations,
  	 * also patching current and previous prototypes to forward calls to it.
  	 */
  	module.exports = function makeAssimilatePrototype() {
  	  var storedPrototype,
  	      knownPrototypes = [];
  	
  	  function wrapMethod(key) {
  	    return function () {
  	      if (storedPrototype[key]) {
  	        return storedPrototype[key].apply(this, arguments);
  	      }
  	    };
  	  }
  	
  	  function patchProperty(proto, key) {
  	    proto[key] = storedPrototype[key];
  	
  	    if (typeof proto[key] !== 'function' ||
  	      key === 'type' ||
  	      key === 'constructor') {
  	      return;
  	    }
  	
  	    proto[key] = wrapMethod(key);
  	
  	    if (storedPrototype[key].isReactClassApproved) {
  	      proto[key].isReactClassApproved = storedPrototype[key].isReactClassApproved;
  	    }
  	
  	    if (proto.__reactAutoBindMap && proto.__reactAutoBindMap[key]) {
  	      proto.__reactAutoBindMap[key] = proto[key];
  	    }
  	  }
  	
  	  function updateStoredPrototype(freshPrototype) {
  	    storedPrototype = {};
  	
  	    Object.getOwnPropertyNames(freshPrototype).forEach(function (key) {
  	      storedPrototype[key] = freshPrototype[key];
  	    });
  	  }
  	
  	  function reconcileWithStoredPrototypes(freshPrototype) {
  	    knownPrototypes.push(freshPrototype);
  	    knownPrototypes.forEach(function (proto) {
  	      Object.getOwnPropertyNames(storedPrototype).forEach(function (key) {
  	        patchProperty(proto, key);
  	      });
  	    });
  	  }
  	
  	  return function assimilatePrototype(freshPrototype) {
  	    if (Object.prototype.hasOwnProperty.call(freshPrototype, '__isAssimilatedByReactHotAPI')) {
  	      return;
  	    }
  	
  	    updateStoredPrototype(freshPrototype);
  	    reconcileWithStoredPrototypes(freshPrototype);
  	    freshPrototype.__isAssimilatedByReactHotAPI = true;
  	  };
  	};
  
  /***/ },
  /* 83 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var deepForceUpdate = __webpack_require__(84);
  	
  	var isRequestPending = false;
  	
  	module.exports = function requestForceUpdateAll(getRootInstances, React) {
  	  if (isRequestPending) {
  	    return;
  	  }
  	
  	  /**
  	   * Forces deep re-render of all mounted React components.
  	   * Hats off to Omar Skalli (@Chetane) for suggesting this approach:
  	   * https://gist.github.com/Chetane/9a230a9fdcdca21a4e29
  	   */
  	  function forceUpdateAll() {
  	    isRequestPending = false;
  	
  	    var rootInstances = getRootInstances(),
  	        rootInstance;
  	
  	    for (var key in rootInstances) {
  	      if (rootInstances.hasOwnProperty(key)) {
  	        rootInstance = rootInstances[key];
  	
  	        // `|| rootInstance` for React 0.12 and earlier
  	        rootInstance = rootInstance._reactInternalInstance || rootInstance;
  	        deepForceUpdate(rootInstance, React);
  	      }
  	    }
  	  }
  	
  	  setTimeout(forceUpdateAll);
  	};
  
  
  /***/ },
  /* 84 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var bindAutoBindMethods = __webpack_require__(85);
  	var traverseRenderedChildren = __webpack_require__(86);
  	
  	function setPendingForceUpdate(internalInstance) {
  	  if (internalInstance._pendingForceUpdate === false) {
  	    internalInstance._pendingForceUpdate = true;
  	  }
  	}
  	
  	function forceUpdateIfPending(internalInstance, React) {
  	  if (internalInstance._pendingForceUpdate === true) {
  	    // `|| internalInstance` for React 0.12 and earlier
  	    var instance = internalInstance._instance || internalInstance;
  	
  	    if (instance.forceUpdate) {
  	      instance.forceUpdate();
  	    } else if (React && React.Component) {
  	      React.Component.prototype.forceUpdate.call(instance);
  	    }
  	  }
  	}
  	
  	/**
  	 * Updates a React component recursively, so even if children define funky
  	 * `shouldComponentUpdate`, they are forced to re-render.
  	 * Makes sure that any newly added methods are properly auto-bound.
  	 */
  	function deepForceUpdate(internalInstance, React) {
  	  traverseRenderedChildren(internalInstance, bindAutoBindMethods);
  	  traverseRenderedChildren(internalInstance, setPendingForceUpdate);
  	  traverseRenderedChildren(internalInstance, forceUpdateIfPending, React);
  	}
  	
  	module.exports = deepForceUpdate;
  
  
  /***/ },
  /* 85 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	function bindAutoBindMethod(component, method) {
  	  var boundMethod = method.bind(component);
  	
  	  boundMethod.__reactBoundContext = component;
  	  boundMethod.__reactBoundMethod = method;
  	  boundMethod.__reactBoundArguments = null;
  	
  	  var componentName = component.constructor.displayName,
  	      _bind = boundMethod.bind;
  	
  	  boundMethod.bind = function (newThis) {
  	    var args = Array.prototype.slice.call(arguments, 1);
  	    if (newThis !== component && newThis !== null) {
  	      console.warn(
  	        'bind(): React component methods may only be bound to the ' +
  	        'component instance. See ' + componentName
  	      );
  	    } else if (!args.length) {
  	      console.warn(
  	        'bind(): You are binding a component method to the component. ' +
  	        'React does this for you automatically in a high-performance ' +
  	        'way, so you can safely remove this call. See ' + componentName
  	      );
  	      return boundMethod;
  	    }
  	
  	    var reboundMethod = _bind.apply(boundMethod, arguments);
  	    reboundMethod.__reactBoundContext = component;
  	    reboundMethod.__reactBoundMethod = method;
  	    reboundMethod.__reactBoundArguments = args;
  	
  	    return reboundMethod;
  	  };
  	
  	  return boundMethod;
  	}
  	
  	/**
  	 * Performs auto-binding similar to how React does it.
  	 * Skips already auto-bound methods.
  	 * Based on https://github.com/facebook/react/blob/b264372e2b3ad0b0c0c0cc95a2f383e4a1325c3d/src/classic/class/ReactClass.js#L639-L705
  	 */
  	module.exports = function bindAutoBindMethods(internalInstance) {
  	  var component = typeof internalInstance.getPublicInstance === 'function' ?
  	    internalInstance.getPublicInstance() :
  	    internalInstance;
  	
  	  if (!component) {
  	    // React 0.14 stateless component has no instance
  	    return;
  	  }
  	
  	  for (var autoBindKey in component.__reactAutoBindMap) {
  	    if (!component.__reactAutoBindMap.hasOwnProperty(autoBindKey)) {
  	      continue;
  	    }
  	
  	    // Skip already bound methods
  	    if (component.hasOwnProperty(autoBindKey) &&
  	        component[autoBindKey].__reactBoundContext === component) {
  	      continue;
  	    }
  	
  	    var method = component.__reactAutoBindMap[autoBindKey];
  	    component[autoBindKey] = bindAutoBindMethod(component, method);
  	  }
  	};
  
  /***/ },
  /* 86 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	function traverseRenderedChildren(internalInstance, callback, argument) {
  	  callback(internalInstance, argument);
  	
  	  if (internalInstance._renderedComponent) {
  	    traverseRenderedChildren(
  	      internalInstance._renderedComponent,
  	      callback,
  	      argument
  	    );
  	  } else {
  	    for (var key in internalInstance._renderedChildren) {
  	      traverseRenderedChildren(
  	        internalInstance._renderedChildren[key],
  	        callback,
  	        argument
  	      );
  	    }
  	  }
  	}
  	
  	module.exports = traverseRenderedChildren;
  
  
  /***/ },
  /* 87 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var getRootInstancesFromReactMount = __webpack_require__(88);
  	
  	var injectedProvider = null,
  	    didWarn = false;
  	
  	function warnOnce() {
  	  if (!didWarn) {
  	    console.warn(
  	      'It appears that React Hot Loader isn\'t configured correctly. ' +
  	      'If you\'re using NPM, make sure your dependencies don\'t drag duplicate React distributions into their node_modules and that require("react") corresponds to the React instance you render your app with.',
  	      'If you\'re using a precompiled version of React, see https://github.com/gaearon/react-hot-loader/tree/master/docs#usage-with-external-react for integration instructions.'
  	    );
  	  }
  	
  	  didWarn = true;
  	}
  	
  	var RootInstanceProvider = {
  	  injection: {
  	    injectProvider: function (provider) {
  	      injectedProvider = provider;
  	    }
  	  },
  	
  	  getRootInstances: function (ReactMount) {
  	    if (injectedProvider) {
  	      return injectedProvider.getRootInstances();
  	    }
  	
  	    var instances = ReactMount && getRootInstancesFromReactMount(ReactMount) || [];
  	    if (!Object.keys(instances).length) {
  	      warnOnce();
  	    }
  	
  	    return instances;
  	  }
  	};
  	
  	module.exports = RootInstanceProvider;
  
  /***/ },
  /* 88 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	function getRootInstancesFromReactMount(ReactMount) {
  	  return ReactMount._instancesByReactRootID || ReactMount._instancesByContainerID || [];
  	}
  	
  	module.exports = getRootInstancesFromReactMount;
  
  /***/ },
  /* 89 */,
  /* 90 */,
  /* 91 */,
  /* 92 */,
  /* 93 */,
  /* 94 */,
  /* 95 */,
  /* 96 */,
  /* 97 */,
  /* 98 */,
  /* 99 */,
  /* 100 */,
  /* 101 */,
  /* 102 */,
  /* 103 */,
  /* 104 */,
  /* 105 */,
  /* 106 */,
  /* 107 */,
  /* 108 */,
  /* 109 */,
  /* 110 */,
  /* 111 */,
  /* 112 */,
  /* 113 */,
  /* 114 */,
  /* 115 */,
  /* 116 */,
  /* 117 */,
  /* 118 */,
  /* 119 */,
  /* 120 */,
  /* 121 */,
  /* 122 */,
  /* 123 */,
  /* 124 */,
  /* 125 */,
  /* 126 */,
  /* 127 */,
  /* 128 */,
  /* 129 */,
  /* 130 */,
  /* 131 */,
  /* 132 */,
  /* 133 */,
  /* 134 */,
  /* 135 */,
  /* 136 */,
  /* 137 */,
  /* 138 */,
  /* 139 */,
  /* 140 */,
  /* 141 */,
  /* 142 */,
  /* 143 */,
  /* 144 */,
  /* 145 */,
  /* 146 */,
  /* 147 */,
  /* 148 */,
  /* 149 */,
  /* 150 */,
  /* 151 */,
  /* 152 */,
  /* 153 */,
  /* 154 */,
  /* 155 */,
  /* 156 */,
  /* 157 */,
  /* 158 */,
  /* 159 */,
  /* 160 */,
  /* 161 */,
  /* 162 */,
  /* 163 */,
  /* 164 */,
  /* 165 */,
  /* 166 */,
  /* 167 */,
  /* 168 */,
  /* 169 */,
  /* 170 */,
  /* 171 */,
  /* 172 */,
  /* 173 */,
  /* 174 */,
  /* 175 */,
  /* 176 */,
  /* 177 */,
  /* 178 */,
  /* 179 */,
  /* 180 */,
  /* 181 */,
  /* 182 */,
  /* 183 */,
  /* 184 */,
  /* 185 */,
  /* 186 */,
  /* 187 */,
  /* 188 */,
  /* 189 */,
  /* 190 */,
  /* 191 */,
  /* 192 */,
  /* 193 */,
  /* 194 */,
  /* 195 */,
  /* 196 */,
  /* 197 */,
  /* 198 */,
  /* 199 */,
  /* 200 */,
  /* 201 */,
  /* 202 */,
  /* 203 */,
  /* 204 */,
  /* 205 */,
  /* 206 */,
  /* 207 */,
  /* 208 */,
  /* 209 */,
  /* 210 */,
  /* 211 */,
  /* 212 */,
  /* 213 */,
  /* 214 */,
  /* 215 */,
  /* 216 */,
  /* 217 */,
  /* 218 */,
  /* 219 */,
  /* 220 */,
  /* 221 */,
  /* 222 */,
  /* 223 */,
  /* 224 */,
  /* 225 */,
  /* 226 */,
  /* 227 */,
  /* 228 */,
  /* 229 */,
  /* 230 */,
  /* 231 */,
  /* 232 */,
  /* 233 */,
  /* 234 */,
  /* 235 */,
  /* 236 */,
  /* 237 */,
  /* 238 */,
  /* 239 */,
  /* 240 */,
  /* 241 */,
  /* 242 */,
  /* 243 */,
  /* 244 */,
  /* 245 */,
  /* 246 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(79), RootInstanceProvider = __webpack_require__(87), ReactMount = __webpack_require__(89), React = __webpack_require__(141); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } try { (function () {
  	
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	exports.Iframe = exports.App = undefined;
  	
  	var _index = __webpack_require__(247);
  	
  	var _index2 = _interopRequireDefault(_index);
  	
  	var _index3 = __webpack_require__(365);
  	
  	var _index4 = _interopRequireDefault(_index3);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	exports.App = _index2.default;
  	exports.Iframe = _index4.default;
  	
  	/* REACT HOT LOADER */ }).call(this); } finally { if (true) { (function () { var foundReactClasses = module.hot.data && module.hot.data.foundReactClasses || false; if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(337); if (makeExportsHot(module, __webpack_require__(141))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error("Cannot apply hot update to " + "index.js" + ": " + err.message); } }); } } module.hot.dispose(function (data) { data.makeHot = module.makeHot; data.foundReactClasses = foundReactClasses; }); })(); } }
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
  
  /***/ },
  /* 247 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(79), RootInstanceProvider = __webpack_require__(87), ReactMount = __webpack_require__(89), React = __webpack_require__(141); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } try { (function () {
  	
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	
  	var _getPrototypeOf = __webpack_require__(248);
  	
  	var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
  	
  	var _classCallCheck2 = __webpack_require__(274);
  	
  	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
  	
  	var _createClass2 = __webpack_require__(275);
  	
  	var _createClass3 = _interopRequireDefault(_createClass2);
  	
  	var _possibleConstructorReturn2 = __webpack_require__(279);
  	
  	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
  	
  	var _inherits2 = __webpack_require__(326);
  	
  	var _inherits3 = _interopRequireDefault(_inherits2);
  	
  	var _react = __webpack_require__(141);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	var _components = __webpack_require__(334);
  	
  	var _jquery = __webpack_require__(341);
  	
  	var _jquery2 = _interopRequireDefault(_jquery);
  	
  	var _helper = __webpack_require__(344);
  	
  	var _helper2 = _interopRequireDefault(_helper);
  	
  	__webpack_require__(364);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	var Compse = function (_Component) {
  	  (0, _inherits3.default)(Compse, _Component);
  	
  	  function Compse() {
  	    (0, _classCallCheck3.default)(this, Compse);
  	    return (0, _possibleConstructorReturn3.default)(this, (Compse.__proto__ || (0, _getPrototypeOf2.default)(Compse)).apply(this, arguments));
  	  }
  	
  	  (0, _createClass3.default)(Compse, [{
  	    key: 'render',
  	    value: function render() {
  	      var props = this.props;
  	      if (props.data) {
  	        props.data.studio.streamid = '';
  	      }
  	      return _react2.default.createElement(
  	        'div',
  	        null,
  	        _react2.default.createElement(_components.Header, { data: props.data.studio }),
  	        _react2.default.createElement(_components.Content, { data: props })
  	      );
  	    }
  	  }]);
  	  return Compse;
  	}(_react.Component);
  	
  	var App = function (_Component2) {
  	  (0, _inherits3.default)(App, _Component2);
  	
  	  function App(props) {
  	    (0, _classCallCheck3.default)(this, App);
  	
  	    var _this2 = (0, _possibleConstructorReturn3.default)(this, (App.__proto__ || (0, _getPrototypeOf2.default)(App)).call(this, props));
  	
  	    _this2.state = {
  	      data: '',
  	      color: 'blue',
  	      newsList: []
  	    };
  	    return _this2;
  	  }
  	
  	  (0, _createClass3.default)(App, [{
  	    key: 'componentWillMount',
  	    value: function componentWillMount() {
  	      var _this3 = this;
  	
  	      var idParam = _helper2.default.getQueryString('id');
  	      idParam = idParam ? idParam : 254;
  	      var timestamp = Date.parse(new Date());
  	      var color = this.state.color;
  	      _helper2.default.getData(idParam).then(function (data) {
  	        (0, _jquery2.default)('.mask').css('display', 'none');
  	        (0, _jquery2.default)('.contentWrapper').css('display', 'block');
  	        if (data.studio.color == 0) {
  	          color = 'red';
  	        }
  	        if (data.studio.color == 1) {
  	          color = 'blue';
  	        }
  	        if (data.studio.color == 2) {
  	          color = 'gry';
  	        }
  	        _this3.setState({
  	          color: color,
  	          data: data,
  	          newsList: data.news,
  	          id: idParam
  	        });
  	        (0, _jquery2.default)('.contentWrapper').addClass(color);
  	      }).then(function () {
  	        var studio = _this3.state.data.studio;
  	      });
  	      var scrollEvent = "onscroll" in document.documentElement ? "scroll" : "touchmove";
  	      (0, _jquery2.default)('.more_btn_loading').css('display', 'block');
  	      /*    $(window).on('swipeDown', function(){
  	          if(b.isclose == '0'){
  	            var rosHeight = $('.roseLive_head_con ').height();
  	            var vd = viewData();
  	            if(vd.scrollTop < rosHeight){
  	              if(b.done){
  	                app._incData('down');
  	              }
  	            }
  	          }
  	        });*/
  	    }
  	  }, {
  	    key: 'componentDidMount',
  	    value: function componentDidMount() {
  	      //console.log('componentDidMount');
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      //console.log(83,this.state.data)
  	      return _react2.default.createElement(Compse, { data: this.state.data, color: this.state.color, newsList: this.state.newsList, id: this.state.id });
  	    }
  	  }]);
  	  return App;
  	}(_react.Component);
  	
  	exports.default = App;
  	
  	/* REACT HOT LOADER */ }).call(this); } finally { if (true) { (function () { var foundReactClasses = module.hot.data && module.hot.data.foundReactClasses || false; if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(337); if (makeExportsHot(module, __webpack_require__(141))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error("Cannot apply hot update to " + "index.jsx" + ": " + err.message); } }); } } module.hot.dispose(function (data) { data.makeHot = module.makeHot; data.foundReactClasses = foundReactClasses; }); })(); } }
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
  
  /***/ },
  /* 248 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(249), __esModule: true };
  
  /***/ },
  /* 249 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(250);
  	module.exports = __webpack_require__(261).Object.getPrototypeOf;
  
  /***/ },
  /* 250 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 19.1.2.9 Object.getPrototypeOf(O)
  	var toObject        = __webpack_require__(251)
  	  , $getPrototypeOf = __webpack_require__(253);
  	
  	__webpack_require__(259)('getPrototypeOf', function(){
  	  return function getPrototypeOf(it){
  	    return $getPrototypeOf(toObject(it));
  	  };
  	});
  
  /***/ },
  /* 251 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 7.1.13 ToObject(argument)
  	var defined = __webpack_require__(252);
  	module.exports = function(it){
  	  return Object(defined(it));
  	};
  
  /***/ },
  /* 252 */
  /***/ function(module, exports) {
  
  	// 7.2.1 RequireObjectCoercible(argument)
  	module.exports = function(it){
  	  if(it == undefined)throw TypeError("Can't call method on  " + it);
  	  return it;
  	};
  
  /***/ },
  /* 253 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
  	var has         = __webpack_require__(254)
  	  , toObject    = __webpack_require__(251)
  	  , IE_PROTO    = __webpack_require__(255)('IE_PROTO')
  	  , ObjectProto = Object.prototype;
  	
  	module.exports = Object.getPrototypeOf || function(O){
  	  O = toObject(O);
  	  if(has(O, IE_PROTO))return O[IE_PROTO];
  	  if(typeof O.constructor == 'function' && O instanceof O.constructor){
  	    return O.constructor.prototype;
  	  } return O instanceof Object ? ObjectProto : null;
  	};
  
  /***/ },
  /* 254 */
  /***/ function(module, exports) {
  
  	var hasOwnProperty = {}.hasOwnProperty;
  	module.exports = function(it, key){
  	  return hasOwnProperty.call(it, key);
  	};
  
  /***/ },
  /* 255 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var shared = __webpack_require__(256)('keys')
  	  , uid    = __webpack_require__(258);
  	module.exports = function(key){
  	  return shared[key] || (shared[key] = uid(key));
  	};
  
  /***/ },
  /* 256 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var global = __webpack_require__(257)
  	  , SHARED = '__core-js_shared__'
  	  , store  = global[SHARED] || (global[SHARED] = {});
  	module.exports = function(key){
  	  return store[key] || (store[key] = {});
  	};
  
  /***/ },
  /* 257 */
  /***/ function(module, exports) {
  
  	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
  	var global = module.exports = typeof window != 'undefined' && window.Math == Math
  	  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
  	if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
  
  /***/ },
  /* 258 */
  /***/ function(module, exports) {
  
  	var id = 0
  	  , px = Math.random();
  	module.exports = function(key){
  	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  	};
  
  /***/ },
  /* 259 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// most Object methods by ES6 should accept primitives
  	var $export = __webpack_require__(260)
  	  , core    = __webpack_require__(261)
  	  , fails   = __webpack_require__(270);
  	module.exports = function(KEY, exec){
  	  var fn  = (core.Object || {})[KEY] || Object[KEY]
  	    , exp = {};
  	  exp[KEY] = exec(fn);
  	  $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
  	};
  
  /***/ },
  /* 260 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var global    = __webpack_require__(257)
  	  , core      = __webpack_require__(261)
  	  , ctx       = __webpack_require__(262)
  	  , hide      = __webpack_require__(264)
  	  , PROTOTYPE = 'prototype';
  	
  	var $export = function(type, name, source){
  	  var IS_FORCED = type & $export.F
  	    , IS_GLOBAL = type & $export.G
  	    , IS_STATIC = type & $export.S
  	    , IS_PROTO  = type & $export.P
  	    , IS_BIND   = type & $export.B
  	    , IS_WRAP   = type & $export.W
  	    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
  	    , expProto  = exports[PROTOTYPE]
  	    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
  	    , key, own, out;
  	  if(IS_GLOBAL)source = name;
  	  for(key in source){
  	    // contains in native
  	    own = !IS_FORCED && target && target[key] !== undefined;
  	    if(own && key in exports)continue;
  	    // export native or passed
  	    out = own ? target[key] : source[key];
  	    // prevent global pollution for namespaces
  	    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
  	    // bind timers to global for call from export context
  	    : IS_BIND && own ? ctx(out, global)
  	    // wrap global constructors for prevent change them in library
  	    : IS_WRAP && target[key] == out ? (function(C){
  	      var F = function(a, b, c){
  	        if(this instanceof C){
  	          switch(arguments.length){
  	            case 0: return new C;
  	            case 1: return new C(a);
  	            case 2: return new C(a, b);
  	          } return new C(a, b, c);
  	        } return C.apply(this, arguments);
  	      };
  	      F[PROTOTYPE] = C[PROTOTYPE];
  	      return F;
  	    // make static versions for prototype methods
  	    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
  	    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
  	    if(IS_PROTO){
  	      (exports.virtual || (exports.virtual = {}))[key] = out;
  	      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
  	      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);
  	    }
  	  }
  	};
  	// type bitmap
  	$export.F = 1;   // forced
  	$export.G = 2;   // global
  	$export.S = 4;   // static
  	$export.P = 8;   // proto
  	$export.B = 16;  // bind
  	$export.W = 32;  // wrap
  	$export.U = 64;  // safe
  	$export.R = 128; // real proto method for `library` 
  	module.exports = $export;
  
  /***/ },
  /* 261 */
  /***/ function(module, exports) {
  
  	var core = module.exports = {version: '2.4.0'};
  	if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
  
  /***/ },
  /* 262 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// optional / simple context binding
  	var aFunction = __webpack_require__(263);
  	module.exports = function(fn, that, length){
  	  aFunction(fn);
  	  if(that === undefined)return fn;
  	  switch(length){
  	    case 1: return function(a){
  	      return fn.call(that, a);
  	    };
  	    case 2: return function(a, b){
  	      return fn.call(that, a, b);
  	    };
  	    case 3: return function(a, b, c){
  	      return fn.call(that, a, b, c);
  	    };
  	  }
  	  return function(/* ...args */){
  	    return fn.apply(that, arguments);
  	  };
  	};
  
  /***/ },
  /* 263 */
  /***/ function(module, exports) {
  
  	module.exports = function(it){
  	  if(typeof it != 'function')throw TypeError(it + ' is not a function!');
  	  return it;
  	};
  
  /***/ },
  /* 264 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var dP         = __webpack_require__(265)
  	  , createDesc = __webpack_require__(273);
  	module.exports = __webpack_require__(269) ? function(object, key, value){
  	  return dP.f(object, key, createDesc(1, value));
  	} : function(object, key, value){
  	  object[key] = value;
  	  return object;
  	};
  
  /***/ },
  /* 265 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var anObject       = __webpack_require__(266)
  	  , IE8_DOM_DEFINE = __webpack_require__(268)
  	  , toPrimitive    = __webpack_require__(272)
  	  , dP             = Object.defineProperty;
  	
  	exports.f = __webpack_require__(269) ? Object.defineProperty : function defineProperty(O, P, Attributes){
  	  anObject(O);
  	  P = toPrimitive(P, true);
  	  anObject(Attributes);
  	  if(IE8_DOM_DEFINE)try {
  	    return dP(O, P, Attributes);
  	  } catch(e){ /* empty */ }
  	  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
  	  if('value' in Attributes)O[P] = Attributes.value;
  	  return O;
  	};
  
  /***/ },
  /* 266 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var isObject = __webpack_require__(267);
  	module.exports = function(it){
  	  if(!isObject(it))throw TypeError(it + ' is not an object!');
  	  return it;
  	};
  
  /***/ },
  /* 267 */
  /***/ function(module, exports) {
  
  	module.exports = function(it){
  	  return typeof it === 'object' ? it !== null : typeof it === 'function';
  	};
  
  /***/ },
  /* 268 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = !__webpack_require__(269) && !__webpack_require__(270)(function(){
  	  return Object.defineProperty(__webpack_require__(271)('div'), 'a', {get: function(){ return 7; }}).a != 7;
  	});
  
  /***/ },
  /* 269 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// Thank's IE8 for his funny defineProperty
  	module.exports = !__webpack_require__(270)(function(){
  	  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
  	});
  
  /***/ },
  /* 270 */
  /***/ function(module, exports) {
  
  	module.exports = function(exec){
  	  try {
  	    return !!exec();
  	  } catch(e){
  	    return true;
  	  }
  	};
  
  /***/ },
  /* 271 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var isObject = __webpack_require__(267)
  	  , document = __webpack_require__(257).document
  	  // in old IE typeof document.createElement is 'object'
  	  , is = isObject(document) && isObject(document.createElement);
  	module.exports = function(it){
  	  return is ? document.createElement(it) : {};
  	};
  
  /***/ },
  /* 272 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 7.1.1 ToPrimitive(input [, PreferredType])
  	var isObject = __webpack_require__(267);
  	// instead of the ES6 spec version, we didn't implement @@toPrimitive case
  	// and the second argument - flag - preferred type is a string
  	module.exports = function(it, S){
  	  if(!isObject(it))return it;
  	  var fn, val;
  	  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
  	  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
  	  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
  	  throw TypeError("Can't convert object to primitive value");
  	};
  
  /***/ },
  /* 273 */
  /***/ function(module, exports) {
  
  	module.exports = function(bitmap, value){
  	  return {
  	    enumerable  : !(bitmap & 1),
  	    configurable: !(bitmap & 2),
  	    writable    : !(bitmap & 4),
  	    value       : value
  	  };
  	};
  
  /***/ },
  /* 274 */
  /***/ function(module, exports) {
  
  	"use strict";
  	
  	exports.__esModule = true;
  	
  	exports.default = function (instance, Constructor) {
  	  if (!(instance instanceof Constructor)) {
  	    throw new TypeError("Cannot call a class as a function");
  	  }
  	};
  
  /***/ },
  /* 275 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	exports.__esModule = true;
  	
  	var _defineProperty = __webpack_require__(276);
  	
  	var _defineProperty2 = _interopRequireDefault(_defineProperty);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	exports.default = function () {
  	  function defineProperties(target, props) {
  	    for (var i = 0; i < props.length; i++) {
  	      var descriptor = props[i];
  	      descriptor.enumerable = descriptor.enumerable || false;
  	      descriptor.configurable = true;
  	      if ("value" in descriptor) descriptor.writable = true;
  	      (0, _defineProperty2.default)(target, descriptor.key, descriptor);
  	    }
  	  }
  	
  	  return function (Constructor, protoProps, staticProps) {
  	    if (protoProps) defineProperties(Constructor.prototype, protoProps);
  	    if (staticProps) defineProperties(Constructor, staticProps);
  	    return Constructor;
  	  };
  	}();
  
  /***/ },
  /* 276 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(277), __esModule: true };
  
  /***/ },
  /* 277 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(278);
  	var $Object = __webpack_require__(261).Object;
  	module.exports = function defineProperty(it, key, desc){
  	  return $Object.defineProperty(it, key, desc);
  	};
  
  /***/ },
  /* 278 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var $export = __webpack_require__(260);
  	// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
  	$export($export.S + $export.F * !__webpack_require__(269), 'Object', {defineProperty: __webpack_require__(265).f});
  
  /***/ },
  /* 279 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	exports.__esModule = true;
  	
  	var _typeof2 = __webpack_require__(280);
  	
  	var _typeof3 = _interopRequireDefault(_typeof2);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	exports.default = function (self, call) {
  	  if (!self) {
  	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  	  }
  	
  	  return call && ((typeof call === "undefined" ? "undefined" : (0, _typeof3.default)(call)) === "object" || typeof call === "function") ? call : self;
  	};
  
  /***/ },
  /* 280 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	exports.__esModule = true;
  	
  	var _iterator = __webpack_require__(281);
  	
  	var _iterator2 = _interopRequireDefault(_iterator);
  	
  	var _symbol = __webpack_require__(310);
  	
  	var _symbol2 = _interopRequireDefault(_symbol);
  	
  	var _typeof = typeof _symbol2.default === "function" && typeof _iterator2.default === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj; };
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	exports.default = typeof _symbol2.default === "function" && _typeof(_iterator2.default) === "symbol" ? function (obj) {
  	  return typeof obj === "undefined" ? "undefined" : _typeof(obj);
  	} : function (obj) {
  	  return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj);
  	};
  
  /***/ },
  /* 281 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(282), __esModule: true };
  
  /***/ },
  /* 282 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(283);
  	__webpack_require__(305);
  	module.exports = __webpack_require__(309).f('iterator');
  
  /***/ },
  /* 283 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	var $at  = __webpack_require__(284)(true);
  	
  	// 21.1.3.27 String.prototype[@@iterator]()
  	__webpack_require__(286)(String, 'String', function(iterated){
  	  this._t = String(iterated); // target
  	  this._i = 0;                // next index
  	// 21.1.5.2.1 %StringIteratorPrototype%.next()
  	}, function(){
  	  var O     = this._t
  	    , index = this._i
  	    , point;
  	  if(index >= O.length)return {value: undefined, done: true};
  	  point = $at(O, index);
  	  this._i += point.length;
  	  return {value: point, done: false};
  	});
  
  /***/ },
  /* 284 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var toInteger = __webpack_require__(285)
  	  , defined   = __webpack_require__(252);
  	// true  -> String#at
  	// false -> String#codePointAt
  	module.exports = function(TO_STRING){
  	  return function(that, pos){
  	    var s = String(defined(that))
  	      , i = toInteger(pos)
  	      , l = s.length
  	      , a, b;
  	    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;
  	    a = s.charCodeAt(i);
  	    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
  	      ? TO_STRING ? s.charAt(i) : a
  	      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
  	  };
  	};
  
  /***/ },
  /* 285 */
  /***/ function(module, exports) {
  
  	// 7.1.4 ToInteger
  	var ceil  = Math.ceil
  	  , floor = Math.floor;
  	module.exports = function(it){
  	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
  	};
  
  /***/ },
  /* 286 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	var LIBRARY        = __webpack_require__(287)
  	  , $export        = __webpack_require__(260)
  	  , redefine       = __webpack_require__(288)
  	  , hide           = __webpack_require__(264)
  	  , has            = __webpack_require__(254)
  	  , Iterators      = __webpack_require__(289)
  	  , $iterCreate    = __webpack_require__(290)
  	  , setToStringTag = __webpack_require__(303)
  	  , getPrototypeOf = __webpack_require__(253)
  	  , ITERATOR       = __webpack_require__(304)('iterator')
  	  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
  	  , FF_ITERATOR    = '@@iterator'
  	  , KEYS           = 'keys'
  	  , VALUES         = 'values';
  	
  	var returnThis = function(){ return this; };
  	
  	module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
  	  $iterCreate(Constructor, NAME, next);
  	  var getMethod = function(kind){
  	    if(!BUGGY && kind in proto)return proto[kind];
  	    switch(kind){
  	      case KEYS: return function keys(){ return new Constructor(this, kind); };
  	      case VALUES: return function values(){ return new Constructor(this, kind); };
  	    } return function entries(){ return new Constructor(this, kind); };
  	  };
  	  var TAG        = NAME + ' Iterator'
  	    , DEF_VALUES = DEFAULT == VALUES
  	    , VALUES_BUG = false
  	    , proto      = Base.prototype
  	    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
  	    , $default   = $native || getMethod(DEFAULT)
  	    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined
  	    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native
  	    , methods, key, IteratorPrototype;
  	  // Fix native
  	  if($anyNative){
  	    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));
  	    if(IteratorPrototype !== Object.prototype){
  	      // Set @@toStringTag to native iterators
  	      setToStringTag(IteratorPrototype, TAG, true);
  	      // fix for some old engines
  	      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
  	    }
  	  }
  	  // fix Array#{values, @@iterator}.name in V8 / FF
  	  if(DEF_VALUES && $native && $native.name !== VALUES){
  	    VALUES_BUG = true;
  	    $default = function values(){ return $native.call(this); };
  	  }
  	  // Define iterator
  	  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){
  	    hide(proto, ITERATOR, $default);
  	  }
  	  // Plug for library
  	  Iterators[NAME] = $default;
  	  Iterators[TAG]  = returnThis;
  	  if(DEFAULT){
  	    methods = {
  	      values:  DEF_VALUES ? $default : getMethod(VALUES),
  	      keys:    IS_SET     ? $default : getMethod(KEYS),
  	      entries: $entries
  	    };
  	    if(FORCED)for(key in methods){
  	      if(!(key in proto))redefine(proto, key, methods[key]);
  	    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
  	  }
  	  return methods;
  	};
  
  /***/ },
  /* 287 */
  /***/ function(module, exports) {
  
  	module.exports = true;
  
  /***/ },
  /* 288 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(264);
  
  /***/ },
  /* 289 */
  /***/ function(module, exports) {
  
  	module.exports = {};
  
  /***/ },
  /* 290 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	var create         = __webpack_require__(291)
  	  , descriptor     = __webpack_require__(273)
  	  , setToStringTag = __webpack_require__(303)
  	  , IteratorPrototype = {};
  	
  	// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
  	__webpack_require__(264)(IteratorPrototype, __webpack_require__(304)('iterator'), function(){ return this; });
  	
  	module.exports = function(Constructor, NAME, next){
  	  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});
  	  setToStringTag(Constructor, NAME + ' Iterator');
  	};
  
  /***/ },
  /* 291 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
  	var anObject    = __webpack_require__(266)
  	  , dPs         = __webpack_require__(292)
  	  , enumBugKeys = __webpack_require__(301)
  	  , IE_PROTO    = __webpack_require__(255)('IE_PROTO')
  	  , Empty       = function(){ /* empty */ }
  	  , PROTOTYPE   = 'prototype';
  	
  	// Create object with fake `null` prototype: use iframe Object with cleared prototype
  	var createDict = function(){
  	  // Thrash, waste and sodomy: IE GC bug
  	  var iframe = __webpack_require__(271)('iframe')
  	    , i      = enumBugKeys.length
  	    , lt     = '<'
  	    , gt     = '>'
  	    , iframeDocument;
  	  iframe.style.display = 'none';
  	  __webpack_require__(302).appendChild(iframe);
  	  iframe.src = 'javascript:'; // eslint-disable-line no-script-url
  	  // createDict = iframe.contentWindow.Object;
  	  // html.removeChild(iframe);
  	  iframeDocument = iframe.contentWindow.document;
  	  iframeDocument.open();
  	  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
  	  iframeDocument.close();
  	  createDict = iframeDocument.F;
  	  while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];
  	  return createDict();
  	};
  	
  	module.exports = Object.create || function create(O, Properties){
  	  var result;
  	  if(O !== null){
  	    Empty[PROTOTYPE] = anObject(O);
  	    result = new Empty;
  	    Empty[PROTOTYPE] = null;
  	    // add "__proto__" for Object.getPrototypeOf polyfill
  	    result[IE_PROTO] = O;
  	  } else result = createDict();
  	  return Properties === undefined ? result : dPs(result, Properties);
  	};
  
  
  /***/ },
  /* 292 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var dP       = __webpack_require__(265)
  	  , anObject = __webpack_require__(266)
  	  , getKeys  = __webpack_require__(293);
  	
  	module.exports = __webpack_require__(269) ? Object.defineProperties : function defineProperties(O, Properties){
  	  anObject(O);
  	  var keys   = getKeys(Properties)
  	    , length = keys.length
  	    , i = 0
  	    , P;
  	  while(length > i)dP.f(O, P = keys[i++], Properties[P]);
  	  return O;
  	};
  
  /***/ },
  /* 293 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 19.1.2.14 / 15.2.3.14 Object.keys(O)
  	var $keys       = __webpack_require__(294)
  	  , enumBugKeys = __webpack_require__(301);
  	
  	module.exports = Object.keys || function keys(O){
  	  return $keys(O, enumBugKeys);
  	};
  
  /***/ },
  /* 294 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var has          = __webpack_require__(254)
  	  , toIObject    = __webpack_require__(295)
  	  , arrayIndexOf = __webpack_require__(298)(false)
  	  , IE_PROTO     = __webpack_require__(255)('IE_PROTO');
  	
  	module.exports = function(object, names){
  	  var O      = toIObject(object)
  	    , i      = 0
  	    , result = []
  	    , key;
  	  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
  	  // Don't enum bug & hidden keys
  	  while(names.length > i)if(has(O, key = names[i++])){
  	    ~arrayIndexOf(result, key) || result.push(key);
  	  }
  	  return result;
  	};
  
  /***/ },
  /* 295 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// to indexed object, toObject with fallback for non-array-like ES3 strings
  	var IObject = __webpack_require__(296)
  	  , defined = __webpack_require__(252);
  	module.exports = function(it){
  	  return IObject(defined(it));
  	};
  
  /***/ },
  /* 296 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// fallback for non-array-like ES3 and non-enumerable old V8 strings
  	var cof = __webpack_require__(297);
  	module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
  	  return cof(it) == 'String' ? it.split('') : Object(it);
  	};
  
  /***/ },
  /* 297 */
  /***/ function(module, exports) {
  
  	var toString = {}.toString;
  	
  	module.exports = function(it){
  	  return toString.call(it).slice(8, -1);
  	};
  
  /***/ },
  /* 298 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// false -> Array#indexOf
  	// true  -> Array#includes
  	var toIObject = __webpack_require__(295)
  	  , toLength  = __webpack_require__(299)
  	  , toIndex   = __webpack_require__(300);
  	module.exports = function(IS_INCLUDES){
  	  return function($this, el, fromIndex){
  	    var O      = toIObject($this)
  	      , length = toLength(O.length)
  	      , index  = toIndex(fromIndex, length)
  	      , value;
  	    // Array#includes uses SameValueZero equality algorithm
  	    if(IS_INCLUDES && el != el)while(length > index){
  	      value = O[index++];
  	      if(value != value)return true;
  	    // Array#toIndex ignores holes, Array#includes - not
  	    } else for(;length > index; index++)if(IS_INCLUDES || index in O){
  	      if(O[index] === el)return IS_INCLUDES || index || 0;
  	    } return !IS_INCLUDES && -1;
  	  };
  	};
  
  /***/ },
  /* 299 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 7.1.15 ToLength
  	var toInteger = __webpack_require__(285)
  	  , min       = Math.min;
  	module.exports = function(it){
  	  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  	};
  
  /***/ },
  /* 300 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var toInteger = __webpack_require__(285)
  	  , max       = Math.max
  	  , min       = Math.min;
  	module.exports = function(index, length){
  	  index = toInteger(index);
  	  return index < 0 ? max(index + length, 0) : min(index, length);
  	};
  
  /***/ },
  /* 301 */
  /***/ function(module, exports) {
  
  	// IE 8- don't enum bug keys
  	module.exports = (
  	  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
  	).split(',');
  
  /***/ },
  /* 302 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(257).document && document.documentElement;
  
  /***/ },
  /* 303 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var def = __webpack_require__(265).f
  	  , has = __webpack_require__(254)
  	  , TAG = __webpack_require__(304)('toStringTag');
  	
  	module.exports = function(it, tag, stat){
  	  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
  	};
  
  /***/ },
  /* 304 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var store      = __webpack_require__(256)('wks')
  	  , uid        = __webpack_require__(258)
  	  , Symbol     = __webpack_require__(257).Symbol
  	  , USE_SYMBOL = typeof Symbol == 'function';
  	
  	var $exports = module.exports = function(name){
  	  return store[name] || (store[name] =
  	    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
  	};
  	
  	$exports.store = store;
  
  /***/ },
  /* 305 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(306);
  	var global        = __webpack_require__(257)
  	  , hide          = __webpack_require__(264)
  	  , Iterators     = __webpack_require__(289)
  	  , TO_STRING_TAG = __webpack_require__(304)('toStringTag');
  	
  	for(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){
  	  var NAME       = collections[i]
  	    , Collection = global[NAME]
  	    , proto      = Collection && Collection.prototype;
  	  if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);
  	  Iterators[NAME] = Iterators.Array;
  	}
  
  /***/ },
  /* 306 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	var addToUnscopables = __webpack_require__(307)
  	  , step             = __webpack_require__(308)
  	  , Iterators        = __webpack_require__(289)
  	  , toIObject        = __webpack_require__(295);
  	
  	// 22.1.3.4 Array.prototype.entries()
  	// 22.1.3.13 Array.prototype.keys()
  	// 22.1.3.29 Array.prototype.values()
  	// 22.1.3.30 Array.prototype[@@iterator]()
  	module.exports = __webpack_require__(286)(Array, 'Array', function(iterated, kind){
  	  this._t = toIObject(iterated); // target
  	  this._i = 0;                   // next index
  	  this._k = kind;                // kind
  	// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
  	}, function(){
  	  var O     = this._t
  	    , kind  = this._k
  	    , index = this._i++;
  	  if(!O || index >= O.length){
  	    this._t = undefined;
  	    return step(1);
  	  }
  	  if(kind == 'keys'  )return step(0, index);
  	  if(kind == 'values')return step(0, O[index]);
  	  return step(0, [index, O[index]]);
  	}, 'values');
  	
  	// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
  	Iterators.Arguments = Iterators.Array;
  	
  	addToUnscopables('keys');
  	addToUnscopables('values');
  	addToUnscopables('entries');
  
  /***/ },
  /* 307 */
  /***/ function(module, exports) {
  
  	module.exports = function(){ /* empty */ };
  
  /***/ },
  /* 308 */
  /***/ function(module, exports) {
  
  	module.exports = function(done, value){
  	  return {value: value, done: !!done};
  	};
  
  /***/ },
  /* 309 */
  /***/ function(module, exports, __webpack_require__) {
  
  	exports.f = __webpack_require__(304);
  
  /***/ },
  /* 310 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(311), __esModule: true };
  
  /***/ },
  /* 311 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(312);
  	__webpack_require__(323);
  	__webpack_require__(324);
  	__webpack_require__(325);
  	module.exports = __webpack_require__(261).Symbol;
  
  /***/ },
  /* 312 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	// ECMAScript 6 symbols shim
  	var global         = __webpack_require__(257)
  	  , has            = __webpack_require__(254)
  	  , DESCRIPTORS    = __webpack_require__(269)
  	  , $export        = __webpack_require__(260)
  	  , redefine       = __webpack_require__(288)
  	  , META           = __webpack_require__(313).KEY
  	  , $fails         = __webpack_require__(270)
  	  , shared         = __webpack_require__(256)
  	  , setToStringTag = __webpack_require__(303)
  	  , uid            = __webpack_require__(258)
  	  , wks            = __webpack_require__(304)
  	  , wksExt         = __webpack_require__(309)
  	  , wksDefine      = __webpack_require__(314)
  	  , keyOf          = __webpack_require__(315)
  	  , enumKeys       = __webpack_require__(316)
  	  , isArray        = __webpack_require__(319)
  	  , anObject       = __webpack_require__(266)
  	  , toIObject      = __webpack_require__(295)
  	  , toPrimitive    = __webpack_require__(272)
  	  , createDesc     = __webpack_require__(273)
  	  , _create        = __webpack_require__(291)
  	  , gOPNExt        = __webpack_require__(320)
  	  , $GOPD          = __webpack_require__(322)
  	  , $DP            = __webpack_require__(265)
  	  , $keys          = __webpack_require__(293)
  	  , gOPD           = $GOPD.f
  	  , dP             = $DP.f
  	  , gOPN           = gOPNExt.f
  	  , $Symbol        = global.Symbol
  	  , $JSON          = global.JSON
  	  , _stringify     = $JSON && $JSON.stringify
  	  , PROTOTYPE      = 'prototype'
  	  , HIDDEN         = wks('_hidden')
  	  , TO_PRIMITIVE   = wks('toPrimitive')
  	  , isEnum         = {}.propertyIsEnumerable
  	  , SymbolRegistry = shared('symbol-registry')
  	  , AllSymbols     = shared('symbols')
  	  , OPSymbols      = shared('op-symbols')
  	  , ObjectProto    = Object[PROTOTYPE]
  	  , USE_NATIVE     = typeof $Symbol == 'function'
  	  , QObject        = global.QObject;
  	// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
  	var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
  	
  	// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
  	var setSymbolDesc = DESCRIPTORS && $fails(function(){
  	  return _create(dP({}, 'a', {
  	    get: function(){ return dP(this, 'a', {value: 7}).a; }
  	  })).a != 7;
  	}) ? function(it, key, D){
  	  var protoDesc = gOPD(ObjectProto, key);
  	  if(protoDesc)delete ObjectProto[key];
  	  dP(it, key, D);
  	  if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc);
  	} : dP;
  	
  	var wrap = function(tag){
  	  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
  	  sym._k = tag;
  	  return sym;
  	};
  	
  	var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){
  	  return typeof it == 'symbol';
  	} : function(it){
  	  return it instanceof $Symbol;
  	};
  	
  	var $defineProperty = function defineProperty(it, key, D){
  	  if(it === ObjectProto)$defineProperty(OPSymbols, key, D);
  	  anObject(it);
  	  key = toPrimitive(key, true);
  	  anObject(D);
  	  if(has(AllSymbols, key)){
  	    if(!D.enumerable){
  	      if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {}));
  	      it[HIDDEN][key] = true;
  	    } else {
  	      if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
  	      D = _create(D, {enumerable: createDesc(0, false)});
  	    } return setSymbolDesc(it, key, D);
  	  } return dP(it, key, D);
  	};
  	var $defineProperties = function defineProperties(it, P){
  	  anObject(it);
  	  var keys = enumKeys(P = toIObject(P))
  	    , i    = 0
  	    , l = keys.length
  	    , key;
  	  while(l > i)$defineProperty(it, key = keys[i++], P[key]);
  	  return it;
  	};
  	var $create = function create(it, P){
  	  return P === undefined ? _create(it) : $defineProperties(_create(it), P);
  	};
  	var $propertyIsEnumerable = function propertyIsEnumerable(key){
  	  var E = isEnum.call(this, key = toPrimitive(key, true));
  	  if(this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return false;
  	  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
  	};
  	var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
  	  it  = toIObject(it);
  	  key = toPrimitive(key, true);
  	  if(it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return;
  	  var D = gOPD(it, key);
  	  if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
  	  return D;
  	};
  	var $getOwnPropertyNames = function getOwnPropertyNames(it){
  	  var names  = gOPN(toIObject(it))
  	    , result = []
  	    , i      = 0
  	    , key;
  	  while(names.length > i){
  	    if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key);
  	  } return result;
  	};
  	var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
  	  var IS_OP  = it === ObjectProto
  	    , names  = gOPN(IS_OP ? OPSymbols : toIObject(it))
  	    , result = []
  	    , i      = 0
  	    , key;
  	  while(names.length > i){
  	    if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]);
  	  } return result;
  	};
  	
  	// 19.4.1.1 Symbol([description])
  	if(!USE_NATIVE){
  	  $Symbol = function Symbol(){
  	    if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!');
  	    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
  	    var $set = function(value){
  	      if(this === ObjectProto)$set.call(OPSymbols, value);
  	      if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
  	      setSymbolDesc(this, tag, createDesc(1, value));
  	    };
  	    if(DESCRIPTORS && setter)setSymbolDesc(ObjectProto, tag, {configurable: true, set: $set});
  	    return wrap(tag);
  	  };
  	  redefine($Symbol[PROTOTYPE], 'toString', function toString(){
  	    return this._k;
  	  });
  	
  	  $GOPD.f = $getOwnPropertyDescriptor;
  	  $DP.f   = $defineProperty;
  	  __webpack_require__(321).f = gOPNExt.f = $getOwnPropertyNames;
  	  __webpack_require__(318).f  = $propertyIsEnumerable;
  	  __webpack_require__(317).f = $getOwnPropertySymbols;
  	
  	  if(DESCRIPTORS && !__webpack_require__(287)){
  	    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
  	  }
  	
  	  wksExt.f = function(name){
  	    return wrap(wks(name));
  	  }
  	}
  	
  	$export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol});
  	
  	for(var symbols = (
  	  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
  	  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
  	).split(','), i = 0; symbols.length > i; )wks(symbols[i++]);
  	
  	for(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]);
  	
  	$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
  	  // 19.4.2.1 Symbol.for(key)
  	  'for': function(key){
  	    return has(SymbolRegistry, key += '')
  	      ? SymbolRegistry[key]
  	      : SymbolRegistry[key] = $Symbol(key);
  	  },
  	  // 19.4.2.5 Symbol.keyFor(sym)
  	  keyFor: function keyFor(key){
  	    if(isSymbol(key))return keyOf(SymbolRegistry, key);
  	    throw TypeError(key + ' is not a symbol!');
  	  },
  	  useSetter: function(){ setter = true; },
  	  useSimple: function(){ setter = false; }
  	});
  	
  	$export($export.S + $export.F * !USE_NATIVE, 'Object', {
  	  // 19.1.2.2 Object.create(O [, Properties])
  	  create: $create,
  	  // 19.1.2.4 Object.defineProperty(O, P, Attributes)
  	  defineProperty: $defineProperty,
  	  // 19.1.2.3 Object.defineProperties(O, Properties)
  	  defineProperties: $defineProperties,
  	  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
  	  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
  	  // 19.1.2.7 Object.getOwnPropertyNames(O)
  	  getOwnPropertyNames: $getOwnPropertyNames,
  	  // 19.1.2.8 Object.getOwnPropertySymbols(O)
  	  getOwnPropertySymbols: $getOwnPropertySymbols
  	});
  	
  	// 24.3.2 JSON.stringify(value [, replacer [, space]])
  	$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){
  	  var S = $Symbol();
  	  // MS Edge converts symbol values to JSON as {}
  	  // WebKit converts symbol values to JSON as null
  	  // V8 throws on boxed symbols
  	  return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';
  	})), 'JSON', {
  	  stringify: function stringify(it){
  	    if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined
  	    var args = [it]
  	      , i    = 1
  	      , replacer, $replacer;
  	    while(arguments.length > i)args.push(arguments[i++]);
  	    replacer = args[1];
  	    if(typeof replacer == 'function')$replacer = replacer;
  	    if($replacer || !isArray(replacer))replacer = function(key, value){
  	      if($replacer)value = $replacer.call(this, key, value);
  	      if(!isSymbol(value))return value;
  	    };
  	    args[1] = replacer;
  	    return _stringify.apply($JSON, args);
  	  }
  	});
  	
  	// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
  	$Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(264)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
  	// 19.4.3.5 Symbol.prototype[@@toStringTag]
  	setToStringTag($Symbol, 'Symbol');
  	// 20.2.1.9 Math[@@toStringTag]
  	setToStringTag(Math, 'Math', true);
  	// 24.3.3 JSON[@@toStringTag]
  	setToStringTag(global.JSON, 'JSON', true);
  
  /***/ },
  /* 313 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var META     = __webpack_require__(258)('meta')
  	  , isObject = __webpack_require__(267)
  	  , has      = __webpack_require__(254)
  	  , setDesc  = __webpack_require__(265).f
  	  , id       = 0;
  	var isExtensible = Object.isExtensible || function(){
  	  return true;
  	};
  	var FREEZE = !__webpack_require__(270)(function(){
  	  return isExtensible(Object.preventExtensions({}));
  	});
  	var setMeta = function(it){
  	  setDesc(it, META, {value: {
  	    i: 'O' + ++id, // object ID
  	    w: {}          // weak collections IDs
  	  }});
  	};
  	var fastKey = function(it, create){
  	  // return primitive with prefix
  	  if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
  	  if(!has(it, META)){
  	    // can't set metadata to uncaught frozen object
  	    if(!isExtensible(it))return 'F';
  	    // not necessary to add metadata
  	    if(!create)return 'E';
  	    // add missing metadata
  	    setMeta(it);
  	  // return object ID
  	  } return it[META].i;
  	};
  	var getWeak = function(it, create){
  	  if(!has(it, META)){
  	    // can't set metadata to uncaught frozen object
  	    if(!isExtensible(it))return true;
  	    // not necessary to add metadata
  	    if(!create)return false;
  	    // add missing metadata
  	    setMeta(it);
  	  // return hash weak collections IDs
  	  } return it[META].w;
  	};
  	// add metadata on freeze-family methods calling
  	var onFreeze = function(it){
  	  if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it);
  	  return it;
  	};
  	var meta = module.exports = {
  	  KEY:      META,
  	  NEED:     false,
  	  fastKey:  fastKey,
  	  getWeak:  getWeak,
  	  onFreeze: onFreeze
  	};
  
  /***/ },
  /* 314 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var global         = __webpack_require__(257)
  	  , core           = __webpack_require__(261)
  	  , LIBRARY        = __webpack_require__(287)
  	  , wksExt         = __webpack_require__(309)
  	  , defineProperty = __webpack_require__(265).f;
  	module.exports = function(name){
  	  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
  	  if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)});
  	};
  
  /***/ },
  /* 315 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var getKeys   = __webpack_require__(293)
  	  , toIObject = __webpack_require__(295);
  	module.exports = function(object, el){
  	  var O      = toIObject(object)
  	    , keys   = getKeys(O)
  	    , length = keys.length
  	    , index  = 0
  	    , key;
  	  while(length > index)if(O[key = keys[index++]] === el)return key;
  	};
  
  /***/ },
  /* 316 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// all enumerable object keys, includes symbols
  	var getKeys = __webpack_require__(293)
  	  , gOPS    = __webpack_require__(317)
  	  , pIE     = __webpack_require__(318);
  	module.exports = function(it){
  	  var result     = getKeys(it)
  	    , getSymbols = gOPS.f;
  	  if(getSymbols){
  	    var symbols = getSymbols(it)
  	      , isEnum  = pIE.f
  	      , i       = 0
  	      , key;
  	    while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key);
  	  } return result;
  	};
  
  /***/ },
  /* 317 */
  /***/ function(module, exports) {
  
  	exports.f = Object.getOwnPropertySymbols;
  
  /***/ },
  /* 318 */
  /***/ function(module, exports) {
  
  	exports.f = {}.propertyIsEnumerable;
  
  /***/ },
  /* 319 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 7.2.2 IsArray(argument)
  	var cof = __webpack_require__(297);
  	module.exports = Array.isArray || function isArray(arg){
  	  return cof(arg) == 'Array';
  	};
  
  /***/ },
  /* 320 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
  	var toIObject = __webpack_require__(295)
  	  , gOPN      = __webpack_require__(321).f
  	  , toString  = {}.toString;
  	
  	var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
  	  ? Object.getOwnPropertyNames(window) : [];
  	
  	var getWindowNames = function(it){
  	  try {
  	    return gOPN(it);
  	  } catch(e){
  	    return windowNames.slice();
  	  }
  	};
  	
  	module.exports.f = function getOwnPropertyNames(it){
  	  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
  	};
  
  
  /***/ },
  /* 321 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
  	var $keys      = __webpack_require__(294)
  	  , hiddenKeys = __webpack_require__(301).concat('length', 'prototype');
  	
  	exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){
  	  return $keys(O, hiddenKeys);
  	};
  
  /***/ },
  /* 322 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var pIE            = __webpack_require__(318)
  	  , createDesc     = __webpack_require__(273)
  	  , toIObject      = __webpack_require__(295)
  	  , toPrimitive    = __webpack_require__(272)
  	  , has            = __webpack_require__(254)
  	  , IE8_DOM_DEFINE = __webpack_require__(268)
  	  , gOPD           = Object.getOwnPropertyDescriptor;
  	
  	exports.f = __webpack_require__(269) ? gOPD : function getOwnPropertyDescriptor(O, P){
  	  O = toIObject(O);
  	  P = toPrimitive(P, true);
  	  if(IE8_DOM_DEFINE)try {
  	    return gOPD(O, P);
  	  } catch(e){ /* empty */ }
  	  if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);
  	};
  
  /***/ },
  /* 323 */
  /***/ function(module, exports) {
  
  
  
  /***/ },
  /* 324 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(314)('asyncIterator');
  
  /***/ },
  /* 325 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(314)('observable');
  
  /***/ },
  /* 326 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	exports.__esModule = true;
  	
  	var _setPrototypeOf = __webpack_require__(327);
  	
  	var _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);
  	
  	var _create = __webpack_require__(331);
  	
  	var _create2 = _interopRequireDefault(_create);
  	
  	var _typeof2 = __webpack_require__(280);
  	
  	var _typeof3 = _interopRequireDefault(_typeof2);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	exports.default = function (subClass, superClass) {
  	  if (typeof superClass !== "function" && superClass !== null) {
  	    throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : (0, _typeof3.default)(superClass)));
  	  }
  	
  	  subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, {
  	    constructor: {
  	      value: subClass,
  	      enumerable: false,
  	      writable: true,
  	      configurable: true
  	    }
  	  });
  	  if (superClass) _setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass;
  	};
  
  /***/ },
  /* 327 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(328), __esModule: true };
  
  /***/ },
  /* 328 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(329);
  	module.exports = __webpack_require__(261).Object.setPrototypeOf;
  
  /***/ },
  /* 329 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 19.1.3.19 Object.setPrototypeOf(O, proto)
  	var $export = __webpack_require__(260);
  	$export($export.S, 'Object', {setPrototypeOf: __webpack_require__(330).set});
  
  /***/ },
  /* 330 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// Works with __proto__ only. Old v8 can't work with null proto objects.
  	/* eslint-disable no-proto */
  	var isObject = __webpack_require__(267)
  	  , anObject = __webpack_require__(266);
  	var check = function(O, proto){
  	  anObject(O);
  	  if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
  	};
  	module.exports = {
  	  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
  	    function(test, buggy, set){
  	      try {
  	        set = __webpack_require__(262)(Function.call, __webpack_require__(322).f(Object.prototype, '__proto__').set, 2);
  	        set(test, []);
  	        buggy = !(test instanceof Array);
  	      } catch(e){ buggy = true; }
  	      return function setPrototypeOf(O, proto){
  	        check(O, proto);
  	        if(buggy)O.__proto__ = proto;
  	        else set(O, proto);
  	        return O;
  	      };
  	    }({}, false) : undefined),
  	  check: check
  	};
  
  /***/ },
  /* 331 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(332), __esModule: true };
  
  /***/ },
  /* 332 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(333);
  	var $Object = __webpack_require__(261).Object;
  	module.exports = function create(P, D){
  	  return $Object.create(P, D);
  	};
  
  /***/ },
  /* 333 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var $export = __webpack_require__(260)
  	// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
  	$export($export.S, 'Object', {create: __webpack_require__(291)});
  
  /***/ },
  /* 334 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(79), RootInstanceProvider = __webpack_require__(87), ReactMount = __webpack_require__(89), React = __webpack_require__(141); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } try { (function () {
  	
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	exports.Content = exports.Header = exports.MyComponent = undefined;
  	
  	var _index = __webpack_require__(335);
  	
  	var _index2 = _interopRequireDefault(_index);
  	
  	var _index3 = __webpack_require__(340);
  	
  	var _index4 = _interopRequireDefault(_index3);
  	
  	var _index5 = __webpack_require__(342);
  	
  	var _index6 = _interopRequireDefault(_index5);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	exports.MyComponent = _index2.default;
  	exports.Header = _index4.default;
  	exports.Content = _index6.default;
  	
  	/* REACT HOT LOADER */ }).call(this); } finally { if (true) { (function () { var foundReactClasses = module.hot.data && module.hot.data.foundReactClasses || false; if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(337); if (makeExportsHot(module, __webpack_require__(141))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error("Cannot apply hot update to " + "index.js" + ": " + err.message); } }); } } module.hot.dispose(function (data) { data.makeHot = module.makeHot; data.foundReactClasses = foundReactClasses; }); })(); } }
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
  
  /***/ },
  /* 335 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(79), RootInstanceProvider = __webpack_require__(87), ReactMount = __webpack_require__(89), React = __webpack_require__(141); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } try { (function () {
  	
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	
  	var _getPrototypeOf = __webpack_require__(248);
  	
  	var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
  	
  	var _classCallCheck2 = __webpack_require__(274);
  	
  	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
  	
  	var _createClass2 = __webpack_require__(275);
  	
  	var _createClass3 = _interopRequireDefault(_createClass2);
  	
  	var _possibleConstructorReturn2 = __webpack_require__(279);
  	
  	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
  	
  	var _inherits2 = __webpack_require__(326);
  	
  	var _inherits3 = _interopRequireDefault(_inherits2);
  	
  	var _react = __webpack_require__(141);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	__webpack_require__(336);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	var MyComponent = function (_Component) {
  	  (0, _inherits3.default)(MyComponent, _Component);
  	
  	  function MyComponent() {
  	    (0, _classCallCheck3.default)(this, MyComponent);
  	    return (0, _possibleConstructorReturn3.default)(this, (MyComponent.__proto__ || (0, _getPrototypeOf2.default)(MyComponent)).apply(this, arguments));
  	  }
  	
  	  (0, _createClass3.default)(MyComponent, [{
  	    key: 'render',
  	    value: function render() {
  	      return _react2.default.createElement(
  	        'h1',
  	        { className: 'demo' },
  	        _react2.default.createElement('span', { className: 'glyphicon glyphicon-th' }),
  	        '\u66F4\u591A\u5E72\u8D27\u8BF7\u524D\u5F80\uFF1Ahttp://guoyongfeng.github.io/idoc/',
  	        _react2.default.createElement('span', { className: 'glyphicon glyphicon-plane' })
  	      );
  	    }
  	  }]);
  	  return MyComponent;
  	}(_react.Component);
  	
  	exports.default = MyComponent;
  	
  	/* REACT HOT LOADER */ }).call(this); } finally { if (true) { (function () { var foundReactClasses = module.hot.data && module.hot.data.foundReactClasses || false; if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(337); if (makeExportsHot(module, __webpack_require__(141))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error("Cannot apply hot update to " + "index.jsx" + ": " + err.message); } }); } } module.hot.dispose(function (data) { data.makeHot = module.makeHot; data.foundReactClasses = foundReactClasses; }); })(); } }
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
  
  /***/ },
  /* 336 */
  /***/ function(module, exports) {
  
  	// removed by extract-text-webpack-plugin
  
  /***/ },
  /* 337 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var isReactClassish = __webpack_require__(338),
  	    isReactElementish = __webpack_require__(339);
  	
  	function makeExportsHot(m, React) {
  	  if (isReactElementish(m.exports, React)) {
  	    // React elements are never valid React classes
  	    return false;
  	  }
  	
  	  var freshExports = m.exports,
  	      exportsReactClass = isReactClassish(m.exports, React),
  	      foundReactClasses = false;
  	
  	  if (exportsReactClass) {
  	    m.exports = m.makeHot(m.exports, '__MODULE_EXPORTS');
  	    foundReactClasses = true;
  	  }
  	
  	  for (var key in m.exports) {
  	    if (!Object.prototype.hasOwnProperty.call(freshExports, key)) {
  	      continue;
  	    }
  	
  	    if (exportsReactClass && key === 'type') {
  	      // React 0.12 also puts classes under `type` property for compat.
  	      // Skip to avoid updating twice.
  	      continue;
  	    }
  	
  	    var value;
  	    try {
  	      value = freshExports[key];
  	    } catch (err) {
  	      continue;
  	    }
  	
  	    if (!isReactClassish(value, React)) {
  	      continue;
  	    }
  	
  	    if (Object.getOwnPropertyDescriptor(m.exports, key).writable) {
  	      m.exports[key] = m.makeHot(value, '__MODULE_EXPORTS_' + key);
  	      foundReactClasses = true;
  	    } else {
  	      console.warn("Can't make class " + key + " hot reloadable due to being read-only. To fix this you can try two solutions. First, you can exclude files or directories (for example, /node_modules/) using 'exclude' option in loader configuration. Second, if you are using Babel, you can enable loose mode for `es6.modules` using the 'loose' option. See: http://babeljs.io/docs/plugins/transform-es2015-modules-commonjs/#options-loose and http://babeljs.io/docs/usage/options/");
  	    }
  	  }
  	
  	  return foundReactClasses;
  	}
  	
  	module.exports = makeExportsHot;
  
  
  /***/ },
  /* 338 */
  /***/ function(module, exports) {
  
  	function hasRender(Class) {
  	  var prototype = Class.prototype;
  	  if (!prototype) {
  	    return false;
  	  }
  	
  	  return typeof prototype.render === 'function';
  	}
  	
  	function descendsFromReactComponent(Class, React) {
  	  if (!React.Component) {
  	    return false;
  	  }
  	
  	  var Base = Object.getPrototypeOf(Class);
  	  while (Base) {
  	    if (Base === React.Component) {
  	      return true;
  	    }
  	
  	    Base = Object.getPrototypeOf(Base);
  	  }
  	
  	  return false;
  	}
  	
  	function isReactClassish(Class, React) {
  	  if (typeof Class !== 'function') {
  	    return false;
  	  }
  	
  	  // React 0.13
  	  if (hasRender(Class) || descendsFromReactComponent(Class, React)) {
  	    return true;
  	  }
  	
  	  // React 0.12 and earlier
  	  if (Class.type && hasRender(Class.type)) {
  	    return true;
  	  }
  	
  	  return false;
  	}
  	
  	module.exports = isReactClassish;
  
  /***/ },
  /* 339 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var isReactClassish = __webpack_require__(338);
  	
  	function isReactElementish(obj, React) {
  	  if (!obj) {
  	    return false;
  	  }
  	
  	  return Object.prototype.toString.call(obj.props) === '[object Object]' &&
  	         isReactClassish(obj.type, React);
  	}
  	
  	module.exports = isReactElementish;
  
  /***/ },
  /* 340 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(79), RootInstanceProvider = __webpack_require__(87), ReactMount = __webpack_require__(89), React = __webpack_require__(141); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } try { (function () {
  	
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	
  	var _getPrototypeOf = __webpack_require__(248);
  	
  	var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
  	
  	var _classCallCheck2 = __webpack_require__(274);
  	
  	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
  	
  	var _createClass2 = __webpack_require__(275);
  	
  	var _createClass3 = _interopRequireDefault(_createClass2);
  	
  	var _possibleConstructorReturn2 = __webpack_require__(279);
  	
  	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
  	
  	var _inherits2 = __webpack_require__(326);
  	
  	var _inherits3 = _interopRequireDefault(_inherits2);
  	
  	var _react = __webpack_require__(141);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	var _jquery = __webpack_require__(341);
  	
  	var _jquery2 = _interopRequireDefault(_jquery);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	var Header = function (_Component) {
  	  (0, _inherits3.default)(Header, _Component);
  	
  	  function Header(props) {
  	    (0, _classCallCheck3.default)(this, Header);
  	    return (0, _possibleConstructorReturn3.default)(this, (Header.__proto__ || (0, _getPrototypeOf2.default)(Header)).call(this, props));
  	  }
  	
  	  (0, _createClass3.default)(Header, [{
  	    key: 'render',
  	    value: function render() {
  	      var studio = this.props.data;
  	      if (studio && parseInt(studio.streamid)) {
  	        (0, _jquery2.default)('.contentWrapper').addClass('fixe');
  	        (0, _jquery2.default)('.roseLive_head_con').addClass('fixeddd');
  	        var head = _react2.default.createElement(
  	          'div',
  	          { className: 'videoW' },
  	          _react2.default.createElement(
  	            'video',
  	            { id: 'Video', onwebkitfullscreenchange: 'OnFullscreen(this)', onresize: 'OnFullscreen(this)', controls: '', width: '100%', height: '100%', poster: '', 'x-webkit-airplay': 'true', 'webkit-playsinline': 'true' },
  	            _react2.default.createElement('source', { src: studio.streamurl, type: 'video/mp4' })
  	          )
  	        );
  	      } else if (studio && studio.titlepic) {
  	        var head = _react2.default.createElement(
  	          'div',
  	          { className: 'head_img' },
  	          _react2.default.createElement('img', { className: 'livebackground pic_ground', src: studio.titlepic, alt: '', width: '100%' })
  	        );
  	      }
  	      return _react2.default.createElement(
  	        'div',
  	        { className: 'roseLive_head_con' },
  	        _react2.default.createElement(
  	          'div',
  	          { className: 'roseLive_head' },
  	          head
  	        )
  	      );
  	    }
  	  }]);
  	  return Header;
  	}(_react.Component);
  	
  	exports.default = Header;
  	
  	/* REACT HOT LOADER */ }).call(this); } finally { if (true) { (function () { var foundReactClasses = module.hot.data && module.hot.data.foundReactClasses || false; if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(337); if (makeExportsHot(module, __webpack_require__(141))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error("Cannot apply hot update to " + "index.jsx" + ": " + err.message); } }); } } module.hot.dispose(function (data) { data.makeHot = module.makeHot; data.foundReactClasses = foundReactClasses; }); })(); } }
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
  
  /***/ },
  /* 341 */,
  /* 342 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(79), RootInstanceProvider = __webpack_require__(87), ReactMount = __webpack_require__(89), React = __webpack_require__(141); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } try { (function () {
  	
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	
  	var _getPrototypeOf = __webpack_require__(248);
  	
  	var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
  	
  	var _classCallCheck2 = __webpack_require__(274);
  	
  	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
  	
  	var _createClass2 = __webpack_require__(275);
  	
  	var _createClass3 = _interopRequireDefault(_createClass2);
  	
  	var _possibleConstructorReturn2 = __webpack_require__(279);
  	
  	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
  	
  	var _inherits2 = __webpack_require__(326);
  	
  	var _inherits3 = _interopRequireDefault(_inherits2);
  	
  	var _react = __webpack_require__(141);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	var _reactDom = __webpack_require__(245);
  	
  	var _reactDom2 = _interopRequireDefault(_reactDom);
  	
  	var _jquery = __webpack_require__(341);
  	
  	var _jquery2 = _interopRequireDefault(_jquery);
  	
  	var _iscrollProbe = __webpack_require__(343);
  	
  	var _iscrollProbe2 = _interopRequireDefault(_iscrollProbe);
  	
  	var _helper = __webpack_require__(344);
  	
  	var _helper2 = _interopRequireDefault(_helper);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	var myScroll = void 0;
  	
  	var options = {
  	  preventDefault: false,
  	  mouseWheel: true,
  	  scrollbars: false,
  	  preventDefaultException: { tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT|A|IFRAME|VIDEO)$/ },
  	  probeType: 1,
  	  fadeScrollbars: false,
  	  checkDOMChanges: true,
  	  useTransition: true
  	};
  	
  	var ContentS = function (_Component) {
  	  (0, _inherits3.default)(ContentS, _Component);
  	
  	  function ContentS() {
  	    var _ref;
  	
  	    var _temp, _this, _ret;
  	
  	    (0, _classCallCheck3.default)(this, ContentS);
  	
  	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
  	      args[_key] = arguments[_key];
  	    }
  	
  	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3.default)(this, (_ref = ContentS.__proto__ || (0, _getPrototypeOf2.default)(ContentS)).call.apply(_ref, [this].concat(args))), _this), _this.posterClick = function () {
  	      var poster = (0, _reactDom.findDOMNode)(_this.refs.poster);
  	      var ele = (0, _reactDom.findDOMNode)(_this.refs.VideoComp);
  	      var id = (0, _jquery2.default)(ele).attr('id');
  	      (0, _jquery2.default)(poster).addClass('reClick');
  	      var video = document.getElementById(id);
  	      (0, _jquery2.default)(video).css('display', 'block');
  	      if (video.paused) {
  	        video.style.width = '100%';
  	        video.style.height = '100%';
  	        video.play();
  	        (0, _jquery2.default)(poster).css('display', 'none');
  	      }
  	      video.addEventListener("pause", function () {
  	        (0, _jquery2.default)(poster).removeClass('reClick');
  	        (0, _jquery2.default)(poster).css('display', 'block');
  	        video.style.width = '1px';
  	        video.style.height = '1px';
  	        (0, _jquery2.default)(poster).find('.poster').css({
  	          'height': '100',
  	          'width': '100%'
  	        });
  	      }, false);
  	    }, _temp), (0, _possibleConstructorReturn3.default)(_this, _ret);
  	  }
  	
  	  (0, _createClass3.default)(ContentS, [{
  	    key: 'componentWillMount',
  	    value: function componentWillMount() {
  	      /*    var data = this.props.data
  	          console.log(data)
  	          if(data.inc && data.bar){
  	            console.log('删除')
  	            $('.fresh .timeCollection').eq(0).remove()
  	          }*/
  	    }
  	  }, {
  	    key: 'componentWillReceiveProps',
  	    value: function componentWillReceiveProps(nextProps) {
  	      var data = nextProps.data;
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      var stremid = this.props.stremid;
  	      var data = this.props.data;
  	      return _react2.default.createElement(
  	        'div',
  	        null,
  	        _helper2.default.render(data, stremid, this)
  	      );
  	    }
  	  }]);
  	  return ContentS;
  	}(_react.Component);
  	
  	var CommentComp = function (_Component2) {
  	  (0, _inherits3.default)(CommentComp, _Component2);
  	
  	  function CommentComp() {
  	    var _ref2;
  	
  	    var _temp2, _this2, _ret2;
  	
  	    (0, _classCallCheck3.default)(this, CommentComp);
  	
  	    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
  	      args[_key2] = arguments[_key2];
  	    }
  	
  	    return _ret2 = (_temp2 = (_this2 = (0, _possibleConstructorReturn3.default)(this, (_ref2 = CommentComp.__proto__ || (0, _getPrototypeOf2.default)(CommentComp)).call.apply(_ref2, [this].concat(args))), _this2), _this2.state = {
  	      newsList: [],
  	      date: ''
  	    }, _temp2), (0, _possibleConstructorReturn3.default)(_this2, _ret2);
  	  }
  	
  	  (0, _createClass3.default)(CommentComp, [{
  	    key: 'componentWillReceiveProps',
  	    value: function componentWillReceiveProps(nextProps) {
  	      var that = this,
  	          newsList = nextProps.newsList;
  	      for (var i = 0; i < newsList.length; i++) {
  	        if (newsList[i].inc) {
  	          if (newsList[i].timeC == newsList[i + 1].timeC) {
  	            newsList[i + 1].bar = 0;
  	          }
  	        }
  	      }
  	      this.setState({
  	        newsList: newsList
  	      });
  	    }
  	  }, {
  	    key: 'componentWillMount',
  	    value: function componentWillMount() {
  	      console.log('CommentComp componentWillMount', this.props);
  	      this.setState({
  	        newsList: this.props.newsList
  	      });
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      var streamid = this.props.streamid;
  	      return _react2.default.createElement(
  	        'div',
  	        null,
  	        _react2.default.createElement('div', { className: 'maskload' }),
  	        _react2.default.createElement(
  	          'div',
  	          { className: 'pulldown' },
  	          _react2.default.createElement('span', { className: 'icon' }),
  	          _react2.default.createElement(
  	            'span',
  	            { className: 'label' },
  	            '\u4E0B\u62C9\u5237\u65B0...'
  	          )
  	        ),
  	        _react2.default.createElement(
  	          'div',
  	          { className: 'smalltxt' },
  	          _react2.default.createElement(
  	            'div',
  	            { className: 'text' },
  	            _react2.default.createElement(
  	              'span',
  	              null,
  	              '\u6838\u5FC3\u63D0\u793A\uFF1A'
  	            ),
  	            _react2.default.createElement(
  	              'i',
  	              null,
  	              this.props.intro
  	            )
  	          )
  	        ),
  	        _react2.default.createElement(
  	          'div',
  	          { className: 'topW' },
  	          _react2.default.createElement(
  	            'div',
  	            { className: 'ui-newstips-wrap tipBand' },
  	            _react2.default.createElement(
  	              'div',
  	              { className: 'ui-newstips' },
  	              _react2.default.createElement('i', null),
  	              _react2.default.createElement(
  	                'div',
  	                null,
  	                '\u65B0\u6D88\u606F'
  	              ),
  	              _react2.default.createElement(
  	                'span',
  	                { className: 'ui-badge-num' },
  	                '123'
  	              )
  	            )
  	          )
  	        ),
  	        _react2.default.createElement(
  	          'div',
  	          { className: 'fresh' },
  	          this.state.newsList.map(function (object, i) {
  	            return _react2.default.createElement(ContentS, { data: object, key: i, stremid: streamid });
  	          })
  	        ),
  	        _react2.default.createElement(
  	          'div',
  	          { id: 'j_pullLoader', className: 'more_btnbox hide' },
  	          _react2.default.createElement(
  	            'div',
  	            { className: 'more_btn_loading' },
  	            _react2.default.createElement('span', { className: 'loadingbtn' }),
  	            _react2.default.createElement(
  	              'span',
  	              { className: 'more_btn' },
  	              '\u4E0A\u62C9\u52A0\u8F7D\u66F4\u591A'
  	            )
  	          )
  	        )
  	      );
  	    }
  	  }]);
  	  return CommentComp;
  	}(_react.Component);
  	
  	var WebIScroll = function (_Component3) {
  	  (0, _inherits3.default)(WebIScroll, _Component3);
  	
  	  function WebIScroll() {
  	    var _ref3;
  	
  	    var _temp3, _this3, _ret3;
  	
  	    (0, _classCallCheck3.default)(this, WebIScroll);
  	
  	    for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
  	      args[_key3] = arguments[_key3];
  	    }
  	
  	    return _ret3 = (_temp3 = (_this3 = (0, _possibleConstructorReturn3.default)(this, (_ref3 = WebIScroll.__proto__ || (0, _getPrototypeOf2.default)(WebIScroll)).call.apply(_ref3, [this].concat(args))), _this3), _this3.state = {
  	      newsList: [1],
  	      intro: '',
  	      streamid: '',
  	      id: 0
  	    }, _temp3), (0, _possibleConstructorReturn3.default)(_this3, _ret3);
  	  }
  	
  	  (0, _createClass3.default)(WebIScroll, [{
  	    key: 'componentWillMount',
  	    value: function componentWillMount() {
  	      //console.log('componentWillMount WebIScroll')
  	      this.setState({
  	        newsList: this.props.newsList,
  	        intro: this.props.intro,
  	        streamid: this.props.streamid,
  	        id: this.props.id
  	      });
  	    }
  	  }, {
  	    key: 'componentWillReceiveProps',
  	    value: function componentWillReceiveProps(nextProps) {
  	      //console.log('componentWillReceiveProps ReactIScroll',nextProps)
  	      var props = nextProps.newsList;
  	      this.setState({
  	        newsList: props,
  	        intro: nextProps.intro,
  	        streamid: nextProps.streamid,
  	        id: nextProps.id
  	      });
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      //console.log('WebIScroll render')
  	      return _react2.default.createElement(CommentComp, { newsList: this.state.newsList, intro: this.state.intro, streamid: this.state.streamid, id: this.state.id });
  	    }
  	  }, {
  	    key: 'scrollFunc',
  	    value: function scrollFunc() {
  	      var rosHeight = (0, _jquery2.default)('.roseLive_head_con').height() + (0, _jquery2.default)('.smalltxt').height() + 2 * (0, _jquery2.default)('.timeCollection.sub').height();
  	      var vd = _helper2.default.viewData();
  	      if (vd.scrollTop > rosHeight) {
  	        (0, _jquery2.default)('.timeCollection.tip').css('display', 'block').html((0, _jquery2.default)('.timeCollection.sub').eq(0).html());
  	      } else {
  	        (0, _jquery2.default)('.timeCollection.tip').css('display', 'none');
  	      }
  	      (0, _jquery2.default)('.timeCollection.sub').each(function (i) {
  	        var judgTimeT = (0, _jquery2.default)(this).position().top;
  	        if (judgTimeT < vd.scrollTop) {
  	          (0, _jquery2.default)('.timeCollection.tip').html((0, _jquery2.default)(this).html());
  	        }
  	      });
  	    }
  	  }, {
  	    key: 'componentDidMount',
  	    value: function componentDidMount() {
  	      (0, _jquery2.default)('.maskload').css('display', 'none');
  	      //console.log('componentDidMount WebTScroll')
  	      var scrollEvent = "onscroll" in document.documentElement ? "scroll" : "touchmove";
  	      var that = this;
  	      console.log(176, this.props);
  	      (0, _jquery2.default)(window).on(scrollEvent, function () {
  	        var ret = _helper2.default.util._initScrollEnd(that.props.id);
  	        if (ret) {
  	          ret.then(function (data) {
  	            if (data.length) {
  	              var olddata = that.state.newsList;
  	              var join = olddata.concat(data);
  	              that.setState({
  	                newsList: join
  	              });
  	            }
  	          });
  	        }
  	        that.scrollFunc();
  	      });
  	
  	      var scrollEvent = "onscroll" in document.documentElement ? "scroll" : "touchmove";
  	      (0, _jquery2.default)(window).on(scrollEvent, function () {});
  	    }
  	  }, {
  	    key: 'componentDidUpdate',
  	    value: function componentDidUpdate() {
  	      //console.log('componentDidUpdate WebTScroll')
  	    }
  	  }]);
  	  return WebIScroll;
  	}(_react.Component);
  	
  	var ReactIScroll = function (_Component4) {
  	  (0, _inherits3.default)(ReactIScroll, _Component4);
  	
  	  function ReactIScroll() {
  	    var _ref4;
  	
  	    var _temp4, _this4, _ret4;
  	
  	    (0, _classCallCheck3.default)(this, ReactIScroll);
  	
  	    for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
  	      args[_key4] = arguments[_key4];
  	    }
  	
  	    return _ret4 = (_temp4 = (_this4 = (0, _possibleConstructorReturn3.default)(this, (_ref4 = ReactIScroll.__proto__ || (0, _getPrototypeOf2.default)(ReactIScroll)).call.apply(_ref4, [this].concat(args))), _this4), _this4.state = {
  	      newsList: [1],
  	      intro: '',
  	      streamid: ''
  	    }, _temp4), (0, _possibleConstructorReturn3.default)(_this4, _ret4);
  	  }
  	
  	  (0, _createClass3.default)(ReactIScroll, [{
  	    key: 'componentWillMount',
  	    value: function componentWillMount() {
  	      //console.log('componentWillMount ReactIScroll')
  	      this.setState({
  	        newsList: this.props.newsList,
  	        intro: this.props.intro,
  	        streamid: this.props.streamid
  	      });
  	    }
  	  }, {
  	    key: 'componentWillUpdate',
  	    value: function componentWillUpdate(nextProps, nextState) {
  	      //console.log('componentWillUpdate ReactIScroll');
  	    }
  	  }, {
  	    key: 'componentWillReceiveProps',
  	    value: function componentWillReceiveProps(nextProps) {
  	      //console.log(173,'componentWillReceiveProps ReactIScroll',nextProps)
  	      this.setState({
  	        newsList: nextProps.newsList,
  	        intro: nextProps.intro,
  	        streamid: nextProps.streamid
  	      });
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      //console.log('ReactIScroll render',this.state.newsList)
  	      var dd = (0, _jquery2.default)('.fixeddd').height();
  	      (0, _jquery2.default)('.fixe .ul_content').css({
  	        'top': dd - 50 + 'px'
  	      });
  	      (0, _jquery2.default)('.timeCollection.tip').css({
  	        'top': dd + 'px'
  	      });
  	      //console.log('render ReactIScroll')
  	      return _react2.default.createElement(CommentComp, { newsList: this.state.newsList, intro: this.state.intro, streamid: this.state.streamid });
  	    }
  	  }, {
  	    key: 'scrollFunc',
  	    value: function scrollFunc() {
  	      var dd = (0, _jquery2.default)('.fixeddd').height();
  	      if ((0, _jquery2.default)('.timeCollection.sub').eq(0).length == 0) {
  	        return;
  	      }
  	      (0, _jquery2.default)('.timeCollection.tip').css('display', 'block');
  	      var startS = (0, _jquery2.default)('.timeCollection.sub').eq(0).offset().top;
  	      if (startS < dd) {
  	        (0, _jquery2.default)('.timeCollection.tip').css('display', 'block').html((0, _jquery2.default)('.timeCollection.sub').html());
  	      }
  	      if (startS > dd) {
  	        (0, _jquery2.default)('.timeCollection.tip').css('display', 'none');
  	      }
  	      (0, _jquery2.default)('.timeCollection.sub').each(function (i) {
  	        var judgTimeT = (0, _jquery2.default)(this).offset().top;
  	        if (judgTimeT < dd) {
  	          (0, _jquery2.default)('.timeCollection.tip').html((0, _jquery2.default)(this).html());
  	        }
  	      });
  	    }
  	  }, {
  	    key: 'componentDidMount',
  	    value: function componentDidMount() {
  	      myScroll = new _iscrollProbe2.default('.ul_content', options);
  	      var scroll = _helper2.default.scroll,
  	          that = this;
  	      myScroll.on('scroll', function () {
  	        o;
  	        var scint = this;
  	        scroll.onscroll(scint);
  	        that.scrollFunc();
  	      });
  	      myScroll.on('scrollEnd', function () {
  	        that.scrollFunc();
  	        var scint = this;
  	        var ret = scroll.onscrollEnd(scint, that.props.id);
  	        if (ret) {
  	          ret.then(function (data) {
  	            var olddata = that.state.newsList;
  	            var join = olddata.concat(data);
  	            that.setState({
  	              newsList: join
  	            });
  	          });
  	        }
  	      });
  	      myScroll.refresh();
  	      setTimeout(function () {
  	        (0, _jquery2.default)('.maskload').css('display', 'none');
  	        myScroll.refresh();
  	      }, 500);
  	    }
  	  }, {
  	    key: 'componentDidUpdate',
  	    value: function componentDidUpdate() {
  	      //console.log('componentDidUpdate ReactIScroll')
  	      myScroll.refresh();
  	      setTimeout(function () {
  	        (0, _jquery2.default)('.maskload').css('display', 'none');
  	        myScroll.refresh();
  	      }, 500);
  	    }
  	  }]);
  	  return ReactIScroll;
  	}(_react.Component);
  	
  	var Combine = function (_Component5) {
  	  (0, _inherits3.default)(Combine, _Component5);
  	
  	  function Combine() {
  	    var _ref5;
  	
  	    var _temp5, _this5, _ret5;
  	
  	    (0, _classCallCheck3.default)(this, Combine);
  	
  	    for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
  	      args[_key5] = arguments[_key5];
  	    }
  	
  	    return _ret5 = (_temp5 = (_this5 = (0, _possibleConstructorReturn3.default)(this, (_ref5 = Combine.__proto__ || (0, _getPrototypeOf2.default)(Combine)).call.apply(_ref5, [this].concat(args))), _this5), _this5.state = {
  	      newsList: [],
  	      intro: '',
  	      streamid: ''
  	    }, _temp5), (0, _possibleConstructorReturn3.default)(_this5, _ret5);
  	  }
  	
  	  (0, _createClass3.default)(Combine, [{
  	    key: 'componentWillReceiveProps',
  	    value: function componentWillReceiveProps(nextProps) {
  	      console.log(310, nextProps);
  	      this.setState({
  	        newsList: nextProps.newsList,
  	        intro: nextProps.intro,
  	        streamid: nextProps.streamid,
  	        id: nextProps.id
  	      });
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      var streamid = this.props.streamid;
  	      if (streamid) {
  	        var html = _react2.default.createElement(ReactIScroll, { newsList: this.state.newsList, intro: this.state.intro, streamid: this.state.streamid, id: this.state.id });
  	      } else {
  	        var html = _react2.default.createElement(WebIScroll, { newsList: this.state.newsList, intro: this.state.intro, streamid: this.state.treamid, id: this.props.id });
  	      }
  	      //console.log('Combine render')
  	      return _react2.default.createElement(
  	        'div',
  	        { id: 'scroller' },
  	        html
  	      );
  	    }
  	  }]);
  	  return Combine;
  	}(_react.Component);
  	
  	var Content = function (_Component6) {
  	  (0, _inherits3.default)(Content, _Component6);
  	
  	  function Content() {
  	    var _ref6;
  	
  	    var _temp6, _this6, _ret6;
  	
  	    (0, _classCallCheck3.default)(this, Content);
  	
  	    for (var _len6 = arguments.length, args = Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
  	      args[_key6] = arguments[_key6];
  	    }
  	
  	    return _ret6 = (_temp6 = (_this6 = (0, _possibleConstructorReturn3.default)(this, (_ref6 = Content.__proto__ || (0, _getPrototypeOf2.default)(Content)).call.apply(_ref6, [this].concat(args))), _this6), _this6.state = {
  	      newsList: [1]
  	    }, _this6.Props = {
  	      value: '开始渲染'
  	    }, _temp6), (0, _possibleConstructorReturn3.default)(_this6, _ret6);
  	  }
  	
  	  (0, _createClass3.default)(Content, [{
  	    key: 'componentWillReceiveProps',
  	    value: function componentWillReceiveProps(nextProps) {
  	      var props = nextProps.data.newsList;
  	      this.setState({
  	        newsList: props
  	      });
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      console.log('Content render', this.props);
  	      var props = this.props.data.data;
  	      var intro = props != '' ? props.studio.intro : '';
  	      var streamid = props != '' ? props.studio.streamid : '';
  	      var id = this.props.data.id;
  	      console.log(230, 'streamid', streamid, id);
  	      return _react2.default.createElement(
  	        'div',
  	        null,
  	        _react2.default.createElement('div', { className: 'timeCollection tip' }),
  	        _react2.default.createElement(
  	          'div',
  	          { className: 'ul_content', ref: 'ul_content' },
  	          _react2.default.createElement(Combine, { newsList: this.state.newsList, intro: intro, streamid: streamid, id: id })
  	        )
  	      );
  	    }
  	  }, {
  	    key: 'componentDidMount',
  	    value: function componentDidMount() {
  	      //console.log('componentDidMount Content')
  	      console.log(365, this.props.data.id);
  	      var that = this;
  	      var flagtime = setInterval(function () {
  	        _helper2.default._incData(that.props.data.id).then(function (data) {
  	          var oldA = that.state.newsList;
  	          data.reverse().map(function (obj, i) {
  	            oldA.unshift(obj);
  	          });
  	          that.setState({
  	            newsList: oldA
  	          });
  	          console.log(oldA);
  	        });
  	      }, 1000 * 60);
  	    }
  	  }, {
  	    key: 'componentDidUpdate',
  	    value: function componentDidUpdate() {
  	      console.log('componentDidUpdate content');
  	    }
  	  }]);
  	  return Content;
  	}(_react.Component);
  	
  	exports.default = Content;
  	
  	/* REACT HOT LOADER */ }).call(this); } finally { if (true) { (function () { var foundReactClasses = module.hot.data && module.hot.data.foundReactClasses || false; if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(337); if (makeExportsHot(module, __webpack_require__(141))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error("Cannot apply hot update to " + "index.jsx" + ": " + err.message); } }); } } module.hot.dispose(function (data) { data.makeHot = module.makeHot; data.foundReactClasses = foundReactClasses; }); })(); } }
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
  
  /***/ },
  /* 343 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var __WEBPACK_AMD_DEFINE_RESULT__;/*! iScroll v5.2.0 ~ (c) 2008-2016 Matteo Spinelli ~ http://cubiq.org/license */
  	(function (window, document, Math) {
  	var rAF = window.requestAnimationFrame	||
  		window.webkitRequestAnimationFrame	||
  		window.mozRequestAnimationFrame		||
  		window.oRequestAnimationFrame		||
  		window.msRequestAnimationFrame		||
  		function (callback) { window.setTimeout(callback, 1000 / 60); };
  	
  	var utils = (function () {
  		var me = {};
  	
  		var _elementStyle = document.createElement('div').style;
  		var _vendor = (function () {
  			var vendors = ['t', 'webkitT', 'MozT', 'msT', 'OT'],
  				transform,
  				i = 0,
  				l = vendors.length;
  	
  			for ( ; i < l; i++ ) {
  				transform = vendors[i] + 'ransform';
  				if ( transform in _elementStyle ) return vendors[i].substr(0, vendors[i].length-1);
  			}
  	
  			return false;
  		})();
  	
  		function _prefixStyle (style) {
  			if ( _vendor === false ) return false;
  			if ( _vendor === '' ) return style;
  			return _vendor + style.charAt(0).toUpperCase() + style.substr(1);
  		}
  	
  		me.getTime = Date.now || function getTime () { return new Date().getTime(); };
  	
  		me.extend = function (target, obj) {
  			for ( var i in obj ) {
  				target[i] = obj[i];
  			}
  		};
  	
  		me.addEvent = function (el, type, fn, capture) {
  			el.addEventListener(type, fn, !!capture);
  		};
  	
  		me.removeEvent = function (el, type, fn, capture) {
  			el.removeEventListener(type, fn, !!capture);
  		};
  	
  		me.prefixPointerEvent = function (pointerEvent) {
  			return window.MSPointerEvent ?
  				'MSPointer' + pointerEvent.charAt(7).toUpperCase() + pointerEvent.substr(8):
  				pointerEvent;
  		};
  	
  		me.momentum = function (current, start, time, lowerMargin, wrapperSize, deceleration) {
  			var distance = current - start,
  				speed = Math.abs(distance) / time,
  				destination,
  				duration;
  	
  			deceleration = deceleration === undefined ? 0.0006 : deceleration;
  	
  			destination = current + ( speed * speed ) / ( 2 * deceleration ) * ( distance < 0 ? -1 : 1 );
  			duration = speed / deceleration;
  	
  			if ( destination < lowerMargin ) {
  				destination = wrapperSize ? lowerMargin - ( wrapperSize / 2.5 * ( speed / 8 ) ) : lowerMargin;
  				distance = Math.abs(destination - current);
  				duration = distance / speed;
  			} else if ( destination > 0 ) {
  				destination = wrapperSize ? wrapperSize / 2.5 * ( speed / 8 ) : 0;
  				distance = Math.abs(current) + destination;
  				duration = distance / speed;
  			}
  	
  			return {
  				destination: Math.round(destination),
  				duration: duration
  			};
  		};
  	
  		var _transform = _prefixStyle('transform');
  	
  		me.extend(me, {
  			hasTransform: _transform !== false,
  			hasPerspective: _prefixStyle('perspective') in _elementStyle,
  			hasTouch: 'ontouchstart' in window,
  			hasPointer: !!(window.PointerEvent || window.MSPointerEvent), // IE10 is prefixed
  			hasTransition: _prefixStyle('transition') in _elementStyle
  		});
  	
  		/*
  		This should find all Android browsers lower than build 535.19 (both stock browser and webview)
  		- galaxy S2 is ok
  	    - 2.3.6 : `AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1`
  	    - 4.0.4 : `AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30`
  	   - galaxy S3 is badAndroid (stock brower, webview)
  	     `AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30`
  	   - galaxy S4 is badAndroid (stock brower, webview)
  	     `AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30`
  	   - galaxy S5 is OK
  	     `AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Mobile Safari/537.36 (Chrome/)`
  	   - galaxy S6 is OK
  	     `AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Mobile Safari/537.36 (Chrome/)`
  	  */
  		me.isBadAndroid = (function() {
  			var appVersion = window.navigator.appVersion;
  			// Android browser is not a chrome browser.
  			if (/Android/.test(appVersion) && !(/Chrome\/\d/.test(appVersion))) {
  				var safariVersion = appVersion.match(/Safari\/(\d+.\d)/);
  				if(safariVersion && typeof safariVersion === "object" && safariVersion.length >= 2) {
  					return parseFloat(safariVersion[1]) < 535.19;
  				} else {
  					return true;
  				}
  			} else {
  				return false;
  			}
  		})();
  	
  		me.extend(me.style = {}, {
  			transform: _transform,
  			transitionTimingFunction: _prefixStyle('transitionTimingFunction'),
  			transitionDuration: _prefixStyle('transitionDuration'),
  			transitionDelay: _prefixStyle('transitionDelay'),
  			transformOrigin: _prefixStyle('transformOrigin')
  		});
  	
  		me.hasClass = function (e, c) {
  			var re = new RegExp("(^|\\s)" + c + "(\\s|$)");
  			return re.test(e.className);
  		};
  	
  		me.addClass = function (e, c) {
  			if ( me.hasClass(e, c) ) {
  				return;
  			}
  	
  			var newclass = e.className.split(' ');
  			newclass.push(c);
  			e.className = newclass.join(' ');
  		};
  	
  		me.removeClass = function (e, c) {
  			if ( !me.hasClass(e, c) ) {
  				return;
  			}
  	
  			var re = new RegExp("(^|\\s)" + c + "(\\s|$)", 'g');
  			e.className = e.className.replace(re, ' ');
  		};
  	
  		me.offset = function (el) {
  			var left = -el.offsetLeft,
  				top = -el.offsetTop;
  	
  			// jshint -W084
  			while (el = el.offsetParent) {
  				left -= el.offsetLeft;
  				top -= el.offsetTop;
  			}
  			// jshint +W084
  	
  			return {
  				left: left,
  				top: top
  			};
  		};
  	
  		me.preventDefaultException = function (el, exceptions) {
  			for ( var i in exceptions ) {
  				if ( exceptions[i].test(el[i]) ) {
  					return true;
  				}
  			}
  	
  			return false;
  		};
  	
  		me.extend(me.eventType = {}, {
  			touchstart: 1,
  			touchmove: 1,
  			touchend: 1,
  	
  			mousedown: 2,
  			mousemove: 2,
  			mouseup: 2,
  	
  			pointerdown: 3,
  			pointermove: 3,
  			pointerup: 3,
  	
  			MSPointerDown: 3,
  			MSPointerMove: 3,
  			MSPointerUp: 3
  		});
  	
  		me.extend(me.ease = {}, {
  			quadratic: {
  				style: 'cubic-bezier(0.25, 0.46, 0.45, 0.94)',
  				fn: function (k) {
  					return k * ( 2 - k );
  				}
  			},
  			circular: {
  				style: 'cubic-bezier(0.1, 0.57, 0.1, 1)',	// Not properly "circular" but this looks better, it should be (0.075, 0.82, 0.165, 1)
  				fn: function (k) {
  					return Math.sqrt( 1 - ( --k * k ) );
  				}
  			},
  			back: {
  				style: 'cubic-bezier(0.175, 0.885, 0.32, 1.275)',
  				fn: function (k) {
  					var b = 4;
  					return ( k = k - 1 ) * k * ( ( b + 1 ) * k + b ) + 1;
  				}
  			},
  			bounce: {
  				style: '',
  				fn: function (k) {
  					if ( ( k /= 1 ) < ( 1 / 2.75 ) ) {
  						return 7.5625 * k * k;
  					} else if ( k < ( 2 / 2.75 ) ) {
  						return 7.5625 * ( k -= ( 1.5 / 2.75 ) ) * k + 0.75;
  					} else if ( k < ( 2.5 / 2.75 ) ) {
  						return 7.5625 * ( k -= ( 2.25 / 2.75 ) ) * k + 0.9375;
  					} else {
  						return 7.5625 * ( k -= ( 2.625 / 2.75 ) ) * k + 0.984375;
  					}
  				}
  			},
  			elastic: {
  				style: '',
  				fn: function (k) {
  					var f = 0.22,
  						e = 0.4;
  	
  					if ( k === 0 ) { return 0; }
  					if ( k == 1 ) { return 1; }
  	
  					return ( e * Math.pow( 2, - 10 * k ) * Math.sin( ( k - f / 4 ) * ( 2 * Math.PI ) / f ) + 1 );
  				}
  			}
  		});
  	
  		me.tap = function (e, eventName) {
  			var ev = document.createEvent('Event');
  			ev.initEvent(eventName, true, true);
  			ev.pageX = e.pageX;
  			ev.pageY = e.pageY;
  			e.target.dispatchEvent(ev);
  		};
  	
  		me.click = function (e) {
  			var target = e.target,
  				ev;
  	
  			if ( !(/(SELECT|INPUT|TEXTAREA)/i).test(target.tagName) ) {
  				ev = document.createEvent('MouseEvents');
  				ev.initMouseEvent('click', true, true, e.view, 1,
  					target.screenX, target.screenY, target.clientX, target.clientY,
  					e.ctrlKey, e.altKey, e.shiftKey, e.metaKey,
  					0, null);
  	
  				ev._constructed = true;
  				target.dispatchEvent(ev);
  			}
  		};
  	
  		return me;
  	})();
  	function IScroll (el, options) {
  		this.wrapper = typeof el == 'string' ? document.querySelector(el) : el;
  		this.scroller = this.wrapper.children[0];
  		this.scrollerStyle = this.scroller.style;		// cache style for better performance
  	
  		this.options = {
  	
  			resizeScrollbars: true,
  	
  			mouseWheelSpeed: 20,
  	
  			snapThreshold: 0.334,
  	
  	// INSERT POINT: OPTIONS
  			disablePointer : !utils.hasPointer,
  			disableTouch : utils.hasPointer || !utils.hasTouch,
  			disableMouse : utils.hasPointer || utils.hasTouch,
  			startX: 0,
  			startY: 0,
  			scrollY: true,
  			directionLockThreshold: 5,
  			momentum: true,
  	
  			bounce: true,
  			bounceTime: 600,
  			bounceEasing: '',
  	
  			preventDefault: true,
  			preventDefaultException: { tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT)$/ },
  	
  			HWCompositing: true,
  			useTransition: true,
  			useTransform: true,
  			bindToWrapper: typeof window.onmousedown === "undefined"
  		};
  	
  		for ( var i in options ) {
  			this.options[i] = options[i];
  		}
  	
  		// Normalize options
  		this.translateZ = this.options.HWCompositing && utils.hasPerspective ? ' translateZ(0)' : '';
  	
  		this.options.useTransition = utils.hasTransition && this.options.useTransition;
  		this.options.useTransform = utils.hasTransform && this.options.useTransform;
  	
  		this.options.eventPassthrough = this.options.eventPassthrough === true ? 'vertical' : this.options.eventPassthrough;
  		this.options.preventDefault = !this.options.eventPassthrough && this.options.preventDefault;
  	
  		// If you want eventPassthrough I have to lock one of the axes
  		this.options.scrollY = this.options.eventPassthrough == 'vertical' ? false : this.options.scrollY;
  		this.options.scrollX = this.options.eventPassthrough == 'horizontal' ? false : this.options.scrollX;
  	
  		// With eventPassthrough we also need lockDirection mechanism
  		this.options.freeScroll = this.options.freeScroll && !this.options.eventPassthrough;
  		this.options.directionLockThreshold = this.options.eventPassthrough ? 0 : this.options.directionLockThreshold;
  	
  		this.options.bounceEasing = typeof this.options.bounceEasing == 'string' ? utils.ease[this.options.bounceEasing] || utils.ease.circular : this.options.bounceEasing;
  	
  		this.options.resizePolling = this.options.resizePolling === undefined ? 60 : this.options.resizePolling;
  	
  		if ( this.options.tap === true ) {
  			this.options.tap = 'tap';
  		}
  	
  		if ( this.options.shrinkScrollbars == 'scale' ) {
  			this.options.useTransition = false;
  		}
  	
  		this.options.invertWheelDirection = this.options.invertWheelDirection ? -1 : 1;
  	
  		if ( this.options.probeType == 3 ) {
  			this.options.useTransition = false;	}
  	
  	// INSERT POINT: NORMALIZATION
  	
  		// Some defaults
  		this.x = 0;
  		this.y = 0;
  		this.directionX = 0;
  		this.directionY = 0;
  		this._events = {};
  	
  	// INSERT POINT: DEFAULTS
  	
  		this._init();
  		this.refresh();
  	
  		this.scrollTo(this.options.startX, this.options.startY);
  		this.enable();
  	}
  	
  	IScroll.prototype = {
  		version: '5.2.0',
  	
  		_init: function () {
  			this._initEvents();
  	
  			if ( this.options.scrollbars || this.options.indicators ) {
  				this._initIndicators();
  			}
  	
  			if ( this.options.mouseWheel ) {
  				this._initWheel();
  			}
  	
  			if ( this.options.snap ) {
  				this._initSnap();
  			}
  	
  			if ( this.options.keyBindings ) {
  				this._initKeys();
  			}
  	
  	// INSERT POINT: _init
  	
  		},
  	
  		destroy: function () {
  			this._initEvents(true);
  			clearTimeout(this.resizeTimeout);
  	 		this.resizeTimeout = null;
  			this._execEvent('destroy');
  		},
  	
  		_transitionEnd: function (e) {
  			if ( e.target != this.scroller || !this.isInTransition ) {
  				return;
  			}
  	
  			this._transitionTime();
  			if ( !this.resetPosition(this.options.bounceTime) ) {
  				this.isInTransition = false;
  				this._execEvent('scrollEnd');
  			}
  		},
  	
  		_start: function (e) {
  			// React to left mouse button only
  			if ( utils.eventType[e.type] != 1 ) {
  			  // for button property
  			  // http://unixpapa.com/js/mouse.html
  			  var button;
  		    if (!e.which) {
  		      /* IE case */
  		      button = (e.button < 2) ? 0 :
  		               ((e.button == 4) ? 1 : 2);
  		    } else {
  		      /* All others */
  		      button = e.button;
  		    }
  				if ( button !== 0 ) {
  					return;
  				}
  			}
  	
  			if ( !this.enabled || (this.initiated && utils.eventType[e.type] !== this.initiated) ) {
  				return;
  			}
  	
  			if ( this.options.preventDefault && !utils.isBadAndroid && !utils.preventDefaultException(e.target, this.options.preventDefaultException) ) {
  				e.preventDefault();
  			}
  	
  			var point = e.touches ? e.touches[0] : e,
  				pos;
  	
  			this.initiated	= utils.eventType[e.type];
  			this.moved		= false;
  			this.distX		= 0;
  			this.distY		= 0;
  			this.directionX = 0;
  			this.directionY = 0;
  			this.directionLocked = 0;
  	
  			this.startTime = utils.getTime();
  	
  			if ( this.options.useTransition && this.isInTransition ) {
  				this._transitionTime();
  				this.isInTransition = false;
  				pos = this.getComputedPosition();
  				this._translate(Math.round(pos.x), Math.round(pos.y));
  				this._execEvent('scrollEnd');
  			} else if ( !this.options.useTransition && this.isAnimating ) {
  				this.isAnimating = false;
  				this._execEvent('scrollEnd');
  			}
  	
  			this.startX    = this.x;
  			this.startY    = this.y;
  			this.absStartX = this.x;
  			this.absStartY = this.y;
  			this.pointX    = point.pageX;
  			this.pointY    = point.pageY;
  	
  			this._execEvent('beforeScrollStart');
  		},
  	
  		_move: function (e) {
  			if ( !this.enabled || utils.eventType[e.type] !== this.initiated ) {
  				return;
  			}
  	
  			if ( this.options.preventDefault ) {	// increases performance on Android? TODO: check!
  				e.preventDefault();
  			}
  	
  			var point		= e.touches ? e.touches[0] : e,
  				deltaX		= point.pageX - this.pointX,
  				deltaY		= point.pageY - this.pointY,
  				timestamp	= utils.getTime(),
  				newX, newY,
  				absDistX, absDistY;
  	
  			this.pointX		= point.pageX;
  			this.pointY		= point.pageY;
  	
  			this.distX		+= deltaX;
  			this.distY		+= deltaY;
  			absDistX		= Math.abs(this.distX);
  			absDistY		= Math.abs(this.distY);
  	
  			// We need to move at least 10 pixels for the scrolling to initiate
  			if ( timestamp - this.endTime > 300 && (absDistX < 10 && absDistY < 10) ) {
  				return;
  			}
  	
  			// If you are scrolling in one direction lock the other
  			if ( !this.directionLocked && !this.options.freeScroll ) {
  				if ( absDistX > absDistY + this.options.directionLockThreshold ) {
  					this.directionLocked = 'h';		// lock horizontally
  				} else if ( absDistY >= absDistX + this.options.directionLockThreshold ) {
  					this.directionLocked = 'v';		// lock vertically
  				} else {
  					this.directionLocked = 'n';		// no lock
  				}
  			}
  	
  			if ( this.directionLocked == 'h' ) {
  				if ( this.options.eventPassthrough == 'vertical' ) {
  					e.preventDefault();
  				} else if ( this.options.eventPassthrough == 'horizontal' ) {
  					this.initiated = false;
  					return;
  				}
  	
  				deltaY = 0;
  			} else if ( this.directionLocked == 'v' ) {
  				if ( this.options.eventPassthrough == 'horizontal' ) {
  					e.preventDefault();
  				} else if ( this.options.eventPassthrough == 'vertical' ) {
  					this.initiated = false;
  					return;
  				}
  	
  				deltaX = 0;
  			}
  	
  			deltaX = this.hasHorizontalScroll ? deltaX : 0;
  			deltaY = this.hasVerticalScroll ? deltaY : 0;
  	
  			newX = this.x + deltaX;
  			newY = this.y + deltaY;
  	
  			// Slow down if outside of the boundaries
  			if ( newX > 0 || newX < this.maxScrollX ) {
  				newX = this.options.bounce ? this.x + deltaX / 3 : newX > 0 ? 0 : this.maxScrollX;
  			}
  			if ( newY > 0 || newY < this.maxScrollY ) {
  				newY = this.options.bounce ? this.y + deltaY / 3 : newY > 0 ? 0 : this.maxScrollY;
  			}
  	
  			this.directionX = deltaX > 0 ? -1 : deltaX < 0 ? 1 : 0;
  			this.directionY = deltaY > 0 ? -1 : deltaY < 0 ? 1 : 0;
  	
  			if ( !this.moved ) {
  				this._execEvent('scrollStart');
  			}
  	
  			this.moved = true;
  	
  			this._translate(newX, newY);
  	
  	/* REPLACE START: _move */
  			if ( timestamp - this.startTime > 300 ) {
  				this.startTime = timestamp;
  				this.startX = this.x;
  				this.startY = this.y;
  	
  				if ( this.options.probeType == 1 ) {
  					this._execEvent('scroll');
  				}
  			}
  	
  			if ( this.options.probeType > 1 ) {
  				this._execEvent('scroll');
  			}
  	/* REPLACE END: _move */
  	
  		},
  	
  		_end: function (e) {
  			if ( !this.enabled || utils.eventType[e.type] !== this.initiated ) {
  				return;
  			}
  	
  			if ( this.options.preventDefault && !utils.preventDefaultException(e.target, this.options.preventDefaultException) ) {
  				e.preventDefault();
  			}
  	
  			var point = e.changedTouches ? e.changedTouches[0] : e,
  				momentumX,
  				momentumY,
  				duration = utils.getTime() - this.startTime,
  				newX = Math.round(this.x),
  				newY = Math.round(this.y),
  				distanceX = Math.abs(newX - this.startX),
  				distanceY = Math.abs(newY - this.startY),
  				time = 0,
  				easing = '';
  	
  			this.isInTransition = 0;
  			this.initiated = 0;
  			this.endTime = utils.getTime();
  	
  			// reset if we are outside of the boundaries
  			if ( this.resetPosition(this.options.bounceTime) ) {
  				return;
  			}
  	
  			this.scrollTo(newX, newY);	// ensures that the last position is rounded
  	
  			// we scrolled less than 10 pixels
  			if ( !this.moved ) {
  				if ( this.options.tap ) {
  					utils.tap(e, this.options.tap);
  				}
  	
  				if ( this.options.click ) {
  					utils.click(e);
  				}
  	
  				this._execEvent('scrollCancel');
  				return;
  			}
  	
  			if ( this._events.flick && duration < 200 && distanceX < 100 && distanceY < 100 ) {
  				this._execEvent('flick');
  				return;
  			}
  	
  			// start momentum animation if needed
  			if ( this.options.momentum && duration < 300 ) {
  				momentumX = this.hasHorizontalScroll ? utils.momentum(this.x, this.startX, duration, this.maxScrollX, this.options.bounce ? this.wrapperWidth : 0, this.options.deceleration) : { destination: newX, duration: 0 };
  				momentumY = this.hasVerticalScroll ? utils.momentum(this.y, this.startY, duration, this.maxScrollY, this.options.bounce ? this.wrapperHeight : 0, this.options.deceleration) : { destination: newY, duration: 0 };
  				newX = momentumX.destination;
  				newY = momentumY.destination;
  				time = Math.max(momentumX.duration, momentumY.duration);
  				this.isInTransition = 1;
  			}
  	
  	
  			if ( this.options.snap ) {
  				var snap = this._nearestSnap(newX, newY);
  				this.currentPage = snap;
  				time = this.options.snapSpeed || Math.max(
  						Math.max(
  							Math.min(Math.abs(newX - snap.x), 1000),
  							Math.min(Math.abs(newY - snap.y), 1000)
  						), 300);
  				newX = snap.x;
  				newY = snap.y;
  	
  				this.directionX = 0;
  				this.directionY = 0;
  				easing = this.options.bounceEasing;
  			}
  	
  	// INSERT POINT: _end
  	
  			if ( newX != this.x || newY != this.y ) {
  				// change easing function when scroller goes out of the boundaries
  				if ( newX > 0 || newX < this.maxScrollX || newY > 0 || newY < this.maxScrollY ) {
  					easing = utils.ease.quadratic;
  				}
  	
  				this.scrollTo(newX, newY, time, easing);
  				return;
  			}
  	
  			this._execEvent('scrollEnd');
  		},
  	
  		_resize: function () {
  			var that = this;
  	
  			clearTimeout(this.resizeTimeout);
  	
  			this.resizeTimeout = setTimeout(function () {
  				that.refresh();
  			}, this.options.resizePolling);
  		},
  	
  		resetPosition: function (time) {
  			var x = this.x,
  				y = this.y;
  	
  			time = time || 0;
  	
  			if ( !this.hasHorizontalScroll || this.x > 0 ) {
  				x = 0;
  			} else if ( this.x < this.maxScrollX ) {
  				x = this.maxScrollX;
  			}
  	
  			if ( !this.hasVerticalScroll || this.y > 0 ) {
  				y = 0;
  			} else if ( this.y < this.maxScrollY ) {
  				y = this.maxScrollY;
  			}
  	
  			if ( x == this.x && y == this.y ) {
  				return false;
  			}
  	
  			this.scrollTo(x, y, time, this.options.bounceEasing);
  	
  			return true;
  		},
  	
  		disable: function () {
  			this.enabled = false;
  		},
  	
  		enable: function () {
  			this.enabled = true;
  		},
  	
  		refresh: function () {
  			var rf = this.wrapper.offsetHeight;		// Force reflow
  	
  			this.wrapperWidth	= this.wrapper.clientWidth;
  			this.wrapperHeight	= this.wrapper.clientHeight;
  	
  	/* REPLACE START: refresh */
  	
  			this.scrollerWidth	= this.scroller.offsetWidth;
  			this.scrollerHeight	= this.scroller.offsetHeight;
  	
  			this.maxScrollX		= this.wrapperWidth - this.scrollerWidth;
  			this.maxScrollY		= this.wrapperHeight - this.scrollerHeight;
  	
  	/* REPLACE END: refresh */
  	
  			this.hasHorizontalScroll	= this.options.scrollX && this.maxScrollX < 0;
  			this.hasVerticalScroll		= this.options.scrollY && this.maxScrollY < 0;
  	
  			if ( !this.hasHorizontalScroll ) {
  				this.maxScrollX = 0;
  				this.scrollerWidth = this.wrapperWidth;
  			}
  	
  			if ( !this.hasVerticalScroll ) {
  				this.maxScrollY = 0;
  				this.scrollerHeight = this.wrapperHeight;
  			}
  	
  			this.endTime = 0;
  			this.directionX = 0;
  			this.directionY = 0;
  	
  			this.wrapperOffset = utils.offset(this.wrapper);
  	
  			this._execEvent('refresh');
  	
  			this.resetPosition();
  	
  	// INSERT POINT: _refresh
  	
  		},
  	
  		on: function (type, fn) {
  			if ( !this._events[type] ) {
  				this._events[type] = [];
  			}
  	
  			this._events[type].push(fn);
  		},
  	
  		off: function (type, fn) {
  			if ( !this._events[type] ) {
  				return;
  			}
  	
  			var index = this._events[type].indexOf(fn);
  	
  			if ( index > -1 ) {
  				this._events[type].splice(index, 1);
  			}
  		},
  	
  		_execEvent: function (type) {
  			if ( !this._events[type] ) {
  				return;
  			}
  	
  			var i = 0,
  				l = this._events[type].length;
  	
  			if ( !l ) {
  				return;
  			}
  	
  			for ( ; i < l; i++ ) {
  				this._events[type][i].apply(this, [].slice.call(arguments, 1));
  			}
  		},
  	
  		scrollBy: function (x, y, time, easing) {
  			x = this.x + x;
  			y = this.y + y;
  			time = time || 0;
  	
  			this.scrollTo(x, y, time, easing);
  		},
  	
  		scrollTo: function (x, y, time, easing) {
  			easing = easing || utils.ease.circular;
  	
  			this.isInTransition = this.options.useTransition && time > 0;
  			var transitionType = this.options.useTransition && easing.style;
  			if ( !time || transitionType ) {
  					if(transitionType) {
  						this._transitionTimingFunction(easing.style);
  						this._transitionTime(time);
  					}
  				this._translate(x, y);
  			} else {
  				this._animate(x, y, time, easing.fn);
  			}
  		},
  	
  		scrollToElement: function (el, time, offsetX, offsetY, easing) {
  			el = el.nodeType ? el : this.scroller.querySelector(el);
  	
  			if ( !el ) {
  				return;
  			}
  	
  			var pos = utils.offset(el);
  	
  			pos.left -= this.wrapperOffset.left;
  			pos.top  -= this.wrapperOffset.top;
  	
  			// if offsetX/Y are true we center the element to the screen
  			if ( offsetX === true ) {
  				offsetX = Math.round(el.offsetWidth / 2 - this.wrapper.offsetWidth / 2);
  			}
  			if ( offsetY === true ) {
  				offsetY = Math.round(el.offsetHeight / 2 - this.wrapper.offsetHeight / 2);
  			}
  	
  			pos.left -= offsetX || 0;
  			pos.top  -= offsetY || 0;
  	
  			pos.left = pos.left > 0 ? 0 : pos.left < this.maxScrollX ? this.maxScrollX : pos.left;
  			pos.top  = pos.top  > 0 ? 0 : pos.top  < this.maxScrollY ? this.maxScrollY : pos.top;
  	
  			time = time === undefined || time === null || time === 'auto' ? Math.max(Math.abs(this.x-pos.left), Math.abs(this.y-pos.top)) : time;
  	
  			this.scrollTo(pos.left, pos.top, time, easing);
  		},
  	
  		_transitionTime: function (time) {
  			time = time || 0;
  	
  			var durationProp = utils.style.transitionDuration;
  			this.scrollerStyle[durationProp] = time + 'ms';
  	
  			if ( !time && utils.isBadAndroid ) {
  				this.scrollerStyle[durationProp] = '0.0001ms';
  				// remove 0.0001ms
  				var self = this;
  				rAF(function() {
  					if(self.scrollerStyle[durationProp] === '0.0001ms') {
  						self.scrollerStyle[durationProp] = '0s';
  					}
  				});
  			}
  	
  	
  			if ( this.indicators ) {
  				for ( var i = this.indicators.length; i--; ) {
  					this.indicators[i].transitionTime(time);
  				}
  			}
  	
  	
  	// INSERT POINT: _transitionTime
  	
  		},
  	
  		_transitionTimingFunction: function (easing) {
  			this.scrollerStyle[utils.style.transitionTimingFunction] = easing;
  	
  	
  			if ( this.indicators ) {
  				for ( var i = this.indicators.length; i--; ) {
  					this.indicators[i].transitionTimingFunction(easing);
  				}
  			}
  	
  	
  	// INSERT POINT: _transitionTimingFunction
  	
  		},
  	
  		_translate: function (x, y) {
  			if ( this.options.useTransform ) {
  	
  	/* REPLACE START: _translate */
  	
  				this.scrollerStyle[utils.style.transform] = 'translate(' + x + 'px,' + y + 'px)' + this.translateZ;
  	
  	/* REPLACE END: _translate */
  	
  			} else {
  				x = Math.round(x);
  				y = Math.round(y);
  				this.scrollerStyle.left = x + 'px';
  				this.scrollerStyle.top = y + 'px';
  			}
  	
  			this.x = x;
  			this.y = y;
  	
  	
  		if ( this.indicators ) {
  			for ( var i = this.indicators.length; i--; ) {
  				this.indicators[i].updatePosition();
  			}
  		}
  	
  	
  	// INSERT POINT: _translate
  	
  		},
  	
  		_initEvents: function (remove) {
  			var eventType = remove ? utils.removeEvent : utils.addEvent,
  				target = this.options.bindToWrapper ? this.wrapper : window;
  	
  			eventType(window, 'orientationchange', this);
  			eventType(window, 'resize', this);
  	
  			if ( this.options.click ) {
  				eventType(this.wrapper, 'click', this, true);
  			}
  	
  			if ( !this.options.disableMouse ) {
  				eventType(this.wrapper, 'mousedown', this);
  				eventType(target, 'mousemove', this);
  				eventType(target, 'mousecancel', this);
  				eventType(target, 'mouseup', this);
  			}
  	
  			if ( utils.hasPointer && !this.options.disablePointer ) {
  				eventType(this.wrapper, utils.prefixPointerEvent('pointerdown'), this);
  				eventType(target, utils.prefixPointerEvent('pointermove'), this);
  				eventType(target, utils.prefixPointerEvent('pointercancel'), this);
  				eventType(target, utils.prefixPointerEvent('pointerup'), this);
  			}
  	
  			if ( utils.hasTouch && !this.options.disableTouch ) {
  				eventType(this.wrapper, 'touchstart', this);
  				eventType(target, 'touchmove', this);
  				eventType(target, 'touchcancel', this);
  				eventType(target, 'touchend', this);
  			}
  	
  			eventType(this.scroller, 'transitionend', this);
  			eventType(this.scroller, 'webkitTransitionEnd', this);
  			eventType(this.scroller, 'oTransitionEnd', this);
  			eventType(this.scroller, 'MSTransitionEnd', this);
  		},
  	
  		getComputedPosition: function () {
  			var matrix = window.getComputedStyle(this.scroller, null),
  				x, y;
  	
  			if ( this.options.useTransform ) {
  				matrix = matrix[utils.style.transform].split(')')[0].split(', ');
  				x = +(matrix[12] || matrix[4]);
  				y = +(matrix[13] || matrix[5]);
  			} else {
  				x = +matrix.left.replace(/[^-\d.]/g, '');
  				y = +matrix.top.replace(/[^-\d.]/g, '');
  			}
  	
  			return { x: x, y: y };
  		},
  		_initIndicators: function () {
  			var interactive = this.options.interactiveScrollbars,
  				customStyle = typeof this.options.scrollbars != 'string',
  				indicators = [],
  				indicator;
  	
  			var that = this;
  	
  			this.indicators = [];
  	
  			if ( this.options.scrollbars ) {
  				// Vertical scrollbar
  				if ( this.options.scrollY ) {
  					indicator = {
  						el: createDefaultScrollbar('v', interactive, this.options.scrollbars),
  						interactive: interactive,
  						defaultScrollbars: true,
  						customStyle: customStyle,
  						resize: this.options.resizeScrollbars,
  						shrink: this.options.shrinkScrollbars,
  						fade: this.options.fadeScrollbars,
  						listenX: false
  					};
  	
  					this.wrapper.appendChild(indicator.el);
  					indicators.push(indicator);
  				}
  	
  				// Horizontal scrollbar
  				if ( this.options.scrollX ) {
  					indicator = {
  						el: createDefaultScrollbar('h', interactive, this.options.scrollbars),
  						interactive: interactive,
  						defaultScrollbars: true,
  						customStyle: customStyle,
  						resize: this.options.resizeScrollbars,
  						shrink: this.options.shrinkScrollbars,
  						fade: this.options.fadeScrollbars,
  						listenY: false
  					};
  	
  					this.wrapper.appendChild(indicator.el);
  					indicators.push(indicator);
  				}
  			}
  	
  			if ( this.options.indicators ) {
  				// TODO: check concat compatibility
  				indicators = indicators.concat(this.options.indicators);
  			}
  	
  			for ( var i = indicators.length; i--; ) {
  				this.indicators.push( new Indicator(this, indicators[i]) );
  			}
  	
  			// TODO: check if we can use array.map (wide compatibility and performance issues)
  			function _indicatorsMap (fn) {
  				if (that.indicators) {
  					for ( var i = that.indicators.length; i--; ) {
  						fn.call(that.indicators[i]);
  					}
  				}
  			}
  	
  			if ( this.options.fadeScrollbars ) {
  				this.on('scrollEnd', function () {
  					_indicatorsMap(function () {
  						this.fade();
  					});
  				});
  	
  				this.on('scrollCancel', function () {
  					_indicatorsMap(function () {
  						this.fade();
  					});
  				});
  	
  				this.on('scrollStart', function () {
  					_indicatorsMap(function () {
  						this.fade(1);
  					});
  				});
  	
  				this.on('beforeScrollStart', function () {
  					_indicatorsMap(function () {
  						this.fade(1, true);
  					});
  				});
  			}
  	
  	
  			this.on('refresh', function () {
  				_indicatorsMap(function () {
  					this.refresh();
  				});
  			});
  	
  			this.on('destroy', function () {
  				_indicatorsMap(function () {
  					this.destroy();
  				});
  	
  				delete this.indicators;
  			});
  		},
  	
  		_initWheel: function () {
  			utils.addEvent(this.wrapper, 'wheel', this);
  			utils.addEvent(this.wrapper, 'mousewheel', this);
  			utils.addEvent(this.wrapper, 'DOMMouseScroll', this);
  	
  			this.on('destroy', function () {
  				clearTimeout(this.wheelTimeout);
  				this.wheelTimeout = null;
  				utils.removeEvent(this.wrapper, 'wheel', this);
  				utils.removeEvent(this.wrapper, 'mousewheel', this);
  				utils.removeEvent(this.wrapper, 'DOMMouseScroll', this);
  			});
  		},
  	
  		_wheel: function (e) {
  			if ( !this.enabled ) {
  				return;
  			}
  	
  			e.preventDefault();
  	
  			var wheelDeltaX, wheelDeltaY,
  				newX, newY,
  				that = this;
  	
  			if ( this.wheelTimeout === undefined ) {
  				that._execEvent('scrollStart');
  			}
  	
  			// Execute the scrollEnd event after 400ms the wheel stopped scrolling
  			clearTimeout(this.wheelTimeout);
  			this.wheelTimeout = setTimeout(function () {
  				if(!that.options.snap) {
  					that._execEvent('scrollEnd');
  				}
  				that.wheelTimeout = undefined;
  			}, 400);
  	
  			if ( 'deltaX' in e ) {
  				if (e.deltaMode === 1) {
  					wheelDeltaX = -e.deltaX * this.options.mouseWheelSpeed;
  					wheelDeltaY = -e.deltaY * this.options.mouseWheelSpeed;
  				} else {
  					wheelDeltaX = -e.deltaX;
  					wheelDeltaY = -e.deltaY;
  				}
  			} else if ( 'wheelDeltaX' in e ) {
  				wheelDeltaX = e.wheelDeltaX / 120 * this.options.mouseWheelSpeed;
  				wheelDeltaY = e.wheelDeltaY / 120 * this.options.mouseWheelSpeed;
  			} else if ( 'wheelDelta' in e ) {
  				wheelDeltaX = wheelDeltaY = e.wheelDelta / 120 * this.options.mouseWheelSpeed;
  			} else if ( 'detail' in e ) {
  				wheelDeltaX = wheelDeltaY = -e.detail / 3 * this.options.mouseWheelSpeed;
  			} else {
  				return;
  			}
  	
  			wheelDeltaX *= this.options.invertWheelDirection;
  			wheelDeltaY *= this.options.invertWheelDirection;
  	
  			if ( !this.hasVerticalScroll ) {
  				wheelDeltaX = wheelDeltaY;
  				wheelDeltaY = 0;
  			}
  	
  			if ( this.options.snap ) {
  				newX = this.currentPage.pageX;
  				newY = this.currentPage.pageY;
  	
  				if ( wheelDeltaX > 0 ) {
  					newX--;
  				} else if ( wheelDeltaX < 0 ) {
  					newX++;
  				}
  	
  				if ( wheelDeltaY > 0 ) {
  					newY--;
  				} else if ( wheelDeltaY < 0 ) {
  					newY++;
  				}
  	
  				this.goToPage(newX, newY);
  	
  				return;
  			}
  	
  			newX = this.x + Math.round(this.hasHorizontalScroll ? wheelDeltaX : 0);
  			newY = this.y + Math.round(this.hasVerticalScroll ? wheelDeltaY : 0);
  	
  			this.directionX = wheelDeltaX > 0 ? -1 : wheelDeltaX < 0 ? 1 : 0;
  			this.directionY = wheelDeltaY > 0 ? -1 : wheelDeltaY < 0 ? 1 : 0;
  	
  			if ( newX > 0 ) {
  				newX = 0;
  			} else if ( newX < this.maxScrollX ) {
  				newX = this.maxScrollX;
  			}
  	
  			if ( newY > 0 ) {
  				newY = 0;
  			} else if ( newY < this.maxScrollY ) {
  				newY = this.maxScrollY;
  			}
  	
  			this.scrollTo(newX, newY, 0);
  	
  			if ( this.options.probeType > 1 ) {
  				this._execEvent('scroll');
  			}
  	
  	// INSERT POINT: _wheel
  		},
  	
  		_initSnap: function () {
  			this.currentPage = {};
  	
  			if ( typeof this.options.snap == 'string' ) {
  				this.options.snap = this.scroller.querySelectorAll(this.options.snap);
  			}
  	
  			this.on('refresh', function () {
  				var i = 0, l,
  					m = 0, n,
  					cx, cy,
  					x = 0, y,
  					stepX = this.options.snapStepX || this.wrapperWidth,
  					stepY = this.options.snapStepY || this.wrapperHeight,
  					el;
  	
  				this.pages = [];
  	
  				if ( !this.wrapperWidth || !this.wrapperHeight || !this.scrollerWidth || !this.scrollerHeight ) {
  					return;
  				}
  	
  				if ( this.options.snap === true ) {
  					cx = Math.round( stepX / 2 );
  					cy = Math.round( stepY / 2 );
  	
  					while ( x > -this.scrollerWidth ) {
  						this.pages[i] = [];
  						l = 0;
  						y = 0;
  	
  						while ( y > -this.scrollerHeight ) {
  							this.pages[i][l] = {
  								x: Math.max(x, this.maxScrollX),
  								y: Math.max(y, this.maxScrollY),
  								width: stepX,
  								height: stepY,
  								cx: x - cx,
  								cy: y - cy
  							};
  	
  							y -= stepY;
  							l++;
  						}
  	
  						x -= stepX;
  						i++;
  					}
  				} else {
  					el = this.options.snap;
  					l = el.length;
  					n = -1;
  	
  					for ( ; i < l; i++ ) {
  						if ( i === 0 || el[i].offsetLeft <= el[i-1].offsetLeft ) {
  							m = 0;
  							n++;
  						}
  	
  						if ( !this.pages[m] ) {
  							this.pages[m] = [];
  						}
  	
  						x = Math.max(-el[i].offsetLeft, this.maxScrollX);
  						y = Math.max(-el[i].offsetTop, this.maxScrollY);
  						cx = x - Math.round(el[i].offsetWidth / 2);
  						cy = y - Math.round(el[i].offsetHeight / 2);
  	
  						this.pages[m][n] = {
  							x: x,
  							y: y,
  							width: el[i].offsetWidth,
  							height: el[i].offsetHeight,
  							cx: cx,
  							cy: cy
  						};
  	
  						if ( x > this.maxScrollX ) {
  							m++;
  						}
  					}
  				}
  	
  				this.goToPage(this.currentPage.pageX || 0, this.currentPage.pageY || 0, 0);
  	
  				// Update snap threshold if needed
  				if ( this.options.snapThreshold % 1 === 0 ) {
  					this.snapThresholdX = this.options.snapThreshold;
  					this.snapThresholdY = this.options.snapThreshold;
  				} else {
  					this.snapThresholdX = Math.round(this.pages[this.currentPage.pageX][this.currentPage.pageY].width * this.options.snapThreshold);
  					this.snapThresholdY = Math.round(this.pages[this.currentPage.pageX][this.currentPage.pageY].height * this.options.snapThreshold);
  				}
  			});
  	
  			this.on('flick', function () {
  				var time = this.options.snapSpeed || Math.max(
  						Math.max(
  							Math.min(Math.abs(this.x - this.startX), 1000),
  							Math.min(Math.abs(this.y - this.startY), 1000)
  						), 300);
  	
  				this.goToPage(
  					this.currentPage.pageX + this.directionX,
  					this.currentPage.pageY + this.directionY,
  					time
  				);
  			});
  		},
  	
  		_nearestSnap: function (x, y) {
  			if ( !this.pages.length ) {
  				return { x: 0, y: 0, pageX: 0, pageY: 0 };
  			}
  	
  			var i = 0,
  				l = this.pages.length,
  				m = 0;
  	
  			// Check if we exceeded the snap threshold
  			if ( Math.abs(x - this.absStartX) < this.snapThresholdX &&
  				Math.abs(y - this.absStartY) < this.snapThresholdY ) {
  				return this.currentPage;
  			}
  	
  			if ( x > 0 ) {
  				x = 0;
  			} else if ( x < this.maxScrollX ) {
  				x = this.maxScrollX;
  			}
  	
  			if ( y > 0 ) {
  				y = 0;
  			} else if ( y < this.maxScrollY ) {
  				y = this.maxScrollY;
  			}
  	
  			for ( ; i < l; i++ ) {
  				if ( x >= this.pages[i][0].cx ) {
  					x = this.pages[i][0].x;
  					break;
  				}
  			}
  	
  			l = this.pages[i].length;
  	
  			for ( ; m < l; m++ ) {
  				if ( y >= this.pages[0][m].cy ) {
  					y = this.pages[0][m].y;
  					break;
  				}
  			}
  	
  			if ( i == this.currentPage.pageX ) {
  				i += this.directionX;
  	
  				if ( i < 0 ) {
  					i = 0;
  				} else if ( i >= this.pages.length ) {
  					i = this.pages.length - 1;
  				}
  	
  				x = this.pages[i][0].x;
  			}
  	
  			if ( m == this.currentPage.pageY ) {
  				m += this.directionY;
  	
  				if ( m < 0 ) {
  					m = 0;
  				} else if ( m >= this.pages[0].length ) {
  					m = this.pages[0].length - 1;
  				}
  	
  				y = this.pages[0][m].y;
  			}
  	
  			return {
  				x: x,
  				y: y,
  				pageX: i,
  				pageY: m
  			};
  		},
  	
  		goToPage: function (x, y, time, easing) {
  			easing = easing || this.options.bounceEasing;
  	
  			if ( x >= this.pages.length ) {
  				x = this.pages.length - 1;
  			} else if ( x < 0 ) {
  				x = 0;
  			}
  	
  			if ( y >= this.pages[x].length ) {
  				y = this.pages[x].length - 1;
  			} else if ( y < 0 ) {
  				y = 0;
  			}
  	
  			var posX = this.pages[x][y].x,
  				posY = this.pages[x][y].y;
  	
  			time = time === undefined ? this.options.snapSpeed || Math.max(
  				Math.max(
  					Math.min(Math.abs(posX - this.x), 1000),
  					Math.min(Math.abs(posY - this.y), 1000)
  				), 300) : time;
  	
  			this.currentPage = {
  				x: posX,
  				y: posY,
  				pageX: x,
  				pageY: y
  			};
  	
  			this.scrollTo(posX, posY, time, easing);
  		},
  	
  		next: function (time, easing) {
  			var x = this.currentPage.pageX,
  				y = this.currentPage.pageY;
  	
  			x++;
  	
  			if ( x >= this.pages.length && this.hasVerticalScroll ) {
  				x = 0;
  				y++;
  			}
  	
  			this.goToPage(x, y, time, easing);
  		},
  	
  		prev: function (time, easing) {
  			var x = this.currentPage.pageX,
  				y = this.currentPage.pageY;
  	
  			x--;
  	
  			if ( x < 0 && this.hasVerticalScroll ) {
  				x = 0;
  				y--;
  			}
  	
  			this.goToPage(x, y, time, easing);
  		},
  	
  		_initKeys: function (e) {
  			// default key bindings
  			var keys = {
  				pageUp: 33,
  				pageDown: 34,
  				end: 35,
  				home: 36,
  				left: 37,
  				up: 38,
  				right: 39,
  				down: 40
  			};
  			var i;
  	
  			// if you give me characters I give you keycode
  			if ( typeof this.options.keyBindings == 'object' ) {
  				for ( i in this.options.keyBindings ) {
  					if ( typeof this.options.keyBindings[i] == 'string' ) {
  						this.options.keyBindings[i] = this.options.keyBindings[i].toUpperCase().charCodeAt(0);
  					}
  				}
  			} else {
  				this.options.keyBindings = {};
  			}
  	
  			for ( i in keys ) {
  				this.options.keyBindings[i] = this.options.keyBindings[i] || keys[i];
  			}
  	
  			utils.addEvent(window, 'keydown', this);
  	
  			this.on('destroy', function () {
  				utils.removeEvent(window, 'keydown', this);
  			});
  		},
  	
  		_key: function (e) {
  			if ( !this.enabled ) {
  				return;
  			}
  	
  			var snap = this.options.snap,	// we are using this alot, better to cache it
  				newX = snap ? this.currentPage.pageX : this.x,
  				newY = snap ? this.currentPage.pageY : this.y,
  				now = utils.getTime(),
  				prevTime = this.keyTime || 0,
  				acceleration = 0.250,
  				pos;
  	
  			if ( this.options.useTransition && this.isInTransition ) {
  				pos = this.getComputedPosition();
  	
  				this._translate(Math.round(pos.x), Math.round(pos.y));
  				this.isInTransition = false;
  			}
  	
  			this.keyAcceleration = now - prevTime < 200 ? Math.min(this.keyAcceleration + acceleration, 50) : 0;
  	
  			switch ( e.keyCode ) {
  				case this.options.keyBindings.pageUp:
  					if ( this.hasHorizontalScroll && !this.hasVerticalScroll ) {
  						newX += snap ? 1 : this.wrapperWidth;
  					} else {
  						newY += snap ? 1 : this.wrapperHeight;
  					}
  					break;
  				case this.options.keyBindings.pageDown:
  					if ( this.hasHorizontalScroll && !this.hasVerticalScroll ) {
  						newX -= snap ? 1 : this.wrapperWidth;
  					} else {
  						newY -= snap ? 1 : this.wrapperHeight;
  					}
  					break;
  				case this.options.keyBindings.end:
  					newX = snap ? this.pages.length-1 : this.maxScrollX;
  					newY = snap ? this.pages[0].length-1 : this.maxScrollY;
  					break;
  				case this.options.keyBindings.home:
  					newX = 0;
  					newY = 0;
  					break;
  				case this.options.keyBindings.left:
  					newX += snap ? -1 : 5 + this.keyAcceleration>>0;
  					break;
  				case this.options.keyBindings.up:
  					newY += snap ? 1 : 5 + this.keyAcceleration>>0;
  					break;
  				case this.options.keyBindings.right:
  					newX -= snap ? -1 : 5 + this.keyAcceleration>>0;
  					break;
  				case this.options.keyBindings.down:
  					newY -= snap ? 1 : 5 + this.keyAcceleration>>0;
  					break;
  				default:
  					return;
  			}
  	
  			if ( snap ) {
  				this.goToPage(newX, newY);
  				return;
  			}
  	
  			if ( newX > 0 ) {
  				newX = 0;
  				this.keyAcceleration = 0;
  			} else if ( newX < this.maxScrollX ) {
  				newX = this.maxScrollX;
  				this.keyAcceleration = 0;
  			}
  	
  			if ( newY > 0 ) {
  				newY = 0;
  				this.keyAcceleration = 0;
  			} else if ( newY < this.maxScrollY ) {
  				newY = this.maxScrollY;
  				this.keyAcceleration = 0;
  			}
  	
  			this.scrollTo(newX, newY, 0);
  	
  			this.keyTime = now;
  		},
  	
  		_animate: function (destX, destY, duration, easingFn) {
  			var that = this,
  				startX = this.x,
  				startY = this.y,
  				startTime = utils.getTime(),
  				destTime = startTime + duration;
  	
  			function step () {
  				var now = utils.getTime(),
  					newX, newY,
  					easing;
  	
  				if ( now >= destTime ) {
  					that.isAnimating = false;
  					that._translate(destX, destY);
  					
  					if ( !that.resetPosition(that.options.bounceTime) ) {
  						that._execEvent('scrollEnd');
  					}
  	
  					return;
  				}
  	
  				now = ( now - startTime ) / duration;
  				easing = easingFn(now);
  				newX = ( destX - startX ) * easing + startX;
  				newY = ( destY - startY ) * easing + startY;
  				that._translate(newX, newY);
  	
  				if ( that.isAnimating ) {
  					rAF(step);
  				}
  	
  				if ( that.options.probeType == 3 ) {
  					that._execEvent('scroll');
  				}
  			}
  	
  			this.isAnimating = true;
  			step();
  		},
  	
  		handleEvent: function (e) {
  			switch ( e.type ) {
  				case 'touchstart':
  				case 'pointerdown':
  				case 'MSPointerDown':
  				case 'mousedown':
  					this._start(e);
  					break;
  				case 'touchmove':
  				case 'pointermove':
  				case 'MSPointerMove':
  				case 'mousemove':
  					this._move(e);
  					break;
  				case 'touchend':
  				case 'pointerup':
  				case 'MSPointerUp':
  				case 'mouseup':
  				case 'touchcancel':
  				case 'pointercancel':
  				case 'MSPointerCancel':
  				case 'mousecancel':
  					this._end(e);
  					break;
  				case 'orientationchange':
  				case 'resize':
  					this._resize();
  					break;
  				case 'transitionend':
  				case 'webkitTransitionEnd':
  				case 'oTransitionEnd':
  				case 'MSTransitionEnd':
  					this._transitionEnd(e);
  					break;
  				case 'wheel':
  				case 'DOMMouseScroll':
  				case 'mousewheel':
  					this._wheel(e);
  					break;
  				case 'keydown':
  					this._key(e);
  					break;
  				case 'click':
  					if ( this.enabled && !e._constructed ) {
  						e.preventDefault();
  						e.stopPropagation();
  					}
  					break;
  			}
  		}
  	};
  	function createDefaultScrollbar (direction, interactive, type) {
  		var scrollbar = document.createElement('div'),
  			indicator = document.createElement('div');
  	
  		if ( type === true ) {
  			scrollbar.style.cssText = 'position:absolute;z-index:9999';
  			indicator.style.cssText = '-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;position:absolute;background:rgba(0,0,0,0.5);border:1px solid rgba(255,255,255,0.9);border-radius:3px';
  		}
  	
  		indicator.className = 'iScrollIndicator';
  	
  		if ( direction == 'h' ) {
  			if ( type === true ) {
  				scrollbar.style.cssText += ';height:7px;left:2px;right:2px;bottom:0';
  				indicator.style.height = '100%';
  			}
  			scrollbar.className = 'iScrollHorizontalScrollbar';
  		} else {
  			if ( type === true ) {
  				scrollbar.style.cssText += ';width:7px;bottom:2px;top:2px;right:1px';
  				indicator.style.width = '100%';
  			}
  			scrollbar.className = 'iScrollVerticalScrollbar';
  		}
  	
  		scrollbar.style.cssText += ';overflow:hidden';
  	
  		if ( !interactive ) {
  			scrollbar.style.pointerEvents = 'none';
  		}
  	
  		scrollbar.appendChild(indicator);
  	
  		return scrollbar;
  	}
  	
  	function Indicator (scroller, options) {
  		this.wrapper = typeof options.el == 'string' ? document.querySelector(options.el) : options.el;
  		this.wrapperStyle = this.wrapper.style;
  		this.indicator = this.wrapper.children[0];
  		this.indicatorStyle = this.indicator.style;
  		this.scroller = scroller;
  	
  		this.options = {
  			listenX: true,
  			listenY: true,
  			interactive: false,
  			resize: true,
  			defaultScrollbars: false,
  			shrink: false,
  			fade: false,
  			speedRatioX: 0,
  			speedRatioY: 0
  		};
  	
  		for ( var i in options ) {
  			this.options[i] = options[i];
  		}
  	
  		this.sizeRatioX = 1;
  		this.sizeRatioY = 1;
  		this.maxPosX = 0;
  		this.maxPosY = 0;
  	
  		if ( this.options.interactive ) {
  			if ( !this.options.disableTouch ) {
  				utils.addEvent(this.indicator, 'touchstart', this);
  				utils.addEvent(window, 'touchend', this);
  			}
  			if ( !this.options.disablePointer ) {
  				utils.addEvent(this.indicator, utils.prefixPointerEvent('pointerdown'), this);
  				utils.addEvent(window, utils.prefixPointerEvent('pointerup'), this);
  			}
  			if ( !this.options.disableMouse ) {
  				utils.addEvent(this.indicator, 'mousedown', this);
  				utils.addEvent(window, 'mouseup', this);
  			}
  		}
  	
  		if ( this.options.fade ) {
  			this.wrapperStyle[utils.style.transform] = this.scroller.translateZ;
  			var durationProp = utils.style.transitionDuration;
  			this.wrapperStyle[durationProp] = utils.isBadAndroid ? '0.0001ms' : '0ms';
  			// remove 0.0001ms
  			var self = this;
  			if(utils.isBadAndroid) {
  				rAF(function() {
  					if(self.wrapperStyle[durationProp] === '0.0001ms') {
  						self.wrapperStyle[durationProp] = '0s';
  					}
  				});
  			}
  			this.wrapperStyle.opacity = '0';
  		}
  	}
  	
  	Indicator.prototype = {
  		handleEvent: function (e) {
  			switch ( e.type ) {
  				case 'touchstart':
  				case 'pointerdown':
  				case 'MSPointerDown':
  				case 'mousedown':
  					this._start(e);
  					break;
  				case 'touchmove':
  				case 'pointermove':
  				case 'MSPointerMove':
  				case 'mousemove':
  					this._move(e);
  					break;
  				case 'touchend':
  				case 'pointerup':
  				case 'MSPointerUp':
  				case 'mouseup':
  				case 'touchcancel':
  				case 'pointercancel':
  				case 'MSPointerCancel':
  				case 'mousecancel':
  					this._end(e);
  					break;
  			}
  		},
  	
  		destroy: function () {
  			if ( this.options.fadeScrollbars ) {
  				clearTimeout(this.fadeTimeout);
  				this.fadeTimeout = null;
  			}
  			if ( this.options.interactive ) {
  				utils.removeEvent(this.indicator, 'touchstart', this);
  				utils.removeEvent(this.indicator, utils.prefixPointerEvent('pointerdown'), this);
  				utils.removeEvent(this.indicator, 'mousedown', this);
  	
  				utils.removeEvent(window, 'touchmove', this);
  				utils.removeEvent(window, utils.prefixPointerEvent('pointermove'), this);
  				utils.removeEvent(window, 'mousemove', this);
  	
  				utils.removeEvent(window, 'touchend', this);
  				utils.removeEvent(window, utils.prefixPointerEvent('pointerup'), this);
  				utils.removeEvent(window, 'mouseup', this);
  			}
  	
  			if ( this.options.defaultScrollbars ) {
  				this.wrapper.parentNode.removeChild(this.wrapper);
  			}
  		},
  	
  		_start: function (e) {
  			var point = e.touches ? e.touches[0] : e;
  	
  			e.preventDefault();
  			e.stopPropagation();
  	
  			this.transitionTime();
  	
  			this.initiated = true;
  			this.moved = false;
  			this.lastPointX	= point.pageX;
  			this.lastPointY	= point.pageY;
  	
  			this.startTime	= utils.getTime();
  	
  			if ( !this.options.disableTouch ) {
  				utils.addEvent(window, 'touchmove', this);
  			}
  			if ( !this.options.disablePointer ) {
  				utils.addEvent(window, utils.prefixPointerEvent('pointermove'), this);
  			}
  			if ( !this.options.disableMouse ) {
  				utils.addEvent(window, 'mousemove', this);
  			}
  	
  			this.scroller._execEvent('beforeScrollStart');
  		},
  	
  		_move: function (e) {
  			var point = e.touches ? e.touches[0] : e,
  				deltaX, deltaY,
  				newX, newY,
  				timestamp = utils.getTime();
  	
  			if ( !this.moved ) {
  				this.scroller._execEvent('scrollStart');
  			}
  	
  			this.moved = true;
  	
  			deltaX = point.pageX - this.lastPointX;
  			this.lastPointX = point.pageX;
  	
  			deltaY = point.pageY - this.lastPointY;
  			this.lastPointY = point.pageY;
  	
  			newX = this.x + deltaX;
  			newY = this.y + deltaY;
  	
  			this._pos(newX, newY);
  	
  	
  			if ( this.scroller.options.probeType == 1 && timestamp - this.startTime > 300 ) {
  				this.startTime = timestamp;
  				this.scroller._execEvent('scroll');
  			} else if ( this.scroller.options.probeType > 1 ) {
  				this.scroller._execEvent('scroll');
  			}
  	
  	
  	// INSERT POINT: indicator._move
  	
  			e.preventDefault();
  			e.stopPropagation();
  		},
  	
  		_end: function (e) {
  			if ( !this.initiated ) {
  				return;
  			}
  	
  			this.initiated = false;
  	
  			e.preventDefault();
  			e.stopPropagation();
  	
  			utils.removeEvent(window, 'touchmove', this);
  			utils.removeEvent(window, utils.prefixPointerEvent('pointermove'), this);
  			utils.removeEvent(window, 'mousemove', this);
  	
  			if ( this.scroller.options.snap ) {
  				var snap = this.scroller._nearestSnap(this.scroller.x, this.scroller.y);
  	
  				var time = this.options.snapSpeed || Math.max(
  						Math.max(
  							Math.min(Math.abs(this.scroller.x - snap.x), 1000),
  							Math.min(Math.abs(this.scroller.y - snap.y), 1000)
  						), 300);
  	
  				if ( this.scroller.x != snap.x || this.scroller.y != snap.y ) {
  					this.scroller.directionX = 0;
  					this.scroller.directionY = 0;
  					this.scroller.currentPage = snap;
  					this.scroller.scrollTo(snap.x, snap.y, time, this.scroller.options.bounceEasing);
  				}
  			}
  	
  			if ( this.moved ) {
  				this.scroller._execEvent('scrollEnd');
  			}
  		},
  	
  		transitionTime: function (time) {
  			time = time || 0;
  			var durationProp = utils.style.transitionDuration;
  			this.indicatorStyle[durationProp] = time + 'ms';
  	
  			if ( !time && utils.isBadAndroid ) {
  				this.indicatorStyle[durationProp] = '0.0001ms';
  				// remove 0.0001ms
  				var self = this;
  				rAF(function() {
  					if(self.indicatorStyle[durationProp] === '0.0001ms') {
  						self.indicatorStyle[durationProp] = '0s';
  					}
  				});
  			}
  		},
  	
  		transitionTimingFunction: function (easing) {
  			this.indicatorStyle[utils.style.transitionTimingFunction] = easing;
  		},
  	
  		refresh: function () {
  			this.transitionTime();
  	
  			if ( this.options.listenX && !this.options.listenY ) {
  				this.indicatorStyle.display = this.scroller.hasHorizontalScroll ? 'block' : 'none';
  			} else if ( this.options.listenY && !this.options.listenX ) {
  				this.indicatorStyle.display = this.scroller.hasVerticalScroll ? 'block' : 'none';
  			} else {
  				this.indicatorStyle.display = this.scroller.hasHorizontalScroll || this.scroller.hasVerticalScroll ? 'block' : 'none';
  			}
  	
  			if ( this.scroller.hasHorizontalScroll && this.scroller.hasVerticalScroll ) {
  				utils.addClass(this.wrapper, 'iScrollBothScrollbars');
  				utils.removeClass(this.wrapper, 'iScrollLoneScrollbar');
  	
  				if ( this.options.defaultScrollbars && this.options.customStyle ) {
  					if ( this.options.listenX ) {
  						this.wrapper.style.right = '8px';
  					} else {
  						this.wrapper.style.bottom = '8px';
  					}
  				}
  			} else {
  				utils.removeClass(this.wrapper, 'iScrollBothScrollbars');
  				utils.addClass(this.wrapper, 'iScrollLoneScrollbar');
  	
  				if ( this.options.defaultScrollbars && this.options.customStyle ) {
  					if ( this.options.listenX ) {
  						this.wrapper.style.right = '2px';
  					} else {
  						this.wrapper.style.bottom = '2px';
  					}
  				}
  			}
  	
  			var r = this.wrapper.offsetHeight;	// force refresh
  	
  			if ( this.options.listenX ) {
  				this.wrapperWidth = this.wrapper.clientWidth;
  				if ( this.options.resize ) {
  					this.indicatorWidth = Math.max(Math.round(this.wrapperWidth * this.wrapperWidth / (this.scroller.scrollerWidth || this.wrapperWidth || 1)), 8);
  					this.indicatorStyle.width = this.indicatorWidth + 'px';
  				} else {
  					this.indicatorWidth = this.indicator.clientWidth;
  				}
  	
  				this.maxPosX = this.wrapperWidth - this.indicatorWidth;
  	
  				if ( this.options.shrink == 'clip' ) {
  					this.minBoundaryX = -this.indicatorWidth + 8;
  					this.maxBoundaryX = this.wrapperWidth - 8;
  				} else {
  					this.minBoundaryX = 0;
  					this.maxBoundaryX = this.maxPosX;
  				}
  	
  				this.sizeRatioX = this.options.speedRatioX || (this.scroller.maxScrollX && (this.maxPosX / this.scroller.maxScrollX));
  			}
  	
  			if ( this.options.listenY ) {
  				this.wrapperHeight = this.wrapper.clientHeight;
  				if ( this.options.resize ) {
  					this.indicatorHeight = Math.max(Math.round(this.wrapperHeight * this.wrapperHeight / (this.scroller.scrollerHeight || this.wrapperHeight || 1)), 8);
  					this.indicatorStyle.height = this.indicatorHeight + 'px';
  				} else {
  					this.indicatorHeight = this.indicator.clientHeight;
  				}
  	
  				this.maxPosY = this.wrapperHeight - this.indicatorHeight;
  	
  				if ( this.options.shrink == 'clip' ) {
  					this.minBoundaryY = -this.indicatorHeight + 8;
  					this.maxBoundaryY = this.wrapperHeight - 8;
  				} else {
  					this.minBoundaryY = 0;
  					this.maxBoundaryY = this.maxPosY;
  				}
  	
  				this.maxPosY = this.wrapperHeight - this.indicatorHeight;
  				this.sizeRatioY = this.options.speedRatioY || (this.scroller.maxScrollY && (this.maxPosY / this.scroller.maxScrollY));
  			}
  	
  			this.updatePosition();
  		},
  	
  		updatePosition: function () {
  			var x = this.options.listenX && Math.round(this.sizeRatioX * this.scroller.x) || 0,
  				y = this.options.listenY && Math.round(this.sizeRatioY * this.scroller.y) || 0;
  	
  			if ( !this.options.ignoreBoundaries ) {
  				if ( x < this.minBoundaryX ) {
  					if ( this.options.shrink == 'scale' ) {
  						this.width = Math.max(this.indicatorWidth + x, 8);
  						this.indicatorStyle.width = this.width + 'px';
  					}
  					x = this.minBoundaryX;
  				} else if ( x > this.maxBoundaryX ) {
  					if ( this.options.shrink == 'scale' ) {
  						this.width = Math.max(this.indicatorWidth - (x - this.maxPosX), 8);
  						this.indicatorStyle.width = this.width + 'px';
  						x = this.maxPosX + this.indicatorWidth - this.width;
  					} else {
  						x = this.maxBoundaryX;
  					}
  				} else if ( this.options.shrink == 'scale' && this.width != this.indicatorWidth ) {
  					this.width = this.indicatorWidth;
  					this.indicatorStyle.width = this.width + 'px';
  				}
  	
  				if ( y < this.minBoundaryY ) {
  					if ( this.options.shrink == 'scale' ) {
  						this.height = Math.max(this.indicatorHeight + y * 3, 8);
  						this.indicatorStyle.height = this.height + 'px';
  					}
  					y = this.minBoundaryY;
  				} else if ( y > this.maxBoundaryY ) {
  					if ( this.options.shrink == 'scale' ) {
  						this.height = Math.max(this.indicatorHeight - (y - this.maxPosY) * 3, 8);
  						this.indicatorStyle.height = this.height + 'px';
  						y = this.maxPosY + this.indicatorHeight - this.height;
  					} else {
  						y = this.maxBoundaryY;
  					}
  				} else if ( this.options.shrink == 'scale' && this.height != this.indicatorHeight ) {
  					this.height = this.indicatorHeight;
  					this.indicatorStyle.height = this.height + 'px';
  				}
  			}
  	
  			this.x = x;
  			this.y = y;
  	
  			if ( this.scroller.options.useTransform ) {
  				this.indicatorStyle[utils.style.transform] = 'translate(' + x + 'px,' + y + 'px)' + this.scroller.translateZ;
  			} else {
  				this.indicatorStyle.left = x + 'px';
  				this.indicatorStyle.top = y + 'px';
  			}
  		},
  	
  		_pos: function (x, y) {
  			if ( x < 0 ) {
  				x = 0;
  			} else if ( x > this.maxPosX ) {
  				x = this.maxPosX;
  			}
  	
  			if ( y < 0 ) {
  				y = 0;
  			} else if ( y > this.maxPosY ) {
  				y = this.maxPosY;
  			}
  	
  			x = this.options.listenX ? Math.round(x / this.sizeRatioX) : this.scroller.x;
  			y = this.options.listenY ? Math.round(y / this.sizeRatioY) : this.scroller.y;
  	
  			this.scroller.scrollTo(x, y);
  		},
  	
  		fade: function (val, hold) {
  			if ( hold && !this.visible ) {
  				return;
  			}
  	
  			clearTimeout(this.fadeTimeout);
  			this.fadeTimeout = null;
  	
  			var time = val ? 250 : 500,
  				delay = val ? 0 : 300;
  	
  			val = val ? '1' : '0';
  	
  			this.wrapperStyle[utils.style.transitionDuration] = time + 'ms';
  	
  			this.fadeTimeout = setTimeout((function (val) {
  				this.wrapperStyle.opacity = val;
  				this.visible = +val;
  			}).bind(this, val), delay);
  		}
  	};
  	
  	IScroll.utils = utils;
  	
  	if ( typeof module != 'undefined' && module.exports ) {
  		module.exports = IScroll;
  	} else if ( true ) {
  	        !(__WEBPACK_AMD_DEFINE_RESULT__ = function () { return IScroll; }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  	} else {
  		window.IScroll = IScroll;
  	}
  	
  	})(window, document, Math);
  
  
  /***/ },
  /* 344 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(79), RootInstanceProvider = __webpack_require__(87), ReactMount = __webpack_require__(89), React = __webpack_require__(141); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } try { (function () {
  	
  	'use strict';
  	
  	var _axios = __webpack_require__(345);
  	
  	var _axios2 = _interopRequireDefault(_axios);
  	
  	var _jquery = __webpack_require__(341);
  	
  	var _jquery2 = _interopRequireDefault(_jquery);
  	
  	var _react = __webpack_require__(141);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	var _react3 = __webpack_require__(363);
  	
  	var _react4 = _interopRequireDefault(_react3);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	var url = 'http://api.kankanews.com/kkweb/kkstu/cast/';
  	var linkPic = 'http://skin.kankanews.com/onlive/mline/images/link.png';
  	var journPic = 'http://skin.kankanews.com/onlive/mline/images/xiaowen.jpg';
  	var loadingPic = 'http://skin.kankanews.com/onlive/mline/images/place.jpg';
  	var date = [],
  	    headDate = [];
  	var outhtml = '';
  	
  	function getQueryString(name) {
  	  var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
  	  var r = window.location.search.substr(1).match(reg);
  	  if (r != null) return unescape(r[2]);return null;
  	}
  	
  	function dataMap(arr) {
  	  var inc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  	
  	  return arr.map(function (obj, i) {
  	    var objDate = obj.newstime.split(' ')[0];
  	    obj.timeC = objDate;
  	    if (_jquery2.default.inArray(objDate, date) == -1) {
  	      date.push(objDate);
  	      obj.bar = 1;
  	    } else {
  	      obj.bar = 0;
  	    }
  	    inc ? obj.inc = 1 : obj.inc = 0;
  	    inc ? obj.bar = 1 : '';
  	  });
  	}
  	
  	function getData(id) {
  	  var timestamp = Date.parse(new Date());
  	  var u = url + id + '.json?ord=asc?' + timestamp + '&jsoncallback=?';
  	  return _jquery2.default.getJSON(u).then(function (data) {
  	    var dataNews = data.news.reverse();
  	    dataMap(dataNews);
  	    return data;
  	  });
  	}
  	
  	function getNextData(pid, cid) {
  	  var url = 'http://api.kankanews.com/kkweb/kkstu/next/' + pid + '/' + cid + '.json?ord=desc&jsoncallback=?';
  	  console.log('url', url);
  	  return _jquery2.default.getJSON(url).then(function (data) {
  	    var dataM = data.reverse();
  	    dataMap(dataM);
  	    return dataM;
  	  });
  	}
  	
  	function _incData(cid) {
  	  if (!b.done) return;
  	  var time = (0, _jquery2.default)('.fresh .allnews').first().attr('data-time');
  	  if (time == undefined) {
  	    time = 1;
  	  }
  	  var timestamp = Date.parse(new Date());
  	  var request_url = 'http://api.kankanews.com/kkweb/kkstu/incre/' + time + '/' + cid + '.json?' + timestamp + '&jsoncallback=?';
  	  //console.log(request_url)
  	  return _jquery2.default.getJSON(request_url).then(function (data) {
  	    /*    data[0].newstime = "10月20日 06:39"
  	        data[1].newstime = "10月20日 08:10"
  	        data[2].newstime = "10月20日 18:10"*/
  	    dataMap(data.reverse(), 1);
  	    return data;
  	  });
  	}
  	
  	function regBr(txt) {
  	  return txt.replace(/\r\n/g, "<br>");
  	}
  	
  	var b = {
  	  //streamid:streamid,
  	  eid: eid, isclose: isclose, page: 0, flag: false, timefalg: 0,
  	  win: (0, _jquery2.default)(window), loading: (0, _jquery2.default)('.feed-card-loading'), winWidth: document.documentElement.clientWidth,
  	  loadpic: 'http://skin.kankanews.com/onlive/mline/images/place.jpg',
  	  color: color, date: [], headDate: [], videoSt: 'on', done: true, load: false,
  	  vidoepic: 'http://act.shanghaicity.openservice.kankanews.com/iloveshanghai/2015/live/images/play.png',
  	  uc: false
  	};
  	
  	var util = {
  	  param: {
  	    cid: 0
  	  },
  	  more_btn: function more_btn(cid) {
  	    this.param.cid = cid;
  	    var that = this;
  	    var timeout = null;
  	    (0, _jquery2.default)('.more_btn_loading').css('display', 'block');
  	    if (parseInt(streamid)) {
  	      if (b.flag) return;
  	      if (timeout) {
  	        clearTimeout(timeout);
  	      }
  	      return;
  	    }
  	    (0, _jquery2.default)('.more_btn_loading').css('display', 'block');
  	    if (b.flag) return;
  	    if (timeout) {
  	      clearTimeout(timeout);
  	    }
  	  },
  	  viewData: function viewData() {
  	    var e = 0,
  	        l = 0,
  	        i = 0,
  	        g = 0,
  	        f = 0,
  	        m = 0;
  	    var j = window,
  	        h = document,
  	        k = h.documentElement;
  	    e = k.clientWidth || h.body.clientWidth || 0;
  	    l = j.innerHeight || k.clientHeight || h.body.clientHeight || 0;
  	    g = h.body.scrollTop || k.scrollTop || j.pageYOffset || 0;
  	    i = h.body.scrollLeft || k.scrollLeft || j.pageXOffset || 0;
  	    f = Math.max(h.body.scrollWidth, k.scrollWidth || 0);
  	    m = Math.max(h.body.scrollHeight, k.scrollHeight || 0, l);
  	    return { scrollTop: g, scrollLeft: i, documentWidth: f, documentHeight: m, viewWidth: e, viewHeight: l };
  	  },
  	  _initScrollEnd: function _initScrollEnd(cid) {
  	    this.more_btn(cid);
  	    var vd = this.viewData();
  	    this.ald = 0;
  	    if (vd.viewHeight + vd.scrollTop + this.ald >= vd.documentHeight) {
  	      return this._loadNews().then(function (data) {
  	        b.done = true;
  	        if (data.length == 0) {
  	          (0, _jquery2.default)('.more_btn').html('已经加载全部');(0, _jquery2.default)('.loadingbtn').css('opacity', 0);
  	          b.flag = true;
  	        } else {
  	          (0, _jquery2.default)('.more_btn').html('上拉加载更多');(0, _jquery2.default)('.loadingbtn').css('opacity', 0);
  	          return data;
  	        }
  	      });
  	    }
  	  },
  	  _loadNews: function _loadNews() {
  	    var scrolltime = (0, _jquery2.default)('.allnews').last().attr('data-time');
  	    console.log('_loadNews', scrolltime);
  	    if (scrolltime == null) {
  	      return;
  	    }
  	    (0, _jquery2.default)('.more_btn').html('加载中……');(0, _jquery2.default)('.loadingbtn').css('opacity', 1);
  	    var that = this;
  	    return that._setLoadingState(true);
  	  },
  	  _setLoadingState: function _setLoadingState(isLoading) {
  	    var that = this;
  	    that.isLoading = isLoading;
  	    if (isLoading) {
  	      var scrolltime = (0, _jquery2.default)('.allnews').last().attr('data-time');
  	      (0, _jquery2.default)('.more_btnbox').css('display', 'block');
  	      if (b.isclose == 1) {
  	        var od = 'asc';
  	      } else {
  	        var od = 'desc';
  	      }
  	      var url = 'http://api.kankanews.com/kkweb/kkstu/next/' + scrolltime + '/' + this.param.cid + '.json?ord=' + od;
  	      return that.render(scrolltime, this.param.cid);
  	    }
  	  },
  	  render: function render(pid, cid) {
  	    b.done = false;
  	    if (b.flag) {
  	      (0, _jquery2.default)('.more_btn').html('已经加载全部');(0, _jquery2.default)('.loadingbtn').css('opacity', 0);
  	      b.done = true;
  	      return false;
  	    }
  	    (0, _jquery2.default)('.more_btn').html('加载中……');(0, _jquery2.default)('.loadingbtn').css('opacity', 1);
  	    return getNextData(pid, cid);
  	  }
  	};
  	
  	var scroll = {
  	  onscroll: function onscroll(scint) {
  	    //app._vidoeTimeBand();
  	    console.log('scroll', b.done);
  	    if (!b.done) return;
  	    var $pullDown = (0, _jquery2.default)('.pulldown');
  	    var $pullUp = (0, _jquery2.default)('.more_btn_loading');
  	    if (scint.y > 40) {
  	      $pullDown.addClass('flip').html('松开后刷新...');
  	    } else {
  	      $pullDown.removeClass('flip').find('.more_btn').html('下拉刷新...');
  	    }
  	    if (b.flag) return;
  	    if (scint.maxScrollY - scint.y > 40) {
  	      $pullUp.addClass('flip');
  	    }
  	  },
  	  onscrollEnd: function onscrollEnd(scint, cid) {
  	    util.more_btn(cid);
  	    //app._vidoeTimeBand();
  	    if (!b.done) return;
  	    var $pullDown = (0, _jquery2.default)('.pulldown');
  	    var $pullUp = (0, _jquery2.default)('.more_btn_loading');
  	    if ($pullDown.hasClass('flip')) {
  	      $pullDown.removeClass('flip').html('加载中...');
  	      if (b.done) {
  	        //app._incData('down');  // 0 表示下拉刷新
  	      }
  	    }
  	    if (b.flag) return;
  	    console.log(scint.maxScrollY, scint.y);
  	    if (scint.maxScrollY - scint.y > -5) {
  	      console.log('b.done', b.done);
  	      $pullUp.removeClass('flip').find('.more_btn').html('加载中...');
  	      // 1 表示上拉刷新
  	      return util._loadNews().then(function (data) {
  	        b.done = true;
  	        if (data.length == 0) {
  	          (0, _jquery2.default)('.more_btn').html('已经加载全部');(0, _jquery2.default)('.loadingbtn').css('opacity', 0);
  	          b.flag = true;
  	        } else {
  	          (0, _jquery2.default)('.more_btn').html('上拉加载更多');(0, _jquery2.default)('.loadingbtn').css('opacity', 0);
  	          return data;
  	        }
  	      });
  	    }
  	  }
  	};
  	
  	function render(data, streamid, conts) {
  	  var journalistintro = data.journalistintro ? '[' + data.journalistintro + ']' : '[看看新闻主持人]';
  	  var journalist = data.journalist ? data.journalist : ' ';
  	
  	  if (data.videoframe) {
  	    if (parseInt(streamid)) {
  	      var source = [{ src: data.videourl, type: 'video/mp4' }];
  	      var picontent = _react2.default.createElement(
  	        'div',
  	        { className: 'pics video before', 'data-src': data.videoframe },
  	        _react2.default.createElement(
  	          'div',
  	          { className: 'poster', onClick: conts.posterClick, ref: 'poster' },
  	          _react2.default.createElement('img', { src: data.titlepic }),
  	          _react2.default.createElement('div', { className: 'playbut' })
  	        ),
  	        _react2.default.createElement(_react4.default, {
  	          id: data.timestamp,
  	          ref: 'VideoComp',
  	          cls: 'custom-video',
  	          height: '100%', width: '100%',
  	          poster: data.titlepic,
  	          source: source })
  	      );
  	    } else {
  	      //console.log('videoframe',data.videoframe)
  	      var patt = /http(.*?)"/gi;
  	      var str = data.videoframe;
  	      var iUrl = str.match(patt)[0].split('\"')[0];
  	      var picontent = _react2.default.createElement(
  	        'div',
  	        { className: 'pics video before', 'data-src': str },
  	        _react2.default.createElement('iframe', { height: '450', width: '530', src: iUrl, frameBorder: '0', allowFullScreen: true })
  	      );
  	    }
  	  } else {
  	    var piclist = data.titlepic ? data.titlepic.split("|") : '';
  	    if (piclist.length > 1) {
  	      var pictwo = 'pics more clearfix';
  	      if (piclist.length == 2) {
  	        pictwo += ' two';
  	      }
  	      var style = {
  	        'backgroundImage': 'url({loadingPic})'
  	      };
  	      var picontent = _react2.default.createElement(
  	        'div',
  	        { className: pictwo },
  	        piclist.map(function (obj, i) {
  	          return _react2.default.createElement(
  	            'li',
  	            null,
  	            _react2.default.createElement(
  	              'span',
  	              null,
  	              _react2.default.createElement('img', { className: 'demos-image', style: style, 'data-time': data.newstime ? data.newstime.split(' ')[1] : '', 'data-original': obj, src: obj })
  	            )
  	          );
  	        })
  	      );
  	    } else {
  	      if (piclist[0]) {
  	        var picontent = _react2.default.createElement(
  	          'div',
  	          { className: 'pics' },
  	          _react2.default.createElement(
  	            'li',
  	            null,
  	            _react2.default.createElement(
  	              'span',
  	              null,
  	              _react2.default.createElement('img', { src: piclist[0], width: '100%', onload: 'app.loadImage()' })
  	            )
  	          )
  	        );
  	      } else {
  	        var picontent = '';
  	      }
  	    }
  	  }
  	  var outlink = '';
  	  if (data.outlink && data.outlink.length) {
  	    outlink = data.outlink.map(function (obj, i) {
  	      var style = {
  	        color: obj.color
  	      };
  	      return _react2.default.createElement(
  	        'span',
  	        { className: 'outlink' },
  	        _react2.default.createElement(
  	          'a',
  	          { href: obj.link, style: style },
  	          obj.title
  	        )
  	      );
  	    });
  	  }
  	
  	  var dd = data.newstime ? data.newstime.split(' ')[0] : '';
  	
  	  var html = _react2.default.createElement(
  	    'div',
  	    { className: 'live_list allnews', 'data-time': data.timestamp, 'data-date': data.newstime ? data.newstime.split(' ')[0] : '' },
  	    data.bar ? _react2.default.createElement(
  	      'div',
  	      { className: 'timeCollection sub', 'data-time': dd, ref: 'timeBar' },
  	      dd
  	    ) : '',
  	    _react2.default.createElement(
  	      'div',
  	      { className: 'list_con' },
  	      _react2.default.createElement(
  	        'div',
  	        { className: 'content' },
  	        _react2.default.createElement(
  	          'div',
  	          { className: 'item' },
  	          _react2.default.createElement(
  	            'p',
  	            { className: 'portrait' },
  	            data.journalistpic ? _react2.default.createElement('img', { src: data.journalistpic }) : _react2.default.createElement('img', { src: journPic })
  	          ),
  	          _react2.default.createElement(
  	            'div',
  	            { className: 'itemW' },
  	            _react2.default.createElement(
  	              'div',
  	              { className: 'news' },
  	              _react2.default.createElement(
  	                'div',
  	                { className: 'man' },
  	                data.journalistintro || data.journalist ? _react2.default.createElement(
  	                  'span',
  	                  { className: 'identity' },
  	                  journalistintro
  	                ) : _react2.default.createElement(
  	                  'span',
  	                  { className: 'identity' },
  	                  '[\u770B\u770B\u65B0\u95FB\u4E3B\u6301\u4EBA]'
  	                ),
  	                data.journalistintro || data.journalist ? _react2.default.createElement(
  	                  'span',
  	                  { className: 'name' },
  	                  journalist
  	                ) : _react2.default.createElement(
  	                  'span',
  	                  { className: 'name' },
  	                  '\u5C0F\u6587'
  	                ),
  	                _react2.default.createElement(
  	                  'span',
  	                  { className: 'time' },
  	                  data.newstime ? data.newstime.split(' ')[1] : ''
  	                )
  	              ),
  	              _react2.default.createElement(
  	                'p',
  	                { className: 'title' },
  	                data.titleurl ? _react2.default.createElement(
  	                  'a',
  	                  { href: data.titleurl },
  	                  data.title,
  	                  _react2.default.createElement(
  	                    'i',
  	                    null,
  	                    _react2.default.createElement('img', { src: linkPic, width: '16', height: '16' })
  	                  )
  	                ) : data.title
  	              ),
  	              data.newstext && _react2.default.createElement(
  	                'div',
  	                { className: 'desc' },
  	                _react2.default.createElement(
  	                  'p',
  	                  null,
  	                  regBr(data.newstext)
  	                )
  	              ),
  	              picontent,
  	              outlink
  	            )
  	          )
  	        )
  	      )
  	    )
  	  );
  	  return html;
  	}
  	
  	module.exports = {
  	  getQueryString: getQueryString,
  	  viewData: util.viewData,
  	  getData: getData,
  	  util: util,
  	  regBr: regBr,
  	  render: render,
  	  scroll: scroll,
  	  _incData: _incData
  	};
  	
  	/* REACT HOT LOADER */ }).call(this); } finally { if (true) { (function () { var foundReactClasses = module.hot.data && module.hot.data.foundReactClasses || false; if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(337); if (makeExportsHot(module, __webpack_require__(141))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error("Cannot apply hot update to " + "helper.jsx" + ": " + err.message); } }); } } module.hot.dispose(function (data) { data.makeHot = module.makeHot; data.foundReactClasses = foundReactClasses; }); })(); } }
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
  
  /***/ },
  /* 345 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(346);
  
  /***/ },
  /* 346 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var defaults = __webpack_require__(347);
  	var utils = __webpack_require__(348);
  	var dispatchRequest = __webpack_require__(349);
  	var InterceptorManager = __webpack_require__(358);
  	var isAbsoluteURL = __webpack_require__(359);
  	var combineURLs = __webpack_require__(360);
  	var bind = __webpack_require__(361);
  	var transformData = __webpack_require__(353);
  	
  	function Axios(defaultConfig) {
  	  this.defaults = utils.merge({}, defaultConfig);
  	  this.interceptors = {
  	    request: new InterceptorManager(),
  	    response: new InterceptorManager()
  	  };
  	}
  	
  	Axios.prototype.request = function request(config) {
  	  /*eslint no-param-reassign:0*/
  	  // Allow for axios('example/url'[, config]) a la fetch API
  	  if (typeof config === 'string') {
  	    config = utils.merge({
  	      url: arguments[0]
  	    }, arguments[1]);
  	  }
  	
  	  config = utils.merge(defaults, this.defaults, { method: 'get' }, config);
  	
  	  // Support baseURL config
  	  if (config.baseURL && !isAbsoluteURL(config.url)) {
  	    config.url = combineURLs(config.baseURL, config.url);
  	  }
  	
  	  // Don't allow overriding defaults.withCredentials
  	  config.withCredentials = config.withCredentials || this.defaults.withCredentials;
  	
  	  // Transform request data
  	  config.data = transformData(
  	    config.data,
  	    config.headers,
  	    config.transformRequest
  	  );
  	
  	  // Flatten headers
  	  config.headers = utils.merge(
  	    config.headers.common || {},
  	    config.headers[config.method] || {},
  	    config.headers || {}
  	  );
  	
  	  utils.forEach(
  	    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
  	    function cleanHeaderConfig(method) {
  	      delete config.headers[method];
  	    }
  	  );
  	
  	  // Hook up interceptors middleware
  	  var chain = [dispatchRequest, undefined];
  	  var promise = Promise.resolve(config);
  	
  	  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
  	    chain.unshift(interceptor.fulfilled, interceptor.rejected);
  	  });
  	
  	  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
  	    chain.push(interceptor.fulfilled, interceptor.rejected);
  	  });
  	
  	  while (chain.length) {
  	    promise = promise.then(chain.shift(), chain.shift());
  	  }
  	
  	  return promise;
  	};
  	
  	var defaultInstance = new Axios(defaults);
  	var axios = module.exports = bind(Axios.prototype.request, defaultInstance);
  	module.exports.Axios = Axios;
  	
  	// Expose properties from defaultInstance
  	axios.defaults = defaultInstance.defaults;
  	axios.interceptors = defaultInstance.interceptors;
  	
  	// Factory for creating new instances
  	axios.create = function create(defaultConfig) {
  	  return new Axios(defaultConfig);
  	};
  	
  	// Expose all/spread
  	axios.all = function all(promises) {
  	  return Promise.all(promises);
  	};
  	axios.spread = __webpack_require__(362);
  	
  	// Provide aliases for supported request methods
  	utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
  	  /*eslint func-names:0*/
  	  Axios.prototype[method] = function(url, config) {
  	    return this.request(utils.merge(config || {}, {
  	      method: method,
  	      url: url
  	    }));
  	  };
  	  axios[method] = bind(Axios.prototype[method], defaultInstance);
  	});
  	
  	utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
  	  /*eslint func-names:0*/
  	  Axios.prototype[method] = function(url, data, config) {
  	    return this.request(utils.merge(config || {}, {
  	      method: method,
  	      url: url,
  	      data: data
  	    }));
  	  };
  	  axios[method] = bind(Axios.prototype[method], defaultInstance);
  	});
  
  
  /***/ },
  /* 347 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var utils = __webpack_require__(348);
  	
  	var PROTECTION_PREFIX = /^\)\]\}',?\n/;
  	var DEFAULT_CONTENT_TYPE = {
  	  'Content-Type': 'application/x-www-form-urlencoded'
  	};
  	
  	module.exports = {
  	  transformRequest: [function transformRequest(data, headers) {
  	    if (utils.isFormData(data) || utils.isArrayBuffer(data) || utils.isStream(data)) {
  	      return data;
  	    }
  	    if (utils.isArrayBufferView(data)) {
  	      return data.buffer;
  	    }
  	    if (utils.isObject(data) && !utils.isFile(data) && !utils.isBlob(data)) {
  	      // Set application/json if no Content-Type has been specified
  	      if (!utils.isUndefined(headers)) {
  	        utils.forEach(headers, function processContentTypeHeader(val, key) {
  	          if (key.toLowerCase() === 'content-type') {
  	            headers['Content-Type'] = val;
  	          }
  	        });
  	
  	        if (utils.isUndefined(headers['Content-Type'])) {
  	          headers['Content-Type'] = 'application/json;charset=utf-8';
  	        }
  	      }
  	      return JSON.stringify(data);
  	    }
  	    return data;
  	  }],
  	
  	  transformResponse: [function transformResponse(data) {
  	    /*eslint no-param-reassign:0*/
  	    if (typeof data === 'string') {
  	      data = data.replace(PROTECTION_PREFIX, '');
  	      try {
  	        data = JSON.parse(data);
  	      } catch (e) { /* Ignore */ }
  	    }
  	    return data;
  	  }],
  	
  	  headers: {
  	    common: {
  	      'Accept': 'application/json, text/plain, */*'
  	    },
  	    patch: utils.merge(DEFAULT_CONTENT_TYPE),
  	    post: utils.merge(DEFAULT_CONTENT_TYPE),
  	    put: utils.merge(DEFAULT_CONTENT_TYPE)
  	  },
  	
  	  timeout: 0,
  	
  	  xsrfCookieName: 'XSRF-TOKEN',
  	  xsrfHeaderName: 'X-XSRF-TOKEN',
  	
  	  maxContentLength: -1,
  	
  	  validateStatus: function validateStatus(status) {
  	    return status >= 200 && status < 300;
  	  }
  	};
  
  
  /***/ },
  /* 348 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	/*global toString:true*/
  	
  	// utils is a library of generic helper functions non-specific to axios
  	
  	var toString = Object.prototype.toString;
  	
  	/**
  	 * Determine if a value is an Array
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is an Array, otherwise false
  	 */
  	function isArray(val) {
  	  return toString.call(val) === '[object Array]';
  	}
  	
  	/**
  	 * Determine if a value is an ArrayBuffer
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
  	 */
  	function isArrayBuffer(val) {
  	  return toString.call(val) === '[object ArrayBuffer]';
  	}
  	
  	/**
  	 * Determine if a value is a FormData
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is an FormData, otherwise false
  	 */
  	function isFormData(val) {
  	  return (typeof FormData !== 'undefined') && (val instanceof FormData);
  	}
  	
  	/**
  	 * Determine if a value is a view on an ArrayBuffer
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
  	 */
  	function isArrayBufferView(val) {
  	  var result;
  	  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
  	    result = ArrayBuffer.isView(val);
  	  } else {
  	    result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
  	  }
  	  return result;
  	}
  	
  	/**
  	 * Determine if a value is a String
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is a String, otherwise false
  	 */
  	function isString(val) {
  	  return typeof val === 'string';
  	}
  	
  	/**
  	 * Determine if a value is a Number
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is a Number, otherwise false
  	 */
  	function isNumber(val) {
  	  return typeof val === 'number';
  	}
  	
  	/**
  	 * Determine if a value is undefined
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if the value is undefined, otherwise false
  	 */
  	function isUndefined(val) {
  	  return typeof val === 'undefined';
  	}
  	
  	/**
  	 * Determine if a value is an Object
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is an Object, otherwise false
  	 */
  	function isObject(val) {
  	  return val !== null && typeof val === 'object';
  	}
  	
  	/**
  	 * Determine if a value is a Date
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is a Date, otherwise false
  	 */
  	function isDate(val) {
  	  return toString.call(val) === '[object Date]';
  	}
  	
  	/**
  	 * Determine if a value is a File
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is a File, otherwise false
  	 */
  	function isFile(val) {
  	  return toString.call(val) === '[object File]';
  	}
  	
  	/**
  	 * Determine if a value is a Blob
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is a Blob, otherwise false
  	 */
  	function isBlob(val) {
  	  return toString.call(val) === '[object Blob]';
  	}
  	
  	/**
  	 * Determine if a value is a Function
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is a Function, otherwise false
  	 */
  	function isFunction(val) {
  	  return toString.call(val) === '[object Function]';
  	}
  	
  	/**
  	 * Determine if a value is a Stream
  	 *
  	 * @param {Object} val The value to test
  	 * @returns {boolean} True if value is a Stream, otherwise false
  	 */
  	function isStream(val) {
  	  return isObject(val) && isFunction(val.pipe);
  	}
  	
  	/**
  	 * Trim excess whitespace off the beginning and end of a string
  	 *
  	 * @param {String} str The String to trim
  	 * @returns {String} The String freed of excess whitespace
  	 */
  	function trim(str) {
  	  return str.replace(/^\s*/, '').replace(/\s*$/, '');
  	}
  	
  	/**
  	 * Determine if we're running in a standard browser environment
  	 *
  	 * This allows axios to run in a web worker, and react-native.
  	 * Both environments support XMLHttpRequest, but not fully standard globals.
  	 *
  	 * web workers:
  	 *  typeof window -> undefined
  	 *  typeof document -> undefined
  	 *
  	 * react-native:
  	 *  typeof document.createElement -> undefined
  	 */
  	function isStandardBrowserEnv() {
  	  return (
  	    typeof window !== 'undefined' &&
  	    typeof document !== 'undefined' &&
  	    typeof document.createElement === 'function'
  	  );
  	}
  	
  	/**
  	 * Iterate over an Array or an Object invoking a function for each item.
  	 *
  	 * If `obj` is an Array callback will be called passing
  	 * the value, index, and complete array for each item.
  	 *
  	 * If 'obj' is an Object callback will be called passing
  	 * the value, key, and complete object for each property.
  	 *
  	 * @param {Object|Array} obj The object to iterate
  	 * @param {Function} fn The callback to invoke for each item
  	 */
  	function forEach(obj, fn) {
  	  // Don't bother if no value provided
  	  if (obj === null || typeof obj === 'undefined') {
  	    return;
  	  }
  	
  	  // Force an array if not already something iterable
  	  if (typeof obj !== 'object' && !isArray(obj)) {
  	    /*eslint no-param-reassign:0*/
  	    obj = [obj];
  	  }
  	
  	  if (isArray(obj)) {
  	    // Iterate over array values
  	    for (var i = 0, l = obj.length; i < l; i++) {
  	      fn.call(null, obj[i], i, obj);
  	    }
  	  } else {
  	    // Iterate over object keys
  	    for (var key in obj) {
  	      if (obj.hasOwnProperty(key)) {
  	        fn.call(null, obj[key], key, obj);
  	      }
  	    }
  	  }
  	}
  	
  	/**
  	 * Accepts varargs expecting each argument to be an object, then
  	 * immutably merges the properties of each object and returns result.
  	 *
  	 * When multiple objects contain the same key the later object in
  	 * the arguments list will take precedence.
  	 *
  	 * Example:
  	 *
  	 * ```js
  	 * var result = merge({foo: 123}, {foo: 456});
  	 * console.log(result.foo); // outputs 456
  	 * ```
  	 *
  	 * @param {Object} obj1 Object to merge
  	 * @returns {Object} Result of all merge properties
  	 */
  	function merge(/* obj1, obj2, obj3, ... */) {
  	  var result = {};
  	  function assignValue(val, key) {
  	    if (typeof result[key] === 'object' && typeof val === 'object') {
  	      result[key] = merge(result[key], val);
  	    } else {
  	      result[key] = val;
  	    }
  	  }
  	
  	  for (var i = 0, l = arguments.length; i < l; i++) {
  	    forEach(arguments[i], assignValue);
  	  }
  	  return result;
  	}
  	
  	module.exports = {
  	  isArray: isArray,
  	  isArrayBuffer: isArrayBuffer,
  	  isFormData: isFormData,
  	  isArrayBufferView: isArrayBufferView,
  	  isString: isString,
  	  isNumber: isNumber,
  	  isObject: isObject,
  	  isUndefined: isUndefined,
  	  isDate: isDate,
  	  isFile: isFile,
  	  isBlob: isBlob,
  	  isFunction: isFunction,
  	  isStream: isStream,
  	  isStandardBrowserEnv: isStandardBrowserEnv,
  	  forEach: forEach,
  	  merge: merge,
  	  trim: trim
  	};
  
  
  /***/ },
  /* 349 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	/**
  	 * Dispatch a request to the server using whichever adapter
  	 * is supported by the current environment.
  	 *
  	 * @param {object} config The config that is to be used for the request
  	 * @returns {Promise} The Promise to be fulfilled
  	 */
  	module.exports = function dispatchRequest(config) {
  	  return new Promise(function executor(resolve, reject) {
  	    try {
  	      var adapter;
  	
  	      if (typeof config.adapter === 'function') {
  	        // For custom adapter support
  	        adapter = config.adapter;
  	      } else if (typeof XMLHttpRequest !== 'undefined') {
  	        // For browsers use XHR adapter
  	        adapter = __webpack_require__(350);
  	      } else if (typeof process !== 'undefined') {
  	        // For node use HTTP adapter
  	        adapter = __webpack_require__(350);
  	      }
  	
  	      if (typeof adapter === 'function') {
  	        adapter(resolve, reject, config);
  	      }
  	    } catch (e) {
  	      reject(e);
  	    }
  	  });
  	};
  	
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 350 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  	
  	var utils = __webpack_require__(348);
  	var buildURL = __webpack_require__(351);
  	var parseHeaders = __webpack_require__(352);
  	var transformData = __webpack_require__(353);
  	var isURLSameOrigin = __webpack_require__(354);
  	var btoa = (typeof window !== 'undefined' && window.btoa) || __webpack_require__(355);
  	var settle = __webpack_require__(356);
  	
  	module.exports = function xhrAdapter(resolve, reject, config) {
  	  var requestData = config.data;
  	  var requestHeaders = config.headers;
  	
  	  if (utils.isFormData(requestData)) {
  	    delete requestHeaders['Content-Type']; // Let the browser set it
  	  }
  	
  	  var request = new XMLHttpRequest();
  	  var loadEvent = 'onreadystatechange';
  	  var xDomain = false;
  	
  	  // For IE 8/9 CORS support
  	  // Only supports POST and GET calls and doesn't returns the response headers.
  	  // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.
  	  if (process.env.NODE_ENV !== 'test' && typeof window !== 'undefined' && window.XDomainRequest && !('withCredentials' in request) && !isURLSameOrigin(config.url)) {
  	    request = new window.XDomainRequest();
  	    loadEvent = 'onload';
  	    xDomain = true;
  	    request.onprogress = function handleProgress() {};
  	    request.ontimeout = function handleTimeout() {};
  	  }
  	
  	  // HTTP basic authentication
  	  if (config.auth) {
  	    var username = config.auth.username || '';
  	    var password = config.auth.password || '';
  	    requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
  	  }
  	
  	  request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);
  	
  	  // Set the request timeout in MS
  	  request.timeout = config.timeout;
  	
  	  // Listen for ready state
  	  request[loadEvent] = function handleLoad() {
  	    if (!request || (request.readyState !== 4 && !xDomain)) {
  	      return;
  	    }
  	
  	    // The request errored out and we didn't get a response, this will be
  	    // handled by onerror instead
  	    if (request.status === 0) {
  	      return;
  	    }
  	
  	    // Prepare the response
  	    var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
  	    var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
  	    var response = {
  	      data: transformData(
  	        responseData,
  	        responseHeaders,
  	        config.transformResponse
  	      ),
  	      // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)
  	      status: request.status === 1223 ? 204 : request.status,
  	      statusText: request.status === 1223 ? 'No Content' : request.statusText,
  	      headers: responseHeaders,
  	      config: config,
  	      request: request
  	    };
  	
  	    settle(resolve, reject, response);
  	
  	    // Clean up request
  	    request = null;
  	  };
  	
  	  // Handle low level network errors
  	  request.onerror = function handleError() {
  	    // Real errors are hidden from us by the browser
  	    // onerror should only fire if it's a network error
  	    reject(new Error('Network Error'));
  	
  	    // Clean up request
  	    request = null;
  	  };
  	
  	  // Handle timeout
  	  request.ontimeout = function handleTimeout() {
  	    var err = new Error('timeout of ' + config.timeout + 'ms exceeded');
  	    err.timeout = config.timeout;
  	    err.code = 'ECONNABORTED';
  	    reject(err);
  	
  	    // Clean up request
  	    request = null;
  	  };
  	
  	  // Add xsrf header
  	  // This is only done if running in a standard browser environment.
  	  // Specifically not if we're in a web worker, or react-native.
  	  if (utils.isStandardBrowserEnv()) {
  	    var cookies = __webpack_require__(357);
  	
  	    // Add xsrf header
  	    var xsrfValue = config.withCredentials || isURLSameOrigin(config.url) ?
  	        cookies.read(config.xsrfCookieName) :
  	        undefined;
  	
  	    if (xsrfValue) {
  	      requestHeaders[config.xsrfHeaderName] = xsrfValue;
  	    }
  	  }
  	
  	  // Add headers to the request
  	  if ('setRequestHeader' in request) {
  	    utils.forEach(requestHeaders, function setRequestHeader(val, key) {
  	      if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
  	        // Remove Content-Type if data is undefined
  	        delete requestHeaders[key];
  	      } else {
  	        // Otherwise add header to the request
  	        request.setRequestHeader(key, val);
  	      }
  	    });
  	  }
  	
  	  // Add withCredentials to request if needed
  	  if (config.withCredentials) {
  	    request.withCredentials = true;
  	  }
  	
  	  // Add responseType to request if needed
  	  if (config.responseType) {
  	    try {
  	      request.responseType = config.responseType;
  	    } catch (e) {
  	      if (request.responseType !== 'json') {
  	        throw e;
  	      }
  	    }
  	  }
  	
  	  // Handle progress if needed
  	  if (config.progress) {
  	    if (config.method === 'post' || config.method === 'put') {
  	      request.upload.addEventListener('progress', config.progress);
  	    } else if (config.method === 'get') {
  	      request.addEventListener('progress', config.progress);
  	    }
  	  }
  	
  	  if (requestData === undefined) {
  	    requestData = null;
  	  }
  	
  	  // Send the request
  	  request.send(requestData);
  	};
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(17)))
  
  /***/ },
  /* 351 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var utils = __webpack_require__(348);
  	
  	function encode(val) {
  	  return encodeURIComponent(val).
  	    replace(/%40/gi, '@').
  	    replace(/%3A/gi, ':').
  	    replace(/%24/g, '$').
  	    replace(/%2C/gi, ',').
  	    replace(/%20/g, '+').
  	    replace(/%5B/gi, '[').
  	    replace(/%5D/gi, ']');
  	}
  	
  	/**
  	 * Build a URL by appending params to the end
  	 *
  	 * @param {string} url The base of the url (e.g., http://www.google.com)
  	 * @param {object} [params] The params to be appended
  	 * @returns {string} The formatted url
  	 */
  	module.exports = function buildURL(url, params, paramsSerializer) {
  	  /*eslint no-param-reassign:0*/
  	  if (!params) {
  	    return url;
  	  }
  	
  	  var serializedParams;
  	  if (paramsSerializer) {
  	    serializedParams = paramsSerializer(params);
  	  } else {
  	    var parts = [];
  	
  	    utils.forEach(params, function serialize(val, key) {
  	      if (val === null || typeof val === 'undefined') {
  	        return;
  	      }
  	
  	      if (utils.isArray(val)) {
  	        key = key + '[]';
  	      }
  	
  	      if (!utils.isArray(val)) {
  	        val = [val];
  	      }
  	
  	      utils.forEach(val, function parseValue(v) {
  	        if (utils.isDate(v)) {
  	          v = v.toISOString();
  	        } else if (utils.isObject(v)) {
  	          v = JSON.stringify(v);
  	        }
  	        parts.push(encode(key) + '=' + encode(v));
  	      });
  	    });
  	
  	    serializedParams = parts.join('&');
  	  }
  	
  	  if (serializedParams) {
  	    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
  	  }
  	
  	  return url;
  	};
  	
  
  
  /***/ },
  /* 352 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var utils = __webpack_require__(348);
  	
  	/**
  	 * Parse headers into an object
  	 *
  	 * ```
  	 * Date: Wed, 27 Aug 2014 08:58:49 GMT
  	 * Content-Type: application/json
  	 * Connection: keep-alive
  	 * Transfer-Encoding: chunked
  	 * ```
  	 *
  	 * @param {String} headers Headers needing to be parsed
  	 * @returns {Object} Headers parsed into an object
  	 */
  	module.exports = function parseHeaders(headers) {
  	  var parsed = {};
  	  var key;
  	  var val;
  	  var i;
  	
  	  if (!headers) { return parsed; }
  	
  	  utils.forEach(headers.split('\n'), function parser(line) {
  	    i = line.indexOf(':');
  	    key = utils.trim(line.substr(0, i)).toLowerCase();
  	    val = utils.trim(line.substr(i + 1));
  	
  	    if (key) {
  	      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
  	    }
  	  });
  	
  	  return parsed;
  	};
  
  
  /***/ },
  /* 353 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var utils = __webpack_require__(348);
  	
  	/**
  	 * Transform the data for a request or a response
  	 *
  	 * @param {Object|String} data The data to be transformed
  	 * @param {Array} headers The headers for the request or response
  	 * @param {Array|Function} fns A single function or Array of functions
  	 * @returns {*} The resulting transformed data
  	 */
  	module.exports = function transformData(data, headers, fns) {
  	  /*eslint no-param-reassign:0*/
  	  utils.forEach(fns, function transform(fn) {
  	    data = fn(data, headers);
  	  });
  	
  	  return data;
  	};
  
  
  /***/ },
  /* 354 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var utils = __webpack_require__(348);
  	
  	module.exports = (
  	  utils.isStandardBrowserEnv() ?
  	
  	  // Standard browser envs have full support of the APIs needed to test
  	  // whether the request URL is of the same origin as current location.
  	  (function standardBrowserEnv() {
  	    var msie = /(msie|trident)/i.test(navigator.userAgent);
  	    var urlParsingNode = document.createElement('a');
  	    var originURL;
  	
  	    /**
  	    * Parse a URL to discover it's components
  	    *
  	    * @param {String} url The URL to be parsed
  	    * @returns {Object}
  	    */
  	    function resolveURL(url) {
  	      var href = url;
  	
  	      if (msie) {
  	        // IE needs attribute set twice to normalize properties
  	        urlParsingNode.setAttribute('href', href);
  	        href = urlParsingNode.href;
  	      }
  	
  	      urlParsingNode.setAttribute('href', href);
  	
  	      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
  	      return {
  	        href: urlParsingNode.href,
  	        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
  	        host: urlParsingNode.host,
  	        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
  	        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
  	        hostname: urlParsingNode.hostname,
  	        port: urlParsingNode.port,
  	        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
  	                  urlParsingNode.pathname :
  	                  '/' + urlParsingNode.pathname
  	      };
  	    }
  	
  	    originURL = resolveURL(window.location.href);
  	
  	    /**
  	    * Determine if a URL shares the same origin as the current location
  	    *
  	    * @param {String} requestURL The URL to test
  	    * @returns {boolean} True if URL shares the same origin, otherwise false
  	    */
  	    return function isURLSameOrigin(requestURL) {
  	      var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
  	      return (parsed.protocol === originURL.protocol &&
  	            parsed.host === originURL.host);
  	    };
  	  })() :
  	
  	  // Non standard browser envs (web workers, react-native) lack needed support.
  	  (function nonStandardBrowserEnv() {
  	    return function isURLSameOrigin() {
  	      return true;
  	    };
  	  })()
  	);
  
  
  /***/ },
  /* 355 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js
  	
  	var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
  	
  	function E() {
  	  this.message = 'String contains an invalid character';
  	}
  	E.prototype = new Error;
  	E.prototype.code = 5;
  	E.prototype.name = 'InvalidCharacterError';
  	
  	function btoa(input) {
  	  var str = String(input);
  	  var output = '';
  	  for (
  	    // initialize result and counter
  	    var block, charCode, idx = 0, map = chars;
  	    // if the next str index does not exist:
  	    //   change the mapping table to "="
  	    //   check if d has no fractional digits
  	    str.charAt(idx | 0) || (map = '=', idx % 1);
  	    // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
  	    output += map.charAt(63 & block >> 8 - idx % 1 * 8)
  	  ) {
  	    charCode = str.charCodeAt(idx += 3 / 4);
  	    if (charCode > 0xFF) {
  	      throw new E();
  	    }
  	    block = block << 8 | charCode;
  	  }
  	  return output;
  	}
  	
  	module.exports = btoa;
  
  
  /***/ },
  /* 356 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	/**
  	 * Resolve or reject a Promise based on response status.
  	 *
  	 * @param {Function} resolve A function that resolves the promise.
  	 * @param {Function} reject A function that rejects the promise.
  	 * @param {object} response The response.
  	 */
  	module.exports = function settle(resolve, reject, response) {
  	  var validateStatus = response.config.validateStatus;
  	  // Note: status is not exposed by XDomainRequest
  	  if (!response.status || !validateStatus || validateStatus(response.status)) {
  	    resolve(response);
  	  } else {
  	    reject(response);
  	  }
  	};
  
  
  /***/ },
  /* 357 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var utils = __webpack_require__(348);
  	
  	module.exports = (
  	  utils.isStandardBrowserEnv() ?
  	
  	  // Standard browser envs support document.cookie
  	  (function standardBrowserEnv() {
  	    return {
  	      write: function write(name, value, expires, path, domain, secure) {
  	        var cookie = [];
  	        cookie.push(name + '=' + encodeURIComponent(value));
  	
  	        if (utils.isNumber(expires)) {
  	          cookie.push('expires=' + new Date(expires).toGMTString());
  	        }
  	
  	        if (utils.isString(path)) {
  	          cookie.push('path=' + path);
  	        }
  	
  	        if (utils.isString(domain)) {
  	          cookie.push('domain=' + domain);
  	        }
  	
  	        if (secure === true) {
  	          cookie.push('secure');
  	        }
  	
  	        document.cookie = cookie.join('; ');
  	      },
  	
  	      read: function read(name) {
  	        var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
  	        return (match ? decodeURIComponent(match[3]) : null);
  	      },
  	
  	      remove: function remove(name) {
  	        this.write(name, '', Date.now() - 86400000);
  	      }
  	    };
  	  })() :
  	
  	  // Non standard browser env (web workers, react-native) lack needed support.
  	  (function nonStandardBrowserEnv() {
  	    return {
  	      write: function write() {},
  	      read: function read() { return null; },
  	      remove: function remove() {}
  	    };
  	  })()
  	);
  
  
  /***/ },
  /* 358 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var utils = __webpack_require__(348);
  	
  	function InterceptorManager() {
  	  this.handlers = [];
  	}
  	
  	/**
  	 * Add a new interceptor to the stack
  	 *
  	 * @param {Function} fulfilled The function to handle `then` for a `Promise`
  	 * @param {Function} rejected The function to handle `reject` for a `Promise`
  	 *
  	 * @return {Number} An ID used to remove interceptor later
  	 */
  	InterceptorManager.prototype.use = function use(fulfilled, rejected) {
  	  this.handlers.push({
  	    fulfilled: fulfilled,
  	    rejected: rejected
  	  });
  	  return this.handlers.length - 1;
  	};
  	
  	/**
  	 * Remove an interceptor from the stack
  	 *
  	 * @param {Number} id The ID that was returned by `use`
  	 */
  	InterceptorManager.prototype.eject = function eject(id) {
  	  if (this.handlers[id]) {
  	    this.handlers[id] = null;
  	  }
  	};
  	
  	/**
  	 * Iterate over all the registered interceptors
  	 *
  	 * This method is particularly useful for skipping over any
  	 * interceptors that may have become `null` calling `eject`.
  	 *
  	 * @param {Function} fn The function to call for each interceptor
  	 */
  	InterceptorManager.prototype.forEach = function forEach(fn) {
  	  utils.forEach(this.handlers, function forEachHandler(h) {
  	    if (h !== null) {
  	      fn(h);
  	    }
  	  });
  	};
  	
  	module.exports = InterceptorManager;
  
  
  /***/ },
  /* 359 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	/**
  	 * Determines whether the specified URL is absolute
  	 *
  	 * @param {string} url The URL to test
  	 * @returns {boolean} True if the specified URL is absolute, otherwise false
  	 */
  	module.exports = function isAbsoluteURL(url) {
  	  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
  	  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
  	  // by any combination of letters, digits, plus, period, or hyphen.
  	  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
  	};
  
  
  /***/ },
  /* 360 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	/**
  	 * Creates a new URL by combining the specified URLs
  	 *
  	 * @param {string} baseURL The base URL
  	 * @param {string} relativeURL The relative URL
  	 * @returns {string} The combined URL
  	 */
  	module.exports = function combineURLs(baseURL, relativeURL) {
  	  return baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '');
  	};
  
  
  /***/ },
  /* 361 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	module.exports = function bind(fn, thisArg) {
  	  return function wrap() {
  	    var args = new Array(arguments.length);
  	    for (var i = 0; i < args.length; i++) {
  	      args[i] = arguments[i];
  	    }
  	    return fn.apply(thisArg, args);
  	  };
  	};
  
  
  /***/ },
  /* 362 */
  /***/ function(module, exports) {
  
  	'use strict';
  	
  	/**
  	 * Syntactic sugar for invoking a function and expanding an array for arguments.
  	 *
  	 * Common use case would be to use `Function.prototype.apply`.
  	 *
  	 *  ```js
  	 *  function f(x, y, z) {}
  	 *  var args = [1, 2, 3];
  	 *  f.apply(null, args);
  	 *  ```
  	 *
  	 * With `spread` this example can be re-written.
  	 *
  	 *  ```js
  	 *  spread(function(x, y, z) {})([1, 2, 3]);
  	 *  ```
  	 *
  	 * @param {Function} callback
  	 * @returns {Function}
  	 */
  	module.exports = function spread(callback) {
  	  return function wrap(arr) {
  	    return callback.apply(null, arr);
  	  };
  	};
  
  
  /***/ },
  /* 363 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	
  	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  	
  	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	
  	var _react = __webpack_require__(141);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  	
  	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  	
  	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* jshint strict: true */
  	/* jshint esversion: 6 */
  	
  	/**
  	 * @author oliviercolonna@gmail.com
  	 * Copyright(c) 2016 Olivier Colonna
  	 * MIT Licensed
  	 *
  	 * ReactVideo
  	 */
  	
  	var ReactVideo = function (_React$Component) {
  	  _inherits(ReactVideo, _React$Component);
  	
  	  function ReactVideo(props) {
  	    _classCallCheck(this, ReactVideo);
  	
  	    var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(ReactVideo).call(this, props));
  	
  	    _this.state = {
  	      volume: 1,
  	      playbackRate: 1
  	    };
  	    return _this;
  	  }
  	
  	  /**
  	   * The canPlayType() method checks if the browser can play the specified audio/video type.
  	   * @param {string} format, common values (video/mp4, video/webm, audio/mpeg, audio/ogg, audio/mp4).
  	   * @return {string} format, common values, including codecs.
  	   */
  	
  	  _createClass(ReactVideo, [{
  	    key: 'canPlayType',
  	    value: function canPlayType(format) {
  	      return this.refs.ReactVideo.canPlayType(format);
  	    }
  	
  	    /**
  	     * return if the media is currently playing.
  	     * @return {Boolean} playing, return the playback playing status.
  	     */
  	
  	  }, {
  	    key: 'isPlaying',
  	    value: function isPlaying() {
  	      var isPaused = Boolean(this.refs.ReactVideo.paused);
  	      return !isPaused;
  	    }
  	
  	    /**
  	     * get whenever the media playback has ended.
  	     * @return {Boolean} ended, return the playback ended status.
  	     */
  	
  	  }, {
  	    key: 'isEnded',
  	    value: function isEnded() {
  	      return Boolean(this.refs.ReactVideo.ended);
  	    }
  	
  	    /**
  	     * Will begin loading the media immediately.
  	     */
  	
  	  }, {
  	    key: 'load',
  	    value: function load() {
  	      this.refs.ReactVideo.load();
  	    }
  	
  	    /**
  	     * Starts or resumes media playback.
  	     */
  	
  	  }, {
  	    key: 'play',
  	    value: function play() {
  	      this.refs.ReactVideo.play();
  	    }
  	
  	    /**
  	     * Pauses media playback.
  	     */
  	
  	  }, {
  	    key: 'pause',
  	    value: function pause() {
  	      this.refs.ReactVideo.pause();
  	    }
  	
  	    /**
  	     * Stops media playback and returns to the beginning.
  	     */
  	
  	  }, {
  	    key: 'stop',
  	    value: function stop() {
  	      var me = this;
  	
  	      me.setCurrentTime(0);
  	      me.pause();
  	    }
  	
  	    /**
  	     * The duration property returns the length of the current audio/video, in seconds.
  	     * @return {number} duration, A Number representing the length of the video, in seconds. If no video is set, "NaN" (Not-a-Number) is returned.
  	     */
  	
  	  }, {
  	    key: 'getDuration',
  	    value: function getDuration() {
  	      return this.refs.ReactVideo.duration;
  	    }
  	
  	    /**
  	     * Returns the current time of the media, in seconds.
  	     * @return {Number} seconds.
  	     */
  	
  	  }, {
  	    key: 'getCurrentTime',
  	    value: function getCurrentTime() {
  	      return this.refs.ReactVideo.currentTime;
  	    }
  	
  	    /**
  	     * Retun the current volume of the video.
  	     * @return {number} Must be a number between 0.0 and 1.0.
  	     */
  	
  	  }, {
  	    key: 'getVolume',
  	    value: function getVolume() {
  	      return this.state.volume;
  	    }
  	
  	    /**
  	     * The TimeRanges object represents the user's buffered ranges of the video.
  	     * @return {object} TimeRanges Object.
  	     * length - get the number of buffered ranges in the audio/video
  	     * start(index) - get the start position of a buffered range
  	     * end(index) - get the end position of a buffered range
  	     */
  	
  	  }, {
  	    key: 'getBuffered',
  	    value: function getBuffered() {
  	      var vid = this.refs.ReactVideo;
  	
  	      return vid.buffured;
  	    }
  	
  	    /**
  	     * @return {number} Number, the current playback speed.
  	     */
  	
  	  }, {
  	    key: 'getPlaybackRate',
  	    value: function getPlaybackRate() {
  	      return this.state.playbackRate;
  	    }
  	
  	    /**
  	     * Returns the value of url.
  	     * @return {string} return the src value of the video.
  	     */
  	
  	  }, {
  	    key: 'getUrl',
  	    value: function getUrl() {
  	      return this.refs.ReactVideo.url;
  	    }
  	
  	    /**
  	     * Set the current time of the media.
  	     * @param {Number} time The time, in seconds.
  	     * @return {Number} return time in seconds.
  	     */
  	
  	  }, {
  	    key: 'setCurrentTime',
  	    value: function setCurrentTime(time) {
  	      this.refs.ReactVideo.currentTime = time;
  	
  	      return time;
  	    }
  	
  	    /**
  	     * Set the current volume of the media.
  	     * @param {number} volume, Specifies the current volume of the audio/video. Must be a number between 0.0 and 1.0. 
  	     */
  	
  	  }, {
  	    key: 'setVolume',
  	    value: function setVolume(volume) {
  	      this.setState({ volume: volume });
  	
  	      this.refs.ReactVideo.volume = this.getVolume();
  	    }
  	
  	    /**
  	     * Set video to play in slow motion.
  	     * The playbackRate property sets the current playback speed of the video.
  	     * @param {number} rate, Indicates the current playback speed of the video.
  	     * @example
  	     * 1.0 is normal speed
  	     * 0.5 is half speed (slower)
  	     * 2.0 is double speed (faster)
  	     * -1.0 is backwards, normal speed
  	     * -0.5 is backwards, half speed
  	     */
  	
  	  }, {
  	    key: 'setPlaybackRate',
  	    value: function setPlaybackRate(rate) {
  	      this.setState({
  	        playbackRate: rate
  	      });
  	
  	      this.setState({
  	        playbackRate: this.getPlaybackRate()
  	      });
  	    }
  	
  	    /**
  	     * Toggles the media playback state.
  	     */
  	
  	  }, {
  	    key: 'toggle',
  	    value: function toggle() {
  	      if (this.isPlaying()) {
  	        this.pause();
  	      } else {
  	        this.play();
  	      }
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      var _props = this.props;
  	      var notSupportedMessage = _props.notSupportedMessage;
  	      var cls = _props.cls;
  	      var source = _props.source;
  	
  	      return _react2.default.createElement(
  	        'video',
  	        _extends({ ref: 'ReactVideo', className: 'video ' + cls }, this.props),
  	        notSupportedMessage,
  	        source.map(function (item, i) {
  	          return _react2.default.createElement('source', { src: item.src, type: item.type, key: i });
  	        })
  	      );
  	    }
  	  }]);
  	
  	  return ReactVideo;
  	}(_react2.default.Component);
  	
  	exports.default = ReactVideo;
  	
  	ReactVideo.defaultProps = {
  	  cls: void 0,
  	  autoPlay: false,
  	  src: void 0,
  	  source: [],
  	  controls: true,
  	  loop: false,
  	  muted: false,
  	  posterUrl: void 0,
  	  preload: true,
  	  width: null,
  	  height: null,
  	  notSupportedMessage: 'Sorry your browser does not support HTML5 video',
  	  style: {}
  	};
  	
  	ReactVideo.propTypes = {
  	  cls: _react2.default.PropTypes.string,
  	  autoPause: _react2.default.PropTypes.bool,
  	  autoResume: _react2.default.PropTypes.bool,
  	  source: _react2.default.PropTypes.arrayOf(_react2.default.PropTypes.object),
  	  src: _react2.default.PropTypes.string,
  	  controls: _react2.default.PropTypes.bool,
  	  loop: _react2.default.PropTypes.bool,
  	  posterUrl: _react2.default.PropTypes.string,
  	  preload: _react2.default.PropTypes.bool,
  	  style: _react2.default.PropTypes.object,
  	  notSupportedMessage: _react2.default.PropTypes.string
  	};
  
  /***/ },
  /* 364 */
  /***/ function(module, exports) {
  
  	// removed by extract-text-webpack-plugin
  
  /***/ },
  /* 365 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(module) {/* REACT HOT LOADER */ if (true) { (function () { var ReactHotAPI = __webpack_require__(79), RootInstanceProvider = __webpack_require__(87), ReactMount = __webpack_require__(89), React = __webpack_require__(141); module.makeHot = module.hot.data ? module.hot.data.makeHot : ReactHotAPI(function () { return RootInstanceProvider.getRootInstances(ReactMount); }, React); })(); } try { (function () {
  	
  	'use strict';
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	
  	var _getPrototypeOf = __webpack_require__(248);
  	
  	var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
  	
  	var _classCallCheck2 = __webpack_require__(274);
  	
  	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
  	
  	var _createClass2 = __webpack_require__(275);
  	
  	var _createClass3 = _interopRequireDefault(_createClass2);
  	
  	var _possibleConstructorReturn2 = __webpack_require__(279);
  	
  	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
  	
  	var _inherits2 = __webpack_require__(326);
  	
  	var _inherits3 = _interopRequireDefault(_inherits2);
  	
  	var _react = __webpack_require__(141);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	var _jquery = __webpack_require__(341);
  	
  	var _jquery2 = _interopRequireDefault(_jquery);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	var Iframe = function (_Component) {
  	  (0, _inherits3.default)(Iframe, _Component);
  	
  	  function Iframe() {
  	    (0, _classCallCheck3.default)(this, Iframe);
  	    return (0, _possibleConstructorReturn3.default)(this, (Iframe.__proto__ || (0, _getPrototypeOf2.default)(Iframe)).apply(this, arguments));
  	  }
  	
  	  (0, _createClass3.default)(Iframe, [{
  	    key: 'render',
  	    value: function render() {
  	      return _react2.default.createElement(
  	        'div',
  	        null,
  	        'test'
  	      );
  	    }
  	  }]);
  	  return Iframe;
  	}(_react.Component);
  	
  	exports.default = Iframe;
  	
  	/* REACT HOT LOADER */ }).call(this); } finally { if (true) { (function () { var foundReactClasses = module.hot.data && module.hot.data.foundReactClasses || false; if (module.exports && module.makeHot) { var makeExportsHot = __webpack_require__(337); if (makeExportsHot(module, __webpack_require__(141))) { foundReactClasses = true; } var shouldAcceptModule = true && foundReactClasses; if (shouldAcceptModule) { module.hot.accept(function (err) { if (err) { console.error("Cannot apply hot update to " + "index.jsx" + ": " + err.message); } }); } } module.hot.dispose(function (data) { data.makeHot = module.makeHot; data.foundReactClasses = foundReactClasses; }); })(); } }
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
  
  /***/ }
  ]);
  //# sourceMappingURL=index.js.map