		@@ -1,1392 +0,87 @@
		(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["ReactOutsideClickHandler"] = factory(require("react"));
		else
		root["ReactOutsideClickHandler"] = factory(root["React"]);
		})(this, function(__WEBPACK_EXTERNAL_MODULE_0__) {
		return /******/ (function(modules) { // webpackBootstrap
		/******/ // The module cache
		/******/ var installedModules = {};
		(function (global, factory) {
		typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('prop-types')) :
		typeof define === 'function' && define.amd ? define(['exports', 'react', 'prop-types'], factory) :
		(factory((global.ReactOutsideClickHandler = {}),global.React,global.PropTypes));
		}(this, (function (exports,React,PropTypes) { 'use strict';

		/******/ // The require function
		/******/ function __webpack_require__(moduleId) {
		React = React && React.hasOwnProperty('default') ? React['default'] : React;
		PropTypes = PropTypes && PropTypes.hasOwnProperty('default') ? PropTypes['default'] : PropTypes;

		/******/ // Check if module is in cache
		/******/ if(installedModules[moduleId])
		/******/ return installedModules[moduleId].exports;
		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; }; }();

		/******/ // Create a new module (and put it into the cache)
		/******/ var module = installedModules[moduleId] = {
		/******/ i: moduleId,
		/******/ l: false,
		/******/ exports: {}
		/******/ };
		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		/******/ // Execute the module function
		/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
		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; }

		/******/ // Flag the module as loaded
		/******/ module.l = true;
		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; }

		/******/ // 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;

		/******/ // identity function for calling harmony imports with the correct context
		/******/ __webpack_require__.i = function(value) { return value; };

		/******/ // define getter function for harmony exports
		/******/ __webpack_require__.d = function(exports, name, getter) {
		/******/ if(!__webpack_require__.o(exports, name)) {
		/******/ Object.defineProperty(exports, name, {
		/******/ configurable: false,
		/******/ enumerable: true,
		/******/ get: getter
		/******/ });
		/******/ }
		/******/ };

		/******/ // getDefaultExport function for compatibility with non-harmony modules
		/******/ __webpack_require__.n = function(module) {
		/******/ var getter = module && module.__esModule ?
		/******/ function getDefault() { return module['default']; } :
		/******/ function getModuleExports() { return module; };
		/******/ __webpack_require__.d(getter, 'a', getter);
		/******/ return getter;
		/******/ };

		/******/ // Object.prototype.hasOwnProperty.call
		/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

		/******/ // __webpack_public_path__
		/******/ __webpack_require__.p = "/";

		/******/ // Load entry module and return exports
		/******/ return __webpack_require__(__webpack_require__.s = "./lib/OutsideClickHandler.jsx");
		/******/ })
		/************************************************************************/
		/******/ ({

		/***/ "./lib/OutsideClickHandler.jsx":
		/***/ (function(module, exports, __webpack_require__) {

		"use strict";


		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

		var _react = __webpack_require__(0);

		var _react2 = _interopRequireDefault(_react);

		var _propTypes = __webpack_require__("./node_modules/prop-types/index.js");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		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 propTypes = {
		children: _propTypes2.default.node,
		useCapture: _propTypes2.default.bool,
		onOutsideClick: _propTypes2.default.func
		};

		var defaultProps = {
		children: _react2.default.createElement('span', null),
		useCapture: true,
		onOutsideClick: function onOutsideClick() {}
		};

		var OutsideClickHandler = function (_React$Component) {
		_inherits(OutsideClickHandler, _React$Component);

		function OutsideClickHandler(props) {
		_classCallCheck(this, OutsideClickHandler);

		var _this = _possibleConstructorReturn(this, (OutsideClickHandler.__proto__ \|\| Object.getPrototypeOf(OutsideClickHandler)).call(this, props));

		_this.handleOutsideClick = _this.handleOutsideClick.bind(_this);
		return _this;
		}

		_createClass(OutsideClickHandler, [{
		key: 'componentDidMount',
		value: function componentDidMount() {
		if (document.addEventListener) {
		document.addEventListener('click', this.handleOutsideClick, this.props.useCapture);
		} else {
		document.attachEvent('onclick', this.handleOutsideClick);
		}
		}
		}, {
		key: 'componentWillUnmount',
		value: function componentWillUnmount() {
		if (document.removeEventListener) {
		document.removeEventListener('click', this.handleOutsideClick, this.props.useCapture);
		} else {
		document.detachEvent('onclick', this.handleOutsideClick);
		}
		}
		}, {
		key: 'handleOutsideClick',
		value: function handleOutsideClick(e) {
		var isDescendantOfRoot = this.childNode.contains(e.target);
		if (!isDescendantOfRoot) {
		this.props.onOutsideClick(e);
		}
		}
		}, {
		key: 'render',
		value: function render() {
		var _this2 = this;

		return _react2.default.createElement(
		'div',
		{ ref: function ref(_ref) {
		_this2.childNode = _ref;
		} },
		this.props.children
		);
		}
		}]);

		return OutsideClickHandler;
		}(_react2.default.Component);

		OutsideClickHandler.propTypes = propTypes;
		OutsideClickHandler.defaultProps = defaultProps;

		exports.default = OutsideClickHandler;

		/***/ }),

		/***/ "./node_modules/fbjs/lib/emptyFunction.js":
		/***/ (function(module, exports, __webpack_require__) {

		"use strict";


		/**
		* Copyright (c) 2013-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*
		*
		*/

		function makeEmptyFunction(arg) {
		return function () {
		return arg;
		var propTypes = {
		children: PropTypes.node,
		useCapture: PropTypes.bool,
		onOutsideClick: PropTypes.func
		};
		}

		/**
		* This function accepts and discards inputs; it has no side effects. This is
		* primarily useful idiomatically for overridable function endpoints which
		* always need to be callable, since JS lacks a null-call idiom ala Cocoa.
		*/
		var emptyFunction = function emptyFunction() {};

		emptyFunction.thatReturns = makeEmptyFunction;
		emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
		emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
		emptyFunction.thatReturnsNull = makeEmptyFunction(null);
		emptyFunction.thatReturnsThis = function () {
		return this;
		};
		emptyFunction.thatReturnsArgument = function (arg) {
		return arg;
		};

		module.exports = emptyFunction;

		/***/ }),

		/***/ "./node_modules/fbjs/lib/invariant.js":
		/***/ (function(module, exports, __webpack_require__) {

		"use strict";
		/* WEBPACK VAR INJECTION /(function(process) {/*
		* Copyright (c) 2013-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*
		*/



		/**
		* Use invariant() to assert state which your program assumes to be true.
		*
		* Provide sprintf-style format (only %s is supported) and arguments
		* to provide information about what broke and what you were
		* expecting.
		*
		* The invariant message will be stripped in production, but the invariant
		* will remain to ensure logic does not differ in production.
		*/

		var validateFormat = function validateFormat(format) {};

		if (process.env.NODE_ENV !== 'production') {
		validateFormat = function validateFormat(format) {
		if (format === undefined) {
		throw new Error('invariant requires an error message argument');
		}
		var defaultProps = {
		children: React.createElement('span', null),
		useCapture: true,
		onOutsideClick: function onOutsideClick() {}
		};
		}

		function invariant(condition, format, a, b, c, d, e, f) {
		validateFormat(format);
		var OutsideClickHandler = function (_React$Component) {
		_inherits(OutsideClickHandler, _React$Component);

		if (!condition) {
		var error;
		if (format === undefined) {
		error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
		} else {
		var args = [a, b, c, d, e, f];
		var argIndex = 0;
		error = new Error(format.replace(/%s/g, function () {
		return args[argIndex++];
		}));
		error.name = 'Invariant Violation';
		}
		function OutsideClickHandler(props) {
		_classCallCheck(this, OutsideClickHandler);

		error.framesToPop = 1; // we don't care about invariant's own frame
		throw error;
		}
		}
		var _this = _possibleConstructorReturn(this, (OutsideClickHandler.__proto__ \|\| Object.getPrototypeOf(OutsideClickHandler)).call(this, props));

		module.exports = invariant;
		/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__("./node_modules/process/browser.js")))

		/***/ }),

		/***/ "./node_modules/fbjs/lib/warning.js":
		/***/ (function(module, exports, __webpack_require__) {

		"use strict";
		/* WEBPACK VAR INJECTION /(function(process) {/*
		* Copyright (c) 2014-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*
		*/



		var emptyFunction = __webpack_require__("./node_modules/fbjs/lib/emptyFunction.js");

		/**
		* Similar to invariant but only logs a warning if the condition is not met.
		* This can be used to log issues in development environments in critical
		* paths. Removing the logging code for production environments will keep the
		* same logic and follow the same code paths.
		*/

		var warning = emptyFunction;

		if (process.env.NODE_ENV !== 'production') {
		var printWarning = function printWarning(format) {
		for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
		args[_key - 1] = arguments[_key];
		_this.handleOutsideClick = _this.handleOutsideClick.bind(_this);
		_this.setChildNode = _this.setChildNode.bind(_this);
		return _this;
		}

		var argIndex = 0;
		var message = 'Warning: ' + format.replace(/%s/g, function () {
		return args[argIndex++];
		});
		if (typeof console !== 'undefined') {
		console.error(message);
		}
		try {
		// --- Welcome to debugging React ---
		// This error was thrown as a convenience so that you can use this stack
		// to find the callsite that caused this warning to fire.
		throw new Error(message);
		} catch (x) {}
		};

		warning = function warning(condition, format) {
		if (format === undefined) {
		throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
		}

		if (format.indexOf('Failed Composite propType: ') === 0) {
		return; // Ignore CompositeComponent proptype check.
		}

		if (!condition) {
		for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
		args[_key2 - 2] = arguments[_key2];
		_createClass(OutsideClickHandler, [{
		key: 'componentDidMount',
		value: function componentDidMount() {
		document.addEventListener('click', this.handleOutsideClick, this.props.useCapture);
		}

		printWarning.apply(undefined, [format].concat(args));
		}
		};
		}

		module.exports = warning;
		/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__("./node_modules/process/browser.js")))

		/***/ }),

		/***/ "./node_modules/process/browser.js":
		/***/ (function(module, exports) {

		// shim for using process in browser
		var process = module.exports = {};

		// cached from whatever global is present so that test runners that stub it
		// don't break things. But we need to wrap it in a try catch in case it is
		// wrapped in strict mode code which doesn't define any globals. It's inside a
		// function because try/catches deoptimize in certain engines.

		var cachedSetTimeout;
		var cachedClearTimeout;

		function defaultSetTimout() {
		throw new Error('setTimeout has not been defined');
		}
		function defaultClearTimeout () {
		throw new Error('clearTimeout has not been defined');
		}
		(function () {
		try {
		if (typeof setTimeout === 'function') {
		cachedSetTimeout = setTimeout;
		} else {
		cachedSetTimeout = defaultSetTimout;
		}
		} catch (e) {
		cachedSetTimeout = defaultSetTimout;
		}
		try {
		if (typeof clearTimeout === 'function') {
		cachedClearTimeout = clearTimeout;
		} else {
		cachedClearTimeout = defaultClearTimeout;
		}
		} catch (e) {
		cachedClearTimeout = defaultClearTimeout;
		}
		} ())
		function runTimeout(fun) {
		if (cachedSetTimeout === setTimeout) {
		//normal enviroments in sane situations
		return setTimeout(fun, 0);
		}
		// if setTimeout wasn't available but was latter defined
		if ((cachedSetTimeout === defaultSetTimout \|\| !cachedSetTimeout) && setTimeout) {
		cachedSetTimeout = setTimeout;
		return setTimeout(fun, 0);
		}
		try {
		// when when somebody has screwed with setTimeout but no I.E. maddness
		return cachedSetTimeout(fun, 0);
		} catch(e){
		try {
		// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
		return cachedSetTimeout.call(null, fun, 0);
		} catch(e){
		// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
		return cachedSetTimeout.call(this, fun, 0);
		}
		}


		}
		function runClearTimeout(marker) {
		if (cachedClearTimeout === clearTimeout) {
		//normal enviroments in sane situations
		return clearTimeout(marker);
		}
		// if clearTimeout wasn't available but was latter defined
		if ((cachedClearTimeout === defaultClearTimeout \|\| !cachedClearTimeout) && clearTimeout) {
		cachedClearTimeout = clearTimeout;
		return clearTimeout(marker);
		}
		try {
		// when when somebody has screwed with setTimeout but no I.E. maddness
		return cachedClearTimeout(marker);
		} catch (e){
		try {
		// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
		return cachedClearTimeout.call(null, marker);
		} catch (e){
		// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
		// Some versions of I.E. have different rules for clearTimeout vs setTimeout
		return cachedClearTimeout.call(this, marker);
		}
		}



		}
		var queue = [];
		var draining = false;
		var currentQueue;
		var queueIndex = -1;

		function cleanUpNextTick() {
		if (!draining \|\| !currentQueue) {
		return;
		}
		draining = false;
		if (currentQueue.length) {
		queue = currentQueue.concat(queue);
		} else {
		queueIndex = -1;
		}
		if (queue.length) {
		drainQueue();
		}
		}

		function drainQueue() {
		if (draining) {
		return;
		}
		var timeout = runTimeout(cleanUpNextTick);
		draining = true;

		var len = queue.length;
		while(len) {
		currentQueue = queue;
		queue = [];
		while (++queueIndex < len) {
		if (currentQueue) {
		currentQueue[queueIndex].run();
		}
		}
		queueIndex = -1;
		len = queue.length;
		}
		currentQueue = null;
		draining = false;
		runClearTimeout(timeout);
		}

		process.nextTick = function (fun) {
		var args = new Array(arguments.length - 1);
		if (arguments.length > 1) {
		for (var i = 1; i < arguments.length; i++) {
		args[i - 1] = arguments[i];
		}
		}
		queue.push(new Item(fun, args));
		if (queue.length === 1 && !draining) {
		runTimeout(drainQueue);
		}
		};

		// v8 likes predictible objects
		function Item(fun, array) {
		this.fun = fun;
		this.array = array;
		}
		Item.prototype.run = function () {
		this.fun.apply(null, this.array);
		};
		process.title = 'browser';
		process.browser = true;
		process.env = {};
		process.argv = [];
		process.version = ''; // empty string to avoid regexp issues
		process.versions = {};

		function noop() {}

		process.on = noop;
		process.addListener = noop;
		process.once = noop;
		process.off = noop;
		process.removeListener = noop;
		process.removeAllListeners = noop;
		process.emit = noop;

		process.binding = function (name) {
		throw new Error('process.binding is not supported');
		};

		process.cwd = function () { return '/' };
		process.chdir = function (dir) {
		throw new Error('process.chdir is not supported');
		};
		process.umask = function() { return 0; };


		/***/ }),

		/***/ "./node_modules/prop-types/checkPropTypes.js":
		/***/ (function(module, exports, __webpack_require__) {

		"use strict";
		/* WEBPACK VAR INJECTION /(function(process) {/*
		* Copyright (c) 2013-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*/



		if (process.env.NODE_ENV !== 'production') {
		var invariant = __webpack_require__("./node_modules/fbjs/lib/invariant.js");
		var warning = __webpack_require__("./node_modules/fbjs/lib/warning.js");
		var ReactPropTypesSecret = __webpack_require__("./node_modules/prop-types/lib/ReactPropTypesSecret.js");
		var loggedTypeFailures = {};
		}

		/**
		* Assert that the values match with the type specs.
		* Error messages are memorized and will only be shown once.
		*
		* @param {object} typeSpecs Map of name to a ReactPropType
		* @param {object} values Runtime values that need to be type-checked
		* @param {string} location e.g. "prop", "context", "child context"
		* @param {string} componentName Name of the component for error messages.
		* @param {?Function} getStack Returns the component stack.
		* @private
		*/
		function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
		if (process.env.NODE_ENV !== 'production') {
		for (var typeSpecName in typeSpecs) {
		if (typeSpecs.hasOwnProperty(typeSpecName)) {
		var error;
		// Prop type validation may throw. In case they do, we don't want to
		// fail the render phase where it didn't fail before. So we log it.
		// After these have been cleaned up, we'll let them throw.
		try {
		// This is intentionally an invariant that gets caught. It's the same
		// behavior as without this statement except with a better message.
		invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName \|\| 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]);
		error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
		} catch (ex) {
		error = ex;
		}
		warning(!error \|\| error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName \|\| 'React class', location, typeSpecName, typeof error);
		if (error instanceof Error && !(error.message in loggedTypeFailures)) {
		// Only monitor this failure once because there tends to be a lot of the
		// same error.
		loggedTypeFailures[error.message] = true;

		var stack = getStack ? getStack() : '';

		warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');
		}
		}, {
		key: 'componentWillUnmount',
		value: function componentWillUnmount() {
		document.removeEventListener('click', this.handleOutsideClick, this.props.useCapture);
		}
		}
		}
		}

		module.exports = checkPropTypes;

		/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__("./node_modules/process/browser.js")))

		/***/ }),

		/***/ "./node_modules/prop-types/factoryWithThrowingShims.js":
		/***/ (function(module, exports, __webpack_require__) {

		"use strict";
		/**
		* Copyright (c) 2013-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*/



		var emptyFunction = __webpack_require__("./node_modules/fbjs/lib/emptyFunction.js");
		var invariant = __webpack_require__("./node_modules/fbjs/lib/invariant.js");
		var ReactPropTypesSecret = __webpack_require__("./node_modules/prop-types/lib/ReactPropTypesSecret.js");

		module.exports = function() {
		function shim(props, propName, componentName, location, propFullName, secret) {
		if (secret === ReactPropTypesSecret) {
		// It is still safe when called from React.
		return;
		}
		invariant(
		false,
		'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
		'Use PropTypes.checkPropTypes() to call them. ' +
		'Read more at http://fb.me/use-check-prop-types'
		);
		};
		shim.isRequired = shim;
		function getShim() {
		return shim;
		};
		// Important!
		// Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
		var ReactPropTypes = {
		array: shim,
		bool: shim,
		func: shim,
		number: shim,
		object: shim,
		string: shim,
		symbol: shim,

		any: shim,
		arrayOf: getShim,
		element: shim,
		instanceOf: getShim,
		node: shim,
		objectOf: getShim,
		oneOf: getShim,
		oneOfType: getShim,
		shape: getShim,
		exact: getShim
		};

		ReactPropTypes.checkPropTypes = emptyFunction;
		ReactPropTypes.PropTypes = ReactPropTypes;

		return ReactPropTypes;
		};


		/***/ }),

		/***/ "./node_modules/prop-types/factoryWithTypeCheckers.js":
		/***/ (function(module, exports, __webpack_require__) {

		"use strict";
		/* WEBPACK VAR INJECTION /(function(process) {/*
		* Copyright (c) 2013-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*/



		var emptyFunction = __webpack_require__("./node_modules/fbjs/lib/emptyFunction.js");
		var invariant = __webpack_require__("./node_modules/fbjs/lib/invariant.js");
		var warning = __webpack_require__("./node_modules/fbjs/lib/warning.js");
		var assign = __webpack_require__("./node_modules/prop-types/node_modules/object-assign/index.js");

		var ReactPropTypesSecret = __webpack_require__("./node_modules/prop-types/lib/ReactPropTypesSecret.js");
		var checkPropTypes = __webpack_require__("./node_modules/prop-types/checkPropTypes.js");

		module.exports = function(isValidElement, throwOnDirectAccess) {
		/* global Symbol */
		var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
		var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.

		/**
		* Returns the iterator method function contained on the iterable object.
		*
		* Be sure to invoke the function with the iterable as context:
		*
		* var iteratorFn = getIteratorFn(myIterable);
		* if (iteratorFn) {
		* var iterator = iteratorFn.call(myIterable);
		* ...
		* }
		*
		* @param {?object} maybeIterable
		* @return {?function}
		*/
		function getIteratorFn(maybeIterable) {
		var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] \|\| maybeIterable[FAUX_ITERATOR_SYMBOL]);
		if (typeof iteratorFn === 'function') {
		return iteratorFn;
		}
		}

		/**
		* Collection of methods that allow declaration and validation of props that are
		* supplied to React components. Example usage:
		*
		* var Props = require('ReactPropTypes');
		* var MyArticle = React.createClass({
		* propTypes: {
		* // An optional string prop named "description".
		* description: Props.string,
		*
		* // A required enum prop named "category".
		* category: Props.oneOf(['News','Photos']).isRequired,
		*
		* // A prop named "dialog" that requires an instance of Dialog.
		* dialog: Props.instanceOf(Dialog).isRequired
		* },
		* render: function() { ... }
		* });
		*
		* A more formal specification of how these methods are used:
		*
		* type := array\|bool\|func\|object\|number\|string\|oneOf([...])\|instanceOf(...)
		* decl := ReactPropTypes.{type}(.isRequired)?
		*
		* Each and every declaration produces a function with the same signature. This
		* allows the creation of custom validation functions. For example:
		*
		* var MyLink = React.createClass({
		* propTypes: {
		* // An optional string or URI prop named "href".
		* href: function(props, propName, componentName) {
		* var propValue = props[propName];
		* if (propValue != null && typeof propValue !== 'string' &&
		* !(propValue instanceof URI)) {
		* return new Error(
		* 'Expected a string or an URI for ' + propName + ' in ' +
		* componentName
		* );
		* }
		* }
		* },
		* render: function() {...}
		* });
		*
		* @internal
		*/

		var ANONYMOUS = '<<anonymous>>';

		// Important!
		// Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
		var ReactPropTypes = {
		array: createPrimitiveTypeChecker('array'),
		bool: createPrimitiveTypeChecker('boolean'),
		func: createPrimitiveTypeChecker('function'),
		number: createPrimitiveTypeChecker('number'),
		object: createPrimitiveTypeChecker('object'),
		string: createPrimitiveTypeChecker('string'),
		symbol: createPrimitiveTypeChecker('symbol'),

		any: createAnyTypeChecker(),
		arrayOf: createArrayOfTypeChecker,
		element: createElementTypeChecker(),
		instanceOf: createInstanceTypeChecker,
		node: createNodeChecker(),
		objectOf: createObjectOfTypeChecker,
		oneOf: createEnumTypeChecker,
		oneOfType: createUnionTypeChecker,
		shape: createShapeTypeChecker,
		exact: createStrictShapeTypeChecker,
		};

		/**
		* inlined Object.is polyfill to avoid requiring consumers ship their own
		* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
		*/
		/eslint-disable no-self-compare/
		function is(x, y) {
		// SameValue algorithm
		if (x === y) {
		// Steps 1-5, 7-10
		// Steps 6.b-6.e: +0 != -0
		return x !== 0 \|\| 1 / x === 1 / y;
		} else {
		// Step 6.a: NaN == NaN
		return x !== x && y !== y;
		}
		}
		/eslint-enable no-self-compare/

		/**
		* We use an Error-like object for backward compatibility as people may call
		* PropTypes directly and inspect their output. However, we don't use real
		* Errors anymore. We don't inspect their stack anyway, and creating them
		* is prohibitively expensive if they are created too often, such as what
		* happens in oneOfType() for any type before the one that matched.
		*/
		function PropTypeError(message) {
		this.message = message;
		this.stack = '';
		}
		// Make `instanceof Error` still work for returned errors.
		PropTypeError.prototype = Error.prototype;

		function createChainableTypeChecker(validate) {
		if (process.env.NODE_ENV !== 'production') {
		var manualPropTypeCallCache = {};
		var manualPropTypeWarningCount = 0;
		}
		function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
		componentName = componentName \|\| ANONYMOUS;
		propFullName = propFullName \|\| propName;

		if (secret !== ReactPropTypesSecret) {
		if (throwOnDirectAccess) {
		// New behavior only for users of `prop-types` package
		invariant(
		false,
		'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
		'Use `PropTypes.checkPropTypes()` to call them. ' +
		'Read more at http://fb.me/use-check-prop-types'
		);
		} else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
		// Old behavior for people using React.PropTypes
		var cacheKey = componentName + ':' + propName;
		if (
		!manualPropTypeCallCache[cacheKey] &&
		// Avoid spamming the console because they are often not actionable except for lib authors
		manualPropTypeWarningCount < 3
		) {
		warning(
		false,
		'You are manually calling a React.PropTypes validation ' +
		'function for the `%s` prop on `%s`. This is deprecated ' +
		'and will throw in the standalone `prop-types` package. ' +
		'You may be seeing this warning due to a third-party PropTypes ' +
		'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',
		propFullName,
		componentName
		);
		manualPropTypeCallCache[cacheKey] = true;
		manualPropTypeWarningCount++;
		}
		}
		}, {
		key: 'setChildNode',
		value: function setChildNode(ref) {
		this.childNode = ref;
		}
		if (props[propName] == null) {
		if (isRequired) {
		if (props[propName] === null) {
		return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
		}
		return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
		}, {
		key: 'handleOutsideClick',
		value: function handleOutsideClick(e) {
		var isDescendantOfRoot = this.childNode.contains(e.target);
		if (!isDescendantOfRoot) {
		this.props.onOutsideClick(e);
		}
		return null;
		} else {
		return validate(props, propName, componentName, location, propFullName);
		}
		}

		var chainedCheckType = checkType.bind(null, false);
		chainedCheckType.isRequired = checkType.bind(null, true);

		return chainedCheckType;
		}

		function createPrimitiveTypeChecker(expectedType) {
		function validate(props, propName, componentName, location, propFullName, secret) {
		var propValue = props[propName];
		var propType = getPropType(propValue);
		if (propType !== expectedType) {
		// `propValue` being instance of, say, date/regexp, pass the 'object'
		// check, but we can offer a more precise error message here rather than
		// 'of type `object`'.
		var preciseType = getPreciseType(propValue);

		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
		}
		return null;
		}
		return createChainableTypeChecker(validate);
		}

		function createAnyTypeChecker() {
		return createChainableTypeChecker(emptyFunction.thatReturnsNull);
		}

		function createArrayOfTypeChecker(typeChecker) {
		function validate(props, propName, componentName, location, propFullName) {
		if (typeof typeChecker !== 'function') {
		return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
		}
		var propValue = props[propName];
		if (!Array.isArray(propValue)) {
		var propType = getPropType(propValue);
		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
		}
		for (var i = 0; i < propValue.length; i++) {
		var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
		if (error instanceof Error) {
		return error;
		}
		}
		return null;
		}
		return createChainableTypeChecker(validate);
		}

		function createElementTypeChecker() {
		function validate(props, propName, componentName, location, propFullName) {
		var propValue = props[propName];
		if (!isValidElement(propValue)) {
		var propType = getPropType(propValue);
		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
		}
		return null;
		}
		return createChainableTypeChecker(validate);
		}

		function createInstanceTypeChecker(expectedClass) {
		function validate(props, propName, componentName, location, propFullName) {
		if (!(props[propName] instanceof expectedClass)) {
		var expectedClassName = expectedClass.name \|\| ANONYMOUS;
		var actualClassName = getClassName(props[propName]);
		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
		}
		return null;
		}
		return createChainableTypeChecker(validate);
		}

		function createEnumTypeChecker(expectedValues) {
		if (!Array.isArray(expectedValues)) {
		process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
		return emptyFunction.thatReturnsNull;
		}

		function validate(props, propName, componentName, location, propFullName) {
		var propValue = props[propName];
		for (var i = 0; i < expectedValues.length; i++) {
		if (is(propValue, expectedValues[i])) {
		return null;
		}
		}

		var valuesString = JSON.stringify(expectedValues);
		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
		}
		return createChainableTypeChecker(validate);
		}

		function createObjectOfTypeChecker(typeChecker) {
		function validate(props, propName, componentName, location, propFullName) {
		if (typeof typeChecker !== 'function') {
		return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
		}
		var propValue = props[propName];
		var propType = getPropType(propValue);
		if (propType !== 'object') {
		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
		}
		for (var key in propValue) {
		if (propValue.hasOwnProperty(key)) {
		var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
		if (error instanceof Error) {
		return error;
		}
		}
		}
		return null;
		}
		return createChainableTypeChecker(validate);
		}

		function createUnionTypeChecker(arrayOfTypeCheckers) {
		if (!Array.isArray(arrayOfTypeCheckers)) {
		process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
		return emptyFunction.thatReturnsNull;
		}

		for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
		var checker = arrayOfTypeCheckers[i];
		if (typeof checker !== 'function') {
		warning(
		false,
		'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
		'received %s at index %s.',
		getPostfixForTypeWarning(checker),
		i
		}, {
		key: 'render',
		value: function render() {
		return React.createElement(
		'div',
		{ ref: this.setChildNode },
		this.props.children
		);
		return emptyFunction.thatReturnsNull;
		}
		}
		}]);

		function validate(props, propName, componentName, location, propFullName) {
		for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
		var checker = arrayOfTypeCheckers[i];
		if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
		return null;
		}
		}
		return OutsideClickHandler;
		}(React.Component);

		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
		}
		return createChainableTypeChecker(validate);
		}
		OutsideClickHandler.propTypes = propTypes;
		OutsideClickHandler.defaultProps = defaultProps;

		function createNodeChecker() {
		function validate(props, propName, componentName, location, propFullName) {
		if (!isNode(props[propName])) {
		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
		}
		return null;
		}
		return createChainableTypeChecker(validate);
		}
		exports.default = OutsideClickHandler;

		function createShapeTypeChecker(shapeTypes) {
		function validate(props, propName, componentName, location, propFullName) {
		var propValue = props[propName];
		var propType = getPropType(propValue);
		if (propType !== 'object') {
		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
		}
		for (var key in shapeTypes) {
		var checker = shapeTypes[key];
		if (!checker) {
		continue;
		}
		var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
		if (error) {
		return error;
		}
		}
		return null;
		}
		return createChainableTypeChecker(validate);
		}
		Object.defineProperty(exports, '__esModule', { value: true });

		function createStrictShapeTypeChecker(shapeTypes) {
		function validate(props, propName, componentName, location, propFullName) {
		var propValue = props[propName];
		var propType = getPropType(propValue);
		if (propType !== 'object') {
		return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
		}
		// We need to check all keys in case some are required but missing from
		// props.
		var allKeys = assign({}, props[propName], shapeTypes);
		for (var key in allKeys) {
		var checker = shapeTypes[key];
		if (!checker) {
		return new PropTypeError(
		'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
		'\nBad object: ' + JSON.stringify(props[propName], null, ' ') +
		'\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ')
		);
		}
		var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
		if (error) {
		return error;
		}
		}
		return null;
		}

		return createChainableTypeChecker(validate);
		}

		function isNode(propValue) {
		switch (typeof propValue) {
		case 'number':
		case 'string':
		case 'undefined':
		return true;
		case 'boolean':
		return !propValue;
		case 'object':
		if (Array.isArray(propValue)) {
		return propValue.every(isNode);
		}
		if (propValue === null \|\| isValidElement(propValue)) {
		return true;
		}

		var iteratorFn = getIteratorFn(propValue);
		if (iteratorFn) {
		var iterator = iteratorFn.call(propValue);
		var step;
		if (iteratorFn !== propValue.entries) {
		while (!(step = iterator.next()).done) {
		if (!isNode(step.value)) {
		return false;
		}
		}
		} else {
		// Iterator will provide entry [k,v] tuples rather than values.
		while (!(step = iterator.next()).done) {
		var entry = step.value;
		if (entry) {
		if (!isNode(entry[1])) {
		return false;
		}
		}
		}
		}
		} else {
		return false;
		}

		return true;
		default:
		return false;
		}
		}

		function isSymbol(propType, propValue) {
		// Native Symbol.
		if (propType === 'symbol') {
		return true;
		}

		// 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
		if (propValue['@@toStringTag'] === 'Symbol') {
		return true;
		}

		// Fallback for non-spec compliant Symbols which are polyfilled.
		if (typeof Symbol === 'function' && propValue instanceof Symbol) {
		return true;
		}

		return false;
		}

		// Equivalent of `typeof` but with special handling for array and regexp.
		function getPropType(propValue) {
		var propType = typeof propValue;
		if (Array.isArray(propValue)) {
		return 'array';
		}
		if (propValue instanceof RegExp) {
		// Old webkits (at least until Android 4.0) return 'function' rather than
		// 'object' for typeof a RegExp. We'll normalize this here so that /bla/
		// passes PropTypes.object.
		return 'object';
		}
		if (isSymbol(propType, propValue)) {
		return 'symbol';
		}
		return propType;
		}

		// This handles more types than `getPropType`. Only used for error messages.
		// See `createPrimitiveTypeChecker`.
		function getPreciseType(propValue) {
		if (typeof propValue === 'undefined' \|\| propValue === null) {
		return '' + propValue;
		}
		var propType = getPropType(propValue);
		if (propType === 'object') {
		if (propValue instanceof Date) {
		return 'date';
		} else if (propValue instanceof RegExp) {
		return 'regexp';
		}
		}
		return propType;
		}

		// Returns a string that is postfixed to a warning about an invalid type.
		// For example, "undefined" or "of type array"
		function getPostfixForTypeWarning(value) {
		var type = getPreciseType(value);
		switch (type) {
		case 'array':
		case 'object':
		return 'an ' + type;
		case 'boolean':
		case 'date':
		case 'regexp':
		return 'a ' + type;
		default:
		return type;
		}
		}

		// Returns class name of the object, if any.
		function getClassName(propValue) {
		if (!propValue.constructor \|\| !propValue.constructor.name) {
		return ANONYMOUS;
		}
		return propValue.constructor.name;
		}

		ReactPropTypes.checkPropTypes = checkPropTypes;
		ReactPropTypes.PropTypes = ReactPropTypes;

		return ReactPropTypes;
		};

		/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__("./node_modules/process/browser.js")))

		/***/ }),

		/***/ "./node_modules/prop-types/index.js":
		/***/ (function(module, exports, __webpack_require__) {

		/* WEBPACK VAR INJECTION /(function(process) {/*
		* Copyright (c) 2013-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*/

		if (process.env.NODE_ENV !== 'production') {
		var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&
		Symbol.for &&
		Symbol.for('react.element')) \|\|
		0xeac7;

		var isValidElement = function(object) {
		return typeof object === 'object' &&
		object !== null &&
		object.$$typeof === REACT_ELEMENT_TYPE;
		};

		// By explicitly using `prop-types` you are opting into new development behavior.
		// http://fb.me/prop-types-in-prod
		var throwOnDirectAccess = true;
		module.exports = __webpack_require__("./node_modules/prop-types/factoryWithTypeCheckers.js")(isValidElement, throwOnDirectAccess);
		} else {
		// By explicitly using `prop-types` you are opting into new production behavior.
		// http://fb.me/prop-types-in-prod
		module.exports = __webpack_require__("./node_modules/prop-types/factoryWithThrowingShims.js")();
		}

		/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__("./node_modules/process/browser.js")))

		/***/ }),

		/***/ "./node_modules/prop-types/lib/ReactPropTypesSecret.js":
		/***/ (function(module, exports, __webpack_require__) {

		"use strict";
		/**
		* Copyright (c) 2013-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*/



		var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

		module.exports = ReactPropTypesSecret;


		/***/ }),

		/***/ "./node_modules/prop-types/node_modules/object-assign/index.js":
		/***/ (function(module, exports, __webpack_require__) {

		"use strict";
		/*
		object-assign
		(c) Sindre Sorhus
		@license MIT
		*/


		/* eslint-disable no-unused-vars */
		var getOwnPropertySymbols = Object.getOwnPropertySymbols;
		var hasOwnProperty = Object.prototype.hasOwnProperty;
		var propIsEnumerable = Object.prototype.propertyIsEnumerable;

		function toObject(val) {
		if (val === null \|\| val === undefined) {
		throw new TypeError('Object.assign cannot be called with null or undefined');
		}

		return Object(val);
		}

		function shouldUseNative() {
		try {
		if (!Object.assign) {
		return false;
		}

		// Detect buggy property enumeration order in older V8 versions.

		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
		var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
		test1[5] = 'de';
		if (Object.getOwnPropertyNames(test1)[0] === '5') {
		return false;
		}

		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test2 = {};
		for (var i = 0; i < 10; i++) {
		test2['_' + String.fromCharCode(i)] = i;
		}
		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
		return test2[n];
		});
		if (order2.join('') !== '0123456789') {
		return false;
		}

		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test3 = {};
		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
		test3[letter] = letter;
		});
		if (Object.keys(Object.assign({}, test3)).join('') !==
		'abcdefghijklmnopqrst') {
		return false;
		}

		return true;
		} catch (err) {
		// We don't expect any of the above to throw, but better to be safe.
		return false;
		}
		}

		module.exports = shouldUseNative() ? Object.assign : function (target, source) {
		var from;
		var to = toObject(target);
		var symbols;

		for (var s = 1; s < arguments.length; s++) {
		from = Object(arguments[s]);

		for (var key in from) {
		if (hasOwnProperty.call(from, key)) {
		to[key] = from[key];
		}
		}

		if (getOwnPropertySymbols) {
		symbols = getOwnPropertySymbols(from);
		for (var i = 0; i < symbols.length; i++) {
		if (propIsEnumerable.call(from, symbols[i])) {
		to[symbols[i]] = from[symbols[i]];
		}
		}
		}
		}

		return to;
		};


		/***/ }),

		/***/ 0:
		/***/ (function(module, exports) {

		module.exports = __WEBPACK_EXTERNAL_MODULE_0__;

		/***/ })

		/******/ });
		});
		})));

dist/OutsideClickHandler.min.js

		@@ -1,6 +0,1 @@
		!function(e,n){"object"==typeof exports&&"object"==typeof module?module.exports=n(require("react")):"function"==typeof define&&define.amd?define(["react"],n):"object"==typeof exports?exports.ReactOutsideClickHandler=n(require("react")):e.ReactOutsideClickHandler=n(e.React)}(this,function(e){return function(e){function n(r){if(t[r])return t[r].exports;var o=t[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}var t={};return n.m=e,n.c=t,n.i=function(e){return e},n.d=function(e,t,r){n.o(e,t)\|\|Object.defineProperty(e,t,{configurable:!1,enumerable:!0,get:r})},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},n.p="/",n(n.s="./lib/OutsideClickHandler.jsx")}({"./lib/OutsideClickHandler.jsx":function(e,n,t){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,n){if(!(e instanceof n))throw new TypeError("Cannot call a class as a function")}function i(e,n){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!n\|\|"object"!=typeof n&&"function"!=typeof n?e:n}function u(e,n){if("function"!=typeof n&&null!==n)throw new TypeError("Super expression must either be null or a function, not "+typeof n);e.prototype=Object.create(n&&n.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),n&&(Object.setPrototypeOf?Object.setPrototypeOf(e,n):e.__proto__=n)}Object.defineProperty(n,"__esModule",{value:!0});var a=function(){function e(e,n){for(var t=0;t<n.length;t++){var r=n[t];r.enumerable=r.enumerable\|\|!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(n,t,r){return t&&e(n.prototype,t),r&&e(n,r),n}}(),s=t(0),c=r(s),l=t("./node_modules/prop-types/index.js"),f=r(l),p={children:f.default.node,useCapture:f.default.bool,onOutsideClick:f.default.func},d={children:c.default.createElement("span",null),useCapture:!0,onOutsideClick:function(){}},y=function(e){function n(e){o(this,n);var t=i(this,(n.__proto__\|\|Object.getPrototypeOf(n)).call(this,e));return t.handleOutsideClick=t.handleOutsideClick.bind(t),t}return u(n,e),a(n,[{key:"componentDidMount",value:function(){document.addEventListener?document.addEventListener("click",this.handleOutsideClick,this.props.useCapture):document.attachEvent("onclick",this.handleOutsideClick)}},{key:"componentWillUnmount",value:function(){document.removeEventListener?document.removeEventListener("click",this.handleOutsideClick,this.props.useCapture):document.detachEvent("onclick",this.handleOutsideClick)}},{key:"handleOutsideClick",value:function(e){var n=this.childNode.contains(e.target);n\|\|this.props.onOutsideClick(e)}},{key:"render",value:function(){var e=this;return c.default.createElement("div",{ref:function(n){e.childNode=n}},this.props.children)}}]),n}(c.default.Component);y.propTypes=p,y.defaultProps=d,n.default=y},"./node_modules/fbjs/lib/emptyFunction.js":function(e,n,t){"use strict";function r(e){return function(){return e}}var o=function(){};o.thatReturns=r,o.thatReturnsFalse=r(!1),o.thatReturnsTrue=r(!0),o.thatReturnsNull=r(null),o.thatReturnsThis=function(){return this},o.thatReturnsArgument=function(e){return e},e.exports=o},"./node_modules/fbjs/lib/invariant.js":function(e,n,t){"use strict";(function(n){function t(e,n,t,o,i,u,a,s){if(r(n),!e){var c;if(void 0===n)c=new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");else{var l=[t,o,i,u,a,s],f=0;c=new Error(n.replace(/%s/g,function(){return l[f++]})),c.name="Invariant Violation"}throw c.framesToPop=1,c}}var r=function(e){};"production"!==n.env.NODE_ENV&&(r=function(e){if(void 0===e)throw new Error("invariant requires an error message argument")}),e.exports=t}).call(n,t("./node_modules/process/browser.js"))},"./node_modules/fbjs/lib/warning.js":function(e,n,t){"use strict";(function(n){var r=t("./node_modules/fbjs/lib/emptyFunction.js"),o=r;if("production"!==n.env.NODE_ENV){var i=function(e){for(var n=arguments.length,t=Array(n>1?n-1:0),r=1;r<n;r++)t[r-1]=arguments[r];var o=0,i="Warning: "+e.replace(/%s/g,function(){return t[o++]});"undefined"!=typeof console&&console.error(i);try{throw new Error(i)}catch(e){}};o=function(e,n){if(void 0===n)throw new Error("`warning(condition, format, ...args)` requires a warning message argument");if(0!==n.indexOf("Failed Composite propType: ")&&!e){for(var t=arguments.length,r=Array(t>2?t-2:0),o=2;o<t;o++)r[o-2]=arguments[o];i.apply(void 0,[n].concat(r))}}}e.exports=o}).call(n,t("./node_modules/process/browser.js"))},"./node_modules/process/browser.js":function(e,n){function t(){throw new Error("setTimeout has not been defined")}function r(){throw new Error("clearTimeout has not been defined")}function o(e){if(l===setTimeout)return setTimeout(e,0);if((l===t\|\|!l)&&setTimeout)return l=setTimeout,setTimeout(e,0);try{return l(e,0)}catch(n){try{return l.call(null,e,0)}catch(n){return l.call(this,e,0)}}}function i(e){if(f===clearTimeout)return clearTimeout(e);if((f===r\|\|!f)&&clearTimeout)return f=clearTimeout,clearTimeout(e);try{return f(e)}catch(n){try{return f.call(null,e)}catch(n){return f.call(this,e)}}}function u(){v&&d&&(v=!1,d.length?y=d.concat(y):h=-1,y.length&&a())}function a(){if(!v){var e=o(u);v=!0;for(var n=y.length;n;){for(d=y,y=[];++h<n;)d&&d[h].run();h=-1,n=y.length}d=null,v=!1,i(e)}}function s(e,n){this.fun=e,this.array=n}function c(){}var l,f,p=e.exports={};!function(){try{l="function"==typeof setTimeout?setTimeout:t}catch(e){l=t}try{f="function"==typeof clearTimeout?clearTimeout:r}catch(e){f=r}}();var d,y=[],v=!1,h=-1;p.nextTick=function(e){var n=new Array(arguments.length-1);if(arguments.length>1)for(var t=1;t<arguments.length;t++)n[t-1]=arguments[t];y.push(new s(e,n)),1!==y.length\|\|v\|\|o(a)},s.prototype.run=function(){this.fun.apply(null,this.array)},p.title="browser",p.browser=!0,p.env={},p.argv=[],p.version="",p.versions={},p.on=c,p.addListener=c,p.once=c,p.off=c,p.removeListener=c,p.removeAllListeners=c,p.emit=c,p.binding=function(e){throw new Error("process.binding is not supported")},p.cwd=function(){return"/"},p.chdir=function(e){throw new Error("process.chdir is not supported")},p.umask=function(){return 0}},"./node_modules/prop-types/checkPropTypes.js":function(e,n,t){"use strict";(function(n){function r(e,t,r,s,c){if("production"!==n.env.NODE_ENV)for(var l in e)if(e.hasOwnProperty(l)){var f;try{o("function"==typeof e[l],"%s: %s type `%s` is invalid; it must be a function, usually from the `prop-types` package, but received `%s`.",s\|\|"React class",r,l,typeof e[l]),f=e[l](t,l,s,r,null,u)}catch(e){f=e}if(i(!f\|\|f instanceof Error,"%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).",s\|\|"React class",r,l,typeof f),f instanceof Error&&!(f.message in a)){a[f.message]=!0;var p=c?c():"";i(!1,"Failed %s type: %s%s",r,f.message,null!=p?p:"")}}}if("production"!==n.env.NODE_ENV)var o=t("./node_modules/fbjs/lib/invariant.js"),i=t("./node_modules/fbjs/lib/warning.js"),u=t("./node_modules/prop-types/lib/ReactPropTypesSecret.js"),a={};e.exports=r}).call(n,t("./node_modules/process/browser.js"))},"./node_modules/prop-types/factoryWithThrowingShims.js":function(e,n,t){"use strict";var r=t("./node_modules/fbjs/lib/emptyFunction.js"),o=t("./node_modules/fbjs/lib/invariant.js"),i=t("./node_modules/prop-types/lib/ReactPropTypesSecret.js");e.exports=function(){function e(e,n,t,r,u,a){a!==i&&o(!1,"Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types")}function n(){return e}e.isRequired=e;var t={array:e,bool:e,func:e,number:e,object:e,string:e,symbol:e,any:e,arrayOf:n,element:e,instanceOf:n,node:e,objectOf:n,oneOf:n,oneOfType:n,shape:n,exact:n};return t.checkPropTypes=r,t.PropTypes=t,t}},"./node_modules/prop-types/factoryWithTypeCheckers.js":function(e,n,t){"use strict";(function(n){var r=t("./node_modules/fbjs/lib/emptyFunction.js"),o=t("./node_modules/fbjs/lib/invariant.js"),i=t("./node_modules/fbjs/lib/warning.js"),u=t("./node_modules/prop-types/node_modules/object-assign/index.js"),a=t("./node_modules/prop-types/lib/ReactPropTypesSecret.js"),s=t("./node_modules/prop-types/checkPropTypes.js");e.exports=function(e,t){function c(e){var n=e&&(R&&e[R]\|\|e[C]);if("function"==typeof n)return n}function l(e,n){return e===n?0!==e\|\|1/e===1/n:e!==e&&n!==n}function f(e){this.message=e,this.stack=""}function p(e){function r(r,c,l,p,d,y,v){if(p=p\|\|S,y=y\|\|l,v!==a)if(t)o(!1,"Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types");else if("production"!==n.env.NODE_ENV&&"undefined"!=typeof console){var h=p+":"+l;!u[h]&&s<3&&(i(!1,"You are manually calling a React.PropTypes validation function for the `%s` prop on `%s`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details.",y,p),u[h]=!0,s++)}return null==c[l]?r?new f(null===c[l]?"The "+d+" `"+y+"` is marked as required "+("in `"+p+"`, but its value is `null`."):"The "+d+" `"+y+"` is marked as required in "+("`"+p+"`, but its value is `undefined`.")):null:e(c,l,p,d,y)}if("production"!==n.env.NODE_ENV)var u={},s=0;var c=r.bind(null,!1);return c.isRequired=r.bind(null,!0),c}function d(e){function n(n,t,r,o,i,u){var a=n[t],s=x(a);if(s!==e){var c=k(a);return new f("Invalid "+o+" `"+i+"` of type "+("`"+c+"` supplied to `"+r+"`, expected ")+("`"+e+"`."))}return null}return p(n)}function y(){return p(r.thatReturnsNull)}function v(e){function n(n,t,r,o,i){if("function"!=typeof e)return new f("Property `"+i+"` of component `"+r+"` has invalid PropType notation inside arrayOf.");var u=n[t];if(!Array.isArray(u)){var s=x(u);return new f("Invalid "+o+" `"+i+"` of type "+("`"+s+"` supplied to `"+r+"`, expected an array."))}for(var c=0;c<u.length;c++){var l=e(u,c,r,o,i+"["+c+"]",a);if(l instanceof Error)return l}return null}return p(n)}function h(){function n(n,t,r,o,i){var u=n[t];if(!e(u)){var a=x(u);return new f("Invalid "+o+" `"+i+"` of type "+("`"+a+"` supplied to `"+r+"`, expected a single ReactElement."))}return null}return p(n)}function m(e){function n(n,t,r,o,i){if(!(n[t]instanceof e)){var u=e.name\|\|S,a=N(n[t]);return new f("Invalid "+o+" `"+i+"` of type "+("`"+a+"` supplied to `"+r+"`, expected ")+("instance of `"+u+"`."))}return null}return p(n)}function b(e){function t(n,t,r,o,i){for(var u=n[t],a=0;a<e.length;a++)if(l(u,e[a]))return null;var s=JSON.stringify(e);return new f("Invalid "+o+" `"+i+"` of value `"+u+"` "+("supplied to `"+r+"`, expected one of "+s+"."))}return Array.isArray(e)?p(t):("production"!==n.env.NODE_ENV?i(!1,"Invalid argument supplied to oneOf, expected an instance of array."):void 0,r.thatReturnsNull)}function j(e){function n(n,t,r,o,i){if("function"!=typeof e)return new f("Property `"+i+"` of component `"+r+"` has invalid PropType notation inside objectOf.");var u=n[t],s=x(u);if("object"!==s)return new f("Invalid "+o+" `"+i+"` of type "+("`"+s+"` supplied to `"+r+"`, expected an object."));for(var c in u)if(u.hasOwnProperty(c)){var l=e(u,c,r,o,i+"."+c,a);if(l instanceof Error)return l}return null}return p(n)}function g(e){function t(n,t,r,o,i){for(var u=0;u<e.length;u++){var s=e[u];if(null==s(n,t,r,o,i,a))return null}return new f("Invalid "+o+" `"+i+"` supplied to "+("`"+r+"`."))}if(!Array.isArray(e))return"production"!==n.env.NODE_ENV?i(!1,"Invalid argument supplied to oneOfType, expected an instance of array."):void 0,r.thatReturnsNull;for(var o=0;o<e.length;o++){var u=e[o];if("function"!=typeof u)return i(!1,"Invalid argument supplied to oneOfType. Expected an array of check functions, but received %s at index %s.",P(u),o),r.thatReturnsNull}return p(t)}function O(){function e(e,n,t,r,o){return T(e[n])?null:new f("Invalid "+r+" `"+o+"` supplied to "+("`"+t+"`, expected a ReactNode."))}return p(e)}function w(e){function n(n,t,r,o,i){var u=n[t],s=x(u);if("object"!==s)return new f("Invalid "+o+" `"+i+"` of type `"+s+"` "+("supplied to `"+r+"`, expected `object`."));for(var c in e){var l=e[c];if(l){var p=l(u,c,r,o,i+"."+c,a);if(p)return p}}return null}return p(n)}function _(e){function n(n,t,r,o,i){var s=n[t],c=x(s);if("object"!==c)return new f("Invalid "+o+" `"+i+"` of type `"+c+"` "+("supplied to `"+r+"`, expected `object`."));var l=u({},n[t],e);for(var p in l){var d=e[p];if(!d)return new f("Invalid "+o+" `"+i+"` key `"+p+"` supplied to `"+r+"`.\nBad object: "+JSON.stringify(n[t],null," ")+"\nValid keys: "+JSON.stringify(Object.keys(e),null," "));var y=d(s,p,r,o,i+"."+p,a);if(y)return y}return null}return p(n)}function T(n){switch(typeof n){case"number":case"string":case"undefined":return!0;case"boolean":return!n;case"object":if(Array.isArray(n))return n.every(T);if(null===n\|\|e(n))return!0;var t=c(n);if(!t)return!1;var r,o=t.call(n);if(t!==n.entries){for(;!(r=o.next()).done;)if(!T(r.value))return!1}else for(;!(r=o.next()).done;){var i=r.value;if(i&&!T(i[1]))return!1}return!0;default:return!1}}function E(e,n){return"symbol"===e\|\|("Symbol"===n["@@toStringTag"]\|\|"function"==typeof Symbol&&n instanceof Symbol)}function x(e){var n=typeof e;return Array.isArray(e)?"array":e instanceof RegExp?"object":E(n,e)?"symbol":n}function k(e){if("undefined"==typeof e\|\|null===e)return""+e;var n=x(e);if("object"===n){if(e instanceof Date)return"date";if(e instanceof RegExp)return"regexp"}return n}function P(e){var n=k(e);switch(n){case"array":case"object":return"an "+n;case"boolean":case"date":case"regexp":return"a "+n;default:return n}}function N(e){return e.constructor&&e.constructor.name?e.constructor.name:S}var R="function"==typeof Symbol&&Symbol.iterator,C="@@iterator",S="<<anonymous>>",I={array:d("array"),bool:d("boolean"),func:d("function"),number:d("number"),object:d("object"),string:d("string"),symbol:d("symbol"),any:y(),arrayOf:v,element:h(),instanceOf:m,node:O(),objectOf:j,oneOf:b,oneOfType:g,shape:w,exact:_};return f.prototype=Error.prototype,I.checkPropTypes=s,I.PropTypes=I,I}}).call(n,t("./node_modules/process/browser.js"))},"./node_modules/prop-types/index.js":function(e,n,t){(function(n){if("production"!==n.env.NODE_ENV){var r="function"==typeof Symbol&&Symbol.for&&Symbol.for("react.element")\|\|60103,o=function(e){return"object"==typeof e&&null!==e&&e.$$typeof===r},i=!0;e.exports=t("./node_modules/prop-types/factoryWithTypeCheckers.js")(o,i)}else e.exports=t("./node_modules/prop-types/factoryWithThrowingShims.js")()}).call(n,t("./node_modules/process/browser.js"))},"./node_modules/prop-types/lib/ReactPropTypesSecret.js":function(e,n,t){"use strict";var r="SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";e.exports=r},"./node_modules/prop-types/node_modules/object-assign/index.js":function(e,n,t){"use strict";function r(e){if(null===e\|\|void 0===e)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(e)}function o(){try{if(!Object.assign)return!1;var e=new String("abc");if(e[5]="de","5"===Object.getOwnPropertyNames(e)[0])return!1;for(var n={},t=0;t<10;t++)n["_"+String.fromCharCode(t)]=t;var r=Object.getOwnPropertyNames(n).map(function(e){return n[e]});if("0123456789"!==r.join(""))return!1;var o={};return"abcdefghijklmnopqrst".split("").forEach(function(e){o[e]=e}),"abcdefghijklmnopqrst"===Object.keys(Object.assign({},o)).join("")}catch(e){return!1}}/*
		object-assign
		(c) Sindre Sorhus
		@license MIT
		*/
		var i=Object.getOwnPropertySymbols,u=Object.prototype.hasOwnProperty,a=Object.prototype.propertyIsEnumerable;e.exports=o()?Object.assign:function(e,n){for(var t,o,s=r(e),c=1;c<arguments.length;c++){t=Object(arguments[c]);for(var l in t)u.call(t,l)&&(s[l]=t[l]);if(i){o=i(t);for(var f=0;f<o.length;f++)a.call(t,o[f])&&(s[o[f]]=t[o[f]])}}return s}},0:function(n,t){n.exports=e}})});
		!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("react"),require("prop-types")):"function"==typeof define&&define.amd?define(["exports","react","prop-types"],t):t(e.ReactOutsideClickHandler={},e.React,e.PropTypes)}(this,function(e,t,n){"use strict";t=t&&t.hasOwnProperty("default")?t.default:t,n=n&&n.hasOwnProperty("default")?n.default:n;var o=function(){function e(e,t){for(var n=0;n<t.length;n++){var o=t[n];o.enumerable=o.enumerable\|\|!1,o.configurable=!0,"value"in o&&(o.writable=!0),Object.defineProperty(e,o.key,o)}}return function(t,n,o){return n&&e(t.prototype,n),o&&e(t,o),t}}();var r={children:n.node,useCapture:n.bool,onOutsideClick:n.func},i={children:t.createElement("span",null),useCapture:!0,onOutsideClick:function(){}},u=function(e){function n(e){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,n);var t=function(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t\|\|"object"!=typeof t&&"function"!=typeof t?e:t}(this,(n.__proto__\|\|Object.getPrototypeOf(n)).call(this,e));return t.handleOutsideClick=t.handleOutsideClick.bind(t),t.setChildNode=t.setChildNode.bind(t),t}return function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}(n,t.Component),o(n,[{key:"componentDidMount",value:function(){document.addEventListener("click",this.handleOutsideClick,this.props.useCapture)}},{key:"componentWillUnmount",value:function(){document.removeEventListener("click",this.handleOutsideClick,this.props.useCapture)}},{key:"setChildNode",value:function(e){this.childNode=e}},{key:"handleOutsideClick",value:function(e){this.childNode.contains(e.target)\|\|this.props.onOutsideClick(e)}},{key:"render",value:function(){return t.createElement("div",{ref:this.setChildNode},this.props.children)}}]),n}();u.propTypes=r,u.defaultProps=i,e.default=u,Object.defineProperty(e,"__esModule",{value:!0})});

