jss-preset-default.js

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["jssPreset"] = factory();
	else
		root["jssPreset"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

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

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _jssTemplate = __webpack_require__(1);

	var _jssTemplate2 = _interopRequireDefault(_jssTemplate);

	var _jssGlobal = __webpack_require__(4);

	var _jssGlobal2 = _interopRequireDefault(_jssGlobal);

	var _jssExtend = __webpack_require__(36);

	var _jssExtend2 = _interopRequireDefault(_jssExtend);

	var _jssNested = __webpack_require__(37);

	var _jssNested2 = _interopRequireDefault(_jssNested);

	var _jssCompose = __webpack_require__(38);

	var _jssCompose2 = _interopRequireDefault(_jssCompose);

	var _jssCamelCase = __webpack_require__(39);

	var _jssCamelCase2 = _interopRequireDefault(_jssCamelCase);

	var _jssDefaultUnit = __webpack_require__(40);

	var _jssDefaultUnit2 = _interopRequireDefault(_jssDefaultUnit);

	var _jssExpand = __webpack_require__(42);

	var _jssExpand2 = _interopRequireDefault(_jssExpand);

	var _jssVendorPrefixer = __webpack_require__(44);

	var _jssVendorPrefixer2 = _interopRequireDefault(_jssVendorPrefixer);

	var _jssPropsSort = __webpack_require__(50);

	var _jssPropsSort2 = _interopRequireDefault(_jssPropsSort);

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

	exports.default = function () {
	  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	  return {
	    plugins: [(0, _jssTemplate2.default)(options.template), (0, _jssGlobal2.default)(options.global), (0, _jssExtend2.default)(options.extend), (0, _jssNested2.default)(options.nested), (0, _jssCompose2.default)(options.compose), (0, _jssCamelCase2.default)(options.camelCase), (0, _jssDefaultUnit2.default)(options.defaultUnit), (0, _jssExpand2.default)(options.expand), (0, _jssVendorPrefixer2.default)(options.vendorPrefixer), (0, _jssPropsSort2.default)(options.propsSort)]
	  };
	};

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _parse = __webpack_require__(2);

	var _parse2 = _interopRequireDefault(_parse);

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

	var onProcessRule = function onProcessRule(rule) {
	  if (typeof rule.style === 'string') {
	    rule.style = (0, _parse2['default'])(rule.style);
	  }
	};

	exports['default'] = function () {
	  return { onProcessRule: onProcessRule };
	};

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

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

	var semiWithNl = /;\n/;

	/**
	 * Naive CSS parser.
	 * - Supports only rule body (no selectors)
	 * - Requires semicolon and new line after the value (except of last line)
	 * - No nested rules support
	 */

	exports['default'] = function (cssText) {
	  var style = {};
	  var split = cssText.split(semiWithNl);
	  for (var i = 0; i < split.length; i++) {
	    var decl = split[i];

	    if (!decl) continue;
	    var colonIndex = decl.indexOf(':');
	    if (colonIndex === -1) {
	      (0, _warning2['default'])(false, 'Malformed CSS string "%s"', decl);
	      continue;
	    }
	    var prop = decl.substr(0, colonIndex).trim();
	    var value = decl.substr(colonIndex + 1).trim();
	    style[prop] = value;
	  }
	  return style;
	};

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

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

	'use strict';

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

	var warning = function() {};

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

	module.exports = warning;


/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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

	exports['default'] = jssGlobal;

	var _jss = __webpack_require__(5);

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

	var propKey = '@global';
	var prefixKey = '@global ';

	var GlobalContainerRule = function () {
	  function GlobalContainerRule(key, styles, options) {
	    _classCallCheck(this, GlobalContainerRule);

	    this.type = 'global';

	    this.key = key;
	    this.options = options;
	    this.rules = new _jss.RuleList(_extends({}, options, {
	      parent: this
	    }));

	    for (var selector in styles) {
	      this.rules.add(selector, styles[selector], { selector: selector });
	    }

	    this.rules.process();
	  }

	  /**
	   * Get a rule.
	   */


	  _createClass(GlobalContainerRule, [{
	    key: 'getRule',
	    value: function getRule(name) {
	      return this.rules.get(name);
	    }

	    /**
	     * Create and register rule, run plugins.
	     */

	  }, {
	    key: 'addRule',
	    value: function addRule(name, style, options) {
	      var rule = this.rules.add(name, style, options);
	      this.options.jss.plugins.onProcessRule(rule);
	      return rule;
	    }

	    /**
	     * Get index of a rule.
	     */

	  }, {
	    key: 'indexOf',
	    value: function indexOf(rule) {
	      return this.rules.indexOf(rule);
	    }

	    /**
	     * Generates a CSS string.
	     */

	  }, {
	    key: 'toString',
	    value: function toString() {
	      return this.rules.toString();
	    }
	  }]);

	  return GlobalContainerRule;
	}();

	var GlobalPrefixedRule = function () {
	  function GlobalPrefixedRule(name, style, options) {
	    _classCallCheck(this, GlobalPrefixedRule);

	    this.name = name;
	    this.options = options;
	    var selector = name.substr(prefixKey.length);
	    this.rule = options.jss.createRule(selector, style, _extends({}, options, {
	      parent: this,
	      selector: selector
	    }));
	  }

	  _createClass(GlobalPrefixedRule, [{
	    key: 'toString',
	    value: function toString(options) {
	      return this.rule.toString(options);
	    }
	  }]);

	  return GlobalPrefixedRule;
	}();

	var separatorRegExp = /\s*,\s*/g;

	function addScope(selector, scope) {
	  var parts = selector.split(separatorRegExp);
	  var scoped = '';
	  for (var i = 0; i < parts.length; i++) {
	    scoped += scope + ' ' + parts[i].trim();
	    if (parts[i + 1]) scoped += ', ';
	  }
	  return scoped;
	}

	function handleNestedGlobalContainerRule(rule) {
	  var options = rule.options,
	      style = rule.style;

	  var rules = style[propKey];

	  if (!rules) return;

	  for (var name in rules) {
	    options.sheet.addRule(name, rules[name], _extends({}, options, {
	      selector: addScope(name, rule.selector)
	    }));
	  }

	  delete style[propKey];
	}

	function handlePrefixedGlobalRule(rule) {
	  var options = rule.options,
	      style = rule.style;

	  for (var prop in style) {
	    if (prop.substr(0, propKey.length) !== propKey) continue;

	    var selector = addScope(prop.substr(propKey.length), rule.selector);
	    options.sheet.addRule(selector, style[prop], _extends({}, options, {
	      selector: selector
	    }));
	    delete style[prop];
	  }
	}

	/**
	 * Convert nested rules to separate, remove them from original styles.
	 *
	 * @param {Rule} rule
	 * @api public
	 */
	function jssGlobal() {
	  function onCreateRule(name, styles, options) {
	    if (name === propKey) {
	      return new GlobalContainerRule(name, styles, options);
	    }

	    if (name[0] === '@' && name.substr(0, prefixKey.length) === prefixKey) {
	      return new GlobalPrefixedRule(name, styles, options);
	    }

	    var parent = options.parent;


	    if (parent) {
	      if (parent.type === 'global' || parent.options.parent.type === 'global') {
	        options.global = true;
	      }
	    }

	    if (options.global) options.selector = name;

	    return null;
	  }

	  function onProcessRule(rule) {
	    if (rule.type !== 'style') return;

	    handleNestedGlobalContainerRule(rule);
	    handlePrefixedGlobalRule(rule);
	  }

	  return { onCreateRule: onCreateRule, onProcessRule: onProcessRule };
	}

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.create = exports.createGenerateClassName = exports.sheets = exports.RuleList = exports.SheetsManager = exports.SheetsRegistry = exports.getDynamicStyles = undefined;

	var _getDynamicStyles = __webpack_require__(6);

	Object.defineProperty(exports, 'getDynamicStyles', {
	  enumerable: true,
	  get: function get() {
	    return _interopRequireDefault(_getDynamicStyles)['default'];
	  }
	});

	var _SheetsRegistry = __webpack_require__(7);

	Object.defineProperty(exports, 'SheetsRegistry', {
	  enumerable: true,
	  get: function get() {
	    return _interopRequireDefault(_SheetsRegistry)['default'];
	  }
	});

	var _SheetsManager = __webpack_require__(8);

	Object.defineProperty(exports, 'SheetsManager', {
	  enumerable: true,
	  get: function get() {
	    return _interopRequireDefault(_SheetsManager)['default'];
	  }
	});

	var _RuleList = __webpack_require__(9);

	Object.defineProperty(exports, 'RuleList', {
	  enumerable: true,
	  get: function get() {
	    return _interopRequireDefault(_RuleList)['default'];
	  }
	});

	var _sheets = __webpack_require__(21);

	Object.defineProperty(exports, 'sheets', {
	  enumerable: true,
	  get: function get() {
	    return _interopRequireDefault(_sheets)['default'];
	  }
	});

	var _createGenerateClassName = __webpack_require__(22);

	Object.defineProperty(exports, 'createGenerateClassName', {
	  enumerable: true,
	  get: function get() {
	    return _interopRequireDefault(_createGenerateClassName)['default'];
	  }
	});

	var _Jss = __webpack_require__(24);

	var _Jss2 = _interopRequireDefault(_Jss);

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

	/**
	 * Creates a new instance of Jss.
	 */
	var create = exports.create = function create(options) {
	  return new _Jss2['default'](options);
	};

	/**
	 * A global Jss instance.
	 */
	exports['default'] = create();

/***/ }),
/* 6 */
/***/ (function(module, exports) {

	'use strict';

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

	/**
	 * Extracts a styles object with only props that contain function values.
	 */
	exports['default'] = function (styles) {
	  // eslint-disable-next-line no-shadow
	  function extract(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 = extract(value);
	        if (extracted) {
	          if (!to) to = {};
	          to[key] = extracted;
	        }
	      }
	    }

	    return to;
	  }

	  return extract(styles);
	};

