Removed GopherJS, basic frontend completed, need backend changes for

torrent storage

torrent-project/node_modules/material-ui/node_modules/recompose/.npmignore

@@ -0,0 +1 @@
+/**/__tests__

torrent-project/node_modules/material-ui/node_modules/recompose/README.md

@@ -0,0 +1,6 @@
+recompose
+=========
+
+[![npm version](https://img.shields.io/npm/v/recompose.svg?style=flat-square)](https://www.npmjs.com/package/recompose)
+
+Recompose is a React utility belt for function components and higher-order components. See the [GitHub project page](https://github.com/acdlite/recompose) for more information.

torrent-project/node_modules/material-ui/node_modules/recompose/baconObservableConfig.js

@@ -0,0 +1,56 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _symbolObservable = require('symbol-observable');
+
+var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
+
+var _baconjs = require('baconjs');
+
+var _baconjs2 = _interopRequireDefault(_baconjs);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var config = {
+  fromESObservable: function fromESObservable(observable) {
+    return _baconjs2.default.fromBinder(function (sink) {
+      var _observable$subscribe = observable.subscribe({
+        next: function next(val) {
+          return sink(new _baconjs2.default.Next(val));
+        },
+        error: function error(err) {
+          return sink(new _baconjs2.default.Error(err));
+        },
+        complete: function complete() {
+          return sink(new _baconjs2.default.End());
+        }
+      }),
+          unsubscribe = _observable$subscribe.unsubscribe;
+
+      return unsubscribe;
+    });
+  },
+  toESObservable: function toESObservable(stream) {
+    var _ref;
+
+    return _ref = {
+      subscribe: function subscribe(observer) {
+        var unsubscribe = stream.subscribe(function (event) {
+          if (event.hasValue()) {
+            observer.next(event.value());
+          } else if (event.isError()) {
+            observer.error(event.error);
+          } else if (event.isEnd()) {
+            observer.complete();
+          }
+        });
+        return { unsubscribe: unsubscribe };
+      }
+    }, _ref[_symbolObservable2.default] = function () {
+      return this;
+    }, _ref;
+  }
+};
+
+exports.default = config;

torrent-project/node_modules/material-ui/node_modules/recompose/branch.js

@@ -0,0 +1,42 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var identity = function identity(Component) {
+  return Component;
+};
+
+var branch = function branch(test, left) {
+  var right = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : identity;
+  return function (BaseComponent) {
+    var leftFactory = void 0;
+    var rightFactory = void 0;
+    var Branch = function Branch(props) {
+      if (test(props)) {
+        leftFactory = leftFactory || (0, _react.createFactory)(left(BaseComponent));
+        return leftFactory(props);
+      }
+      rightFactory = rightFactory || (0, _react.createFactory)(right(BaseComponent));
+      return rightFactory(props);
+    };
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'branch'))(Branch);
+    }
+    return Branch;
+  };
+};
+
+exports.default = branch;

torrent-project/node_modules/material-ui/node_modules/recompose/componentFromProp.js

@@ -0,0 +1,21 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+var _omit = require('./utils/omit');
+
+var _omit2 = _interopRequireDefault(_omit);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var componentFromProp = function componentFromProp(propName) {
+  var Component = function Component(props) {
+    return (0, _react.createElement)(props[propName], (0, _omit2.default)(props, [propName]));
+  };
+  Component.displayName = 'componentFromProp(' + propName + ')';
+  return Component;
+};
+
+exports.default = componentFromProp;

torrent-project/node_modules/material-ui/node_modules/recompose/componentFromStream.js

@@ -0,0 +1,104 @@
+'use strict';
+
+exports.__esModule = true;
+exports.componentFromStreamWithConfig = undefined;
+
+var _react = require('react');
+
+var _changeEmitter = require('change-emitter');
+
+var _symbolObservable = require('symbol-observable');
+
+var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
+
+var _setObservableConfig = require('./setObservableConfig');
+
+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 componentFromStreamWithConfig = exports.componentFromStreamWithConfig = function componentFromStreamWithConfig(config) {
+  return function (propsToVdom) {
+    return function (_Component) {
+      _inherits(ComponentFromStream, _Component);
+
+      function ComponentFromStream() {
+        var _config$fromESObserva;
+
+        var _temp, _this, _ret;
+
+        _classCallCheck(this, ComponentFromStream);
+
+        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = { vdom: null }, _this.propsEmitter = (0, _changeEmitter.createChangeEmitter)(), _this.props$ = config.fromESObservable((_config$fromESObserva = {
+          subscribe: function subscribe(observer) {
+            var unsubscribe = _this.propsEmitter.listen(function (props) {
+              if (props) {
+                observer.next(props);
+              } else {
+                observer.complete();
+              }
+            });
+            return { unsubscribe: unsubscribe };
+          }
+        }, _config$fromESObserva[_symbolObservable2.default] = function () {
+          return this;
+        }, _config$fromESObserva)), _this.vdom$ = config.toESObservable(propsToVdom(_this.props$)), _temp), _possibleConstructorReturn(_this, _ret);
+      }
+
+      // Stream of props
+
+
+      // Stream of vdom
+
+
+      ComponentFromStream.prototype.componentWillMount = function componentWillMount() {
+        var _this2 = this;
+
+        // Subscribe to child prop changes so we know when to re-render
+        this.subscription = this.vdom$.subscribe({
+          next: function next(vdom) {
+            _this2.setState({ vdom: vdom });
+          }
+        });
+        this.propsEmitter.emit(this.props);
+      };
+
+      ComponentFromStream.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
+        // Receive new props from the owner
+        this.propsEmitter.emit(nextProps);
+      };
+
+      ComponentFromStream.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
+        return nextState.vdom !== this.state.vdom;
+      };
+
+      ComponentFromStream.prototype.componentWillUnmount = function componentWillUnmount() {
+        // Call without arguments to complete stream
+        this.propsEmitter.emit();
+
+        // Clean-up subscription before un-mounting
+        this.subscription.unsubscribe();
+      };
+
+      ComponentFromStream.prototype.render = function render() {
+        return this.state.vdom;
+      };
+
+      return ComponentFromStream;
+    }(_react.Component);
+  };
+};
+
+var componentFromStream = function componentFromStream(propsToVdom) {
+  return componentFromStreamWithConfig(_setObservableConfig.config)(propsToVdom);
+};
+
+exports.default = componentFromStream;

torrent-project/node_modules/material-ui/node_modules/recompose/compose.js

@@ -0,0 +1,25 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = compose;
+function compose() {
+  for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
+    funcs[_key] = arguments[_key];
+  }
+
+  if (funcs.length === 0) {
+    return function (arg) {
+      return arg;
+    };
+  }
+
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+
+  return funcs.reduce(function (a, b) {
+    return function () {
+      return a(b.apply(undefined, arguments));
+    };
+  });
+}

