autoprefixer 9.8.7 → 10.0.2

package/lib/hacks/grid-utils.js

@@ -1,281 +1,250 @@
-"use strict";
-
-function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-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)];
+let parser = require('postcss-value-parser')
+let list = require('postcss').list
+
+let uniq = require('../utils').uniq
+let escapeRegexp = require('../utils').escapeRegexp
+let 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 [parseInt(value[0], 10), false]
   }
 
-  return [false, false];
+  return [false, false]
 }
 
-function translate(values, startIndex, endIndex) {
-  var startValue = values[startIndex];
-  var endValue = values[endIndex];
+function translate (values, startIndex, endIndex) {
+  let startValue = values[startIndex]
+  let endValue = values[endIndex]
 
   if (!startValue) {
-    return [false, false];
+    return [false, false]
   }
 
-  var _convert = convert(startValue),
-      start = _convert[0],
-      spanStart = _convert[1];
-
-  var _convert2 = convert(endValue),
-      end = _convert2[0],
-      spanEnd = _convert2[1];
+  let [start, spanStart] = convert(startValue)
+  let [end, spanEnd] = convert(endValue)
 
   if (start && !endValue) {
-    return [start, false];
+    return [start, false]
   }
 
   if (spanStart && end) {
-    return [end - spanStart, spanStart];
+    return [end - spanStart, spanStart]
   }
 
   if (start && spanEnd) {
-    return [start, spanEnd];
+    return [start, spanEnd]
   }
 
   if (start && end) {
-    return [start, end - start];
+    return [start, end - start]
   }
 
-  return [false, false];
+  return [false, false]
 }
 
-function parse(decl) {
-  var node = parser(decl.value);
-  var values = [];
-  var current = 0;
-  values[current] = [];
+function parse (decl) {
+  let node = parser(decl.value)
 
-  for (var _iterator = _createForOfIteratorHelperLoose(node.nodes), _step; !(_step = _iterator()).done;) {
-    var i = _step.value;
+  let values = []
+  let current = 0
+  values[current] = []
 
+  for (let i of node.nodes) {
     if (i.type === 'div') {
-      current += 1;
-      values[current] = [];
+      current += 1
+      values[current] = []
     } else if (i.type === 'word') {
-      values[current].push(i.value);
+      values[current].push(i.value)
     }
   }
 
-  return values;
+  return values
 }
 
-function insertDecl(decl, prop, value) {
-  if (value && !decl.parent.some(function (i) {
-    return i.prop === "-ms-" + prop;
-  })) {
+function insertDecl (decl, prop, value) {
+  if (value && !decl.parent.some(i => i.prop === `-ms-${prop}`)) {
     decl.cloneBefore({
-      prop: "-ms-" + prop,
+      prop: `-ms-${prop}`,
       value: value.toString()
-    });
+    })
   }
-} // Track transforms
+}
 
+// Track transforms
 
-function prefixTrackProp(_ref) {
-  var prop = _ref.prop,
-      prefix = _ref.prefix;
-  return prefix + prop.replace('template-', '');
+function prefixTrackProp ({ prop, prefix }) {
+  return prefix + prop.replace('template-', '')
 }
 
-function transformRepeat(_ref2, _ref3) {
-  var nodes = _ref2.nodes;
-  var gap = _ref3.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));
+function transformRepeat ({ nodes }, { gap }) {
+  let { count, size } = nodes.reduce(
+    (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: []
     }
+  )
 
-    return result;
-  }, {
-    key: 'count',
-    size: [],
-    count: []
-  }),
-      count = _nodes$reduce.count,
-      size = _nodes$reduce.size; // insert gap values
-
-
+  // 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(' ')
-      };
-    }();
+    size = size.filter(i => i.trim())
+    let val = []
+    for (let i = 1; i <= count; i++) {
+      size.forEach((item, index) => {
+        if (index > 0 || i > 1) {
+          val.push(gap)
+        }
+        val.push(item)
+      })
+    }
 
-    if (typeof _ret === "object") return _ret.v;
+    return val.join(' ')
   }
 
-  return "(" + size.join('') + ")[" + count.join('') + "]";
+  return `(${size.join('')})[${count.join('')}]`
 }
 