/***/ }),
/* 7 */
/***/ (function(module, exports) {

	'use strict';

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

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

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

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

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

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

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

/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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

	var _createRule = __webpack_require__(10);

	var _createRule2 = _interopRequireDefault(_createRule);

	var _updateStyle = __webpack_require__(19);

	var _updateStyle2 = _interopRequireDefault(_updateStyle);

	var _linkRule = __webpack_require__(20);

	var _linkRule2 = _interopRequireDefault(_linkRule);

	var _StyleRule = __webpack_require__(11);

	var _StyleRule2 = _interopRequireDefault(_StyleRule);

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

	/**
	 * Contains rules objects and allows adding/removing etc.
	 * Is used for e.g. by `StyleSheet` or `ConditionalRule`.
	 */
	var RuleList = function () {

	  // Original styles object.
	  function RuleList(options) {
	    _classCallCheck(this, RuleList);

	    this.map = {};
	    this.raw = {};
	    this.index = [];

	    this.options = options;
	    this.classes = options.classes;
	  }

	  /**
	   * Create and register rule.
	   *
	   * Will not render after Style Sheet was rendered the first time.
	   */


	  // Used to ensure correct rules order.

	  // Rules registry for access by .get() method.
	  // It contains the same rule registered by name and by selector.


	  _createClass(RuleList, [{
	    key: 'add',
	    value: function add(name, decl, options) {
	      var _options = this.options,
	          parent = _options.parent,
	          sheet = _options.sheet,
	          jss = _options.jss,
	          Renderer = _options.Renderer,
	          generateClassName = _options.generateClassName;


	      options = _extends({
	        classes: this.classes,
	        parent: parent,
	        sheet: sheet,
	        jss: jss,
	        Renderer: Renderer,
	        generateClassName: generateClassName
	      }, options);

	      if (!options.selector && this.classes[name]) {
	        options.selector = '.' + this.classes[name];
	      }

	      this.raw[name] = decl;

	      var rule = (0, _createRule2['default'])(name, decl, options);
	      var className = void 0;

	      if (!options.selector && rule instanceof _StyleRule2['default']) {
	        className = generateClassName(rule, sheet);
	        rule.selector = '.' + className;
	      }

	      this.register(rule, className);

	      var index = options.index === undefined ? this.index.length : options.index;
	      this.index.splice(index, 0, rule);

	      return rule;
	    }

	    /**
	     * Get a rule.
	     */

	  }, {
	    key: 'get',
	    value: function get(name) {
	      return this.map[name];
	    }

	    /**
	     * Delete a rule.
	     */

	  }, {
	    key: 'remove',
	    value: function remove(rule) {
	      this.unregister(rule);
	      this.index.splice(this.indexOf(rule), 1);
	    }

	    /**
	     * Get index of a rule.
	     */

	  }, {
	    key: 'indexOf',
	    value: function indexOf(rule) {
	      return this.index.indexOf(rule);
	    }

	    /**
	     * Run `onProcessRule()` plugins on every rule.
	     */

	  }, {
	    key: 'process',
	    value: function process() {
	      var plugins = this.options.jss.plugins;
	      // We need to clone array because if we modify the index somewhere else during a loop
	      // we end up with very hard-to-track-down side effects.

	      this.index.slice(0).forEach(plugins.onProcessRule, plugins);
	    }

	    /**
	     * Register a rule in `.map` and `.classes` maps.
	     */

	  }, {
	    key: 'register',
	    value: function register(rule, className) {
	      this.map[rule.key] = rule;
	      if (rule instanceof _StyleRule2['default']) {
	        this.map[rule.selector] = rule;
	        if (className) this.classes[rule.key] = className;
	      }
	    }

	    /**
	     * Unregister a rule.
	     */

	  }, {
	    key: 'unregister',
	    value: function unregister(rule) {
	      delete this.map[rule.key];
	      if (rule instanceof _StyleRule2['default']) {
	        delete this.map[rule.selector];
	        delete this.classes[rule.key];
	      }
	    }

	    /**
	     * Update the function values with a new data.
	     */

	  }, {
	    key: 'update',
	    value: function update(name, data) {
	      if (typeof name === 'string') {
	        (0, _updateStyle2['default'])(this.get(name), data, RuleList);
	        return;
	      }

	      for (var index = 0; index < this.index.length; index++) {
	        (0, _updateStyle2['default'])(this.index[index], name, RuleList);
	      }
	    }

	    /**
	     * Link renderable rules with CSSRuleList.
	     */

	  }, {
	    key: 'link',
	    value: function link(cssRules) {
	      var map = this.options.sheet.renderer.getUnescapedKeysMap(this.index);

	      for (var i = 0; i < cssRules.length; i++) {
	        var cssRule = cssRules[i];
	        var _key = this.options.sheet.renderer.getKey(cssRule);
	        if (map[_key]) _key = map[_key];
	        var rule = this.map[_key];
	        if (rule) (0, _linkRule2['default'])(rule, cssRule);
	      }
	    }

	    /**
	     * Convert rules to a CSS string.
	     */

	  }, {
	    key: 'toString',
	    value: function toString(options) {
	      var str = '';

	      for (var index = 0; index < this.index.length; index++) {
	        var rule = this.index[index];
	        var css = rule.toString(options);

	        // No need to render an empty rule.
	        if (!css) continue;

	        if (str) str += '\n';
	        str += css;
	      }

	      return str;
	    }
	  }]);

	  return RuleList;
	}();

	exports['default'] = RuleList;

/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

	var _StyleRule = __webpack_require__(11);

	var _StyleRule2 = _interopRequireDefault(_StyleRule);

	var _cloneStyle = __webpack_require__(18);

	var _cloneStyle2 = _interopRequireDefault(_cloneStyle);

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

	/**
	 * Create a rule instance.
	 */
	function createRule() {
	  var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'unnamed';
	  var decl = arguments[1];
	  var options = arguments[2];
	  var jss = options.jss;

	  var declCopy = (0, _cloneStyle2['default'])(decl);

	  var rule = jss.plugins.onCreateRule(name, declCopy, options);
	  if (rule) return rule;

	  // It is an at-rule and it has no instance.
	  if (name[0] === '@') {
	    (0, _warning2['default'])(false, '[JSS] Unknown at-rule %s', name);
	  }

	  return new _StyleRule2['default'](name, declCopy, options);
	}

/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

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

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

	var _toCss = __webpack_require__(12);

	var _toCss2 = _interopRequireDefault(_toCss);

	var _toCssValue = __webpack_require__(13);

	var _toCssValue2 = _interopRequireDefault(_toCssValue);

	var _isDynamicValue = __webpack_require__(14);

	var _isDynamicValue2 = _interopRequireDefault(_isDynamicValue);

	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(StyleRule, [{
	    key: 'prop',


	    /**
	     * Get or set a style property.
	     */
	    value: function prop(name, nextValue) {
	      // The result of a dynamic value is prefixed with $ and is not innumerable in
	      // order to be ignored by all plugins or during stringification.
	      var $name = (0, _isDynamicValue2['default'])(this.style[name]) ? '$' + name : name;

	      // Its a setter.
	      if (nextValue != null) {
	        // Don't do anything if the value has not changed.
	        if (this.style[$name] !== nextValue) {
	          nextValue = this.options.jss.plugins.onChangeValue(nextValue, name, this);
	          Object.defineProperty(this.style, $name, {
	            value: nextValue,
	            writable: true
	          });
	          // Renderable is defined if StyleSheet option `link` is true.
	          if (this.renderable) this.renderer.setStyle(this.renderable, name, nextValue);else {
	            var sheet = this.options.sheet;

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

	      return this.style[$name];
	    }

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

	  }, {
	    key: 'applyTo',
	    value: function applyTo(renderable) {
	      var json = this.toJSON();
	      for (var prop in json) {
	        this.renderer.setStyle(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 ((0, _isDynamicValue2['default'])(value)) json[prop] = this.style['$' + prop];else 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) {
	      return (0, _toCss2['default'])(this.selector, this.style, options);
	    }
	  }, {
	    key: 'selector',
	    set: function set(selector) {
	      if (selector === this.selectorText) return;

	      this.selectorText = selector;

	      if (this.renderable) {
	        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;

/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _toCssValue = __webpack_require__(13);

	var _toCssValue2 = _interopRequireDefault(_toCssValue);

	var _isDynamicValue = __webpack_require__(14);

	var _isDynamicValue2 = _interopRequireDefault(_isDynamicValue);

	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);
	          }
	        }
	      }
	    }
	    // Object syntax {fallbacks: {prop: value}}
	    else {
	        for (var _prop in fallbacks) {
	          var _value = fallbacks[_prop];
	          if (_value != null) {
	            result += '\n' + indentStr(_prop + ': ' + (0, _toCssValue2['default'])(_value) + ';', indent);
	          }
	        }
	      }
	  }

	  var hasDynamicValue = false;

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

	  if (!result && !hasDynamicValue) return result;

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

	  return result;
	}

/***/ }),
/* 13 */
/***/ (function(module, exports) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = toCssValue;
	var joinWithSpace = function joinWithSpace(value) {
	  return value.join(' ');
	};

	/**
	 * Converts array values to string.
	 *
	 * `margin: [['5px', '10px']]` > `margin: 5px 10px;`
	 * `border: ['1px', '2px']` > `border: 1px, 2px;`
	 */
	function toCssValue(value) {
	  if (!Array.isArray(value)) return value;

	  // Support space separated values.
	  if (Array.isArray(value[0])) {
	    return toCssValue(value.map(joinWithSpace));
	  }

	  return value.join(', ');
	}

/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _isObservable = __webpack_require__(15);

	var _isObservable2 = _interopRequireDefault(_isObservable);

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

	exports['default'] = function (value) {
	  return typeof value === 'function' || (0, _isObservable2['default'])(value);
	};

/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	var symbolObservable = __webpack_require__(16);

	module.exports = function (fn) {
		return Boolean(fn && fn[symbolObservable]);
	};


/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/* global window */
	'use strict';

	module.exports = __webpack_require__(17)(global || window || this);

	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 17 */
/***/ (function(module, exports) {

	'use strict';

	module.exports = 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;
	};


/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	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'] = cloneStyle;

	var _isObservable = __webpack_require__(15);

	var _isObservable2 = _interopRequireDefault(_isObservable);

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

	var isArray = Array.isArray;
	function cloneStyle(style) {
	  // Support empty values in case user ends up with them by accident.
	  if (style == null) return style;

	  // Support string value for SimpleRule.
	  var typeOfStyle = typeof style === 'undefined' ? 'undefined' : _typeof(style);
	  if (typeOfStyle === 'string' || typeOfStyle === 'number') return style;

	  // Support array for FontFaceRule.
	  if (isArray(style)) return style.map(cloneStyle);

	  var newStyle = {};
	  for (var name in style) {
	    var value = style[name];
	    if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && !(0, _isObservable2['default'])(value)) {
	      newStyle[name] = cloneStyle(value);
	      continue;
	    }
	    newStyle[name] = value;
	  }

	  return newStyle;
	}

/***/ }),
/* 19 */
/***/ (function(module, exports) {

	'use strict';

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

	exports['default'] = function (rule, data, RuleList) {
	  if (rule.type === 'style') {
	    for (var prop in rule.style) {
	      var value = rule.style[prop];
	      if (typeof value === 'function') {
	        rule.prop(prop, value(data));
	      }
	    }
	  } else if (rule.rules instanceof RuleList) {
	    rule.rules.update(data);
	  }
	};

/***/ }),
/* 20 */
/***/ (function(module, exports) {

	"use strict";

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = linkRule;
	/**
	 * Link rule with CSSStyleRule and nested rules with corresponding nested cssRules if both exists.
	 */
	function linkRule(rule, cssRule) {
	  rule.renderable = cssRule;
	  if (rule.rules && cssRule.cssRules) rule.rules.link(cssRule.cssRules);
	}

/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _SheetsRegistry = __webpack_require__(7);

	var _SheetsRegistry2 = _interopRequireDefault(_SheetsRegistry);

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

	/**
	 * This is a global sheets registry. Only DomRenderer will add sheets to it.
	 * On the server one should use an own SheetsRegistry instance and add the
	 * sheets to it, because you need to make sure to create a new registry for
	 * each request in order to not leak sheets across requests.
	 */
	exports['default'] = new _SheetsRegistry2['default']();

/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {'use strict';

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

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

	var _StyleSheet = __webpack_require__(23);

	var _StyleSheet2 = _interopRequireDefault(_StyleSheet);

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

	var globalRef = typeof window === 'undefined' ? global : window;
	var ns = '2f1acc6c3a606b082e5eef5e54414ffb';
	if (globalRef[ns] == null) globalRef[ns] = 0;
	// In case we have more than one JSS version.
	var jssCounter = globalRef[ns]++;

	var maxRules = 1e10;

	var env = ("development");

	/**
	 * Returns a function which generates unique class names based on counters.
	 * When new generator function is created, rule counter is reseted.
	 * We need to reset the rule counter for SSR for each request.
	 */

	exports['default'] = function () {
	  var ruleCounter = 0;

	  return function (rule, sheet) {
	    ruleCounter += 1;

	    if (ruleCounter > maxRules) {
	      (0, _warning2['default'])(false, 'You might have a memory leak. Rule counter is at %s.', ruleCounter);
	    }

	    if (env === 'production') {
	      return 'c' + jssCounter + ruleCounter;
	    }

	    var prefix = sheet ? sheet.options.classNamePrefix || '' : '';

	    return '' + prefix + rule.key + '-' + jssCounter + '-' + ruleCounter;
	  };
	};
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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

	var _linkRule = __webpack_require__(20);

	var _linkRule2 = _interopRequireDefault(_linkRule);

	var _RuleList = __webpack_require__(9);

	var _RuleList2 = _interopRequireDefault(_RuleList);

	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 StyleSheet = function () {
	  function StyleSheet(styles, options) {
	    _classCallCheck(this, StyleSheet);

	    this.attached = false;
	    this.deployed = false;
	    this.linked = false;
	    this.classes = {};
	    this.options = _extends({}, options, {
	      sheet: this,
	      parent: this,
	      classes: this.classes
	    });
	    this.renderer = new options.Renderer(this);
	    this.rules = new _RuleList2['default'](this.options);

	    for (var name in styles) {
	      this.rules.add(name, styles[name]);
	    }

	    this.rules.process();
	  }

	  /**
	   * Attach renderable to the render tree.
	   */


	  _createClass(StyleSheet, [{
	    key: 'attach',
	    value: function attach() {
	      if (this.attached) return this;
	      if (!this.deployed) this.deploy();
	      this.renderer.attach();
	      if (!this.linked && this.options.link) this.link();
	      this.attached = true;
	      return this;
	    }

	    /**
	     * Remove renderable from render tree.
	     */

	  }, {
	    key: 'detach',
	    value: function detach() {
	      if (!this.attached) return this;
	      this.renderer.detach();
	      this.attached = false;
	      return this;
	    }

	    /**
	     * Add a rule to the current stylesheet.
	     * Will insert a rule also after the stylesheet has been rendered first time.
	     */

	  }, {
	    key: 'addRule',
	    value: function addRule(name, decl, options) {
	      var queue = this.queue;

	      // Plugins can create rules.
	      // In order to preserve the right order, we need to queue all `.addRule` calls,
	      // which happen after the first `rules.add()` call.

	      if (this.attached && !queue) this.queue = [];

	      var rule = this.rules.add(name, decl, options);
	      this.options.jss.plugins.onProcessRule(rule);

	      if (this.attached) {
	        if (!this.deployed) return rule;
	        // Don't insert rule directly if there is no stringified version yet.
	        // It will be inserted all together when .attach is called.
	        if (queue) queue.push(rule);else {
	          this.insertRule(rule);
	          if (this.queue) {
	            this.queue.forEach(this.insertRule, this);
	            this.queue = undefined;
	          }
	        }
	        return rule;
	      }

	      // We can't add rules to a detached style node.
	      // We will redeploy the sheet once user will attach it.
	      this.deployed = false;

	      return rule;
	    }

	    /**
	     * Insert rule into the StyleSheet
	     */

	  }, {
	    key: 'insertRule',
	    value: function insertRule(rule) {
	      var renderable = this.renderer.insertRule(rule);
	      if (renderable && this.options.link) (0, _linkRule2['default'])(rule, renderable);
	    }

	    /**
	     * Create and add rules.
	     * Will render also after Style Sheet was rendered the first time.
	     */

	  }, {
	    key: 'addRules',
	    value: function addRules(styles, options) {
	      var added = [];
	      for (var name in styles) {
	        added.push(this.addRule(name, styles[name], options));
	      }
	      return added;
	    }

	    /**
	     * Get a rule by name.
	     */

	  }, {
	    key: 'getRule',
	    value: function getRule(name) {
	      return this.rules.get(name);
	    }

	    /**
	     * Delete a rule by name.
	     * Returns `true`: if rule has been deleted from the DOM.
	     */

	  }, {
	    key: 'deleteRule',
	    value: function deleteRule(name) {
	      var rule = this.rules.get(name);

	      if (!rule) return false;

	      this.rules.remove(rule);

	      if (this.attached && rule.renderable) {
	        return this.renderer.deleteRule(rule.renderable);
	      }

	      return true;
	    }

	    /**
	     * Get index of a rule.
	     */

	  }, {
	    key: 'indexOf',
	    value: function indexOf(rule) {
	      return this.rules.indexOf(rule);
	    }

	    /**
	     * Deploy pure CSS string to a renderable.
	     */

	  }, {
	    key: 'deploy',
	    value: function deploy() {
	      this.renderer.deploy();
	      this.deployed = true;
	      return this;
	    }

	    /**
	     * Link renderable CSS rules from sheet with their corresponding models.
	     */

	  }, {
	    key: 'link',
	    value: function link() {
	      var cssRules = this.renderer.getRules();

	      // Is undefined when VirtualRenderer is used.
	      if (cssRules) this.rules.link(cssRules);
	      this.linked = true;
	      return this;
	    }

	    /**
	     * Update the function values with a new data.
	     */

	  }, {
	    key: 'update',
	    value: function update(name, data) {
	      this.rules.update(name, data);
	      return this;
	    }

	    /**
	     * Convert rules to a CSS string.
	     */

	  }, {
	    key: 'toString',
	    value: function toString(options) {
	      return this.rules.toString(options);
	    }
	  }]);

	  return StyleSheet;
	}();

	exports['default'] = StyleSheet;

/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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

	var _isInBrowser = __webpack_require__(25);

	var _isInBrowser2 = _interopRequireDefault(_isInBrowser);

	var _StyleSheet = __webpack_require__(23);

	var _StyleSheet2 = _interopRequireDefault(_StyleSheet);

	var _PluginsRegistry = __webpack_require__(26);

	var _PluginsRegistry2 = _interopRequireDefault(_PluginsRegistry);

	var _rules = __webpack_require__(27);

	var _rules2 = _interopRequireDefault(_rules);

	var _observables = __webpack_require__(33);

	var _observables2 = _interopRequireDefault(_observables);

	var _sheets = __webpack_require__(21);

	var _sheets2 = _interopRequireDefault(_sheets);

	var _StyleRule = __webpack_require__(11);

	var _StyleRule2 = _interopRequireDefault(_StyleRule);

	var _createGenerateClassName = __webpack_require__(22);

	var _createGenerateClassName2 = _interopRequireDefault(_createGenerateClassName);

	var _createRule2 = __webpack_require__(10);

	var _createRule3 = _interopRequireDefault(_createRule2);

	var _DomRenderer = __webpack_require__(34);

	var _DomRenderer2 = _interopRequireDefault(_DomRenderer);

	var _VirtualRenderer = __webpack_require__(35);

	var _VirtualRenderer2 = _interopRequireDefault(_VirtualRenderer);

	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 defaultPlugins = _rules2['default'].concat([_observables2['default']]);

	var Jss = function () {
	  function Jss(options) {
	    _classCallCheck(this, Jss);

	    this.version = "9.0.0";
	    this.plugins = new _PluginsRegistry2['default']();
	    this.options = {
	      createGenerateClassName: _createGenerateClassName2['default'],
	      Renderer: _isInBrowser2['default'] ? _DomRenderer2['default'] : _VirtualRenderer2['default'],
	      plugins: []
	    };
	    this.generateClassName = (0, _createGenerateClassName2['default'])();

	    // eslint-disable-next-line prefer-spread
	    this.use.apply(this, defaultPlugins);
	    this.setup(options);
	  }

	  _createClass(Jss, [{
	    key: 'setup',
	    value: function setup() {
	      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

	      if (options.createGenerateClassName) {
	        this.options.createGenerateClassName = options.createGenerateClassName;
	        // $FlowFixMe
	        this.generateClassName = options.createGenerateClassName();
	      }

	      if (options.insertionPoint != null) this.options.insertionPoint = options.insertionPoint;
	      if (options.virtual || options.Renderer) {
	        this.options.Renderer = options.Renderer || (options.virtual ? _VirtualRenderer2['default'] : _DomRenderer2['default']);
	      }

	      // eslint-disable-next-line prefer-spread
	      if (options.plugins) this.use.apply(this, options.plugins);

	      return this;
	    }

	    /**
	     * Create a Style Sheet.
	     */

	  }, {
	    key: 'createStyleSheet',
	    value: function createStyleSheet(styles) {
	      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

	      var index = options.index;
	      if (typeof index !== 'number') {
	        index = _sheets2['default'].index === 0 ? 0 : _sheets2['default'].index + 1;
	      }
	      var sheet = new _StyleSheet2['default'](styles, _extends({}, options, {
	        jss: this,
	        generateClassName: options.generateClassName || this.generateClassName,
	        insertionPoint: this.options.insertionPoint,
	        Renderer: this.options.Renderer,
	        index: index
	      }));
	      this.plugins.onProcessSheet(sheet);

	      return sheet;
	    }

	    /**
	     * Detach the Style Sheet and remove it from the registry.
	     */

	  }, {
	    key: 'removeStyleSheet',
	    value: function removeStyleSheet(sheet) {
	      sheet.detach();
	      _sheets2['default'].remove(sheet);
	      return this;
	    }

	    /**
	     * Create a rule without a Style Sheet.
	     */

	  }, {
	    key: 'createRule',
	    value: function createRule(name) {
	      var style = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

	      // Enable rule without name for inline styles.
	      if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
	        options = style;
	        style = name;
	        name = undefined;
	      }

	      // Cast from RuleFactoryOptions to RuleOptions
	      // https://stackoverflow.com/questions/41328728/force-casting-in-flow
	      var ruleOptions = options;

	      ruleOptions.jss = this;
	      ruleOptions.Renderer = this.options.Renderer;
	      if (!ruleOptions.generateClassName) ruleOptions.generateClassName = this.generateClassName;
	      if (!ruleOptions.classes) ruleOptions.classes = {};
	      var rule = (0, _createRule3['default'])(name, style, ruleOptions);

	      if (!ruleOptions.selector && rule instanceof _StyleRule2['default']) {
	        rule.selector = '.' + ruleOptions.generateClassName(rule);
	      }

	      this.plugins.onProcessRule(rule);

	      return rule;
	    }

	    /**
	     * Register plugin. Passed function will be invoked with a rule instance.
	     */

	  }, {
	    key: 'use',
	    value: function use() {
	      var _this = this;

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

	      plugins.forEach(function (plugin) {
	        // Avoids applying same plugin twice, at least based on ref.
	        if (_this.options.plugins.indexOf(plugin) === -1) {
	          _this.options.plugins.push(plugin);
	          _this.plugins.use(plugin);
	        }
	      });

	      return this;
	    }
	  }]);

	  return Jss;
	}();

	exports['default'] = Jss;

/***/ }),
/* 25 */
/***/ (function(module, exports) {

	"use strict";

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

	var isBrowser = exports.isBrowser = (typeof window === "undefined" ? "undefined" : _typeof(window)) === "object" && (typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object' && document.nodeType === 9;

	exports.default = isBrowser;

/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

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

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

	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 PluginsRegistry = function () {
	  function PluginsRegistry() {
	    _classCallCheck(this, PluginsRegistry);

	    this.hooks = {
	      onCreateRule: [],
	      onProcessRule: [],
	      onProcessStyle: [],
	      onProcessSheet: [],
	      onChangeValue: []

	      /**
	       * Call `onCreateRule` hooks and return an object if returned by a hook.
	       */
	    };
	  }

	  _createClass(PluginsRegistry, [{
	    key: 'onCreateRule',
	    value: function onCreateRule(name, decl, options) {
	      for (var i = 0; i < this.hooks.onCreateRule.length; i++) {
	        var rule = this.hooks.onCreateRule[i](name, decl, options);
	        if (rule) return rule;
	      }
	      return null;
	    }

	    /**
	     * Call `onProcessRule` hooks.
	     */

	  }, {
	    key: 'onProcessRule',
	    value: function onProcessRule(rule) {
	      if (rule.isProcessed) return;
	      var sheet = rule.options.sheet;

	      for (var i = 0; i < this.hooks.onProcessRule.length; i++) {
	        this.hooks.onProcessRule[i](rule, sheet);
	      }

	      // $FlowFixMe
	      if (rule.style) this.onProcessStyle(rule.style, rule, sheet);

	      rule.isProcessed = true;
	    }

	    /**
	     * Call `onProcessStyle` hooks.
	     */

	  }, {
	    key: 'onProcessStyle',
	    value: function onProcessStyle(style, rule, sheet) {
	      var nextStyle = style;

	      for (var i = 0; i < this.hooks.onProcessStyle.length; i++) {
	        nextStyle = this.hooks.onProcessStyle[i](nextStyle, rule, sheet);
	        // $FlowFixMe
	        rule.style = nextStyle;
	      }
	    }

	    /**
	     * Call `onProcessSheet` hooks.
	     */

	  }, {
	    key: 'onProcessSheet',
	    value: function onProcessSheet(sheet) {
	      for (var i = 0; i < this.hooks.onProcessSheet.length; i++) {
	        this.hooks.onProcessSheet[i](sheet);
	      }
	    }

	    /**
	     * Call `onChangeValue` hooks.
	     */

	  }, {
	    key: 'onChangeValue',
	    value: function onChangeValue(value, prop, rule) {
	      var processedValue = value;
	      for (var i = 0; i < this.hooks.onChangeValue.length; i++) {
	        processedValue = this.hooks.onChangeValue[i](processedValue, prop, rule);
	      }
	      return processedValue;
	    }

	    /**
	     * Register a plugin.
	     * If function is passed, it is a shortcut for `{onProcessRule}`.
	     */

	  }, {
	    key: 'use',
	    value: function use(plugin) {
	      for (var name in plugin) {
	        if (this.hooks[name]) this.hooks[name].push(plugin[name]);else (0, _warning2['default'])(false, '[JSS] Unknown hook "%s".', name);
	      }
	    }
	  }]);

	  return PluginsRegistry;
	}();

	exports['default'] = PluginsRegistry;

/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _SimpleRule = __webpack_require__(28);

	var _SimpleRule2 = _interopRequireDefault(_SimpleRule);

	var _KeyframesRule = __webpack_require__(29);

	var _KeyframesRule2 = _interopRequireDefault(_KeyframesRule);

	var _ConditionalRule = __webpack_require__(30);

	var _ConditionalRule2 = _interopRequireDefault(_ConditionalRule);

	var _FontFaceRule = __webpack_require__(31);

	var _FontFaceRule2 = _interopRequireDefault(_FontFaceRule);

	var _ViewportRule = __webpack_require__(32);

	var _ViewportRule2 = _interopRequireDefault(_ViewportRule);

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

	var classes = {
	  '@charset': _SimpleRule2['default'],
	  '@import': _SimpleRule2['default'],
	  '@namespace': _SimpleRule2['default'],
	  '@keyframes': _KeyframesRule2['default'],
	  '@media': _ConditionalRule2['default'],
	  '@supports': _ConditionalRule2['default'],
	  '@font-face': _FontFaceRule2['default'],
	  '@viewport': _ViewportRule2['default'],
	  '@-ms-viewport': _ViewportRule2['default']

	  /**
	   * Generate plugins which will register all rules.
	   */
	};
	exports['default'] = Object.keys(classes).map(function (key) {
	  // https://jsperf.com/indexof-vs-substr-vs-regex-at-the-beginning-3
	  var re = new RegExp('^' + key);
	  var onCreateRule = function onCreateRule(name, decl, options) {
	    return re.test(name) ? new classes[key](name, decl, options) : null;
	  };
	  return { onCreateRule: onCreateRule };
	});

/***/ }),
/* 28 */
/***/ (function(module, exports) {

	'use strict';

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

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

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

	var SimpleRule = function () {
	  function SimpleRule(key, value, options) {
	    _classCallCheck(this, SimpleRule);

	    this.type = 'simple';
	    this.isProcessed = false;

	    this.key = key;
	    this.value = value;
	    this.options = options;
	  }

	  /**
	   * Generates a CSS string.
	   */
	  // eslint-disable-next-line no-unused-vars


	  _createClass(SimpleRule, [{
	    key: 'toString',
	    value: function toString(options) {
	      if (Array.isArray(this.value)) {
	        var str = '';
	        for (var index = 0; index < this.value.length; index++) {
	          str += this.key + ' ' + this.value[index] + ';';
	          if (this.value[index + 1]) str += '\n';
	        }
	        return str;
	      }

	      return this.key + ' ' + this.value + ';';
	    }
	  }]);

	  return SimpleRule;
	}();

	exports['default'] = SimpleRule;

/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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

	var _RuleList = __webpack_require__(9);

	var _RuleList2 = _interopRequireDefault(_RuleList);

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

	/**
	 * Rule for @keyframes
	 */
	var KeyframesRule = function () {
	  function KeyframesRule(key, frames, options) {
	    _classCallCheck(this, KeyframesRule);

	    this.type = 'keyframes';
	    this.isProcessed = false;

	    this.key = key;
	    this.options = options;
	    this.rules = new _RuleList2['default'](_extends({}, options, { parent: this }));

	    for (var name in frames) {
	      this.rules.add(name, frames[name], _extends({}, this.options, {
	        parent: this,
	        selector: name
	      }));
	    }

	    this.rules.process();
	  }

	  /**
	   * Generates a CSS string.
	   */


	  _createClass(KeyframesRule, [{
	    key: 'toString',
	    value: function toString() {
	      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { indent: 1 };

	      var inner = this.rules.toString(options);
	      if (inner) inner += '\n';
	      return this.key + ' {\n' + inner + '}';
	    }
	  }]);

	  return KeyframesRule;
	}();

	exports['default'] = KeyframesRule;

/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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

	var _RuleList = __webpack_require__(9);

	var _RuleList2 = _interopRequireDefault(_RuleList);

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

	/**
	 * Conditional rule for @media, @supports
	 */
	var ConditionalRule = function () {
	  function ConditionalRule(key, styles, options) {
	    _classCallCheck(this, ConditionalRule);

	    this.type = 'conditional';
	    this.isProcessed = false;

	    this.key = key;
	    this.options = options;
	    this.rules = new _RuleList2['default'](_extends({}, options, { parent: this }));

	    for (var name in styles) {
	      this.rules.add(name, styles[name]);
	    }

	    this.rules.process();
	  }

	  /**
	   * Get a rule.
	   */


	  _createClass(ConditionalRule, [{
	    key: 'getRule',
	    value: function getRule(name) {
	      return this.rules.get(name);
	    }

	    /**
	     * Get index of a rule.
	     */

	  }, {
	    key: 'indexOf',
	    value: function indexOf(rule) {
	      return this.rules.indexOf(rule);
	    }

	    /**
	     * Create and register rule, run plugins.
	     */

	  }, {
	    key: 'addRule',
	    value: function addRule(name, style, options) {
	      var rule = this.rules.add(name, style, options);
	      this.options.jss.plugins.onProcessRule(rule);
	      return rule;
	    }

	    /**
	     * Generates a CSS string.
	     */

	  }, {
	    key: 'toString',
	    value: function toString() {
	      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { indent: 1 };

	      var inner = this.rules.toString(options);
	      return inner ? this.key + ' {\n' + inner + '\n}' : '';
	    }
	  }]);

	  return ConditionalRule;
	}();

	exports['default'] = ConditionalRule;

/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

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

	var _toCss = __webpack_require__(12);

	var _toCss2 = _interopRequireDefault(_toCss);

	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 FontFaceRule = function () {
	  function FontFaceRule(key, style, options) {
	    _classCallCheck(this, FontFaceRule);

	    this.type = 'font-face';
	    this.isProcessed = false;

	    this.key = key;
	    this.style = style;
	    this.options = options;
	  }

	  /**
	   * Generates a CSS string.
	   */


	  _createClass(FontFaceRule, [{
	    key: 'toString',
	    value: function toString(options) {
	      if (Array.isArray(this.style)) {
	        var str = '';
	        for (var index = 0; index < this.style.length; index++) {
	          str += (0, _toCss2['default'])(this.key, this.style[index]);
	          if (this.style[index + 1]) str += '\n';
	        }
	        return str;
	      }

	      return (0, _toCss2['default'])(this.key, this.style, options);
	    }
	  }]);

	  return FontFaceRule;
	}();

	exports['default'] = FontFaceRule;

/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

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

	var _toCss = __webpack_require__(12);

	var _toCss2 = _interopRequireDefault(_toCss);

	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 ViewportRule = function () {
	  function ViewportRule(key, style, options) {
	    _classCallCheck(this, ViewportRule);

	    this.type = 'viewport';
	    this.isProcessed = false;

	    this.key = key;
	    this.style = style;
	    this.options = options;
	  }

	  /**
	   * Generates a CSS string.
	   */


	  _createClass(ViewportRule, [{
	    key: 'toString',
	    value: function toString(options) {
	      return (0, _toCss2['default'])(this.key, this.style, options);
	    }
	  }]);

	  return ViewportRule;
	}();

	exports['default'] = ViewportRule;

/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _isObservable = __webpack_require__(15);

	var _isObservable2 = _interopRequireDefault(_isObservable);

	var _StyleRule = __webpack_require__(11);

	var _StyleRule2 = _interopRequireDefault(_StyleRule);

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

	exports['default'] = {
	  onProcessRule: function onProcessRule(rule) {
	    if (!(rule instanceof _StyleRule2['default'])) return;
	    var style = rule.style;

	    var _loop = function _loop(prop) {
	      var value = style[prop];
	      if (!(0, _isObservable2['default'])(value)) return 'continue';
	      value.subscribe({
	        next: function next(nextValue) {
	          // $FlowFixMe
	          rule.prop(prop, nextValue);
	        }
	      });
	    };

	    for (var prop in style) {
	      var _ret = _loop(prop);

	      if (_ret === 'continue') continue;
	    }
	  }
	};

/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

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

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

	var _sheets = __webpack_require__(21);

	var _sheets2 = _interopRequireDefault(_sheets);

	var _StyleRule = __webpack_require__(11);

	var _StyleRule2 = _interopRequireDefault(_StyleRule);

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

	/**
	 * Get a style property.
	 */
	function getStyle(cssRule, prop) {
	  try {
	    return cssRule.style.getPropertyValue(prop);
	  } catch (err) {
	    // IE may throw if property is unknown.
	    return '';
	  }
	}

	/**
	 * Set a style property.
	 */
	function setStyle(cssRule, prop, value) {
	  try {
	    cssRule.style.setProperty(prop, value);
	  } catch (err) {
	    // IE may throw if property is unknown.
	    return false;
	  }
	  return true;
	}

	var CSSRuleTypes = {
	  STYLE_RULE: 1,
	  KEYFRAMES_RULE: 7

	  /**
	   * Get the CSS Rule key.
	   */

	};var getKey = function () {
	  var extractKey = function extractKey(cssText) {
	    var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
	    return cssText.substr(from, cssText.indexOf('{') - 1);
	  };

	  return function (cssRule) {
	    if (cssRule.type === CSSRuleTypes.STYLE_RULE) return cssRule.selectorText;
	    if (cssRule.type === CSSRuleTypes.KEYFRAMES_RULE) {
	      var name = cssRule.name;

	      if (name) return '@keyframes ' + name;

	      // There is no rule.name in the following browsers:
	      // - IE 9
	      // - Safari 7.1.8
	      // - Mobile Safari 9.0.0
	      var cssText = cssRule.cssText;

	      return '@' + extractKey(cssText, cssText.indexOf('keyframes'));
	    }

	    // Conditionals.
	    return extractKey(cssRule.cssText);
	  };
	}();

	/**
	 * Set the selector.
	 */
	function setSelector(cssRule, selectorText) {
	  cssRule.selectorText = selectorText;

	  // Return false if setter was not successful.
	  // Currently works in chrome only.
	  return cssRule.selectorText === selectorText;
	}

	/**
	 * Gets the `head` element upon the first call and caches it.
	 */
	var getHead = function () {
	  var head = void 0;
	  return function () {
	    if (!head) head = document.head || document.getElementsByTagName('head')[0];
	    return head;
	  };
	}();

	/**
	 * Gets a map of rule keys, where the property is an unescaped key and value
	 * is a potentially escaped one.
	 * It is used to identify CSS rules and the corresponding JSS rules. As an identifier
	 * for CSSStyleRule we normally use `selectorText`. Though if original selector text
	 * contains escaped code points e.g. `:not(#\\20)`, CSSOM will compile it to `:not(# )`
	 * and so CSS rule's `selectorText` won't match JSS rule selector.
	 *
	 * https://www.w3.org/International/questions/qa-escapes#cssescapes
	 */
	var getUnescapedKeysMap = function () {
	  var style = void 0;
	  var isAttached = false;

	  return function (rules) {
	    var map = {};
	    // https://github.com/facebook/flow/issues/2696
	    if (!style) style = document.createElement('style');
	    for (var i = 0; i < rules.length; i++) {
	      var rule = rules[i];
	      if (!(rule instanceof _StyleRule2['default'])) continue;
	      var selector = rule.selector;
	      // Only unescape selector over CSSOM if it contains a back slash.

	      if (selector && selector.indexOf('\\') !== -1) {
	        // Lazilly attach when needed.
	        if (!isAttached) {
	          getHead().appendChild(style);
	          isAttached = true;
	        }
	        style.textContent = selector + ' {}';
	        var _style = style,
	            sheet = _style.sheet;

	        if (sheet) {
	          var cssRules = sheet.cssRules;

	          if (cssRules) map[cssRules[0].selectorText] = rule.key;
	        }
	      }
	    }
	    if (isAttached) {
	      getHead().removeChild(style);
	      isAttached = false;
	    }
	    return map;
	  };
	}();

	/**
	 * Find attached sheet with an index higher than the passed one.
	 */
	function findHigherSheet(registry, options) {
	  for (var i = 0; i < registry.length; i++) {
	    var sheet = registry[i];
	    if (sheet.attached && sheet.options.index > options.index && sheet.options.insertionPoint === options.insertionPoint) {
	      return sheet;
	    }
	  }
	  return null;
	}

	/**
	 * Find attached sheet with the highest index.
	 */
	function findHighestSheet(registry, options) {
	  for (var i = registry.length - 1; i >= 0; i--) {
	    var sheet = registry[i];
	    if (sheet.attached && sheet.options.insertionPoint === options.insertionPoint) {
	      return sheet;
	    }
	  }
	  return null;
	}

	/**
	 * Find a comment with "jss" inside.
	 */
	function findCommentNode(text) {
	  var head = getHead();
	  for (var i = 0; i < head.childNodes.length; i++) {
	    var node = head.childNodes[i];
	    if (node.nodeType === 8 && node.nodeValue.trim() === text) {
	      return node;
	    }
	  }
	  return null;
	}

	/**
	 * Find a node before which we can insert the sheet.
	 */
	function findPrevNode(options) {
	  var registry = _sheets2['default'].registry;


	  if (registry.length > 0) {
	    // Try to insert before the next higher sheet.
	    var sheet = findHigherSheet(registry, options);
	    if (sheet) return sheet.renderer.element;

	    // Otherwise insert after the last attached.
	    sheet = findHighestSheet(registry, options);
	    if (sheet) return sheet.renderer.element.nextElementSibling;
	  }

	  // Try to find a comment placeholder if registry is empty.
	  var insertionPoint = options.insertionPoint;

	  if (insertionPoint && typeof insertionPoint === 'string') {
	    var comment = findCommentNode(insertionPoint);
	    if (comment) return comment.nextSibling;
	    // If user specifies an insertion point and it can't be found in the document -
	    // bad specificity issues may appear.
	    (0, _warning2['default'])(insertionPoint === 'jss', '[JSS] Insertion point "%s" not found.', insertionPoint);
	  }

	  return null;
	}

	/**
	 * Insert style element into the DOM.
	 */
	function insertStyle(style, options) {
	  var insertionPoint = options.insertionPoint;

	  var prevNode = findPrevNode(options);

	  if (prevNode) {
	    var parentNode = prevNode.parentNode;

	    if (parentNode) parentNode.insertBefore(style, prevNode);
	    return;
	  }

	  // Works with iframes and any node types.
	  if (insertionPoint && typeof insertionPoint.nodeType === 'number') {
	    // https://stackoverflow.com/questions/41328728/force-casting-in-flow
	    var insertionPointElement = insertionPoint;
	    var _parentNode = insertionPointElement.parentNode;

	    if (_parentNode) _parentNode.insertBefore(style, insertionPointElement.nextSibling);else (0, _warning2['default'])(false, '[JSS] Insertion point is not in the DOM.');
	    return;
	  }

	  getHead().insertBefore(style, prevNode);
	}

	var DomRenderer = function () {
	  function DomRenderer(sheet) {
	    _classCallCheck(this, DomRenderer);

	    this.getStyle = getStyle;
	    this.setStyle = setStyle;
	    this.setSelector = setSelector;
	    this.getKey = getKey;
	    this.getUnescapedKeysMap = getUnescapedKeysMap;
	    this.hasInsertedRules = false;

	    // There is no sheet when the renderer is used from a standalone StyleRule.
	    if (sheet) _sheets2['default'].add(sheet);

	    this.sheet = sheet;

	    var _ref = this.sheet ? this.sheet.options : {},
	        media = _ref.media,
	        meta = _ref.meta,
	        element = _ref.element;

	    this.element = element || document.createElement('style');
	    this.element.type = 'text/css';
	    this.element.setAttribute('data-jss', '');
	    if (media) this.element.setAttribute('media', media);
	    if (meta) this.element.setAttribute('data-meta', meta);
	  }

	  /**
	   * Insert style element into render tree.
	   */


	  // HTMLStyleElement needs fixing https://github.com/facebook/flow/issues/2696


	  _createClass(DomRenderer, [{
	    key: 'attach',
	    value: function attach() {
	      // In the case the element node is external and it is already in the DOM.
	      if (this.element.parentNode || !this.sheet) return;

	      // When rules are inserted using `insertRule` API, after `sheet.detach().attach()`
	      // browsers remove those rules.
	      // TODO figure out if its a bug and if it is known.
	      // Workaround is to redeploy the sheet before attaching as a string.
	      if (this.hasInsertedRules) {
	        this.deploy();
	        this.hasInsertedRules = false;
	      }

	      insertStyle(this.element, this.sheet.options);
	    }

	    /**
	     * Remove style element from render tree.
	     */

	  }, {
	    key: 'detach',
	    value: function detach() {
	      this.element.parentNode.removeChild(this.element);
	    }

	    /**
	     * Inject CSS string into element.
	     */

	  }, {
	    key: 'deploy',
	    value: function deploy() {
	      if (!this.sheet) return;
	      this.element.textContent = '\n' + this.sheet.toString() + '\n';
	    }

	    /**
	     * Insert a rule into element.
	     */

	  }, {
	    key: 'insertRule',
	    value: function insertRule(rule, index) {
	      var sheet = this.element.sheet;
	      var cssRules = sheet.cssRules;

	      var str = rule.toString();
	      if (!index) index = cssRules.length;

	      if (!str) return false;

	      try {
	        sheet.insertRule(str, index);
	      } catch (err) {
	        (0, _warning2['default'])(false, '[JSS] Can not insert an unsupported rule \n\r%s', rule);
	        return false;
	      }
	      this.hasInsertedRules = true;

	      return cssRules[index];
	    }

	    /**
	     * Delete a rule.
	     */

	  }, {
	    key: 'deleteRule',
	    value: function deleteRule(cssRule) {
	      var sheet = this.element.sheet;

	      var index = this.indexOf(cssRule);
	      if (index === -1) return false;
	      sheet.deleteRule(index);
	      return true;
	    }

	    /**
	     * Get index of a CSS Rule.
	     */

	  }, {
	    key: 'indexOf',
	    value: function indexOf(cssRule) {
	      var cssRules = this.element.sheet.cssRules;

	      for (var _index = 0; _index < cssRules.length; _index++) {
	        if (cssRule === cssRules[_index]) return _index;
	      }
	      return -1;
	    }

	    /**
	     * Generate a new CSS rule and replace the existing one.
	     */

	  }, {
	    key: 'replaceRule',
	    value: function replaceRule(cssRule, rule) {
	      var index = this.indexOf(cssRule);
	      var newCssRule = this.insertRule(rule, index);
	      this.element.sheet.deleteRule(index);
	      return newCssRule;
	    }

	    /**
	     * Get all rules elements.
	     */

	  }, {
	    key: 'getRules',
	    value: function getRules() {
	      return this.element.sheet.cssRules;
	    }
	  }]);

	  return DomRenderer;
	}();

	exports['default'] = DomRenderer;

/***/ }),
/* 35 */
/***/ (function(module, exports) {

	'use strict';

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

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

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

	/* eslint-disable class-methods-use-this */

	/**
	 * Rendering backend to do nothing in nodejs.
	 */
	var VirtualRenderer = function () {
	  function VirtualRenderer() {
	    _classCallCheck(this, VirtualRenderer);
	  }

	  _createClass(VirtualRenderer, [{
	    key: 'setStyle',
	    value: function setStyle() {
	      return true;
	    }
	  }, {
	    key: 'getStyle',
	    value: function getStyle() {
	      return '';
	    }
	  }, {
	    key: 'setSelector',
	    value: function setSelector() {
	      return true;
	    }
	  }, {
	    key: 'getKey',
	    value: function getKey() {
	      return '';
	    }
	  }, {
	    key: 'attach',
	    value: function attach() {}
	  }, {
	    key: 'detach',
	    value: function detach() {}
	  }, {
	    key: 'deploy',
	    value: function deploy() {}
	  }, {
	    key: 'insertRule',
	    value: function insertRule() {
	      return false;
	    }
	  }, {
	    key: 'deleteRule',
	    value: function deleteRule() {
	      return true;
	    }
	  }, {
	    key: 'replaceRule',
	    value: function replaceRule() {
	      return false;
	    }
	  }, {
	    key: 'getRules',
	    value: function getRules() {}
	  }, {
	    key: 'indexOf',
	    value: function indexOf() {
	      return -1;
	    }
	  }]);

	  return VirtualRenderer;
	}();

	exports['default'] = VirtualRenderer;

/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	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'] = jssExtend;

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

	var _isObservable = __webpack_require__(15);

	var _isObservable2 = _interopRequireDefault(_isObservable);

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

	var isObject = function isObject(obj) {
	  return obj && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && !Array.isArray(obj) && !(0, _isObservable2['default'])(obj);
	};

	/**
	 * Recursively extend styles.
	 */
	function extend(style, rule, sheet) {
	  var newStyle = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};

	  if (typeof style.extend === 'string') {
	    if (sheet) {
	      var refRule = sheet.getRule(style.extend);
	      if (refRule) {
	        if (refRule === rule) (0, _warning2['default'])(false, '[JSS] A rule tries to extend itself \r\n%s', rule);else if (refRule.options.parent) {
	          var originalStyle = refRule.options.parent.rules.raw[style.extend];
	          extend(originalStyle, rule, sheet, newStyle);
	        }
	      }
	    }
	  } else if (Array.isArray(style.extend)) {
	    for (var index = 0; index < style.extend.length; index++) {
	      extend(style.extend[index], rule, sheet, newStyle);
	    }
	  } else {
	    for (var prop in style.extend) {
	      if (prop === 'extend') {
	        extend(style.extend.extend, rule, sheet, newStyle);
	      } else if (isObject(style.extend[prop])) {
	        if (!newStyle[prop]) newStyle[prop] = {};
	        extend(style.extend[prop], rule, sheet, newStyle[prop]);
	      } else {
	        newStyle[prop] = style.extend[prop];
	      }
	    }
	  }
	  // Copy base style.
	  for (var _prop in style) {
	    if (_prop === 'extend') continue;
	    if (isObject(newStyle[_prop]) && isObject(style[_prop])) {
	      extend(style[_prop], rule, sheet, newStyle[_prop]);
	    } else if (isObject(style[_prop])) {
	      newStyle[_prop] = extend(style[_prop], rule, sheet);
	    } else {
	      newStyle[_prop] = style[_prop];
	    }
	  }

	  return newStyle;
	}

	/**
	 * Handle `extend` property.
	 *
	 * @param {Rule} rule
	 * @api public
	 */
	function jssExtend() {
	  function onProcessStyle(style, rule, sheet) {
	    return style.extend ? extend(style, rule, sheet) : style;
	  }

	  return { onProcessStyle: onProcessStyle };
	}

/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

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

	exports.default = jssNested;

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

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

	var separatorRegExp = /\s*,\s*/g;
	var parentRegExp = /&/g;
	var refRegExp = /\$([\w-]+)/g;

	/**
	 * Convert nested rules to separate, remove them from original styles.
	 *
	 * @param {Rule} rule
	 * @api public
	 */
	function jssNested() {
	  // Get a function to be used for $ref replacement.
	  function getReplaceRef(container) {
	    return function (match, key) {
	      var rule = container.getRule(key);
	      if (rule) return rule.selector;
	      (0, _warning2.default)(false, '[JSS] Could not find the referenced rule %s in %s.', key, container.options.meta || container);
	      return key;
	    };
	  }

	  var hasAnd = function hasAnd(str) {
	    return str.indexOf('&') !== -1;
	  };

	  function replaceParentRefs(nestedProp, parentProp) {
	    var parentSelectors = parentProp.split(separatorRegExp);
	    var nestedSelectors = nestedProp.split(separatorRegExp);

	    var result = '';

	    for (var i = 0; i < parentSelectors.length; i++) {
	      var parent = parentSelectors[i];

	      for (var j = 0; j < nestedSelectors.length; j++) {
	        var nested = nestedSelectors[j];
	        if (result) result += ', ';
	        // Replace all & by the parent or prefix & with the parent.
	        result += hasAnd(nested) ? nested.replace(parentRegExp, parent) : parent + ' ' + nested;
	      }
	    }

	    return result;
	  }

	  function getOptions(rule, container, options) {
	    // Options has been already created, now we only increase index.
	    if (options) return _extends({}, options, { index: options.index + 1 });

	    var nestingLevel = rule.options.nestingLevel;

	    nestingLevel = nestingLevel === undefined ? 1 : nestingLevel + 1;

	    return _extends({}, rule.options, {
	      nestingLevel: nestingLevel,
	      index: container.indexOf(rule) + 1
	    });
	  }

	  function onProcessStyle(style, rule) {
	    if (rule.type !== 'style') return style;
	    var container = rule.options.parent;
	    var options = void 0;
	    var replaceRef = void 0;
	    for (var prop in style) {
	      var isNested = hasAnd(prop);
	      var isNestedConditional = prop[0] === '@';

	      if (!isNested && !isNestedConditional) continue;

	      options = getOptions(rule, container, options);

	      if (isNested) {
	        var selector = replaceParentRefs(prop, rule.selector
	        // Lazily create the ref replacer function just once for
	        // all nested rules within the sheet.
	        );if (!replaceRef) replaceRef = getReplaceRef(container
	        // Replace all $refs.
	        );selector = selector.replace(refRegExp, replaceRef);

	        container.addRule(selector, style[prop], _extends({}, options, { selector: selector }));
	      } else if (isNestedConditional) {
	        container
	        // Place conditional right after the parent rule to ensure right ordering.
	        .addRule(prop, null, options).addRule(rule.key, style[prop], { selector: rule.selector });
	      }

	      delete style[prop];
	    }

	    return style;
	  }

	  return { onProcessStyle: onProcessStyle };
	}

/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _warning = __webpack_require__(3);

	var _warning2 = _interopRequireDefault(_warning);

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

	/**
	 * Set selector.
	 *
	 * @param {Object} original rule
	 * @param {String} className class string
	 * @return {Boolean} flag, indicating function was successfull or not
	 */
	function registerClass(rule, className) {
	  // Skip falsy values
	  if (!className) return true;

	  // Support array of class names `{composes: ['foo', 'bar']}`
	  if (Array.isArray(className)) {
	    for (var index = 0; index < className.length; index++) {
	      var isSetted = registerClass(rule, className[index]);
	      if (!isSetted) return false;
	    }

	    return true;
	  }

	  // Support space separated class names `{composes: 'foo bar'}`
	  if (className.indexOf(' ') > -1) {
	    return registerClass(rule, className.split(' '));
	  }

	  var parent = rule.options.parent;

	  // It is a ref to a local rule.

	  if (className[0] === '$') {
	    var refRule = parent.getRule(className.substr(1));

	    if (!refRule) {
	      (0, _warning2.default)(false, '[JSS] Referenced rule is not defined. \r\n%s', rule);
	      return false;
	    }

	    if (refRule === rule) {
	      (0, _warning2.default)(false, '[JSS] Cyclic composition detected. \r\n%s', rule);
	      return false;
	    }

	    parent.classes[rule.key] += ' ' + parent.classes[refRule.key];

	    return true;
	  }

	  rule.options.parent.classes[rule.key] += ' ' + className;

	  return true;
	}

	/**
	 * Convert compose property to additional class, remove property from original styles.
	 *
	 * @param {Rule} rule
	 * @api public
	 */
	function jssCompose() {
	  function onProcessStyle(style, rule) {
	    if (!style.composes) return style;
	    registerClass(rule, style.composes);
	    // Remove composes property to prevent infinite loop.
	    delete style.composes;
	    return style;
	  }
	  return { onProcessStyle: onProcessStyle };
	}

/***/ }),
/* 39 */
/***/ (function(module, exports) {

	"use strict";

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = camelCase;
	var regExp = /([A-Z])/g;

	/**
	 * Replace a string passed from String#replace.
	 * @param {String} str
	 * @return {String}
	 */
	function replace(str) {
	  return "-" + str.toLowerCase();
	}

	/**
	 * Convert camel cased property names to dash separated.
	 *
	 * @param {Object} style
	 * @return {Object}
	 */
	function convertCase(style) {
	  var converted = {};

	  for (var prop in style) {
	    converted[prop.replace(regExp, replace)] = style[prop];
	  }

	  if (style.fallbacks) {
	    if (Array.isArray(style.fallbacks)) converted.fallbacks = style.fallbacks.map(convertCase);else converted.fallbacks = convertCase(style.fallbacks);
	  }

	  return converted;
	}

	/**
	 * Allow camel cased property names by converting them back to dasherized.
	 *
	 * @param {Rule} rule
	 */
	function camelCase() {
	  function onProcessStyle(style) {
	    if (Array.isArray(style)) {
	      // Handle rules like @font-face, which can have multiple styles in an array
	      for (var index = 0; index < style.length; index++) {
	        style[index] = convertCase(style[index]);
	      }
	      return style;
	    }

	    return convertCase(style);
	  }

	  return { onProcessStyle: onProcessStyle };
	}

/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	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'] = defaultUnit;

	var _isObservable = __webpack_require__(15);

	var _isObservable2 = _interopRequireDefault(_isObservable);

	var _defaultUnits = __webpack_require__(41);

	var _defaultUnits2 = _interopRequireDefault(_defaultUnits);

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

	/**
	 * Clones the object and adds a camel cased property version.
	 */
	function addCamelCasedVersion(obj) {
	  var regExp = /(-[a-z])/g;
	  var replace = function replace(str) {
	    return str[1].toUpperCase();
	  };
	  var newObj = {};
	  for (var key in obj) {
	    newObj[key] = obj[key];
	    newObj[key.replace(regExp, replace)] = obj[key];
	  }
	  return newObj;
	}

	var units = addCamelCasedVersion(_defaultUnits2['default']);

	/**
	 * Recursive deep style passing function
	 *
	 * @param {String} current property
	 * @param {(Object|Array|Number|String)} property value
	 * @param {Object} options
	 * @return {(Object|Array|Number|String)} resulting value
	 */
	function iterate(prop, value, options) {
	  if (!value) return value;

	  var convertedValue = value;

	  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
	  if (type === 'object') {
	    if (Array.isArray(value)) type = 'array';
	    if ((0, _isObservable2['default'])(value)) type = 'observable';
	  }

	  switch (type) {
	    case 'object':
	      if (prop === 'fallbacks') {
	        for (var innerProp in value) {
	          value[innerProp] = iterate(innerProp, value[innerProp], options);
	        }
	        break;
	      }
	      for (var _innerProp in value) {
	        value[_innerProp] = iterate(prop + '-' + _innerProp, value[_innerProp], options);
	      }
	      break;
	    case 'array':
	      for (var i = 0; i < value.length; i++) {
	        value[i] = iterate(prop, value[i], options);
	      }
	      break;
	    case 'number':
	      if (value !== 0) {
	        convertedValue = value + (options[prop] || units[prop] || '');
	      }
	      break;
	    default:
	      break;
	  }

	  return convertedValue;
	}

	/**
	 * Add unit to numeric values.
	 */
	function defaultUnit() {
	  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

	  var camelCasedOptions = addCamelCasedVersion(options);

	  function onProcessStyle(style, rule) {
	    if (rule.type !== 'style') return style;

	    for (var prop in style) {
	      style[prop] = iterate(prop, style[prop], camelCasedOptions);
	    }

	    return style;
	  }

	  function onChangeValue(value, prop) {
	    return iterate(prop, value, camelCasedOptions);
	  }

	  return { onProcessStyle: onProcessStyle, onChangeValue: onChangeValue };
	}

/***/ }),
/* 41 */
/***/ (function(module, exports) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	/**
	 * Generated jss-default-unit CSS property units
	 *
	 * @type object
	 */
	exports['default'] = {
	  'animation-delay': 'ms',
	  'animation-duration': 'ms',
	  'background-position': 'px',
	  'background-position-x': 'px',
	  'background-position-y': 'px',
	  'background-size': 'px',
	  border: 'px',
	  'border-bottom': 'px',
	  'border-bottom-left-radius': 'px',
	  'border-bottom-right-radius': 'px',
	  'border-bottom-width': 'px',
	  'border-left': 'px',
	  'border-left-width': 'px',
	  'border-radius': 'px',
	  'border-right': 'px',
	  'border-right-width': 'px',
	  'border-spacing': 'px',
	  'border-top': 'px',
	  'border-top-left-radius': 'px',
	  'border-top-right-radius': 'px',
	  'border-top-width': 'px',
	  'border-width': 'px',
	  'border-after-width': 'px',
	  'border-before-width': 'px',
	  'border-end-width': 'px',
	  'border-horizontal-spacing': 'px',
	  'border-start-width': 'px',
	  'border-vertical-spacing': 'px',
	  bottom: 'px',
	  'box-shadow': 'px',
	  'column-gap': 'px',
	  'column-rule': 'px',
	  'column-rule-width': 'px',
	  'column-width': 'px',
	  'flex-basis': 'px',
	  'font-size': 'px',
	  'font-size-delta': 'px',
	  height: 'px',
	  left: 'px',
	  'letter-spacing': 'px',
	  'logical-height': 'px',
	  'logical-width': 'px',
	  margin: 'px',
	  'margin-after': 'px',
	  'margin-before': 'px',
	  'margin-bottom': 'px',
	  'margin-left': 'px',
	  'margin-right': 'px',
	  'margin-top': 'px',
	  'max-height': 'px',
	  'max-width': 'px',
	  'margin-end': 'px',
	  'margin-start': 'px',
	  'mask-position-x': 'px',
	  'mask-position-y': 'px',
	  'mask-size': 'px',
	  'max-logical-height': 'px',
	  'max-logical-width': 'px',
	  'min-height': 'px',
	  'min-width': 'px',
	  'min-logical-height': 'px',
	  'min-logical-width': 'px',
	  motion: 'px',
	  'motion-offset': 'px',
	  outline: 'px',
	  'outline-offset': 'px',
	  'outline-width': 'px',
	  padding: 'px',
	  'padding-bottom': 'px',
	  'padding-left': 'px',
	  'padding-right': 'px',
	  'padding-top': 'px',
	  'padding-after': 'px',
	  'padding-before': 'px',
	  'padding-end': 'px',
	  'padding-start': 'px',
	  'perspective-origin-x': '%',
	  'perspective-origin-y': '%',
	  perspective: 'px',
	  right: 'px',
	  'shape-margin': 'px',
	  size: 'px',
	  'text-indent': 'px',
	  'text-stroke': 'px',
	  'text-stroke-width': 'px',
	  top: 'px',
	  'transform-origin': '%',
	  'transform-origin-x': '%',
	  'transform-origin-y': '%',
	  'transform-origin-z': '%',
	  'transition-delay': 'ms',
	  'transition-duration': 'ms',
	  'vertical-align': 'px',
	  width: 'px',
	  'word-spacing': 'px',
	  // Not existing properties.
	  // Used to avoid issues with jss-expand intergration.
	  'box-shadow-x': 'px',
	  'box-shadow-y': 'px',
	  'box-shadow-blur': 'px',
	  'box-shadow-spread': 'px',
	  'font-line-height': 'px',
	  'text-shadow-x': 'px',
	  'text-shadow-y': 'px',
	  'text-shadow-blur': 'px'
	};

/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	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 = jssExpand;

	var _isObservable = __webpack_require__(15);

	var _isObservable2 = _interopRequireDefault(_isObservable);

	var _props = __webpack_require__(43);

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

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

	/**
	 * Map values by given prop.
	 *
	 * @param {Array} array of values
	 * @param {String} original property
	 * @param {String} original rule
	 * @return {String} mapped values
	 */
	function mapValuesByProp(value, prop, rule) {
	  return value.map(function (item) {
	    return objectToString(item, prop, rule);
	  });
	}

	/**
	 * Convert array to string.
	 *
	 * @param {Array} array of values
	 * @param {String} original property
	 * @param {Object} sheme, for converting arrays in strings
	 * @param {Object} original rule
	 * @return {String} converted string
	 */
	function arrayToString(value, prop, scheme, rule) {
	  if (scheme[prop] == null) return value.join(',');
	  if (value.length === 0) return '';
	  if (Array.isArray(value[0])) return arrayToString(value[0], prop, scheme);
	  if (_typeof(value[0]) === 'object' && !(0, _isObservable2.default)(value[0])) {
	    return mapValuesByProp(value, prop, rule);
	  }
	  return value.join(' ');
	}

	/**
	 * Convert object to string.
	 *
	 * @param {Object} object of values
	 * @param {String} original property
	 * @param {Object} original rule
	 * @param {Boolean} is fallback prop
	 * @return {String} converted string
	 */
	function objectToString(value, prop, rule, isFallback) {
	  if (!(_props.propObj[prop] || _props.customPropObj[prop])) return '';

	  var result = [];

	  // Check if exists any non-standart property
	  if (_props.customPropObj[prop]) {
	    value = customPropsToStyle(value, rule, _props.customPropObj[prop], isFallback);
	  }

	  // Pass throught all standart props
	  if (Object.keys(value).length) {
	    for (var baseProp in _props.propObj[prop]) {
	      if (value[baseProp]) {
	        if (Array.isArray(value[baseProp])) {
	          result.push(arrayToString(value[baseProp], baseProp, _props.propArrayInObj));
	        } else result.push(value[baseProp]);
	        continue;
	      }

	      // Add default value from props config.
	      if (_props.propObj[prop][baseProp] != null) {
	        result.push(_props.propObj[prop][baseProp]);
	      }
	    }
	  }

	  return result.join(' ');
	}

	/**
	 * Convert custom properties values to styles adding them to rule directly
	 *
	 * @param {Object} object of values
	 * @param {Object} original rule
	 * @param {String} property, that contain partial custom properties
	 * @param {Boolean} is fallback prop
	 * @return {Object} value without custom properties, that was already added to rule
	 */
	function customPropsToStyle(value, rule, customProps, isFallback) {
	  for (var prop in customProps) {
	    var propName = customProps[prop];

	    // If current property doesn't exist already in rule - add new one
	    if (typeof value[prop] !== 'undefined' && (isFallback || !rule.prop(propName))) {
	      var appendedValue = styleDetector(_defineProperty({}, propName, value[prop]), rule)[propName];

	      // Add style directly in rule
	      if (isFallback) rule.style.fallbacks[propName] = appendedValue;else rule.style[propName] = appendedValue;
	    }
	    // Delete converted property to avoid double converting
	    delete value[prop];
	  }

	  return value;
	}

	/**
	 * Detect if a style needs to be converted.
	 *
	 * @param {Object} style
	 * @param {Object} rule
	 * @param {Boolean} is fallback prop
	 * @return {Object} convertedStyle
	 */
	function styleDetector(style, rule, isFallback) {
	  for (var prop in style) {
	    var value = style[prop];

	    if (Array.isArray(value)) {
	      // Check double arrays to avoid recursion.
	      if (!Array.isArray(value[0])) {
	        if (prop === 'fallbacks') {
	          for (var index = 0; index < style.fallbacks.length; index++) {
	            style.fallbacks[index] = styleDetector(style.fallbacks[index], rule, true);
	          }
	          continue;
	        }

	        style[prop] = arrayToString(value, prop, _props.propArray);
	        // Avoid creating properties with empty values
	        if (!style[prop]) delete style[prop];
	      }
	    } else if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && !(0, _isObservable2.default)(value)) {
	      if (prop === 'fallbacks') {
	        style.fallbacks = styleDetector(style.fallbacks, rule, true);
	        continue;
	      }

	      style[prop] = objectToString(value, prop, rule, isFallback);
	      // Avoid creating properties with empty values
	      if (!style[prop]) delete style[prop];
	    }

	    // Maybe a computed value resulting in an empty string
	    else if (style[prop] === '') delete style[prop];
	  }

	  return style;
	}

	/**
	 * Adds possibility to write expanded styles.
	 *
	 * @param {Rule} rule
	 * @api public
	 */
	function jssExpand() {
	  function onProcessStyle(style, rule) {
	    if (!style || rule.type !== 'style') return style;

	    if (Array.isArray(style)) {
	      // Pass rules one by one and reformat them
	      for (var index = 0; index < style.length; index++) {
	        style[index] = styleDetector(style[index], rule);
	      }
	      return style;
	    }

	    return styleDetector(style, rule);
	  }

	  return { onProcessStyle: onProcessStyle };
	}

/***/ }),
/* 43 */
/***/ (function(module, exports) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	/**
	 * A scheme for converting properties from array to regular style.
	 * All properties listed below will be transformed to a string separated by space.
	 */
	var propArray = exports.propArray = {
	  'background-size': true,
	  'background-position': true,
	  border: true,
	  'border-bottom': true,
	  'border-left': true,
	  'border-top': true,
	  'border-right': true,
	  'border-radius': true,
	  'box-shadow': true,
	  flex: true,
	  margin: true,
	  padding: true,
	  outline: true,
	  'transform-origin': true,
	  transform: true,
	  transition: true
	};

	/**
	 * A scheme for converting arrays to regular styles inside of objects.
	 * For e.g.: "{position: [0, 0]}" => "background-position: 0 0;".
	 */
	var propArrayInObj = exports.propArrayInObj = {
	  position: true, // background-position
	  size: true // background-size
	};

	/**
	 * A scheme for parsing and building correct styles from passed objects.
	 */
	var propObj = exports.propObj = {
	  padding: {
	    top: 0,
	    right: 0,
	    bottom: 0,
	    left: 0
	  },
	  margin: {
	    top: 0,
	    right: 0,
	    bottom: 0,
	    left: 0
	  },
	  background: {
	    attachment: null,
	    color: null,
	    image: null,
	    position: null,
	    repeat: null
	  },
	  border: {
	    width: null,
	    style: null,
	    color: null
	  },
	  'border-top': {
	    width: null,
	    style: null,
	    color: null
	  },
	  'border-right': {
	    width: null,
	    style: null,
	    color: null
	  },
	  'border-bottom': {
	    width: null,
	    style: null,
	    color: null
	  },
	  'border-left': {
	    width: null,
	    style: null,
	    color: null
	  },
	  outline: {
	    width: null,
	    style: null,
	    color: null
	  },
	  'list-style': {
	    type: null,
	    position: null,
	    image: null
	  },
	  transition: {
	    property: null,
	    duration: null,
	    'timing-function': null,
	    timingFunction: null, // Needed for avoiding comilation issues with jss-camel-case
	    delay: null
	  },
	  animation: {
	    name: null,
	    duration: null,
	    'timing-function': null,
	    timingFunction: null, // Needed to avoid compilation issues with jss-camel-case
	    delay: null,
	    'iteration-count': null,
	    iterationCount: null, // Needed to avoid compilation issues with jss-camel-case
	    direction: null,
	    'fill-mode': null,
	    fillMode: null, // Needed to avoid compilation issues with jss-camel-case
	    'play-state': null,
	    playState: null // Needed to avoid compilation issues with jss-camel-case
	  },
	  'box-shadow': {
	    x: 0,
	    y: 0,
	    blur: 0,
	    spread: 0,
	    color: null,
	    inset: null
	  },
	  'text-shadow': {
	    x: 0,
	    y: 0,
	    blur: null,
	    color: null
	  }
	};

	/**
	 * A scheme for converting non-standart properties inside object.
	 * For e.g.: include 'border-radius' property inside 'border' object.
	 */
	var customPropObj = exports.customPropObj = {
	  border: {
	    radius: 'border-radius'
	  },
	  background: {
	    size: 'background-size',
	    image: 'background-image'
	  },
	  font: {
	    style: 'font-style',
	    variant: 'font-variant',
	    weight: 'font-weight',
	    stretch: 'font-stretch',
	    size: 'font-size',
	    family: 'font-family',
	    lineHeight: 'line-height', // Needed to avoid compilation issues with jss-camel-case
	    'line-height': 'line-height'
	  },
	  flex: {
	    grow: 'flex-grow',
	    basis: 'flex-basis',
	    direction: 'flex-direction',
	    wrap: 'flex-wrap',
	    flow: 'flex-flow',
	    shrink: 'flex-shrink'
	  },
	  align: {
	    self: 'align-self',
	    items: 'align-items',
	    content: 'align-content'
	  }
	};

/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _cssVendor = __webpack_require__(45);

	var vendor = _interopRequireWildcard(_cssVendor);

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

	/**
	 * Add vendor prefix to a property name when needed.
	 *
	 * @param {Rule} rule
	 * @api public
	 */
	function jssVendorPrefixer() {
	  function onProcessRule(rule) {
	    if (rule.type === 'keyframes') {
	      rule.key = '@' + vendor.prefix.css + rule.key.substr(1);
	    }
	  }

	  function onProcessStyle(style, rule) {
	    if (rule.type !== 'style') return style;

	    for (var prop in style) {
	      var value = style[prop];

	      var changeProp = false;
	      var supportedProp = vendor.supportedProperty(prop);
	      if (supportedProp && supportedProp !== prop) changeProp = true;

	      var changeValue = false;
	      var supportedValue = vendor.supportedValue(supportedProp, value);
	      if (supportedValue && supportedValue !== value) changeValue = true;

	      if (changeProp || changeValue) {
	        if (changeProp) delete style[prop];
	        style[supportedProp || prop] = supportedValue || value;
	      }
	    }

	    return style;
	  }

	  function onChangeValue(value, prop) {
	    return vendor.supportedValue(prop, value);
	  }

	  return { onProcessRule: onProcessRule, onProcessStyle: onProcessStyle, onChangeValue: onChangeValue };
	}

/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.supportedValue = exports.supportedProperty = exports.prefix = undefined;

	var _prefix = __webpack_require__(46);

	var _prefix2 = _interopRequireDefault(_prefix);

	var _supportedProperty = __webpack_require__(47);

	var _supportedProperty2 = _interopRequireDefault(_supportedProperty);

	var _supportedValue = __webpack_require__(49);

	var _supportedValue2 = _interopRequireDefault(_supportedValue);

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

	exports['default'] = {
	  prefix: _prefix2['default'],
	  supportedProperty: _supportedProperty2['default'],
	  supportedValue: _supportedValue2['default']
	}; /**
	    * CSS Vendor prefix detection and property feature testing.
	    *
	    * @copyright Oleg Slobodskoi 2015
	    * @website https://github.com/jsstyles/css-vendor
	    * @license MIT
	    */

	exports.prefix = _prefix2['default'];
	exports.supportedProperty = _supportedProperty2['default'];
	exports.supportedValue = _supportedValue2['default'];

/***/ }),
/* 46 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _isInBrowser = __webpack_require__(25);

	var _isInBrowser2 = _interopRequireDefault(_isInBrowser);

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

	var js = ''; /**
	              * Export javascript style and css style vendor prefixes.
	              * Based on "transform" support test.
	              */

	var css = '';

	// We should not do anything if required serverside.
	if (_isInBrowser2['default']) {
	  // Order matters. We need to check Webkit the last one because
	  // other vendors use to add Webkit prefixes to some properties
	  var jsCssMap = {
	    Moz: '-moz-',
	    // IE did it wrong again ...
	    ms: '-ms-',
	    O: '-o-',
	    Webkit: '-webkit-'
	  };
	  var style = document.createElement('p').style;
	  var testProp = 'Transform';

	  for (var key in jsCssMap) {
	    if (key + testProp in style) {
	      js = key;
	      css = jsCssMap[key];
	      break;
	    }
	  }
	}

	/**
	 * Vendor prefix string for the current browser.
	 *
	 * @type {{js: String, css: String}}
	 * @api public
	 */
	exports['default'] = { js: js, css: css };