torrent-project/node_modules/material-ui/node_modules/recompose/createEventHandler.js

@@ -0,0 +1,40 @@
+'use strict';
+
+exports.__esModule = true;
+exports.createEventHandlerWithConfig = undefined;
+
+var _symbolObservable = require('symbol-observable');
+
+var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
+
+var _changeEmitter = require('change-emitter');
+
+var _setObservableConfig = require('./setObservableConfig');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var createEventHandlerWithConfig = exports.createEventHandlerWithConfig = function createEventHandlerWithConfig(config) {
+  return function () {
+    var _config$fromESObserva;
+
+    var emitter = (0, _changeEmitter.createChangeEmitter)();
+    var stream = config.fromESObservable((_config$fromESObserva = {
+      subscribe: function subscribe(observer) {
+        var unsubscribe = emitter.listen(function (value) {
+          return observer.next(value);
+        });
+        return { unsubscribe: unsubscribe };
+      }
+    }, _config$fromESObserva[_symbolObservable2.default] = function () {
+      return this;
+    }, _config$fromESObserva));
+    return {
+      handler: emitter.emit,
+      stream: stream
+    };
+  };
+};
+
+var createEventHandler = createEventHandlerWithConfig(_setObservableConfig.config);
+
+exports.default = createEventHandler;

torrent-project/node_modules/material-ui/node_modules/recompose/createSink.js

@@ -0,0 +1,39 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+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 createSink = function createSink(callback) {
+  return function (_Component) {
+    _inherits(Sink, _Component);
+
+    function Sink() {
+      _classCallCheck(this, Sink);
+
+      return _possibleConstructorReturn(this, _Component.apply(this, arguments));
+    }
+
+    Sink.prototype.componentWillMount = function componentWillMount() {
+      callback(this.props);
+    };
+
+    Sink.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
+      callback(nextProps);
+    };
+
+    Sink.prototype.render = function render() {
+      return null;
+    };
+
+    return Sink;
+  }(_react.Component);
+};
+
+exports.default = createSink;

torrent-project/node_modules/material-ui/node_modules/recompose/defaultProps.js

@@ -0,0 +1,31 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var defaultProps = function defaultProps(props) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+    var DefaultProps = function DefaultProps(ownerProps) {
+      return factory(ownerProps);
+    };
+    DefaultProps.defaultProps = props;
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'defaultProps'))(DefaultProps);
+    }
+    return DefaultProps;
+  };
+};
+
+exports.default = defaultProps;

torrent-project/node_modules/material-ui/node_modules/recompose/flattenProp.js

@@ -0,0 +1,33 @@
+'use strict';
+
+exports.__esModule = 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 _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var flattenProp = function flattenProp(propName) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+    var FlattenProp = function FlattenProp(props) {
+      return factory(_extends({}, props, props[propName]));
+    };
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'flattenProp'))(FlattenProp);
+    }
+    return FlattenProp;
+  };
+};
+
+exports.default = flattenProp;

torrent-project/node_modules/material-ui/node_modules/recompose/flydObservableConfig.js

@@ -0,0 +1,59 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _symbolObservable = require('symbol-observable');
+
+var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
+
+var _flyd = require('flyd');
+
+var _flyd2 = _interopRequireDefault(_flyd);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var noop = function noop() {};
+
+var config = {
+  fromESObservable: function fromESObservable(observable) {
+    var stream = _flyd2.default.stream();
+
+    var _observable$subscribe = observable.subscribe({
+      next: function next(value) {
+        return stream(value);
+      },
+      error: function error(_error) {
+        return stream({ error: _error });
+      },
+      complete: function complete() {
+        return stream.end(true);
+      }
+    }),
+        unsubscribe = _observable$subscribe.unsubscribe;
+
+    _flyd2.default.on(unsubscribe, stream.end);
+    return stream;
+  },
+
+  toESObservable: function toESObservable(stream) {
+    var _ref;
+
+    return _ref = {
+      subscribe: function subscribe(observer) {
+        var sub = _flyd2.default.on(observer.next || noop, stream);
+        _flyd2.default.on(function (_) {
+          return observer.complete();
+        }, sub.end);
+        return {
+          unsubscribe: function unsubscribe() {
+            return sub.end(true);
+          }
+        };
+      }
+    }, _ref[_symbolObservable2.default] = function () {
+      return this;
+    }, _ref;
+  }
+};
+
+exports.default = config;

torrent-project/node_modules/material-ui/node_modules/recompose/getContext.js

@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = 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 _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var getContext = function getContext(contextTypes) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+    var GetContext = function GetContext(ownerProps, context) {
+      return factory(_extends({}, ownerProps, context));
+    };
+
+    GetContext.contextTypes = contextTypes;
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'getContext'))(GetContext);
+    }
+    return GetContext;
+  };
+};
+
+exports.default = getContext;

torrent-project/node_modules/material-ui/node_modules/recompose/getDisplayName.js

@@ -0,0 +1,16 @@
+'use strict';
+
+exports.__esModule = true;
+var getDisplayName = function getDisplayName(Component) {
+  if (typeof Component === 'string') {
+    return Component;
+  }
+
+  if (!Component) {
+    return undefined;
+  }
+
+  return Component.displayName || Component.name || 'Component';
+};
+
+exports.default = getDisplayName;

torrent-project/node_modules/material-ui/node_modules/recompose/hoistStatics.js

@@ -0,0 +1,19 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _hoistNonReactStatics = require('hoist-non-react-statics');
+
+var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var hoistStatics = function hoistStatics(higherOrderComponent) {
+  return function (BaseComponent) {
+    var NewComponent = higherOrderComponent(BaseComponent);
+    (0, _hoistNonReactStatics2.default)(NewComponent, BaseComponent);
+    return NewComponent;
+  };
+};
+
+exports.default = hoistStatics;

torrent-project/node_modules/material-ui/node_modules/recompose/index.js