-function prefixTrackValue(_ref4) {
-  var value = _ref4.value,
-      gap = _ref4.gap;
-  var result = parser(value).nodes.reduce(function (nodes, node) {
+function prefixTrackValue ({ value, gap }) {
+  let result = parser(value).nodes.reduce((nodes, node) => {
     if (node.type === 'function' && node.value === 'repeat') {
       return nodes.concat({
         type: 'word',
-        value: transformRepeat(node, {
-          gap: gap
-        })
-      });
+        value: transformRepeat(node, { gap })
+      })
     }
-
     if (gap && node.type === 'space') {
-      return nodes.concat({
-        type: 'space',
-        value: ' '
-      }, {
-        type: 'word',
-        value: gap
-      }, node);
+      return nodes.concat(
+        {
+          type: 'space',
+          value: ' '
+        },
+        {
+          type: 'word',
+          value: gap
+        },
+        node
+      )
     }
+    return nodes.concat(node)
+  }, [])
 
-    return nodes.concat(node);
-  }, []);
-  return parser.stringify(result);
-} // Parse grid-template-areas
+  return parser.stringify(result)
+}
 
+// Parse grid-template-areas
 
-var DOTS = /^\.+$/;
+let DOTS = /^\.+$/
 
-function track(start, end) {
-  return {
-    start: start,
-    end: end,
-    span: end - start
-  };
+function track (start, end) {
+  return { start, end, span: end - start }
 }
 
-function getColumns(line) {
-  return line.trim().split(/\s+/g);
+function getColumns (line) {
+  return line.trim().split(/\s+/g)
 }
 
-function parseGridAreas(_ref5) {
-  var rows = _ref5.rows,
-      gap = _ref5.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;
+function parseGridAreas ({ rows, gap }) {
+  return rows.reduce((areas, line, rowIndex) => {
+    if (gap.row) rowIndex *= 2
+
+    if (line.trim() === '') return areas
+
+    getColumns(line).forEach((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;
+        let { column, row } = areas[area]
+
+        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
+    })
 
+    return areas
+  }, {})
+}
 
-function testTrack(node) {
-  return node.type === 'word' && /^\[.+]$/.test(node.value);
+// Parse grid-template
+
+function testTrack (node) {
+  return node.type === 'word' && /^\[.+]$/.test(node.value)
 }
 
-function verifyRowSize(result) {
+function verifyRowSize (result) {
   if (result.areas.length > result.rows.length) {
-    result.rows.push('auto');
+    result.rows.push('auto')
   }
-
-  return result;
+  return result
 }
 
-function parseTemplate(_ref6) {
-  var decl = _ref6.decl,
-      gap = _ref6.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
+function parseTemplate ({ decl, gap }) {
+  let gridTemplate = parser(decl.value).nodes.reduce(
+    (result, node) => {
+      let { type, value } = node
 
-    if (type === 'string') {
-      result = verifyRowSize(result);
-      result.areas.push(value);
-    } // values and function
+      if (testTrack(node) || type === 'space') return result
 
+      // area
+      if (type === 'string') {
+        result = verifyRowSize(result)
+        result.areas.push(value)
+      }
 
-    if (type === 'word' || type === 'function') {
-      result[result.key].push(parser.stringify(node));
-    } // divider(/)
+      // 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)
+      }
 
-    if (type === 'div' && value === '/') {
-      result.key = 'columns';
-      result = verifyRowSize(result);
+      return result
+    },
+    {
+      key: 'rows',
+      columns: [],
+      rows: [],
+      areas: []
     }
+  )
 
-    return result;
-  }, {
-    key: 'rows',
-    columns: [],
-    rows: [],
-    areas: []
-  });
   return {
     areas: parseGridAreas({
       rows: gridTemplate.areas,
-      gap: gap
+      gap
     }),
     columns: prefixTrackValue({
       value: gridTemplate.columns.join(' '),
@@ -285,8 +254,10 @@ function parseTemplate(_ref6) {
       value: gridTemplate.rows.join(' '),
       gap: gap.row
     })
-  };
-} // Insert parsed grid areas
+  }
+}
+
+// Insert parsed grid areas
 
 /**
  * Get an array of -ms- prefixed props and values
@@ -295,377 +266,395 @@ function parseTemplate(_ref6) {
  * @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;
+function getMSDecls (area, addRowSpan = false, addColumnSpan = false) {
+  let result = [
+    {
+      prop: '-ms-grid-row',
+      value: String(area.row.start)
+    }
+  ]
+  if (area.row.span > 1 || addRowSpan) {
+    result.push({
+      prop: '-ms-grid-row-span',
+      value: String(area.row.span)
+    })
   }
-
-  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)
-  } : [], {
+  result.push({
     prop: '-ms-grid-column',
     value: String(area.column.start)
-  }, area.column.span > 1 || addColumnSpan ? {
-    prop: '-ms-grid-column-span',
-    value: String(area.column.span)
-  } : []);
+  })
+  if (area.column.span > 1 || addColumnSpan) {
+    result.push({
+      prop: '-ms-grid-column-span',
+      value: String(area.column.span)
+    })
+  }
+  return result
 }
 
-function getParentMedia(parent) {
+function getParentMedia (parent) {
   if (parent.type === 'atrule' && parent.name === 'media') {
-    return parent;
+    return parent
   }
-
   if (!parent.parent) {
-    return false;
+    return false
   }
-
-  return getParentMedia(parent.parent);
+  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);
+function changeDuplicateAreaSelectors (ruleSelectors, templateSelectors) {
+  ruleSelectors = ruleSelectors.map(selector => {
+    let selectorBySpace = list.space(selector)
+    let selectorByComma = list.comma(selector)
 
     if (selectorBySpace.length > selectorByComma.length) {
-      selector = selectorBySpace.slice(-1).join('');
+      selector = selectorBySpace.slice(-1).join('')
     }
+    return selector
+  })
+
+  return ruleSelectors.map(ruleSelector => {
+    let newSelector = templateSelectors.map((tplSelector, index) => {
+      let space = index === 0 ? '' : ' '
+      return `${space}${tplSelector} > ${ruleSelector}`
+    })
 
-    return selector;
-  });
-  return ruleSelectors.map(function (ruleSelector) {
-    var newSelector = templateSelectors.map(function (tplSelector, index) {
-      var space = index === 0 ? '' : ' ';
-      return "" + space + tplSelector + " > " + ruleSelector;
-    });
-    return newSelector;
-  });
+    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;
-    });
-  });
+function selectorsEqual (ruleA, ruleB) {
+  return ruleA.selectors.some(sel => {
+    return ruleB.selectors.some(s => s === sel)
+  })
 }
+
 /**
  * Parse data from all grid-template(-areas) declarations
  * @param  {Root} css css root
  * @return {Object} parsed data
  */
+function parseGridTemplatesData (css) {
+  let parsed = []
 
-
-function parseGridTemplatesData(css) {
-  var parsed = []; // we walk through every grid-template(-areas) declaration and store
+  // 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
-
+  css.walkDecls(/grid-template(-areas)?$/, d => {
+    let rule = d.parent
+    let media = getParentMedia(rule)
+    let gap = getGridGap(d)
+    let inheritedGap = inheritGridGap(d, gap)
+    let { areas } = parseTemplate({ decl: d, gap: inheritedGap || gap })
+    let 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
-
+      return true
+    }
 
-    var index = parsed.reduce(function (acc, _ref7, idx) {
-      var allAreas = _ref7.allAreas;
-      var hasAreas = allAreas && areaNames.some(function (area) {
-        return allAreas.includes(area);
-      });
-      return hasAreas ? idx : acc;
-    }, null);
+    // check parsed array for item that include the same area names
+    // return index of that item
+    let index = parsed.reduce((acc, { allAreas }, idx) => {
+      let hasAreas = allAreas && areaNames.some(area => 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
+      let { allAreas, rules } = parsed[index]
+
+      // check if rule has no duplicate area names
+      let hasNoDuplicates = rules.some(r => {
+        return r.hasDuplicates === false && selectorsEqual(r, rule)
+      })
 
-      var hasNoDuplicates = rules.some(function (r) {
-        return r.hasDuplicates === false && selectorsEqual(r, rule);
-      });
-      var duplicatesFound = false; // check need to gather all duplicate area names
+      let duplicatesFound = false
 
-      var duplicateAreaNames = rules.reduce(function (acc, r) {
+      // check need to gather all duplicate area names
+      let duplicateAreaNames = rules.reduce((acc, r) => {
         if (!r.params && selectorsEqual(r, rule)) {
-          duplicatesFound = true;
-          return r.duplicateAreaNames;
+          duplicatesFound = true
+          return r.duplicateAreaNames
         }
-
         if (!duplicatesFound) {
-          areaNames.forEach(function (name) {
+          areaNames.forEach(name => {
             if (r.areas[name]) {
-              acc.push(name);
+              acc.push(name)
             }
-          });
+          })
         }
+        return uniq(acc)
+      }, [])
 
-        return uniq(acc);
-      }, []); // update grid-row/column-span values for areas with duplicate
+      // 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];
-
+      rules.forEach(r => {
+        areaNames.forEach(name => {
+          let area = r.areas[name]
           if (area && area.row.span !== areas[name].row.span) {
-            areas[name].row.updateSpan = true;
+            areas[name].row.updateSpan = true
           }
 
           if (area && area.column.span !== areas[name].column.span) {
-            areas[name].column.updateSpan = true;
+            areas[name].column.updateSpan = true
           }
-        });
-      });
-      parsed[index].allAreas = uniq([].concat(allAreas, areaNames));
+        })
+      })
+
+      parsed[index].allAreas = uniq([...allAreas, ...areaNames])
       parsed[index].rules.push({
         hasDuplicates: !hasNoDuplicates,
         params: media.params,
         selectors: rule.selectors,
         node: rule,
-        duplicateAreaNames: duplicateAreaNames,
-        areas: areas
-      });
+        duplicateAreaNames,
+        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
-        }]
-      });
+        rules: [
+          {
+            hasDuplicates: false,
+            duplicateRules: [],
+            params: media.params,
+            selectors: rule.selectors,
+            node: rule,
+            duplicateAreaNames: [],
+            areas
+          }
+        ]
+      })
     }
 