/***/ }),
/* 47 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _isInBrowser = __webpack_require__(25);

	var _isInBrowser2 = _interopRequireDefault(_isInBrowser);

	var _prefix = __webpack_require__(46);

	var _prefix2 = _interopRequireDefault(_prefix);

	var _camelize = __webpack_require__(48);

	var _camelize2 = _interopRequireDefault(_camelize);

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

	var el = void 0;
	var cache = {};

	if (_isInBrowser2['default']) {
	  el = document.createElement('p');

	  /**
	   * We test every property on vendor prefix requirement.
	   * Once tested, result is cached. It gives us up to 70% perf boost.
	   * http://jsperf.com/element-style-object-access-vs-plain-object
	   *
	   * Prefill cache with known css properties to reduce amount of
	   * properties we need to feature test at runtime.
	   * http://davidwalsh.name/vendor-prefix
	   */
	  var computed = window.getComputedStyle(document.documentElement, '');
	  for (var key in computed) {
	    if (!isNaN(key)) cache[computed[key]] = computed[key];
	  }
	}

	/**
	 * Test if a property is supported, returns supported property with vendor
	 * prefix if required. Returns `false` if not supported.
	 *
	 * @param {String} prop dash separated
	 * @return {String|Boolean}
	 * @api public
	 */
	function supportedProperty(prop) {
	  // For server-side rendering.
	  if (!el) return prop;

	  // We have not tested this prop yet, lets do the test.
	  if (cache[prop] != null) return cache[prop];

	  // Camelization is required because we can't test using
	  // css syntax for e.g. in FF.
	  // Test if property is supported as it is.
	  if ((0, _camelize2['default'])(prop) in el.style) {
	    cache[prop] = prop;
	  }
	  // Test if property is supported with vendor prefix.
	  else if (_prefix2['default'].js + (0, _camelize2['default'])('-' + prop) in el.style) {
	      cache[prop] = _prefix2['default'].css + prop;
	    } else {
	      cache[prop] = false;
	    }

	  return cache[prop];
	}