@@ -0,0 +1,365 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _mapProps = require('./mapProps');
+
+Object.defineProperty(exports, 'mapProps', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_mapProps).default;
+  }
+});
+
+var _withProps = require('./withProps');
+
+Object.defineProperty(exports, 'withProps', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_withProps).default;
+  }
+});
+
+var _withPropsOnChange = require('./withPropsOnChange');
+
+Object.defineProperty(exports, 'withPropsOnChange', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_withPropsOnChange).default;
+  }
+});
+
+var _withHandlers = require('./withHandlers');
+
+Object.defineProperty(exports, 'withHandlers', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_withHandlers).default;
+  }
+});
+
+var _defaultProps = require('./defaultProps');
+
+Object.defineProperty(exports, 'defaultProps', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_defaultProps).default;
+  }
+});
+
+var _renameProp = require('./renameProp');
+
+Object.defineProperty(exports, 'renameProp', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_renameProp).default;
+  }
+});
+
+var _renameProps = require('./renameProps');
+
+Object.defineProperty(exports, 'renameProps', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_renameProps).default;
+  }
+});
+
+var _flattenProp = require('./flattenProp');
+
+Object.defineProperty(exports, 'flattenProp', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_flattenProp).default;
+  }
+});
+
+var _withState = require('./withState');
+
+Object.defineProperty(exports, 'withState', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_withState).default;
+  }
+});
+
+var _withStateHandlers = require('./withStateHandlers');
+
+Object.defineProperty(exports, 'withStateHandlers', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_withStateHandlers).default;
+  }
+});
+
+var _withReducer = require('./withReducer');
+
+Object.defineProperty(exports, 'withReducer', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_withReducer).default;
+  }
+});
+
+var _branch = require('./branch');
+
+Object.defineProperty(exports, 'branch', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_branch).default;
+  }
+});
+
+var _renderComponent = require('./renderComponent');
+
+Object.defineProperty(exports, 'renderComponent', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_renderComponent).default;
+  }
+});
+
+var _renderNothing = require('./renderNothing');
+
+Object.defineProperty(exports, 'renderNothing', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_renderNothing).default;
+  }
+});
+
+var _shouldUpdate = require('./shouldUpdate');
+
+Object.defineProperty(exports, 'shouldUpdate', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_shouldUpdate).default;
+  }
+});
+
+var _pure = require('./pure');
+
+Object.defineProperty(exports, 'pure', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_pure).default;
+  }
+});
+
+var _onlyUpdateForKeys = require('./onlyUpdateForKeys');
+
+Object.defineProperty(exports, 'onlyUpdateForKeys', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_onlyUpdateForKeys).default;
+  }
+});
+
+var _onlyUpdateForPropTypes = require('./onlyUpdateForPropTypes');
+
+Object.defineProperty(exports, 'onlyUpdateForPropTypes', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_onlyUpdateForPropTypes).default;
+  }
+});
+
+var _withContext = require('./withContext');
+
+Object.defineProperty(exports, 'withContext', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_withContext).default;
+  }
+});
+
+var _getContext = require('./getContext');
+
+Object.defineProperty(exports, 'getContext', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_getContext).default;
+  }
+});
+
+var _lifecycle = require('./lifecycle');
+
+Object.defineProperty(exports, 'lifecycle', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_lifecycle).default;
+  }
+});
+
+var _toClass = require('./toClass');
+
+Object.defineProperty(exports, 'toClass', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_toClass).default;
+  }
+});
+
+var _setStatic = require('./setStatic');
+
+Object.defineProperty(exports, 'setStatic', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_setStatic).default;
+  }
+});
+
+var _setPropTypes = require('./setPropTypes');
+
+Object.defineProperty(exports, 'setPropTypes', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_setPropTypes).default;
+  }
+});
+
+var _setDisplayName = require('./setDisplayName');
+
+Object.defineProperty(exports, 'setDisplayName', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_setDisplayName).default;
+  }
+});
+
+var _compose = require('./compose');
+
+Object.defineProperty(exports, 'compose', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_compose).default;
+  }
+});
+
+var _getDisplayName = require('./getDisplayName');
+
+Object.defineProperty(exports, 'getDisplayName', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_getDisplayName).default;
+  }
+});
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+Object.defineProperty(exports, 'wrapDisplayName', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_wrapDisplayName).default;
+  }
+});
+
+var _shallowEqual = require('./shallowEqual');
+
+Object.defineProperty(exports, 'shallowEqual', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_shallowEqual).default;
+  }
+});
+
+var _isClassComponent = require('./isClassComponent');
+
+Object.defineProperty(exports, 'isClassComponent', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_isClassComponent).default;
+  }
+});
+
+var _createSink = require('./createSink');
+
+Object.defineProperty(exports, 'createSink', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_createSink).default;
+  }
+});
+
+var _componentFromProp = require('./componentFromProp');
+
+Object.defineProperty(exports, 'componentFromProp', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_componentFromProp).default;
+  }
+});
+
+var _nest = require('./nest');
+
+Object.defineProperty(exports, 'nest', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_nest).default;
+  }
+});
+
+var _hoistStatics = require('./hoistStatics');
+
+Object.defineProperty(exports, 'hoistStatics', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_hoistStatics).default;
+  }
+});
+
+var _componentFromStream = require('./componentFromStream');
+
+Object.defineProperty(exports, 'componentFromStream', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_componentFromStream).default;
+  }
+});
+Object.defineProperty(exports, 'componentFromStreamWithConfig', {
+  enumerable: true,
+  get: function get() {
+    return _componentFromStream.componentFromStreamWithConfig;
+  }
+});
+
+var _mapPropsStream = require('./mapPropsStream');
+
+Object.defineProperty(exports, 'mapPropsStream', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_mapPropsStream).default;
+  }
+});
+Object.defineProperty(exports, 'mapPropsStreamWithConfig', {
+  enumerable: true,
+  get: function get() {
+    return _mapPropsStream.mapPropsStreamWithConfig;
+  }
+});
+
+var _createEventHandler = require('./createEventHandler');
+
+Object.defineProperty(exports, 'createEventHandler', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_createEventHandler).default;
+  }
+});
+Object.defineProperty(exports, 'createEventHandlerWithConfig', {
+  enumerable: true,
+  get: function get() {
+    return _createEventHandler.createEventHandlerWithConfig;
+  }
+});
+
+var _setObservableConfig = require('./setObservableConfig');
+
+Object.defineProperty(exports, 'setObservableConfig', {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_setObservableConfig).default;
+  }
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

torrent-project/node_modules/material-ui/node_modules/recompose/isClassComponent.js

@@ -0,0 +1,8 @@
+'use strict';
+
+exports.__esModule = true;
+var isClassComponent = function isClassComponent(Component) {
+  return Boolean(Component && Component.prototype && typeof Component.prototype.render === 'function');
+};
+
+exports.default = isClassComponent;

torrent-project/node_modules/material-ui/node_modules/recompose/kefirObservableConfig.js

@@ -0,0 +1,18 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _kefir = require('kefir');
+
+var _kefir2 = _interopRequireDefault(_kefir);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var config = {
+  fromESObservable: _kefir2.default.fromESObservable,
+  toESObservable: function toESObservable(stream) {
+    return stream.toESObservable();
+  }
+};
+
+exports.default = config;

torrent-project/node_modules/material-ui/node_modules/recompose/lifecycle.js

@@ -0,0 +1,61 @@
+'use strict';
+
+exports.__esModule = 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 _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+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; } /* eslint-disable no-console */
+
+
+var lifecycle = function lifecycle(spec) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+
+    if (process.env.NODE_ENV !== 'production' && spec.hasOwnProperty('render')) {
+      console.error('lifecycle() does not support the render method; its behavior is to ' + 'pass all props and state to the base component.');
+    }
+
+    var Lifecycle = function (_Component) {
+      _inherits(Lifecycle, _Component);
+
+      function Lifecycle() {
+        _classCallCheck(this, Lifecycle);
+
+        return _possibleConstructorReturn(this, _Component.apply(this, arguments));
+      }
+
+      Lifecycle.prototype.render = function render() {
+        return factory(_extends({}, this.props, this.state));
+      };
+
+      return Lifecycle;
+    }(_react.Component);
+
+    Object.keys(spec).forEach(function (hook) {
+      return Lifecycle.prototype[hook] = spec[hook];
+    });
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'lifecycle'))(Lifecycle);
+    }
+    return Lifecycle;
+  };
+};
+
+exports.default = lifecycle;

torrent-project/node_modules/material-ui/node_modules/recompose/mapProps.js

@@ -0,0 +1,30 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var mapProps = function mapProps(propsMapper) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+    var MapProps = function MapProps(props) {
+      return factory(propsMapper(props));
+    };
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'mapProps'))(MapProps);
+    }
+    return MapProps;
+  };
+};
+
+exports.default = mapProps;

torrent-project/node_modules/material-ui/node_modules/recompose/mapPropsStream.js

@@ -0,0 +1,76 @@
+'use strict';
+
+exports.__esModule = true;
+exports.mapPropsStreamWithConfig = undefined;
+
+var _react = require('react');
+
+var _symbolObservable = require('symbol-observable');
+
+var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
+
+var _componentFromStream = require('./componentFromStream');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+var _setObservableConfig = require('./setObservableConfig');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var identity = function identity(t) {
+  return t;
+};
+
+var mapPropsStreamWithConfig = exports.mapPropsStreamWithConfig = function mapPropsStreamWithConfig(config) {
+  var componentFromStream = (0, _componentFromStream.componentFromStreamWithConfig)({
+    fromESObservable: identity,
+    toESObservable: identity
+  });
+  return function (transform) {
+    return function (BaseComponent) {
+      var factory = (0, _react.createFactory)(BaseComponent);
+      var fromESObservable = config.fromESObservable,
+          toESObservable = config.toESObservable;
+
+      return componentFromStream(function (props$) {
+        var _ref;
+
+        return _ref = {
+          subscribe: function subscribe(observer) {
+            var subscription = toESObservable(transform(fromESObservable(props$))).subscribe({
+              next: function next(childProps) {
+                return observer.next(factory(childProps));
+              }
+            });
+            return {
+              unsubscribe: function unsubscribe() {
+                return subscription.unsubscribe();
+              }
+            };
+          }
+        }, _ref[_symbolObservable2.default] = function () {
+          return this;
+        }, _ref;
+      });
+    };
+  };
+};
+
+var mapPropsStream = function mapPropsStream(transform) {
+  var hoc = mapPropsStreamWithConfig(_setObservableConfig.config)(transform);
+
+  if (process.env.NODE_ENV !== 'production') {
+    return function (BaseComponent) {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'mapPropsStream'))(hoc(BaseComponent));
+    };
+  }
+  return hoc;
+};
+
+exports.default = mapPropsStream;

torrent-project/node_modules/material-ui/node_modules/recompose/mostObservableConfig.js

@@ -0,0 +1,14 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _most = require('most');
+
+var config = {
+  fromESObservable: _most.from || _most.Stream.from,
+  toESObservable: function toESObservable(stream) {
+    return stream;
+  }
+};
+
+exports.default = config;

torrent-project/node_modules/material-ui/node_modules/recompose/nest.js

@@ -0,0 +1,38 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+var _getDisplayName = require('./getDisplayName');
+
+var _getDisplayName2 = _interopRequireDefault(_getDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
+var nest = function nest() {
+  for (var _len = arguments.length, Components = Array(_len), _key = 0; _key < _len; _key++) {
+    Components[_key] = arguments[_key];
+  }
+
+  var factories = Components.map(_react.createFactory);
+  var Nest = function Nest(_ref) {
+    var props = _objectWithoutProperties(_ref, []),
+        children = _ref.children;
+
+    return factories.reduceRight(function (child, factory) {
+      return factory(props, child);
+    }, children);
+  };
+
+  if (process.env.NODE_ENV !== 'production') {
+    var displayNames = Components.map(_getDisplayName2.default);
+    Nest.displayName = 'nest(' + displayNames.join(', ') + ')';
+  }
+
+  return Nest;
+};
+
+exports.default = nest;

torrent-project/node_modules/material-ui/node_modules/recompose/onlyUpdateForKeys.js

@@ -0,0 +1,40 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _shouldUpdate = require('./shouldUpdate');
+
+var _shouldUpdate2 = _interopRequireDefault(_shouldUpdate);
+
+var _shallowEqual = require('./shallowEqual');
+
+var _shallowEqual2 = _interopRequireDefault(_shallowEqual);
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+var _pick = require('./utils/pick');
+
+var _pick2 = _interopRequireDefault(_pick);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var onlyUpdateForKeys = function onlyUpdateForKeys(propKeys) {
+  var hoc = (0, _shouldUpdate2.default)(function (props, nextProps) {
+    return !(0, _shallowEqual2.default)((0, _pick2.default)(nextProps, propKeys), (0, _pick2.default)(props, propKeys));
+  });
+
+  if (process.env.NODE_ENV !== 'production') {
+    return function (BaseComponent) {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'onlyUpdateForKeys'))(hoc(BaseComponent));
+    };
+  }
+  return hoc;
+};
+
+exports.default = onlyUpdateForKeys;

torrent-project/node_modules/material-ui/node_modules/recompose/onlyUpdateForPropTypes.js

@@ -0,0 +1,43 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _onlyUpdateForKeys = require('./onlyUpdateForKeys');
+
+var _onlyUpdateForKeys2 = _interopRequireDefault(_onlyUpdateForKeys);
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+var _getDisplayName = require('./getDisplayName');
+
+var _getDisplayName2 = _interopRequireDefault(_getDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var onlyUpdateForPropTypes = function onlyUpdateForPropTypes(BaseComponent) {
+  var propTypes = BaseComponent.propTypes;
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (!propTypes) {
+      /* eslint-disable */
+      console.error('A component without any `propTypes` was passed to ' + '`onlyUpdateForPropTypes()`. Check the implementation of the ' + ('component with display name "' + (0, _getDisplayName2.default)(BaseComponent) + '".'));
+      /* eslint-enable */
+    }
+  }
+
+  var propKeys = Object.keys(propTypes || {});
+  var OnlyUpdateForPropTypes = (0, _onlyUpdateForKeys2.default)(propKeys)(BaseComponent);
+
+  if (process.env.NODE_ENV !== 'production') {
+    return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'onlyUpdateForPropTypes'))(OnlyUpdateForPropTypes);
+  }
+  return OnlyUpdateForPropTypes;
+};
+
+exports.default = onlyUpdateForPropTypes;

torrent-project/node_modules/material-ui/node_modules/recompose/package.json

@@ -0,0 +1,66 @@
+{
+  "_args": [
+    [
+      "recompose@0.26.0",
+      "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project"
+    ]
+  ],
+  "_from": "recompose@0.26.0",
+  "_id": "recompose@0.26.0",
+  "_inBundle": false,
+  "_integrity": "sha512-KwOu6ztO0mN5vy3+zDcc45lgnaUoaQse/a5yLVqtzTK13czSWnFGmXbQVmnoMgDkI5POd1EwIKSbjU1V7xdZog==",
+  "_location": "/material-ui/recompose",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "recompose@0.26.0",
+    "name": "recompose",
+    "escapedName": "recompose",
+    "rawSpec": "0.26.0",
+    "saveSpec": null,
+    "fetchSpec": "0.26.0"
+  },
+  "_requiredBy": [
+    "/material-ui"
+  ],
+  "_resolved": "https://registry.npmjs.org/recompose/-/recompose-0.26.0.tgz",
+  "_spec": "0.26.0",
+  "_where": "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project",
+  "author": {
+    "name": "Andrew Clark",
+    "email": "acdlite@me.com"
+  },
+  "bugs": {
+    "url": "https://github.com/acdlite/recompose/issues"
+  },
+  "dependencies": {
+    "change-emitter": "^0.1.2",
+    "fbjs": "^0.8.1",
+    "hoist-non-react-statics": "^2.3.1",
+    "symbol-observable": "^1.0.4"
+  },
+  "description": "A React utility belt for function components and higher-order components",
+  "homepage": "https://github.com/acdlite/recompose",
+  "keywords": [
+    "react",
+    "higher-order",
+    "components",
+    "microcomponentization",
+    "toolkit",
+    "utilities",
+    "composition"
+  ],
+  "license": "MIT",
+  "main": "cjs/Recompose.js",
+  "module": "es/Recompose.js",
+  "name": "recompose",
+  "peerDependencies": {
+    "react": "^0.14.0 || ^15.0.0 || ^16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/acdlite/recompose.git"
+  },
+  "version": "0.26.0"
+}

torrent-project/node_modules/material-ui/node_modules/recompose/pure.js

@@ -0,0 +1,35 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _shouldUpdate = require('./shouldUpdate');
+
+var _shouldUpdate2 = _interopRequireDefault(_shouldUpdate);
+
+var _shallowEqual = require('./shallowEqual');
+
+var _shallowEqual2 = _interopRequireDefault(_shallowEqual);
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var pure = function pure(BaseComponent) {
+  var hoc = (0, _shouldUpdate2.default)(function (props, nextProps) {
+    return !(0, _shallowEqual2.default)(props, nextProps);
+  });
+
+  if (process.env.NODE_ENV !== 'production') {
+    return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'pure'))(hoc(BaseComponent));
+  }
+
+  return hoc(BaseComponent);
+};
+
+exports.default = pure;

torrent-project/node_modules/material-ui/node_modules/recompose/renameProp.js

@@ -0,0 +1,39 @@
+'use strict';
+
+exports.__esModule = 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 _omit = require('./utils/omit');
+
+var _omit2 = _interopRequireDefault(_omit);
+
+var _mapProps = require('./mapProps');
+
+var _mapProps2 = _interopRequireDefault(_mapProps);
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var renameProp = function renameProp(oldName, newName) {
+  var hoc = (0, _mapProps2.default)(function (props) {
+    var _extends2;
+
+    return _extends({}, (0, _omit2.default)(props, [oldName]), (_extends2 = {}, _extends2[newName] = props[oldName], _extends2));
+  });
+  if (process.env.NODE_ENV !== 'production') {
+    return function (BaseComponent) {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'renameProp'))(hoc(BaseComponent));
+    };
+  }
+  return hoc;
+};
+
+exports.default = renameProp;

torrent-project/node_modules/material-ui/node_modules/recompose/renameProps.js

@@ -0,0 +1,56 @@
+'use strict';
+
+exports.__esModule = 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 _omit = require('./utils/omit');
+
+var _omit2 = _interopRequireDefault(_omit);
+
+var _pick = require('./utils/pick');
+
+var _pick2 = _interopRequireDefault(_pick);
+
+var _mapProps = require('./mapProps');
+
+var _mapProps2 = _interopRequireDefault(_mapProps);
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var keys = Object.keys;
+
+
+var mapKeys = function mapKeys(obj, func) {
+  return keys(obj).reduce(function (result, key) {
+    var val = obj[key];
+    /* eslint-disable no-param-reassign */
+    result[func(val, key)] = val;
+    /* eslint-enable no-param-reassign */
+    return result;
+  }, {});
+};
+
+var renameProps = function renameProps(nameMap) {
+  var hoc = (0, _mapProps2.default)(function (props) {
+    return _extends({}, (0, _omit2.default)(props, keys(nameMap)), mapKeys((0, _pick2.default)(props, keys(nameMap)), function (_, oldName) {
+      return nameMap[oldName];
+    }));
+  });
+  if (process.env.NODE_ENV !== 'production') {
+    return function (BaseComponent) {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'renameProps'))(hoc(BaseComponent));
+    };
+  }
+  return hoc;
+};
+
+exports.default = renameProps;

torrent-project/node_modules/material-ui/node_modules/recompose/renderComponent.js

@@ -0,0 +1,26 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var renderComponent = function renderComponent(Component) {
+  return function (_) {
+    var factory = (0, _react.createFactory)(Component);
+    var RenderComponent = function RenderComponent(props) {
+      return factory(props);
+    };
+    if (process.env.NODE_ENV !== 'production') {
+      RenderComponent.displayName = (0, _wrapDisplayName2.default)(Component, 'renderComponent');
+    }
+    return RenderComponent;
+  };
+};
+
+exports.default = renderComponent;

torrent-project/node_modules/material-ui/node_modules/recompose/renderNothing.js

@@ -0,0 +1,33 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+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 Nothing = function (_Component) {
+  _inherits(Nothing, _Component);
+
+  function Nothing() {
+    _classCallCheck(this, Nothing);
+
+    return _possibleConstructorReturn(this, _Component.apply(this, arguments));
+  }
+
+  Nothing.prototype.render = function render() {
+    return null;
+  };
+
+  return Nothing;
+}(_react.Component);
+
+var renderNothing = function renderNothing(_) {
+  return Nothing;
+};
+
+exports.default = renderNothing;

torrent-project/node_modules/material-ui/node_modules/recompose/rxjs4ObservableConfig.js

@@ -0,0 +1,56 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _symbolObservable = require('symbol-observable');
+
+var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
+
+var _rx = require('rx');
+
+var _rx2 = _interopRequireDefault(_rx);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var config = {
+  fromESObservable: function fromESObservable(observable) {
+    return _rx2.default.Observable.create(function (observer) {
+      var _observable$subscribe = observable.subscribe({
+        next: function next(val) {
+          return observer.onNext(val);
+        },
+        error: function error(_error) {
+          return observer.onError(_error);
+        },
+        complete: function complete() {
+          return observer.onCompleted();
+        }
+      }),
+          unsubscribe = _observable$subscribe.unsubscribe;
+
+      return unsubscribe;
+    });
+  },
+  toESObservable: function toESObservable(rxObservable) {
+    var _ref;
+
+    return _ref = {
+      subscribe: function subscribe(observer) {
+        var subscription = rxObservable.subscribe(function (val) {
+          return observer.next(val);
+        }, function (error) {
+          return observer.error(error);
+        }, function () {
+          return observer.complete();
+        });
+        return { unsubscribe: function unsubscribe() {
+            return subscription.dispose();
+          } };
+      }
+    }, _ref[_symbolObservable2.default] = function () {
+      return this;
+    }, _ref;
+  }
+};
+
+exports.default = config;

torrent-project/node_modules/material-ui/node_modules/recompose/rxjsObservableConfig.js

@@ -0,0 +1,18 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _rxjs = require('rxjs');
+
+var _rxjs2 = _interopRequireDefault(_rxjs);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var config = {
+  fromESObservable: _rxjs2.default.Observable.from,
+  toESObservable: function toESObservable(stream) {
+    return stream;
+  }
+};
+
+exports.default = config;

torrent-project/node_modules/material-ui/node_modules/recompose/setDisplayName.js

@@ -0,0 +1,15 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _setStatic = require('./setStatic');
+
+var _setStatic2 = _interopRequireDefault(_setStatic);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var setDisplayName = function setDisplayName(displayName) {
+  return (0, _setStatic2.default)('displayName', displayName);
+};
+
+exports.default = setDisplayName;

torrent-project/node_modules/material-ui/node_modules/recompose/setObservableConfig.js

@@ -0,0 +1,22 @@
+'use strict';
+
+exports.__esModule = true;
+var _config = {
+  fromESObservable: null,
+  toESObservable: null
+};
+
+var configureObservable = function configureObservable(c) {
+  _config = c;
+};
+
+var config = exports.config = {
+  fromESObservable: function fromESObservable(observable) {
+    return typeof _config.fromESObservable === 'function' ? _config.fromESObservable(observable) : observable;
+  },
+  toESObservable: function toESObservable(stream) {
+    return typeof _config.toESObservable === 'function' ? _config.toESObservable(stream) : stream;
+  }
+};
+
+exports.default = configureObservable;

torrent-project/node_modules/material-ui/node_modules/recompose/setPropTypes.js

@@ -0,0 +1,15 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _setStatic = require('./setStatic');
+
+var _setStatic2 = _interopRequireDefault(_setStatic);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var setPropTypes = function setPropTypes(propTypes) {
+  return (0, _setStatic2.default)('propTypes', propTypes);
+};
+
+exports.default = setPropTypes;

torrent-project/node_modules/material-ui/node_modules/recompose/setStatic.js

@@ -0,0 +1,13 @@
+"use strict";
+
+exports.__esModule = true;
+var setStatic = function setStatic(key, value) {
+  return function (BaseComponent) {
+    /* eslint-disable no-param-reassign */
+    BaseComponent[key] = value;
+    /* eslint-enable no-param-reassign */
+    return BaseComponent;
+  };
+};
+
+exports.default = setStatic;

torrent-project/node_modules/material-ui/node_modules/recompose/shallowEqual.js

@@ -0,0 +1,11 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _shallowEqual = require('fbjs/lib/shallowEqual');
+
+var _shallowEqual2 = _interopRequireDefault(_shallowEqual);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = _shallowEqual2.default;

torrent-project/node_modules/material-ui/node_modules/recompose/shouldUpdate.js

@@ -0,0 +1,54 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+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 shouldUpdate = function shouldUpdate(test) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+
+    var ShouldUpdate = function (_Component) {
+      _inherits(ShouldUpdate, _Component);
+
+      function ShouldUpdate() {
+        _classCallCheck(this, ShouldUpdate);
+
+        return _possibleConstructorReturn(this, _Component.apply(this, arguments));
+      }
+
+      ShouldUpdate.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
+        return test(this.props, nextProps);
+      };
+
+      ShouldUpdate.prototype.render = function render() {
+        return factory(this.props);
+      };
+
+      return ShouldUpdate;
+    }(_react.Component);
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'shouldUpdate'))(ShouldUpdate);
+    }
+    return ShouldUpdate;
+  };
+};
+
+exports.default = shouldUpdate;

torrent-project/node_modules/material-ui/node_modules/recompose/toClass.js

@@ -0,0 +1,57 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _getDisplayName = require('./getDisplayName');
+
+var _getDisplayName2 = _interopRequireDefault(_getDisplayName);
+
+var _isClassComponent = require('./isClassComponent');
+
+var _isClassComponent2 = _interopRequireDefault(_isClassComponent);
+
+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 toClass = function toClass(baseComponent) {
+  if ((0, _isClassComponent2.default)(baseComponent)) {
+    return baseComponent;
+  }
+
+  var ToClass = function (_Component) {
+    _inherits(ToClass, _Component);
+
+    function ToClass() {
+      _classCallCheck(this, ToClass);
+
+      return _possibleConstructorReturn(this, _Component.apply(this, arguments));
+    }
+
+    ToClass.prototype.render = function render() {
+      if (typeof baseComponent === 'string') {
+        return _react2.default.createElement(baseComponent, this.props);
+      }
+      return baseComponent(this.props, this.context);
+    };
+
+    return ToClass;
+  }(_react.Component);
+
+  ToClass.displayName = (0, _getDisplayName2.default)(baseComponent);
+  ToClass.propTypes = baseComponent.propTypes;
+  ToClass.contextTypes = baseComponent.contextTypes;
+  ToClass.defaultProps = baseComponent.defaultProps;
+
+  return ToClass;
+};
+
+exports.default = toClass;

torrent-project/node_modules/material-ui/node_modules/recompose/utils/mapValues.js

@@ -0,0 +1,16 @@
+"use strict";
+
+exports.__esModule = true;
+var mapValues = function mapValues(obj, func) {
+  var result = {};
+  /* eslint-disable no-restricted-syntax */
+  for (var key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      result[key] = func(obj[key], key);
+    }
+  }
+  /* eslint-enable no-restricted-syntax */
+  return result;
+};
+
+exports.default = mapValues;

torrent-project/node_modules/material-ui/node_modules/recompose/utils/omit.js

@@ -0,0 +1,19 @@
+"use strict";
+
+exports.__esModule = true;
+
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
+var omit = function omit(obj, keys) {
+  var rest = _objectWithoutProperties(obj, []);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (rest.hasOwnProperty(key)) {
+      delete rest[key];
+    }
+  }
+  return rest;
+};
+
+exports.default = omit;

torrent-project/node_modules/material-ui/node_modules/recompose/utils/pick.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+var pick = function pick(obj, keys) {
+  var result = {};
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (obj.hasOwnProperty(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+};
+
+exports.default = pick;

torrent-project/node_modules/material-ui/node_modules/recompose/withContext.js

@@ -0,0 +1,60 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+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 withContext = function withContext(childContextTypes, getChildContext) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+
+    var WithContext = function (_Component) {
+      _inherits(WithContext, _Component);
+
+      function WithContext() {
+        var _temp, _this, _ret;
+
+        _classCallCheck(this, WithContext);
+
+        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.getChildContext = function () {
+          return getChildContext(_this.props);
+        }, _temp), _possibleConstructorReturn(_this, _ret);
+      }
+
+      WithContext.prototype.render = function render() {
+        return factory(this.props);
+      };
+
+      return WithContext;
+    }(_react.Component);
+
+    WithContext.childContextTypes = childContextTypes;
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'withContext'))(WithContext);
+    }
+    return WithContext;
+  };
+};
+
+exports.default = withContext;

torrent-project/node_modules/material-ui/node_modules/recompose/withHandlers.js

@@ -0,0 +1,92 @@
+'use strict';
+
+exports.__esModule = 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 _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+var _mapValues = require('./utils/mapValues');
+
+var _mapValues2 = _interopRequireDefault(_mapValues);
+
+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; } /* eslint-disable no-console */
+
+
+var withHandlers = function withHandlers(handlers) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+
+    var WithHandlers = function (_Component) {
+      _inherits(WithHandlers, _Component);
+
+      function WithHandlers() {
+        var _temp, _this, _ret;
+
+        _classCallCheck(this, WithHandlers);
+
+        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _initialiseProps.call(_this), _temp), _possibleConstructorReturn(_this, _ret);
+      }
+
+      WithHandlers.prototype.componentWillReceiveProps = function componentWillReceiveProps() {
+        this.cachedHandlers = {};
+      };
+
+      WithHandlers.prototype.render = function render() {
+        return factory(_extends({}, this.props, this.handlers));
+      };
+
+      return WithHandlers;
+    }(_react.Component);
+
+    var _initialiseProps = function _initialiseProps() {
+      var _this2 = this;
+
+      this.cachedHandlers = {};
+      this.handlers = (0, _mapValues2.default)(typeof handlers === 'function' ? handlers(this.props) : handlers, function (createHandler, handlerName) {
+        return function () {
+          var cachedHandler = _this2.cachedHandlers[handlerName];
+          if (cachedHandler) {
+            return cachedHandler.apply(undefined, arguments);
+          }
+
+          var handler = createHandler(_this2.props);
+          _this2.cachedHandlers[handlerName] = handler;
+
+          if (process.env.NODE_ENV !== 'production' && typeof handler !== 'function') {
+            console.error(
+            // eslint-disable-line no-console
+            'withHandlers(): Expected a map of higher-order functions. ' + 'Refer to the docs for more info.');
+          }
+
+          return handler.apply(undefined, arguments);
+        };
+      });
+    };
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'withHandlers'))(WithHandlers);
+    }
+    return WithHandlers;
+  };
+};
+
+exports.default = withHandlers;

torrent-project/node_modules/material-ui/node_modules/recompose/withProps.js

@@ -0,0 +1,33 @@
+'use strict';
+
+exports.__esModule = 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 _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _mapProps = require('./mapProps');
+
+var _mapProps2 = _interopRequireDefault(_mapProps);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var withProps = function withProps(input) {
+  var hoc = (0, _mapProps2.default)(function (props) {
+    return _extends({}, props, typeof input === 'function' ? input(props) : input);
+  });
+  if (process.env.NODE_ENV !== 'production') {
+    return function (BaseComponent) {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'withProps'))(hoc(BaseComponent));
+    };
+  }
+  return hoc;
+};
+
+exports.default = withProps;

torrent-project/node_modules/material-ui/node_modules/recompose/withPropsOnChange.js

@@ -0,0 +1,75 @@
+'use strict';
+
+exports.__esModule = 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 _react = require('react');
+
+var _pick = require('./utils/pick');
+
+var _pick2 = _interopRequireDefault(_pick);
+
+var _shallowEqual = require('./shallowEqual');
+
+var _shallowEqual2 = _interopRequireDefault(_shallowEqual);
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+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 withPropsOnChange = function withPropsOnChange(shouldMapOrKeys, propsMapper) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+    var shouldMap = typeof shouldMapOrKeys === 'function' ? shouldMapOrKeys : function (props, nextProps) {
+      return !(0, _shallowEqual2.default)((0, _pick2.default)(props, shouldMapOrKeys), (0, _pick2.default)(nextProps, shouldMapOrKeys));
+    };
+
+    var WithPropsOnChange = function (_Component) {
+      _inherits(WithPropsOnChange, _Component);
+
+      function WithPropsOnChange() {
+        var _temp, _this, _ret;
+
+        _classCallCheck(this, WithPropsOnChange);
+
+        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.computedProps = propsMapper(_this.props), _temp), _possibleConstructorReturn(_this, _ret);
+      }
+
+      WithPropsOnChange.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
+        if (shouldMap(this.props, nextProps)) {
+          this.computedProps = propsMapper(nextProps);
+        }
+      };
+
+      WithPropsOnChange.prototype.render = function render() {
+        return factory(_extends({}, this.props, this.computedProps));
+      };
+
+      return WithPropsOnChange;
+    }(_react.Component);
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'withPropsOnChange'))(WithPropsOnChange);
+    }
+    return WithPropsOnChange;
+  };
+};
+
+exports.default = withPropsOnChange;

torrent-project/node_modules/material-ui/node_modules/recompose/withReducer.js

