text: (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
    typeof define === 'function' && define.amd ? define(['exports'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jssPluginNested = {}));
  }(this, (function (exports) { 'use strict';
  
    function _extends() {
      _extends = Object.assign || function (target) {
        for (var i = 1; i < arguments.length; i++) {
          var source = arguments[i];
  
          for (var key in source) {
            if (Object.prototype.hasOwnProperty.call(source, key)) {
              target[key] = source[key];
            }
          }
        }
  
        return target;
      };
  
      return _extends.apply(this, arguments);
    }
  
    function warning(condition, message) {
      {
        if (condition) {
          return;
        }
  
        var text = "Warning: " + message;
  
        if (typeof console !== 'undefined') {
          console.warn(text);
        }
  
        try {
          throw Error(text);
        } catch (x) {}
      }
    }
  
    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, sheet) {
        return function (match, key) {
          var rule = container.getRule(key) || sheet && sheet.getRule(key);
  
          if (rule) {
            rule = rule;
            return rule.selector;
          }
  
           warning(false, "[JSS] Could not find the referenced rule \"" + key + "\" in \"" + (container.options.meta || container.toString()) + "\".") ;
          return key;
        };
      }
  
      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 += nested.indexOf('&') !== -1 ? nested.replace(parentRegExp, parent) : parent + " " + nested;
          }
        }
  
        return result;
      }
  
      function getOptions(rule, container, prevOptions) {
        // Options has been already created, now we only increase index.
        if (prevOptions) return _extends({}, prevOptions, {
          index: prevOptions.index + 1 // $FlowFixMe[prop-missing]
  
        });
        var nestingLevel = rule.options.nestingLevel;
        nestingLevel = nestingLevel === undefined ? 1 : nestingLevel + 1;
  
        var options = _extends({}, rule.options, {
          nestingLevel: nestingLevel,
          index: container.indexOf(rule) + 1 // We don't need the parent name to be set options for chlid.
  
        });
  
        delete options.name;
        return options;
      }
  
      function onProcessStyle(style, rule, sheet) {
        if (rule.type !== 'style') return style;
        var styleRule = rule;
        var container = styleRule.options.parent;
        var options;
        var replaceRef;
  
        for (var prop in style) {
          var isNested = prop.indexOf('&') !== -1;
          var isNestedConditional = prop[0] === '@';
          if (!isNested && !isNestedConditional) continue;
          options = getOptions(styleRule, container, options);
  
          if (isNested) {
            var selector = replaceParentRefs(prop, styleRule.selector); // Lazily create the ref replacer function just once for
            // all nested rules within the sheet.
  
            if (!replaceRef) replaceRef = getReplaceRef(container, sheet); // Replace all $refs.
  
            selector = selector.replace(refRegExp, replaceRef);
            container.addRule(selector, style[prop], _extends({}, options, {
              selector: selector
            }));
          } else if (isNestedConditional) {
            // Place conditional right after the parent rule to ensure right ordering.
            container.addRule(prop, {}, options) // Flow expects more options but they aren't required
            // And flow doesn't know this will always be a StyleRule which has the addRule method
            // $FlowFixMe[incompatible-use]
            // $FlowFixMe[prop-missing]
            .addRule(styleRule.key, style[prop], {
              selector: styleRule.selector
            });
          }
  
          delete style[prop];
        }
  
        return style;
      }
  
      return {
        onProcessStyle: onProcessStyle
      };
    }
  
    exports.default = jssNested;
  
    Object.defineProperty(exports, '__esModule', { value: true });
  
  })));
  //# sourceMappingURL=jss-plugin-nested.js.map
  