-    return undefined;
-  });
-  return parsed;
+    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) {
+function insertAreas (css, isDisabled) {
   // parse grid-template declarations
-  var gridTemplatesData = parseGridTemplatesData(css); // return undefined if no declarations found
+  let 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
+    return undefined
+  }
 
+  // we need to store the rules that we will insert later
+  let rulesToInsert = {}
 
-  var rulesToInsert = {};
-  css.walkDecls('grid-area', function (gridArea) {
-    var gridAreaRule = gridArea.parent;
-    var hasPrefixedRow = gridAreaRule.first.prop === '-ms-grid-row';
-    var gridAreaMedia = getParentMedia(gridAreaRule);
+  css.walkDecls('grid-area', gridArea => {
+    let gridAreaRule = gridArea.parent
+    let hasPrefixedRow = gridAreaRule.first.prop === '-ms-grid-row'
+    let gridAreaMedia = getParentMedia(gridAreaRule)
 
     if (isDisabled(gridArea)) {
-      return undefined;
+      return undefined
     }
 
-    var gridAreaRuleIndex = gridAreaMedia ? css.index(gridAreaMedia) : css.index(gridAreaRule);
-    var value = gridArea.value; // found the data that matches grid-area identifier
+    let gridAreaRuleIndex = css.index(gridAreaMedia || gridAreaRule)
 
-    var data = gridTemplatesData.filter(function (d) {
-      return d.allAreas.includes(value);
-    })[0];
+    let value = gridArea.value
+    // found the data that matches grid-area identifier
+    let data = gridTemplatesData.filter(d => d.allAreas.includes(value))[0]
 
     if (!data) {
-      return true;
+      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
+    let lastArea = data.allAreas[data.allAreas.length - 1]
+    let selectorBySpace = list.space(gridAreaRule.selector)
+    let selectorByComma = list.comma(gridAreaRule.selector)
+    let 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
-
+      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] = {};
+      rulesToInsert[lastArea] = {}
     }
 
-    var lastRuleIsSet = false; // walk through every grid-template rule data
+    let lastRuleIsSet = false
 
-    for (var _iterator2 = _createForOfIteratorHelperLoose(data.rules), _step2; !(_step2 = _iterator2()).done;) {
-      var rule = _step2.value;
-      var area = rule.areas[value];
-      var hasDuplicateName = rule.duplicateAreaNames.includes(value); // if we can't find the area name, update lastRule and continue
+    // walk through every grid-template rule data
+    for (let rule of data.rules) {
+      let area = rule.areas[value]
+      let 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);
-
+        let lastRuleIndex = css.index(rulesToInsert[lastArea].lastRule)
         if (gridAreaRuleIndex > lastRuleIndex) {
-          rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule;
+          rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule
         }
+        continue
+      }
 
-        continue;
-      } // for grid-templates inside media rule we need to create empty
+      // 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] = [];
+        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])) {
+        getMSDecls(area, false, false)
+          .reverse()
+          .forEach(i =>
+            gridAreaRule.prepend(
+              Object.assign(i, {
+                raws: {
+                  between: gridArea.raws.between
+                }
+              })
+            )
+          )
+
+        rulesToInsert[lastArea].lastRule = gridAreaRule
+        lastRuleIsSet = true
+      } else if (rule.hasDuplicates && !rule.params && !selectorIsComplex) {
+        // grid-template has duplicates and not inside media rule
+        let cloned = gridAreaRule.clone()
+        cloned.removeAll()
+
+        getMSDecls(area, area.row.updateSpan, area.column.updateSpan)
+          .reverse()
+          .forEach(i =>
+            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
-            }
-          }));
-        });
+        gridAreaRule.walkDecls(/-ms-grid-(row|column)/, d => d.remove())
+        getMSDecls(area, area.row.updateSpan, area.column.updateSpan)
+          .reverse()
+          .forEach(i =>
+            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;
+        // 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
+        let cloned = gridAreaRule.clone()
+        cloned.removeAll()
+
+        getMSDecls(area, area.row.updateSpan, area.column.updateSpan)
+          .reverse()
+          .forEach(i =>
+            cloned.prepend(
+              Object.assign(i, {
+                raws: {
+                  between: gridArea.raws.between
+                }
+              })
+            )
+          )
+
+        if (rule.hasDuplicates && hasDuplicateName) {
+          cloned.selectors = changeDuplicateAreaSelectors(
+            cloned.selectors,
+            rule.selectors
+          )
+        }
 
-          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
+        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)
+        }
 
-          if (!lastRuleIsSet) {
-            rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule;
-          }
-        })();
+        // 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;
+    return undefined
+  })
+
+  // append stored rules inside the media rules
+  Object.keys(rulesToInsert).forEach(area => {
+    let data = rulesToInsert[area]
+    let lastRule = data.lastRule
+    Object.keys(data)
+      .reverse()
+      .filter(p => p !== 'lastRule')
+      .forEach(params => {
+        if (data[params].length > 0 && lastRule) {
+          lastRule.after({ name: 'media', params })
+          lastRule.next().append(data[params])
+        }
+      })
+  })
+
+  return undefined
 }
+
 /**
  * Warn user if grid area identifiers are not found
  * @param  {Object} areas
@@ -673,22 +662,20 @@ function insertAreas(css, isDisabled) {
  * @param  {Result} result
  * @return {void}
  */
+function warnMissedAreas (areas, decl, result) {
+  let missed = Object.keys(areas)
 
-
-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;
-    });
-  });
+  decl.root().walkDecls('grid-area', gridArea => {
+    missed = missed.filter(e => e !== gridArea.value)
+  })
 
   if (missed.length > 0) {
-    decl.warn(result, 'Can not find grid areas: ' + missed.join(', '));
+    decl.warn(result, 'Can not find grid areas: ' + missed.join(', '))
   }
 
