		@@ -6,2 +6,8 @@ # Changelog

		## [[v2.4.5]](https://github.com/springload/react-accessible-accordion/releases/tag/v2.4.5)

		### Fixed

		* Fixes SSR.

		## [[v2.4.4]](https://github.com/springload/react-accessible-accordion/releases/tag/v2.4.4)
		@@ -8,0 +14,0 @@

1799

dist/es/index.js

		import React, { Component } from 'react';

		function unwrapExports (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
		function _classCallCheck(instance, Constructor) {
		if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
		}
		}

		function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
		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);
		}
		}

		/**
		* 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;
		};
		function _createClass(Constructor, protoProps, staticProps) {
		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
		if (staticProps) _defineProperties(Constructor, staticProps);
		return Constructor;
		}

		/**
		* 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() {};
		function _defineProperty(obj, key, value) {
		if (key in obj) {
		Object.defineProperty(obj, key, {
		value: value,
		enumerable: true,
		configurable: true,
		writable: true
		});
		} else {
		obj[key] = value;
		}

		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;
		};
		return obj;
		}

		var emptyFunction_1 = emptyFunction;
		function _extends() {
		_extends = Object.assign \|\| function (target) {
		for (var i = 1; i < arguments.length; i++) {
		var source = arguments[i];

		var emptyFunction$1 = /#__PURE__/Object.freeze({
		default: emptyFunction_1,
		__moduleExports: emptyFunction_1
		});
		for (var key in source) {
		if (Object.prototype.hasOwnProperty.call(source, key)) {
		target[key] = source[key];
		}
		}
		}

		/**
		* 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.
		*
		*/
		return target;
		};

		/**
		* 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.
		*/
		return _extends.apply(this, arguments);
		}

		var validateFormat = function validateFormat(format) {};
		function _objectSpread(target) {
		for (var i = 1; i < arguments.length; i++) {
		var source = arguments[i] != null ? arguments[i] : {};
		var ownKeys = Object.keys(source);

		function invariant(condition, format, a, b, c, d, e, f) {
		validateFormat(format);

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

		error.framesToPop = 1; // we don't care about invariant's own frame
		throw error;
		ownKeys.forEach(function (key) {
		_defineProperty(target, key, source[key]);
		});
		}

		return target;
		}

		var invariant_1 = invariant;
		function _inherits(subClass, superClass) {
		if (typeof superClass !== "function" && superClass !== null) {
		throw new TypeError("Super expression must either be null or a function");
		}

		var invariant$1 = /#__PURE__/Object.freeze({
		default: invariant_1,
		__moduleExports: invariant_1
		});

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

		var ReactPropTypesSecret_1 = ReactPropTypesSecret;

		var ReactPropTypesSecret$1 = /#__PURE__/Object.freeze({
		default: ReactPropTypesSecret_1,
		__moduleExports: ReactPropTypesSecret_1
		});

		var emptyFunction$2 = ( emptyFunction$1 && emptyFunction_1 ) \|\| emptyFunction$1;

		var invariant$2 = ( invariant$1 && invariant_1 ) \|\| invariant$1;

		var ReactPropTypesSecret$2 = ( ReactPropTypesSecret$1 && ReactPropTypesSecret_1 ) \|\| ReactPropTypesSecret$1;

		var factoryWithThrowingShims = function () {
		function shim(props, propName, componentName, location, propFullName, secret) {
		if (secret === ReactPropTypesSecret$2) {
		// It is still safe when called from React.
		return;
		subClass.prototype = Object.create(superClass && superClass.prototype, {
		constructor: {
		value: subClass,
		writable: true,
		configurable: true
		}
		invariant$2(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,
		});
		if (superClass) _setPrototypeOf(subClass, superClass);
		}

		any: shim,
		arrayOf: getShim,
		element: shim,
		instanceOf: getShim,
		node: shim,
		objectOf: getShim,
		oneOf: getShim,
		oneOfType: getShim,
		shape: getShim,
		exact: getShim
		function _getPrototypeOf(o) {
		_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
		return o.__proto__ \|\| Object.getPrototypeOf(o);
		};
		return _getPrototypeOf(o);
		}

		ReactPropTypes.checkPropTypes = emptyFunction$2;
		ReactPropTypes.PropTypes = ReactPropTypes;
		function _setPrototypeOf(o, p) {
		_setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) {
		o.__proto__ = p;
		return o;
		};

		return ReactPropTypes;
		};
		return _setPrototypeOf(o, p);
		}

		var factoryWithThrowingShims$1 = /#__PURE__/Object.freeze({
		default: factoryWithThrowingShims,
		__moduleExports: factoryWithThrowingShims
		});
		function _objectWithoutPropertiesLoose(source, excluded) {
		if (source == null) return {};
		var target = {};
		var sourceKeys = Object.keys(source);
		var key, i;

		var require$$0 = ( factoryWithThrowingShims$1 && factoryWithThrowingShims ) \|\| factoryWithThrowingShims$1;
		for (i = 0; i < sourceKeys.length; i++) {
		key = sourceKeys[i];
		if (excluded.indexOf(key) >= 0) continue;
		target[key] = source[key];
		}

		var propTypes = createCommonjsModule(function (module) {

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

		{
		// By explicitly using `prop-types` you are opting into new production behavior.
		// http://fb.me/prop-types-in-prod
		module.exports = require$$0();
		return target;
		}
		});

		var propTypes$1 = /#__PURE__/Object.freeze({
		default: propTypes,
		__moduleExports: propTypes
		});
		function _objectWithoutProperties(source, excluded) {
		if (source == null) return {};

		var _propTypes = ( propTypes$1 && propTypes ) \|\| propTypes$1;
		var target = _objectWithoutPropertiesLoose(source, excluded);

		var lib = createCommonjsModule(function (module, exports) {
		var key, i;

		var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
		if (Object.getOwnPropertySymbols) {
		var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

		exports.__esModule = true;
		for (i = 0; i < sourceSymbolKeys.length; i++) {
		key = sourceSymbolKeys[i];
		if (excluded.indexOf(key) >= 0) continue;
		if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
		target[key] = source[key];
		}
		}

		return target;
		}

		function _assertThisInitialized(self) {
		if (self === void 0) {
		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
		}

		var _react2 = _interopRequireDefault(React);



		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) {
		return obj && obj.__esModule ? obj : { default: obj };
		return self;
		}

		function _classCallCheck(instance, Constructor) {
		if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
		function _possibleConstructorReturn(self, call) {
		if (call && (typeof call === "object" \|\| typeof call === "function")) {
		return call;
		}

		return _assertThisInitialized(self);
		}

		function _possibleConstructorReturn(self, call) {
		if (!self) {
		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
		}return call && ((typeof call === 'undefined' ? 'undefined' : _typeof(call)) === "object" \|\| typeof call === "function") ? call : self;
		function _toConsumableArray(arr) {
		return _arrayWithoutHoles(arr) \|\| _iterableToArray(arr) \|\| _nonIterableSpread();
		}

		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 === 'undefined' ? 'undefined' : _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;
		function _arrayWithoutHoles(arr) {
		if (Array.isArray(arr)) {
		for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

		return arr2;
		}
		}

		function createEventEmitter(value) {
		var handlers = [];
		return {
		on: function on(handler) {
		handlers.push(handler);
		},
		off: function off(handler) {
		handlers = handlers.filter(function (h) {
		return h !== handler;
		});
		},
		get: function get() {
		return value;
		},
		set: function set(newValue) {
		value = newValue;
		handlers.forEach(function (handler) {
		return handler(value);
		});
		}
		};
		function _iterableToArray(iter) {
		if (Symbol.iterator in Object(iter) \|\| Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
		}

		function onlyChild(children) {
		return Array.isArray(children) ? children[0] : children;
		function _nonIterableSpread() {
		throw new TypeError("Invalid attempt to spread non-iterable instance");
		}

		var uniqueId = 0;
		// Arbitrary, but ought to be unique to avoid context namespace clashes.
		var CONTEXT_KEY = 'react-accessible-accordion@AccordionContainer';
		var Provider =
		/#__PURE__/
		function (_Component) {
		_inherits(Provider, _Component);

		function createReactContext(defaultValue) {
		var _Provider$childContex, _Consumer$contextType;
		function Provider() {
		var _getPrototypeOf2;

		var contextProp = '__create-react-context-' + uniqueId++ + '__';
		var _this;

		var Provider = function (_Component) {
		_inherits(Provider, _Component);
		_classCallCheck(this, Provider);

		function Provider() {
		var _temp, _this, _ret;
		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		_classCallCheck(this, Provider);
		_this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Provider)).call.apply(_getPrototypeOf2, [this].concat(args)));

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "state", {
		items: _this.props.items \|\| []
		});

		return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.emitter = createEventEmitter(_this.props.value), _temp), _possibleConstructorReturn(_this, _ret);
		}
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "addItem", function (newItem) {
		// Need to use callback style otherwise race-conditions are created by concurrent registrations.
		_this.setState(function (state) {
		var items;

		Provider.prototype.getChildContext = function getChildContext() {
		var _ref;
		if (state.items.some(function (item) {
		return item.uuid === newItem.uuid;
		})) {
		// eslint-disable-next-line no-console
		console.error("AccordionItem error: One item already has the uuid \"".concat(newItem.uuid, "\". Uuid property must be unique. See: https://github.com/springload/react-accessible-accordion#accordionitem"));
		}

		return _ref = {}, _ref[contextProp] = this.emitter, _ref;
		};
		if (_this.props.accordion && newItem.expanded) {
		// If this is a true accordion and the new item is expanded, then the others must be closed.
		items = _toConsumableArray(state.items.map(function (item) {
		return _objectSpread({}, item, {
		expanded: false
		});
		})).concat([newItem]);
		} else {
		items = _toConsumableArray(state.items).concat([newItem]);
		}

		Provider.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
		if (this.props.value !== nextProps.value) {
		this.emitter.set(nextProps.value);
		}
		};
		return {
		items: items
		};
		});
		});

		Provider.prototype.render = function render() {
		return this.props.children;
		};
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "removeItem", function (key) {
		return _this.setState(function (state) {
		return {
		items: state.items.filter(function (item) {
		return item.uuid !== key;
		})
		};
		});
		});

		return Provider;
		}(React.Component);
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "setExpanded", function (key, expanded) {
		return _this.setState(function (state) {
		return {
		items: state.items.map(function (item) {
		if (item.uuid === key) {
		return _objectSpread({}, item, {
		expanded: expanded
		});
		}

		Provider.childContextTypes = (_Provider$childContex = {}, _Provider$childContex[contextProp] = _propTypes2.default.object.isRequired, _Provider$childContex);
		if (_this.props.accordion && expanded) {
		// If this is an accordion, we might need to collapse the other expanded item.
		return _objectSpread({}, item, {
		expanded: false
		});
		}

		var Consumer = function (_Component2) {
		_inherits(Consumer, _Component2);
		return item;
		})
		};
		}, function () {
		if (_this.props.onChange) {
		_this.props.onChange(_this.props.accordion ? key : _this.state.items.filter(function (item) {
		return item.expanded;
		}).map(function (item) {
		return item.uuid;
		}));
		}
		});
		});

		function Consumer() {
		var _temp2, _this2, _ret2;
		return _this;
		}

		_classCallCheck(this, Consumer);
		_createClass(Provider, [{
		key: "getChildContext",
		value: function getChildContext() {
		var context = {
		items: this.state.items,
		accordion: !!this.props.accordion,
		addItem: this.addItem,
		removeItem: this.removeItem,
		setExpanded: this.setExpanded
		};
		return _defineProperty({}, CONTEXT_KEY, context);
		}
		}, {
		key: "render",
		value: function render() {
		return this.props.children \|\| null;
		}
		}]);

		for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
		args[_key2] = arguments[_key2];
		}
		return Provider;
		}(Component); // eslint-disable-next-line react/no-multi-comp

		return _ret2 = (_temp2 = (_this2 = _possibleConstructorReturn(this, _Component2.call.apply(_Component2, [this].concat(args))), _this2), _this2.state = {
		value: _this2.getValue()
		}, _this2.onUpdate = function () {
		_this2.setState({
		value: _this2.getValue()
		});
		}, _temp2), _possibleConstructorReturn(_this2, _ret2);
		}
		_defineProperty(Provider, "childContextTypes", _defineProperty({}, CONTEXT_KEY, function () {
		return null;
		}));

		Consumer.prototype.componentDidMount = function componentDidMount() {
		if (this.context[contextProp]) {
		this.context[contextProp].on(this.onUpdate);
		}
		};
		var Consumer =
		/#__PURE__/
		function (_Component2) {
		_inherits(Consumer, _Component2);

		Consumer.prototype.componentWillUnmount = function componentWillUnmount() {
		if (this.context[contextProp]) {
		this.context[contextProp].off(this.onUpdate);
		}
		};
		function Consumer() {
		_classCallCheck(this, Consumer);

		Consumer.prototype.getValue = function getValue() {
		if (this.context[contextProp]) {
		return this.context[contextProp].get();
		} else {
		return defaultValue;
		}
		};
		return _possibleConstructorReturn(this, _getPrototypeOf(Consumer).apply(this, arguments));
		}

		Consumer.prototype.render = function render() {
		return onlyChild(this.props.children)(this.state.value);
		};
		_createClass(Consumer, [{
		key: "render",
		value: function render() {
		return this.props.children(this.context[CONTEXT_KEY]);
		}
		}]);

		return Consumer;
		}(React.Component);
		return Consumer;
		}(Component);

		Consumer.contextTypes = (_Consumer$contextType = {}, _Consumer$contextType[contextProp] = _propTypes2.default.object, _Consumer$contextType);
		_defineProperty(Consumer, "contextTypes", _defineProperty({}, CONTEXT_KEY, function () {
		return null;
		}));

		return {
		Provider: Provider,
		Consumer: Consumer
		};
		}
		var accordionDefaultProps = {
		accordion: true
		};

		exports.default = createReactContext;
		module.exports = exports['default'];
		});
		var Accordion = function Accordion(_ref) {
		var accordion = _ref.accordion,
		rest = _objectWithoutProperties(_ref, ["accordion"]);

		var createReactContext = unwrapExports(lib);
		return React.createElement("div", _extends({
		role: accordion ? 'tablist' : null
		}, rest));
		};

		var _typeof2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
		Accordion.defaultProps = accordionDefaultProps;

		var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol" ? function (obj) {
		return typeof obj === 'undefined' ? 'undefined' : _typeof2(obj);
		} : function (obj) {
		return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj === 'undefined' ? 'undefined' : _typeof2(obj);
		var defaultProps = {
		accordion: true,
		onChange: function onChange() {},
		className: 'accordion',
		children: null
		};

		function _possibleConstructorReturn(self, call) {
		if (!self) {
		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
		}return call && ((typeof call === 'undefined' ? 'undefined' : _typeof2(call)) === "object" \|\| typeof call === "function") ? call : self;
		}
		var AccordionWrapper =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionWrapper, _Component);

		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 === 'undefined' ? 'undefined' : _typeof2(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;
		}
		function AccordionWrapper() {
		var _getPrototypeOf2;

		function _classCallCheck(instance, Constructor) {
		if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
		}
		}
		var _this;

		var StateContext = createReactContext(null);
		_classCallCheck(this, AccordionWrapper);

		var Container = function () {
		function Container() {
		var _this = this;
		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		_classCallCheck(this, Container);
		_this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AccordionWrapper)).call.apply(_getPrototypeOf2, [this].concat(args)));

		this._listeners = [];
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "renderAccordion", function (accordionStore) {
		var _this$props = _this.props,
		accordion = _this$props.accordion,
		onChange = _this$props.onChange,
		rest = _objectWithoutProperties(_this$props, ["accordion", "onChange"]);

		CONTAINER_DEBUG_CALLBACKS.forEach(function (cb) {
		return cb(_this);
		return React.createElement(Accordion, _extends({
		accordion: accordionStore.accordion
		}, rest));
		});

		return _this;
		}

		Container.prototype.setState = function setState(updater, callback) {
		var _this2 = this;
		_createClass(AccordionWrapper, [{
		key: "render",
		value: function render() {
		return React.createElement(Provider, {
		accordion: this.props.accordion,
		onChange: this.props.onChange
		}, React.createElement(Consumer, null, this.renderAccordion));
		}
		}]);

		return Promise.resolve().then(function () {
		var nextState = void 0;
		return AccordionWrapper;
		}(Component);

		if (typeof updater === 'function') {
		nextState = updater(_this2.state);
		} else {
		nextState = updater;
		}
		_defineProperty(AccordionWrapper, "defaultProps", defaultProps);

		if (nextState == null) {
		if (callback) callback();
		return;
		function _extends$1() {
		_extends$1 = 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];
		}
		}
		}

		_this2.state = Object.assign({}, _this2.state, nextState);
		return target;
		};

		var promises = _this2._listeners.map(function (listener) {
		return listener();
		});
		return _extends$1.apply(this, arguments);
		}

		return Promise.all(promises).then(function () {
		if (callback) {
		return callback();
		}
		});
		});
		};
		/**
		* 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.
		*
		* @typechecks
		*
		*/

		Container.prototype.subscribe = function subscribe(fn) {
		this._listeners.push(fn);
		};
		function _inheritsLoose$1(subClass, superClass) {
		subClass.prototype = Object.create(superClass.prototype);
		subClass.prototype.constructor = subClass;
		subClass.__proto__ = superClass;
		}

		Container.prototype.unsubscribe = function unsubscribe(fn) {
		this._listeners = this._listeners.filter(function (f) {
		return f !== fn;
		});
		};
		/**
		* 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.
		*/

		return Container;
		}();
		function unwrapExports (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
		}

		var DUMMY_STATE = {};
		function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
		}

		var Subscribe = function (_React$Component) {
		_inherits(Subscribe, _React$Component);
		var lib = createCommonjsModule(function (module, exports) {

		function Subscribe() {
		var _temp, _this3, _ret;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		_classCallCheck(this, Subscribe);
		var createChangeEmitter = exports.createChangeEmitter = function createChangeEmitter() {
		var currentListeners = [];
		var nextListeners = currentListeners;

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		function ensureCanMutateNextListeners() {
		if (nextListeners === currentListeners) {
		nextListeners = currentListeners.slice();
		}

		return _ret = (_temp = (_this3 = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this3), _this3.state = {}, _this3.instances = [], _this3.unmounted = false, _this3.onUpdate = function () {
		return new Promise(function (resolve) {
		if (!_this3.unmounted) {
		_this3.setState(DUMMY_STATE, resolve);
		} else {
		resolve();
		}
		});
		}, _temp), _possibleConstructorReturn(_this3, _ret);
		}

		Subscribe.prototype.componentWillUnmount = function componentWillUnmount() {
		this.unmounted = true;
		this._unsubscribe();
		};

		Subscribe.prototype._unsubscribe = function _unsubscribe() {
		var _this4 = this;

		this.instances.forEach(function (container) {
		container.unsubscribe(_this4.onUpdate);
		});
		};

		Subscribe.prototype._createInstances = function _createInstances(map, containers) {
		var _this5 = this;

		this._unsubscribe();

		if (map === null) {
		throw new Error('You must wrap your <Subscribe> components with a <Provider>');
		function listen(listener) {
		if (typeof listener !== 'function') {
		throw new Error('Expected listener to be a function.');
		}

		var safeMap = map;
		var instances = containers.map(function (ContainerItem) {
		var instance = void 0;

		if ((typeof ContainerItem === 'undefined' ? 'undefined' : _typeof(ContainerItem)) === 'object' && ContainerItem instanceof Container) {
		instance = ContainerItem;
		} else {
		instance = safeMap.get(ContainerItem);

		if (!instance) {
		instance = new ContainerItem();
		safeMap.set(ContainerItem, instance);
		}
		var isSubscribed = true;
		ensureCanMutateNextListeners();
		nextListeners.push(listener);
		return function () {
		if (!isSubscribed) {
		return;
		}

		instance.unsubscribe(_this5.onUpdate);
		instance.subscribe(_this5.onUpdate);
		isSubscribed = false;
		ensureCanMutateNextListeners();
		var index = nextListeners.indexOf(listener);
		nextListeners.splice(index, 1);
		};
		}

		return instance;
		});
		function emit() {
		currentListeners = nextListeners;
		var listeners = currentListeners;

		this.instances = instances;
		return instances;
		};
		for (var i = 0; i < listeners.length; i++) {
		listeners[i].apply(listeners, arguments);
		}
		}

		Subscribe.prototype.render = function render() {
		var _this6 = this;

		return React.createElement(StateContext.Consumer, null, function (map) {
		return _this6.props.children.apply(null, _this6._createInstances(map, _this6.props.to));
		});
		return {
		listen: listen,
		emit: emit
		};
		};
		});

		return Subscribe;
		}(React.Component);
		unwrapExports(lib);
		var lib_1 = lib.createChangeEmitter;

		function Provider(props) {
		return React.createElement(StateContext.Consumer, null, function (parentMap) {
		var childMap = new Map(parentMap);
		function symbolObservablePonyfill(root) {
		var result;
		var Symbol = root.Symbol;

		if (props.inject) {
		props.inject.forEach(function (instance) {
		childMap.set(instance.constructor, instance);
		});
		if (typeof Symbol === 'function') {
		if (Symbol.observable) {
		result = Symbol.observable;
		} else {
		result = Symbol('observable');
		Symbol.observable = result;
		}
		} else {
		result = '@@observable';
		}

		return React.createElement(StateContext.Provider, { value: childMap }, props.children);
		});
		return result;
		}

		var CONTAINER_DEBUG_CALLBACKS = [];
		/* global window */
		var root;

		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; };
		if (typeof self !== 'undefined') {
		root = self;
		} else if (typeof window !== 'undefined') {
		root = window;
		} else if (typeof global !== 'undefined') {
		root = global;
		} else if (typeof module !== 'undefined') {
		root = module;
		} else {
		root = Function('return this')();
		}

		function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
		var result = symbolObservablePonyfill(root);

		function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		var Nothing =
		/#__PURE__/
		function (_Component) {
		_inheritsLoose$1(Nothing, _Component);

		function _possibleConstructorReturn$1(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 Nothing() {
		return _Component.apply(this, arguments) \|\| this;
		}

		function _inherits$1(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 _proto = Nothing.prototype;

		var AccordionContainer = function (_Container) {
		_inherits$1(AccordionContainer, _Container);
		_proto.render = function render() {
		return null;
		};

		function AccordionContainer() {
		var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
		return Nothing;
		}(Component);

		_classCallCheck$1(this, AccordionContainer);
		var fromRenderProps = function fromRenderProps(RenderPropsComponent, propsMapper, renderPropName) {
		if (renderPropName === void 0) {
		renderPropName = 'children';
		}

		var _this = _possibleConstructorReturn$1(this, (AccordionContainer.__proto__ \|\| Object.getPrototypeOf(AccordionContainer)).call(this));
		return function (BaseComponent) {
		var baseFactory = React.createFactory(BaseComponent);
		var renderPropsFactory = React.createFactory(RenderPropsComponent);

		_this.setAccordion = function (accordion) {
		if (accordion !== _this.state.accordion) {
		return _this.setState({ accordion: accordion });
		}
		return null;
		};
		var FromRenderProps = function FromRenderProps(ownerProps) {
		var _renderPropsFactory;

		_this.setOnChange = function (onChange) {
		if (onChange !== _this.state.onChange) {
		return _this.setState({ onChange: onChange });
		}
		return null;
		};
		return renderPropsFactory((_renderPropsFactory = {}, _renderPropsFactory[renderPropName] = function () {
		return baseFactory(_extends({}, ownerProps, propsMapper.apply(void 0, arguments)));
		}, _renderPropsFactory));
		};

		_this.addItem = function (newItem) {
		// Need to use callback style otherwise race-conditions are created by concurrent registrations.
		_this.setState(function (state) {
		var items = void 0;

		if (state.items.some(function (item) {
		return item.uuid === newItem.uuid;
		})) {
		// eslint-disable-next-line no-console
		console.error('AccordionItem error: One item already has the uuid "' + newItem.uuid + '". Uuid property must be unique. See: https://github.com/springload/react-accessible-accordion#accordionitem');
		}
		if (state.accordion && newItem.expanded) {
		// If this is a true accordion and the new item is expanded, then the others must be closed.
		items = [].concat(_toConsumableArray(state.items.map(function (item) {
		return _extends({}, item, {
		expanded: false
		});
		})), [newItem]);
		} else {
		items = [].concat(_toConsumableArray(state.items), [newItem]);
		}
		return {
		items: items
		};
		});
		};

		_this.removeItem = function (key) {
		return _this.setState(function (state) {
		return {
		items: state.items.filter(function (item) {
		return item.uuid !== key;
		})
		};
		});
		};

		_this.setExpanded = function (key, expanded) {
		return _this.setState(function (state) {
		return {
		items: state.items.map(function (item) {
		if (item.uuid === key) {
		return _extends({}, item, {
		expanded: expanded
		});
		}
		if (state.accordion && expanded) {
		// If this is an accordion, we might need to collapse the other expanded item.
		return _extends({}, item, {
		expanded: false
		});
		}
		return item;
		})
		};
		}).then(function () {
		if (_this.state.accordion) {
		_this.state.onChange(key);
		} else {
		_this.state.onChange(_this.state.items.filter(function (item) {
		return item.expanded;
		}).map(function (item) {
		return item.uuid;
		}));
		}
		});
		};

		_this.state = _extends({
		items: [],
		accordion: true,
		onChange: function onChange() {}
		}, args);
		return _this;
		}

		return AccordionContainer;
		}(Container);

		var _extends$1 = 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; };

		function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

		var accordionDefaultProps = {
		accordion: true
		return FromRenderProps;
		};
		};

		var Accordion = function Accordion(_ref) {
		var accordion = _ref.accordion,
		rest = _objectWithoutProperties(_ref, ['accordion']);
		var compose = function compose() {
		for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
		funcs[_key] = arguments[_key];
		}

		return React.createElement('div', _extends$1({ role: accordion ? 'tablist' : null }, rest));
		return funcs.reduce(function (a, b) {
		return function () {
		return a(b.apply(void 0, arguments));
		};
		}, function (arg) {
		return arg;
		});
		};
		Accordion.defaultProps = accordionDefaultProps;

		var _extends$2 = 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; }; }();

		function _objectWithoutProperties$1(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$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn$2(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$2(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 defaultProps = {
		accordion: true,
		onChange: function onChange() {},
		className: 'accordion',
		children: null
		};

		var AccordionWrapper = function (_Component) {
		_inherits$2(AccordionWrapper, _Component);

		function AccordionWrapper() {
		var _ref;

		var _temp, _this, _ret;

		_classCallCheck$2(this, AccordionWrapper);

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return _ret = (_temp = (_this = _possibleConstructorReturn$2(this, (_ref = AccordionWrapper.__proto__ \|\| Object.getPrototypeOf(AccordionWrapper)).call.apply(_ref, [this].concat(args))), _this), _this.accordionStore = new AccordionContainer({
		accordion: _this.props.accordion,
		onChange: _this.props.onChange
		}), _this.renderAccordion = function (accordionStore) {
		var _this$props = _this.props,
		accordion = _this$props.accordion,
		onChange = _this$props.onChange,
		rest = _objectWithoutProperties$1(_this$props, ['accordion', 'onChange']);

		return React.createElement(Accordion, _extends$2({ accordion: accordionStore.state.accordion }, rest));
		}, _temp), _possibleConstructorReturn$2(_this, _ret);
		}

		_createClass(AccordionWrapper, [{
		key: 'componentDidMount',
		value: function componentDidMount() {
		this.accordionStore.setAccordion(this.props.accordion);
		this.accordionStore.setOnChange(this.props.onChange);
		}
		}, {
		key: 'componentDidUpdate',
		value: function componentDidUpdate() {
		this.accordionStore.setAccordion(this.props.accordion);
		this.accordionStore.setOnChange(this.props.onChange);
		}
		}, {
		key: 'render',
		value: function render() {
		return React.createElement(
		Provider,
		{ inject: [this.accordionStore] },
		React.createElement(
		Subscribe,
		{ to: [AccordionContainer] },
		this.renderAccordion
		)
		);
		}
		}]);

		return AccordionWrapper;
		}(Component);

		AccordionWrapper.defaultProps = defaultProps;

		/*!
		@@ -761,5 +600,5 @@ * consecutive
		if (typeof inc !== 'number') inc = 1;

		return function () {
		var res;

		if (typeof base === 'undefined' \|\| base === 10) {
		@@ -777,49 +616,65 @@ res = number;

		var _extends$3 = 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; };
		// Arbitrary, but ought to be unique to avoid context namespace clashes.
		var CONTEXT_KEY$1 = 'react-accessible-accordion@ItemContainer';
		var Provider$1 =
		/#__PURE__/
		function (_Component) {
		_inherits(Provider, _Component);

		var _createClass$1 = 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 Provider() {
		_classCallCheck(this, Provider);

		function _classCallCheck$3(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		return _possibleConstructorReturn(this, _getPrototypeOf(Provider).apply(this, arguments));
		}

		function _possibleConstructorReturn$3(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; }
		_createClass(Provider, [{
		key: "getChildContext",
		value: function getChildContext() {
		var uuid = this.props.uuid;
		var context = {
		uuid: uuid
		};
		return _defineProperty({}, CONTEXT_KEY$1, context);
		}
		}, {
		key: "render",
		value: function render() {
		return this.props.children \|\| null;
		}
		}]);

		function _inherits$3(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 Provider;
		}(Component);

		var nextUuid = consecutive();
		function resetNextUuid() {
		nextUuid = consecutive();
		}
		_defineProperty(Provider$1, "childContextTypes", _defineProperty({}, CONTEXT_KEY$1, function () {
		return null;
		}));

		var ItemContainer = function (_Container) {
		_inherits$3(ItemContainer, _Container);
		// eslint-disable-next-line react/no-multi-comp
		var Consumer$1 =
		/#__PURE__/
		function (_Component2) {
		_inherits(Consumer, _Component2);

		function ItemContainer() {
		var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
		function Consumer() {
		_classCallCheck(this, Consumer);

		_classCallCheck$3(this, ItemContainer);
		return _possibleConstructorReturn(this, _getPrototypeOf(Consumer).apply(this, arguments));
		}

		var _this = _possibleConstructorReturn$3(this, (ItemContainer.__proto__ \|\| Object.getPrototypeOf(ItemContainer)).call(this));

		_this.state = _extends$3({}, args);
		if (_this.state.uuid === undefined) {
		_this.state.uuid = nextUuid();
		}
		return _this;
		_createClass(Consumer, [{
		key: "render",
		value: function render() {
		return this.props.children(this.context[CONTEXT_KEY$1]);
		}
		}]);

		_createClass$1(ItemContainer, [{
		key: 'setUuid',
		value: function setUuid(customUuid) {
		return this.setState({
		uuid: customUuid
		});
		}
		}]);
		return Consumer;
		}(Component);

		return ItemContainer;
		}(Container);
		_defineProperty(Consumer$1, "contextTypes", _defineProperty({}, CONTEXT_KEY$1, function () {
		return null;
		}));

		var classnames = createCommonjsModule(function (module) {
		var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

		/*!
		@@ -830,436 +685,392 @@ Copyright (c) 2016 Jed Watson.
		*/

		/* global define */

		(function () {

		var hasOwn = {}.hasOwnProperty;
		var hasOwn = {}.hasOwnProperty;

		function classNames() {
		var classes = [];
		function classNames() {
		var classes = [];

		for (var i = 0; i < arguments.length; i++) {
		var arg = arguments[i];
		if (!arg) continue;
		for (var i = 0; i < arguments.length; i++) {
		var arg = arguments[i];
		if (!arg) continue;
		var argType = typeof arg;

		var argType = typeof arg === 'undefined' ? 'undefined' : _typeof(arg);
		if (argType === 'string' \|\| argType === 'number') {
		classes.push(arg);
		} else if (Array.isArray(arg)) {
		classes.push(classNames.apply(null, arg));
		} else if (argType === 'object') {
		for (var key in arg) {
		if (hasOwn.call(arg, key) && arg[key]) {
		classes.push(key);
		}
		}
		}
		}

		if (argType === 'string' \|\| argType === 'number') {
		classes.push(arg);
		} else if (Array.isArray(arg)) {
		classes.push(classNames.apply(null, arg));
		} else if (argType === 'object') {
		for (var key in arg) {
		if (hasOwn.call(arg, key) && arg[key]) {
		classes.push(key);
		}
		}
		}
		}
		return classes.join(' ');
		}

		return classes.join(' ');
		}

		if (module.exports) {
		module.exports = classNames;
		} else if (typeof undefined === 'function' && _typeof(undefined.amd) === 'object' && undefined.amd) {
		// register as 'classnames', consistent with npm package name
		undefined('classnames', [], function () {
		return classNames;
		});
		} else {
		window.classNames = classNames;
		}
		if (module.exports) {
		module.exports = classNames;
		} else if (typeof undefined === 'function' && typeof undefined.amd === 'object' && undefined.amd) {
		// register as 'classnames', consistent with npm package name
		undefined('classnames', [], function () {
		return classNames;
		});
		} else {
		window.classNames = classNames;
		}
		})();
		});

		var _extends$4 = 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 AccordionItem =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItem, _Component);

		var _createClass$2 = 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 AccordionItem() {
		_classCallCheck(this, AccordionItem);

		function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
		return _possibleConstructorReturn(this, _getPrototypeOf(AccordionItem).apply(this, arguments));
		}

		function _objectWithoutProperties$2(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; }
		_createClass(AccordionItem, [{
		key: "componentDidMount",
		value: function componentDidMount() {
		var _this$props = this.props,
		uuid = _this$props.uuid,
		accordionStore = _this$props.accordionStore,
		disabled = _this$props.disabled;
		accordionStore.addItem({
		uuid: uuid,
		expanded: this.props.expanded \|\| false,
		disabled: disabled
		});
		}
		}, {
		key: "componentWillUnmount",
		value: function componentWillUnmount() {
		this.props.accordionStore.removeItem(this.props.uuid);
		} // This is here so that the user can dynamically set the 'expanded' state using the 'expanded' prop.

		function _classCallCheck$4(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		}, {
		key: "componentDidUpdate",
		value: function componentDidUpdate(prevProps) {
		var _this$props2 = this.props,
		uuid = _this$props2.uuid,
		expanded = _this$props2.expanded,
		accordionStore = _this$props2.accordionStore;

		function _possibleConstructorReturn$4(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; }
		if (expanded !== prevProps.expanded) {
		accordionStore.setExpanded(uuid, expanded);
		}
		}
		}, {
		key: "render",
		value: function render() {
		var _this$props3 = this.props,
		uuid = _this$props3.uuid,
		className = _this$props3.className,
		hideBodyClassName = _this$props3.hideBodyClassName,
		accordionStore = _this$props3.accordionStore,
		disabled = _this$props3.disabled,
		expanded = _this$props3.expanded,
		rest = _objectWithoutProperties(_this$props3, ["uuid", "className", "hideBodyClassName", "accordionStore", "disabled", "expanded"]); // Deliberately not using 'find' because IE compat.

		function _inherits$4(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 AccordionItem = function (_Component) {
		_inherits$4(AccordionItem, _Component);
		var currentItem = accordionStore.items.filter(function (item) {
		return item.uuid === uuid;
		})[0];

		function AccordionItem() {
		_classCallCheck$4(this, AccordionItem);
		if (!currentItem) {
		return null;
		}

		return _possibleConstructorReturn$4(this, (AccordionItem.__proto__ \|\| Object.getPrototypeOf(AccordionItem)).apply(this, arguments));
		return React.createElement("div", _extends({
		className: classnames(className, _defineProperty({}, hideBodyClassName, !currentItem.expanded && hideBodyClassName))
		}, rest));
		}
		}]);

		_createClass$2(AccordionItem, [{
		key: 'componentDidMount',
		value: function componentDidMount() {
		var _props = this.props,
		uuid = _props.uuid,
		accordionStore = _props.accordionStore,
		disabled = _props.disabled;


		accordionStore.addItem({
		uuid: uuid,
		expanded: this.props.expanded \|\| false,
		disabled: disabled
		});
		}
		}, {
		key: 'componentWillUnmount',
		value: function componentWillUnmount() {
		this.props.accordionStore.removeItem(this.props.uuid);
		}

		// This is here so that the user can dynamically set the 'expanded' state using the 'expanded' prop.

		}, {
		key: 'componentDidUpdate',
		value: function componentDidUpdate(prevProps) {
		var _props2 = this.props,
		uuid = _props2.uuid,
		expanded = _props2.expanded,
		accordionStore = _props2.accordionStore;

		if (expanded !== prevProps.expanded) {
		accordionStore.setExpanded(uuid, expanded);
		}
		}
		}, {
		key: 'render',
		value: function render() {
		var _props3 = this.props,
		uuid = _props3.uuid,
		className = _props3.className,
		hideBodyClassName = _props3.hideBodyClassName,
		accordionStore = _props3.accordionStore,
		disabled = _props3.disabled,
		expanded = _props3.expanded,
		rest = _objectWithoutProperties$2(_props3, ['uuid', 'className', 'hideBodyClassName', 'accordionStore', 'disabled', 'expanded']);

		var currentItem = accordionStore.state.items.filter(function (item) {
		return item.uuid === uuid;
		})[0];

		if (!currentItem) {
		return null;
		}

		return React.createElement('div', _extends$4({
		className: classnames(className, _defineProperty({}, hideBodyClassName, !currentItem.expanded && hideBodyClassName))
		}, rest));
		}
		}]);

		return AccordionItem;
		return AccordionItem;
		}(Component);

		var _extends$5 = 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 nextUuid = consecutive();
		function resetNextUuid() {
		nextUuid = consecutive();
		}

		var _createClass$3 = 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 AccordionItemWrapper =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItemWrapper, _Component);

		function _classCallCheck$5(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		function AccordionItemWrapper() {
		var _getPrototypeOf2;

		function _possibleConstructorReturn$5(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }
		var _this;

		function _inherits$5(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; }
		_classCallCheck(this, AccordionItemWrapper);

		var defaultProps$1 = {
		className: 'accordion__item',
		hideBodyClassName: '',
		disabled: false,
		expanded: false,
		accordionStore: new AccordionContainer(),
		uuid: undefined
		};
		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		var AccordionItemWrapper = function (_Component) {
		_inherits$5(AccordionItemWrapper, _Component);
		_this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AccordionItemWrapper)).call.apply(_getPrototypeOf2, [this].concat(args)));

		function AccordionItemWrapper() {
		var _ref;
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "id", nextUuid());

		var _temp, _this, _ret;
		return _this;
		}

		_classCallCheck$5(this, AccordionItemWrapper);
		_createClass(AccordionItemWrapper, [{
		key: "render",
		value: function render() {
		var _this$props = this.props,
		accordionStore = _this$props.accordionStore,
		uuid = _this$props.uuid,
		rest = _objectWithoutProperties(_this$props, ["accordionStore", "uuid"]);

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return _ret = (_temp = (_this = _possibleConstructorReturn$5(this, (_ref = AccordionItemWrapper.__proto__ \|\| Object.getPrototypeOf(AccordionItemWrapper)).call.apply(_ref, [this].concat(args))), _this), _this.itemContainer = new ItemContainer({
		uuid: _this.props.uuid
		}), _this.renderItem = function (accordionStore, itemStore) {
		var uuid = itemStore.state.uuid;

		return React.createElement(AccordionItem, _extends$5({}, _this.props, {
		uuid: uuid,
		accordionStore: accordionStore
		}));
		}, _temp), _possibleConstructorReturn$5(_this, _ret);
		var itemUuid = uuid !== undefined ? uuid : this.id;
		return React.createElement(Provider$1, {
		uuid: itemUuid
		}, React.createElement(AccordionItem, _extends({}, rest, {
		uuid: itemUuid,
		accordionStore: accordionStore
		})));
		}
		}]);

		_createClass$3(AccordionItemWrapper, [{
		key: 'render',
		value: function render() {
		return React.createElement(
		Provider,
		{ inject: [this.itemContainer] },
		React.createElement(
		Subscribe,
		{ to: [AccordionContainer, ItemContainer] },
		this.renderItem
		)
		);
		}
		}]);

		return AccordionItemWrapper;
		return AccordionItemWrapper;
		}(Component);

		AccordionItemWrapper.defaultProps = defaultProps$1;
		_defineProperty(AccordionItemWrapper, "defaultProps", {
		className: 'accordion__item',
		hideBodyClassName: '',
		disabled: false,
		expanded: false,
		uuid: undefined
		});

		var _extends$6 = 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 AccordionItem_wrapper = compose(fromRenderProps(Consumer, function (accordionStore) {
		return {
		accordionStore: accordionStore
		};
		}))(AccordionItemWrapper);

		var _createClass$4 = 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 AccordionItemTitle =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItemTitle, _Component);

		function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
		function AccordionItemTitle() {
		var _getPrototypeOf2;

		function _objectWithoutProperties$3(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
		var _this;

		function _classCallCheck$6(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		_classCallCheck(this, AccordionItemTitle);

		function _possibleConstructorReturn$6(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; }
		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		function _inherits$6(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; }
		_this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AccordionItemTitle)).call.apply(_getPrototypeOf2, [this].concat(args)));

		var AccordionItemTitle = function (_Component) {
		_inherits$6(AccordionItemTitle, _Component);
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "handleClick", function () {
		var _this$props = _this.props,
		uuid = _this$props.uuid,
		expanded = _this$props.expanded,
		setExpanded = _this$props.setExpanded;
		setExpanded(uuid, !expanded);
		});

		function AccordionItemTitle() {
		var _ref;
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "handleKeyPress", function (evt) {
		if (evt.charCode === 13 \|\| evt.charCode === 32) {
		evt.preventDefault();

		var _temp, _this, _ret;
		_this.handleClick();
		}
		});

		_classCallCheck$6(this, AccordionItemTitle);
		return _this;
		}

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}
		_createClass(AccordionItemTitle, [{
		key: "render",
		value: function render() {
		var _this$props2 = this.props,
		className = _this$props2.className,
		hideBodyClassName = _this$props2.hideBodyClassName,
		item = _this$props2.item,
		accordion = _this$props2.accordion,
		setExpanded = _this$props2.setExpanded,
		expanded = _this$props2.expanded,
		uuid = _this$props2.uuid,
		disabled = _this$props2.disabled,
		rest = _objectWithoutProperties(_this$props2, ["className", "hideBodyClassName", "item", "accordion", "setExpanded", "expanded", "uuid", "disabled"]);

		return _ret = (_temp = (_this = _possibleConstructorReturn$6(this, (_ref = AccordionItemTitle.__proto__ \|\| Object.getPrototypeOf(AccordionItemTitle)).call.apply(_ref, [this].concat(args))), _this), _this.handleClick = function () {
		var _this$props = _this.props,
		uuid = _this$props.uuid,
		expanded = _this$props.expanded,
		setExpanded = _this$props.setExpanded;
		var id = "accordion__title-".concat(uuid);
		var ariaControls = "accordion__body-".concat(uuid);
		var role = accordion ? 'tab' : 'button';
		var titleClassName = classnames(className, _defineProperty({}, hideBodyClassName, hideBodyClassName && !expanded));

		if (role === 'tab') {
		return React.createElement("div", _extends({
		id: id,
		"aria-selected": expanded,
		"aria-controls": ariaControls,
		className: titleClassName,
		onClick: disabled ? undefined : this.handleClick,
		role: role,
		tabIndex: "0" // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
		,
		onKeyPress: this.handleKeyPress,
		disabled: disabled
		}, rest));
		}

		setExpanded(uuid, !expanded);
		}, _this.handleKeyPress = function (evt) {
		if (evt.charCode === 13 \|\| evt.charCode === 32) {
		evt.preventDefault();
		_this.handleClick();
		}
		}, _temp), _possibleConstructorReturn$6(_this, _ret);
		return React.createElement("div", _extends({
		id: id,
		"aria-expanded": expanded,
		"aria-controls": ariaControls,
		className: titleClassName,
		onClick: disabled ? undefined : this.handleClick,
		role: role,
		tabIndex: "0" // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
		,
		onKeyPress: this.handleKeyPress,
		disabled: disabled
		}, rest));
		}
		}]);

		_createClass$4(AccordionItemTitle, [{
		key: 'render',
		value: function render() {
		var _props = this.props,
		className = _props.className,
		hideBodyClassName = _props.hideBodyClassName,
		accordionStore = _props.accordionStore,
		item = _props.item,
		accordion = _props.accordion,
		setExpanded = _props.setExpanded,
		expanded = _props.expanded,
		uuid = _props.uuid,
		disabled = _props.disabled,
		rest = _objectWithoutProperties$3(_props, ['className', 'hideBodyClassName', 'accordionStore', 'item', 'accordion', 'setExpanded', 'expanded', 'uuid', 'disabled']);

		var id = 'accordion__title-' + uuid;
		var ariaControls = 'accordion__body-' + uuid;
		var role = accordion ? 'tab' : 'button';
		var titleClassName = classnames(className, _defineProperty$1({}, hideBodyClassName, hideBodyClassName && !expanded));

		if (role === 'tab') {
		return React.createElement('div', _extends$6({
		id: id,
		'aria-selected': expanded,
		'aria-controls': ariaControls,
		className: titleClassName,
		onClick: disabled ? undefined : this.handleClick,
		role: role,
		tabIndex: '0' // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
		, onKeyPress: this.handleKeyPress,
		disabled: disabled
		}, rest));
		}
		return React.createElement('div', _extends$6({
		id: id,
		'aria-expanded': expanded,
		'aria-controls': ariaControls,
		className: titleClassName,
		onClick: disabled ? undefined : this.handleClick,
		role: role,
		tabIndex: '0' // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
		, onKeyPress: this.handleKeyPress,
		disabled: disabled
		}, rest));
		}
		}]);

		return AccordionItemTitle;
		return AccordionItemTitle;
		}(Component);

		AccordionItemTitle.accordionElementName = 'AccordionItemTitle';
		_defineProperty(AccordionItemTitle, "accordionElementName", 'AccordionItemTitle');

		var _extends$7 = 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; };
		// eslint-disable-next-line react/prefer-stateless-function
		var AccordionItemTitleWrapper =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItemTitleWrapper, _Component);

		var _createClass$5 = 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 AccordionItemTitleWrapper() {
		_classCallCheck(this, AccordionItemTitleWrapper);

		function _classCallCheck$7(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		return _possibleConstructorReturn(this, _getPrototypeOf(AccordionItemTitleWrapper).apply(this, arguments));
		}

		function _possibleConstructorReturn$7(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; }
		_createClass(AccordionItemTitleWrapper, [{
		key: "render",
		value: function render() {
		var _this$props = this.props,
		itemStore = _this$props.itemStore,
		accordionStore = _this$props.accordionStore,
		rest = _objectWithoutProperties(_this$props, ["itemStore", "accordionStore"]);

		function _inherits$7(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 AccordionItemTitleWrapper = function (_Component) {
		_inherits$7(AccordionItemTitleWrapper, _Component);

		function AccordionItemTitleWrapper() {
		var _ref;

		var _temp, _this, _ret;

		_classCallCheck$7(this, AccordionItemTitleWrapper);

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return _ret = (_temp = (_this = _possibleConstructorReturn$7(this, (_ref = AccordionItemTitleWrapper.__proto__ \|\| Object.getPrototypeOf(AccordionItemTitleWrapper)).call.apply(_ref, [this].concat(args))), _this), _this.renderItemTitle = function (accordionStore, itemStore) {
		var uuid = itemStore.state.uuid;
		var _accordionStore$state = accordionStore.state,
		items = _accordionStore$state.items,
		accordion = _accordionStore$state.accordion;

		var item = items.filter(function (stateItem) {
		return stateItem.uuid === uuid;
		})[0];

		return React.createElement(AccordionItemTitle, _extends$7({}, _this.props, item, {
		setExpanded: accordionStore.setExpanded,
		accordion: accordion
		}));
		}, _temp), _possibleConstructorReturn$7(_this, _ret);
		var uuid = itemStore.uuid;
		var items = accordionStore.items,
		accordion = accordionStore.accordion;
		var item = items.filter(function (stateItem) {
		return stateItem.uuid === uuid;
		})[0];
		return React.createElement(AccordionItemTitle, _extends({}, rest, item, {
		setExpanded: accordionStore.setExpanded,
		accordion: accordion
		}));
		}
		}]);

		_createClass$5(AccordionItemTitleWrapper, [{
		key: 'render',
		value: function render() {
		return React.createElement(
		Subscribe,
		{ to: [AccordionContainer, ItemContainer] },
		this.renderItemTitle
		);
		}
		}]);

		return AccordionItemTitleWrapper;
		return AccordionItemTitleWrapper;
		}(Component);

		AccordionItemTitleWrapper.defaultProps = {
		className: 'accordion__title',
		hideBodyClassName: ''
		};
		_defineProperty(AccordionItemTitleWrapper, "defaultProps", {
		className: 'accordion__title',
		hideBodyClassName: ''
		});

		var _extends$8 = 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 AccordionItemTitle_wrapper = compose(fromRenderProps(Consumer, function (accordionStore) {
		return {
		accordionStore: accordionStore
		};
		}), fromRenderProps(Consumer$1, function (itemStore) {
		return {
		itemStore: itemStore
		};
		}))(AccordionItemTitleWrapper);

		function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

		function _objectWithoutProperties$4(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

		var AccordionItemBody = function AccordionItemBody(props) {
		var className = props.className,
		hideBodyClassName = props.hideBodyClassName,
		uuid = props.uuid,
		expanded = props.expanded,
		disabled = props.disabled,
		accordion = props.accordion,
		rest = _objectWithoutProperties$4(props, ['className', 'hideBodyClassName', 'uuid', 'expanded', 'disabled', 'accordion']);
		var className = props.className,
		hideBodyClassName = props.hideBodyClassName,
		uuid = props.uuid,
		expanded = props.expanded,
		disabled = props.disabled,
		accordion = props.accordion,
		rest = _objectWithoutProperties(props, ["className", "hideBodyClassName", "uuid", "expanded", "disabled", "accordion"]);

		return React.createElement('div', _extends$8({
		id: 'accordion__body-' + uuid,
		className: classnames(className, _defineProperty$2({}, hideBodyClassName, !expanded)),
		'aria-hidden': !expanded,
		'aria-labelledby': 'accordion__title-' + uuid,
		role: accordion ? 'tabpanel' : null
		}, rest));
		return React.createElement("div", _extends({
		id: "accordion__body-".concat(uuid),
		className: classnames(className, _defineProperty({}, hideBodyClassName, !expanded)),
		"aria-hidden": !expanded,
		"aria-labelledby": "accordion__title-".concat(uuid),
		role: accordion ? 'tabpanel' : null
		}, rest));
		};

		var _extends$9 = 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; };
		// eslint-disable-next-line react/prefer-stateless-function
		var AccordionItemBodyWrapper =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItemBodyWrapper, _Component);

		var _createClass$6 = 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 AccordionItemBodyWrapper() {
		_classCallCheck(this, AccordionItemBodyWrapper);

		function _classCallCheck$8(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		return _possibleConstructorReturn(this, _getPrototypeOf(AccordionItemBodyWrapper).apply(this, arguments));
		}

		function _possibleConstructorReturn$8(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; }
		_createClass(AccordionItemBodyWrapper, [{
		key: "render",
		value: function render() {
		var _this$props = this.props,
		itemStore = _this$props.itemStore,
		accordionStore = _this$props.accordionStore,
		rest = _objectWithoutProperties(_this$props, ["itemStore", "accordionStore"]);

		function _inherits$8(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 uuid = itemStore.uuid;
		var items = accordionStore.items,
		accordion = accordionStore.accordion;
		var item = items.filter(function (stateItem) {
		return stateItem.uuid === uuid;
		})[0];
		return item ? React.createElement(AccordionItemBody, _extends({}, rest, item, {
		accordion: accordion
		})) : null;
		}
		}]);

		var AccordionItemBodyWrapper = function (_Component) {
		_inherits$8(AccordionItemBodyWrapper, _Component);
		return AccordionItemBodyWrapper;
		}(Component);

		function AccordionItemBodyWrapper() {
		var _ref;
		_defineProperty(AccordionItemBodyWrapper, "defaultProps", {
		className: 'accordion__body',
		hideBodyClassName: 'accordion__body--hidden'
		});

		var _temp, _this, _ret;
		var AccordionItemBody_wrapper = compose(fromRenderProps(Consumer, function (accordionStore) {
		return {
		accordionStore: accordionStore
		};
		}), fromRenderProps(Consumer$1, function (itemStore) {
		return {
		itemStore: itemStore
		};
		}))(AccordionItemBodyWrapper);

		_classCallCheck$8(this, AccordionItemBodyWrapper);
		// eslint-disable-next-line

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return _ret = (_temp = (_this = _possibleConstructorReturn$8(this, (_ref = AccordionItemBodyWrapper.__proto__ \|\| Object.getPrototypeOf(AccordionItemBodyWrapper)).call.apply(_ref, [this].concat(args))), _this), _this.renderItemBody = function (accordionStore, itemStore) {
		var uuid = itemStore.state.uuid;
		var _accordionStore$state = accordionStore.state,
		items = _accordionStore$state.items,
		accordion = _accordionStore$state.accordion;

		var item = items.filter(function (stateItem) {
		return stateItem.uuid === uuid;
		})[0];
		return React.createElement(AccordionItemBody, _extends$9({}, _this.props, item, {
		accordion: accordion
		}));
		}, _temp), _possibleConstructorReturn$8(_this, _ret);
		}

		_createClass$6(AccordionItemBodyWrapper, [{
		key: 'render',
		value: function render() {
		return React.createElement(
		Subscribe,
		{ to: [AccordionContainer, ItemContainer] },
		this.renderItemBody
		);
		}
		}]);

		return AccordionItemBodyWrapper;
		}(Component);

		AccordionItemBodyWrapper.defaultProps = {
		className: 'accordion__body',
		hideBodyClassName: 'accordion__body--hidden'
		};

		export { AccordionWrapper as Accordion, AccordionItemWrapper as AccordionItem, AccordionItemTitleWrapper as AccordionItemTitle, AccordionItemBodyWrapper as AccordionItemBody, resetNextUuid };
		export { AccordionWrapper as Accordion, AccordionItem_wrapper as AccordionItem, AccordionItemTitle_wrapper as AccordionItemTitle, AccordionItemBody_wrapper as AccordionItemBody, resetNextUuid };

1949

dist/umd/index.js

		(function (global, factory) {
		typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
		typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
		(factory((global.reactAccessibleAccordion = {}),global.React));
		typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
		typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
		(factory((global.reactAccessibleAccordion = {}),global.React));
		}(this, (function (exports,React) { 'use strict';

		var React__default = 'default' in React ? React['default'] : React;
		var React__default = 'default' in React ? React['default'] : React;

		function unwrapExports (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
		}
		function _classCallCheck(instance, Constructor) {
		if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
		}
		}

		function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
		}
		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);
		}
		}

		/**
		* 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 _createClass(Constructor, protoProps, staticProps) {
		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
		if (staticProps) _defineProperties(Constructor, staticProps);
		return Constructor;
		}

		function makeEmptyFunction(arg) {
		return function () {
		return arg;
		};
		}
		function _defineProperty(obj, key, value) {
		if (key in obj) {
		Object.defineProperty(obj, key, {
		value: value,
		enumerable: true,
		configurable: true,
		writable: true
		});
		} else {
		obj[key] = value;
		}

		/**
		* 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() {};
		return obj;
		}

		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;
		};
		function _extends() {
		_extends = Object.assign \|\| function (target) {
		for (var i = 1; i < arguments.length; i++) {
		var source = arguments[i];

		var emptyFunction_1 = emptyFunction;
		for (var key in source) {
		if (Object.prototype.hasOwnProperty.call(source, key)) {
		target[key] = source[key];
		}
		}
		}

		var emptyFunction$1 = /#__PURE__/Object.freeze({
		default: emptyFunction_1,
		__moduleExports: emptyFunction_1
		});
		return target;
		};

		/**
		* 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.
		*
		*/
		return _extends.apply(this, arguments);
		}

		/**
		* 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.
		*/
		function _objectSpread(target) {
		for (var i = 1; i < arguments.length; i++) {
		var source = arguments[i] != null ? arguments[i] : {};
		var ownKeys = Object.keys(source);

		var validateFormat = function validateFormat(format) {};
		if (typeof Object.getOwnPropertySymbols === 'function') {
		ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
		return Object.getOwnPropertyDescriptor(source, sym).enumerable;
		}));
		}

		function invariant(condition, format, a, b, c, d, e, f) {
		validateFormat(format);
		ownKeys.forEach(function (key) {
		_defineProperty(target, key, source[key]);
		});
		}

		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';
		}
		return target;
		}

		error.framesToPop = 1; // we don't care about invariant's own frame
		throw error;
		}
		}
		function _inherits(subClass, superClass) {
		if (typeof superClass !== "function" && superClass !== null) {
		throw new TypeError("Super expression must either be null or a function");
		}

		var invariant_1 = invariant;
		subClass.prototype = Object.create(superClass && superClass.prototype, {
		constructor: {
		value: subClass,
		writable: true,
		configurable: true
		}
		});
		if (superClass) _setPrototypeOf(subClass, superClass);
		}

		var invariant$1 = /#__PURE__/Object.freeze({
		default: invariant_1,
		__moduleExports: invariant_1
		});
		function _getPrototypeOf(o) {
		_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
		return o.__proto__ \|\| Object.getPrototypeOf(o);
		};
		return _getPrototypeOf(o);
		}

		/**
		* 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 _setPrototypeOf(o, p) {
		_setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) {
		o.__proto__ = p;
		return o;
		};

		var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
		return _setPrototypeOf(o, p);
		}

		var ReactPropTypesSecret_1 = ReactPropTypesSecret;
		function _objectWithoutPropertiesLoose(source, excluded) {
		if (source == null) return {};
		var target = {};
		var sourceKeys = Object.keys(source);
		var key, i;

		var ReactPropTypesSecret$1 = /#__PURE__/Object.freeze({
		default: ReactPropTypesSecret_1,
		__moduleExports: ReactPropTypesSecret_1
		});
		for (i = 0; i < sourceKeys.length; i++) {
		key = sourceKeys[i];
		if (excluded.indexOf(key) >= 0) continue;
		target[key] = source[key];
		}

		var emptyFunction$2 = ( emptyFunction$1 && emptyFunction_1 ) \|\| emptyFunction$1;
		return target;
		}

		var invariant$2 = ( invariant$1 && invariant_1 ) \|\| invariant$1;
		function _objectWithoutProperties(source, excluded) {
		if (source == null) return {};

		var ReactPropTypesSecret$2 = ( ReactPropTypesSecret$1 && ReactPropTypesSecret_1 ) \|\| ReactPropTypesSecret$1;
		var target = _objectWithoutPropertiesLoose(source, excluded);

		var factoryWithThrowingShims = function () {
		function shim(props, propName, componentName, location, propFullName, secret) {
		if (secret === ReactPropTypesSecret$2) {
		// It is still safe when called from React.
		return;
		}
		invariant$2(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,
		var key, i;

		any: shim,
		arrayOf: getShim,
		element: shim,
		instanceOf: getShim,
		node: shim,
		objectOf: getShim,
		oneOf: getShim,
		oneOfType: getShim,
		shape: getShim,
		exact: getShim
		};
		if (Object.getOwnPropertySymbols) {
		var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

		ReactPropTypes.checkPropTypes = emptyFunction$2;
		ReactPropTypes.PropTypes = ReactPropTypes;
		for (i = 0; i < sourceSymbolKeys.length; i++) {
		key = sourceSymbolKeys[i];
		if (excluded.indexOf(key) >= 0) continue;
		if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
		target[key] = source[key];
		}
		}

		return ReactPropTypes;
		};
		return target;
		}

		var factoryWithThrowingShims$1 = /#__PURE__/Object.freeze({
		default: factoryWithThrowingShims,
		__moduleExports: factoryWithThrowingShims
		});
		function _assertThisInitialized(self) {
		if (self === void 0) {
		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
		}

		var require$$0 = ( factoryWithThrowingShims$1 && factoryWithThrowingShims ) \|\| factoryWithThrowingShims$1;
		return self;
		}

		var propTypes = createCommonjsModule(function (module) {
		function _possibleConstructorReturn(self, call) {
		if (call && (typeof call === "object" \|\| typeof call === "function")) {
		return call;
		}

		/**
		* 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.
		*/
		return _assertThisInitialized(self);
		}

		{
		// By explicitly using `prop-types` you are opting into new production behavior.
		// http://fb.me/prop-types-in-prod
		module.exports = require$$0();
		}
		});
		function _toConsumableArray(arr) {
		return _arrayWithoutHoles(arr) \|\| _iterableToArray(arr) \|\| _nonIterableSpread();
		}

		var propTypes$1 = /#__PURE__/Object.freeze({
		default: propTypes,
		__moduleExports: propTypes
		});
		function _arrayWithoutHoles(arr) {
		if (Array.isArray(arr)) {
		for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

		var _propTypes = ( propTypes$1 && propTypes ) \|\| propTypes$1;
		return arr2;
		}
		}

		var lib = createCommonjsModule(function (module, exports) {
		function _iterableToArray(iter) {
		if (Symbol.iterator in Object(iter) \|\| Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
		}

		var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
		function _nonIterableSpread() {
		throw new TypeError("Invalid attempt to spread non-iterable instance");
		}

		exports.__esModule = true;
		// Arbitrary, but ought to be unique to avoid context namespace clashes.
		var CONTEXT_KEY = 'react-accessible-accordion@AccordionContainer';
		var Provider =
		/#__PURE__/
		function (_Component) {
		_inherits(Provider, _Component);

		function Provider() {
		var _getPrototypeOf2;

		var _this;

		var _react2 = _interopRequireDefault(React__default);
		_classCallCheck(this, Provider);

		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		_this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Provider)).call.apply(_getPrototypeOf2, [this].concat(args)));

		var _propTypes2 = _interopRequireDefault(_propTypes);
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "state", {
		items: _this.props.items \|\| []
		});

		function _interopRequireDefault(obj) {
		return obj && obj.__esModule ? obj : { default: obj };
		}
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "addItem", function (newItem) {
		// Need to use callback style otherwise race-conditions are created by concurrent registrations.
		_this.setState(function (state) {
		var items;

		function _classCallCheck(instance, Constructor) {
		if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
		}
		}
		if (state.items.some(function (item) {
		return item.uuid === newItem.uuid;
		})) {
		// eslint-disable-next-line no-console
		console.error("AccordionItem error: One item already has the uuid \"".concat(newItem.uuid, "\". Uuid property must be unique. See: https://github.com/springload/react-accessible-accordion#accordionitem"));
		}

		function _possibleConstructorReturn(self, call) {
		if (!self) {
		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
		}return call && ((typeof call === 'undefined' ? 'undefined' : _typeof(call)) === "object" \|\| typeof call === "function") ? call : self;
		}
		if (_this.props.accordion && newItem.expanded) {
		// If this is a true accordion and the new item is expanded, then the others must be closed.
		items = _toConsumableArray(state.items.map(function (item) {
		return _objectSpread({}, item, {
		expanded: false
		});
		})).concat([newItem]);
		} else {
		items = _toConsumableArray(state.items).concat([newItem]);
		}

		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 === 'undefined' ? 'undefined' : _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 {
		items: items
		};
		});
		});

		function createEventEmitter(value) {
		var handlers = [];
		return {
		on: function on(handler) {
		handlers.push(handler);
		},
		off: function off(handler) {
		handlers = handlers.filter(function (h) {
		return h !== handler;
		});
		},
		get: function get() {
		return value;
		},
		set: function set(newValue) {
		value = newValue;
		handlers.forEach(function (handler) {
		return handler(value);
		});
		}
		};
		}
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "removeItem", function (key) {
		return _this.setState(function (state) {
		return {
		items: state.items.filter(function (item) {
		return item.uuid !== key;
		})
		};
		});
		});

		function onlyChild(children) {
		return Array.isArray(children) ? children[0] : children;
		}
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "setExpanded", function (key, expanded) {
		return _this.setState(function (state) {
		return {
		items: state.items.map(function (item) {
		if (item.uuid === key) {
		return _objectSpread({}, item, {
		expanded: expanded
		});
		}

		var uniqueId = 0;
		if (_this.props.accordion && expanded) {
		// If this is an accordion, we might need to collapse the other expanded item.
		return _objectSpread({}, item, {
		expanded: false
		});
		}

		function createReactContext(defaultValue) {
		var _Provider$childContex, _Consumer$contextType;
		return item;
		})
		};
		}, function () {
		if (_this.props.onChange) {
		_this.props.onChange(_this.props.accordion ? key : _this.state.items.filter(function (item) {
		return item.expanded;
		}).map(function (item) {
		return item.uuid;
		}));
		}
		});
		});

		var contextProp = '__create-react-context-' + uniqueId++ + '__';
		return _this;
		}

		var Provider = function (_Component) {
		_inherits(Provider, _Component);
		_createClass(Provider, [{
		key: "getChildContext",
		value: function getChildContext() {
		var context = {
		items: this.state.items,
		accordion: !!this.props.accordion,
		addItem: this.addItem,
		removeItem: this.removeItem,
		setExpanded: this.setExpanded
		};
		return _defineProperty({}, CONTEXT_KEY, context);
		}
		}, {
		key: "render",
		value: function render() {
		return this.props.children \|\| null;
		}
		}]);

		function Provider() {
		var _temp, _this, _ret;
		return Provider;
		}(React.Component); // eslint-disable-next-line react/no-multi-comp

		_classCallCheck(this, Provider);
		_defineProperty(Provider, "childContextTypes", _defineProperty({}, CONTEXT_KEY, function () {
		return null;
		}));

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}
		var Consumer =
		/#__PURE__/
		function (_Component2) {
		_inherits(Consumer, _Component2);

		return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.emitter = createEventEmitter(_this.props.value), _temp), _possibleConstructorReturn(_this, _ret);
		}
		function Consumer() {
		_classCallCheck(this, Consumer);

		Provider.prototype.getChildContext = function getChildContext() {
		var _ref;
		return _possibleConstructorReturn(this, _getPrototypeOf(Consumer).apply(this, arguments));
		}

		return _ref = {}, _ref[contextProp] = this.emitter, _ref;
		};
		_createClass(Consumer, [{
		key: "render",
		value: function render() {
		return this.props.children(this.context[CONTEXT_KEY]);
		}
		}]);

		Provider.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
		if (this.props.value !== nextProps.value) {
		this.emitter.set(nextProps.value);
		}
		};
		return Consumer;
		}(React.Component);

		Provider.prototype.render = function render() {
		return this.props.children;
		};
		_defineProperty(Consumer, "contextTypes", _defineProperty({}, CONTEXT_KEY, function () {
		return null;
		}));

		return Provider;
		}(React__default.Component);
		var accordionDefaultProps = {
		accordion: true
		};

		Provider.childContextTypes = (_Provider$childContex = {}, _Provider$childContex[contextProp] = _propTypes2.default.object.isRequired, _Provider$childContex);
		var Accordion = function Accordion(_ref) {
		var accordion = _ref.accordion,
		rest = _objectWithoutProperties(_ref, ["accordion"]);

		var Consumer = function (_Component2) {
		_inherits(Consumer, _Component2);
		return React__default.createElement("div", _extends({
		role: accordion ? 'tablist' : null
		}, rest));
		};

		function Consumer() {
		var _temp2, _this2, _ret2;
		Accordion.defaultProps = accordionDefaultProps;

		_classCallCheck(this, Consumer);
		var defaultProps = {
		accordion: true,
		onChange: function onChange() {},
		className: 'accordion',
		children: null
		};

		for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
		args[_key2] = arguments[_key2];
		}
		var AccordionWrapper =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionWrapper, _Component);

		return _ret2 = (_temp2 = (_this2 = _possibleConstructorReturn(this, _Component2.call.apply(_Component2, [this].concat(args))), _this2), _this2.state = {
		value: _this2.getValue()
		}, _this2.onUpdate = function () {
		_this2.setState({
		value: _this2.getValue()
		});
		}, _temp2), _possibleConstructorReturn(_this2, _ret2);
		}
		function AccordionWrapper() {
		var _getPrototypeOf2;

		Consumer.prototype.componentDidMount = function componentDidMount() {
		if (this.context[contextProp]) {
		this.context[contextProp].on(this.onUpdate);
		}
		};
		var _this;

		Consumer.prototype.componentWillUnmount = function componentWillUnmount() {
		if (this.context[contextProp]) {
		this.context[contextProp].off(this.onUpdate);
		}
		};
		_classCallCheck(this, AccordionWrapper);

		Consumer.prototype.getValue = function getValue() {
		if (this.context[contextProp]) {
		return this.context[contextProp].get();
		} else {
		return defaultValue;
		}
		};
		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		Consumer.prototype.render = function render() {
		return onlyChild(this.props.children)(this.state.value);
		};
		_this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AccordionWrapper)).call.apply(_getPrototypeOf2, [this].concat(args)));

		return Consumer;
		}(React__default.Component);
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "renderAccordion", function (accordionStore) {
		var _this$props = _this.props,
		accordion = _this$props.accordion,
		onChange = _this$props.onChange,
		rest = _objectWithoutProperties(_this$props, ["accordion", "onChange"]);

		Consumer.contextTypes = (_Consumer$contextType = {}, _Consumer$contextType[contextProp] = _propTypes2.default.object, _Consumer$contextType);
		return React__default.createElement(Accordion, _extends({
		accordion: accordionStore.accordion
		}, rest));
		});

		return {
		Provider: Provider,
		Consumer: Consumer
		};
		}
		return _this;
		}

		exports.default = createReactContext;
		module.exports = exports['default'];
		});
		_createClass(AccordionWrapper, [{
		key: "render",
		value: function render() {
		return React__default.createElement(Provider, {
		accordion: this.props.accordion,
		onChange: this.props.onChange
		}, React__default.createElement(Consumer, null, this.renderAccordion));
		}
		}]);

		var createReactContext = unwrapExports(lib);
		return AccordionWrapper;
		}(React.Component);

		var _typeof2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
		_defineProperty(AccordionWrapper, "defaultProps", defaultProps);

		var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol" ? function (obj) {
		return typeof obj === 'undefined' ? 'undefined' : _typeof2(obj);
		} : function (obj) {
		return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj === 'undefined' ? 'undefined' : _typeof2(obj);
		};
		function _extends$1() {
		_extends$1 = Object.assign \|\| function (target) {
		for (var i = 1; i < arguments.length; i++) {
		var source = arguments[i];

		function _possibleConstructorReturn(self, call) {
		if (!self) {
		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
		}return call && ((typeof call === 'undefined' ? 'undefined' : _typeof2(call)) === "object" \|\| typeof call === "function") ? call : self;
		}
		for (var key in source) {
		if (Object.prototype.hasOwnProperty.call(source, key)) {
		target[key] = source[key];
		}
		}
		}

		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 === 'undefined' ? 'undefined' : _typeof2(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 target;
		};

		function _classCallCheck(instance, Constructor) {
		if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
		}
		}
		return _extends$1.apply(this, arguments);
		}

		var StateContext = createReactContext(null);
		/**
		* 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.
		*
		* @typechecks
		*
		*/

		var Container = function () {
		function Container() {
		var _this = this;
		function _inheritsLoose$1(subClass, superClass) {
		subClass.prototype = Object.create(superClass.prototype);
		subClass.prototype.constructor = subClass;
		subClass.__proto__ = superClass;
		}

		_classCallCheck(this, Container);
		/**
		* 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.
		*/

		this._listeners = [];
		function unwrapExports (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
		}

		CONTAINER_DEBUG_CALLBACKS.forEach(function (cb) {
		return cb(_this);
		});
		}
		function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
		}

		Container.prototype.setState = function setState(updater, callback) {
		var _this2 = this;
		var lib = createCommonjsModule(function (module, exports) {

		return Promise.resolve().then(function () {
		var nextState = void 0;
		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		if (typeof updater === 'function') {
		nextState = updater(_this2.state);
		} else {
		nextState = updater;
		}
		var createChangeEmitter = exports.createChangeEmitter = function createChangeEmitter() {
		var currentListeners = [];
		var nextListeners = currentListeners;

		if (nextState == null) {
		if (callback) callback();
		return;
		}
		function ensureCanMutateNextListeners() {
		if (nextListeners === currentListeners) {
		nextListeners = currentListeners.slice();
		}
		}

		_this2.state = Object.assign({}, _this2.state, nextState);
		function listen(listener) {
		if (typeof listener !== 'function') {
		throw new Error('Expected listener to be a function.');
		}

		var promises = _this2._listeners.map(function (listener) {
		return listener();
		});
		var isSubscribed = true;
		ensureCanMutateNextListeners();
		nextListeners.push(listener);
		return function () {
		if (!isSubscribed) {
		return;
		}

		return Promise.all(promises).then(function () {
		if (callback) {
		return callback();
		}
		});
		});
		};
		isSubscribed = false;
		ensureCanMutateNextListeners();
		var index = nextListeners.indexOf(listener);
		nextListeners.splice(index, 1);
		};
		}

		Container.prototype.subscribe = function subscribe(fn) {
		this._listeners.push(fn);
		};
		function emit() {
		currentListeners = nextListeners;
		var listeners = currentListeners;

		Container.prototype.unsubscribe = function unsubscribe(fn) {
		this._listeners = this._listeners.filter(function (f) {
		return f !== fn;
		});
		};
		for (var i = 0; i < listeners.length; i++) {
		listeners[i].apply(listeners, arguments);
		}
		}

		return Container;
		}();
		return {
		listen: listen,
		emit: emit
		};
		};
		});

		var DUMMY_STATE = {};
		unwrapExports(lib);
		var lib_1 = lib.createChangeEmitter;

		var Subscribe = function (_React$Component) {
		_inherits(Subscribe, _React$Component);
		function symbolObservablePonyfill(root) {
		var result;
		var Symbol = root.Symbol;

		function Subscribe() {
		var _temp, _this3, _ret;
		if (typeof Symbol === 'function') {
		if (Symbol.observable) {
		result = Symbol.observable;
		} else {
		result = Symbol('observable');
		Symbol.observable = result;
		}
		} else {
		result = '@@observable';
		}

		_classCallCheck(this, Subscribe);
		return result;
		}

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}
		/* global window */
		var root;

		return _ret = (_temp = (_this3 = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this3), _this3.state = {}, _this3.instances = [], _this3.unmounted = false, _this3.onUpdate = function () {
		return new Promise(function (resolve) {
		if (!_this3.unmounted) {
		_this3.setState(DUMMY_STATE, resolve);
		} else {
		resolve();
		}
		});
		}, _temp), _possibleConstructorReturn(_this3, _ret);
		}
		if (typeof self !== 'undefined') {
		root = self;
		} else if (typeof window !== 'undefined') {
		root = window;
		} else if (typeof global !== 'undefined') {
		root = global;
		} else if (typeof module !== 'undefined') {
		root = module;
		} else {
		root = Function('return this')();
		}

		Subscribe.prototype.componentWillUnmount = function componentWillUnmount() {
		this.unmounted = true;
		this._unsubscribe();
		};
		var result = symbolObservablePonyfill(root);

		Subscribe.prototype._unsubscribe = function _unsubscribe() {
		var _this4 = this;
		var Nothing =
		/#__PURE__/
		function (_Component) {
		_inheritsLoose$1(Nothing, _Component);

		this.instances.forEach(function (container) {
		container.unsubscribe(_this4.onUpdate);
		});
		};
		function Nothing() {
		return _Component.apply(this, arguments) \|\| this;
		}

		Subscribe.prototype._createInstances = function _createInstances(map, containers) {
		var _this5 = this;
		var _proto = Nothing.prototype;

		this._unsubscribe();
		_proto.render = function render() {
		return null;
		};

		if (map === null) {
		throw new Error('You must wrap your <Subscribe> components with a <Provider>');
		}
		return Nothing;
		}(React.Component);

		var safeMap = map;
		var instances = containers.map(function (ContainerItem) {
		var instance = void 0;
		var fromRenderProps = function fromRenderProps(RenderPropsComponent, propsMapper, renderPropName) {
		if (renderPropName === void 0) {
		renderPropName = 'children';
		}

		if ((typeof ContainerItem === 'undefined' ? 'undefined' : _typeof(ContainerItem)) === 'object' && ContainerItem instanceof Container) {
		instance = ContainerItem;
		} else {
		instance = safeMap.get(ContainerItem);
		return function (BaseComponent) {
		var baseFactory = React__default.createFactory(BaseComponent);
		var renderPropsFactory = React__default.createFactory(RenderPropsComponent);

		if (!instance) {
		instance = new ContainerItem();
		safeMap.set(ContainerItem, instance);
		}
		}
		var FromRenderProps = function FromRenderProps(ownerProps) {
		var _renderPropsFactory;

		instance.unsubscribe(_this5.onUpdate);
		instance.subscribe(_this5.onUpdate);
		return renderPropsFactory((_renderPropsFactory = {}, _renderPropsFactory[renderPropName] = function () {
		return baseFactory(_extends({}, ownerProps, propsMapper.apply(void 0, arguments)));
		}, _renderPropsFactory));
		};

		return instance;
		});
		return FromRenderProps;
		};
		};

		this.instances = instances;
		return instances;
		};
		var compose = function compose() {
		for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
		funcs[_key] = arguments[_key];
		}

		Subscribe.prototype.render = function render() {
		var _this6 = this;
		return funcs.reduce(function (a, b) {
		return function () {
		return a(b.apply(void 0, arguments));
		};
		}, function (arg) {
		return arg;
		});
		};

		return React__default.createElement(StateContext.Consumer, null, function (map) {
		return _this6.props.children.apply(null, _this6._createInstances(map, _this6.props.to));
		});
		};
		/*!
		* consecutive
		* Get consecutive numbers
		* Copyright(c) 2017 ivanoff .$ curl -A cv ivanoff.org.ua
		* MIT Licensed
		*/

		return Subscribe;
		}(React__default.Component);
		var consecutive = function (begin, base, inc) {
		var number = begin \|\| 0;
		if (typeof base !== 'number') base = 10;
		if (typeof inc !== 'number') inc = 1;
		return function () {
		var res;

		function Provider(props) {
		return React__default.createElement(StateContext.Consumer, null, function (parentMap) {
		var childMap = new Map(parentMap);
		if (typeof base === 'undefined' \|\| base === 10) {
		res = number;
		number += inc;
		} else {
		res = number.toString();
		number = (parseInt(number, base) + inc).toString(base);
		}

		if (props.inject) {
		props.inject.forEach(function (instance) {
		childMap.set(instance.constructor, instance);
		});
		}
		return res;
		};
		};

		return React__default.createElement(StateContext.Provider, { value: childMap }, props.children);
		});
		}
		// Arbitrary, but ought to be unique to avoid context namespace clashes.
		var CONTEXT_KEY$1 = 'react-accessible-accordion@ItemContainer';
		var Provider$1 =
		/#__PURE__/
		function (_Component) {
		_inherits(Provider, _Component);

		var CONTAINER_DEBUG_CALLBACKS = [];
		function Provider() {
		_classCallCheck(this, Provider);

		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; };
		return _possibleConstructorReturn(this, _getPrototypeOf(Provider).apply(this, arguments));
		}

		function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
		_createClass(Provider, [{
		key: "getChildContext",
		value: function getChildContext() {
		var uuid = this.props.uuid;
		var context = {
		uuid: uuid
		};
		return _defineProperty({}, CONTEXT_KEY$1, context);
		}
		}, {
		key: "render",
		value: function render() {
		return this.props.children \|\| null;
		}
		}]);

		function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		return Provider;
		}(React.Component);

		function _possibleConstructorReturn$1(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; }
		_defineProperty(Provider$1, "childContextTypes", _defineProperty({}, CONTEXT_KEY$1, function () {
		return null;
		}));

		function _inherits$1(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
		// eslint-disable-next-line react/no-multi-comp
		var Consumer$1 =
		/#__PURE__/
		function (_Component2) {
		_inherits(Consumer, _Component2);

		var AccordionContainer = function (_Container) {
		_inherits$1(AccordionContainer, _Container);
		function Consumer() {
		_classCallCheck(this, Consumer);

		function AccordionContainer() {
		var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
		return _possibleConstructorReturn(this, _getPrototypeOf(Consumer).apply(this, arguments));
		}

		_classCallCheck$1(this, AccordionContainer);
		_createClass(Consumer, [{
		key: "render",
		value: function render() {
		return this.props.children(this.context[CONTEXT_KEY$1]);
		}
		}]);

		var _this = _possibleConstructorReturn$1(this, (AccordionContainer.__proto__ \|\| Object.getPrototypeOf(AccordionContainer)).call(this));
		return Consumer;
		}(React.Component);

		_this.setAccordion = function (accordion) {
		if (accordion !== _this.state.accordion) {
		return _this.setState({ accordion: accordion });
		}
		return null;
		};
		_defineProperty(Consumer$1, "contextTypes", _defineProperty({}, CONTEXT_KEY$1, function () {
		return null;
		}));

		_this.setOnChange = function (onChange) {
		if (onChange !== _this.state.onChange) {
		return _this.setState({ onChange: onChange });
		}
		return null;
		};
		var classnames = createCommonjsModule(function (module) {
		/*!
		Copyright (c) 2016 Jed Watson.
		Licensed under the MIT License (MIT), see
		http://jedwatson.github.io/classnames
		*/

		_this.addItem = function (newItem) {
		// Need to use callback style otherwise race-conditions are created by concurrent registrations.
		_this.setState(function (state) {
		var items = void 0;
		/* global define */
		(function () {

		if (state.items.some(function (item) {
		return item.uuid === newItem.uuid;
		})) {
		// eslint-disable-next-line no-console
		console.error('AccordionItem error: One item already has the uuid "' + newItem.uuid + '". Uuid property must be unique. See: https://github.com/springload/react-accessible-accordion#accordionitem');
		}
		if (state.accordion && newItem.expanded) {
		// If this is a true accordion and the new item is expanded, then the others must be closed.
		items = [].concat(_toConsumableArray(state.items.map(function (item) {
		return _extends({}, item, {
		expanded: false
		});
		})), [newItem]);
		} else {
		items = [].concat(_toConsumableArray(state.items), [newItem]);
		}
		return {
		items: items
		};
		});
		};
		var hasOwn = {}.hasOwnProperty;

		_this.removeItem = function (key) {
		return _this.setState(function (state) {
		return {
		items: state.items.filter(function (item) {
		return item.uuid !== key;
		})
		};
		});
		};
		function classNames() {
		var classes = [];

		_this.setExpanded = function (key, expanded) {
		return _this.setState(function (state) {
		return {
		items: state.items.map(function (item) {
		if (item.uuid === key) {
		return _extends({}, item, {
		expanded: expanded
		});
		}
		if (state.accordion && expanded) {
		// If this is an accordion, we might need to collapse the other expanded item.
		return _extends({}, item, {
		expanded: false
		});
		}
		return item;
		})
		};
		}).then(function () {
		if (_this.state.accordion) {
		_this.state.onChange(key);
		} else {
		_this.state.onChange(_this.state.items.filter(function (item) {
		return item.expanded;
		}).map(function (item) {
		return item.uuid;
		}));
		}
		});
		};
		for (var i = 0; i < arguments.length; i++) {
		var arg = arguments[i];
		if (!arg) continue;
		var argType = typeof arg;

		_this.state = _extends({
		items: [],
		accordion: true,
		onChange: function onChange() {}
		}, args);
		return _this;
		}
		if (argType === 'string' \|\| argType === 'number') {
		classes.push(arg);
		} else if (Array.isArray(arg)) {
		classes.push(classNames.apply(null, arg));
		} else if (argType === 'object') {
		for (var key in arg) {
		if (hasOwn.call(arg, key) && arg[key]) {
		classes.push(key);
		}
		}
		}
		}

		return AccordionContainer;
		}(Container);
		return classes.join(' ');
		}

		var _extends$1 = 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; };
		if (module.exports) {
		module.exports = classNames;
		} else if (typeof undefined === 'function' && typeof undefined.amd === 'object' && undefined.amd) {
		// register as 'classnames', consistent with npm package name
		undefined('classnames', [], function () {
		return classNames;
		});
		} else {
		window.classNames = classNames;
		}
		})();
		});

		function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
		var AccordionItem =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItem, _Component);

		var accordionDefaultProps = {
		accordion: true
		};
		function AccordionItem() {
		_classCallCheck(this, AccordionItem);

		var Accordion = function Accordion(_ref) {
		var accordion = _ref.accordion,
		rest = _objectWithoutProperties(_ref, ['accordion']);
		return _possibleConstructorReturn(this, _getPrototypeOf(AccordionItem).apply(this, arguments));
		}

		return React__default.createElement('div', _extends$1({ role: accordion ? 'tablist' : null }, rest));
		};
		Accordion.defaultProps = accordionDefaultProps;
		_createClass(AccordionItem, [{
		key: "componentDidMount",
		value: function componentDidMount() {
		var _this$props = this.props,
		uuid = _this$props.uuid,
		accordionStore = _this$props.accordionStore,
		disabled = _this$props.disabled;
		accordionStore.addItem({
		uuid: uuid,
		expanded: this.props.expanded \|\| false,
		disabled: disabled
		});
		}
		}, {
		key: "componentWillUnmount",
		value: function componentWillUnmount() {
		this.props.accordionStore.removeItem(this.props.uuid);
		} // This is here so that the user can dynamically set the 'expanded' state using the 'expanded' prop.

		var _extends$2 = 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; };
		}, {
		key: "componentDidUpdate",
		value: function componentDidUpdate(prevProps) {
		var _this$props2 = this.props,
		uuid = _this$props2.uuid,
		expanded = _this$props2.expanded,
		accordionStore = _this$props2.accordionStore;

		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; }; }();
		if (expanded !== prevProps.expanded) {
		accordionStore.setExpanded(uuid, expanded);
		}
		}
		}, {
		key: "render",
		value: function render() {
		var _this$props3 = this.props,
		uuid = _this$props3.uuid,
		className = _this$props3.className,
		hideBodyClassName = _this$props3.hideBodyClassName,
		accordionStore = _this$props3.accordionStore,
		disabled = _this$props3.disabled,
		expanded = _this$props3.expanded,
		rest = _objectWithoutProperties(_this$props3, ["uuid", "className", "hideBodyClassName", "accordionStore", "disabled", "expanded"]); // Deliberately not using 'find' because IE compat.

		function _objectWithoutProperties$1(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$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		var currentItem = accordionStore.items.filter(function (item) {
		return item.uuid === uuid;
		})[0];

		function _possibleConstructorReturn$2(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; }
		if (!currentItem) {
		return null;
		}

		function _inherits$2(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 React__default.createElement("div", _extends({
		className: classnames(className, _defineProperty({}, hideBodyClassName, !currentItem.expanded && hideBodyClassName))
		}, rest));
		}
		}]);

		var defaultProps = {
		accordion: true,
		onChange: function onChange() {},
		className: 'accordion',
		children: null
		};
		return AccordionItem;
		}(React.Component);

		var AccordionWrapper = function (_Component) {
		_inherits$2(AccordionWrapper, _Component);
		var nextUuid = consecutive();
		function resetNextUuid() {
		nextUuid = consecutive();
		}

		function AccordionWrapper() {
		var _ref;
		var AccordionItemWrapper =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItemWrapper, _Component);

		var _temp, _this, _ret;
		function AccordionItemWrapper() {
		var _getPrototypeOf2;

		_classCallCheck$2(this, AccordionWrapper);
		var _this;

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}
		_classCallCheck(this, AccordionItemWrapper);

		return _ret = (_temp = (_this = _possibleConstructorReturn$2(this, (_ref = AccordionWrapper.__proto__ \|\| Object.getPrototypeOf(AccordionWrapper)).call.apply(_ref, [this].concat(args))), _this), _this.accordionStore = new AccordionContainer({
		accordion: _this.props.accordion,
		onChange: _this.props.onChange
		}), _this.renderAccordion = function (accordionStore) {
		var _this$props = _this.props,
		accordion = _this$props.accordion,
		onChange = _this$props.onChange,
		rest = _objectWithoutProperties$1(_this$props, ['accordion', 'onChange']);
		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return React__default.createElement(Accordion, _extends$2({ accordion: accordionStore.state.accordion }, rest));
		}, _temp), _possibleConstructorReturn$2(_this, _ret);
		}
		_this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AccordionItemWrapper)).call.apply(_getPrototypeOf2, [this].concat(args)));

		_createClass(AccordionWrapper, [{
		key: 'componentDidMount',
		value: function componentDidMount() {
		this.accordionStore.setAccordion(this.props.accordion);
		this.accordionStore.setOnChange(this.props.onChange);
		}
		}, {
		key: 'componentDidUpdate',
		value: function componentDidUpdate() {
		this.accordionStore.setAccordion(this.props.accordion);
		this.accordionStore.setOnChange(this.props.onChange);
		}
		}, {
		key: 'render',
		value: function render() {
		return React__default.createElement(
		Provider,
		{ inject: [this.accordionStore] },
		React__default.createElement(
		Subscribe,
		{ to: [AccordionContainer] },
		this.renderAccordion
		)
		);
		}
		}]);
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "id", nextUuid());

		return AccordionWrapper;
		}(React.Component);
		return _this;
		}

		AccordionWrapper.defaultProps = defaultProps;
		_createClass(AccordionItemWrapper, [{
		key: "render",
		value: function render() {
		var _this$props = this.props,
		accordionStore = _this$props.accordionStore,
		uuid = _this$props.uuid,
		rest = _objectWithoutProperties(_this$props, ["accordionStore", "uuid"]);

		/*!
		* consecutive
		* Get consecutive numbers
		* Copyright(c) 2017 ivanoff .$ curl -A cv ivanoff.org.ua
		* MIT Licensed
		*/
		var itemUuid = uuid !== undefined ? uuid : this.id;
		return React__default.createElement(Provider$1, {
		uuid: itemUuid
		}, React__default.createElement(AccordionItem, _extends({}, rest, {
		uuid: itemUuid,
		accordionStore: accordionStore
		})));
		}
		}]);

		var consecutive = function (begin, base, inc) {
		var number = begin \|\| 0;
		if (typeof base !== 'number') base = 10;
		if (typeof inc !== 'number') inc = 1;
		return AccordionItemWrapper;
		}(React.Component);

		return function () {
		var res;
		if (typeof base === 'undefined' \|\| base === 10) {
		res = number;
		number += inc;
		} else {
		res = number.toString();
		number = (parseInt(number, base) + inc).toString(base);
		}
		_defineProperty(AccordionItemWrapper, "defaultProps", {
		className: 'accordion__item',
		hideBodyClassName: '',
		disabled: false,
		expanded: false,
		uuid: undefined
		});

		return res;
		};
		};
		var AccordionItem_wrapper = compose(fromRenderProps(Consumer, function (accordionStore) {
		return {
		accordionStore: accordionStore
		};
		}))(AccordionItemWrapper);

		var _extends$3 = 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 AccordionItemTitle =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItemTitle, _Component);

		var _createClass$1 = 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 AccordionItemTitle() {
		var _getPrototypeOf2;

		function _classCallCheck$3(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		var _this;

		function _possibleConstructorReturn$3(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; }
		_classCallCheck(this, AccordionItemTitle);

		function _inherits$3(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; }
		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		var nextUuid = consecutive();
		function resetNextUuid() {
		nextUuid = consecutive();
		}
		_this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AccordionItemTitle)).call.apply(_getPrototypeOf2, [this].concat(args)));

		var ItemContainer = function (_Container) {
		_inherits$3(ItemContainer, _Container);
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "handleClick", function () {
		var _this$props = _this.props,
		uuid = _this$props.uuid,
		expanded = _this$props.expanded,
		setExpanded = _this$props.setExpanded;
		setExpanded(uuid, !expanded);
		});

		function ItemContainer() {
		var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
		_defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "handleKeyPress", function (evt) {
		if (evt.charCode === 13 \|\| evt.charCode === 32) {
		evt.preventDefault();

		_classCallCheck$3(this, ItemContainer);
		_this.handleClick();
		}
		});

		var _this = _possibleConstructorReturn$3(this, (ItemContainer.__proto__ \|\| Object.getPrototypeOf(ItemContainer)).call(this));
		return _this;
		}

		_this.state = _extends$3({}, args);
		if (_this.state.uuid === undefined) {
		_this.state.uuid = nextUuid();
		}
		return _this;
		}
		_createClass(AccordionItemTitle, [{
		key: "render",
		value: function render() {
		var _this$props2 = this.props,
		className = _this$props2.className,
		hideBodyClassName = _this$props2.hideBodyClassName,
		item = _this$props2.item,
		accordion = _this$props2.accordion,
		setExpanded = _this$props2.setExpanded,
		expanded = _this$props2.expanded,
		uuid = _this$props2.uuid,
		disabled = _this$props2.disabled,
		rest = _objectWithoutProperties(_this$props2, ["className", "hideBodyClassName", "item", "accordion", "setExpanded", "expanded", "uuid", "disabled"]);

		_createClass$1(ItemContainer, [{
		key: 'setUuid',
		value: function setUuid(customUuid) {
		return this.setState({
		uuid: customUuid
		});
		}
		}]);
		var id = "accordion__title-".concat(uuid);
		var ariaControls = "accordion__body-".concat(uuid);
		var role = accordion ? 'tab' : 'button';
		var titleClassName = classnames(className, _defineProperty({}, hideBodyClassName, hideBodyClassName && !expanded));

		return ItemContainer;
		}(Container);
		if (role === 'tab') {
		return React__default.createElement("div", _extends({
		id: id,
		"aria-selected": expanded,
		"aria-controls": ariaControls,
		className: titleClassName,
		onClick: disabled ? undefined : this.handleClick,
		role: role,
		tabIndex: "0" // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
		,
		onKeyPress: this.handleKeyPress,
		disabled: disabled
		}, rest));
		}

		var classnames = createCommonjsModule(function (module) {
		var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
		return React__default.createElement("div", _extends({
		id: id,
		"aria-expanded": expanded,
		"aria-controls": ariaControls,
		className: titleClassName,
		onClick: disabled ? undefined : this.handleClick,
		role: role,
		tabIndex: "0" // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
		,
		onKeyPress: this.handleKeyPress,
		disabled: disabled
		}, rest));
		}
		}]);

		/*!
		Copyright (c) 2016 Jed Watson.
		Licensed under the MIT License (MIT), see
		http://jedwatson.github.io/classnames
		*/
		/* global define */
		return AccordionItemTitle;
		}(React.Component);

		(function () {
		_defineProperty(AccordionItemTitle, "accordionElementName", 'AccordionItemTitle');

		var hasOwn = {}.hasOwnProperty;
		// eslint-disable-next-line react/prefer-stateless-function
		var AccordionItemTitleWrapper =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItemTitleWrapper, _Component);

		function classNames() {
		var classes = [];
		function AccordionItemTitleWrapper() {
		_classCallCheck(this, AccordionItemTitleWrapper);

		for (var i = 0; i < arguments.length; i++) {
		var arg = arguments[i];
		if (!arg) continue;
		return _possibleConstructorReturn(this, _getPrototypeOf(AccordionItemTitleWrapper).apply(this, arguments));
		}

		var argType = typeof arg === 'undefined' ? 'undefined' : _typeof(arg);
		_createClass(AccordionItemTitleWrapper, [{
		key: "render",
		value: function render() {
		var _this$props = this.props,
		itemStore = _this$props.itemStore,
		accordionStore = _this$props.accordionStore,
		rest = _objectWithoutProperties(_this$props, ["itemStore", "accordionStore"]);

		if (argType === 'string' \|\| argType === 'number') {
		classes.push(arg);
		} else if (Array.isArray(arg)) {
		classes.push(classNames.apply(null, arg));
		} else if (argType === 'object') {
		for (var key in arg) {
		if (hasOwn.call(arg, key) && arg[key]) {
		classes.push(key);
		}
		}
		}
		}
		var uuid = itemStore.uuid;
		var items = accordionStore.items,
		accordion = accordionStore.accordion;
		var item = items.filter(function (stateItem) {
		return stateItem.uuid === uuid;
		})[0];
		return React__default.createElement(AccordionItemTitle, _extends({}, rest, item, {
		setExpanded: accordionStore.setExpanded,
		accordion: accordion
		}));
		}
		}]);

		return classes.join(' ');
		}
		return AccordionItemTitleWrapper;
		}(React.Component);

		if (module.exports) {
		module.exports = classNames;
		} else if (typeof undefined === 'function' && _typeof(undefined.amd) === 'object' && undefined.amd) {
		// register as 'classnames', consistent with npm package name
		undefined('classnames', [], function () {
		return classNames;
		});
		} else {
		window.classNames = classNames;
		}
		})();
		});
		_defineProperty(AccordionItemTitleWrapper, "defaultProps", {
		className: 'accordion__title',
		hideBodyClassName: ''
		});

		var _extends$4 = 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 AccordionItemTitle_wrapper = compose(fromRenderProps(Consumer, function (accordionStore) {
		return {
		accordionStore: accordionStore
		};
		}), fromRenderProps(Consumer$1, function (itemStore) {
		return {
		itemStore: itemStore
		};
		}))(AccordionItemTitleWrapper);

		var _createClass$2 = 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 AccordionItemBody = function AccordionItemBody(props) {
		var className = props.className,
		hideBodyClassName = props.hideBodyClassName,
		uuid = props.uuid,
		expanded = props.expanded,
		disabled = props.disabled,
		accordion = props.accordion,
		rest = _objectWithoutProperties(props, ["className", "hideBodyClassName", "uuid", "expanded", "disabled", "accordion"]);

		function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
		return React__default.createElement("div", _extends({
		id: "accordion__body-".concat(uuid),
		className: classnames(className, _defineProperty({}, hideBodyClassName, !expanded)),
		"aria-hidden": !expanded,
		"aria-labelledby": "accordion__title-".concat(uuid),
		role: accordion ? 'tabpanel' : null
		}, rest));
		};

		function _objectWithoutProperties$2(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; }
		// eslint-disable-next-line react/prefer-stateless-function
		var AccordionItemBodyWrapper =
		/#__PURE__/
		function (_Component) {
		_inherits(AccordionItemBodyWrapper, _Component);

		function _classCallCheck$4(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		function AccordionItemBodyWrapper() {
		_classCallCheck(this, AccordionItemBodyWrapper);

		function _possibleConstructorReturn$4(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; }
		return _possibleConstructorReturn(this, _getPrototypeOf(AccordionItemBodyWrapper).apply(this, arguments));
		}

		function _inherits$4(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; }
		_createClass(AccordionItemBodyWrapper, [{
		key: "render",
		value: function render() {
		var _this$props = this.props,
		itemStore = _this$props.itemStore,
		accordionStore = _this$props.accordionStore,
		rest = _objectWithoutProperties(_this$props, ["itemStore", "accordionStore"]);

		var AccordionItem = function (_Component) {
		_inherits$4(AccordionItem, _Component);
		var uuid = itemStore.uuid;
		var items = accordionStore.items,
		accordion = accordionStore.accordion;
		var item = items.filter(function (stateItem) {
		return stateItem.uuid === uuid;
		})[0];
		return item ? React__default.createElement(AccordionItemBody, _extends({}, rest, item, {
		accordion: accordion
		})) : null;
		}
		}]);

		function AccordionItem() {
		_classCallCheck$4(this, AccordionItem);
		return AccordionItemBodyWrapper;
		}(React.Component);

		return _possibleConstructorReturn$4(this, (AccordionItem.__proto__ \|\| Object.getPrototypeOf(AccordionItem)).apply(this, arguments));
		}
		_defineProperty(AccordionItemBodyWrapper, "defaultProps", {
		className: 'accordion__body',
		hideBodyClassName: 'accordion__body--hidden'
		});

		_createClass$2(AccordionItem, [{
		key: 'componentDidMount',
		value: function componentDidMount() {
		var _props = this.props,
		uuid = _props.uuid,
		accordionStore = _props.accordionStore,
		disabled = _props.disabled;
		var AccordionItemBody_wrapper = compose(fromRenderProps(Consumer, function (accordionStore) {
		return {
		accordionStore: accordionStore
		};
		}), fromRenderProps(Consumer$1, function (itemStore) {
		return {
		itemStore: itemStore
		};
		}))(AccordionItemBodyWrapper);

		// eslint-disable-next-line

		accordionStore.addItem({
		uuid: uuid,
		expanded: this.props.expanded \|\| false,
		disabled: disabled
		});
		}
		}, {
		key: 'componentWillUnmount',
		value: function componentWillUnmount() {
		this.props.accordionStore.removeItem(this.props.uuid);
		}
		exports.Accordion = AccordionWrapper;
		exports.AccordionItem = AccordionItem_wrapper;
		exports.AccordionItemTitle = AccordionItemTitle_wrapper;
		exports.AccordionItemBody = AccordionItemBody_wrapper;
		exports.resetNextUuid = resetNextUuid;

		// This is here so that the user can dynamically set the 'expanded' state using the 'expanded' prop.
		Object.defineProperty(exports, '__esModule', { value: true });

		}, {
		key: 'componentDidUpdate',
		value: function componentDidUpdate(prevProps) {
		var _props2 = this.props,
		uuid = _props2.uuid,
		expanded = _props2.expanded,
		accordionStore = _props2.accordionStore;

		if (expanded !== prevProps.expanded) {
		accordionStore.setExpanded(uuid, expanded);
		}
		}
		}, {
		key: 'render',
		value: function render() {
		var _props3 = this.props,
		uuid = _props3.uuid,
		className = _props3.className,
		hideBodyClassName = _props3.hideBodyClassName,
		accordionStore = _props3.accordionStore,
		disabled = _props3.disabled,
		expanded = _props3.expanded,
		rest = _objectWithoutProperties$2(_props3, ['uuid', 'className', 'hideBodyClassName', 'accordionStore', 'disabled', 'expanded']);

		var currentItem = accordionStore.state.items.filter(function (item) {
		return item.uuid === uuid;
		})[0];

		if (!currentItem) {
		return null;
		}

		return React__default.createElement('div', _extends$4({
		className: classnames(className, _defineProperty({}, hideBodyClassName, !currentItem.expanded && hideBodyClassName))
		}, rest));
		}
		}]);

		return AccordionItem;
		}(React.Component);

		var _extends$5 = 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$3 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

		function _classCallCheck$5(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn$5(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$5(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 defaultProps$1 = {
		className: 'accordion__item',
		hideBodyClassName: '',
		disabled: false,
		expanded: false,
		accordionStore: new AccordionContainer(),
		uuid: undefined
		};

		var AccordionItemWrapper = function (_Component) {
		_inherits$5(AccordionItemWrapper, _Component);

		function AccordionItemWrapper() {
		var _ref;

		var _temp, _this, _ret;

		_classCallCheck$5(this, AccordionItemWrapper);

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return _ret = (_temp = (_this = _possibleConstructorReturn$5(this, (_ref = AccordionItemWrapper.__proto__ \|\| Object.getPrototypeOf(AccordionItemWrapper)).call.apply(_ref, [this].concat(args))), _this), _this.itemContainer = new ItemContainer({
		uuid: _this.props.uuid
		}), _this.renderItem = function (accordionStore, itemStore) {
		var uuid = itemStore.state.uuid;

		return React__default.createElement(AccordionItem, _extends$5({}, _this.props, {
		uuid: uuid,
		accordionStore: accordionStore
		}));
		}, _temp), _possibleConstructorReturn$5(_this, _ret);
		}

		_createClass$3(AccordionItemWrapper, [{
		key: 'render',
		value: function render() {
		return React__default.createElement(
		Provider,
		{ inject: [this.itemContainer] },
		React__default.createElement(
		Subscribe,
		{ to: [AccordionContainer, ItemContainer] },
		this.renderItem
		)
		);
		}
		}]);

		return AccordionItemWrapper;
		}(React.Component);

		AccordionItemWrapper.defaultProps = defaultProps$1;

		var _extends$6 = 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$4 = 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 _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

		function _objectWithoutProperties$3(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$6(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn$6(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$6(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 AccordionItemTitle = function (_Component) {
		_inherits$6(AccordionItemTitle, _Component);

		function AccordionItemTitle() {
		var _ref;

		var _temp, _this, _ret;

		_classCallCheck$6(this, AccordionItemTitle);

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return _ret = (_temp = (_this = _possibleConstructorReturn$6(this, (_ref = AccordionItemTitle.__proto__ \|\| Object.getPrototypeOf(AccordionItemTitle)).call.apply(_ref, [this].concat(args))), _this), _this.handleClick = function () {
		var _this$props = _this.props,
		uuid = _this$props.uuid,
		expanded = _this$props.expanded,
		setExpanded = _this$props.setExpanded;


		setExpanded(uuid, !expanded);
		}, _this.handleKeyPress = function (evt) {
		if (evt.charCode === 13 \|\| evt.charCode === 32) {
		evt.preventDefault();
		_this.handleClick();
		}
		}, _temp), _possibleConstructorReturn$6(_this, _ret);
		}

		_createClass$4(AccordionItemTitle, [{
		key: 'render',
		value: function render() {
		var _props = this.props,
		className = _props.className,
		hideBodyClassName = _props.hideBodyClassName,
		accordionStore = _props.accordionStore,
		item = _props.item,
		accordion = _props.accordion,
		setExpanded = _props.setExpanded,
		expanded = _props.expanded,
		uuid = _props.uuid,
		disabled = _props.disabled,
		rest = _objectWithoutProperties$3(_props, ['className', 'hideBodyClassName', 'accordionStore', 'item', 'accordion', 'setExpanded', 'expanded', 'uuid', 'disabled']);

		var id = 'accordion__title-' + uuid;
		var ariaControls = 'accordion__body-' + uuid;
		var role = accordion ? 'tab' : 'button';
		var titleClassName = classnames(className, _defineProperty$1({}, hideBodyClassName, hideBodyClassName && !expanded));

		if (role === 'tab') {
		return React__default.createElement('div', _extends$6({
		id: id,
		'aria-selected': expanded,
		'aria-controls': ariaControls,
		className: titleClassName,
		onClick: disabled ? undefined : this.handleClick,
		role: role,
		tabIndex: '0' // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
		, onKeyPress: this.handleKeyPress,
		disabled: disabled
		}, rest));
		}
		return React__default.createElement('div', _extends$6({
		id: id,
		'aria-expanded': expanded,
		'aria-controls': ariaControls,
		className: titleClassName,
		onClick: disabled ? undefined : this.handleClick,
		role: role,
		tabIndex: '0' // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
		, onKeyPress: this.handleKeyPress,
		disabled: disabled
		}, rest));
		}
		}]);

		return AccordionItemTitle;
		}(React.Component);

		AccordionItemTitle.accordionElementName = 'AccordionItemTitle';

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

		function _classCallCheck$7(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn$7(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$7(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 AccordionItemTitleWrapper = function (_Component) {
		_inherits$7(AccordionItemTitleWrapper, _Component);

		function AccordionItemTitleWrapper() {
		var _ref;

		var _temp, _this, _ret;

		_classCallCheck$7(this, AccordionItemTitleWrapper);

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return _ret = (_temp = (_this = _possibleConstructorReturn$7(this, (_ref = AccordionItemTitleWrapper.__proto__ \|\| Object.getPrototypeOf(AccordionItemTitleWrapper)).call.apply(_ref, [this].concat(args))), _this), _this.renderItemTitle = function (accordionStore, itemStore) {
		var uuid = itemStore.state.uuid;
		var _accordionStore$state = accordionStore.state,
		items = _accordionStore$state.items,
		accordion = _accordionStore$state.accordion;

		var item = items.filter(function (stateItem) {
		return stateItem.uuid === uuid;
		})[0];

		return React__default.createElement(AccordionItemTitle, _extends$7({}, _this.props, item, {
		setExpanded: accordionStore.setExpanded,
		accordion: accordion
		}));
		}, _temp), _possibleConstructorReturn$7(_this, _ret);
		}

		_createClass$5(AccordionItemTitleWrapper, [{
		key: 'render',
		value: function render() {
		return React__default.createElement(
		Subscribe,
		{ to: [AccordionContainer, ItemContainer] },
		this.renderItemTitle
		);
		}
		}]);

		return AccordionItemTitleWrapper;
		}(React.Component);

		AccordionItemTitleWrapper.defaultProps = {
		className: 'accordion__title',
		hideBodyClassName: ''
		};

		var _extends$8 = 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; };

		function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

		function _objectWithoutProperties$4(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

		var AccordionItemBody = function AccordionItemBody(props) {
		var className = props.className,
		hideBodyClassName = props.hideBodyClassName,
		uuid = props.uuid,
		expanded = props.expanded,
		disabled = props.disabled,
		accordion = props.accordion,
		rest = _objectWithoutProperties$4(props, ['className', 'hideBodyClassName', 'uuid', 'expanded', 'disabled', 'accordion']);

		return React__default.createElement('div', _extends$8({
		id: 'accordion__body-' + uuid,
		className: classnames(className, _defineProperty$2({}, hideBodyClassName, !expanded)),
		'aria-hidden': !expanded,
		'aria-labelledby': 'accordion__title-' + uuid,
		role: accordion ? 'tabpanel' : null
		}, rest));
		};

		var _extends$9 = 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$6 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

		function _classCallCheck$8(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn$8(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$8(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 AccordionItemBodyWrapper = function (_Component) {
		_inherits$8(AccordionItemBodyWrapper, _Component);

		function AccordionItemBodyWrapper() {
		var _ref;

		var _temp, _this, _ret;

		_classCallCheck$8(this, AccordionItemBodyWrapper);

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return _ret = (_temp = (_this = _possibleConstructorReturn$8(this, (_ref = AccordionItemBodyWrapper.__proto__ \|\| Object.getPrototypeOf(AccordionItemBodyWrapper)).call.apply(_ref, [this].concat(args))), _this), _this.renderItemBody = function (accordionStore, itemStore) {
		var uuid = itemStore.state.uuid;
		var _accordionStore$state = accordionStore.state,
		items = _accordionStore$state.items,
		accordion = _accordionStore$state.accordion;

		var item = items.filter(function (stateItem) {
		return stateItem.uuid === uuid;
		})[0];
		return React__default.createElement(AccordionItemBody, _extends$9({}, _this.props, item, {
		accordion: accordion
		}));
		}, _temp), _possibleConstructorReturn$8(_this, _ret);
		}

		_createClass$6(AccordionItemBodyWrapper, [{
		key: 'render',
		value: function render() {
		return React__default.createElement(
		Subscribe,
		{ to: [AccordionContainer, ItemContainer] },
		this.renderItemBody
		);
		}
		}]);

		return AccordionItemBodyWrapper;
		}(React.Component);

		AccordionItemBodyWrapper.defaultProps = {
		className: 'accordion__body',
		hideBodyClassName: 'accordion__body--hidden'
		};

		exports.Accordion = AccordionWrapper;
		exports.AccordionItem = AccordionItemWrapper;
		exports.AccordionItemTitle = AccordionItemTitleWrapper;
		exports.AccordionItemBody = AccordionItemBodyWrapper;
		exports.resetNextUuid = resetNextUuid;

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

		})));

package.json

		{
		"name": "react-accessible-accordion",
		"version": "2.4.4",
		"version": "2.4.5",
		"description": "Accessible Accordion component for React",
		@@ -68,10 +68,13 @@ "main": "dist/umd/index.js",
		"devDependencies": {
		"babel-cli": "^6.26.0",
		"@babel/cli": "7.0.0",
		"@babel/core": "7.0.0",
		"@babel/plugin-proposal-class-properties": "7.0.0",
		"@babel/polyfill": "7.0.0",
		"@babel/preset-env": "7.0.0",
		"@babel/preset-flow": "7.0.0",
		"@babel/preset-react": "7.0.0",
		"babel-core": "^7.0.0-bridge.0",
		"babel-eslint": "^8.2.2",
		"babel-jest": "^23.0.1",
		"babel-loader": "^7.1.4",
		"babel-polyfill": "^6.26.0",
		"babel-preset-env": "^1.7.0",
		"babel-preset-react": "^6.24.1",
		"babel-preset-stage-2": "^6.24.1",
		"babel-jest": "^23.4.2",
		"babel-loader": "^8.0.0",
		"coveralls": "^3.0.0",
		@@ -93,3 +96,3 @@ "css-loader": "^1.0.0",
		"html-webpack-plugin": "^3.2.0",
		"jest": "^23.0.0",
		"jest": "^23.5.0",
		"prettier": "^1.12.0",
		@@ -101,3 +104,3 @@ "raf": "^3.4.0",
		"rollup": "^0.59.4",
		"rollup-plugin-babel": "^3.0.3",
		"rollup-plugin-babel": "^4.0.2",
		"rollup-plugin-commonjs": "^9.1.0",
		@@ -115,3 +118,3 @@ "rollup-plugin-eslint": "^4.0.0",
		"consecutive": "^5.0.4",
		"unstated": "^2.1.1"
		"recompose": "^0.30.0"
		},
		@@ -118,0 +121,0 @@ "peerDependencies": {

README.md

		@@ -61,2 +61,3 @@ [react-accessible-accordion](https://springload.github.io/react-accessible-accordion/) [![npm](https://img.shields.io/npm/v/react-accessible-accordion.svg?style=flat-square)](https://www.npmjs.com/package/react-accessible-accordion) [![Build Status](https://travis-ci.org/springload/react-accessible-accordion.svg?branch=master)](https://travis-ci.org/springload/react-accessible-accordion) [![Coverage Status](https://coveralls.io/repos/github/springload/react-accessible-accordion/badge.svg)](https://coveralls.io/github/springload/react-accessible-accordion) [![Dependency Status](https://david-dm.org/springload/react-accessible-accordion.svg?style=flat-square)](https://david-dm.org/springload/react-accessible-accordion) [![devDependency Status](https://david-dm.org/springload/react-accessible-accordion/dev-status.svg?style=flat-square)](https://david-dm.org/springload/react-accessible-accordion#info=devDependencies)
		We strongly encourage you to write your own styles for your accordions, but we've published these two starter stylesheets to help you get up and running:

		```js
		@@ -233,6 +234,6 @@ // 'Minimal' theme - hide/show the AccordionBody component:

		* Accordion: `tablist`
		* AccordionItem: no specific role
		* AccordionItemTitle: `tab`
		* AccordionItemBody: `tabpanel`
		* Accordion: `tablist`
		* AccordionItem: no specific role
		* AccordionItemTitle: `tab`
		* AccordionItemBody: `tabpanel`

		@@ -245,59 +246,7 @@ #### Multiple items

		* Accordion: no specific role
		* AccordionItem: no specific role
		* AccordionItemTitle: `button`
		* AccordionItemBody: no specific role
		* Accordion: no specific role
		* AccordionItem: no specific role
		* AccordionItemTitle: `button`
		* AccordionItemBody: no specific role

		## Development

		### Install

		> Clone the project on your computer, and install [Node](https://nodejs.org). This project also uses [nvm](https://github.com/springload/frontend-starter-kit/blob/master/docs/useful-tooling.md#nvm).

		```sh
		nvm install
		# Then, install all project dependencies.
		npm install
		# Install the git hooks.
		./.githooks/deploy
		# Set up a `.env` file with the appropriate secrets.
		touch .env
		```

		### Working on the project

		> Everything mentioned in the installation process should already be done.

		```sh
		# Make sure you use the right node version.
		nvm use
		# Start the the development tools in watch mode.
		npm run start
		# Runs linting.
		npm run lint
		# Runs tests.
		npm run test
		# View other available commands with:
		npm run
		```

		### Run the demo

		> Everything mentioned in the installation process should already be done.

		```sh
		# Make sure you use the right node version.
		nvm use
		# Start the server and the development tools.
		npm run start-demo
		```

		### Publish

		```sh
		npm version [TYPE]
		git push origin master --tags
		npm publish
		```

		# Browser support
		@@ -304,0 +253,0 @@

dist/es/unstated-test-helpers.js.flow

flow-typed/npm/jest_v22.x.x.js

dist/es/Accordion/Accordion.wrapper.js.flow