lib/OutsideClickHandler.jsx

		@@ -20,20 +20,17 @@ import React from 'react';
		this.handleOutsideClick = this.handleOutsideClick.bind(this);
		this.setChildNode = this.setChildNode.bind(this);
		}

		componentDidMount() {
		if (document.addEventListener) {
		document.addEventListener('click', this.handleOutsideClick, this.props.useCapture);
		} else {
		document.attachEvent('onclick', this.handleOutsideClick);
		}
		document.addEventListener('click', this.handleOutsideClick, this.props.useCapture);
		}

		componentWillUnmount() {
		if (document.removeEventListener) {
		document.removeEventListener('click', this.handleOutsideClick, this.props.useCapture);
		} else {
		document.detachEvent('onclick', this.handleOutsideClick);
		}
		document.removeEventListener('click', this.handleOutsideClick, this.props.useCapture);
		}

		setChildNode(ref) {
		this.childNode = ref;
		}

		handleOutsideClick(e) {
		@@ -48,3 +45,3 @@ const isDescendantOfRoot = this.childNode.contains(e.target);
		return (
		<div ref={(ref) => { this.childNode = ref; }}>
		<div ref={this.setChildNode}>
		{this.props.children}
		@@ -51,0 +48,0 @@ </div>

105

package.json

		{
		"name": "react-outside-click-handler",
		"version": "0.2.0",
		"version": "0.3.0",
		"main": "dist/OutsideClickHandler.js",
		@@ -21,59 +21,56 @@ "description": "React Outside Click Handler",
		"scripts": {
		"start": "yarn serve",
		"build": "yarn lint && webpack --config webpack.dist.config.js --progress",
		"lint": "eslint example lib test --ext .js,.jsx",
		"precommit": "yarn lint",
		"serve": "NODE_ENV=development webpack-dev-server --config webpack.dev.config.js --env.dev --inline --watch --host 0.0.0.0",
		"test": "NODE_ENV=test karma start",
		"test:coverage": "NODE_ENV=test karma start --coverage",
		"test:watch": "npm test -- --auto-watch --no-single-run"
		"build": "yarn clean && yarn build:dev && yarn build:prod",
		"build:dev": "cross-env NODE_ENV=development rollup -c -i lib/OutsideClickHandler.jsx -o dist/OutsideClickHandler.js",
		"build:prod": "cross-env NODE_ENV=production rollup -c -i lib/OutsideClickHandler.jsx -o dist/OutsideClickHandler.min.js",
		"clean": "rimraf dist",
		"lint": "eslint lib test example --ext .js,.jsx",
		"precommit": "lint-staged",
		"prepush": "yarn lint && yarn test",
		"test": "cross-env NODE_ENV=test jest --config jest.config.json",
		"test:coverage": "yarn test --coverage",
		"test:watch": "yarn test --watch",
		"ncu": "ncu"
		},
		"lint-staged": {
		"*.js": [
		"eslint --fix",
		"git add"
		]
		},
		"devDependencies": {
		"babel": "^6.5.2",
		"babel-core": "^6.18.2",
		"babel-loader": "^6.2.10",
		"babel-plugin-__coverage__": "^11.0.0",
		"babel-preset-airbnb": "^2.1.1",
		"babel-preset-es2015": "^6.18.0",
		"babel-preset-react": "^6.16.0",
		"chai": "^3.5.0",
		"classnames": "^2.2.5",
		"clean-webpack-plugin": "^0.1.14",
		"css-loader": "^0.26.1",
		"enzyme": "^2.7.0",
		"eslint": "^3.9.1",
		"eslint-config-airbnb": "^13.0.0",
		"eslint-loader": "^1.6.1",
		"eslint-plugin-import": "^2.2.0",
		"eslint-plugin-jsx-a11y": "^2.2.3",
		"eslint-plugin-react": "^6.8.0",
		"html-webpack-plugin": "^2.26.0",
		"husky": "^0.12.0",
		"istanbul": "^0.4.5",
		"karma": "^1.3.0",
		"karma-chai": "^0.1.0",
		"karma-coverage": "^1.1.1",
		"karma-coveralls": "^1.1.2",
		"karma-firefox-launcher": "^1.0.1",
		"karma-mocha": "^1.3.0",
		"karma-mocha-reporter": "^2.2.3",
		"karma-phantomjs-launcher": "^1.0.4",
		"karma-sourcemap-loader": "^0.3.7",
		"karma-webpack": "^1.8.1",
		"mocha": "^3.2.0",
		"phantomjs-prebuilt": "^2.1.14",
		"react": "^15.6.0",
		"react-addons-test-utils": "^15.4.1",
		"react-dom": "^15.6.0",
		"react-hot-loader": "^1.3.1",
		"sinon": "^2.1.0",
		"style-loader": "^0.13.1",
		"webpack": "^2.2.0",
		"webpack-dev-server": "^2.2.0",
		"webpack-merge": "^2.6.1"
		"babel-core": "^6.26.0",
		"babel-jest": "^22.4.3",
		"babel-preset-airbnb": "^2.4.0",
		"babel-preset-env": "^1.6.1",
		"babel-preset-react": "^6.24.1",
		"coveralls": "^3.0.0",
		"cross-env": "^5.1.4",
		"enzyme": "^3.3.0",
		"enzyme-adapter-react-16": "^1.1.1",
		"enzyme-to-json": "^3.3.3",
		"eslint": "^4.19.1",
		"eslint-config-airbnb": "^16.1.0",
		"eslint-plugin-import": "^2.7.0",
		"eslint-plugin-jest": "^21.15.0",
		"eslint-plugin-jsx-a11y": "^6.0.2",
		"eslint-plugin-react": "^7.4.0",
		"husky": "^0.14.3",
		"jest": "^22.4.3",
		"lint-staged": "^7.0.2",
		"npm-check-updates": "^2.14.1",
		"prop-types": "^15.6.0",
		"react": "^16.3.0",
		"react-dom": "^16.3.0",
		"react-test-renderer": "^16.3.0",
		"rimraf": "^2.6.2",
		"rollup": "^0.57.1",
		"rollup-plugin-babel": "^3.0.3",
		"rollup-plugin-commonjs": "^9.1.0",
		"rollup-plugin-node-resolve": "^3.3.0",
		"rollup-plugin-replace": "^2.0.0",
		"rollup-plugin-uglify": "^3.0.0"
		},
		"dependencies": {
		"prop-types": "^15.6.0"
		},
		"dependencies": {},
		"peerDependencies": {
		"prop-types": "^15.5.0",
		"react": "0.14.x \|\| 15.x \|\| 16.x",
		@@ -80,0 +77,0 @@ "react-dom": "0.14.x \|\| 15.x \|\| 16.x"

README.md

		@@ -1,9 +0,5 @@
		# react-outside-click-handler
		# react-outside-click-handler [![Build Status](https://travis-ci.org/taehwanno/react-outside-click-handler.svg?branch=master)](https://travis-ci.org/taehwanno/react-outside-click-handler) [![Coverage Status](https://coveralls.io/repos/github/taehwanno/react-outside-click-handler/badge.svg)](https://coveralls.io/github/taehwanno/react-outside-click-handler) [![npm version](https://badge.fury.io/js/react-outside-click-handler.svg)](https://badge.fury.io/js/react-outside-click-handler)

		[![Build Status](https://travis-ci.org/taehwanno/react-outside-click-handler.svg?branch=master)](https://travis-ci.org/taehwanno/react-outside-click-handler)
		[![Coverage Status](https://coveralls.io/repos/github/taehwanno/react-outside-click-handler/badge.svg?branch=master)](https://coveralls.io/github/taehwanno/react-outside-click-handler?branch=master)
		[![npm version](https://badge.fury.io/js/react-outside-click-handler.svg)](https://badge.fury.io/js/react-outside-click-handler)
		React Component for handling click events outside a specific component.

		React Component for handling some specific component outside click

		Table of contents
		@@ -13,65 +9,45 @@
		- [API](#api)
		- `<OutsideClickHandler onOutsideClick useCapture />`
		- [Example](#example)
		- [Development](#development)
		- [`<OutsideClickHandler children useCapture onOutsideClick />`](#api)
		- [Credits](#credits)
		- [License](#license)

		# Installation
		## Installation

		`react-outside-click-handler` requires React >= 0.14.

		```bash
		yarn add react-outside-click-handler
		$ npm install --save react-outside-click-handler
		```

		# API
		Alternatively, using yarn:

		- `<OutsideClickHandler onOutsideClick useCapture />`
		```bash
		$ yarn add react-outside-click-handler
		```

		## API

		- `<OutsideClickHandler children useCapture onOutsideClick />`

		### props

		- `onOutsideClick` (Function): outside click handler
		- `useCapture` (Boolean): See [link's useCapture section](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener) (Default: `true`)
		- `children` (ReactNode): The specific inner react node that not trigger `onOutsideClick` handler.
		- `useCapture` (Boolean): See [link's useCapture section](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Parameters) (Default: `true`)
		- `onOutsideClick` (Function): Click event handler outside `children` react node.

		# Example
		### Usage

		```jsx
		class Example extends React.Component {
		constructor(props) {
		super(props);
		this.handleOutsideClick = this.handleOutsideClick.bind(this);
		}

		handleOutsideClick() {
		// ...
		}

		render() {
		return (
		<div>
		<TodoList>
		<Todo />
		...
		</TodoList>
		<OutsideClickHandler onOutsideClick={this.handleOutsideClick}>
		<InsideComponent />
		</OutsideClickHandler>
		</div>
		);
		}
		}
		<OutsideClickHandler useCapture onOutsideClick={Function}>
		<p>The specific inner react node.</p>
		<p>When this nodes are clicked, "onOutsideClick" is not triggered.</p>
		</OutsideClickHandler>
		```

		# Development
		## Credits

		```bash
		yarn start
		```
		This component is inspired by [airbnb/react-dates's OutsideClickHandler](https://github.com/airbnb/react-dates/blob/master/src/components/OutsideClickHandler.jsx).

		Then, Go to `http://localhost:3000`
		## License

		# Credits

		This component is inspired by [airbnb/react-dates's OutsideClickHandler](https://github.com/airbnb/react-dates/blob/master/src/components/OutsideClickHandler.jsx)

		# Licence

		MIT @ [Taehwan, No (taehwanno)](https://github.com/taehwanno)
		MIT © [Taehwan, Noh (taehwanno)](https://github.com/taehwanno)

.npmignore

react-outside-click-handler - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes