text: 'use strict';
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  var _extends = require('@babel/runtime/helpers/extends');
  var jss = require('jss');
  
  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
  
  var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
  
  var at = '@global';
  var atPrefix = '@global ';
  
  var GlobalContainerRule =
  /*#__PURE__*/
  function () {
    function GlobalContainerRule(key, styles, options) {
      this.type = 'global';
      this.at = at;
      this.isProcessed = false;
      this.key = key;
      this.options = options;
      this.rules = new jss.RuleList(_extends__default['default']({}, options, {
        parent: this
      }));
  
      for (var selector in styles) {
        this.rules.add(selector, styles[selector]);
      }
  
      this.rules.process();
    }
    /**
     * Get a rule.
     */
  
  
    var _proto = GlobalContainerRule.prototype;
  
    _proto.getRule = function getRule(name) {
      return this.rules.get(name);
    }
    /**
     * Create and register rule, run plugins.
     */
    ;
  
    _proto.addRule = function addRule(name, style, options) {
      var rule = this.rules.add(name, style, options);
      if (rule) this.options.jss.plugins.onProcessRule(rule);
      return rule;
    }
    /**
     * Get index of a rule.
     */
    ;
  
    _proto.indexOf = function indexOf(rule) {
      return this.rules.indexOf(rule);
    }
    /**
     * Generates a CSS string.
     */
    ;
  
    _proto.toString = function toString() {
      return this.rules.toString();
    };
  
    return GlobalContainerRule;
  }();
  
  var GlobalPrefixedRule =
  /*#__PURE__*/
  function () {
    function GlobalPrefixedRule(key, style, options) {
      this.type = 'global';
      this.at = at;
      this.isProcessed = false;
      this.key = key;
      this.options = options;
      var selector = key.substr(atPrefix.length);
      this.rule = options.jss.createRule(selector, style, _extends__default['default']({}, options, {
        parent: this
      }));
    }
  
    var _proto2 = GlobalPrefixedRule.prototype;
  
    _proto2.toString = function toString(options) {
      return this.rule ? 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, sheet) {
    var options = rule.options,
        style = rule.style;
    var rules = style ? style[at] : null;
    if (!rules) return;
  
    for (var name in rules) {
      sheet.addRule(name, rules[name], _extends__default['default']({}, options, {
        selector: addScope(name, rule.selector)
      }));
    }
  
    delete style[at];
  }
  
  function handlePrefixedGlobalRule(rule, sheet) {
    var options = rule.options,
        style = rule.style;
  
    for (var prop in style) {
      if (prop[0] !== '@' || prop.substr(0, at.length) !== at) continue;
      var selector = addScope(prop.substr(at.length), rule.selector);
      sheet.addRule(selector, style[prop], _extends__default['default']({}, options, {
        selector: selector
      }));
      delete style[prop];
    }
  }
  /**
   * Convert nested rules to separate, remove them from original styles.
   */
  
  
  function jssGlobal() {
    function onCreateRule(name, styles, options) {
      if (!name) return null;
  
      if (name === at) {
        return new GlobalContainerRule(name, styles, options);
      }
  
      if (name[0] === '@' && name.substr(0, atPrefix.length) === atPrefix) {
        return new GlobalPrefixedRule(name, styles, options);
      }
  
      var parent = options.parent;
  
      if (parent) {
        if (parent.type === 'global' || parent.options.parent && parent.options.parent.type === 'global') {
          options.scoped = false;
        }
      }
  
      if (options.scoped === false) {
        options.selector = name;
      }
  
      return null;
    }
  
    function onProcessRule(rule, sheet) {
      if (rule.type !== 'style' || !sheet) return;
      handleNestedGlobalContainerRule(rule, sheet);
      handlePrefixedGlobalRule(rule, sheet);
    }
  
    return {
      onCreateRule: onCreateRule,
      onProcessRule: onProcessRule
    };
  }
  
  exports.default = jssGlobal;
  