/***/ }),
/* 48 */
/***/ (function(module, exports) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = camelize;
	var regExp = /[-\s]+(.)?/g;

	/**
	 * Convert dash separated strings to camel cased.
	 *
	 * @param {String} str
	 * @return {String}
	 */
	function camelize(str) {
	  return str.replace(regExp, toUpper);
	}

	function toUpper(match, c) {
	  return c ? c.toUpperCase() : '';
	}

/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

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

	var _isInBrowser = __webpack_require__(25);

	var _isInBrowser2 = _interopRequireDefault(_isInBrowser);

	var _prefix = __webpack_require__(46);

	var _prefix2 = _interopRequireDefault(_prefix);

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

	var cache = {};
	var el = void 0;

	if (_isInBrowser2['default']) el = document.createElement('p');

	/**
	 * Returns prefixed value if needed. Returns `false` if value is not supported.
	 *
	 * @param {String} property
	 * @param {String} value
	 * @return {String|Boolean}
	 * @api public
	 */
	function supportedValue(property, value) {
	  // For server-side rendering.
	  if (!el) return value;

	  // It is a string or a number as a string like '1'.
	  // We want only prefixable values here.
	  if (typeof value !== 'string' || !isNaN(parseInt(value, 10))) return value;

	  var cacheKey = property + value;

	  if (cache[cacheKey] != null) return cache[cacheKey];

	  // IE can even throw an error in some cases, for e.g. style.content = 'bar'
	  try {
	    // Test value as it is.
	    el.style[property] = value;
	  } catch (err) {
	    cache[cacheKey] = false;
	    return false;
	  }

	  // Value is supported as it is.
	  if (el.style[property] !== '') {
	    cache[cacheKey] = value;
	  } else {
	    // Test value with vendor prefix.
	    value = _prefix2['default'].css + value;

	    // Hardcode test to convert "flex" to "-ms-flexbox" for IE10.
	    if (value === '-ms-flex') value = '-ms-flexbox';

	    el.style[property] = value;

	    // Value is supported with vendor prefix.
	    if (el.style[property] !== '') cache[cacheKey] = value;
	  }

	  if (!cache[cacheKey]) cache[cacheKey] = false;

	  // Reset style value.
	  el.style[property] = '';

	  return cache[cacheKey];
	}

/***/ }),
/* 50 */
/***/ (function(module, exports) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = jssPropsSort;
	/**
	 * Sort props by length.
	 */
	function jssPropsSort() {
	  function sort(prop0, prop1) {
	    return prop0.length - prop1.length;
	  }

	  function onProcessStyle(style, rule) {
	    if (rule.type !== 'style') return style;

	    var newStyle = {};
	    var props = Object.keys(style).sort(sort);
	    for (var prop in props) {
	      newStyle[props[prop]] = style[props[prop]];
	    }
	    return newStyle;
	  }

	  return { onProcessStyle: onProcessStyle };
	}

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