@@ -0,0 +1,76 @@
+'use strict';
+
+exports.__esModule = 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 _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+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 withReducer = function withReducer(stateName, dispatchName, reducer, initialState) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+
+    var WithReducer = function (_Component) {
+      _inherits(WithReducer, _Component);
+
+      function WithReducer() {
+        var _temp, _this, _ret;
+
+        _classCallCheck(this, WithReducer);
+
+        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = {
+          stateValue: _this.initializeStateValue()
+        }, _this.dispatch = function (action) {
+          return _this.setState(function (_ref) {
+            var stateValue = _ref.stateValue;
+            return {
+              stateValue: reducer(stateValue, action)
+            };
+          });
+        }, _temp), _possibleConstructorReturn(_this, _ret);
+      }
+
+      WithReducer.prototype.initializeStateValue = function initializeStateValue() {
+        if (initialState !== undefined) {
+          return typeof initialState === 'function' ? initialState(this.props) : initialState;
+        }
+        return reducer(undefined, { type: '@@recompose/INIT' });
+      };
+
+      WithReducer.prototype.render = function render() {
+        var _extends2;
+
+        return factory(_extends({}, this.props, (_extends2 = {}, _extends2[stateName] = this.state.stateValue, _extends2[dispatchName] = this.dispatch, _extends2)));
+      };
+
+      return WithReducer;
+    }(_react.Component);
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'withReducer'))(WithReducer);
+    }
+    return WithReducer;
+  };
+};
+
+exports.default = withReducer;

torrent-project/node_modules/material-ui/node_modules/recompose/withState.js

@@ -0,0 +1,69 @@
+'use strict';
+
+exports.__esModule = 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 _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+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 withState = function withState(stateName, stateUpdaterName, initialState) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+
+    var WithState = function (_Component) {
+      _inherits(WithState, _Component);
+
+      function WithState() {
+        var _temp, _this, _ret;
+
+        _classCallCheck(this, WithState);
+
+        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = {
+          stateValue: typeof initialState === 'function' ? initialState(_this.props) : initialState
+        }, _this.updateStateValue = function (updateFn, callback) {
+          return _this.setState(function (_ref) {
+            var stateValue = _ref.stateValue;
+            return {
+              stateValue: typeof updateFn === 'function' ? updateFn(stateValue) : updateFn
+            };
+          }, callback);
+        }, _temp), _possibleConstructorReturn(_this, _ret);
+      }
+
+      WithState.prototype.render = function render() {
+        var _extends2;
+
+        return factory(_extends({}, this.props, (_extends2 = {}, _extends2[stateName] = this.state.stateValue, _extends2[stateUpdaterName] = this.updateStateValue, _extends2)));
+      };
+
+      return WithState;
+    }(_react.Component);
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'withState'))(WithState);
+    }
+    return WithState;
+  };
+};
+
+exports.default = withState;

torrent-project/node_modules/material-ui/node_modules/recompose/withStateHandlers.js

@@ -0,0 +1,97 @@
+'use strict';
+
+exports.__esModule = 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 _react = require('react');
+
+var _setDisplayName = require('./setDisplayName');
+
+var _setDisplayName2 = _interopRequireDefault(_setDisplayName);
+
+var _wrapDisplayName = require('./wrapDisplayName');
+
+var _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName);
+
+var _shallowEqual = require('./shallowEqual');
+
+var _shallowEqual2 = _interopRequireDefault(_shallowEqual);
+
+var _mapValues = require('./utils/mapValues');
+
+var _mapValues2 = _interopRequireDefault(_mapValues);
+
+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 withStateHandlers = function withStateHandlers(initialState, stateUpdaters) {
+  return function (BaseComponent) {
+    var factory = (0, _react.createFactory)(BaseComponent);
+
+    var WithStateHandlers = function (_Component) {
+      _inherits(WithStateHandlers, _Component);
+
+      function WithStateHandlers() {
+        var _temp, _this, _ret;
+
+        _classCallCheck(this, WithStateHandlers);
+
+        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _initialiseProps.call(_this), _temp), _possibleConstructorReturn(_this, _ret);
+      }
+
+      WithStateHandlers.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
+        var propsChanged = nextProps !== this.props;
+        // the idea is to skip render if stateUpdater handler return undefined
+        // this allows to create no state update handlers with access to state and props
+        var stateChanged = !(0, _shallowEqual2.default)(nextState, this.state);
+        return propsChanged || stateChanged;
+      };
+
+      WithStateHandlers.prototype.render = function render() {
+        return factory(_extends({}, this.props, this.state, this.stateUpdaters));
+      };
+
+      return WithStateHandlers;
+    }(_react.Component);
+
+    var _initialiseProps = function _initialiseProps() {
+      var _this2 = this;
+
+      this.state = typeof initialState === 'function' ? initialState(this.props) : initialState;
+      this.stateUpdaters = (0, _mapValues2.default)(stateUpdaters, function (handler) {
+        return function (mayBeEvent) {
+          for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            args[_key2 - 1] = arguments[_key2];
+          }
+
+          // Having that functional form of setState can be called async
+          // we need to persist SyntheticEvent
+          if (mayBeEvent && typeof mayBeEvent.persist === 'function') {
+            mayBeEvent.persist();
+          }
+
+          _this2.setState(function (state, props) {
+            return handler(state, props).apply(undefined, [mayBeEvent].concat(args));
+          });
+        };
+      });
+    };
+
+    if (process.env.NODE_ENV !== 'production') {
+      return (0, _setDisplayName2.default)((0, _wrapDisplayName2.default)(BaseComponent, 'withStateHandlers'))(WithStateHandlers);
+    }
+    return WithStateHandlers;
+  };
+};
+
+exports.default = withStateHandlers;

torrent-project/node_modules/material-ui/node_modules/recompose/wrapDisplayName.js

@@ -0,0 +1,15 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _getDisplayName = require('./getDisplayName');
+
+var _getDisplayName2 = _interopRequireDefault(_getDisplayName);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var wrapDisplayName = function wrapDisplayName(BaseComponent, hocName) {
+  return hocName + '(' + (0, _getDisplayName2.default)(BaseComponent) + ')';
+};
+
+exports.default = wrapDisplayName;

torrent-project/node_modules/material-ui/node_modules/recompose/xstreamObservableConfig.js

@@ -0,0 +1,52 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _symbolObservable = require('symbol-observable');
+
+var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
+
+var _xstream = require('xstream');
+
+var _xstream2 = _interopRequireDefault(_xstream);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var noop = function noop() {};
+
+var config = {
+  fromESObservable: function fromESObservable(observable) {
+    return _xstream2.default.create({
+      subscription: null,
+      start: function start(listener) {
+        this.subscription = observable.subscribe(listener);
+      },
+      stop: function stop() {
+        this.subscription.unsubscribe();
+      }
+    });
+  },
+  toESObservable: function toESObservable(stream) {
+    var _ref;
+
+    return _ref = {
+      subscribe: function subscribe(observer) {
+        var listener = {
+          next: observer.next || noop,
+          error: observer.error || noop,
+          complete: observer.complete || noop
+        };
+        stream.addListener(listener);
+        return {
+          unsubscribe: function unsubscribe() {
+            return stream.removeListener(listener);
+          }
+        };
+      }
+    }, _ref[_symbolObservable2.default] = function () {
+      return this;
+    }, _ref;
+  }
+};
+
+exports.default = config;