content: import React, { Component } from 'react';
  import shallowEqual from 'fbjs/lib/shallowEqual';
  import hoistNonReactStatics from 'hoist-non-react-statics';
  import { createChangeEmitter } from 'change-emitter';
  import $$observable from 'symbol-observable';
  
  var getDisplayName = function getDisplayName(Component$$1) {
    if (typeof Component$$1 === 'string') {
      return Component$$1;
    }
  
    if (!Component$$1) {
      return undefined;
    }
  
    return Component$$1.displayName || Component$$1.name || 'Component';
  };
  
  var wrapDisplayName = function wrapDisplayName(BaseComponent, hocName) {
    return hocName + '(' + getDisplayName(BaseComponent) + ')';
  };
  
  var createHelper = function createHelper(func, helperName) {
    var setDisplayName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
    var noArgs = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  
    if (process.env.NODE_ENV !== 'production' && setDisplayName) {
      if (noArgs) {
        return function (BaseComponent) {
          var Component$$1 = func(BaseComponent);
          Component$$1.displayName = wrapDisplayName(BaseComponent, helperName);
          return Component$$1;
        };
      }
  
      return function () {
        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
  
        return function (BaseComponent) {
          var Component$$1 = func.apply(undefined, args)(BaseComponent);
          Component$$1.displayName = wrapDisplayName(BaseComponent, helperName);
          return Component$$1;
        };
      };
    }
  
    return func;
  };
  
  var classCallCheck = function (instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  };
  
  
  
  
  
  
  
  
  
  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 inherits = function (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 objectWithoutProperties = function (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 possibleConstructorReturn = function (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;
  };
  
  var createEagerElementUtil = function createEagerElementUtil(hasKey, isReferentiallyTransparent, type, props, children) {
    if (!hasKey && isReferentiallyTransparent) {
      if (children) {
        return type(_extends({}, props, { children: children }));
      }
      return type(props);
    }
  
    var Component$$1 = type;
  
    if (children) {
      return React.createElement(
        Component$$1,
        props,
        children
      );
    }
  
    return React.createElement(Component$$1, props);
  };
  
  var isClassComponent = function isClassComponent(Component$$1) {
    return Boolean(Component$$1 && Component$$1.prototype && typeof Component$$1.prototype.isReactComponent === 'object');
  };
  
  var isReferentiallyTransparentFunctionComponent = function isReferentiallyTransparentFunctionComponent(Component$$1) {
    return Boolean(typeof Component$$1 === 'function' && !isClassComponent(Component$$1) && !Component$$1.defaultProps && !Component$$1.contextTypes && (process.env.NODE_ENV === 'production' || !Component$$1.propTypes));
  };
  
  var createFactory = function createFactory(type) {
    var isReferentiallyTransparent = isReferentiallyTransparentFunctionComponent(type);
    return function (p, c) {
      return createEagerElementUtil(false, isReferentiallyTransparent, type, p, c);
    };
  };
  
  var mapProps = function mapProps(propsMapper) {
    return function (BaseComponent) {
      var factory = createFactory(BaseComponent);
      return function (props) {
        return factory(propsMapper(props));
      };
    };
  };
  
  var mapProps$1 = createHelper(mapProps, 'mapProps');
  
  var withProps = function withProps(input) {
    return mapProps$1(function (props) {
      return _extends({}, props, typeof input === 'function' ? input(props) : input);
    });
  };
  
  var withProps$1 = createHelper(withProps, 'withProps');
  
  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;
  };
  
  var withPropsOnChange = function withPropsOnChange(shouldMapOrKeys, propsMapper) {
    return function (BaseComponent) {
      var factory = createFactory(BaseComponent);
      var shouldMap = typeof shouldMapOrKeys === 'function' ? shouldMapOrKeys : function (props, nextProps) {
        return !shallowEqual(pick(props, shouldMapOrKeys), pick(nextProps, shouldMapOrKeys));
      };
  
      return function (_Component) {
        inherits(_class2, _Component);
  
        function _class2() {
          var _temp, _this, _ret;
  
          classCallCheck(this, _class2);
  
          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);
        }
  
        _class2.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
          if (shouldMap(this.props, nextProps)) {
            this.computedProps = propsMapper(nextProps);
          }
        };
  
        _class2.prototype.render = function render() {
          return factory(_extends({}, this.props, this.computedProps));
        };
  
        return _class2;
      }(Component);
    };
  };
  
  var withPropsOnChange$1 = createHelper(withPropsOnChange, 'withPropsOnChange');
  
  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;
  };
  
  var withHandlers = function withHandlers(handlers) {
    return function (BaseComponent) {
      var _class, _temp2, _initialiseProps;
  
      var factory = createFactory(BaseComponent);
      return _temp2 = _class = function (_Component) {
        inherits(_class, _Component);
  
        function _class() {
          var _temp, _this, _ret;
  
          classCallCheck(this, _class);
  
          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);
        }
  
        _class.prototype.componentWillReceiveProps = function componentWillReceiveProps() {
          this.cachedHandlers = {};
        };
  
        _class.prototype.render = function render() {
          return factory(_extends({}, this.props, this.handlers));
        };
  
        return _class;
      }(Component), _initialiseProps = function _initialiseProps() {
        var _this2 = this;
  
        this.cachedHandlers = {};
        this.handlers = mapValues(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);
          };
        });
      }, _temp2;
    };
  };
  
  var withHandlers$1 = createHelper(withHandlers, 'withHandlers');
  
  var defaultProps = function defaultProps(props) {
    return function (BaseComponent) {
      var factory = createFactory(BaseComponent);
      var DefaultProps = function DefaultProps(ownerProps) {
        return factory(ownerProps);
      };
      DefaultProps.defaultProps = props;
      return DefaultProps;
    };
  };
  
  var defaultProps$1 = createHelper(defaultProps, 'defaultProps');
  
  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;
  };
  
  var renameProp = function renameProp(oldName, newName) {
    return mapProps$1(function (props) {
      var _babelHelpers$extends;
  
      return _extends({}, omit(props, [oldName]), (_babelHelpers$extends = {}, _babelHelpers$extends[newName] = props[oldName], _babelHelpers$extends));
    });
  };
  
  var renameProp$1 = createHelper(renameProp, 'renameProp');
  
  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) {
    return mapProps$1(function (props) {
      return _extends({}, omit(props, keys(nameMap)), mapKeys(pick(props, keys(nameMap)), function (_, oldName) {
        return nameMap[oldName];
      }));
    });
  };
  
  var renameProps$1 = createHelper(renameProps, 'renameProps');
  
  var flattenProp = function flattenProp(propName) {
    return function (BaseComponent) {
      var factory = createFactory(BaseComponent);
      return function (props) {
        return factory(_extends({}, props, props[propName]));
      };
    };
  };
  
  var flattenProp$1 = createHelper(flattenProp, 'flattenProp');
  
  var withState = function withState(stateName, stateUpdaterName, initialState) {
    return function (BaseComponent) {
      var factory = createFactory(BaseComponent);
      return function (_Component) {
        inherits(_class2, _Component);
  
        function _class2() {
          var _temp, _this, _ret;
  
          classCallCheck(this, _class2);
  
          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);
        }
  
        _class2.prototype.render = function render() {
          var _babelHelpers$extends;
  
          return factory(_extends({}, this.props, (_babelHelpers$extends = {}, _babelHelpers$extends[stateName] = this.state.stateValue, _babelHelpers$extends[stateUpdaterName] = this.updateStateValue, _babelHelpers$extends)));
        };
  
        return _class2;
      }(Component);
    };
  };
  
  var withState$1 = createHelper(withState, 'withState');
  
  var withReducer = function withReducer(stateName, dispatchName, reducer, initialState) {
    return function (BaseComponent) {
      var factory = createFactory(BaseComponent);
      return function (_Component) {
        inherits(_class2, _Component);
  
        function _class2() {
          var _temp, _this, _ret;
  
          classCallCheck(this, _class2);
  
          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);
        }
  
        _class2.prototype.initializeStateValue = function initializeStateValue() {
          if (initialState !== undefined) {
            return typeof initialState === 'function' ? initialState(this.props) : initialState;
          }
          return reducer(undefined, { type: '@@recompose/INIT' });
        };
  
        _class2.prototype.render = function render() {
          var _babelHelpers$extends;
  
          return factory(_extends({}, this.props, (_babelHelpers$extends = {}, _babelHelpers$extends[stateName] = this.state.stateValue, _babelHelpers$extends[dispatchName] = this.dispatch, _babelHelpers$extends)));
        };
  
        return _class2;
      }(Component);
    };
  };
  
  var withReducer$1 = createHelper(withReducer, 'withReducer');
  
  var identity = function identity(Component$$1) {
    return Component$$1;
  };
  
  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;
      return function (props) {
        if (test(props)) {
          leftFactory = leftFactory || createFactory(left(BaseComponent));
          return leftFactory(props);
        }
        rightFactory = rightFactory || createFactory(right(BaseComponent));
        return rightFactory(props);
      };
    };
  };
  
  var branch$1 = createHelper(branch, 'branch');
  
  var renderComponent = function renderComponent(Component$$1) {
    return function (_) {
      var factory = createFactory(Component$$1);
      var RenderComponent = function RenderComponent(props) {
        return factory(props);
      };
      if (process.env.NODE_ENV !== 'production') {
        RenderComponent.displayName = wrapDisplayName(Component$$1, 'renderComponent');
      }
      return RenderComponent;
    };
  };
  
  var renderComponent$1 = createHelper(renderComponent, 'renderComponent', false);
  
  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;
  }(Component);
  
  Nothing.displayName = 'Nothing';
  
  var renderNothing = function renderNothing(_) {
    return Nothing;
  };
  
  var renderNothing$1 = createHelper(renderNothing, 'renderNothing', false, true);
  
  var shouldUpdate = function shouldUpdate(test) {
    return function (BaseComponent) {
      var factory = createFactory(BaseComponent);
      return function (_Component) {
        inherits(_class, _Component);
  
        function _class() {
          classCallCheck(this, _class);
          return possibleConstructorReturn(this, _Component.apply(this, arguments));
        }
  
        _class.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
          return test(this.props, nextProps);
        };
  
        _class.prototype.render = function render() {
          return factory(this.props);
        };
  
        return _class;
      }(Component);
    };
  };
  
  var shouldUpdate$1 = createHelper(shouldUpdate, 'shouldUpdate');
  
  var pure = shouldUpdate$1(function (props, nextProps) {
    return !shallowEqual(props, nextProps);
  });
  
  var pure$1 = createHelper(pure, 'pure', true, true);
  
  var onlyUpdateForKeys = function onlyUpdateForKeys(propKeys) {
    return shouldUpdate$1(function (props, nextProps) {
      return !shallowEqual(pick(nextProps, propKeys), pick(props, propKeys));
    });
  };
  
  var onlyUpdateForKeys$1 = createHelper(onlyUpdateForKeys, 'onlyUpdateForKeys');
  
  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 "' + getDisplayName(BaseComponent) + '".'));
        /* eslint-enable */
      }
    }
  
    var propKeys = Object.keys(propTypes || {});
    var OnlyUpdateForPropTypes = onlyUpdateForKeys$1(propKeys)(BaseComponent);
  
    return OnlyUpdateForPropTypes;
  };
  
  var onlyUpdateForPropTypes$1 = createHelper(onlyUpdateForPropTypes, 'onlyUpdateForPropTypes', true, true);
  
  var withContext = function withContext(childContextTypes, getChildContext) {
    return function (BaseComponent) {
      var factory = 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;
      }(Component);
  
      WithContext.childContextTypes = childContextTypes;
  
      return WithContext;
    };
  };
  
  var withContext$1 = createHelper(withContext, 'withContext');
  
  var getContext = function getContext(contextTypes) {
    return function (BaseComponent) {
      var factory = createFactory(BaseComponent);
      var GetContext = function GetContext(ownerProps, context) {
        return factory(_extends({}, ownerProps, context));
      };
  
      GetContext.contextTypes = contextTypes;
  
      return GetContext;
    };
  };
  
  var getContext$1 = createHelper(getContext, 'getContext');
  
  var lifecycle = function lifecycle(spec) {
    return function (BaseComponent) {
      var factory = 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.');
      }
  
      return function (_Component) {
        inherits(_class, _Component);
  
        function _class() {
          classCallCheck(this, _class);
  
          for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
  
          var _this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args)));
  
          Object.assign(_this, spec);
          return _this;
        }
  
        _class.prototype.render = function render() {
          return factory(_extends({}, this.props, this.state));
        };
  
        return _class;
      }(Component);
    };
  };
  
  var lifecycle$1 = createHelper(lifecycle, 'lifecycle');
  
  var toClass = function toClass(baseComponent) {
    if (isClassComponent(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 React.createElement(baseComponent, this.props);
        }
        return baseComponent(this.props, this.context);
      };
  
      return ToClass;
    }(Component);
  
    ToClass.displayName = getDisplayName(baseComponent);
    ToClass.propTypes = baseComponent.propTypes;
    ToClass.contextTypes = baseComponent.contextTypes;
    ToClass.defaultProps = baseComponent.defaultProps;
  
    return ToClass;
  };
  
  var setStatic = function setStatic(key, value) {
    return function (BaseComponent) {
      /* eslint-disable no-param-reassign */
      BaseComponent[key] = value;
      /* eslint-enable no-param-reassign */
      return BaseComponent;
    };
  };
  
  var setStatic$1 = createHelper(setStatic, 'setStatic', false);
  
  var setPropTypes = function setPropTypes(propTypes) {
    return setStatic$1('propTypes', propTypes);
  };
  
  var setPropTypes$1 = createHelper(setPropTypes, 'setPropTypes', false);
  
  var setDisplayName = function setDisplayName(displayName) {
    return setStatic$1('displayName', displayName);
  };
  
  var setDisplayName$1 = createHelper(setDisplayName, 'setDisplayName', false);
  
  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));
      };
    });
  }
  
  var createEagerElement = function createEagerElement(type, props, children) {
    var isReferentiallyTransparent = isReferentiallyTransparentFunctionComponent(type);
    /* eslint-disable */
    var hasKey = props && props.hasOwnProperty('key');
    /* eslint-enable */
    return createEagerElementUtil(hasKey, isReferentiallyTransparent, type, props, children);
  };
  
  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;
    }(Component);
  };
  
  var componentFromProp = function componentFromProp(propName) {
    var Component$$1 = function Component$$1(props) {
      return createEagerElement(props[propName], omit(props, [propName]));
    };
    Component$$1.displayName = 'componentFromProp(' + propName + ')';
    return Component$$1;
  };
  
  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(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(getDisplayName);
      Nest.displayName = 'nest(' + displayNames.join(', ') + ')';
    }
  
    return Nest;
  };
  
  var hoistStatics = function hoistStatics(higherOrderComponent) {
    return function (BaseComponent) {
      var NewComponent = higherOrderComponent(BaseComponent);
      hoistNonReactStatics(NewComponent, BaseComponent);
      return NewComponent;
    };
  };
  
  var _config = {
    fromESObservable: null,
    toESObservable: null
  };
  
  var configureObservable = function configureObservable(c) {
    _config = c;
  };
  
  var 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;
    }
  };
  
  var componentFromStreamWithConfig = function componentFromStreamWithConfig(config$$1) {
    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 = createChangeEmitter(), _this.props$ = config$$1.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[$$observable] = function () {
            return this;
          }, _config$fromESObserva)), _this.vdom$ = config$$1.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;
      }(Component);
    };
  };
  
  var componentFromStream = componentFromStreamWithConfig(config);
  
  var identity$1 = function identity(t) {
    return t;
  };
  var componentFromStream$2 = componentFromStreamWithConfig({
    fromESObservable: identity$1,
    toESObservable: identity$1
  });
  
  var mapPropsStreamWithConfig = function mapPropsStreamWithConfig(config$$1) {
    return function (transform) {
      return function (BaseComponent) {
        var factory = createFactory(BaseComponent);
        var fromESObservable = config$$1.fromESObservable,
            toESObservable = config$$1.toESObservable;
  
        return componentFromStream$2(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[$$observable] = function () {
            return this;
          }, _ref;
        });
      };
    };
  };
  
  var mapPropsStream = mapPropsStreamWithConfig(config);
  
  var mapPropsStream$1 = createHelper(mapPropsStream, 'mapPropsStream');
  
  var createEventHandlerWithConfig = function createEventHandlerWithConfig(config$$1) {
    return function () {
      var _config$fromESObserva;
  
      var emitter = createChangeEmitter();
      var stream = config$$1.fromESObservable((_config$fromESObserva = {
        subscribe: function subscribe(observer) {
          var unsubscribe = emitter.listen(function (value) {
            return observer.next(value);
          });
          return { unsubscribe: unsubscribe };
        }
      }, _config$fromESObserva[$$observable] = function () {
        return this;
      }, _config$fromESObserva));
      return {
        handler: emitter.emit,
        stream: stream
      };
    };
  };
  
  var createEventHandler = createEventHandlerWithConfig(config);
  
  // Higher-order component helpers
  // Static property helpers
  
  // Composition function
  
  // Other utils
  
  // Observable helpers
  
  export { mapProps$1 as mapProps, withProps$1 as withProps, withPropsOnChange$1 as withPropsOnChange, withHandlers$1 as withHandlers, defaultProps$1 as defaultProps, renameProp$1 as renameProp, renameProps$1 as renameProps, flattenProp$1 as flattenProp, withState$1 as withState, withReducer$1 as withReducer, branch$1 as branch, renderComponent$1 as renderComponent, renderNothing$1 as renderNothing, shouldUpdate$1 as shouldUpdate, pure$1 as pure, onlyUpdateForKeys$1 as onlyUpdateForKeys, onlyUpdateForPropTypes$1 as onlyUpdateForPropTypes, withContext$1 as withContext, getContext$1 as getContext, lifecycle$1 as lifecycle, toClass, setStatic$1 as setStatic, setPropTypes$1 as setPropTypes, setDisplayName$1 as setDisplayName, compose, getDisplayName, wrapDisplayName, shallowEqual, isClassComponent, createEagerElement, createFactory as createEagerFactory, createSink, componentFromProp, nest, hoistStatics, componentFromStream, mapPropsStream$1 as mapPropsStream, createEventHandler, configureObservable as setObservableConfig };
  