-  return undefined;
+  return undefined
 }
+
 /**
  * compare selectors with grid-area rule and grid-template rule
  * show warning if grid-template selector is not found
@@ -697,69 +684,70 @@ function warnMissedAreas(areas, decl, result) {
  * @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.
+function warnTemplateSelectorNotFound (decl, result) {
+  let rule = decl.parent
+  let root = decl.root()
+  let duplicatesFound = false
+
+  // slice selector array. Remove the last part (for comparison)
+  let slicedSelectorArr = list
+    .space(rule.selector)
+    .filter(str => 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;
+    let gridTemplateFound = false
+    let foundAreaSelector = null
 
-      var _parseTemplate2 = parseTemplate({
-        decl: d,
-        gap: getGridGap(d)
-      }),
-          areas = _parseTemplate2.areas;
+    root.walkDecls(/grid-template(-areas)?$/, d => {
+      let parent = d.parent
+      let templateSelectors = parent.selectors
 
-      var hasArea = areas[decl.value]; // find the the matching selectors
-
-      for (var _iterator3 = _createForOfIteratorHelperLoose(templateSelectors), _step3; !(_step3 = _iterator3()).done;) {
-        var tplSelector = _step3.value;
+      let { areas } = parseTemplate({ decl: d, gap: getGridGap(d) })
+      let hasArea = areas[decl.value]
 
+      // find the the matching selectors
+      for (let tplSelector of templateSelectors) {
         if (gridTemplateFound) {
-          break;
+          break
         }
+        let tplSelectorArr = list.space(tplSelector).filter(str => str !== '>')
 
-        var tplSelectorArr = list.space(tplSelector).filter(function (str) {
-          return str !== '>';
-        });
-        gridTemplateFound = tplSelectorArr.every(function (item, idx) {
-          return item === slicedSelectorArr[idx];
-        });
+        gridTemplateFound = tplSelectorArr.every(
+          (item, idx) => item === slicedSelectorArr[idx]
+        )
       }
 
       if (gridTemplateFound || !hasArea) {
-        return true;
+        return true
       }
 
       if (!foundAreaSelector) {
-        foundAreaSelector = parent.selector;
-      } // if we found the duplicate area with different selector
-
+        foundAreaSelector = parent.selector
+      }
 
+      // if we found the duplicate area with different selector
       if (foundAreaSelector && foundAreaSelector !== parent.selector) {
-        duplicatesFound = true;
+        duplicatesFound = true
       }
 
-      return undefined;
-    }); // warn user if we didn't find template
+      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(' ')));
+      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
@@ -767,72 +755,76 @@ function warnTemplateSelectorNotFound(decl, result) {
  * @param  {Result} result
  * @return {void}
  */
-
-
-function warnIfGridRowColumnExists(decl, result) {
-  var rule = decl.parent;
-  var decls = [];
-  rule.walkDecls(/^grid-(row|column)/, function (d) {
-    if (!d.prop.endsWith('-end') && !d.value.startsWith('span')) {
-      decls.push(d);
+function warnIfGridRowColumnExists (decl, result) {
+  let rule = decl.parent
+  let decls = []
+  rule.walkDecls(/^grid-(row|column)/, d => {
+    if (
+      !d.prop.endsWith('-end') &&
+      !d.value.startsWith('span') &&
+      !d.prop.endsWith('-gap')
+    ) {
+      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"));
-    });
+    decls.forEach(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
-
+  return undefined
+}
 
-function getGridGap(decl) {
-  var gap = {}; // try to find gap
+// Gap utils
 
-  var testGap = /^(grid-)?((row|column)-)?gap$/;
-  decl.parent.walkDecls(testGap, function (_ref8) {
-    var prop = _ref8.prop,
-        value = _ref8.value;
+function getGridGap (decl) {
+  let gap = {}
 
+  // try to find gap
+  let testGap = /^(grid-)?((row|column)-)?gap$/
+  decl.parent.walkDecls(testGap, ({ prop, 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;
+      let [row, , column] = parser(value).nodes
+
+      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
+  })
 
-    if (/^(grid-)?row-gap$/.test(prop)) gap.row = value;
-    if (/^(grid-)?column-gap$/.test(prop)) gap.column = value;
-  });
-  return gap;
+  return gap
 }
+
 /**
  * parse media parameters (for example 'min-width: 500px')
  * @param  {String} params parameter to parse
  * @return {}
  */
-
-
-function parseMediaParams(params) {
+function parseMediaParams (params) {
   if (!params) {
-    return false;
+    return []
   }
+  let parsed = parser(params)
+  let prop
+  let value
 
-  var parsed = parser(params);
-  var prop;
-  var value;
-  parsed.walk(function (node) {
+  parsed.walk(node => {
     if (node.type === 'word' && /min|max/g.test(node.value)) {
-      prop = node.value;
+      prop = node.value
     } else if (node.value.includes('px')) {
-      value = parseInt(node.value.replace(/\D/g, ''));
+      value = parseInt(node.value.replace(/\D/g, ''))
     }
-  });
-  return [prop, value];
+  })
+
+  return [prop, value]
 }
+
 /**
  * Compare the selectors and decide if we
  * need to inherit gap from compared selector or not.
@@ -840,55 +832,52 @@ function parseMediaParams(params) {
  * @type {String} selB
  * @return {Boolean}
  */
+function shouldInheritGap (selA, selB) {
+  let result
 
-
-function shouldInheritGap(selA, selB) {
-  var result; // get arrays of selector split in 3-deep array
-
-  var splitSelectorArrA = splitSelector(selA);
-  var splitSelectorArrB = splitSelector(selB);
+  // get arrays of selector split in 3-deep array
+  let splitSelectorArrA = splitSelector(selA)
+  let 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;
+    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, _ref9, index) {
-      var item = _ref9[0];
-      var firstSelectorPart = splitSelectorArrB[0][0][0];
 
+    let idx = splitSelectorArrA[0].reduce((res, [item], index) => {
+      let firstSelectorPart = splitSelectorArrB[0][0][0]
       if (item === firstSelectorPart) {
-        return index;
+        return index
       }
-
-      return false;
-    }, false);
+      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
+      result = splitSelectorArrB[0].every((arr, index) => {
+        return arr.every(
+          (part, innerIndex) =>
+            // 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;
-        });
-      });
-    });
+    result = splitSelectorArrB.some(byCommaArr => {
+      return byCommaArr.every((bySpaceArr, index) => {
+        return bySpaceArr.every(
+          (part, innerIndex) => splitSelectorArrA[0][index][innerIndex] === part
+        )
+      })
+    })
   }
 
-  return result;
+  return result
 }
 /**
  * inherit grid gap values from the closest rule above
@@ -897,89 +886,88 @@ function shouldInheritGap(selA, selB) {
  * @param  {Object} gap gap values
  * @return {Object | Boolean} return gap values or false (if not found)
  */
+function inheritGridGap (decl, gap) {
+  let rule = decl.parent
+  let mediaRule = getParentMedia(rule)
+  let root = rule.root()
 
+  // get an array of selector split in 3-deep array
+  let splitSelectorArr = splitSelector(rule.selector)
 
-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
-
+  // abort if the rule already has gaps
   if (Object.keys(gap).length > 0) {
-    return false;
-  } // e.g ['min-width']
+    return false
+  }
 
+  // e.g ['min-width']
+  let [prop] = parseMediaParams(mediaRule.params)
 
-  var _parseMediaParams = parseMediaParams(mediaRule.params),
-      prop = _parseMediaParams[0];
+  let lastBySpace = splitSelectorArr[0]
 
-  var lastBySpace = splitSelectorArr[0]; // get escaped value from the selector
+  // get escaped value from the selector
   // if we have '.grid-2.foo.bar' selector, will be '\.grid\-2'
+  let escaped = escapeRegexp(lastBySpace[lastBySpace.length - 1][0])
 
-  var escaped = escapeRegexp(lastBySpace[lastBySpace.length - 1][0]);
-  var regexp = new RegExp("(" + escaped + "$)|(" + escaped + "[,.])"); // find the closest rule with the same selector
+  let regexp = new RegExp(`(${escaped}$)|(${escaped}[,.])`)
 
-  var closestRuleGap;
-  root.walkRules(regexp, function (r) {
-    var gridGap; // abort if are checking the same rule
+  // find the closest rule with the same selector
+  let closestRuleGap
+  root.walkRules(regexp, r => {
+    let gridGap
 
+    // abort if are checking the same rule
     if (rule.toString() === r.toString()) {
-      return false;
-    } // find grid-gap values
-
+      return false
+    }
 
-    r.walkDecls('grid-gap', function (d) {
-      return gridGap = getGridGap(d);
-    }); // skip rule without gaps
+    // find grid-gap values
+    r.walkDecls('grid-gap', d => (gridGap = getGridGap(d)))
 
+    // skip rule without gaps
     if (!gridGap || Object.keys(gridGap).length === 0) {
-      return true;
-    } // skip rules that should not be inherited from
-
+      return true
+    }
 
+    // skip rules that should not be inherited from
     if (!shouldInheritGap(rule.selector, r.selector)) {
-      return true;
+      return true
     }
 
-    var media = getParentMedia(r);
-
+    let 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];
-
+      let propToCompare = parseMediaParams(media.params)[0]
       if (propToCompare === prop) {
-        closestRuleGap = gridGap;
-        return true;
+        closestRuleGap = gridGap
+        return true
       }
     } else {
-      closestRuleGap = gridGap;
-      return true;
+      closestRuleGap = gridGap
+      return true
     }
 
-    return undefined;
-  }); // if we find the closest gap object
+    return undefined
+  })
 
+  // if we find the closest gap object
   if (closestRuleGap && Object.keys(closestRuleGap).length > 0) {
-    return closestRuleGap;
+    return closestRuleGap
   }
-
-  return false;
+  return false
 }
 
-function warnGridGap(_ref10) {
-  var gap = _ref10.gap,
-      hasColumns = _ref10.hasColumns,
-      decl = _ref10.decl,
-      result = _ref10.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');
+function warnGridGap ({ gap, hasColumns, decl, result }) {
+  let 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
@@ -988,50 +976,46 @@ function warnGridGap(_ref10) {
  * 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) {
+function normalizeRowColumn (str) {
+  let normalized = parser(str).nodes.reduce((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;
-        }
+      let key = 'count'
 
-        if (key === 'value') {
-          acc[1] += parser.stringify(n);
-        }
-
-        return acc;
-      }, [0, '']),
-          count = _node$nodes$reduce[0],
-          value = _node$nodes$reduce[1];
+      let [count, value] = node.nodes.reduce(
+        (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, '']
+      )
 
       if (count) {
-        for (var i = 0; i < count; i++) {
-          result.push(value);
+        for (let i = 0; i < count; i++) {
+          result.push(value)
         }
       }
 
-      return result;
+      return result
     }
-
     if (node.type === 'space') {
-      return result;
+      return result
     }
+    return result.concat(parser.stringify(node))
+  }, [])
 
-    return result.concat(parser.stringify(node));
-  }, []);
-  return normalized;
+  return normalized
 }
