material-ui-pickers-fork/dist/material-ui-pickers.umd.js

React components, that implements material design pickers for material-ui v1

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('prop-types'), require('react-dom'), require('@babel/runtime/helpers/esm/extends'), require('@babel/runtime/helpers/esm/objectWithoutPropertiesLoose'), require('@babel/runtime/helpers/esm/inheritsLoose'), require('@babel/runtime/helpers/esm/createClass')) :
	typeof define === 'function' && define.amd ? define(['exports', 'react', 'prop-types', 'react-dom', '@babel/runtime/helpers/esm/extends', '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose', '@babel/runtime/helpers/esm/inheritsLoose', '@babel/runtime/helpers/esm/createClass'], factory) :
	(factory((global['material-ui-pickers-fork'] = {}),global.React,global.PropTypes,global.ReactDOM,global._extends,global._objectWithoutPropertiesLoose,global._inheritsLoose,global._createClass));
}(this, (function (exports,React,PropTypes,require$$10,_extends,_objectWithoutPropertiesLoose,_inheritsLoose,_createClass) { 'use strict';

	var React__default = 'default' in React ? React['default'] : React;
	PropTypes = PropTypes && PropTypes.hasOwnProperty('default') ? PropTypes['default'] : PropTypes;
	var require$$10__default = 'default' in require$$10 ? require$$10['default'] : require$$10;
	_extends = _extends && _extends.hasOwnProperty('default') ? _extends['default'] : _extends;
	_objectWithoutPropertiesLoose = _objectWithoutPropertiesLoose && _objectWithoutPropertiesLoose.hasOwnProperty('default') ? _objectWithoutPropertiesLoose['default'] : _objectWithoutPropertiesLoose;
	_inheritsLoose = _inheritsLoose && _inheritsLoose.hasOwnProperty('default') ? _inheritsLoose['default'] : _inheritsLoose;
	_createClass = _createClass && _createClass.hasOwnProperty('default') ? _createClass['default'] : _createClass;

	var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

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

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

	var keycode = createCommonjsModule(function (module, exports) {
	// Source: http://jsfiddle.net/vWx8V/
	// http://stackoverflow.com/questions/5603195/full-list-of-javascript-keycodes

	/**
	 * Conenience method returns corresponding value for given keyName or keyCode.
	 *
	 * @param {Mixed} keyCode {Number} or keyName {String}
	 * @return {Mixed}
	 * @api public
	 */

	function keyCode(searchInput) {
	  // Keyboard Events
	  if (searchInput && 'object' === typeof searchInput) {
	    var hasKeyCode = searchInput.which || searchInput.keyCode || searchInput.charCode;
	    if (hasKeyCode) searchInput = hasKeyCode;
	  }

	  // Numbers
	  if ('number' === typeof searchInput) return names[searchInput]

	  // Everything else (cast to string)
	  var search = String(searchInput);

	  // check codes
	  var foundNamedKey = codes[search.toLowerCase()];
	  if (foundNamedKey) return foundNamedKey

	  // check aliases
	  var foundNamedKey = aliases[search.toLowerCase()];
	  if (foundNamedKey) return foundNamedKey

	  // weird character?
	  if (search.length === 1) return search.charCodeAt(0)

	  return undefined
	}

	/**
	 * Compares a keyboard event with a given keyCode or keyName.
	 *
	 * @param {Event} event Keyboard event that should be tested
	 * @param {Mixed} keyCode {Number} or keyName {String}
	 * @return {Boolean}
	 * @api public
	 */
	keyCode.isEventKey = function isEventKey(event, nameOrCode) {
	  if (event && 'object' === typeof event) {
	    var keyCode = event.which || event.keyCode || event.charCode;
	    if (keyCode === null || keyCode === undefined) { return false; }
	    if (typeof nameOrCode === 'string') {
	      // check codes
	      var foundNamedKey = codes[nameOrCode.toLowerCase()];
	      if (foundNamedKey) { return foundNamedKey === keyCode; }
	    
	      // check aliases
	      var foundNamedKey = aliases[nameOrCode.toLowerCase()];
	      if (foundNamedKey) { return foundNamedKey === keyCode; }
	    } else if (typeof nameOrCode === 'number') {
	      return nameOrCode === keyCode;
	    }
	    return false;
	  }
	};

	exports = module.exports = keyCode;

	/**
	 * Get by name
	 *
	 *   exports.code['enter'] // => 13
	 */

	var codes = exports.code = exports.codes = {
	  'backspace': 8,
	  'tab': 9,
	  'enter': 13,
	  'shift': 16,
	  'ctrl': 17,
	  'alt': 18,
	  'pause/break': 19,
	  'caps lock': 20,
	  'esc': 27,
	  'space': 32,
	  'page up': 33,
	  'page down': 34,
	  'end': 35,
	  'home': 36,
	  'left': 37,
	  'up': 38,
	  'right': 39,
	  'down': 40,
	  'insert': 45,
	  'delete': 46,
	  'command': 91,
	  'left command': 91,
	  'right command': 93,
	  'numpad *': 106,
	  'numpad +': 107,
	  'numpad -': 109,
	  'numpad .': 110,
	  'numpad /': 111,
	  'num lock': 144,
	  'scroll lock': 145,
	  'my computer': 182,
	  'my calculator': 183,
	  ';': 186,
	  '=': 187,
	  ',': 188,
	  '-': 189,
	  '.': 190,
	  '/': 191,
	  '`': 192,
	  '[': 219,
	  '\\': 220,
	  ']': 221,
	  "'": 222
	};

	// Helper aliases

	var aliases = exports.aliases = {
	  'windows': 91,
	  '⇧': 16,
	  '⌥': 18,
	  '⌃': 17,
	  '⌘': 91,
	  'ctl': 17,
	  'control': 17,
	  'option': 18,
	  'pause': 19,
	  'break': 19,
	  'caps': 20,
	  'return': 13,
	  'escape': 27,
	  'spc': 32,
	  'spacebar': 32,
	  'pgup': 33,
	  'pgdn': 34,
	  'ins': 45,
	  'del': 46,
	  'cmd': 91
	};

	/*!
	 * Programatically add the following
	 */

	// lower case chars
	for (i = 97; i < 123; i++) codes[String.fromCharCode(i)] = i - 32;

	// numbers
	for (var i = 48; i < 58; i++) codes[i - 48] = i;

	// function keys
	for (i = 1; i < 13; i++) codes['f'+i] = i + 111;

	// numpad keys
	for (i = 0; i < 10; i++) codes['numpad '+i] = i + 96;

	/**
	 * Get by code
	 *
	 *   exports.name[13] // => 'Enter'
	 */

	var names = exports.names = exports.title = {}; // title for backward compat

	// Create reverse mapping
	for (i in codes) names[codes[i]] = i;

	// Add aliases
	for (var alias in aliases) {
	  codes[alias] = aliases[alias];
	}
	});
	var keycode_1 = keycode.code;
	var keycode_2 = keycode.codes;
	var keycode_3 = keycode.aliases;
	var keycode_4 = keycode.names;
	var keycode_5 = keycode.title;

	var classnames = createCommonjsModule(function (module) {
	/*!
	  Copyright (c) 2017 Jed Watson.
	  Licensed under the MIT License (MIT), see
	  http://jedwatson.github.io/classnames
	*/
	/* global define */

	(function () {

		var hasOwn = {}.hasOwnProperty;

		function classNames () {
			var classes = [];

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

				var argType = typeof arg;

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

			return classes.join(' ');
		}

		if (module.exports) {
			classNames.default = classNames;
			module.exports = classNames;
		} else {
			window.classNames = classNames;
		}
	}());
	});

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

	var classCallCheck = _classCallCheck;

	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);
	  }
	}

	function _createClass$1(Constructor, protoProps, staticProps) {
	  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
	  if (staticProps) _defineProperties(Constructor, staticProps);
	  return Constructor;
	}

	var createClass = _createClass$1;

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

	function _typeof(obj) {
	  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
	    module.exports = _typeof = function _typeof(obj) {
	      return _typeof2(obj);
	    };
	  } else {
	    module.exports = _typeof = function _typeof(obj) {
	      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
	    };
	  }

	  return _typeof(obj);
	}

	module.exports = _typeof;
	});

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

	  return self;
	}

	var assertThisInitialized = _assertThisInitialized;

	function _possibleConstructorReturn(self, call) {
	  if (call && (_typeof_1(call) === "object" || typeof call === "function")) {
	    return call;
	  }

	  return assertThisInitialized(self);
	}

	var possibleConstructorReturn = _possibleConstructorReturn;

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

	  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 inherits = _inherits;

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

	  for (i = 0; i < sourceKeys.length; i++) {
	    key = sourceKeys[i];
	    if (excluded.indexOf(key) >= 0) continue;
	    target[key] = source[key];
	  }

	  if (Object.getOwnPropertySymbols) {
	    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

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

	var objectWithoutProperties = _objectWithoutProperties;

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

	var defineProperty = _defineProperty;

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

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

	    ownKeys.forEach(function (key) {
	      defineProperty(target, key, source[key]);
	    });
	  }

	  return target;
	}

	var objectSpread = _objectSpread;

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

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

	var __DEV__ = process.env.NODE_ENV !== 'production';

	var warning = function() {};

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

	  warning = function(condition, format, args) {
	    var len = arguments.length;
	    args = new Array(len > 2 ? len - 2 : 0);
	    for (var key = 2; key < len; key++) {
	      args[key - 2] = arguments[key];
	    }
	    if (format === undefined) {
	      throw new Error(
	          '`warning(condition, format, ...args)` requires a warning ' +
	          'message argument'
	      );
	    }
	    if (!condition) {
	      printWarning.apply(null, [format].concat(args));
	    }
	  };
	}

	var warning_1 = warning;

	var reactEventListener_cjs = createCommonjsModule(function (module, exports) {

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

	function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

	var _classCallCheck = _interopDefault(classCallCheck);
	var _createClass$$1 = _interopDefault(createClass);
	var _possibleConstructorReturn = _interopDefault(possibleConstructorReturn);
	var _inherits = _interopDefault(inherits);
	var _typeof = _interopDefault(_typeof_1);
	var _objectWithoutProperties = _interopDefault(objectWithoutProperties);
	var _objectSpread = _interopDefault(objectSpread);
	var React$$1 = _interopDefault(React__default);
	var PropTypes$$1 = _interopDefault(PropTypes);
	var warning = _interopDefault(warning_1);

	function defineProperty(object, property, attr) {
	  return Object.defineProperty(object, property, attr);
	} // Passive options
	// Inspired by https://github.com/Modernizr/Modernizr/blob/master/feature-detects/dom/passiveeventlisteners.js


	var passiveOption = function () {
	  var cache = null;
	  return function () {
	    if (cache !== null) {
	      return cache;
	    }

	    var supportsPassiveOption = false;

	    try {
	      window.addEventListener('test', null, defineProperty({}, 'passive', {
	        get: function get() {
	          supportsPassiveOption = true;
	        }
	      }));
	    } catch (err) {//
	    }

	    cache = supportsPassiveOption;
	    return supportsPassiveOption;
	  }();
	}();

	var defaultEventOptions = {
	  capture: false,
	  passive: false
	};

	function mergeDefaultEventOptions(options) {
	  return _objectSpread({}, defaultEventOptions, options);
	}

	function getEventListenerArgs(eventName, callback, options) {
	  var args = [eventName, callback];
	  args.push(passiveOption ? options : options.capture);
	  return args;
	}

	function on(target, eventName, callback, options) {
	  // eslint-disable-next-line prefer-spread
	  target.addEventListener.apply(target, getEventListenerArgs(eventName, callback, options));
	}

	function off(target, eventName, callback, options) {
	  // eslint-disable-next-line prefer-spread
	  target.removeEventListener.apply(target, getEventListenerArgs(eventName, callback, options));
	}

	function forEachListener(props, iteratee) {
	  var children = props.children,
	      target = props.target,
	      eventProps = _objectWithoutProperties(props, ["children", "target"]);

	  Object.keys(eventProps).forEach(function (name) {
	    if (name.substring(0, 2) !== 'on') {
	      return;
	    }

	    var prop = eventProps[name];

	    var type = _typeof(prop);

	    var isObject = type === 'object';
	    var isFunction = type === 'function';

	    if (!isObject && !isFunction) {
	      return;
	    }

	    var capture = name.substr(-7).toLowerCase() === 'capture';
	    var eventName = name.substring(2).toLowerCase();
	    eventName = capture ? eventName.substring(0, eventName.length - 7) : eventName;

	    if (isObject) {
	      iteratee(eventName, prop.handler, prop.options);
	    } else {
	      iteratee(eventName, prop, mergeDefaultEventOptions({
	        capture: capture
	      }));
	    }
	  });
	}

	function withOptions(handler, options) {
	  process.env.NODE_ENV !== "production" ? warning(options, 'react-event-listener: should be specified options in withOptions.') : void 0;
	  return {
	    handler: handler,
	    options: mergeDefaultEventOptions(options)
	  };
	}

	var EventListener =
	/*#__PURE__*/
	function (_React$PureComponent) {
	  _inherits(EventListener, _React$PureComponent);

	  function EventListener() {
	    _classCallCheck(this, EventListener);

	    return _possibleConstructorReturn(this, (EventListener.__proto__ || Object.getPrototypeOf(EventListener)).apply(this, arguments));
	  }

	  _createClass$$1(EventListener, [{
	    key: "componentDidMount",
	    value: function componentDidMount() {
	      this.applyListeners(on);
	    }
	  }, {
	    key: "componentDidUpdate",
	    value: function componentDidUpdate(prevProps) {
	      this.applyListeners(off, prevProps);
	      this.applyListeners(on);
	    }
	  }, {
	    key: "componentWillUnmount",
	    value: function componentWillUnmount() {
	      this.applyListeners(off);
	    }
	  }, {
	    key: "applyListeners",
	    value: function applyListeners(onOrOff) {
	      var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.props;
	      var target = props.target;

	      if (target) {
	        var element = target;

	        if (typeof target === 'string') {
	          element = window[target];
	        }

	        forEachListener(props, onOrOff.bind(null, element));
	      }
	    }
	  }, {
	    key: "render",
	    value: function render() {
	      return this.props.children || null;
	    }
	  }]);

	  return EventListener;
	}(React$$1.PureComponent);

	EventListener.propTypes = process.env.NODE_ENV !== "production" ? {
	  /**
	   * You can provide a single child too.
	   */
	  children: PropTypes$$1.node,

	  /**
	   * The DOM target to listen to.
	   */
	  target: PropTypes$$1.oneOfType([PropTypes$$1.object, PropTypes$$1.string]).isRequired
	} : {};

	exports.withOptions = withOptions;
	exports.default = EventListener;
	});

	var EventListener = unwrapExports(reactEventListener_cjs);
	var reactEventListener_cjs_1 = reactEventListener_cjs.withOptions;

	var interopRequireWildcard = createCommonjsModule(function (module) {
	function _interopRequireWildcard(obj) {
	  if (obj && obj.__esModule) {
	    return obj;
	  } else {
	    var newObj = {};

	    if (obj != null) {
	      for (var key in obj) {
	        if (Object.prototype.hasOwnProperty.call(obj, key)) {
	          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};

	          if (desc.get || desc.set) {
	            Object.defineProperty(newObj, key, desc);
	          } else {
	            newObj[key] = obj[key];
	          }
	        }
	      }
	    }

	    newObj.default = obj;
	    return newObj;
	  }
	}

	module.exports = _interopRequireWildcard;
	});

	unwrapExports(interopRequireWildcard);

	var interopRequireDefault = createCommonjsModule(function (module) {
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : {
	    default: obj
	  };
	}

	module.exports = _interopRequireDefault;
	});

	unwrapExports(interopRequireDefault);

	var _extends_1 = createCommonjsModule(function (module) {
	function _extends$$1() {
	  module.exports = _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;
	  };

	  return _extends$$1.apply(this, arguments);
	}

	module.exports = _extends$$1;
	});

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

	var defineProperty$1 = _defineProperty$1;

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

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

	    ownKeys.forEach(function (key) {
	      defineProperty$1(target, key, source[key]);
	    });
	  }

	  return target;
	}

	var objectSpread$1 = _objectSpread$1;

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

	var classCallCheck$1 = _classCallCheck$1;

	function _defineProperties$1(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);
	  }
	}

	function _createClass$2(Constructor, protoProps, staticProps) {
	  if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
	  if (staticProps) _defineProperties$1(Constructor, staticProps);
	  return Constructor;
	}

	var createClass$1 = _createClass$2;

	var _typeof_1$1 = createCommonjsModule(function (module) {
	function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }

	function _typeof(obj) {
	  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
	    module.exports = _typeof = function _typeof(obj) {
	      return _typeof2(obj);
	    };
	  } else {
	    module.exports = _typeof = function _typeof(obj) {
	      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
	    };
	  }

	  return _typeof(obj);
	}

	module.exports = _typeof;
	});

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

	  return self;
	}

	var assertThisInitialized$1 = _assertThisInitialized$1;

	function _possibleConstructorReturn$1(self, call) {
	  if (call && (_typeof_1$1(call) === "object" || typeof call === "function")) {
	    return call;
	  }

	  return assertThisInitialized$1(self);
	}

	var possibleConstructorReturn$1 = _possibleConstructorReturn$1;

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

	  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 inherits$1 = _inherits$1;

	function _objectWithoutProperties$1(source, excluded) {
	  if (source == null) return {};
	  var target = {};
	  var sourceKeys = Object.keys(source);
	  var key, i;

	  for (i = 0; i < sourceKeys.length; i++) {
	    key = sourceKeys[i];
	    if (excluded.indexOf(key) >= 0) continue;
	    target[key] = source[key];
	  }

	  if (Object.getOwnPropertySymbols) {
	    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

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

	var objectWithoutProperties$1 = _objectWithoutProperties$1;

	/**
	 * Copyright 2015, Yahoo! Inc.
	 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
	 */
	var REACT_STATICS = {
	    childContextTypes: true,
	    contextTypes: true,
	    defaultProps: true,
	    displayName: true,
	    getDefaultProps: true,
	    getDerivedStateFromProps: true,
	    mixins: true,
	    propTypes: true,
	    type: true
	};

	var KNOWN_STATICS = {
	    name: true,
	    length: true,
	    prototype: true,
	    caller: true,
	    callee: true,
	    arguments: true,
	    arity: true
	};

	var defineProperty$2 = Object.defineProperty;
	var getOwnPropertyNames = Object.getOwnPropertyNames;
	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
	var getPrototypeOf = Object.getPrototypeOf;
	var objectPrototype = getPrototypeOf && getPrototypeOf(Object);

	function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
	    if (typeof sourceComponent !== 'string') { // don't hoist over string (html) components

	        if (objectPrototype) {
	            var inheritedComponent = getPrototypeOf(sourceComponent);
	            if (inheritedComponent && inheritedComponent !== objectPrototype) {
	                hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
	            }
	        }

	        var keys = getOwnPropertyNames(sourceComponent);

	        if (getOwnPropertySymbols) {
	            keys = keys.concat(getOwnPropertySymbols(sourceComponent));
	        }

	        for (var i = 0; i < keys.length; ++i) {
	            var key = keys[i];
	            if (!REACT_STATICS[key] && !KNOWN_STATICS[key] && (!blacklist || !blacklist[key])) {
	                var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
	                try { // Avoid failures from read-only properties
	                    defineProperty$2(targetComponent, key, descriptor);
	                } catch (e) {}
	            }
	        }

	        return targetComponent;
	    }

	    return targetComponent;
	}

	var hoistNonReactStatics_cjs = hoistNonReactStatics;

	var getDisplayName_1 = createCommonjsModule(function (module, exports) {

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = void 0;

	var getDisplayName = function getDisplayName(Component) {
	  if (typeof Component === 'string') {
	    return Component;
	  }

	  if (!Component) {
	    return undefined;
	  }

	  return Component.displayName || Component.name || 'Component';
	};

	var _default = getDisplayName;
	exports.default = _default;
	});

	unwrapExports(getDisplayName_1);

	var interopRequireDefault$2 = createCommonjsModule(function (module) {
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : {
	    default: obj
	  };
	}

	module.exports = _interopRequireDefault;
	});

	unwrapExports(interopRequireDefault$2);

	var wrapDisplayName_1 = createCommonjsModule(function (module, exports) {



	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = void 0;

	var _getDisplayName = interopRequireDefault$2(getDisplayName_1);

	var wrapDisplayName = function wrapDisplayName(BaseComponent, hocName) {
	  return hocName + "(" + (0, _getDisplayName.default)(BaseComponent) + ")";
	};

	var _default = wrapDisplayName;
	exports.default = _default;
	});

	unwrapExports(wrapDisplayName_1);

	var ns = createCommonjsModule(function (module, exports) {

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	/**
	 * Namespaces to avoid conflicts on the context.
	 */
	var jss = exports.jss = '64a55d578f856d258dc345b094a2a2b3';
	var sheetsRegistry = exports.sheetsRegistry = 'd4bd0baacbc52bbd48bbb9eb24344ecd';
	var managers = exports.managers = 'b768b78919504fba9de2c03545c5cd3a';
	var sheetOptions = exports.sheetOptions = '6fc570d6bd61383819d0f9e7407c452d';
	});

	unwrapExports(ns);
	var ns_1 = ns.jss;
	var ns_2 = ns.sheetsRegistry;
	var ns_3 = ns.managers;
	var ns_4 = ns.sheetOptions;

	var propTypes = createCommonjsModule(function (module, exports) {

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



	exports['default'] = {
	  jss: (0, PropTypes.shape)({
	    options: (0, PropTypes.shape)({
	      createGenerateClassName: PropTypes.func.isRequired
	    }).isRequired,
	    createStyleSheet: PropTypes.func.isRequired,
	    removeStyleSheet: PropTypes.func.isRequired
	  }),
	  registry: (0, PropTypes.shape)({
	    add: PropTypes.func.isRequired,
	    toString: PropTypes.func.isRequired
	  })
	};
	});

	unwrapExports(propTypes);

	var contextTypes = createCommonjsModule(function (module, exports) {

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

	var _ns$jss$ns$sheetOptio;





	var ns$$1 = _interopRequireWildcard(ns);



	var _propTypes3 = _interopRequireDefault(propTypes);

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

	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }

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

	exports['default'] = (_ns$jss$ns$sheetOptio = {}, _defineProperty(_ns$jss$ns$sheetOptio, ns$$1.jss, _propTypes3['default'].jss), _defineProperty(_ns$jss$ns$sheetOptio, ns$$1.sheetOptions, PropTypes.object), _defineProperty(_ns$jss$ns$sheetOptio, ns$$1.sheetsRegistry, _propTypes3['default'].registry), _defineProperty(_ns$jss$ns$sheetOptio, ns$$1.managers, PropTypes.object), _ns$jss$ns$sheetOptio);
	});

	unwrapExports(contextTypes);

	var getDynamicStyles_1 = createCommonjsModule(function (module, exports) {

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

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

	exports['default'] = getDynamicStyles;
	/**
	 * Extracts a styles object with only props that contain function values.
	 */
	function getDynamicStyles(styles) {
	  var to = null;

	  for (var key in styles) {
	    var value = styles[key];
	    var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);

	    if (type === 'function') {
	      if (!to) to = {};
	      to[key] = value;
	    } else if (type === 'object' && value !== null && !Array.isArray(value)) {
	      var extracted = getDynamicStyles(value);
	      if (extracted) {
	        if (!to) to = {};
	        to[key] = extracted;
	      }
	    }
	  }

	  return to;
	}
	});

	unwrapExports(getDynamicStyles_1);

	var toCssValue_1 = createCommonjsModule(function (module, exports) {

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = toCssValue;
	var join = function join(value, by) {
	  var result = '';
	  for (var i = 0; i < value.length; i++) {
	    // Remove !important from the value, it will be readded later.
	    if (value[i] === '!important') break;
	    if (result) result += by;
	    result += value[i];
	  }
	  return result;
	};

	/**
	 * Converts array values to string.
	 *
	 * `margin: [['5px', '10px']]` > `margin: 5px 10px;`
	 * `border: ['1px', '2px']` > `border: 1px, 2px;`
	 * `margin: [['5px', '10px'], '!important']` > `margin: 5px 10px !important;`
	 * `color: ['red', !important]` > `color: red !important;`
	 */
	function toCssValue(value) {
	  var ignoreImportant = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

	  if (!Array.isArray(value)) return value;

	  var cssValue = '';

	  // Support space separated values via `[['5px', '10px']]`.
	  if (Array.isArray(value[0])) {
	    for (var i = 0; i < value.length; i++) {
	      if (value[i] === '!important') break;
	      if (cssValue) cssValue += ', ';
	      cssValue += join(value[i], ' ');
	    }
	  } else cssValue = join(value, ', ');

	  // Add !important, because it was ignored.
	  if (!ignoreImportant && value[value.length - 1] === '!important') {
	    cssValue += ' !important';
	  }

	  return cssValue;
	}
	});

	unwrapExports(toCssValue_1);

	var SheetsRegistry_1 = createCommonjsModule(function (module, exports) {

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

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

	/**
	 * Sheets registry to access them all at one place.
	 */
	var SheetsRegistry = function () {
	  function SheetsRegistry() {
	    _classCallCheck(this, SheetsRegistry);

	    this.registry = [];
	  }

	  _createClass$$1(SheetsRegistry, [{
	    key: 'add',


	    /**
	     * Register a Style Sheet.
	     */
	    value: function add(sheet) {
	      var registry = this.registry;
	      var index = sheet.options.index;


	      if (registry.indexOf(sheet) !== -1) return;

	      if (registry.length === 0 || index >= this.index) {
	        registry.push(sheet);
	        return;
	      }

	      // Find a position.
	      for (var i = 0; i < registry.length; i++) {
	        if (registry[i].options.index > index) {
	          registry.splice(i, 0, sheet);
	          return;
	        }
	      }
	    }

	    /**
	     * Reset the registry.
	     */

	  }, {
	    key: 'reset',
	    value: function reset() {
	      this.registry = [];
	    }

	    /**
	     * Remove a Style Sheet.
	     */

	  }, {
	    key: 'remove',
	    value: function remove(sheet) {
	      var index = this.registry.indexOf(sheet);
	      this.registry.splice(index, 1);
	    }

	    /**
	     * Convert all attached sheets to a CSS string.
	     */

	  }, {
	    key: 'toString',
	    value: function toString(options) {
	      return this.registry.filter(function (sheet) {
	        return sheet.attached;
	      }).map(function (sheet) {
	        return sheet.toString(options);
	      }).join('\n');
	    }
	  }, {
	    key: 'index',


	    /**
	     * Current highest index number.
	     */
	    get: function get() {
	      return this.registry.length === 0 ? 0 : this.registry[this.registry.length - 1].options.index;
	    }
	  }]);

	  return SheetsRegistry;
	}();

	exports['default'] = SheetsRegistry;
	});

	unwrapExports(SheetsRegistry_1);

	/**
	 * Copyright 2014-2015, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 */

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

	var __DEV__$1 = process.env.NODE_ENV !== 'production';

	var warning$1 = function() {};

	if (__DEV__$1) {
	  warning$1 = function(condition, format, args) {
	    var len = arguments.length;
	    args = new Array(len > 2 ? len - 2 : 0);
	    for (var key = 2; key < len; key++) {
	      args[key - 2] = arguments[key];
	    }
	    if (format === undefined) {
	      throw new Error(
	        '`warning(condition, format, ...args)` requires a warning ' +
	        'message argument'
	      );
	    }

	    if (format.length < 10 || (/^[s\W]*$/).test(format)) {
	      throw new Error(
	        'The warning format should be able to uniquely identify this ' +
	        'warning. Please, use a more descriptive format than: ' + format
	      );
	    }

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

	var warning_1$1 = warning$1;

	var SheetsManager_1 = createCommonjsModule(function (module, exports) {

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

	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; }; }();



	var _warning2 = _interopRequireDefault(warning_1$1);

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

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

	/**
	 * SheetsManager is like a WeakMap which is designed to count StyleSheet
	 * instances and attach/detach automatically.
	 */
	var SheetsManager = function () {
	  function SheetsManager() {
	    _classCallCheck(this, SheetsManager);

	    this.sheets = [];
	    this.refs = [];
	    this.keys = [];
	  }

	  _createClass$$1(SheetsManager, [{
	    key: 'get',
	    value: function get(key) {
	      var index = this.keys.indexOf(key);
	      return this.sheets[index];
	    }
	  }, {
	    key: 'add',
	    value: function add(key, sheet) {
	      var sheets = this.sheets,
	          refs = this.refs,
	          keys = this.keys;

	      var index = sheets.indexOf(sheet);

	      if (index !== -1) return index;

	      sheets.push(sheet);
	      refs.push(0);
	      keys.push(key);

	      return sheets.length - 1;
	    }
	  }, {
	    key: 'manage',
	    value: function manage(key) {
	      var index = this.keys.indexOf(key);
	      var sheet = this.sheets[index];
	      if (this.refs[index] === 0) sheet.attach();
	      this.refs[index]++;
	      if (!this.keys[index]) this.keys.splice(index, 0, key);
	      return sheet;
	    }
	  }, {
	    key: 'unmanage',
	    value: function unmanage(key) {
	      var index = this.keys.indexOf(key);
	      if (index === -1) {
	        // eslint-ignore-next-line no-console
	        (0, _warning2['default'])(false, "SheetsManager: can't find sheet to unmanage");
	        return;
	      }
	      if (this.refs[index] > 0) {
	        this.refs[index]--;
	        if (this.refs[index] === 0) this.sheets[index].detach();
	      }
	    }
	  }, {
	    key: 'size',
	    get: function get() {
	      return this.keys.length;
	    }
	  }]);

	  return SheetsManager;
	}();

	exports['default'] = SheetsManager;
	});

	unwrapExports(SheetsManager_1);

	var toCss_1 = createCommonjsModule(function (module, exports) {

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = toCss;



	var _toCssValue2 = _interopRequireDefault(toCssValue_1);

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

	/**
	 * Indent a string.
	 * http://jsperf.com/array-join-vs-for
	 */
	function indentStr(str, indent) {
	  var result = '';
	  for (var index = 0; index < indent; index++) {
	    result += '  ';
	  }return result + str;
	}

	/**
	 * Converts a Rule to CSS string.
	 */

	function toCss(selector, style) {
	  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

	  var result = '';

	  if (!style) return result;

	  var _options$indent = options.indent,
	      indent = _options$indent === undefined ? 0 : _options$indent;
	  var fallbacks = style.fallbacks;


	  indent++;

	  // Apply fallbacks first.
	  if (fallbacks) {
	    // Array syntax {fallbacks: [{prop: value}]}
	    if (Array.isArray(fallbacks)) {
	      for (var index = 0; index < fallbacks.length; index++) {
	        var fallback = fallbacks[index];
	        for (var prop in fallback) {
	          var value = fallback[prop];
	          if (value != null) {
	            result += '\n' + indentStr(prop + ': ' + (0, _toCssValue2['default'])(value) + ';', indent);
	          }
	        }
	      }
	    } else {
	      // Object syntax {fallbacks: {prop: value}}
	      for (var _prop in fallbacks) {
	        var _value = fallbacks[_prop];
	        if (_value != null) {
	          result += '\n' + indentStr(_prop + ': ' + (0, _toCssValue2['default'])(_value) + ';', indent);
	        }
	      }
	    }
	  }

	  for (var _prop2 in style) {
	    var _value2 = style[_prop2];
	    if (_value2 != null && _prop2 !== 'fallbacks') {
	      result += '\n' + indentStr(_prop2 + ': ' + (0, _toCssValue2['default'])(_value2) + ';', indent);
	    }
	  }

	  // Allow empty style in this case, because properties will be added dynamically.
	  if (!result && !options.allowEmpty) return result;

	  indent--;
	  result = indentStr(selector + ' {' + result + '\n', indent) + indentStr('}', indent);

	  return result;
	}
	});

	unwrapExports(toCss_1);

	var StyleRule_1 = createCommonjsModule(function (module, exports) {

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

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

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

	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; }; }();



	var _warning2 = _interopRequireDefault(warning_1$1);



	var _toCss2 = _interopRequireDefault(toCss_1);



	var _toCssValue2 = _interopRequireDefault(toCssValue_1);

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

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

	var StyleRule = function () {
	  function StyleRule(key, style, options) {
	    _classCallCheck(this, StyleRule);

	    this.type = 'style';
	    this.isProcessed = false;
	    var sheet = options.sheet,
	        Renderer = options.Renderer,
	        selector = options.selector;

	    this.key = key;
	    this.options = options;
	    this.style = style;
	    if (selector) this.selectorText = selector;
	    this.renderer = sheet ? sheet.renderer : new Renderer();
	  }

	  /**
	   * Set selector string.
	   * Attention: use this with caution. Most browsers didn't implement
	   * selectorText setter, so this may result in rerendering of entire Style Sheet.
	   */


	  _createClass$$1(StyleRule, [{
	    key: 'prop',


	    /**
	     * Get or set a style property.
	     */
	    value: function prop(name, value) {
	      // It's a getter.
	      if (value === undefined) return this.style[name];

	      // Don't do anything if the value has not changed.
	      if (this.style[name] === value) return this;

	      value = this.options.jss.plugins.onChangeValue(value, name, this);

	      var isEmpty = value == null || value === false;
	      var isDefined = name in this.style;

	      // Value is empty and wasn't defined before.
	      if (isEmpty && !isDefined) return this;

	      // We are going to remove this value.
	      var remove = isEmpty && isDefined;

	      if (remove) delete this.style[name];else this.style[name] = value;

	      // Renderable is defined if StyleSheet option `link` is true.
	      if (this.renderable) {
	        if (remove) this.renderer.removeProperty(this.renderable, name);else this.renderer.setProperty(this.renderable, name, value);
	        return this;
	      }

	      var sheet = this.options.sheet;

	      if (sheet && sheet.attached) {
	        (0, _warning2['default'])(false, 'Rule is not linked. Missing sheet option "link: true".');
	      }
	      return this;
	    }

	    /**
	     * Apply rule to an element inline.
	     */

	  }, {
	    key: 'applyTo',
	    value: function applyTo(renderable) {
	      var json = this.toJSON();
	      for (var prop in json) {
	        this.renderer.setProperty(renderable, prop, json[prop]);
	      }return this;
	    }

	    /**
	     * Returns JSON representation of the rule.
	     * Fallbacks are not supported.
	     * Useful for inline styles.
	     */

	  }, {
	    key: 'toJSON',
	    value: function toJSON() {
	      var json = {};
	      for (var prop in this.style) {
	        var value = this.style[prop];
	        if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) !== 'object') json[prop] = value;else if (Array.isArray(value)) json[prop] = (0, _toCssValue2['default'])(value);
	      }
	      return json;
	    }

	    /**
	     * Generates a CSS string.
	     */

	  }, {
	    key: 'toString',
	    value: function toString(options) {
	      var sheet = this.options.sheet;

	      var link = sheet ? sheet.options.link : false;
	      var opts = link ? _extends$$1({}, options, { allowEmpty: true }) : options;
	      return (0, _toCss2['default'])(this.selector, this.style, opts);
	    }
	  }, {
	    key: 'selector',
	    set: function set(selector) {
	      if (selector === this.selectorText) return;

	      this.selectorText = selector;

	      if (!this.renderable) return;

	      var hasChanged = this.renderer.setSelector(this.renderable, selector);

	      // If selector setter is not implemented, rerender the rule.
	      if (!hasChanged && this.renderable) {
	        var renderable = this.renderer.replaceRule(this.renderable, this);
	        if (renderable) this.renderable = renderable;
	      }
	    }

	    /**
	     * Get selector string.
	     */
	    ,
	    get: function get() {
	      return this.selectorText;
	    }
	  }]);

	  return StyleRule;
	}();

	exports['default'] = StyleRule;
	});

	unwrapExports(StyleRule_1);

	function symbolObservablePonyfill(root) {
		var result;
		var Symbol = root.Symbol;

		if (typeof Symbol === 'function') {
			if (Symbol.observable) {
				result = Symbol.observable;
			} else {
				result = Symbol('observable');
				Symbol.observable = result;
			}
		} else {
			result = '@@observable';
		}

		return result;
	}

	/* global window */

	var root;

	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')();
	}

	var result = symbolObservablePonyfill(root);

	var es = /*#__PURE__*/Object.freeze({
		default: result
	});

	var _symbolObservable = ( es && result ) || es;

	var isObservable = createCommonjsModule(function (module, exports) {

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



	var _symbolObservable2 = _interopRequireDefault(_symbolObservable);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { '