text: "use strict";
  
  var parser = require('postcss-value-parser');
  
  var list = require('postcss').list;
  
  var uniq = require('../utils').uniq;
  
  var escapeRegexp = require('../utils').escapeRegexp;
  
  var splitSelector = require('../utils').splitSelector;
  
  function convert(value) {
    if (value && value.length === 2 && value[0] === 'span' && parseInt(value[1], 10) > 0) {
      return [false, parseInt(value[1], 10)];
    }
  
    if (value && value.length === 1 && parseInt(value[0], 10) > 0) {
      return [parseInt(value[0], 10), false];
    }
  
    return [false, false];
  }
  
  function translate(values, startIndex, endIndex) {
    var startValue = values[startIndex];
    var endValue = values[endIndex];
  
    if (!startValue) {
      return [false, false];
    }
  
    var _convert = convert(startValue),
        start = _convert[0],
        spanStart = _convert[1];
  
    var _convert2 = convert(endValue),
        end = _convert2[0],
        spanEnd = _convert2[1];
  
    if (start && !endValue) {
      return [start, false];
    }
  
    if (spanStart && end) {
      return [end - spanStart, spanStart];
    }
  
    if (start && spanEnd) {
      return [start, spanEnd];
    }
  
    if (start && end) {
      return [start, end - start];
    }
  
    return [false, false];
  }
  
  function parse(decl) {
    var node = parser(decl.value);
    var values = [];
    var current = 0;
    values[current] = [];
  
    for (var _iterator = node.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
      var _ref;
  
      if (_isArray) {
        if (_i >= _iterator.length) break;
        _ref = _iterator[_i++];
      } else {
        _i = _iterator.next();
        if (_i.done) break;
        _ref = _i.value;
      }
  
      var i = _ref;
  
      if (i.type === 'div') {
        current += 1;
        values[current] = [];
      } else if (i.type === 'word') {
        values[current].push(i.value);
      }
    }
  
    return values;
  }
  
  function insertDecl(decl, prop, value) {
    if (value && !decl.parent.some(function (i) {
      return i.prop === "-ms-" + prop;
    })) {
      decl.cloneBefore({
        prop: "-ms-" + prop,
        value: value.toString()
      });
    }
  } // Track transforms
  
  
  function prefixTrackProp(_ref2) {
    var prop = _ref2.prop,
        prefix = _ref2.prefix;
    return prefix + prop.replace('template-', '');
  }
  
  function transformRepeat(_ref3, _ref4) {
    var nodes = _ref3.nodes;
    var gap = _ref4.gap;
  
    var _nodes$reduce = nodes.reduce(function (result, node) {
      if (node.type === 'div' && node.value === ',') {
        result.key = 'size';
      } else {
        result[result.key].push(parser.stringify(node));
      }
  
      return result;
    }, {
      key: 'count',
      size: [],
      count: []
    }),
        count = _nodes$reduce.count,
        size = _nodes$reduce.size; // insert gap values
  
  
    if (gap) {
      var _ret = function () {
        size = size.filter(function (i) {
          return i.trim();
        });
        var val = [];
  
        var _loop = function _loop(i) {
          size.forEach(function (item, index) {
            if (index > 0 || i > 1) {
              val.push(gap);
            }
  
            val.push(item);
          });
        };
  
        for (var i = 1; i <= count; i++) {
          _loop(i);
        }
  
        return {
          v: val.join(' ')
        };
      }();
  
      if (typeof _ret === "object") return _ret.v;
    }
  
    return "(" + size.join('') + ")[" + count.join('') + "]";
  }
  
  function prefixTrackValue(_ref5) {
    var value = _ref5.value,
        gap = _ref5.gap;
    var result = parser(value).nodes.reduce(function (nodes, node) {
      if (node.type === 'function' && node.value === 'repeat') {
        return nodes.concat({
          type: 'word',
          value: transformRepeat(node, {
            gap: gap
          })
        });
      }
  
      if (gap && node.type === 'space') {
        return nodes.concat({
          type: 'space',
          value: ' '
        }, {
          type: 'word',
          value: gap
        }, node);
      }
  
      return nodes.concat(node);
    }, []);
    return parser.stringify(result);
  } // Parse grid-template-areas
  
  
  var DOTS = /^\.+$/;
  
  function track(start, end) {
    return {
      start: start,
      end: end,
      span: end - start
    };
  }
  
  function getColumns(line) {
    return line.trim().split(/\s+/g);
  }
  
  function parseGridAreas(_ref6) {
    var rows = _ref6.rows,
        gap = _ref6.gap;
    return rows.reduce(function (areas, line, rowIndex) {
      if (gap.row) rowIndex *= 2;
      if (line.trim() === '') return areas;
      getColumns(line).forEach(function (area, columnIndex) {
        if (DOTS.test(area)) return;
        if (gap.column) columnIndex *= 2;
  
        if (typeof areas[area] === 'undefined') {
          areas[area] = {
            column: track(columnIndex + 1, columnIndex + 2),
            row: track(rowIndex + 1, rowIndex + 2)
          };
        } else {
          var _areas$area = areas[area],
              column = _areas$area.column,
              row = _areas$area.row;
          column.start = Math.min(column.start, columnIndex + 1);
          column.end = Math.max(column.end, columnIndex + 2);
          column.span = column.end - column.start;
          row.start = Math.min(row.start, rowIndex + 1);
          row.end = Math.max(row.end, rowIndex + 2);
          row.span = row.end - row.start;
        }
      });
      return areas;
    }, {});
  } // Parse grid-template
  
  
  function testTrack(node) {
    return node.type === 'word' && /^\[.+\]$/.test(node.value);
  }
  
  function verifyRowSize(result) {
    if (result.areas.length > result.rows.length) {
      result.rows.push('auto');
    }
  
    return result;
  }
  
  function parseTemplate(_ref7) {
    var decl = _ref7.decl,
        gap = _ref7.gap;
    var gridTemplate = parser(decl.value).nodes.reduce(function (result, node) {
      var type = node.type,
          value = node.value;
      if (testTrack(node) || type === 'space') return result; // area
  
      if (type === 'string') {
        result = verifyRowSize(result);
        result.areas.push(value);
      } // values and function
  
  
      if (type === 'word' || type === 'function') {
        result[result.key].push(parser.stringify(node));
      } // divider(/)
  
  
      if (type === 'div' && value === '/') {
        result.key = 'columns';
        result = verifyRowSize(result);
      }
  
      return result;
    }, {
      key: 'rows',
      columns: [],
      rows: [],
      areas: []
    });
    return {
      areas: parseGridAreas({
        rows: gridTemplate.areas,
        gap: gap
      }),
      columns: prefixTrackValue({
        value: gridTemplate.columns.join(' '),
        gap: gap.column
      }),
      rows: prefixTrackValue({
        value: gridTemplate.rows.join(' '),
        gap: gap.row
      })
    };
  } // Insert parsed grid areas
  
  /**
   * Get an array of -ms- prefixed props and values
   * @param  {Object} [area] area object with column and row data
   * @param  {Boolean} [addRowSpan] should we add grid-column-row value?
   * @param  {Boolean} [addColumnSpan] should we add grid-column-span value?
   * @return {Array<Object>}
   */
  
  
  function getMSDecls(area, addRowSpan, addColumnSpan) {
    if (addRowSpan === void 0) {
      addRowSpan = false;
    }
  
    if (addColumnSpan === void 0) {
      addColumnSpan = false;
    }
  
    return [].concat({
      prop: '-ms-grid-row',
      value: String(area.row.start)
    }, area.row.span > 1 || addRowSpan ? {
      prop: '-ms-grid-row-span',
      value: String(area.row.span)
    } : [], {
      prop: '-ms-grid-column',
      value: String(area.column.start)
    }, area.column.span > 1 || addColumnSpan ? {
      prop: '-ms-grid-column-span',
      value: String(area.column.span)
    } : []);
  }
  
  function getParentMedia(parent) {
    if (parent.type === 'atrule' && parent.name === 'media') {
      return parent;
    }
  
    if (!parent.parent) {
      return false;
    }
  
    return getParentMedia(parent.parent);
  }
  /**
   * change selectors for rules with duplicate grid-areas.
   * @param  {Array<Rule>} rules
   * @param  {Array<String>} templateSelectors
   * @return {Array<Rule>} rules with changed selectors
   */
  
  
  function changeDuplicateAreaSelectors(ruleSelectors, templateSelectors) {
    ruleSelectors = ruleSelectors.map(function (selector) {
      var selectorBySpace = list.space(selector);
      var selectorByComma = list.comma(selector);
  
      if (selectorBySpace.length > selectorByComma.length) {
        selector = selectorBySpace.slice(-1).join('');
      }
  
      return selector;
    });
    return ruleSelectors.map(function (ruleSelector) {
      var newSelector = templateSelectors.map(function (tplSelector, index) {
        var space = index === 0 ? '' : ' ';
        return "" + space + tplSelector + " > " + ruleSelector;
      });
      return newSelector;
    });
  }
  /**
   * check if selector of rules are equal
   * @param  {Rule} ruleA
   * @param  {Rule} ruleB
   * @return {Boolean}
   */
  
  
  function selectorsEqual(ruleA, ruleB) {
    return ruleA.selectors.some(function (sel) {
      return ruleB.selectors.some(function (s) {
        return s === sel;
      });
    });
  }
  /**
   * Parse data from all grid-template(-areas) declarations
   * @param  {Root} css css root
   * @return {Object} parsed data
   */
  
  
  function parseGridTemplatesData(css) {
    var parsed = []; // we walk through every grid-template(-areas) declaration and store
    // data with the same area names inside the item
  
    css.walkDecls(/grid-template(-areas)?$/, function (d) {
      var rule = d.parent;
      var media = getParentMedia(rule);
      var gap = getGridGap(d);
      var inheritedGap = inheritGridGap(d, gap);
  
      var _parseTemplate = parseTemplate({
        decl: d,
        gap: inheritedGap || gap
      }),
          areas = _parseTemplate.areas;
  
      var areaNames = Object.keys(areas); // skip node if it doesn't have areas
  
      if (areaNames.length === 0) {
        return true;
      } // check parsed array for item that include the same area names
      // return index of that item
  
  
      var index = parsed.reduce(function (acc, _ref8, idx) {
        var allAreas = _ref8.allAreas;
        var hasAreas = allAreas && areaNames.some(function (area) {
          return allAreas.includes(area);
        });
        return hasAreas ? idx : acc;
      }, null);
  
      if (index !== null) {
        // index is found, add the grid-template data to that item
        var _parsed$index = parsed[index],
            allAreas = _parsed$index.allAreas,
            rules = _parsed$index.rules; // check if rule has no duplicate area names
  
        var hasNoDuplicates = rules.some(function (r) {
          return r.hasDuplicates === false && selectorsEqual(r, rule);
        });
        var duplicatesFound = false; // check need to gather all duplicate area names
  
        var duplicateAreaNames = rules.reduce(function (acc, r) {
          if (!r.params && selectorsEqual(r, rule)) {
            duplicatesFound = true;
            return r.duplicateAreaNames;
          }
  
          if (!duplicatesFound) {
            areaNames.forEach(function (name) {
              if (r.areas[name]) {
                acc.push(name);
              }
            });
          }
  
          return uniq(acc);
        }, []); // update grid-row/column-span values for areas with duplicate
        // area names. @see #1084 and #1146
  
        rules.forEach(function (r) {
          areaNames.forEach(function (name) {
            var area = r.areas[name];
  
            if (area && area.row.span !== areas[name].row.span) {
              areas[name].row.updateSpan = true;
            }
  
            if (area && area.column.span !== areas[name].column.span) {
              areas[name].column.updateSpan = true;
            }
          });
        });
        parsed[index].allAreas = uniq([].concat(allAreas, areaNames));
        parsed[index].rules.push({
          hasDuplicates: !hasNoDuplicates,
          params: media.params,
          selectors: rule.selectors,
          node: rule,
          duplicateAreaNames: duplicateAreaNames,
          areas: areas
        });
      } else {
        // index is NOT found, push the new item to the parsed array
        parsed.push({
          allAreas: areaNames,
          areasCount: 0,
          rules: [{
            hasDuplicates: false,
            duplicateRules: [],
            params: media.params,
            selectors: rule.selectors,
            node: rule,
            duplicateAreaNames: [],
            areas: areas
          }]
        });
      }
  
      return undefined;
    });
    return parsed;
  }
  /**
   * insert prefixed grid-area declarations
   * @param  {Root}  css css root
   * @param  {Function} isDisabled check if the rule is disabled
   * @return {void}
   */
  
  
  function insertAreas(css, isDisabled) {
    // parse grid-template declarations
    var gridTemplatesData = parseGridTemplatesData(css); // return undefined if no declarations found
  
    if (gridTemplatesData.length === 0) {
      return undefined;
    } // we need to store the rules that we will insert later
  
  
    var rulesToInsert = {};
    css.walkDecls('grid-area', function (gridArea) {
      var gridAreaRule = gridArea.parent;
      var hasPrefixedRow = gridAreaRule.first.prop === '-ms-grid-row';
      var gridAreaMedia = getParentMedia(gridAreaRule);
  
      if (isDisabled(gridArea)) {
        return undefined;
      }
  
      var gridAreaRuleIndex = gridAreaMedia ? css.index(gridAreaMedia) : css.index(gridAreaRule);
      var value = gridArea.value; // found the data that matches grid-area identifier
  
      var data = gridTemplatesData.filter(function (d) {
        return d.allAreas.includes(value);
      })[0];
  
      if (!data) {
        return true;
      }
  
      var lastArea = data.allAreas[data.allAreas.length - 1];
      var selectorBySpace = list.space(gridAreaRule.selector);
      var selectorByComma = list.comma(gridAreaRule.selector);
      var selectorIsComplex = selectorBySpace.length > 1 && selectorBySpace.length > selectorByComma.length; // prevent doubling of prefixes
  
      if (hasPrefixedRow) {
        return false;
      } // create the empty object with the key as the last area name
      // e.g if we have templates with "a b c" values, "c" will be the last area
  
  
      if (!rulesToInsert[lastArea]) {
        rulesToInsert[lastArea] = {};
      }
  
      var lastRuleIsSet = false; // walk through every grid-template rule data
  
      for (var _iterator2 = data.rules, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
        var _ref9;
  
        if (_isArray2) {
          if (_i2 >= _iterator2.length) break;
          _ref9 = _iterator2[_i2++];
        } else {
          _i2 = _iterator2.next();
          if (_i2.done) break;
          _ref9 = _i2.value;
        }
  
        var rule = _ref9;
        var area = rule.areas[value];
        var hasDuplicateName = rule.duplicateAreaNames.includes(value); // if we can't find the area name, update lastRule and continue
  
        if (!area) {
          var lastRuleIndex = css.index(rulesToInsert[lastArea].lastRule);
  
          if (gridAreaRuleIndex > lastRuleIndex) {
            rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule;
          }
  
          continue;
        } // for grid-templates inside media rule we need to create empty
        // array to push prefixed grid-area rules later
  
  
        if (rule.params && !rulesToInsert[lastArea][rule.params]) {
          rulesToInsert[lastArea][rule.params] = [];
        }
  
        if ((!rule.hasDuplicates || !hasDuplicateName) && !rule.params) {
          // grid-template has no duplicates and not inside media rule
          getMSDecls(area, false, false).reverse().forEach(function (i) {
            return gridAreaRule.prepend(Object.assign(i, {
              raws: {
                between: gridArea.raws.between
              }
            }));
          });
          rulesToInsert[lastArea].lastRule = gridAreaRule;
          lastRuleIsSet = true;
        } else if (rule.hasDuplicates && !rule.params && !selectorIsComplex) {
          (function () {
            // grid-template has duplicates and not inside media rule
            var cloned = gridAreaRule.clone();
            cloned.removeAll();
            getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach(function (i) {
              return cloned.prepend(Object.assign(i, {
                raws: {
                  between: gridArea.raws.between
                }
              }));
            });
            cloned.selectors = changeDuplicateAreaSelectors(cloned.selectors, rule.selectors);
  
            if (rulesToInsert[lastArea].lastRule) {
              rulesToInsert[lastArea].lastRule.after(cloned);
            }
  
            rulesToInsert[lastArea].lastRule = cloned;
            lastRuleIsSet = true;
          })();
        } else if (rule.hasDuplicates && !rule.params && selectorIsComplex && gridAreaRule.selector.includes(rule.selectors[0])) {
          // grid-template has duplicates and not inside media rule
          // and the selector is complex
          gridAreaRule.walkDecls(/-ms-grid-(row|column)/, function (d) {
            return d.remove();
          });
          getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach(function (i) {
            return gridAreaRule.prepend(Object.assign(i, {
              raws: {
                between: gridArea.raws.between
              }
            }));
          });
        } else if (rule.params) {
          (function () {
            // grid-template is inside media rule
            // if we're inside media rule, we need to store prefixed rules
            // inside rulesToInsert object to be able to preserve the order of media
            // rules and merge them easily
            var cloned = gridAreaRule.clone();
            cloned.removeAll();
            getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach(function (i) {
              return cloned.prepend(Object.assign(i, {
                raws: {
                  between: gridArea.raws.between
                }
              }));
            });
  
            if (rule.hasDuplicates && hasDuplicateName) {
              cloned.selectors = changeDuplicateAreaSelectors(cloned.selectors, rule.selectors);
            }
  
            cloned.raws = rule.node.raws;
  
            if (css.index(rule.node.parent) > gridAreaRuleIndex) {
              // append the prefixed rules right inside media rule
              // with grid-template
              rule.node.parent.append(cloned);
            } else {
              // store the rule to insert later
              rulesToInsert[lastArea][rule.params].push(cloned);
            } // set new rule as last rule ONLY if we didn't set lastRule for
            // this grid-area before
  
  
            if (!lastRuleIsSet) {
              rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule;
            }
          })();
        }
      }
  
      return undefined;
    }); // append stored rules inside the media rules
  
    Object.keys(rulesToInsert).forEach(function (area) {
      var data = rulesToInsert[area];
      var lastRule = data.lastRule;
      Object.keys(data).reverse().filter(function (p) {
        return p !== 'lastRule';
      }).forEach(function (params) {
        if (data[params].length > 0 && lastRule) {
          lastRule.after({
            name: 'media',
            params: params
          });
          lastRule.next().append(data[params]);
        }
      });
    });
    return undefined;
  }
  /**
   * Warn user if grid area identifiers are not found
   * @param  {Object} areas
   * @param  {Declaration} decl
   * @param  {Result} result
   * @return {void}
   */
  
  
  function warnMissedAreas(areas, decl, result) {
    var missed = Object.keys(areas);
    decl.root().walkDecls('grid-area', function (gridArea) {
      missed = missed.filter(function (e) {
        return e !== gridArea.value;
      });
    });
  
    if (missed.length > 0) {
      decl.warn(result, 'Can not find grid areas: ' + missed.join(', '));
    }
  
    return undefined;
  }
  /**
   * compare selectors with grid-area rule and grid-template rule
   * show warning if grid-template selector is not found
   * (this function used for grid-area rule)
   * @param  {Declaration} decl
   * @param  {Result} result
   * @return {void}
   */
  
  
  function warnTemplateSelectorNotFound(decl, result) {
    var rule = decl.parent;
    var root = decl.root();
    var duplicatesFound = false; // slice selector array. Remove the last part (for comparison)
  
    var slicedSelectorArr = list.space(rule.selector).filter(function (str) {
      return str !== '>';
    }).slice(0, -1); // we need to compare only if selector is complex.
    // e.g '.grid-cell' is simple, but '.parent > .grid-cell' is complex
  
    if (slicedSelectorArr.length > 0) {
      var gridTemplateFound = false;
      var foundAreaSelector = null;
      root.walkDecls(/grid-template(-areas)?$/, function (d) {
        var parent = d.parent;
        var templateSelectors = parent.selectors;
  
        var _parseTemplate2 = parseTemplate({
          decl: d,
          gap: getGridGap(d)
        }),
            areas = _parseTemplate2.areas;
  
        var hasArea = areas[decl.value]; // find the the matching selectors
  
        for (var _iterator3 = templateSelectors, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
          var _ref10;
  
          if (_isArray3) {
            if (_i3 >= _iterator3.length) break;
            _ref10 = _iterator3[_i3++];
          } else {
            _i3 = _iterator3.next();
            if (_i3.done) break;
            _ref10 = _i3.value;
          }
  
          var tplSelector = _ref10;
  
          if (gridTemplateFound) {
            break;
          }
  
          var tplSelectorArr = list.space(tplSelector).filter(function (str) {
            return str !== '>';
          });
          gridTemplateFound = tplSelectorArr.every(function (item, idx) {
            return item === slicedSelectorArr[idx];
          });
        }
  
        if (gridTemplateFound || !hasArea) {
          return true;
        }
  
        if (!foundAreaSelector) {
          foundAreaSelector = parent.selector;
        } // if we found the duplicate area with different selector
  
  
        if (foundAreaSelector && foundAreaSelector !== parent.selector) {
          duplicatesFound = true;
        }
  
        return undefined;
      }); // warn user if we didn't find template
  
      if (!gridTemplateFound && duplicatesFound) {
        decl.warn(result, "Autoprefixer cannot find a grid-template " + ("containing the duplicate grid-area \"" + decl.value + "\" ") + ("with full selector matching: " + slicedSelectorArr.join(' ')));
      }
    }
  }
  /**
   * warn user if both grid-area and grid-(row|column)
   * declarations are present in the same rule
   * @param  {Declaration} decl
   * @param  {Result} result
   * @return {void}
   */
  
  
  function warnIfGridRowColumnExists(decl, result) {
    var rule = decl.parent;
    var decls = [];
    rule.walkDecls(/^grid-(row|column)/, function (d) {
      if (!/-end$/.test(d.prop) && !/^span/.test(d.value)) {
        decls.push(d);
      }
    });
  
    if (decls.length > 0) {
      decls.forEach(function (d) {
        d.warn(result, "You already have a grid-area declaration present in the rule. " + ("You should use either grid-area or " + d.prop + ", not both"));
      });
    }
  
    return undefined;
  } // Gap utils
  
  
  function getGridGap(decl) {
    var gap = {}; // try to find gap
  
    var testGap = /^(grid-)?((row|column)-)?gap$/;
    decl.parent.walkDecls(testGap, function (_ref11) {
      var prop = _ref11.prop,
          value = _ref11.value;
  
      if (/^(grid-)?gap$/.test(prop)) {
        var _parser$nodes = parser(value).nodes,
            row = _parser$nodes[0],
            column = _parser$nodes[2];
        gap.row = row && parser.stringify(row);
        gap.column = column ? parser.stringify(column) : gap.row;
      }
  
      if (/^(grid-)?row-gap$/.test(prop)) gap.row = value;
      if (/^(grid-)?column-gap$/.test(prop)) gap.column = value;
    });
    return gap;
  }
  /**
   * parse media parameters (for example 'min-width: 500px')
   * @param  {String} params parameter to parse
   * @return {}
   */
  
  
  function parseMediaParams(params) {
    if (!params) {
      return false;
    }
  
    var parsed = parser(params);
    var prop;
    var value;
    parsed.walk(function (node) {
      if (node.type === 'word' && /min|max/g.test(node.value)) {
        prop = node.value;
      } else if (node.value.includes('px')) {
        value = parseInt(node.value.replace(/\D/g, ''));
      }
    });
    return [prop, value];
  }
  /**
   * Compare the selectors and decide if we
   * need to inherit gap from compared selector or not.
   * @type {String} selA
   * @type {String} selB
   * @return {Boolean}
   */
  
  
  function shouldInheritGap(selA, selB) {
    var result; // get arrays of selector split in 3-deep array
  
    var splitSelectorArrA = splitSelector(selA);
    var splitSelectorArrB = splitSelector(selB);
  
    if (splitSelectorArrA[0].length < splitSelectorArrB[0].length) {
      // abort if selectorA has lower descendant specificity then selectorB
      // (e.g '.grid' and '.hello .world .grid')
      return false;
    } else if (splitSelectorArrA[0].length > splitSelectorArrB[0].length) {
      // if selectorA has higher descendant specificity then selectorB
      // (e.g '.foo .bar .grid' and '.grid')
      var idx = splitSelectorArrA[0].reduce(function (res, _ref12, index) {
        var item = _ref12[0];
        var firstSelectorPart = splitSelectorArrB[0][0][0];
  
        if (item === firstSelectorPart) {
          return index;
        }
  
        return false;
      }, false);
  
      if (idx) {
        result = splitSelectorArrB[0].every(function (arr, index) {
          return arr.every(function (part, innerIndex) {
            return (// because selectorA has more space elements, we need to slice
              // selectorA array by 'idx' number to compare them
              splitSelectorArrA[0].slice(idx)[index][innerIndex] === part
            );
          });
        });
      }
    } else {
      // if selectorA has the same descendant specificity as selectorB
      // this condition covers cases such as: '.grid.foo.bar' and '.grid'
      result = splitSelectorArrB.some(function (byCommaArr) {
        return byCommaArr.every(function (bySpaceArr, index) {
          return bySpaceArr.every(function (part, innerIndex) {
            return splitSelectorArrA[0][index][innerIndex] === part;
          });
        });
      });
    }
  
    return result;
  }
  /**
   * inherit grid gap values from the closest rule above
   * with the same selector
   * @param  {Declaration} decl
   * @param  {Object} gap gap values
   * @return {Object | Boolean} return gap values or false (if not found)
   */
  
  
  function inheritGridGap(decl, gap) {
    var rule = decl.parent;
    var mediaRule = getParentMedia(rule);
    var root = rule.root(); // get an array of selector split in 3-deep array
  
    var splitSelectorArr = splitSelector(rule.selector); // abort if the rule already has gaps
  
    if (Object.keys(gap).length > 0) {
      return false;
    } // e.g ['min-width']
  
  
    var _parseMediaParams = parseMediaParams(mediaRule.params),
        prop = _parseMediaParams[0];
  
    var lastBySpace = splitSelectorArr[0]; // get escaped value from the selector
    // if we have '.grid-2.foo.bar' selector, will be '\.grid\-2'
  
    var escaped = escapeRegexp(lastBySpace[lastBySpace.length - 1][0]);
    var regexp = new RegExp("(" + escaped + "$)|(" + escaped + "[,.])"); // find the closest rule with the same selector
  
    var closestRuleGap;
    root.walkRules(regexp, function (r) {
      var gridGap; // abort if are checking the same rule
  
      if (rule.toString() === r.toString()) {
        return false;
      } // find grid-gap values
  
  
      r.walkDecls('grid-gap', function (d) {
        return gridGap = getGridGap(d);
      }); // skip rule without gaps
  
      if (!gridGap || Object.keys(gridGap).length === 0) {
        return true;
      } // skip rules that should not be inherited from
  
  
      if (!shouldInheritGap(rule.selector, r.selector)) {
        return true;
      }
  
      var media = getParentMedia(r);
  
      if (media) {
        // if we are inside media, we need to check that media props match
        // e.g ('min-width' === 'min-width')
        var propToCompare = parseMediaParams(media.params)[0];
  
        if (propToCompare === prop) {
          closestRuleGap = gridGap;
          return true;
        }
      } else {
        closestRuleGap = gridGap;
        return true;
      }
  
      return undefined;
    }); // if we find the closest gap object
  
    if (closestRuleGap && Object.keys(closestRuleGap).length > 0) {
      return closestRuleGap;
    }
  
    return false;
  }
  
  function warnGridGap(_ref13) {
    var gap = _ref13.gap,
        hasColumns = _ref13.hasColumns,
        decl = _ref13.decl,
        result = _ref13.result;
    var hasBothGaps = gap.row && gap.column;
  
    if (!hasColumns && (hasBothGaps || gap.column && !gap.row)) {
      delete gap.column;
      decl.warn(result, 'Can not implement grid-gap without grid-template-columns');
    }
  }
  /**
   * normalize the grid-template-rows/columns values
   * @param  {String} str grid-template-rows/columns value
   * @return {Array} normalized array with values
   * @example
   * let normalized = normalizeRowColumn('1fr repeat(2, 20px 50px) 1fr')
   * normalized // <= ['1fr', '20px', '50px', '20px', '50px', '1fr']
   */
  
  
  function normalizeRowColumn(str) {
    var normalized = parser(str).nodes.reduce(function (result, node) {
      if (node.type === 'function' && node.value === 'repeat') {
        var key = 'count';
  
        var _node$nodes$reduce = node.nodes.reduce(function (acc, n) {
          if (n.type === 'word' && key === 'count') {
            acc[0] = Math.abs(parseInt(n.value));
            return acc;
          }
  
          if (n.type === 'div' && n.value === ',') {
            key = 'value';
            return acc;
          }
  
          if (key === 'value') {
            acc[1] += parser.stringify(n);
          }
  
          return acc;
        }, [0, '']),
            count = _node$nodes$reduce[0],
            value = _node$nodes$reduce[1];
  
        if (count) {
          for (var i = 0; i < count; i++) {
            result.push(value);
          }
        }
  
        return result;
      }
  
      if (node.type === 'space') {
        return result;
      }
  
      return result.concat(parser.stringify(node));
    }, []);
    return normalized;
  }
  /**
   * Autoplace grid items
   * @param {Declaration} decl
   * @param {Result} result
   * @param {Object} gap gap values
   * @param {String} autoflowValue grid-auto-flow value
   * @return {void}
   * @see https://github.com/postcss/autoprefixer/issues/1148
   */
  
  
  function autoplaceGridItems(decl, result, gap, autoflowValue) {
    if (autoflowValue === void 0) {
      autoflowValue = 'row';
    }
  
    var parent = decl.parent;
    var rowDecl = parent.nodes.find(function (i) {
      return i.prop === 'grid-template-rows';
    });
    var rows = normalizeRowColumn(rowDecl.value);
    var columns = normalizeRowColumn(decl.value); // Build array of area names with dummy values. If we have 3 columns and
    // 2 rows, filledRows will be equal to ['1 2 3', '4 5 6']
  
    var filledRows = rows.map(function (_, rowIndex) {
      return Array.from({
        length: columns.length
      }, function (v, k) {
        return k + rowIndex * columns.length + 1;
      }).join(' ');
    });
    var areas = parseGridAreas({
      rows: filledRows,
      gap: gap
    });
    var keys = Object.keys(areas);
    var items = keys.map(function (i) {
      return areas[i];
    }); // Change the order of cells if grid-auto-flow value is 'column'
  
    if (autoflowValue.includes('column')) {
      items = items.sort(function (a, b) {
        return a.column.start - b.column.start;
      });
    } // Insert new rules
  
  
    items.reverse().forEach(function (item, index) {
      var column = item.column,
          row = item.row;
      var nodeSelector = parent.selectors.map(function (sel) {
        return sel + (" > *:nth-child(" + (keys.length - index) + ")");
      }).join(', '); // create new rule
  
      var node = parent.clone().removeAll(); // change rule selector
  
      node.selector = nodeSelector; // insert prefixed row/column values
  
      node.append({
        prop: '-ms-grid-row',
        value: row.start
      });
      node.append({
        prop: '-ms-grid-column',
        value: column.start
      }); // insert rule
  
      parent.after(node);
    });
    return undefined;
  }
  
  module.exports = {
    parse: parse,
    translate: translate,
    parseTemplate: parseTemplate,
    parseGridAreas: parseGridAreas,
    warnMissedAreas: warnMissedAreas,
    insertAreas: insertAreas,
    insertDecl: insertDecl,
    prefixTrackProp: prefixTrackProp,
    prefixTrackValue: prefixTrackValue,
    getGridGap: getGridGap,
    warnGridGap: warnGridGap,
    warnTemplateSelectorNotFound: warnTemplateSelectorNotFound,
    warnIfGridRowColumnExists: warnIfGridRowColumnExists,
    inheritGridGap: inheritGridGap,
    autoplaceGridItems: autoplaceGridItems
  };