text: /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  /******/
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /*!*************************!*\
    !*** ./static/main.jsx ***!
    \*************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  
  	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; }; }();
  
  	var _Tweet = __webpack_require__(/*! ./components/Tweet */ 1);
  
  	var _Tweet2 = _interopRequireDefault(_Tweet);
  
  	var _TweetList = __webpack_require__(/*! ./components/TweetList */ 11);
  
  	var _TweetList2 = _interopRequireDefault(_TweetList);
  
  	var _reactCookie = __webpack_require__(/*! react-cookie */ 13);
  
  	var _reactCookie2 = _interopRequireDefault(_reactCookie);
  
  	var _Tactions = __webpack_require__(/*! ./actions/Tactions */ 2);
  
  	var _Tactions2 = _interopRequireDefault(_Tactions);
  
  	var _TStore = __webpack_require__(/*! ./stores/TStore */ 17);
  
  	var _TStore2 = _interopRequireDefault(_TStore);
  
  	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; }
  
  	_Tactions2.default.getAllTweets();
  
  	var getAppState = function getAppState() {
  	  return { tweetslist: _TStore2.default.getAll() };
  	};
  
  	var Main = function (_React$Component) {
  	  _inherits(Main, _React$Component);
  
  	  function Main(props) {
  	    _classCallCheck(this, Main);
  
  	    var _this = _possibleConstructorReturn(this, (Main.__proto__ || Object.getPrototypeOf(Main)).call(this, props));
  
  	    _this.state = getAppState();
  	    _this._onChange = _this._onChange.bind(_this);
  	    return _this;
  	  }
  	  // function to pull tweets
  
  
  	  _createClass(Main, [{
  	    key: "componentDidMount",
  	    value: function componentDidMount() {
  	      _TStore2.default.addChangeListener(this._onChange);
  	    }
  	  }, {
  	    key: "componentWillUnMount",
  	    value: function componentWillUnMount() {
  	      _TStore2.default.removeChangeListener(this._onChange);
  	    }
  	  }, {
  	    key: "_onChange",
  	    value: function _onChange() {
  	      this.setState(getAppState());
  	    }
  	  }, {
  	    key: "render",
  	    value: function render() {
  	      return React.createElement(
  	        "div",
  	        null,
  	        React.createElement(_Tweet2.default, null),
  	        React.createElement(_TweetList2.default, { tweet: this.state.tweetslist })
  	      );
  	    }
  	  }]);
  
  	  return Main;
  	}(React.Component);
  
  	var documentReady = function documentReady() {
  	  ReactDOM.render(React.createElement(Main, null), document.getElementById('react'));
  	};
  
  	$(documentReady);
  
  /***/ },
  /* 1 */
  /*!*************************************!*\
    !*** ./static/components/Tweet.jsx ***!
    \*************************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  
  	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; }; }();
  
  	var _Tactions = __webpack_require__(/*! ../actions/Tactions */ 2);
  
  	var _Tactions2 = _interopRequireDefault(_Tactions);
  
  	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; }
  
  	var Tweet = function (_React$Component) {
  	  _inherits(Tweet, _React$Component);
  
  	  function Tweet() {
  	    _classCallCheck(this, Tweet);
  
  	    return _possibleConstructorReturn(this, (Tweet.__proto__ || Object.getPrototypeOf(Tweet)).apply(this, arguments));
  	  }
  
  	  _createClass(Tweet, [{
  	    key: "sendTweet",
  	    value: function sendTweet(event) {
  	      event.preventDefault();
  	      // this.props.sendTweet(this.refs.tweetTextArea.value);
  	      _Tactions2.default.sendTweet(this.refs.tweetTextArea.value, localStorage.getItem("sessionid"));
  	      this.refs.tweetTextArea.value = '';
  	    }
  	  }, {
  	    key: "render",
  	    value: function render() {
  	      return React.createElement(
  	        "div",
  	        { className: "row" },
  	        React.createElement(
  	          "nav",
  	          null,
  	          React.createElement(
  	            "div",
  	            { className: "nav-wrapper" },
  	            React.createElement(
  	              "a",
  	              { href: "#", className: "brand-logo" },
  	              "APP"
  	            ),
  	            React.createElement(
  	              "ul",
  	              { id: "nav-mobile", className: "right hide-on-med-and-down" },
  	              React.createElement(
  	                "li",
  	                null,
  	                React.createElement(
  	                  "a",
  	                  { href: "/profile" },
  	                  "Profile"
  	                )
  	              ),
  	              React.createElement(
  	                "li",
  	                null,
  	                React.createElement(
  	                  "a",
  	                  { href: "/logout" },
  	                  "Logout"
  	                )
  	              )
  	            )
  	          )
  	        ),
  	        React.createElement(
  	          "form",
  	          { onSubmit: this.sendTweet.bind(this) },
  	          React.createElement(
  	            "div",
  	            { className: "input-field" },
  	            React.createElement("textarea", { ref: "tweetTextArea", className: "materialize-textarea" }),
  	            React.createElement(
  	              "label",
  	              null,
  	              "How you doing?"
  	            ),
  	            React.createElement(
  	              "button",
  	              { className: "btn waves-effect waves-light right" },
  	              "Tweet now ",
  	              React.createElement(
  	                "i",
  	                { className: "material-icons right" },
  	                "send"
  	              )
  	            )
  	          )
  	        )
  	      );
  	    }
  	  }]);
  
  	  return Tweet;
  	}(React.Component);
  
  	exports.default = Tweet;
  
  /***/ },
  /* 2 */
  /*!*************************************!*\
    !*** ./static/actions/Tactions.jsx ***!
    \*************************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  
  	var _API = __webpack_require__(/*! ../API */ 3);
  
  	var _API2 = _interopRequireDefault(_API);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.default = {
  	  getAllTweets: function getAllTweets() {
  	    console.log(1, "Tactions for tweets");
  	    _API2.default.getAllTweets();
  	  },
  	  sendTweet: function sendTweet(body, user) {
  	    _API2.default.addTweet(body, user);
  	  }
  	};
  
  /***/ },
  /* 3 */
  /*!************************!*\
    !*** ./static/API.jsx ***!
    \************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  
  	var _SActions = __webpack_require__(/*! ./actions/SActions */ 4);
  
  	var _SActions2 = _interopRequireDefault(_SActions);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.default = {
  	  getAllTweets: function getAllTweets() {
  	    console.log(2, "API get tweets");
  
  	    var str = "/api/v2/tweets/" + localStorage.getItem("sessionid");
  	    $.getJSON(str, function (tweetModels) {
  	      var t = tweetModels;
  	      console.log(5, t);
  	      _SActions2.default.receivedTweets(t);
  	    });
  	  },
  	  addTweet: function addTweet(body, user) {
  	    $.ajax({
  	      url: '/api/v2/tweets',
  	      contentType: 'application/json',
  	      type: 'POST',
  	      data: JSON.stringify({
  	        'username': user,
  	        'body': body
  	      }),
  	      success: function success() {
  	        (function (rawTweet) {
  	          return _SActions2.default.receivedTweet({ tweetedby: user, body: tweet, timestamp: Date.now });
  	        });
  	      },
  	      error: function error() {
  	        return console.log("Failed");
  	      }
  	    });
  	  }
  	};
  
  /***/ },
  /* 4 */
  /*!*************************************!*\
    !*** ./static/actions/SActions.jsx ***!
    \*************************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  
  	var _dispatcher = __webpack_require__(/*! ../dispatcher */ 5);
  
  	var _dispatcher2 = _interopRequireDefault(_dispatcher);
  
  	var _constants = __webpack_require__(/*! ../constants */ 10);
  
  	var _constants2 = _interopRequireDefault(_constants);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.default = {
  	  receivedTweets: function receivedTweets(rawTweets) {
  	    console.log(3, rawTweets);
  	    _dispatcher2.default.dispatch({
  	      actionType: _constants2.default.RECIEVED_TWEETS,
  	      rawTweets: rawTweets
  	    });
  	  },
  	  receivedTweet: function recievedTweet(rawTweet) {
  	    _dispatcher2.default.dispatch({
  	      actionType: _constants2.default.RECIEVED_TWEET,
  	      rawTweet: rawTweet
  	    });
  	  }
  	};
  
  /***/ },
  /* 5 */
  /*!*******************************!*\
    !*** ./static/dispatcher.jsx ***!
    \*******************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  
  	var _flux = __webpack_require__(/*! flux */ 6);
  
  	var _flux2 = _interopRequireDefault(_flux);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	exports.default = new _flux2.default.Dispatcher();
  
  /***/ },
  /* 6 */
  /*!*************************!*\
    !*** ./~/flux/index.js ***!
    \*************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * Copyright (c) 2014-2015, Facebook, Inc.
  	 * All rights reserved.
  	 *
  	 * This source code is licensed under the BSD-style license found in the
  	 * LICENSE file in the root directory of this source tree. An additional grant
  	 * of patent rights can be found in the PATENTS file in the same directory.
  	 */
  
  	module.exports.Dispatcher = __webpack_require__(/*! ./lib/Dispatcher */ 7);
  
  
  /***/ },
  /* 7 */
  /*!**********************************!*\
    !*** ./~/flux/lib/Dispatcher.js ***!
    \**********************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {/**
  	 * Copyright (c) 2014-2015, Facebook, Inc.
  	 * All rights reserved.
  	 *
  	 * This source code is licensed under the BSD-style license found in the
  	 * LICENSE file in the root directory of this source tree. An additional grant
  	 * of patent rights can be found in the PATENTS file in the same directory.
  	 *
  	 * @providesModule Dispatcher
  	 *
  	 * @preventMunge
  	 */
  
  	'use strict';
  
  	exports.__esModule = true;
  
  	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
  
  	var invariant = __webpack_require__(/*! fbjs/lib/invariant */ 9);
  
  	var _prefix = 'ID_';
  
  	/**
  	 * Dispatcher is used to broadcast payloads to registered callbacks. This is
  	 * different from generic pub-sub systems in two ways:
  	 *
  	 *   1) Callbacks are not subscribed to particular events. Every payload is
  	 *      dispatched to every registered callback.
  	 *   2) Callbacks can be deferred in whole or part until other callbacks have
  	 *      been executed.
  	 *
  	 * For example, consider this hypothetical flight destination form, which
  	 * selects a default city when a country is selected:
  	 *
  	 *   var flightDispatcher = new Dispatcher();
  	 *
  	 *   // Keeps track of which country is selected
  	 *   var CountryStore = {country: null};
  	 *
  	 *   // Keeps track of which city is selected
  	 *   var CityStore = {city: null};
  	 *
  	 *   // Keeps track of the base flight price of the selected city
  	 *   var FlightPriceStore = {price: null}
  	 *
  	 * When a user changes the selected city, we dispatch the payload:
  	 *
  	 *   flightDispatcher.dispatch({
  	 *     actionType: 'city-update',
  	 *     selectedCity: 'paris'
  	 *   });
  	 *
  	 * This payload is digested by `CityStore`:
  	 *
  	 *   flightDispatcher.register(function(payload) {
  	 *     if (payload.actionType === 'city-update') {
  	 *       CityStore.city = payload.selectedCity;
  	 *     }
  	 *   });
  	 *
  	 * When the user selects a country, we dispatch the payload:
  	 *
  	 *   flightDispatcher.dispatch({
  	 *     actionType: 'country-update',
  	 *     selectedCountry: 'australia'
  	 *   });
  	 *
  	 * This payload is digested by both stores:
  	 *
  	 *   CountryStore.dispatchToken = flightDispatcher.register(function(payload) {
  	 *     if (payload.actionType === 'country-update') {
  	 *       CountryStore.country = payload.selectedCountry;
  	 *     }
  	 *   });
  	 *
  	 * When the callback to update `CountryStore` is registered, we save a reference
  	 * to the returned token. Using this token with `waitFor()`, we can guarantee
  	 * that `CountryStore` is updated before the callback that updates `CityStore`
  	 * needs to query its data.
  	 *
  	 *   CityStore.dispatchToken = flightDispatcher.register(function(payload) {
  	 *     if (payload.actionType === 'country-update') {
  	 *       // `CountryStore.country` may not be updated.
  	 *       flightDispatcher.waitFor([CountryStore.dispatchToken]);
  	 *       // `CountryStore.country` is now guaranteed to be updated.
  	 *
  	 *       // Select the default city for the new country
  	 *       CityStore.city = getDefaultCityForCountry(CountryStore.country);
  	 *     }
  	 *   });
  	 *
  	 * The usage of `waitFor()` can be chained, for example:
  	 *
  	 *   FlightPriceStore.dispatchToken =
  	 *     flightDispatcher.register(function(payload) {
  	 *       switch (payload.actionType) {
  	 *         case 'country-update':
  	 *         case 'city-update':
  	 *           flightDispatcher.waitFor([CityStore.dispatchToken]);
  	 *           FlightPriceStore.price =
  	 *             getFlightPriceStore(CountryStore.country, CityStore.city);
  	 *           break;
  	 *     }
  	 *   });
  	 *
  	 * The `country-update` payload will be guaranteed to invoke the stores'
  	 * registered callbacks in order: `CountryStore`, `CityStore`, then
  	 * `FlightPriceStore`.
  	 */
  
  	var Dispatcher = (function () {
  	  function Dispatcher() {
  	    _classCallCheck(this, Dispatcher);
  
  	    this._callbacks = {};
  	    this._isDispatching = false;
  	    this._isHandled = {};
  	    this._isPending = {};
  	    this._lastID = 1;
  	  }
  
  	  /**
  	   * Registers a callback to be invoked with every dispatched payload. Returns
  	   * a token that can be used with `waitFor()`.
  	   */
  
  	  Dispatcher.prototype.register = function register(callback) {
  	    var id = _prefix + this._lastID++;
  	    this._callbacks[id] = callback;
  	    return id;
  	  };
  
  	  /**
  	   * Removes a callback based on its token.
  	   */
  
  	  Dispatcher.prototype.unregister = function unregister(id) {
  	    !this._callbacks[id] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Dispatcher.unregister(...): `%s` does not map to a registered callback.', id) : invariant(false) : undefined;
  	    delete this._callbacks[id];
  	  };
  
  	  /**
  	   * Waits for the callbacks specified to be invoked before continuing execution
  	   * of the current callback. This method should only be used by a callback in
  	   * response to a dispatched payload.
  	   */
  
  	  Dispatcher.prototype.waitFor = function waitFor(ids) {
  	    !this._isDispatching ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Dispatcher.waitFor(...): Must be invoked while dispatching.') : invariant(false) : undefined;
  	    for (var ii = 0; ii < ids.length; ii++) {
  	      var id = ids[ii];
  	      if (this._isPending[id]) {
  	        !this._isHandled[id] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Dispatcher.waitFor(...): Circular dependency detected while ' + 'waiting for `%s`.', id) : invariant(false) : undefined;
  	        continue;
  	      }
  	      !this._callbacks[id] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Dispatcher.waitFor(...): `%s` does not map to a registered callback.', id) : invariant(false) : undefined;
  	      this._invokeCallback(id);
  	    }
  	  };
  
  	  /**
  	   * Dispatches a payload to all registered callbacks.
  	   */
  
  	  Dispatcher.prototype.dispatch = function dispatch(payload) {
  	    !!this._isDispatching ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Dispatch.dispatch(...): Cannot dispatch in the middle of a dispatch.') : invariant(false) : undefined;
  	    this._startDispatching(payload);
  	    try {
  	      for (var id in this._callbacks) {
  	        if (this._isPending[id]) {
  	          continue;
  	        }
  	        this._invokeCallback(id);
  	      }
  	    } finally {
  	      this._stopDispatching();
  	    }
  	  };
  
  	  /**
  	   * Is this Dispatcher currently dispatching.
  	   */
  
  	  Dispatcher.prototype.isDispatching = function isDispatching() {
  	    return this._isDispatching;
  	  };
  
  	  /**
  	   * Call the callback stored with the given id. Also do some internal
  	   * bookkeeping.
  	   *
  	   * @internal
  	   */
  
  	  Dispatcher.prototype._invokeCallback = function _invokeCallback(id) {
  	    this._isPending[id] = true;
  	    this._callbacks[id](this._pendingPayload);
  	    this._isHandled[id] = true;
  	  };
  
  	  /**
  	   * Set up bookkeeping needed when dispatching.
  	   *
  	   * @internal
  	   */
  
  	  Dispatcher.prototype._startDispatching = function _startDispatching(payload) {
  	    for (var id in this._callbacks) {
  	      this._isPending[id] = false;
  	      this._isHandled[id] = false;
  	    }
  	    this._pendingPayload = payload;
  	    this._isDispatching = true;
  	  };
  
  	  /**
  	   * Clear bookkeeping used for dispatching.
  	   *
  	   * @internal
  	   */
  
  	  Dispatcher.prototype._stopDispatching = function _stopDispatching() {
  	    delete this._pendingPayload;
  	    this._isDispatching = false;
  	  };
  
  	  return Dispatcher;
  	})();
  
  	module.exports = Dispatcher;
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(/*! ./~/process/browser.js */ 8)))
  
  /***/ },
  /* 8 */
  /*!******************************!*\
    !*** ./~/process/browser.js ***!
    \******************************/
  /***/ function(module, exports) {
  
  	// shim for using process in browser
  	var process = module.exports = {};
  
  	// cached from whatever global is present so that test runners that stub it
  	// don't break things.  But we need to wrap it in a try catch in case it is
  	// wrapped in strict mode code which doesn't define any globals.  It's inside a
  	// function because try/catches deoptimize in certain engines.
  
  	var cachedSetTimeout;
  	var cachedClearTimeout;
  
  	function defaultSetTimout() {
  	    throw new Error('setTimeout has not been defined');
  	}
  	function defaultClearTimeout () {
  	    throw new Error('clearTimeout has not been defined');
  	}
  	(function () {
  	    try {
  	        if (typeof setTimeout === 'function') {
  	            cachedSetTimeout = setTimeout;
  	        } else {
  	            cachedSetTimeout = defaultSetTimout;
  	        }
  	    } catch (e) {
  	        cachedSetTimeout = defaultSetTimout;
  	    }
  	    try {
  	        if (typeof clearTimeout === 'function') {
  	            cachedClearTimeout = clearTimeout;
  	        } else {
  	            cachedClearTimeout = defaultClearTimeout;
  	        }
  	    } catch (e) {
  	        cachedClearTimeout = defaultClearTimeout;
  	    }
  	} ())
  	function runTimeout(fun) {
  	    if (cachedSetTimeout === setTimeout) {
  	        //normal enviroments in sane situations
  	        return setTimeout(fun, 0);
  	    }
  	    // if setTimeout wasn't available but was latter defined
  	    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
  	        cachedSetTimeout = setTimeout;
  	        return setTimeout(fun, 0);
  	    }
  	    try {
  	        // when when somebody has screwed with setTimeout but no I.E. maddness
  	        return cachedSetTimeout(fun, 0);
  	    } catch(e){
  	        try {
  	            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
  	            return cachedSetTimeout.call(null, fun, 0);
  	        } catch(e){
  	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
  	            return cachedSetTimeout.call(this, fun, 0);
  	        }
  	    }
  
  
  	}
  	function runClearTimeout(marker) {
  	    if (cachedClearTimeout === clearTimeout) {
  	        //normal enviroments in sane situations
  	        return clearTimeout(marker);
  	    }
  	    // if clearTimeout wasn't available but was latter defined
  	    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
  	        cachedClearTimeout = clearTimeout;
  	        return clearTimeout(marker);
  	    }
  	    try {
  	        // when when somebody has screwed with setTimeout but no I.E. maddness
  	        return cachedClearTimeout(marker);
  	    } catch (e){
  	        try {
  	            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
  	            return cachedClearTimeout.call(null, marker);
  	        } catch (e){
  	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
  	            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
  	            return cachedClearTimeout.call(this, marker);
  	        }
  	    }
  
  
  
  	}
  	var queue = [];
  	var draining = false;
  	var currentQueue;
  	var queueIndex = -1;
  
  	function cleanUpNextTick() {
  	    if (!draining || !currentQueue) {
  	        return;
  	    }
  	    draining = false;
  	    if (currentQueue.length) {
  	        queue = currentQueue.concat(queue);
  	    } else {
  	        queueIndex = -1;
  	    }
  	    if (queue.length) {
  	        drainQueue();
  	    }
  	}
  
  	function drainQueue() {
  	    if (draining) {
  	        return;
  	    }
  	    var timeout = runTimeout(cleanUpNextTick);
  	    draining = true;
  
  	    var len = queue.length;
  	    while(len) {
  	        currentQueue = queue;
  	        queue = [];
  	        while (++queueIndex < len) {
  	            if (currentQueue) {
  	                currentQueue[queueIndex].run();
  	            }
  	        }
  	        queueIndex = -1;
  	        len = queue.length;
  	    }
  	    currentQueue = null;
  	    draining = false;
  	    runClearTimeout(timeout);
  	}
  
  	process.nextTick = function (fun) {
  	    var args = new Array(arguments.length - 1);
  	    if (arguments.length > 1) {
  	        for (var i = 1; i < arguments.length; i++) {
  	            args[i - 1] = arguments[i];
  	        }
  	    }
  	    queue.push(new Item(fun, args));
  	    if (queue.length === 1 && !draining) {
  	        runTimeout(drainQueue);
  	    }
  	};
  
  	// v8 likes predictible objects
  	function Item(fun, array) {
  	    this.fun = fun;
  	    this.array = array;
  	}
  	Item.prototype.run = function () {
  	    this.fun.apply(null, this.array);
  	};
  	process.title = 'browser';
  	process.browser = true;
  	process.env = {};
  	process.argv = [];
  	process.version = ''; // empty string to avoid regexp issues
  	process.versions = {};
  
  	function noop() {}
  
  	process.on = noop;
  	process.addListener = noop;
  	process.once = noop;
  	process.off = noop;
  	process.removeListener = noop;
  	process.removeAllListeners = noop;
  	process.emit = noop;
  
  	process.binding = function (name) {
  	    throw new Error('process.binding is not supported');
  	};
  
  	process.cwd = function () { return '/' };
  	process.chdir = function (dir) {
  	    throw new Error('process.chdir is not supported');
  	};
  	process.umask = function() { return 0; };
  
  
  /***/ },
  /* 9 */
  /*!*********************************!*\
    !*** ./~/fbjs/lib/invariant.js ***!
    \*********************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {/**
  	 * Copyright (c) 2013-present, Facebook, Inc.
  	 * All rights reserved.
  	 *
  	 * This source code is licensed under the BSD-style license found in the
  	 * LICENSE file in the root directory of this source tree. An additional grant
  	 * of patent rights can be found in the PATENTS file in the same directory.
  	 *
  	 */
  
  	'use strict';
  
  	/**
  	 * Use invariant() to assert state which your program assumes to be true.
  	 *
  	 * Provide sprintf-style format (only %s is supported) and arguments
  	 * to provide information about what broke and what you were
  	 * expecting.
  	 *
  	 * The invariant message will be stripped in production, but the invariant
  	 * will remain to ensure logic does not differ in production.
  	 */
  
  	var validateFormat = function validateFormat(format) {};
  
  	if (process.env.NODE_ENV !== 'production') {
  	  validateFormat = function validateFormat(format) {
  	    if (format === undefined) {
  	      throw new Error('invariant requires an error message argument');
  	    }
  	  };
  	}
  
  	function invariant(condition, format, a, b, c, d, e, f) {
  	  validateFormat(format);
  
  	  if (!condition) {
  	    var error;
  	    if (format === undefined) {
  	      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
  	    } else {
  	      var args = [a, b, c, d, e, f];
  	      var argIndex = 0;
  	      error = new Error(format.replace(/%s/g, function () {
  	        return args[argIndex++];
  	      }));
  	      error.name = 'Invariant Violation';
  	    }
  
  	    error.framesToPop = 1; // we don't care about invariant's own frame
  	    throw error;
  	  }
  	}
  
  	module.exports = invariant;
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(/*! ./~/process/browser.js */ 8)))
  
  /***/ },
  /* 10 */
  /*!******************************!*\
    !*** ./static/constants.jsx ***!
    \******************************/
  /***/ function(module, exports) {
  
  	'use strict';
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	exports.default = {
  	  RECIEVED_TWEETS: 'RECIEVED_TWEETS',
  	  RECIEVED_TWEET: 'RECIEVED_TWEET'
  	};
  
  /***/ },
  /* 11 */
  /*!*****************************************!*\
    !*** ./static/components/TweetList.jsx ***!
    \*****************************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  
  	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; }; }();
  
  	var _templatetweet = __webpack_require__(/*! ./templatetweet */ 12);
  
  	var _templatetweet2 = _interopRequireDefault(_templatetweet);
  
  	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; }
  
  	var TweetList = function (_React$Component) {
  	  _inherits(TweetList, _React$Component);
  
  	  function TweetList() {
  	    _classCallCheck(this, TweetList);
  
  	    return _possibleConstructorReturn(this, (TweetList.__proto__ || Object.getPrototypeOf(TweetList)).apply(this, arguments));
  	  }
  
  	  _createClass(TweetList, [{
  	    key: "render",
  	    value: function render() {
  	      var tweetlist = this.props.tweet.map(function (tweet) {
  	        return React.createElement(_templatetweet2.default, _extends({ key: tweet.timestamp }, tweet));
  	      });
  	      return React.createElement(
  	        "div",
  	        null,
  	        React.createElement(
  	          "ul",
  	          { className: "collection" },
  	          tweetlist
  	        )
  	      );
  	    }
  	  }]);
  
  	  return TweetList;
  	}(React.Component);
  
  	exports.default = TweetList;
  
  /***/ },
  /* 12 */
  /*!*********************************************!*\
    !*** ./static/components/templatetweet.jsx ***!
    \*********************************************/
  /***/ function(module, exports) {
  
  	"use strict";
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  
  	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; }; }();
  
  	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; }
  
  	var Tweettemplate = function (_React$Component) {
  	  _inherits(Tweettemplate, _React$Component);
  
  	  function Tweettemplate() {
  	    _classCallCheck(this, Tweettemplate);
  
  	    return _possibleConstructorReturn(this, (Tweettemplate.__proto__ || Object.getPrototypeOf(Tweettemplate)).apply(this, arguments));
  	  }
  
  	  _createClass(Tweettemplate, [{
  	    key: "render",
  	    value: function render() {
  	      return React.createElement(
  	        "li",
  	        { className: "collection-item avatar" },
  	        React.createElement(
  	          "i",
  	          { className: "material-icons circle red" },
  	          "play_arrow"
  	        ),
  	        React.createElement(
  	          "span",
  	          { className: "title" },
  	          this.props.tweetedby
  	        ),
  	        React.createElement(
  	          "p",
  	          null,
  	          this.props.body
  	        ),
  	        React.createElement(
  	          "p",
  	          null,
  	          this.props.updatedate
  	        )
  	      );
  	    }
  	  }]);
  
  	  return Tweettemplate;
  	}(React.Component);
  
  	exports.default = Tweettemplate;
  
  /***/ },
  /* 13 */
  /*!****************************************!*\
    !*** ./~/react-cookie/build/cookie.js ***!
    \****************************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  
  	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 _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  	exports.load = load;
  	exports.select = select;
  	exports.save = save;
  	exports.remove = remove;
  	exports.setRawCookie = setRawCookie;
  	exports.plugToRequest = plugToRequest;
  
  	var _cookie = __webpack_require__(/*! cookie */ 14);
  
  	var _cookie2 = _interopRequireDefault(_cookie);
  
  	var _objectAssign = __webpack_require__(/*! object-assign */ 15);
  
  	var _objectAssign2 = _interopRequireDefault(_objectAssign);
  
  	var _isNode = __webpack_require__(/*! is-node */ 16);
  
  	var _isNode2 = _interopRequireDefault(_isNode);
  
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  	var _rawCookie = {};
  	var _res = undefined;
  
  	function _isResWritable() {
  	  return _res && !_res.headersSent;
  	}
  
  	function load(name, doNotParse, opt) {
  	  var cookies = _isNode2.default ? _rawCookie : _cookie2.default.parse(document.cookie, opt);
  	  var cookieVal = cookies && cookies[name];
  
  	  if (typeof doNotParse === 'undefined') {
  	    doNotParse = !cookieVal || cookieVal[0] !== '{' && cookieVal[0] !== '[';
  	  }
  
  	  if (!doNotParse) {
  	    try {
  	      cookieVal = JSON.parse(cookieVal);
  	    } catch (e) {
  	      // Not serialized object
  	    }
  	  }
  
  	  return cookieVal;
  	}
  
  	function select(regex) {
  	  var cookies = _isNode2.default ? _rawCookie : _cookie2.default.parse(document.cookie);
  
  	  if (!cookies) {
  	    return {};
  	  }
  
  	  if (!regex) {
  	    return cookies;
  	  }
  
  	  return Object.keys(cookies).reduce(function (accumulator, name) {
  	    if (!regex.test(name)) {
  	      return accumulator;
  	    }
  
  	    var newCookie = {};
  	    newCookie[name] = cookies[name];
  	    return (0, _objectAssign2.default)({}, accumulator, newCookie);
  	  }, {});
  	}
  
  	function save(name, val, opt) {
  	  _rawCookie[name] = val;
  
  	  // allow you to work with cookies as objects.
  	  if ((typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object') {
  	    _rawCookie[name] = JSON.stringify(val);
  	  }
  
  	  // Cookies only work in the browser
  	  if (!_isNode2.default) {
  	    document.cookie = _cookie2.default.serialize(name, _rawCookie[name], opt);
  	  }
  
  	  if (_isResWritable() && _res.cookie) {
  	    var expressOpt = _extends({}, opt);
  	    if (expressOpt.maxAge) {
  	      // the standard for maxAge is seconds but express uses milliseconds
  	      expressOpt.maxAge = opt.maxAge * 1000;
  	    }
  
  	    _res.cookie(name, val, opt);
  	  }
  	}
  
  	function remove(name, opt) {
  	  delete _rawCookie[name];
  
  	  if (typeof opt === 'undefined') {
  	    opt = {};
  	  } else if (typeof opt === 'string') {
  	    // Will be deprecated in future versions
  	    opt = { path: opt };
  	  } else {
  	    // Prevent mutation of opt below
  	    opt = (0, _objectAssign2.default)({}, opt);
  	  }
  
  	  if (typeof document !== 'undefined') {
  	    opt.expires = new Date(1970, 1, 1, 0, 0, 1);
  	    opt.maxAge = 0;
  	    document.cookie = _cookie2.default.serialize(name, '', opt);
  	  }
  
  	  if (_isResWritable() && _res.clearCookie) {
  	    _res.clearCookie(name, opt);
  	  }
  	}
  
  	function setRawCookie(rawCookie) {
  	  if (rawCookie) {
  	    _rawCookie = _cookie2.default.parse(rawCookie);
  	  } else {
  	    _rawCookie = {};
  	  }
  	}
  
  	function plugToRequest(req, res) {
  	  if (req.cookie) {
  	    _rawCookie = req.cookie;
  	  } else if (req.cookies) {
  	    _rawCookie = req.cookies;
  	  } else if (req.headers && req.headers.cookie) {
  	    setRawCookie(req.headers.cookie);
  	  } else {
  	    _rawCookie = {};
  	  }
  
  	  _res = res;
  
  	  return function unplug() {
  	    _res = null;
  	    _rawCookie = {};
  	  };
  	}
  
  	exports.default = {
  	  setRawCookie: setRawCookie,
  	  load: load,
  	  select: select,
  	  save: save,
  	  remove: remove,
  	  plugToRequest: plugToRequest
  	};
  
  /***/ },
  /* 14 */
  /*!******************************************!*\
    !*** ./~/react-cookie/~/cookie/index.js ***!
    \******************************************/
  /***/ function(module, exports) {
  
  	/*!
  	 * cookie
  	 * Copyright(c) 2012-2014 Roman Shtylman
  	 * Copyright(c) 2015 Douglas Christopher Wilson
  	 * MIT Licensed
  	 */
  
  	'use strict';
  
  	/**
  	 * Module exports.
  	 * @public
  	 */
  
  	exports.parse = parse;
  	exports.serialize = serialize;
  
  	/**
  	 * Module variables.
  	 * @private
  	 */
  
  	var decode = decodeURIComponent;
  	var encode = encodeURIComponent;
  	var pairSplitRegExp = /; */;
  
  	/**
  	 * RegExp to match field-content in RFC 7230 sec 3.2
  	 *
  	 * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
  	 * field-vchar   = VCHAR / obs-text
  	 * obs-text      = %x80-FF
  	 */
  
  	var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
  
  	/**
  	 * Parse a cookie header.
  	 *
  	 * Parse the given cookie header string into an object
  	 * The object has the various cookies as keys(names) => values
  	 *
  	 * @param {string} str
  	 * @param {object} [options]
  	 * @return {object}
  	 * @public
  	 */
  
  	function parse(str, options) {
  	  if (typeof str !== 'string') {
  	    throw new TypeError('argument str must be a string');
  	  }
  
  	  var obj = {}
  	  var opt = options || {};
  	  var pairs = str.split(pairSplitRegExp);
  	  var dec = opt.decode || decode;
  
  	  for (var i = 0; i < pairs.length; i++) {
  	    var pair = pairs[i];
  	    var eq_idx = pair.indexOf('=');
  
  	    // skip things that don't look like key=value
  	    if (eq_idx < 0) {
  	      continue;
  	    }
  
  	    var key = pair.substr(0, eq_idx).trim()
  	    var val = pair.substr(++eq_idx, pair.length).trim();
  
  	    // quoted values
  	    if ('"' == val[0]) {
  	      val = val.slice(1, -1);
  	    }
  
  	    // only assign once
  	    if (undefined == obj[key]) {
  	      obj[key] = tryDecode(val, dec);
  	    }
  	  }
  
  	  return obj;
  	}
  
  	/**
  	 * Serialize data into a cookie header.
  	 *
  	 * Serialize the a name value pair into a cookie string suitable for
  	 * http headers. An optional options object specified cookie parameters.
  	 *
  	 * serialize('foo', 'bar', { httpOnly: true })
  	 *   => "foo=bar; httpOnly"
  	 *
  	 * @param {string} name
  	 * @param {string} val
  	 * @param {object} [options]
  	 * @return {string}
  	 * @public
  	 */
  
  	function serialize(name, val, options) {
  	  var opt = options || {};
  	  var enc = opt.encode || encode;
  
  	  if (typeof enc !== 'function') {
  	    throw new TypeError('option encode is invalid');
  	  }
  
  	  if (!fieldContentRegExp.test(name)) {
  	    throw new TypeError('argument name is invalid');
  	  }
  
  	  var value = enc(val);
  
  	  if (value && !fieldContentRegExp.test(value)) {
  	    throw new TypeError('argument val is invalid');
  	  }
  
  	  var str = name + '=' + value;
  
  	  if (null != opt.maxAge) {
  	    var maxAge = opt.maxAge - 0;
  	    if (isNaN(maxAge)) throw new Error('maxAge should be a Number');
  	    str += '; Max-Age=' + Math.floor(maxAge);
  	  }
  
  	  if (opt.domain) {
  	    if (!fieldContentRegExp.test(opt.domain)) {
  	      throw new TypeError('option domain is invalid');
  	    }
  
  	    str += '; Domain=' + opt.domain;
  	  }
  
  	  if (opt.path) {
  	    if (!fieldContentRegExp.test(opt.path)) {
  	      throw new TypeError('option path is invalid');
  	    }
  
  	    str += '; Path=' + opt.path;
  	  }
  
  	  if (opt.expires) {
  	    if (typeof opt.expires.toUTCString !== 'function') {
  	      throw new TypeError('option expires is invalid');
  	    }
  
  	    str += '; Expires=' + opt.expires.toUTCString();
  	  }
  
  	  if (opt.httpOnly) {
  	    str += '; HttpOnly';
  	  }
  
  	  if (opt.secure) {
  	    str += '; Secure';
  	  }
  
  	  if (opt.sameSite) {
  	    var sameSite = typeof opt.sameSite === 'string'
  	      ? opt.sameSite.toLowerCase() : opt.sameSite;
  
  	    switch (sameSite) {
  	      case true:
  	        str += '; SameSite=Strict';
  	        break;
  	      case 'lax':
  	        str += '; SameSite=Lax';
  	        break;
  	      case 'strict':
  	        str += '; SameSite=Strict';
  	        break;
  	      default:
  	        throw new TypeError('option sameSite is invalid');
  	    }
  	  }
  
  	  return str;
  	}
  
  	/**
  	 * Try decoding a string using a decoding function.
  	 *
  	 * @param {string} str
  	 * @param {function} decode
  	 * @private
  	 */
  
  	function tryDecode(str, decode) {
  	  try {
  	    return decode(str);
  	  } catch (e) {
  	    return str;
  	  }
  	}
  
  
  /***/ },
  /* 15 */
  /*!**********************************!*\
    !*** ./~/object-assign/index.js ***!
    \**********************************/
  /***/ function(module, exports) {
  
  	/*
  	object-assign
  	(c) Sindre Sorhus
  	@license MIT
  	*/
  
  	'use strict';
  	/* eslint-disable no-unused-vars */
  	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  	var hasOwnProperty = Object.prototype.hasOwnProperty;
  	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
  
  	function toObject(val) {
  		if (val === null || val === undefined) {
  			throw new TypeError('Object.assign cannot be called with null or undefined');
  		}
  
  		return Object(val);
  	}
  
  	function shouldUseNative() {
  		try {
  			if (!Object.assign) {
  				return false;
  			}
  
  			// Detect buggy property enumeration order in older V8 versions.
  
  			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
  			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
  			test1[5] = 'de';
  			if (Object.getOwnPropertyNames(test1)[0] === '5') {
  				return false;
  			}
  
  			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  			var test2 = {};
  			for (var i = 0; i < 10; i++) {
  				test2['_' + String.fromCharCode(i)] = i;
  			}
  			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
  				return test2[n];
  			});
  			if (order2.join('') !== '0123456789') {
  				return false;
  			}
  
  			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  			var test3 = {};
  			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
  				test3[letter] = letter;
  			});
  			if (Object.keys(Object.assign({}, test3)).join('') !==
  					'abcdefghijklmnopqrst') {
  				return false;
  			}
  
  			return true;
  		} catch (err) {
  			// We don't expect any of the above to throw, but better to be safe.
  			return false;
  		}
  	}
  
  	module.exports = shouldUseNative() ? Object.assign : function (target, source) {
  		var from;
  		var to = toObject(target);
  		var symbols;
  
  		for (var s = 1; s < arguments.length; s++) {
  			from = Object(arguments[s]);
  
  			for (var key in from) {
  				if (hasOwnProperty.call(from, key)) {
  					to[key] = from[key];
  				}
  			}
  
  			if (getOwnPropertySymbols) {
  				symbols = getOwnPropertySymbols(from);
  				for (var i = 0; i < symbols.length; i++) {
  					if (propIsEnumerable.call(from, symbols[i])) {
  						to[symbols[i]] = from[symbols[i]];
  					}
  				}
  			}
  		}
  
  		return to;
  	};
  
  
  /***/ },
  /* 16 */
  /*!****************************!*\
    !*** ./~/is-node/index.js ***!
    \****************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {// Coding standard for this project defined @ https://github.com/MatthewSH/standards/blob/master/JavaScript.md
  	'use strict';
  
  	exports = module.exports = !!(typeof process !== 'undefined' && process.versions && process.versions.node);
  
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(/*! ./~/process/browser.js */ 8)))
  
  /***/ },
  /* 17 */
  /*!**********************************!*\
    !*** ./static/stores/TStore.jsx ***!
    \**********************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  
  	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; }; }();
  
  	var _dispatcher = __webpack_require__(/*! ../dispatcher */ 5);
  
  	var _dispatcher2 = _interopRequireDefault(_dispatcher);
  
  	var _constants = __webpack_require__(/*! ../constants */ 10);
  
  	var _constants2 = _interopRequireDefault(_constants);
  
  	var _events = __webpack_require__(/*! events */ 18);
  
  	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; }
  
  	var _tweets = [];
  	var CHANGE_EVENT = "CHANGE";
  
  	var TweetEventEmitter = function (_EventEmitter) {
  	  _inherits(TweetEventEmitter, _EventEmitter);
  
  	  function TweetEventEmitter() {
  	    _classCallCheck(this, TweetEventEmitter);
  
  	    return _possibleConstructorReturn(this, (TweetEventEmitter.__proto__ || Object.getPrototypeOf(TweetEventEmitter)).apply(this, arguments));
  	  }
  
  	  _createClass(TweetEventEmitter, [{
  	    key: "getAll",
  	    value: function getAll() {
  	      var updatelist = _tweets.map(function (tweet) {
  	        tweet.updatedate = moment(tweet.timestamp).fromNow();
  	        return tweet;
  	      });
  	      return _tweets.reverse();
  	    }
  	  }, {
  	    key: "emitChange",
  	    value: function emitChange() {
  	      this.emit(CHANGE_EVENT);
  	    }
  	  }, {
  	    key: "addChangeListener",
  	    value: function addChangeListener(callback) {
  	      this.on(CHANGE_EVENT, callback);
  	    }
  	  }, {
  	    key: "removeChangeListener",
  	    value: function removeChangeListener(callback) {
  	      this.removeListener(CHANGE_EVENT, callback);
  	    }
  	  }]);
  
  	  return TweetEventEmitter;
  	}(_events.EventEmitter);
  
  	var TStore = new TweetEventEmitter();
  
  	_dispatcher2.default.register(function (action) {
  	  switch (action.actionType) {
  	    case _constants2.default.RECIEVED_TWEETS:
  	      console.log(4, "Tstore for tweets");
  	      _tweets = action.rawTweets;
  	      console.log(6, _tweets[0]);
  	      TStore.emitChange();
  	      break;
  	    case _constants2.default.RECIEVED_TWEET:
  	      _tweets.unshift(action.rawTweet);
  	      TStore.emitChange();
  	      break;
  	    default:
  
  	  }
  	});
  
  	exports.default = TStore;
  
  /***/ },
  /* 18 */
  /*!****************************!*\
    !*** ./~/events/events.js ***!
    \****************************/
  /***/ 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.
  
  	function EventEmitter() {
  	  this._events = this._events || {};
  	  this._maxListeners = this._maxListeners || undefined;
  	}
  	module.exports = EventEmitter;
  
  	// Backwards-compat with node 0.10.x
  	EventEmitter.EventEmitter = EventEmitter;
  
  	EventEmitter.prototype._events = undefined;
  	EventEmitter.prototype._maxListeners = undefined;
  
  	// By default EventEmitters will print a warning if more than 10 listeners are
  	// added to it. This is a useful default which helps finding memory leaks.
  	EventEmitter.defaultMaxListeners = 10;
  
  	// Obviously not all Emitters should be limited to 10. This function allows
  	// that to be increased. Set to zero for unlimited.
  	EventEmitter.prototype.setMaxListeners = function(n) {
  	  if (!isNumber(n) || n < 0 || isNaN(n))
  	    throw TypeError('n must be a positive number');
  	  this._maxListeners = n;
  	  return this;
  	};
  
  	EventEmitter.prototype.emit = function(type) {
  	  var er, handler, len, args, i, listeners;
  
  	  if (!this._events)
  	    this._events = {};
  
  	  // If there is no 'error' event listener then throw.
  	  if (type === 'error') {
  	    if (!this._events.error ||
  	        (isObject(this._events.error) && !this._events.error.length)) {
  	      er = arguments[1];
  	      if (er instanceof Error) {
  	        throw er; // Unhandled 'error' event
  	      } else {
  	        // At least give some kind of context to the user
  	        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
  	        err.context = er;
  	        throw err;
  	      }
  	    }
  	  }
  
  	  handler = this._events[type];
  
  	  if (isUndefined(handler))
  	    return false;
  
  	  if (isFunction(handler)) {
  	    switch (arguments.length) {
  	      // fast cases
  	      case 1:
  	        handler.call(this);
  	        break;
  	      case 2:
  	        handler.call(this, arguments[1]);
  	        break;
  	      case 3:
  	        handler.call(this, arguments[1], arguments[2]);
  	        break;
  	      // slower
  	      default:
  	        args = Array.prototype.slice.call(arguments, 1);
  	        handler.apply(this, args);
  	    }
  	  } else if (isObject(handler)) {
  	    args = Array.prototype.slice.call(arguments, 1);
  	    listeners = handler.slice();
  	    len = listeners.length;
  	    for (i = 0; i < len; i++)
  	      listeners[i].apply(this, args);
  	  }
  
  	  return true;
  	};
  
  	EventEmitter.prototype.addListener = function(type, listener) {
  	  var m;
  
  	  if (!isFunction(listener))
  	    throw TypeError('listener must be a function');
  
  	  if (!this._events)
  	    this._events = {};
  
  	  // To avoid recursion in the case that type === "newListener"! Before
  	  // adding it to the listeners, first emit "newListener".
  	  if (this._events.newListener)
  	    this.emit('newListener', type,
  	              isFunction(listener.listener) ?
  	              listener.listener : listener);
  
  	  if (!this._events[type])
  	    // Optimize the case of one listener. Don't need the extra array object.
  	    this._events[type] = listener;
  	  else if (isObject(this._events[type]))
  	    // If we've already got an array, just append.
  	    this._events[type].push(listener);
  	  else
  	    // Adding the second element, need to change to array.
  	    this._events[type] = [this._events[type], listener];
  
  	  // Check for listener leak
  	  if (isObject(this._events[type]) && !this._events[type].warned) {
  	    if (!isUndefined(this._maxListeners)) {
  	      m = this._maxListeners;
  	    } else {
  	      m = EventEmitter.defaultMaxListeners;
  	    }
  
  	    if (m && m > 0 && this._events[type].length > m) {
  	      this._events[type].warned = true;
  	      console.error('(node) warning: possible EventEmitter memory ' +
  	                    'leak detected. %d listeners added. ' +
  	                    'Use emitter.setMaxListeners() to increase limit.',
  	                    this._events[type].length);
  	      if (typeof console.trace === 'function') {
  	        // not supported in IE 10
  	        console.trace();
  	      }
  	    }
  	  }
  
  	  return this;
  	};
  
  	EventEmitter.prototype.on = EventEmitter.prototype.addListener;
  
  	EventEmitter.prototype.once = function(type, listener) {
  	  if (!isFunction(listener))
  	    throw TypeError('listener must be a function');
  
  	  var fired = false;
  
  	  function g() {
  	    this.removeListener(type, g);
  
  	    if (!fired) {
  	      fired = true;
  	      listener.apply(this, arguments);
  	    }
  	  }
  
  	  g.listener = listener;
  	  this.on(type, g);
  
  	  return this;
  	};
  
  	// emits a 'removeListener' event iff the listener was removed
  	EventEmitter.prototype.removeListener = function(type, listener) {
  	  var list, position, length, i;
  
  	  if (!isFunction(listener))
  	    throw TypeError('listener must be a function');
  
  	  if (!this._events || !this._events[type])
  	    return this;
  
  	  list = this._events[type];
  	  length = list.length;
  	  position = -1;
  
  	  if (list === listener ||
  	      (isFunction(list.listener) && list.listener === listener)) {
  	    delete this._events[type];
  	    if (this._events.removeListener)
  	      this.emit('removeListener', type, listener);
  
  	  } else if (isObject(list)) {
  	    for (i = length; i-- > 0;) {
  	      if (list[i] === listener ||
  	          (list[i].listener && list[i].listener === listener)) {
  	        position = i;
  	        break;
  	      }
  	    }
  
  	    if (position < 0)
  	      return this;
  
  	    if (list.length === 1) {
  	      list.length = 0;
  	      delete this._events[type];
  	    } else {
  	      list.splice(position, 1);
  	    }
  
  	    if (this._events.removeListener)
  	      this.emit('removeListener', type, listener);
  	  }
  
  	  return this;
  	};
  
  	EventEmitter.prototype.removeAllListeners = function(type) {
  	  var key, listeners;
  
  	  if (!this._events)
  	    return this;
  
  	  // not listening for removeListener, no need to emit
  	  if (!this._events.removeListener) {
  	    if (arguments.length === 0)
  	      this._events = {};
  	    else if (this._events[type])
  	      delete this._events[type];
  	    return this;
  	  }
  
  	  // emit removeListener for all listeners on all events
  	  if (arguments.length === 0) {
  	    for (key in this._events) {
  	      if (key === 'removeListener') continue;
  	      this.removeAllListeners(key);
  	    }
  	    this.removeAllListeners('removeListener');
  	    this._events = {};
  	    return this;
  	  }
  
  	  listeners = this._events[type];
  
  	  if (isFunction(listeners)) {
  	    this.removeListener(type, listeners);
  	  } else if (listeners) {
  	    // LIFO order
  	    while (listeners.length)
  	      this.removeListener(type, listeners[listeners.length - 1]);
  	  }
  	  delete this._events[type];
  
  	  return this;
  	};
  
  	EventEmitter.prototype.listeners = function(type) {
  	  var ret;
  	  if (!this._events || !this._events[type])
  	    ret = [];
  	  else if (isFunction(this._events[type]))
  	    ret = [this._events[type]];
  	  else
  	    ret = this._events[type].slice();
  	  return ret;
  	};
  
  	EventEmitter.prototype.listenerCount = function(type) {
  	  if (this._events) {
  	    var evlistener = this._events[type];
  
  	    if (isFunction(evlistener))
  	      return 1;
  	    else if (evlistener)
  	      return evlistener.length;
  	  }
  	  return 0;
  	};
  
  	EventEmitter.listenerCount = function(emitter, type) {
  	  return emitter.listenerCount(type);
  	};
  
  	function isFunction(arg) {
  	  return typeof arg === 'function';
  	}
  
  	function isNumber(arg) {
  	  return typeof arg === 'number';
  	}
  
  	function isObject(arg) {
  	  return typeof arg === 'object' && arg !== null;
  	}
  
  	function isUndefined(arg) {
  	  return arg === void 0;
  	}
  
  
  /***/ }
  /******/ ]);
  //# sourceMappingURL=bundle.js.map
  