+
 /**
  * Autoplace grid items
  * @param {Declaration} decl
@@ -1041,83 +1025,69 @@ function normalizeRowColumn(str) {
  * @return {void}
  * @see https://github.com/postcss/autoprefixer/issues/1148
  */
+function autoplaceGridItems (decl, result, gap, autoflowValue = 'row') {
+  let { parent } = decl
 
+  let rowDecl = parent.nodes.find(i => i.prop === 'grid-template-rows')
+  let rows = normalizeRowColumn(rowDecl.value)
+  let columns = normalizeRowColumn(decl.value)
 
-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
+  // 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'
-
+  let filledRows = rows.map((_, rowIndex) => {
+    return Array.from(
+      { length: columns.length },
+      (v, k) => k + rowIndex * columns.length + 1
+    ).join(' ')
+  })
+
+  let areas = parseGridAreas({ rows: filledRows, gap })
+  let keys = Object.keys(areas)
+  let items = keys.map(i => 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 = items.sort((a, b) => a.column.start - b.column.start)
+  }
 
+  // Insert new rules
+  items.reverse().forEach((item, index) => {
+    let { column, row } = item
+    let nodeSelector = parent.selectors
+      .map(sel => sel + ` > *:nth-child(${keys.length - index})`)
+      .join(', ')
 
-  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
+    // create new rule
+    let node = parent.clone().removeAll()
 
-    var node = parent.clone().removeAll(); // change rule selector
+    // change rule selector
+    node.selector = nodeSelector
 
-    node.selector = nodeSelector; // insert prefixed row/column values
+    // insert prefixed row/column values
+    node.append({ prop: '-ms-grid-row', value: row.start })
+    node.append({ prop: '-ms-grid-column', value: column.start })
 
-    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;
+    // 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
-};
+  parse,
+  translate,
+  parseTemplate,
+  parseGridAreas,
+  warnMissedAreas,
+  insertAreas,
+  insertDecl,
+  prefixTrackProp,
+  prefixTrackValue,
+  getGridGap,
+  warnGridGap,
+  warnTemplateSelectorNotFound,
+  warnIfGridRowColumnExists,
+  inheritGridGap,
+  autoplaceGridItems
+}