text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory(require("react"));
  	else if(typeof define === 'function' && define.amd)
  		define(["react"], factory);
  	else if(typeof exports === 'object')
  		exports["ReactContext"] = factory(require("react"));
  	else
  		root["ReactContext"] = factory(root["React"]);
  })(this, function(__WEBPACK_EXTERNAL_MODULE_1__) {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  
  
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	exports.Inject = exports.Provider = exports.DEFAULT_CONTEXT_NAME = undefined;
  
  	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  
  	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  	var _react = __webpack_require__(1);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _reactSideEffect = __webpack_require__(2);
  
  	var _reactSideEffect2 = _interopRequireDefault(_reactSideEffect);
  
  	var _deepEqual = __webpack_require__(9);
  
  	var _deepEqual2 = _interopRequireDefault(_deepEqual);
  
  	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; }
  
  	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 DEFAULT_CONTEXT_NAME = exports.DEFAULT_CONTEXT_NAME = '_GLOBAL_CONTEXT';
  
  	// a function for generating a random string
  	var id = function id() {
  	  return Math.random().toString(36).substring(7);
  	};
  
  	// the basis of this component is a few shared singleton objects
  	var
  	// stores all the context information
  	CONTEXTS = {},
  
  	// stores inject instance registrations
  	INJECTION_INSTANCES = {};
  
  	var PROVIDER_PROP_TYPES = {
  	  // the name of the context for which this component is providing data
  	  contextName: _react.PropTypes.string,
  
  	  // the data to provide
  	  provides: _react.PropTypes.object.isRequired
  	};
  
  	/**
  	 * This class when rendered provides data for its context
  	 */
  
  	var ProviderBase = function (_Component) {
  	  _inherits(ProviderBase, _Component);
  
  	  function ProviderBase() {
  	    _classCallCheck(this, ProviderBase);
  
  	    return _possibleConstructorReturn(this, (ProviderBase.__proto__ || Object.getPrototypeOf(ProviderBase)).apply(this, arguments));
  	  }
  
  	  _createClass(ProviderBase, [{
  	    key: 'render',
  	    value: function render() {
  	      return null;
  	    }
  	  }]);
  
  	  return ProviderBase;
  	}(_react.Component);
  
  	/**
  	 * Merges a bunch of context data into a single context object, where the providers at the lowest level take precedence
  	 * @param propsList
  	 * @returns {{}}
  	 */
  
  
  	ProviderBase.propTypes = PROVIDER_PROP_TYPES;
  	var reducePropsToState = function reducePropsToState(propsList) {
  	  var newContexts = {};
  
  	  propsList.forEach(function (_ref) {
  	    var _ref$contextName = _ref.contextName,
  	        contextName = _ref$contextName === undefined ? DEFAULT_CONTEXT_NAME : _ref$contextName,
  	        provides = _ref.provides;
  
  	    // if no context yet exists create it
  	    newContexts[contextName] = newContexts[contextName] || {};
  
  	    // and assign the provided data to that context
  	    Object.assign(newContexts[contextName], provides);
  	  });
  
  	  return newContexts;
  	};
  
  	var handleStateChangeOnClient = function handleStateChangeOnClient(newContext) {
  	  // used to keep track of all the contexts that have been updated
  	  var updatedContexts = {};
  
  	  // for each of the keys in the new context, update the CONTEXTS shared variable
  	  Object.keys(newContext).concat(Object.keys(CONTEXTS)).forEach(function (contextName) {
  	    // we have already compared this contextName
  	    if (updatedContexts[contextName]) {
  	      return;
  	    }
  
  	    if (!(0, _deepEqual2.default)(newContext[contextName], CONTEXTS[contextName])) {
  	      CONTEXTS[contextName] = newContext[contextName];
  	      updatedContexts[contextName] = true;
  	    }
  	  });
  
  	  // now for each of the contexts we have updated, we need to update the registered instances
  	  Object.keys(updatedContexts).forEach(function (updatedContextName) {
  	    var injections = INJECTION_INSTANCES[updatedContextName];
  	    if (injections) {
  	      Object.values(injections).forEach(function (instance) {
  	        return instance.forceUpdate();
  	      });
  	    }
  	  });
  	};
  
  	var Provider = exports.Provider = (0, _reactSideEffect2.default)(reducePropsToState, handleStateChangeOnClient)(ProviderBase);
  	Provider.propTypes = PROVIDER_PROP_TYPES;
  
  	/**
  	 * This class takes some context and injects it into its children as a prop
  	 */
  
  	var Inject = exports.Inject = function (_Component2) {
  	  _inherits(Inject, _Component2);
  
  	  function Inject(props, context) {
  	    _classCallCheck(this, Inject);
  
  	    var _this2 = _possibleConstructorReturn(this, (Inject.__proto__ || Object.getPrototypeOf(Inject)).call(this, props, context));
  
  	    _this2._id = id();
  
  	    _this2._id = id();
  	    _this2.registerInstance(props.contextName);
  	    return _this2;
  	  }
  
  	  _createClass(Inject, [{
  	    key: 'componentWillReceiveProps',
  	    value: function componentWillReceiveProps(_ref2) {
  	      var contextName = _ref2.contextName;
  
  	      if (contextName !== this.props.contextName) {
  	        this.registerInstance(contextName);
  	        this.deRegisterInstance(this.props.contextName);
  	      }
  	    }
  	  }, {
  	    key: 'componentWillUnmount',
  	    value: function componentWillUnmount() {
  	      this.deRegisterInstance(this.props.contextName);
  	    }
  	  }, {
  	    key: 'registerInstance',
  	    value: function registerInstance(contextName) {
  	      if (!INJECTION_INSTANCES[contextName]) {
  	        INJECTION_INSTANCES[contextName] = {};
  	      }
  
  	      INJECTION_INSTANCES[contextName][this._id] = this;
  	    }
  	  }, {
  	    key: 'deRegisterInstance',
  	    value: function deRegisterInstance(contextName) {
  	      if (!INJECTION_INSTANCES[contextName]) {
  	        return;
  	      }
  
  	      delete INJECTION_INSTANCES[contextName][this._id];
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      var _props = this.props,
  	          requires = _props.requires,
  	          children = _props.children,
  	          contextName = _props.contextName,
  	          rest = _objectWithoutProperties(_props, ['requires', 'children', 'contextName']);
  
  	      var context = CONTEXTS[contextName];
  
  	      if (Array.isArray(requires)) {
  	        var _iteratorNormalCompletion = true;
  	        var _didIteratorError = false;
  	        var _iteratorError = undefined;
  
  	        try {
  	          for (var _iterator = requires[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
  	            var key = _step.value;
  
  	            if (typeof context[key] === 'undefined') {
  	              return null;
  	            }
  	          }
  	        } catch (err) {
  	          _didIteratorError = true;
  	          _iteratorError = err;
  	        } finally {
  	          try {
  	            if (!_iteratorNormalCompletion && _iterator.return) {
  	              _iterator.return();
  	            }
  	          } finally {
  	            if (_didIteratorError) {
  	              throw _iteratorError;
  	            }
  	          }
  	        }
  	      } else if (requires !== null) {
  	        if (typeof context[requires] === 'undefined') {
  	          return null;
  	        }
  	      }
  
  	      return (0, _react.cloneElement)(_react.Children.only(this.props.children), _extends({}, rest, { context: context }));
  	    }
  	  }]);
  
  	  return Inject;
  	}(_react.Component);
  
  	Inject.propTypes = {
  	  // the name of the context
  	  contextName: _react.PropTypes.string,
  
  	  // any context variables required to render the children
  	  requires: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.arrayOf(_react.PropTypes.string)]),
  
  	  // the child to get the injected context
  	  children: _react.PropTypes.node.isRequired
  	};
  	Inject.defaultProps = {
  	  contextName: DEFAULT_CONTEXT_NAME,
  	  requires: null
  	};
  
  /***/ },
  /* 1 */
  /***/ function(module, exports) {
  
  	module.exports = __WEBPACK_EXTERNAL_MODULE_1__;
  
  /***/ },
  /* 2 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
  
  	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 _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 _react = __webpack_require__(1);
  
  	var _react2 = _interopRequireDefault(_react);
  
  	var _exenv = __webpack_require__(3);
  
  	var _exenv2 = _interopRequireDefault(_exenv);
  
  	var _shallowequal = __webpack_require__(4);
  
  	var _shallowequal2 = _interopRequireDefault(_shallowequal);
  
  	module.exports = function withSideEffect(reducePropsToState, handleStateChangeOnClient, mapStateOnServer) {
  	  if (typeof reducePropsToState !== 'function') {
  	    throw new Error('Expected reducePropsToState to be a function.');
  	  }
  	  if (typeof handleStateChangeOnClient !== 'function') {
  	    throw new Error('Expected handleStateChangeOnClient to be a function.');
  	  }
  	  if (typeof mapStateOnServer !== 'undefined' && typeof mapStateOnServer !== 'function') {
  	    throw new Error('Expected mapStateOnServer to either be undefined or a function.');
  	  }
  
  	  function getDisplayName(WrappedComponent) {
  	    return WrappedComponent.displayName || WrappedComponent.name || 'Component';
  	  }
  
  	  return function wrap(WrappedComponent) {
  	    if (typeof WrappedComponent !== 'function') {
  	      throw new Error('Expected WrappedComponent to be a React component.');
  	    }
  
  	    var mountedInstances = [];
  	    var state = undefined;
  
  	    function emitChange() {
  	      state = reducePropsToState(mountedInstances.map(function (instance) {
  	        return instance.props;
  	      }));
  
  	      if (SideEffect.canUseDOM) {
  	        handleStateChangeOnClient(state);
  	      } else if (mapStateOnServer) {
  	        state = mapStateOnServer(state);
  	      }
  	    }
  
  	    var SideEffect = (function (_Component) {
  	      _inherits(SideEffect, _Component);
  
  	      function SideEffect() {
  	        _classCallCheck(this, SideEffect);
  
  	        _Component.apply(this, arguments);
  	      }
  
  	      SideEffect.peek = function peek() {
  	        return state;
  	      };
  
  	      SideEffect.rewind = function rewind() {
  	        if (SideEffect.canUseDOM) {
  	          throw new Error('You may only call rewind() on the server. Call peek() to read the current state.');
  	        }
  
  	        var recordedState = state;
  	        state = undefined;
  	        mountedInstances = [];
  	        return recordedState;
  	      };
  
  	      SideEffect.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
  	        return !_shallowequal2['default'](nextProps, this.props);
  	      };
  
  	      SideEffect.prototype.componentWillMount = function componentWillMount() {
  	        mountedInstances.push(this);
  	        emitChange();
  	      };
  
  	      SideEffect.prototype.componentDidUpdate = function componentDidUpdate() {
  	        emitChange();
  	      };
  
  	      SideEffect.prototype.componentWillUnmount = function componentWillUnmount() {
  	        var index = mountedInstances.indexOf(this);
  	        mountedInstances.splice(index, 1);
  	        emitChange();
  	      };
  
  	      SideEffect.prototype.render = function render() {
  	        return _react2['default'].createElement(WrappedComponent, this.props);
  	      };
  
  	      _createClass(SideEffect, null, [{
  	        key: 'displayName',
  
  	        // Try to use displayName of wrapped component
  	        value: 'SideEffect(' + getDisplayName(WrappedComponent) + ')',
  
  	        // Expose canUseDOM so tests can monkeypatch it
  	        enumerable: true
  	      }, {
  	        key: 'canUseDOM',
  	        value: _exenv2['default'].canUseDOM,
  	        enumerable: true
  	      }]);
  
  	      return SideEffect;
  	    })(_react.Component);
  
  	    return SideEffect;
  	  };
  	};
  
  /***/ },
  /* 3 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var __WEBPACK_AMD_DEFINE_RESULT__;/*!
  	  Copyright (c) 2015 Jed Watson.
  	  Based on code that is Copyright 2013-2015, Facebook, Inc.
  	  All rights reserved.
  	*/
  	/* global define */
  
  	(function () {
  		'use strict';
  
  		var canUseDOM = !!(
  			typeof window !== 'undefined' &&
  			window.document &&
  			window.document.createElement
  		);
  
  		var ExecutionEnvironment = {
  
  			canUseDOM: canUseDOM,
  
  			canUseWorkers: typeof Worker !== 'undefined',
  
  			canUseEventListeners:
  				canUseDOM && !!(window.addEventListener || window.attachEvent),
  
  			canUseViewport: canUseDOM && !!window.screen
  
  		};
  
  		if (true) {
  			!(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
  				return ExecutionEnvironment;
  			}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  		} else if (typeof module !== 'undefined' && module.exports) {
  			module.exports = ExecutionEnvironment;
  		} else {
  			window.ExecutionEnvironment = ExecutionEnvironment;
  		}
  
  	}());
  
  
  /***/ },
  /* 4 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var fetchKeys = __webpack_require__(5);
  
  	module.exports = function shallowEqual(objA, objB, compare, compareContext) {
  
  	    var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
  
  	    if (ret !== void 0) {
  	        return !!ret;
  	    }
  
  	    if (objA === objB) {
  	        return true;
  	    }
  
  	    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
  	        return false;
  	    }
  
  	    var keysA = fetchKeys(objA);
  	    var keysB = fetchKeys(objB);
  
  	    var len = keysA.length;
  	    if (len !== keysB.length) {
  	        return false;
  	    }
  
  	    compareContext = compareContext || null;
  
  	    // Test for A's keys different from B.
  	    var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
  	    for (var i = 0; i < len; i++) {
  	        var key = keysA[i];
  	        if (!bHasOwnProperty(key)) {
  	            return false;
  	        }
  	        var valueA = objA[key];
  	        var valueB = objB[key];
  
  	        var _ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
  	        if (_ret === false || _ret === void 0 && valueA !== valueB) {
  	            return false;
  	        }
  	    }
  
  	    return true;
  	};
  
  /***/ },
  /* 5 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * lodash 3.1.2 (Custom Build) <https://lodash.com/>
  	 * Build: `lodash modern modularize exports="npm" -o ./`
  	 * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
  	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
  	 * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  	 * Available under MIT license <https://lodash.com/license>
  	 */
  	var getNative = __webpack_require__(6),
  	    isArguments = __webpack_require__(7),
  	    isArray = __webpack_require__(8);
  
  	/** Used to detect unsigned integer values. */
  	var reIsUint = /^\d+$/;
  
  	/** Used for native method references. */
  	var objectProto = Object.prototype;
  
  	/** Used to check objects for own properties. */
  	var hasOwnProperty = objectProto.hasOwnProperty;
  
  	/* Native method references for those with the same name as other `lodash` methods. */
  	var nativeKeys = getNative(Object, 'keys');
  
  	/**
  	 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
  	 * of an array-like value.
  	 */
  	var MAX_SAFE_INTEGER = 9007199254740991;
  
  	/**
  	 * The base implementation of `_.property` without support for deep paths.
  	 *
  	 * @private
  	 * @param {string} key The key of the property to get.
  	 * @returns {Function} Returns the new function.
  	 */
  	function baseProperty(key) {
  	  return function(object) {
  	    return object == null ? undefined : object[key];
  	  };
  	}
  
  	/**
  	 * Gets the "length" property value of `object`.
  	 *
  	 * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
  	 * that affects Safari on at least iOS 8.1-8.3 ARM64.
  	 *
  	 * @private
  	 * @param {Object} object The object to query.
  	 * @returns {*} Returns the "length" value.
  	 */
  	var getLength = baseProperty('length');
  
  	/**
  	 * Checks if `value` is array-like.
  	 *
  	 * @private
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
  	 */
  	function isArrayLike(value) {
  	  return value != null && isLength(getLength(value));
  	}
  
  	/**
  	 * Checks if `value` is a valid array-like index.
  	 *
  	 * @private
  	 * @param {*} value The value to check.
  	 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
  	 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
  	 */
  	function isIndex(value, length) {
  	  value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;
  	  length = length == null ? MAX_SAFE_INTEGER : length;
  	  return value > -1 && value % 1 == 0 && value < length;
  	}
  
  	/**
  	 * Checks if `value` is a valid array-like length.
  	 *
  	 * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
  	 *
  	 * @private
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
  	 */
  	function isLength(value) {
  	  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
  	}
  
  	/**
  	 * A fallback implementation of `Object.keys` which creates an array of the
  	 * own enumerable property names of `object`.
  	 *
  	 * @private
  	 * @param {Object} object The object to query.
  	 * @returns {Array} Returns the array of property names.
  	 */
  	function shimKeys(object) {
  	  var props = keysIn(object),
  	      propsLength = props.length,
  	      length = propsLength && object.length;
  
  	  var allowIndexes = !!length && isLength(length) &&
  	    (isArray(object) || isArguments(object));
  
  	  var index = -1,
  	      result = [];
  
  	  while (++index < propsLength) {
  	    var key = props[index];
  	    if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
  	      result.push(key);
  	    }
  	  }
  	  return result;
  	}
  
  	/**
  	 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
  	 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
  	 * @example
  	 *
  	 * _.isObject({});
  	 * // => true
  	 *
  	 * _.isObject([1, 2, 3]);
  	 * // => true
  	 *
  	 * _.isObject(1);
  	 * // => false
  	 */
  	function isObject(value) {
  	  // Avoid a V8 JIT bug in Chrome 19-20.
  	  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
  	  var type = typeof value;
  	  return !!value && (type == 'object' || type == 'function');
  	}
  
  	/**
  	 * Creates an array of the own enumerable property names of `object`.
  	 *
  	 * **Note:** Non-object values are coerced to objects. See the
  	 * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)
  	 * for more details.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Object
  	 * @param {Object} object The object to query.
  	 * @returns {Array} Returns the array of property names.
  	 * @example
  	 *
  	 * function Foo() {
  	 *   this.a = 1;
  	 *   this.b = 2;
  	 * }
  	 *
  	 * Foo.prototype.c = 3;
  	 *
  	 * _.keys(new Foo);
  	 * // => ['a', 'b'] (iteration order is not guaranteed)
  	 *
  	 * _.keys('hi');
  	 * // => ['0', '1']
  	 */
  	var keys = !nativeKeys ? shimKeys : function(object) {
  	  var Ctor = object == null ? undefined : object.constructor;
  	  if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
  	      (typeof object != 'function' && isArrayLike(object))) {
  	    return shimKeys(object);
  	  }
  	  return isObject(object) ? nativeKeys(object) : [];
  	};
  
  	/**
  	 * Creates an array of the own and inherited enumerable property names of `object`.
  	 *
  	 * **Note:** Non-object values are coerced to objects.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Object
  	 * @param {Object} object The object to query.
  	 * @returns {Array} Returns the array of property names.
  	 * @example
  	 *
  	 * function Foo() {
  	 *   this.a = 1;
  	 *   this.b = 2;
  	 * }
  	 *
  	 * Foo.prototype.c = 3;
  	 *
  	 * _.keysIn(new Foo);
  	 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
  	 */
  	function keysIn(object) {
  	  if (object == null) {
  	    return [];
  	  }
  	  if (!isObject(object)) {
  	    object = Object(object);
  	  }
  	  var length = object.length;
  	  length = (length && isLength(length) &&
  	    (isArray(object) || isArguments(object)) && length) || 0;
  
  	  var Ctor = object.constructor,
  	      index = -1,
  	      isProto = typeof Ctor == 'function' && Ctor.prototype === object,
  	      result = Array(length),
  	      skipIndexes = length > 0;
  
  	  while (++index < length) {
  	    result[index] = (index + '');
  	  }
  	  for (var key in object) {
  	    if (!(skipIndexes && isIndex(key, length)) &&
  	        !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
  	      result.push(key);
  	    }
  	  }
  	  return result;
  	}
  
  	module.exports = keys;
  
  
  /***/ },
  /* 6 */
  /***/ function(module, exports) {
  
  	/**
  	 * lodash 3.9.1 (Custom Build) <https://lodash.com/>
  	 * Build: `lodash modern modularize exports="npm" -o ./`
  	 * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
  	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
  	 * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  	 * Available under MIT license <https://lodash.com/license>
  	 */
  
  	/** `Object#toString` result references. */
  	var funcTag = '[object Function]';
  
  	/** Used to detect host constructors (Safari > 5). */
  	var reIsHostCtor = /^\[object .+?Constructor\]$/;
  
  	/**
  	 * Checks if `value` is object-like.
  	 *
  	 * @private
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
  	 */
  	function isObjectLike(value) {
  	  return !!value && typeof value == 'object';
  	}
  
  	/** Used for native method references. */
  	var objectProto = Object.prototype;
  
  	/** Used to resolve the decompiled source of functions. */
  	var fnToString = Function.prototype.toString;
  
  	/** Used to check objects for own properties. */
  	var hasOwnProperty = objectProto.hasOwnProperty;
  
  	/**
  	 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
  	 * of values.
  	 */
  	var objToString = objectProto.toString;
  
  	/** Used to detect if a method is native. */
  	var reIsNative = RegExp('^' +
  	  fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
  	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
  	);
  
  	/**
  	 * Gets the native function at `key` of `object`.
  	 *
  	 * @private
  	 * @param {Object} object The object to query.
  	 * @param {string} key The key of the method to get.
  	 * @returns {*} Returns the function if it's native, else `undefined`.
  	 */
  	function getNative(object, key) {
  	  var value = object == null ? undefined : object[key];
  	  return isNative(value) ? value : undefined;
  	}
  
  	/**
  	 * Checks if `value` is classified as a `Function` object.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
  	 * @example
  	 *
  	 * _.isFunction(_);
  	 * // => true
  	 *
  	 * _.isFunction(/abc/);
  	 * // => false
  	 */
  	function isFunction(value) {
  	  // The use of `Object#toString` avoids issues with the `typeof` operator
  	  // in older versions of Chrome and Safari which return 'function' for regexes
  	  // and Safari 8 equivalents which return 'object' for typed array constructors.
  	  return isObject(value) && objToString.call(value) == funcTag;
  	}
  
  	/**
  	 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
  	 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
  	 * @example
  	 *
  	 * _.isObject({});
  	 * // => true
  	 *
  	 * _.isObject([1, 2, 3]);
  	 * // => true
  	 *
  	 * _.isObject(1);
  	 * // => false
  	 */
  	function isObject(value) {
  	  // Avoid a V8 JIT bug in Chrome 19-20.
  	  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
  	  var type = typeof value;
  	  return !!value && (type == 'object' || type == 'function');
  	}
  
  	/**
  	 * Checks if `value` is a native function.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
  	 * @example
  	 *
  	 * _.isNative(Array.prototype.push);
  	 * // => true
  	 *
  	 * _.isNative(_);
  	 * // => false
  	 */
  	function isNative(value) {
  	  if (value == null) {
  	    return false;
  	  }
  	  if (isFunction(value)) {
  	    return reIsNative.test(fnToString.call(value));
  	  }
  	  return isObjectLike(value) && reIsHostCtor.test(value);
  	}
  
  	module.exports = getNative;
  
  
  /***/ },
  /* 7 */
  /***/ function(module, exports) {
  
  	/**
  	 * lodash (Custom Build) <https://lodash.com/>
  	 * Build: `lodash modularize exports="npm" -o ./`
  	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
  	 * Released under MIT license <https://lodash.com/license>
  	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
  	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  	 */
  
  	/** Used as references for various `Number` constants. */
  	var MAX_SAFE_INTEGER = 9007199254740991;
  
  	/** `Object#toString` result references. */
  	var argsTag = '[object Arguments]',
  	    funcTag = '[object Function]',
  	    genTag = '[object GeneratorFunction]';
  
  	/** Used for built-in method references. */
  	var objectProto = Object.prototype;
  
  	/** Used to check objects for own properties. */
  	var hasOwnProperty = objectProto.hasOwnProperty;
  
  	/**
  	 * Used to resolve the
  	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
  	 * of values.
  	 */
  	var objectToString = objectProto.toString;
  
  	/** Built-in value references. */
  	var propertyIsEnumerable = objectProto.propertyIsEnumerable;
  
  	/**
  	 * Checks if `value` is likely an `arguments` object.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @since 0.1.0
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
  	 *  else `false`.
  	 * @example
  	 *
  	 * _.isArguments(function() { return arguments; }());
  	 * // => true
  	 *
  	 * _.isArguments([1, 2, 3]);
  	 * // => false
  	 */
  	function isArguments(value) {
  	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
  	  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
  	    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
  	}
  
  	/**
  	 * Checks if `value` is array-like. A value is considered array-like if it's
  	 * not a function and has a `value.length` that's an integer greater than or
  	 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @since 4.0.0
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
  	 * @example
  	 *
  	 * _.isArrayLike([1, 2, 3]);
  	 * // => true
  	 *
  	 * _.isArrayLike(document.body.children);
  	 * // => true
  	 *
  	 * _.isArrayLike('abc');
  	 * // => true
  	 *
  	 * _.isArrayLike(_.noop);
  	 * // => false
  	 */
  	function isArrayLike(value) {
  	  return value != null && isLength(value.length) && !isFunction(value);
  	}
  
  	/**
  	 * This method is like `_.isArrayLike` except that it also checks if `value`
  	 * is an object.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @since 4.0.0
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is an array-like object,
  	 *  else `false`.
  	 * @example
  	 *
  	 * _.isArrayLikeObject([1, 2, 3]);
  	 * // => true
  	 *
  	 * _.isArrayLikeObject(document.body.children);
  	 * // => true
  	 *
  	 * _.isArrayLikeObject('abc');
  	 * // => false
  	 *
  	 * _.isArrayLikeObject(_.noop);
  	 * // => false
  	 */
  	function isArrayLikeObject(value) {
  	  return isObjectLike(value) && isArrayLike(value);
  	}
  
  	/**
  	 * Checks if `value` is classified as a `Function` object.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @since 0.1.0
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
  	 * @example
  	 *
  	 * _.isFunction(_);
  	 * // => true
  	 *
  	 * _.isFunction(/abc/);
  	 * // => false
  	 */
  	function isFunction(value) {
  	  // The use of `Object#toString` avoids issues with the `typeof` operator
  	  // in Safari 8-9 which returns 'object' for typed array and other constructors.
  	  var tag = isObject(value) ? objectToString.call(value) : '';
  	  return tag == funcTag || tag == genTag;
  	}
  
  	/**
  	 * Checks if `value` is a valid array-like length.
  	 *
  	 * **Note:** This method is loosely based on
  	 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
  	 *
  	 * @static
  	 * @memberOf _
  	 * @since 4.0.0
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
  	 * @example
  	 *
  	 * _.isLength(3);
  	 * // => true
  	 *
  	 * _.isLength(Number.MIN_VALUE);
  	 * // => false
  	 *
  	 * _.isLength(Infinity);
  	 * // => false
  	 *
  	 * _.isLength('3');
  	 * // => false
  	 */
  	function isLength(value) {
  	  return typeof value == 'number' &&
  	    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
  	}
  
  	/**
  	 * Checks if `value` is the
  	 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
  	 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
  	 *
  	 * @static
  	 * @memberOf _
  	 * @since 0.1.0
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
  	 * @example
  	 *
  	 * _.isObject({});
  	 * // => true
  	 *
  	 * _.isObject([1, 2, 3]);
  	 * // => true
  	 *
  	 * _.isObject(_.noop);
  	 * // => true
  	 *
  	 * _.isObject(null);
  	 * // => false
  	 */
  	function isObject(value) {
  	  var type = typeof value;
  	  return !!value && (type == 'object' || type == 'function');
  	}
  
  	/**
  	 * Checks if `value` is object-like. A value is object-like if it's not `null`
  	 * and has a `typeof` result of "object".
  	 *
  	 * @static
  	 * @memberOf _
  	 * @since 4.0.0
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
  	 * @example
  	 *
  	 * _.isObjectLike({});
  	 * // => true
  	 *
  	 * _.isObjectLike([1, 2, 3]);
  	 * // => true
  	 *
  	 * _.isObjectLike(_.noop);
  	 * // => false
  	 *
  	 * _.isObjectLike(null);
  	 * // => false
  	 */
  	function isObjectLike(value) {
  	  return !!value && typeof value == 'object';
  	}
  
  	module.exports = isArguments;
  
  
  /***/ },
  /* 8 */
  /***/ function(module, exports) {
  
  	/**
  	 * lodash 3.0.4 (Custom Build) <https://lodash.com/>
  	 * Build: `lodash modern modularize exports="npm" -o ./`
  	 * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
  	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
  	 * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  	 * Available under MIT license <https://lodash.com/license>
  	 */
  
  	/** `Object#toString` result references. */
  	var arrayTag = '[object Array]',
  	    funcTag = '[object Function]';
  
  	/** Used to detect host constructors (Safari > 5). */
  	var reIsHostCtor = /^\[object .+?Constructor\]$/;
  
  	/**
  	 * Checks if `value` is object-like.
  	 *
  	 * @private
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
  	 */
  	function isObjectLike(value) {
  	  return !!value && typeof value == 'object';
  	}
  
  	/** Used for native method references. */
  	var objectProto = Object.prototype;
  
  	/** Used to resolve the decompiled source of functions. */
  	var fnToString = Function.prototype.toString;
  
  	/** Used to check objects for own properties. */
  	var hasOwnProperty = objectProto.hasOwnProperty;
  
  	/**
  	 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
  	 * of values.
  	 */
  	var objToString = objectProto.toString;
  
  	/** Used to detect if a method is native. */
  	var reIsNative = RegExp('^' +
  	  fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
  	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
  	);
  
  	/* Native method references for those with the same name as other `lodash` methods. */
  	var nativeIsArray = getNative(Array, 'isArray');
  
  	/**
  	 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
  	 * of an array-like value.
  	 */
  	var MAX_SAFE_INTEGER = 9007199254740991;
  
  	/**
  	 * Gets the native function at `key` of `object`.
  	 *
  	 * @private
  	 * @param {Object} object The object to query.
  	 * @param {string} key The key of the method to get.
  	 * @returns {*} Returns the function if it's native, else `undefined`.
  	 */
  	function getNative(object, key) {
  	  var value = object == null ? undefined : object[key];
  	  return isNative(value) ? value : undefined;
  	}
  
  	/**
  	 * Checks if `value` is a valid array-like length.
  	 *
  	 * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
  	 *
  	 * @private
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
  	 */
  	function isLength(value) {
  	  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
  	}
  
  	/**
  	 * Checks if `value` is classified as an `Array` object.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
  	 * @example
  	 *
  	 * _.isArray([1, 2, 3]);
  	 * // => true
  	 *
  	 * _.isArray(function() { return arguments; }());
  	 * // => false
  	 */
  	var isArray = nativeIsArray || function(value) {
  	  return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
  	};
  
  	/**
  	 * Checks if `value` is classified as a `Function` object.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
  	 * @example
  	 *
  	 * _.isFunction(_);
  	 * // => true
  	 *
  	 * _.isFunction(/abc/);
  	 * // => false
  	 */
  	function isFunction(value) {
  	  // The use of `Object#toString` avoids issues with the `typeof` operator
  	  // in older versions of Chrome and Safari which return 'function' for regexes
  	  // and Safari 8 equivalents which return 'object' for typed array constructors.
  	  return isObject(value) && objToString.call(value) == funcTag;
  	}
  
  	/**
  	 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
  	 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
  	 * @example
  	 *
  	 * _.isObject({});
  	 * // => true
  	 *
  	 * _.isObject([1, 2, 3]);
  	 * // => true
  	 *
  	 * _.isObject(1);
  	 * // => false
  	 */
  	function isObject(value) {
  	  // Avoid a V8 JIT bug in Chrome 19-20.
  	  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
  	  var type = typeof value;
  	  return !!value && (type == 'object' || type == 'function');
  	}
  
  	/**
  	 * Checks if `value` is a native function.
  	 *
  	 * @static
  	 * @memberOf _
  	 * @category Lang
  	 * @param {*} value The value to check.
  	 * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
  	 * @example
  	 *
  	 * _.isNative(Array.prototype.push);
  	 * // => true
  	 *
  	 * _.isNative(_);
  	 * // => false
  	 */
  	function isNative(value) {
  	  if (value == null) {
  	    return false;
  	  }
  	  if (isFunction(value)) {
  	    return reIsNative.test(fnToString.call(value));
  	  }
  	  return isObjectLike(value) && reIsHostCtor.test(value);
  	}
  
  	module.exports = isArray;
  
  
  /***/ },
  /* 9 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var pSlice = Array.prototype.slice;
  	var objectKeys = __webpack_require__(10);
  	var isArguments = __webpack_require__(11);
  
  	var deepEqual = module.exports = function (actual, expected, opts) {
  	  if (!opts) opts = {};
  	  // 7.1. All identical values are equivalent, as determined by ===.
  	  if (actual === expected) {
  	    return true;
  
  	  } else if (actual instanceof Date && expected instanceof Date) {
  	    return actual.getTime() === expected.getTime();
  
  	  // 7.3. Other pairs that do not both pass typeof value == 'object',
  	  // equivalence is determined by ==.
  	  } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {
  	    return opts.strict ? actual === expected : actual == expected;
  
  	  // 7.4. For all other Object pairs, including Array objects, equivalence is
  	  // determined by having the same number of owned properties (as verified
  	  // with Object.prototype.hasOwnProperty.call), the same set of keys
  	  // (although not necessarily the same order), equivalent values for every
  	  // corresponding key, and an identical 'prototype' property. Note: this
  	  // accounts for both named and indexed properties on Arrays.
  	  } else {
  	    return objEquiv(actual, expected, opts);
  	  }
  	}
  
  	function isUndefinedOrNull(value) {
  	  return value === null || value === undefined;
  	}
  
  	function isBuffer (x) {
  	  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;
  	  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
  	    return false;
  	  }
  	  if (x.length > 0 && typeof x[0] !== 'number') return false;
  	  return true;
  	}
  
  	function objEquiv(a, b, opts) {
  	  var i, key;
  	  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
  	    return false;
  	  // an identical 'prototype' property.
  	  if (a.prototype !== b.prototype) return false;
  	  //~~~I've managed to break Object.keys through screwy arguments passing.
  	  //   Converting to array solves the problem.
  	  if (isArguments(a)) {
  	    if (!isArguments(b)) {
  	      return false;
  	    }
  	    a = pSlice.call(a);
  	    b = pSlice.call(b);
  	    return deepEqual(a, b, opts);
  	  }
  	  if (isBuffer(a)) {
  	    if (!isBuffer(b)) {
  	      return false;
  	    }
  	    if (a.length !== b.length) return false;
  	    for (i = 0; i < a.length; i++) {
  	      if (a[i] !== b[i]) return false;
  	    }
  	    return true;
  	  }
  	  try {
  	    var ka = objectKeys(a),
  	        kb = objectKeys(b);
  	  } catch (e) {//happens when one is a string literal and the other isn't
  	    return false;
  	  }
  	  // having the same number of owned properties (keys incorporates
  	  // hasOwnProperty)
  	  if (ka.length != kb.length)
  	    return false;
  	  //the same set of keys (although not necessarily the same order),
  	  ka.sort();
  	  kb.sort();
  	  //~~~cheap key test
  	  for (i = ka.length - 1; i >= 0; i--) {
  	    if (ka[i] != kb[i])
  	      return false;
  	  }
  	  //equivalent values for every corresponding key, and
  	  //~~~possibly expensive deep test
  	  for (i = ka.length - 1; i >= 0; i--) {
  	    key = ka[i];
  	    if (!deepEqual(a[key], b[key], opts)) return false;
  	  }
  	  return typeof a === typeof b;
  	}
  
  
  /***/ },
  /* 10 */
  /***/ function(module, exports) {
  
  	exports = module.exports = typeof Object.keys === 'function'
  	  ? Object.keys : shim;
  
  	exports.shim = shim;
  	function shim (obj) {
  	  var keys = [];
  	  for (var key in obj) keys.push(key);
  	  return keys;
  	}
  
  
  /***/ },
  /* 11 */
  /***/ function(module, exports) {
  
  	var supportsArgumentsClass = (function(){
  	  return Object.prototype.toString.call(arguments)
  	})() == '[object Arguments]';
  
  	exports = module.exports = supportsArgumentsClass ? supported : unsupported;
  
  	exports.supported = supported;
  	function supported(object) {
  	  return Object.prototype.toString.call(object) == '[object Arguments]';
  	};
  
  	exports.unsupported = unsupported;
  	function unsupported(object){
  	  return object &&
  	    typeof object == 'object' &&
  	    typeof object.length == 'number' &&
  	    Object.prototype.hasOwnProperty.call(object, 'callee') &&
  	    !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||
  	    false;
  	};
  
  
  /***/ }
  /******/ ])
  });
  ;