text: (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["jss"] = factory();
  	else
  		root["jss"] = 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] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = 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;
  /******/
  /******/ 	// identity function for calling harmony imports with the correct context
  /******/ 	__webpack_require__.i = function(value) { return value; };
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, {
  /******/ 				configurable: false,
  /******/ 				enumerable: true,
  /******/ 				get: getter
  /******/ 			});
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 29);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (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__(7);
  
  var _createRule2 = _interopRequireDefault(_createRule);
  
  var _updateRule = __webpack_require__(26);
  
  var _updateRule2 = _interopRequireDefault(_updateRule);
  
  var _linkRule = __webpack_require__(8);
  
  var _linkRule2 = _interopRequireDefault(_linkRule);
  
  var _StyleRule = __webpack_require__(6);
  
  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);
        this.register(rule);
  
        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) {
        this.map[rule.key] = rule;
        if (rule instanceof _StyleRule2['default']) {
          this.map[rule.selector] = rule;
          this.classes[rule.key] = rule.selector.substr(1);
        }
      }
  
      /**
       * Unregister a rule.
       */
  
    }, {
      key: 'unregister',
      value: function unregister(rule) {
        delete this.map[rule.key];
        delete this.classes[rule.key];
        if (rule instanceof _StyleRule2['default']) delete this.map[rule.selector];
      }
  
      /**
       * Update the function values with a new data.
       */
  
    }, {
      key: 'update',
      value: function update(name, data) {
        if (typeof name === 'string') {
          (0, _updateRule2['default'])(this.get(name), data, RuleList);
          return;
        }
  
        for (var index = 0; index < this.index.length; index++) {
          (0, _updateRule2['default'])(this.index[index], name, RuleList);
        }
      }
  
      /**
       * Link renderable rules with CSSRuleList.
       */
  
    }, {
      key: 'link',
      value: function link(cssRules) {
        for (var i = 0; i < cssRules.length; i++) {
          var cssRule = cssRules[i];
          var rule = this.get(this.options.sheet.renderer.getSelector(cssRule));
          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;
  
  /***/ }),
  /* 1 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /**
   * Copyright 2014-2015, Facebook, Inc.
   * All rights reserved.
   *
   * This source code is licensed under the BSD-style license found in the
   * LICENSE file in the root directory of this source tree. An additional grant
   * of patent rights can be found in the PATENTS file in the same directory.
   */
  
  
  
  /**
   * Similar to invariant but only logs a warning if the condition is not met.
   * This can be used to log issues in development environments in critical
   * paths. Removing the logging code for production environments will keep the
   * same logic and follow the same code paths.
   */
  
  var 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;
  
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.create = exports.sheets = exports.RuleList = exports.SheetsManager = exports.SheetsRegistry = exports.getDynamicStyles = undefined;
  
  var _getDynamicStyles = __webpack_require__(25);
  
  Object.defineProperty(exports, 'getDynamicStyles', {
    enumerable: true,
    get: function get() {
      return _interopRequireDefault(_getDynamicStyles)['default'];
    }
  });
  
  var _SheetsRegistry = __webpack_require__(5);
  
  Object.defineProperty(exports, 'SheetsRegistry', {
    enumerable: true,
    get: function get() {
      return _interopRequireDefault(_SheetsRegistry)['default'];
    }
  });
  
  var _SheetsManager = __webpack_require__(12);
  
  Object.defineProperty(exports, 'SheetsManager', {
    enumerable: true,
    get: function get() {
      return _interopRequireDefault(_SheetsManager)['default'];
    }
  });
  
  var _RuleList = __webpack_require__(0);
  
  Object.defineProperty(exports, 'RuleList', {
    enumerable: true,
    get: function get() {
      return _interopRequireDefault(_RuleList)['default'];
    }
  });
  
  var _sheets = __webpack_require__(3);
  
  Object.defineProperty(exports, 'sheets', {
    enumerable: true,
    get: function get() {
      return _interopRequireDefault(_sheets)['default'];
    }
  });
  
  var _Jss = __webpack_require__(10);
  
  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();
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _SheetsRegistry = __webpack_require__(5);
  
  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']();
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports['default'] = toCss;
  
  var _toCssValue = __webpack_require__(9);
  
  var _toCssValue2 = _interopRequireDefault(_toCssValue);
  
  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 hasFunctionValue = false;
  
    for (var _prop2 in style) {
      var _value2 = style[_prop2];
      if (typeof _value2 === 'function') {
        _value2 = style['$' + _prop2];
        hasFunctionValue = true;
      }
      if (_value2 != null && _prop2 !== 'fallbacks') {
        result += '\n' + indentStr(_prop2 + ': ' + (0, _toCssValue2['default'])(_value2) + ';', indent);
      }
    }
  
    if (!result && !hasFunctionValue) return result;
  
    indent--;
    result = indentStr(selector + ' {' + result + '\n', indent) + indentStr('}', indent);
  
    return result;
  }
  
  /***/ }),
  /* 5 */
  /***/ (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; }; }();
  
  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;
  
  /***/ }),
  /* 6 */
  /***/ (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 _toCss = __webpack_require__(4);
  
  var _toCss2 = _interopRequireDefault(_toCss);
  
  var _toCssValue = __webpack_require__(9);
  
  var _toCssValue2 = _interopRequireDefault(_toCssValue);
  
  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 generateClassName = options.generateClassName,
          sheet = options.sheet,
          Renderer = options.Renderer,
          selector = options.selector;
  
      this.key = key;
      this.options = options;
      this.style = style;
      this.selectorText = selector || '.' + generateClassName(this, sheet);
      this.renderer = sheet ? sheet.renderer : new Renderer();
    }
  
    /**
     * Set selector string.
     * TODO rewrite this #419
     * 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) {
        var $name = typeof this.style[name] === 'function' ? '$' + name : name;
        var currValue = this.style[$name];
  
        // Its a setter.
        if (nextValue != null) {
          // Don't do anything if the value has not changed.
          if (currValue !== nextValue) {
            nextValue = this.options.jss.plugins.onChangeValue(nextValue, name, this);
            Object.defineProperty(this.style, $name, {
              value: nextValue,
              writable: true
            });
            // Defined if StyleSheet option `link` is true.
            if (this.renderable) this.renderer.setStyle(this.renderable, name, nextValue);
          }
          return this;
        }
  
        // Its a getter, read the value from the DOM if its not cached.
        if (this.renderable && currValue == null) {
          // Cache the value after we have got it from the DOM first time.
          Object.defineProperty(this.style, $name, {
            value: this.renderer.getStyle(this.renderable, name),
            writable: true
          });
        }
  
        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];
          var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
          if (type === 'function') json[prop] = this.style['$' + prop];else if (type !== '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) {
        var sheet = this.options.sheet;
  
        // After we modify a selector, ref by old selector needs to be removed.
  
        if (sheet) sheet.rules.unregister(this);
  
        this.selectorText = selector;
  
        if (!this.renderable) {
          // Register the rule with new selector.
          if (sheet) sheet.rules.register(this);
          return;
        }
  
        var changed = this.renderer.setSelector(this.renderable, selector);
  
        if (changed && sheet) {
          sheet.rules.register(this);
          return;
        }
  
        // If selector setter is not implemented, rerender the sheet.
        // We need to delete renderable from the rule, because when sheet.deploy()
        // calls rule.toString, it will get the old selector.
        delete this.renderable;
        if (sheet) {
          sheet.rules.register(this);
          sheet.deploy().link();
        }
      }
  
      /**
       * Get selector string.
       */
      ,
      get: function get() {
        if (this.renderable) {
          return this.renderer.getSelector(this.renderable);
        }
  
        return this.selectorText;
      }
    }]);
  
    return StyleRule;
  }();
  
  exports['default'] = StyleRule;
  
  /***/ }),
  /* 7 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports['default'] = createRule;
  
  var _warning = __webpack_require__(1);
  
  var _warning2 = _interopRequireDefault(_warning);
  
  var _StyleRule = __webpack_require__(6);
  
  var _StyleRule2 = _interopRequireDefault(_StyleRule);
  
  var _cloneStyle = __webpack_require__(22);
  
  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);
  }
  
  /***/ }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "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);
  }
  
  /***/ }),
  /* 9 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "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(', ');
  }
  
  /***/ }),
  /* 10 */
  /***/ (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 _StyleSheet = __webpack_require__(13);
  
  var _StyleSheet2 = _interopRequireDefault(_StyleSheet);
  
  var _PluginsRegistry = __webpack_require__(11);
  
  var _PluginsRegistry2 = _interopRequireDefault(_PluginsRegistry);
  
  var _rules = __webpack_require__(14);
  
  var _rules2 = _interopRequireDefault(_rules);
  
  var _sheets = __webpack_require__(3);
  
  var _sheets2 = _interopRequireDefault(_sheets);
  
  var _createGenerateClassName = __webpack_require__(23);
  
  var _createGenerateClassName2 = _interopRequireDefault(_createGenerateClassName);
  
  var _createRule2 = __webpack_require__(7);
  
  var _createRule3 = _interopRequireDefault(_createRule2);
  
  var _findRenderer = __webpack_require__(24);
  
  var _findRenderer2 = _interopRequireDefault(_findRenderer);
  
  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 Jss = function () {
    function Jss(options) {
      _classCallCheck(this, Jss);
  
      this.version = "8.1.0";
      this.plugins = new _PluginsRegistry2['default']();
  
      // eslint-disable-next-line prefer-spread
      this.use.apply(this, _rules2['default']);
      this.setup(options);
    }
  
    _createClass(Jss, [{
      key: 'setup',
      value: function setup() {
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  
        var createGenerateClassName = options.createGenerateClassName || _createGenerateClassName2['default'];
        this.generateClassName = createGenerateClassName();
        this.options = _extends({}, options, {
          createGenerateClassName: createGenerateClassName,
          Renderer: (0, _findRenderer2['default'])(options)
          // 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);
        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) {
          return _this.plugins.use(plugin);
        });
        return this;
      }
    }]);
  
    return Jss;
  }();
  
  exports['default'] = Jss;
  
  /***/ }),
  /* 11 */
  /***/ (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__(1);
  
  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;
  
  /***/ }),
  /* 12 */
  /***/ (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__(1);
  
  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'])('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();
        }
      }
    }]);
  
    return SheetsManager;
  }();
  
  exports['default'] = SheetsManager;
  
  /***/ }),
  /* 13 */
  /***/ (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__(8);
  
  var _linkRule2 = _interopRequireDefault(_linkRule);
  
  var _RuleList = __webpack_require__(0);
  
  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;
  
  /***/ }),
  /* 14 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _SimpleRule = __webpack_require__(20);
  
  var _SimpleRule2 = _interopRequireDefault(_SimpleRule);
  
  var _KeyframesRule = __webpack_require__(19);
  
  var _KeyframesRule2 = _interopRequireDefault(_KeyframesRule);
  
  var _ConditionalRule = __webpack_require__(17);
  
  var _ConditionalRule2 = _interopRequireDefault(_ConditionalRule);
  
  var _FontFaceRule = __webpack_require__(18);
  
  var _FontFaceRule2 = _interopRequireDefault(_FontFaceRule);
  
  var _ViewportRule = __webpack_require__(21);
  
  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 };
  });
  
  /***/ }),
  /* 15 */
  /***/ (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__(1);
  
  var _warning2 = _interopRequireDefault(_warning);
  
  var _sheets = __webpack_require__(3);
  
  var _sheets2 = _interopRequireDefault(_sheets);
  
  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(rule, prop) {
    try {
      return rule.style.getPropertyValue(prop);
    } catch (err) {
      // IE may throw if property is unknown.
      return '';
    }
  }
  
  /**
   * Set a style property.
   */
  function setStyle(rule, prop, value) {
    try {
      rule.style.setProperty(prop, value);
    } catch (err) {
      // IE may throw if property is unknown.
      return false;
    }
    return true;
  }
  
  function extractSelector(cssText) {
    var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  
    return cssText.substr(from, cssText.indexOf('{') - 1);
  }
  
  var CSSRuleTypes = {
    STYLE_RULE: 1,
    KEYFRAMES_RULE: 7
  
    /**
     * Get the selector.
     */
  };function getSelector(rule) {
    if (rule.type === CSSRuleTypes.STYLE_RULE) return rule.selectorText;
    if (rule.type === CSSRuleTypes.KEYFRAMES_RULE) {
      var name = rule.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 = rule.cssText;
  
      return '@' + extractSelector(cssText, cssText.indexOf('keyframes'));
    }
  
    return extractSelector(rule.cssText);
  }
  
  /**
   * Set the selector.
   */
  function setSelector(rule, selectorText) {
    rule.selectorText = selectorText;
  
    // Return false if setter was not successful.
    // Currently works in chrome only.
    return rule.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;
    };
  }();
  
  /**
   * 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.getSelector = getSelector;
      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) {
        var sheet = this.element.sheet;
        var cssRules = sheet.cssRules;
  
        var index = cssRules.length;
        var str = rule.toString();
  
        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(rule) {
        var sheet = this.element.sheet;
        var cssRules = sheet.cssRules;
  
        for (var _index = 0; _index < cssRules.length; _index++) {
          if (rule === cssRules[_index]) {
            sheet.deleteRule(_index);
            return true;
          }
        }
        return false;
      }
  
      /**
       * Get all rules elements.
       */
  
    }, {
      key: 'getRules',
      value: function getRules() {
        return this.element.sheet.cssRules;
      }
    }]);
  
    return DomRenderer;
  }();
  
  exports['default'] = DomRenderer;
  
  /***/ }),
  /* 16 */
  /***/ (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; }; }();
  
  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: 'getSelector',
      value: function getSelector() {
        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: 'getRules',
      value: function getRules() {}
    }]);
  
    return VirtualRenderer;
  }();
  
  exports['default'] = VirtualRenderer;
  
  /***/ }),
  /* 17 */
  /***/ (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__(0);
  
  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;
  
  /***/ }),
  /* 18 */
  /***/ (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__(4);
  
  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;
  
  /***/ }),
  /* 19 */
  /***/ (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__(0);
  
  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;
  
  /***/ }),
  /* 20 */
  /***/ (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; }; }();
  
  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;
  
  /***/ }),
  /* 21 */
  /***/ (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__(4);
  
  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;
  
  /***/ }),
  /* 22 */
  /***/ (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 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') {
        newStyle[name] = cloneStyle(value);
        continue;
      }
      newStyle[name] = value;
    }
  
    return newStyle;
  }
  
  /***/ }),
  /* 23 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(global) {
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  
  var globalRef = typeof window === 'undefined' ? global : window;
  
  var namespace = '__JSS_VERSION_COUNTER__';
  if (globalRef[namespace] == null) globalRef[namespace] = 0;
  // In case we have more than one JSS version.
  var jssCounter = globalRef[namespace]++;
  
  /**
   * 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) {
      return rule.key + '-' + jssCounter + '-' + ruleCounter++;
    };
  };
  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(28)))
  
  /***/ }),
  /* 24 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports['default'] = findRenderer;
  
  var _isInBrowser = __webpack_require__(27);
  
  var _isInBrowser2 = _interopRequireDefault(_isInBrowser);
  
  var _DomRenderer = __webpack_require__(15);
  
  var _DomRenderer2 = _interopRequireDefault(_DomRenderer);
  
  var _VirtualRenderer = __webpack_require__(16);
  
  var _VirtualRenderer2 = _interopRequireDefault(_VirtualRenderer);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  /**
   * Find proper renderer.
   * Option `virtual` is used to force use of VirtualRenderer even if DOM is
   * detected, used for testing only.
   */
  function findRenderer() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  
    if (options.Renderer) return options.Renderer;
    var useVirtual = options.virtual || !_isInBrowser2['default'];
    return useVirtual ? _VirtualRenderer2['default'] : _DomRenderer2['default'];
  }
  
  /***/ }),
  /* 25 */
  /***/ (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; };
  
  /**
   * 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);
  };
  
  /***/ }),
  /* 26 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "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);
    }
  };
  
  /***/ }),
  /* 27 */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isBrowser", function() { return isBrowser; });
  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 = (typeof window === "undefined" ? "undefined" : _typeof(window)) === "object" && (typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object' && document.nodeType === 9;
  
  /* harmony default export */ __webpack_exports__["default"] = (isBrowser);
  
  
  /***/ }),
  /* 28 */
  /***/ (function(module, exports) {
  
  var g;
  
  // This works in non-strict mode
  g = (function() {
  	return this;
  })();
  
  try {
  	// This works if eval is allowed (see CSP)
  	g = g || Function("return this")() || (1,eval)("this");
  } catch(e) {
  	// This works if the window reference is available
  	if(typeof window === "object")
  		g = window;
  }
  
  // g can still be undefined, but nothing to do about it...
  // We return undefined, instead of nothing here, so it's
  // easier to handle this case. if(!global) { ...}
  
  module.exports = g;
  
  
  /***/ }),
  /* 29 */
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__(2);
  module.exports = __webpack_require__(2);
  
  
  /***/ })
  /******/ ]);
  });
  //# sourceMappingURL=jss.js.map