55 files changed, 5035 insertions, 0 deletions
diff --git a/node_modules/autoprefixer/lib/hacks/align-content.js b/node_modules/autoprefixer/lib/hacks/align-content.js
new file mode 100644
index 0000000..2796f56
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/align-content.js
@@ -0,0 +1,81 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var AlignContent =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(AlignContent, _Declaration);
+
+  function AlignContent() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = AlignContent.prototype;
+
+  /**
+   * Change property name for 2012 spec
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2012) {
+      return prefix + 'flex-line-pack';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Return property name by final spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'align-content';
+  }
+  /**
+   * Change value for 2012 spec and ignore prefix for 2009
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    var spec = flexSpec(prefix)[0];
+
+    if (spec === 2012) {
+      decl.value = AlignContent.oldValues[decl.value] || decl.value;
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    if (spec === 'final') {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    return undefined;
+  };
+
+  return AlignContent;
+}(Declaration);
+
+_defineProperty(AlignContent, "names", ['align-content', 'flex-line-pack']);
+
+_defineProperty(AlignContent, "oldValues", {
+  'flex-end': 'end',
+  'flex-start': 'start',
+  'space-between': 'justify',
+  'space-around': 'distribute'
+});
+
+module.exports = AlignContent;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/align-items.js b/node_modules/autoprefixer/lib/hacks/align-items.js
new file mode 100644
index 0000000..a9ed9ba
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/align-items.js
@@ -0,0 +1,78 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var AlignItems =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(AlignItems, _Declaration);
+
+  function AlignItems() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = AlignItems.prototype;
+
+  /**
+   * Change property name for 2009 and 2012 specs
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2009) {
+      return prefix + 'box-align';
+    }
+
+    if (spec === 2012) {
+      return prefix + 'flex-align';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Return property name by final spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'align-items';
+  }
+  /**
+   * Change value for 2009 and 2012 specs
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    var spec = flexSpec(prefix)[0];
+
+    if (spec === 2009 || spec === 2012) {
+      decl.value = AlignItems.oldValues[decl.value] || decl.value;
+    }
+
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
+
+  return AlignItems;
+}(Declaration);
+
+_defineProperty(AlignItems, "names", ['align-items', 'flex-align', 'box-align']);
+
+_defineProperty(AlignItems, "oldValues", {
+  'flex-end': 'end',
+  'flex-start': 'start'
+});
+
+module.exports = AlignItems;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/align-self.js b/node_modules/autoprefixer/lib/hacks/align-self.js
new file mode 100644
index 0000000..9a2b5f6
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/align-self.js
@@ -0,0 +1,86 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var AlignSelf =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(AlignSelf, _Declaration);
+
+  function AlignSelf() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = AlignSelf.prototype;
+
+  _proto.check = function check(decl) {
+    return decl.parent && decl.parent.every(function (i) {
+      return !/^grid-/.test(i.prop);
+    });
+  }
+  /**
+   * Change property name for 2012 specs
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2012) {
+      return prefix + 'flex-item-align';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Return property name by final spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'align-self';
+  }
+  /**
+   * Change value for 2012 spec and ignore prefix for 2009
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    var spec = flexSpec(prefix)[0];
+
+    if (spec === 2012) {
+      decl.value = AlignSelf.oldValues[decl.value] || decl.value;
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    if (spec === 'final') {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    return undefined;
+  };
+
+  return AlignSelf;
+}(Declaration);
+
+_defineProperty(AlignSelf, "names", ['align-self', 'flex-item-align']);
+
+_defineProperty(AlignSelf, "oldValues", {
+  'flex-end': 'end',
+  'flex-start': 'start'
+});
+
+module.exports = AlignSelf;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/animation.js b/node_modules/autoprefixer/lib/hacks/animation.js
new file mode 100644
index 0000000..55a03d9
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/animation.js
@@ -0,0 +1,37 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var Animation =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(Animation, _Declaration);
+
+  function Animation() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = Animation.prototype;
+
+  /**
+   * Don’t add prefixes for modern values.
+   */
+  _proto.check = function check(decl) {
+    return !decl.value.split(/\s+/).some(function (i) {
+      var lower = i.toLowerCase();
+      return lower === 'reverse' || lower === 'alternate-reverse';
+    });
+  };
+
+  return Animation;
+}(Declaration);
+
+_defineProperty(Animation, "names", ['animation', 'animation-direction']);
+
+module.exports = Animation;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/appearance.js b/node_modules/autoprefixer/lib/hacks/appearance.js
new file mode 100644
index 0000000..29424d9
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/appearance.js
@@ -0,0 +1,41 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var utils = require('../utils');
+
+var Appearance =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(Appearance, _Declaration);
+
+  function Appearance(name, prefixes, all) {
+    var _this;
+
+    _this = _Declaration.call(this, name, prefixes, all) || this;
+
+    if (_this.prefixes) {
+      _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
+        if (i === '-ms-') {
+          return '-webkit-';
+        }
+
+        return i;
+      }));
+    }
+
+    return _this;
+  }
+
+  return Appearance;
+}(Declaration);
+
+_defineProperty(Appearance, "names", ['appearance']);
+
+module.exports = Appearance;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/backdrop-filter.js b/node_modules/autoprefixer/lib/hacks/backdrop-filter.js
new file mode 100644
index 0000000..5b97e82
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/backdrop-filter.js
@@ -0,0 +1,37 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var utils = require('../utils');
+
+var BackdropFilter =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(BackdropFilter, _Declaration);
+
+  function BackdropFilter(name, prefixes, all) {
+    var _this;
+
+    _this = _Declaration.call(this, name, prefixes, all) || this;
+
+    if (_this.prefixes) {
+      _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
+        return i === '-ms-' ? '-webkit-' : i;
+      }));
+    }
+
+    return _this;
+  }
+
+  return BackdropFilter;
+}(Declaration);
+
+_defineProperty(BackdropFilter, "names", ['backdrop-filter']);
+
+module.exports = BackdropFilter;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/background-clip.js b/node_modules/autoprefixer/lib/hacks/background-clip.js
new file mode 100644
index 0000000..58fcbb6
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/background-clip.js
@@ -0,0 +1,43 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var utils = require('../utils');
+
+var BackgroundClip =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(BackgroundClip, _Declaration);
+
+  function BackgroundClip(name, prefixes, all) {
+    var _this;
+
+    _this = _Declaration.call(this, name, prefixes, all) || this;
+
+    if (_this.prefixes) {
+      _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
+        return i === '-ms-' ? '-webkit-' : i;
+      }));
+    }
+
+    return _this;
+  }
+
+  var _proto = BackgroundClip.prototype;
+
+  _proto.check = function check(decl) {
+    return decl.value.toLowerCase() === 'text';
+  };
+
+  return BackgroundClip;
+}(Declaration);
+
+_defineProperty(BackgroundClip, "names", ['background-clip']);
+
+module.exports = BackgroundClip;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/background-size.js b/node_modules/autoprefixer/lib/hacks/background-size.js
new file mode 100644
index 0000000..2b9a035
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/background-size.js
@@ -0,0 +1,40 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var BackgroundSize =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(BackgroundSize, _Declaration);
+
+  function BackgroundSize() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = BackgroundSize.prototype;
+
+  /**
+   * Duplication parameter for -webkit- browsers
+   */
+  _proto.set = function set(decl, prefix) {
+    var value = decl.value.toLowerCase();
+
+    if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') {
+      decl.value = decl.value + ' ' + decl.value;
+    }
+
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
+
+  return BackgroundSize;
+}(Declaration);
+
+_defineProperty(BackgroundSize, "names", ['background-size']);
+
+module.exports = BackgroundSize;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/block-logical.js b/node_modules/autoprefixer/lib/hacks/block-logical.js
new file mode 100644
index 0000000..e89ab81
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/block-logical.js
@@ -0,0 +1,50 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var BlockLogical =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(BlockLogical, _Declaration);
+
+  function BlockLogical() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = BlockLogical.prototype;
+
+  /**
+   * Use old syntax for -moz- and -webkit-
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    if (prop.indexOf('-start') !== -1) {
+      return prefix + prop.replace('-block-start', '-before');
+    }
+
+    return prefix + prop.replace('-block-end', '-after');
+  }
+  /**
+   * Return property name by spec
+   */
+  ;
+
+  _proto.normalize = function normalize(prop) {
+    if (prop.indexOf('-before') !== -1) {
+      return prop.replace('-before', '-block-start');
+    }
+
+    return prop.replace('-after', '-block-end');
+  };
+
+  return BlockLogical;
+}(Declaration);
+
+_defineProperty(BlockLogical, "names", ['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', 'border-before', 'border-after', 'margin-before', 'margin-after', 'padding-before', 'padding-after']);
+
+module.exports = BlockLogical;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/border-image.js b/node_modules/autoprefixer/lib/hacks/border-image.js
new file mode 100644
index 0000000..aebd64a
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/border-image.js
@@ -0,0 +1,35 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var BorderImage =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(BorderImage, _Declaration);
+
+  function BorderImage() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = BorderImage.prototype;
+
+  /**
+   * Remove fill parameter for prefixed declarations
+   */
+  _proto.set = function set(decl, prefix) {
+    decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
+
+  return BorderImage;
+}(Declaration);
+
+_defineProperty(BorderImage, "names", ['border-image']);
+
+module.exports = BorderImage;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/border-radius.js b/node_modules/autoprefixer/lib/hacks/border-radius.js
new file mode 100644
index 0000000..3bd42fc
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/border-radius.js
@@ -0,0 +1,64 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var BorderRadius =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(BorderRadius, _Declaration);
+
+  function BorderRadius() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = BorderRadius.prototype;
+
+  /**
+   * Change syntax, when add Mozilla prefix
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    if (prefix === '-moz-') {
+      return prefix + (BorderRadius.toMozilla[prop] || prop);
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Return unprefixed version of property
+   */
+  ;
+
+  _proto.normalize = function normalize(prop) {
+    return BorderRadius.toNormal[prop] || prop;
+  };
+
+  return BorderRadius;
+}(Declaration);
+
+_defineProperty(BorderRadius, "names", ['border-radius']);
+
+_defineProperty(BorderRadius, "toMozilla", {});
+
+_defineProperty(BorderRadius, "toNormal", {});
+
+for (var _i = 0, _arr = ['top', 'bottom']; _i < _arr.length; _i++) {
+  var ver = _arr[_i];
+
+  for (var _i2 = 0, _arr2 = ['left', 'right']; _i2 < _arr2.length; _i2++) {
+    var hor = _arr2[_i2];
+    var normal = "border-" + ver + "-" + hor + "-radius";
+    var mozilla = "border-radius-" + ver + hor;
+    BorderRadius.names.push(normal);
+    BorderRadius.names.push(mozilla);
+    BorderRadius.toMozilla[normal] = mozilla;
+    BorderRadius.toNormal[mozilla] = normal;
+  }
+}
+
+module.exports = BorderRadius;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/break-props.js b/node_modules/autoprefixer/lib/hacks/break-props.js
new file mode 100644
index 0000000..7433035
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/break-props.js
@@ -0,0 +1,78 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var BreakProps =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(BreakProps, _Declaration);
+
+  function BreakProps() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = BreakProps.prototype;
+
+  /**
+   * Change name for -webkit- and -moz- prefix
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    return prefix + "column-" + prop;
+  }
+  /**
+   * Return property name by final spec
+   */
+  ;
+
+  _proto.normalize = function normalize(prop) {
+    if (prop.indexOf('inside') !== -1) {
+      return 'break-inside';
+    }
+
+    if (prop.indexOf('before') !== -1) {
+      return 'break-before';
+    }
+
+    return 'break-after';
+  }
+  /**
+   * Change prefixed value for avoid-column and avoid-page
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    if (decl.prop === 'break-inside' && decl.value === 'avoid-column' || decl.value === 'avoid-page') {
+      decl.value = 'avoid';
+    }
+
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  }
+  /**
+   * Don’t prefix some values
+   */
+  ;
+
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    if (decl.prop !== 'break-inside') {
+      return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    }
+
+    if (/region/i.test(decl.value) || /page/i.test(decl.value)) {
+      return undefined;
+    }
+
+    return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+  };
+
+  return BreakProps;
+}(Declaration);
+
+_defineProperty(BreakProps, "names", ['break-inside', 'page-break-inside', 'column-break-inside', 'break-before', 'page-break-before', 'column-break-before', 'break-after', 'page-break-after', 'column-break-after']);
+
+module.exports = BreakProps;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/color-adjust.js b/node_modules/autoprefixer/lib/hacks/color-adjust.js
new file mode 100644
index 0000000..70f332d
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/color-adjust.js
@@ -0,0 +1,42 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var ColorAdjust =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(ColorAdjust, _Declaration);
+
+  function ColorAdjust() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = ColorAdjust.prototype;
+
+  /**
+   * Change property name for WebKit-based browsers
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    return prefix + 'print-color-adjust';
+  }
+  /**
+   * Return property name by spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'color-adjust';
+  };
+
+  return ColorAdjust;
+}(Declaration);
+
+_defineProperty(ColorAdjust, "names", ['color-adjust', 'print-color-adjust']);
+
+module.exports = ColorAdjust;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/cross-fade.js b/node_modules/autoprefixer/lib/hacks/cross-fade.js
new file mode 100644
index 0000000..b1f0b6e
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/cross-fade.js
@@ -0,0 +1,56 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var list = require('postcss').list;
+
+var Value = require('../value');
+
+var CrossFade =
+/*#__PURE__*/
+function (_Value) {
+  _inheritsLoose(CrossFade, _Value);
+
+  function CrossFade() {
+    return _Value.apply(this, arguments) || this;
+  }
+
+  var _proto = CrossFade.prototype;
+
+  _proto.replace = function replace(string, prefix) {
+    var _this = this;
+
+    return list.space(string).map(function (value) {
+      if (value.slice(0, +_this.name.length + 1) !== _this.name + '(') {
+        return value;
+      }
+
+      var close = value.lastIndexOf(')');
+      var after = value.slice(close + 1);
+      var args = value.slice(_this.name.length + 1, close);
+
+      if (prefix === '-webkit-') {
+        var match = args.match(/\d*.?\d+%?/);
+
+        if (match) {
+          args = args.slice(match[0].length).trim();
+          args += ", " + match[0];
+        } else {
+          args += ', 0.5';
+        }
+      }
+
+      return prefix + _this.name + '(' + args + ')' + after;
+    }).join(' ');
+  };
+
+  return CrossFade;
+}(Value);
+
+_defineProperty(CrossFade, "names", ['cross-fade']);
+
+module.exports = CrossFade;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/display-flex.js b/node_modules/autoprefixer/lib/hacks/display-flex.js
new file mode 100644
index 0000000..1da30b3
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/display-flex.js
@@ -0,0 +1,96 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var OldValue = require('../old-value');
+
+var Value = require('../value');
+
+var DisplayFlex =
+/*#__PURE__*/
+function (_Value) {
+  _inheritsLoose(DisplayFlex, _Value);
+
+  function DisplayFlex(name, prefixes) {
+    var _this;
+
+    _this = _Value.call(this, name, prefixes) || this;
+
+    if (name === 'display-flex') {
+      _this.name = 'flex';
+    }
+
+    return _this;
+  }
+  /**
+   * Faster check for flex value
+   */
+
+
+  var _proto = DisplayFlex.prototype;
+
+  _proto.check = function check(decl) {
+    return decl.prop === 'display' && decl.value === this.name;
+  }
+  /**
+   * Return value by spec
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prefix) {
+    var spec, value;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2009) {
+      if (this.name === 'flex') {
+        value = 'box';
+      } else {
+        value = 'inline-box';
+      }
+    } else if (spec === 2012) {
+      if (this.name === 'flex') {
+        value = 'flexbox';
+      } else {
+        value = 'inline-flexbox';
+      }
+    } else if (spec === 'final') {
+      value = this.name;
+    }
+
+    return prefix + value;
+  }
+  /**
+   * Add prefix to value depend on flebox spec version
+   */
+  ;
+
+  _proto.replace = function replace(string, prefix) {
+    return this.prefixed(prefix);
+  }
+  /**
+   * Change value for old specs
+   */
+  ;
+
+  _proto.old = function old(prefix) {
+    var prefixed = this.prefixed(prefix);
+    if (!prefixed) return undefined;
+    return new OldValue(this.name, prefixed);
+  };
+
+  return DisplayFlex;
+}(Value);
+
+_defineProperty(DisplayFlex, "names", ['display-flex', 'inline-flex']);
+
+module.exports = DisplayFlex;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/display-grid.js b/node_modules/autoprefixer/lib/hacks/display-grid.js
new file mode 100644
index 0000000..bc63bf8
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/display-grid.js
@@ -0,0 +1,43 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Value = require('../value');
+
+var DisplayGrid =
+/*#__PURE__*/
+function (_Value) {
+  _inheritsLoose(DisplayGrid, _Value);
+
+  function DisplayGrid(name, prefixes) {
+    var _this;
+
+    _this = _Value.call(this, name, prefixes) || this;
+
+    if (name === 'display-grid') {
+      _this.name = 'grid';
+    }
+
+    return _this;
+  }
+  /**
+   * Faster check for flex value
+   */
+
+
+  var _proto = DisplayGrid.prototype;
+
+  _proto.check = function check(decl) {
+    return decl.prop === 'display' && decl.value === this.name;
+  };
+
+  return DisplayGrid;
+}(Value);
+
+_defineProperty(DisplayGrid, "names", ['display-grid', 'inline-grid']);
+
+module.exports = DisplayGrid;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/filter-value.js b/node_modules/autoprefixer/lib/hacks/filter-value.js
new file mode 100644
index 0000000..c4c6416
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/filter-value.js
@@ -0,0 +1,33 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Value = require('../value');
+
+var FilterValue =
+/*#__PURE__*/
+function (_Value) {
+  _inheritsLoose(FilterValue, _Value);
+
+  function FilterValue(name, prefixes) {
+    var _this;
+
+    _this = _Value.call(this, name, prefixes) || this;
+
+    if (name === 'filter-function') {
+      _this.name = 'filter';
+    }
+
+    return _this;
+  }
+
+  return FilterValue;
+}(Value);
+
+_defineProperty(FilterValue, "names", ['filter', 'filter-function']);
+
+module.exports = FilterValue;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/filter.js b/node_modules/autoprefixer/lib/hacks/filter.js
new file mode 100644
index 0000000..9d44404
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/filter.js
@@ -0,0 +1,35 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var Filter =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(Filter, _Declaration);
+
+  function Filter() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = Filter.prototype;
+
+  /**
+   * Check is it Internet Explorer filter
+   */
+  _proto.check = function check(decl) {
+    var v = decl.value;
+    return v.toLowerCase().indexOf('alpha(') === -1 && v.indexOf('DXImageTransform.Microsoft') === -1 && v.indexOf('data:image/svg+xml') === -1;
+  };
+
+  return Filter;
+}(Declaration);
+
+_defineProperty(Filter, "names", ['filter']);
+
+module.exports = Filter;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/flex-basis.js b/node_modules/autoprefixer/lib/hacks/flex-basis.js
new file mode 100644
index 0000000..351d61d
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/flex-basis.js
@@ -0,0 +1,74 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var FlexBasis =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(FlexBasis, _Declaration);
+
+  function FlexBasis() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = FlexBasis.prototype;
+
+  /**
+   * Return property name by final spec
+   */
+  _proto.normalize = function normalize() {
+    return 'flex-basis';
+  }
+  /**
+   * Return flex property for 2012 spec
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2012) {
+      return prefix + 'flex-preferred-size';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Ignore 2009 spec and use flex property for 2012
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    var spec;
+
+    var _flexSpec2 = flexSpec(prefix);
+
+    spec = _flexSpec2[0];
+    prefix = _flexSpec2[1];
+
+    if (spec === 2012 || spec === 'final') {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    return undefined;
+  };
+
+  return FlexBasis;
+}(Declaration);
+
+_defineProperty(FlexBasis, "names", ['flex-basis', 'flex-preferred-size']);
+
+module.exports = FlexBasis;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/flex-direction.js b/node_modules/autoprefixer/lib/hacks/flex-direction.js
new file mode 100644
index 0000000..bac62af
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/flex-direction.js
@@ -0,0 +1,110 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var FlexDirection =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(FlexDirection, _Declaration);
+
+  function FlexDirection() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = FlexDirection.prototype;
+
+  /**
+   * Return property name by final spec
+   */
+  _proto.normalize = function normalize() {
+    return 'flex-direction';
+  }
+  /**
+   * Use two properties for 2009 spec
+   */
+  ;
+
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec !== 2009) {
+      return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    }
+
+    var already = decl.parent.some(function (i) {
+      return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction';
+    });
+
+    if (already) {
+      return undefined;
+    }
+
+    var v = decl.value;
+    var orient, dir;
+
+    if (v === 'inherit' || v === 'initial' || v === 'unset') {
+      orient = v;
+      dir = v;
+    } else {
+      orient = v.indexOf('row') !== -1 ? 'horizontal' : 'vertical';
+      dir = v.indexOf('reverse') !== -1 ? 'reverse' : 'normal';
+    }
+
+    var cloned = this.clone(decl);
+    cloned.prop = prefix + 'box-orient';
+    cloned.value = orient;
+
+    if (this.needCascade(decl)) {
+      cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+    }
+
+    decl.parent.insertBefore(decl, cloned);
+    cloned = this.clone(decl);
+    cloned.prop = prefix + 'box-direction';
+    cloned.value = dir;
+
+    if (this.needCascade(decl)) {
+      cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+    }
+
+    return decl.parent.insertBefore(decl, cloned);
+  }
+  /**
+   * Clean two properties for 2009 spec
+   */
+  ;
+
+  _proto.old = function old(prop, prefix) {
+    var spec;
+
+    var _flexSpec2 = flexSpec(prefix);
+
+    spec = _flexSpec2[0];
+    prefix = _flexSpec2[1];
+
+    if (spec === 2009) {
+      return [prefix + 'box-orient', prefix + 'box-direction'];
+    } else {
+      return _Declaration.prototype.old.call(this, prop, prefix);
+    }
+  };
+
+  return FlexDirection;
+}(Declaration);
+
+_defineProperty(FlexDirection, "names", ['flex-direction', 'box-direction', 'box-orient']);
+
+module.exports = FlexDirection;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/flex-flow.js b/node_modules/autoprefixer/lib/hacks/flex-flow.js
new file mode 100644
index 0000000..23eba4d
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/flex-flow.js
@@ -0,0 +1,83 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var FlexFlow =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(FlexFlow, _Declaration);
+
+  function FlexFlow() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = FlexFlow.prototype;
+
+  /**
+   * Use two properties for 2009 spec
+   */
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec !== 2009) {
+      return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    }
+
+    var values = decl.value.split(/\s+/).filter(function (i) {
+      return i !== 'wrap' && i !== 'nowrap' && 'wrap-reverse';
+    });
+
+    if (values.length === 0) {
+      return undefined;
+    }
+
+    var already = decl.parent.some(function (i) {
+      return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction';
+    });
+
+    if (already) {
+      return undefined;
+    }
+
+    var value = values[0];
+    var orient = value.indexOf('row') !== -1 ? 'horizontal' : 'vertical';
+    var dir = value.indexOf('reverse') !== -1 ? 'reverse' : 'normal';
+    var cloned = this.clone(decl);
+    cloned.prop = prefix + 'box-orient';
+    cloned.value = orient;
+
+    if (this.needCascade(decl)) {
+      cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+    }
+
+    decl.parent.insertBefore(decl, cloned);
+    cloned = this.clone(decl);
+    cloned.prop = prefix + 'box-direction';
+    cloned.value = dir;
+
+    if (this.needCascade(decl)) {
+      cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+    }
+
+    return decl.parent.insertBefore(decl, cloned);
+  };
+
+  return FlexFlow;
+}(Declaration);
+
+_defineProperty(FlexFlow, "names", ['flex-flow', 'box-direction', 'box-orient']);
+
+module.exports = FlexFlow;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/flex-grow.js b/node_modules/autoprefixer/lib/hacks/flex-grow.js
new file mode 100644
index 0000000..09278a2
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/flex-grow.js
@@ -0,0 +1,59 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var Flex =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(Flex, _Declaration);
+
+  function Flex() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = Flex.prototype;
+
+  /**
+   * Return property name by final spec
+   */
+  _proto.normalize = function normalize() {
+    return 'flex';
+  }
+  /**
+   * Return flex property for 2009 and 2012 specs
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2009) {
+      return prefix + 'box-flex';
+    }
+
+    if (spec === 2012) {
+      return prefix + 'flex-positive';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  };
+
+  return Flex;
+}(Declaration);
+
+_defineProperty(Flex, "names", ['flex-grow', 'flex-positive']);
+
+module.exports = Flex;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/flex-shrink.js b/node_modules/autoprefixer/lib/hacks/flex-shrink.js
new file mode 100644
index 0000000..cab835c
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/flex-shrink.js
@@ -0,0 +1,74 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var FlexShrink =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(FlexShrink, _Declaration);
+
+  function FlexShrink() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = FlexShrink.prototype;
+
+  /**
+   * Return property name by final spec
+   */
+  _proto.normalize = function normalize() {
+    return 'flex-shrink';
+  }
+  /**
+   * Return flex property for 2012 spec
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2012) {
+      return prefix + 'flex-negative';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Ignore 2009 spec and use flex property for 2012
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    var spec;
+
+    var _flexSpec2 = flexSpec(prefix);
+
+    spec = _flexSpec2[0];
+    prefix = _flexSpec2[1];
+
+    if (spec === 2012 || spec === 'final') {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    return undefined;
+  };
+
+  return FlexShrink;
+}(Declaration);
+
+_defineProperty(FlexShrink, "names", ['flex-shrink', 'flex-negative']);
+
+module.exports = FlexShrink;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/flex-spec.js b/node_modules/autoprefixer/lib/hacks/flex-spec.js
new file mode 100644
index 0000000..d73027a
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/flex-spec.js
@@ -0,0 +1,22 @@
+"use strict";
+
+/**
+ * Return flexbox spec versions by prefix
+ */
+module.exports = function (prefix) {
+  var spec;
+
+  if (prefix === '-webkit- 2009' || prefix === '-moz-') {
+    spec = 2009;
+  } else if (prefix === '-ms-') {
+    spec = 2012;
+  } else if (prefix === '-webkit-') {
+    spec = 'final';
+  }
+
+  if (prefix === '-webkit- 2009') {
+    prefix = '-webkit-';
+  }
+
+  return [spec, prefix];
+};
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/flex-wrap.js b/node_modules/autoprefixer/lib/hacks/flex-wrap.js
new file mode 100644
index 0000000..841eb62
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/flex-wrap.js
@@ -0,0 +1,42 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var FlexWrap =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(FlexWrap, _Declaration);
+
+  function FlexWrap() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = FlexWrap.prototype;
+
+  /**
+   * Don't add prefix for 2009 spec
+   */
+  _proto.set = function set(decl, prefix) {
+    var spec = flexSpec(prefix)[0];
+
+    if (spec !== 2009) {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    return undefined;
+  };
+
+  return FlexWrap;
+}(Declaration);
+
+_defineProperty(FlexWrap, "names", ['flex-wrap']);
+
+module.exports = FlexWrap;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/flex.js b/node_modules/autoprefixer/lib/hacks/flex.js
new file mode 100644
index 0000000..44c9e1e
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/flex.js
@@ -0,0 +1,87 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var list = require('postcss').list;
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var Flex =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(Flex, _Declaration);
+
+  function Flex() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = Flex.prototype;
+
+  /**
+   * Change property name for 2009 spec
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2009) {
+      return prefix + 'box-flex';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Return property name by final spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'flex';
+  }
+  /**
+   * Spec 2009 supports only first argument
+   * Spec 2012 disallows unitless basis
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    var spec = flexSpec(prefix)[0];
+
+    if (spec === 2009) {
+      decl.value = list.space(decl.value)[0];
+      decl.value = Flex.oldValues[decl.value] || decl.value;
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    if (spec === 2012) {
+      var components = list.space(decl.value);
+
+      if (components.length === 3 && components[2] === '0') {
+        decl.value = components.slice(0, 2).concat('0px').join(' ');
+      }
+    }
+
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
+
+  return Flex;
+}(Declaration);
+
+_defineProperty(Flex, "names", ['flex', 'box-flex']);
+
+_defineProperty(Flex, "oldValues", {
+  auto: '1',
+  none: '0'
+});
+
+module.exports = Flex;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/fullscreen.js b/node_modules/autoprefixer/lib/hacks/fullscreen.js
new file mode 100644
index 0000000..fae1849
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/fullscreen.js
@@ -0,0 +1,42 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Selector = require('../selector');
+
+var Fullscreen =
+/*#__PURE__*/
+function (_Selector) {
+  _inheritsLoose(Fullscreen, _Selector);
+
+  function Fullscreen() {
+    return _Selector.apply(this, arguments) || this;
+  }
+
+  var _proto = Fullscreen.prototype;
+
+  /**
+   * Return different selectors depend on prefix
+   */
+  _proto.prefixed = function prefixed(prefix) {
+    if (prefix === '-webkit-') {
+      return ':-webkit-full-screen';
+    }
+
+    if (prefix === '-moz-') {
+      return ':-moz-full-screen';
+    }
+
+    return ":" + prefix + "fullscreen";
+  };
+
+  return Fullscreen;
+}(Selector);
+
+_defineProperty(Fullscreen, "names", [':fullscreen']);
+
+module.exports = Fullscreen;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/gradient.js b/node_modules/autoprefixer/lib/hacks/gradient.js
new file mode 100644
index 0000000..c1cc747
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/gradient.js
@@ -0,0 +1,581 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var parser = require('postcss-value-parser');
+
+var range = require('normalize-range');
+
+var OldValue = require('../old-value');
+
+var Value = require('../value');
+
+var utils = require('../utils');
+
+var IS_DIRECTION = /top|left|right|bottom/gi;
+
+var Gradient =
+/*#__PURE__*/
+function (_Value) {
+  _inheritsLoose(Gradient, _Value);
+
+  function Gradient() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _Value.call.apply(_Value, [this].concat(args)) || this;
+
+    _defineProperty(_assertThisInitialized(_this), "directions", {
+      top: 'bottom',
+      left: 'right',
+      bottom: 'top',
+      right: 'left'
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "oldDirections", {
+      'top': 'left bottom, left top',
+      'left': 'right top, left top',
+      'bottom': 'left top, left bottom',
+      'right': 'left top, right top',
+      'top right': 'left bottom, right top',
+      'top left': 'right bottom, left top',
+      'right top': 'left bottom, right top',
+      'right bottom': 'left top, right bottom',
+      'bottom right': 'left top, right bottom',
+      'bottom left': 'right top, left bottom',
+      'left top': 'right bottom, left top',
+      'left bottom': 'right top, left bottom'
+    });
+
+    return _this;
+  }
+
+  var _proto = Gradient.prototype;
+
+  /**
+   * Change degrees for webkit prefix
+   */
+  _proto.replace = function replace(string, prefix) {
+    var ast = parser(string);
+
+    for (var _iterator = ast.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 node = _ref;
+
+      if (node.type === 'function' && node.value === this.name) {
+        node.nodes = this.newDirection(node.nodes);
+        node.nodes = this.normalize(node.nodes);
+
+        if (prefix === '-webkit- old') {
+          var changes = this.oldWebkit(node);
+
+          if (!changes) {
+            return false;
+          }
+        } else {
+          node.nodes = this.convertDirection(node.nodes);
+          node.value = prefix + node.value;
+        }
+      }
+    }
+
+    return ast.toString();
+  }
+  /**
+   * Replace first token
+   */
+  ;
+
+  _proto.replaceFirst = function replaceFirst(params) {
+    for (var _len2 = arguments.length, words = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      words[_key2 - 1] = arguments[_key2];
+    }
+
+    var prefix = words.map(function (i) {
+      if (i === ' ') {
+        return {
+          type: 'space',
+          value: i
+        };
+      }
+
+      return {
+        type: 'word',
+        value: i
+      };
+    });
+    return prefix.concat(params.slice(1));
+  }
+  /**
+   * Convert angle unit to deg
+   */
+  ;
+
+  _proto.normalizeUnit = function normalizeUnit(str, full) {
+    var num = parseFloat(str);
+    var deg = num / full * 360;
+    return deg + "deg";
+  }
+  /**
+   * Normalize angle
+   */
+  ;
+
+  _proto.normalize = function normalize(nodes) {
+    if (!nodes[0]) return nodes;
+
+    if (/-?\d+(.\d+)?grad/.test(nodes[0].value)) {
+      nodes[0].value = this.normalizeUnit(nodes[0].value, 400);
+    } else if (/-?\d+(.\d+)?rad/.test(nodes[0].value)) {
+      nodes[0].value = this.normalizeUnit(nodes[0].value, 2 * Math.PI);
+    } else if (/-?\d+(.\d+)?turn/.test(nodes[0].value)) {
+      nodes[0].value = this.normalizeUnit(nodes[0].value, 1);
+    } else if (nodes[0].value.indexOf('deg') !== -1) {
+      var num = parseFloat(nodes[0].value);
+      num = range.wrap(0, 360, num);
+      nodes[0].value = num + "deg";
+    }
+
+    if (nodes[0].value === '0deg') {
+      nodes = this.replaceFirst(nodes, 'to', ' ', 'top');
+    } else if (nodes[0].value === '90deg') {
+      nodes = this.replaceFirst(nodes, 'to', ' ', 'right');
+    } else if (nodes[0].value === '180deg') {
+      nodes = this.replaceFirst(nodes, 'to', ' ', 'bottom');
+    } else if (nodes[0].value === '270deg') {
+      nodes = this.replaceFirst(nodes, 'to', ' ', 'left');
+    }
+
+    return nodes;
+  }
+  /**
+   * Replace old direction to new
+   */
+  ;
+
+  _proto.newDirection = function newDirection(params) {
+    if (params[0].value === 'to') {
+      return params;
+    }
+
+    IS_DIRECTION.lastIndex = 0; // reset search index of global regexp
+
+    if (!IS_DIRECTION.test(params[0].value)) {
+      return params;
+    }
+
+    params.unshift({
+      type: 'word',
+      value: 'to'
+    }, {
+      type: 'space',
+      value: ' '
+    });
+
+    for (var i = 2; i < params.length; i++) {
+      if (params[i].type === 'div') {
+        break;
+      }
+
+      if (params[i].type === 'word') {
+        params[i].value = this.revertDirection(params[i].value);
+      }
+    }
+
+    return params;
+  }
+  /**
+   * Look for at word
+   */
+  ;
+
+  _proto.isRadial = function isRadial(params) {
+    var state = 'before';
+
+    for (var _iterator2 = params, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      var param = _ref2;
+
+      if (state === 'before' && param.type === 'space') {
+        state = 'at';
+      } else if (state === 'at' && param.value === 'at') {
+        state = 'after';
+      } else if (state === 'after' && param.type === 'space') {
+        return true;
+      } else if (param.type === 'div') {
+        break;
+      } else {
+        state = 'before';
+      }
+    }
+
+    return false;
+  }
+  /**
+   * Change new direction to old
+   */
+  ;
+
+  _proto.convertDirection = function convertDirection(params) {
+    if (params.length > 0) {
+      if (params[0].value === 'to') {
+        this.fixDirection(params);
+      } else if (params[0].value.indexOf('deg') !== -1) {
+        this.fixAngle(params);
+      } else if (this.isRadial(params)) {
+        this.fixRadial(params);
+      }
+    }
+
+    return params;
+  }
+  /**
+   * Replace `to top left` to `bottom right`
+   */
+  ;
+
+  _proto.fixDirection = function fixDirection(params) {
+    params.splice(0, 2);
+
+    for (var _iterator3 = params, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+      var _ref3;
+
+      if (_isArray3) {
+        if (_i3 >= _iterator3.length) break;
+        _ref3 = _iterator3[_i3++];
+      } else {
+        _i3 = _iterator3.next();
+        if (_i3.done) break;
+        _ref3 = _i3.value;
+      }
+
+      var param = _ref3;
+
+      if (param.type === 'div') {
+        break;
+      }
+
+      if (param.type === 'word') {
+        param.value = this.revertDirection(param.value);
+      }
+    }
+  }
+  /**
+   * Add 90 degrees
+   */
+  ;
+
+  _proto.fixAngle = function fixAngle(params) {
+    var first = params[0].value;
+    first = parseFloat(first);
+    first = Math.abs(450 - first) % 360;
+    first = this.roundFloat(first, 3);
+    params[0].value = first + "deg";
+  }
+  /**
+   * Fix radial direction syntax
+   */
+  ;
+
+  _proto.fixRadial = function fixRadial(params) {
+    var first = [];
+    var second = [];
+    var a, b, c, i, next;
+
+    for (i = 0; i < params.length - 2; i++) {
+      a = params[i];
+      b = params[i + 1];
+      c = params[i + 2];
+
+      if (a.type === 'space' && b.value === 'at' && c.type === 'space') {
+        next = i + 3;
+        break;
+      } else {
+        first.push(a);
+      }
+    }
+
+    var div;
+
+    for (i = next; i < params.length; i++) {
+      if (params[i].type === 'div') {
+        div = params[i];
+        break;
+      } else {
+        second.push(params[i]);
+      }
+    }
+
+    params.splice.apply(params, [0, i].concat(second, [div], first));
+  };
+
+  _proto.revertDirection = function revertDirection(word) {
+    return this.directions[word.toLowerCase()] || word;
+  }
+  /**
+   * Round float and save digits under dot
+   */
+  ;
+
+  _proto.roundFloat = function roundFloat(_float, digits) {
+    return parseFloat(_float.toFixed(digits));
+  }
+  /**
+   * Convert to old webkit syntax
+   */
+  ;
+
+  _proto.oldWebkit = function oldWebkit(node) {
+    var nodes = node.nodes;
+    var string = parser.stringify(node.nodes);
+
+    if (this.name !== 'linear-gradient') {
+      return false;
+    }
+
+    if (nodes[0] && nodes[0].value.indexOf('deg') !== -1) {
+      return false;
+    }
+
+    if (string.indexOf('px') !== -1 || string.indexOf('-corner') !== -1 || string.indexOf('-side') !== -1) {
+      return false;
+    }
+
+    var params = [[]];
+
+    for (var _iterator4 = nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+      var _ref4;
+
+      if (_isArray4) {
+        if (_i4 >= _iterator4.length) break;
+        _ref4 = _iterator4[_i4++];
+      } else {
+        _i4 = _iterator4.next();
+        if (_i4.done) break;
+        _ref4 = _i4.value;
+      }
+
+      var i = _ref4;
+      params[params.length - 1].push(i);
+
+      if (i.type === 'div' && i.value === ',') {
+        params.push([]);
+      }
+    }
+
+    this.oldDirection(params);
+    this.colorStops(params);
+    node.nodes = [];
+
+    for (var _i5 = 0, _params = params; _i5 < _params.length; _i5++) {
+      var param = _params[_i5];
+      node.nodes = node.nodes.concat(param);
+    }
+
+    node.nodes.unshift({
+      type: 'word',
+      value: 'linear'
+    }, this.cloneDiv(node.nodes));
+    node.value = '-webkit-gradient';
+    return true;
+  }
+  /**
+   * Change direction syntax to old webkit
+   */
+  ;
+
+  _proto.oldDirection = function oldDirection(params) {
+    var div = this.cloneDiv(params[0]);
+
+    if (params[0][0].value !== 'to') {
+      return params.unshift([{
+        type: 'word',
+        value: this.oldDirections.bottom
+      }, div]);
+    } else {
+      var words = [];
+
+      for (var _iterator5 = params[0].slice(2), _isArray5 = Array.isArray(_iterator5), _i6 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+        var _ref5;
+
+        if (_isArray5) {
+          if (_i6 >= _iterator5.length) break;
+          _ref5 = _iterator5[_i6++];
+        } else {
+          _i6 = _iterator5.next();
+          if (_i6.done) break;
+          _ref5 = _i6.value;
+        }
+
+        var node = _ref5;
+
+        if (node.type === 'word') {
+          words.push(node.value.toLowerCase());
+        }
+      }
+
+      words = words.join(' ');
+      var old = this.oldDirections[words] || words;
+      params[0] = [{
+        type: 'word',
+        value: old
+      }, div];
+      return params[0];
+    }
+  }
+  /**
+   * Get div token from exists parameters
+   */
+  ;
+
+  _proto.cloneDiv = function cloneDiv(params) {
+    for (var _iterator6 = params, _isArray6 = Array.isArray(_iterator6), _i7 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
+      var _ref6;
+
+      if (_isArray6) {
+        if (_i7 >= _iterator6.length) break;
+        _ref6 = _iterator6[_i7++];
+      } else {
+        _i7 = _iterator6.next();
+        if (_i7.done) break;
+        _ref6 = _i7.value;
+      }
+
+      var i = _ref6;
+
+      if (i.type === 'div' && i.value === ',') {
+        return i;
+      }
+    }
+
+    return {
+      type: 'div',
+      value: ',',
+      after: ' '
+    };
+  }
+  /**
+   * Change colors syntax to old webkit
+   */
+  ;
+
+  _proto.colorStops = function colorStops(params) {
+    var result = [];
+
+    for (var i = 0; i < params.length; i++) {
+      var pos = void 0;
+      var param = params[i];
+      var item = void 0;
+
+      if (i === 0) {
+        continue;
+      }
+
+      var color = parser.stringify(param[0]);
+
+      if (param[1] && param[1].type === 'word') {
+        pos = param[1].value;
+      } else if (param[2] && param[2].type === 'word') {
+        pos = param[2].value;
+      }
+
+      var stop = void 0;
+
+      if (i === 1 && (!pos || pos === '0%')) {
+        stop = "from(" + color + ")";
+      } else if (i === params.length - 1 && (!pos || pos === '100%')) {
+        stop = "to(" + color + ")";
+      } else if (pos) {
+        stop = "color-stop(" + pos + ", " + color + ")";
+      } else {
+        stop = "color-stop(" + color + ")";
+      }
+
+      var div = param[param.length - 1];
+      params[i] = [{
+        type: 'word',
+        value: stop
+      }];
+
+      if (div.type === 'div' && div.value === ',') {
+        item = params[i].push(div);
+      }
+
+      result.push(item);
+    }
+
+    return result;
+  }
+  /**
+   * Remove old WebKit gradient too
+   */
+  ;
+
+  _proto.old = function old(prefix) {
+    if (prefix === '-webkit-') {
+      var type = this.name === 'linear-gradient' ? 'linear' : 'radial';
+      var string = '-gradient';
+      var regexp = utils.regexp("-webkit-(" + type + "-gradient|gradient\\(\\s*" + type + ")", false);
+      return new OldValue(this.name, prefix + this.name, string, regexp);
+    } else {
+      return _Value.prototype.old.call(this, prefix);
+    }
+  }
+  /**
+   * Do not add non-webkit prefixes for list-style and object
+   */
+  ;
+
+  _proto.add = function add(decl, prefix) {
+    var p = decl.prop;
+
+    if (p.indexOf('mask') !== -1) {
+      if (prefix === '-webkit-' || prefix === '-webkit- old') {
+        return _Value.prototype.add.call(this, decl, prefix);
+      }
+    } else if (p === 'list-style' || p === 'list-style-image' || p === 'content') {
+      if (prefix === '-webkit-' || prefix === '-webkit- old') {
+        return _Value.prototype.add.call(this, decl, prefix);
+      }
+    } else {
+      return _Value.prototype.add.call(this, decl, prefix);
+    }
+
+    return undefined;
+  };
+
+  return Gradient;
+}(Value);
+
+_defineProperty(Gradient, "names", ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient']);
+
+module.exports = Gradient;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-area.js b/node_modules/autoprefixer/lib/hacks/grid-area.js
new file mode 100644
index 0000000..8c1b39c
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-area.js
@@ -0,0 +1,54 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var utils = require('./grid-utils');
+
+var GridArea =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(GridArea, _Declaration);
+
+  function GridArea() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = GridArea.prototype;
+
+  /**
+   * Translate grid-area to separate -ms- prefixed properties
+   */
+  _proto.insert = function insert(decl, prefix, prefixes, result) {
+    if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    var values = utils.parse(decl);
+
+    var _utils$translate = utils.translate(values, 0, 2),
+        rowStart = _utils$translate[0],
+        rowSpan = _utils$translate[1];
+
+    var _utils$translate2 = utils.translate(values, 1, 3),
+        columnStart = _utils$translate2[0],
+        columnSpan = _utils$translate2[1];
+
+    [['grid-row', rowStart], ['grid-row-span', rowSpan], ['grid-column', columnStart], ['grid-column-span', columnSpan]].forEach(function (_ref) {
+      var prop = _ref[0],
+          value = _ref[1];
+      utils.insertDecl(decl, prop, value);
+    });
+    utils.warnTemplateSelectorNotFound(decl, result);
+    utils.warnIfGridRowColumnExists(decl, result);
+    return undefined;
+  };
+
+  return GridArea;
+}(Declaration);
+
+_defineProperty(GridArea, "names", ['grid-area']);
+
+module.exports = GridArea;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-column-align.js b/node_modules/autoprefixer/lib/hacks/grid-column-align.js
new file mode 100644
index 0000000..c69efb5
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-column-align.js
@@ -0,0 +1,50 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var GridColumnAlign =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(GridColumnAlign, _Declaration);
+
+  function GridColumnAlign() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = GridColumnAlign.prototype;
+
+  /**
+   * Do not prefix flexbox values
+   */
+  _proto.check = function check(decl) {
+    return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline';
+  }
+  /**
+   * Change property name for IE
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    return prefix + 'grid-column-align';
+  }
+  /**
+   * Change IE property back
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'justify-self';
+  };
+
+  return GridColumnAlign;
+}(Declaration);
+
+_defineProperty(GridColumnAlign, "names", ['grid-column-align']);
+
+module.exports = GridColumnAlign;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-end.js b/node_modules/autoprefixer/lib/hacks/grid-end.js
new file mode 100644
index 0000000..d13c7b8
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-end.js
@@ -0,0 +1,64 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var GridEnd =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(GridEnd, _Declaration);
+
+  function GridEnd() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = GridEnd.prototype;
+
+  /**
+   * Change repeating syntax for IE
+   */
+  _proto.insert = function insert(decl, prefix, prefixes, result) {
+    if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    var clonedDecl = this.clone(decl);
+    var startProp = decl.prop.replace(/end$/, 'start');
+    var spanProp = prefix + decl.prop.replace(/end$/, 'span');
+
+    if (decl.parent.some(function (i) {
+      return i.prop === spanProp;
+    })) {
+      return undefined;
+    }
+
+    clonedDecl.prop = spanProp;
+
+    if (decl.value.includes('span')) {
+      clonedDecl.value = decl.value.replace(/span\s/i, '');
+    } else {
+      var startDecl;
+      decl.parent.walkDecls(startProp, function (d) {
+        startDecl = d;
+      });
+
+      if (startDecl) {
+        var value = Number(decl.value) - Number(startDecl.value) + '';
+        clonedDecl.value = value;
+      } else {
+        decl.warn(result, "Can not prefix " + decl.prop + " (" + startProp + " is not found)");
+      }
+    }
+
+    decl.cloneBefore(clonedDecl);
+    return undefined;
+  };
+
+  return GridEnd;
+}(Declaration);
+
+_defineProperty(GridEnd, "names", ['grid-row-end', 'grid-column-end']);
+
+module.exports = GridEnd;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-row-align.js b/node_modules/autoprefixer/lib/hacks/grid-row-align.js
new file mode 100644
index 0000000..5d0e4dc
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-row-align.js
@@ -0,0 +1,50 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var GridRowAlign =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(GridRowAlign, _Declaration);
+
+  function GridRowAlign() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = GridRowAlign.prototype;
+
+  /**
+   * Do not prefix flexbox values
+   */
+  _proto.check = function check(decl) {
+    return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline';
+  }
+  /**
+   * Change property name for IE
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    return prefix + 'grid-row-align';
+  }
+  /**
+   * Change IE property back
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'align-self';
+  };
+
+  return GridRowAlign;
+}(Declaration);
+
+_defineProperty(GridRowAlign, "names", ['grid-row-align']);
+
+module.exports = GridRowAlign;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-row-column.js b/node_modules/autoprefixer/lib/hacks/grid-row-column.js
new file mode 100644
index 0000000..256f9d1
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-row-column.js
@@ -0,0 +1,54 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var utils = require('./grid-utils');
+
+var GridRowColumn =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(GridRowColumn, _Declaration);
+
+  function GridRowColumn() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = GridRowColumn.prototype;
+
+  /**
+   * Translate grid-row / grid-column to separate -ms- prefixed properties
+   */
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    var values = utils.parse(decl);
+
+    var _utils$translate = utils.translate(values, 0, 1),
+        start = _utils$translate[0],
+        span = _utils$translate[1];
+
+    var hasStartValueSpan = values[0] && values[0].includes('span');
+
+    if (hasStartValueSpan) {
+      span = values[0].join('').replace(/\D/g, '');
+    }
+
+    [[decl.prop, start], [decl.prop + "-span", span]].forEach(function (_ref) {
+      var prop = _ref[0],
+          value = _ref[1];
+      utils.insertDecl(decl, prop, value);
+    });
+    return undefined;
+  };
+
+  return GridRowColumn;
+}(Declaration);
+
+_defineProperty(GridRowColumn, "names", ['grid-row', 'grid-column']);
+
+module.exports = GridRowColumn;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-rows-columns.js b/node_modules/autoprefixer/lib/hacks/grid-rows-columns.js
new file mode 100644
index 0000000..edd1ee6
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-rows-columns.js
@@ -0,0 +1,149 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var _require = require('./grid-utils'),
+    prefixTrackProp = _require.prefixTrackProp,
+    prefixTrackValue = _require.prefixTrackValue,
+    autoplaceGridItems = _require.autoplaceGridItems,
+    getGridGap = _require.getGridGap,
+    inheritGridGap = _require.inheritGridGap;
+
+var Processor = require('../processor');
+
+var GridRowsColumns =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(GridRowsColumns, _Declaration);
+
+  function GridRowsColumns() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = GridRowsColumns.prototype;
+
+  /**
+   * Change property name for IE
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    if (prefix === '-ms-') {
+      return prefixTrackProp({
+        prop: prop,
+        prefix: prefix
+      });
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Change IE property back
+   */
+  ;
+
+  _proto.normalize = function normalize(prop) {
+    return prop.replace(/^grid-(rows|columns)/, 'grid-template-$1');
+  };
+
+  _proto.insert = function insert(decl, prefix, prefixes, result) {
+    if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    var parent = decl.parent,
+        prop = decl.prop,
+        value = decl.value;
+    var isRowProp = prop.includes('rows');
+    var isColumnProp = prop.includes('columns');
+    var hasGridTemplate = parent.some(function (i) {
+      return i.prop === 'grid-template' || i.prop === 'grid-template-areas';
+    });
+    /**
+     * Not to prefix rows declaration if grid-template(-areas) is present
+     */
+
+    if (hasGridTemplate && isRowProp) {
+      return false;
+    }
+
+    var processor = new Processor({});
+    var status = processor.gridStatus(parent, result);
+    var gap = getGridGap(decl);
+    gap = inheritGridGap(decl, gap) || gap;
+    var gapValue = isRowProp ? gap.row : gap.column;
+
+    if ((status === 'no-autoplace' || status === true) && !hasGridTemplate) {
+      gapValue = null;
+    }
+
+    var prefixValue = prefixTrackValue({
+      value: value,
+      gap: gapValue
+    });
+    /**
+     * Insert prefixes
+     */
+
+    decl.cloneBefore({
+      prop: prefixTrackProp({
+        prop: prop,
+        prefix: prefix
+      }),
+      value: prefixValue
+    });
+    var autoflow = parent.nodes.find(function (i) {
+      return i.prop === 'grid-auto-flow';
+    });
+    var autoflowValue = 'row';
+
+    if (autoflow && !processor.disabled(autoflow, result)) {
+      autoflowValue = autoflow.value.trim();
+    }
+
+    if (status === 'autoplace') {
+      /**
+       * Show warning if grid-template-rows decl is not found
+       */
+      var rowDecl = parent.nodes.find(function (i) {
+        return i.prop === 'grid-template-rows';
+      });
+
+      if (!rowDecl && hasGridTemplate) {
+        return undefined;
+      } else if (!rowDecl && !hasGridTemplate) {
+        decl.warn(result, "Autoplacement does not work without grid-template-rows property");
+        return undefined;
+      }
+      /**
+       * Show warning if grid-template-columns decl is not found
+       */
+
+
+      var columnDecl = parent.nodes.find(function (i) {
+        return i.prop === 'grid-template-columns';
+      });
+
+      if (!columnDecl && !hasGridTemplate) {
+        decl.warn(result, "Autoplacement does not work without grid-template-columns property");
+      }
+      /**
+       * Autoplace grid items
+       */
+
+
+      if (isColumnProp && !hasGridTemplate) {
+        autoplaceGridItems(decl, result, gap, autoflowValue);
+      }
+    }
+
+    return undefined;
+  };
+
+  return GridRowsColumns;
+}(Declaration);
+
+_defineProperty(GridRowsColumns, "names", ['grid-template-rows', 'grid-template-columns', 'grid-rows', 'grid-columns']);
+
+module.exports = GridRowsColumns;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-start.js b/node_modules/autoprefixer/lib/hacks/grid-start.js
new file mode 100644
index 0000000..dfbc68b
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-start.js
@@ -0,0 +1,57 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var GridStart =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(GridStart, _Declaration);
+
+  function GridStart() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = GridStart.prototype;
+
+  /**
+   * Do not add prefix for unsupported value in IE
+   */
+  _proto.check = function check(decl) {
+    var value = decl.value;
+    return value.indexOf('/') === -1 || value.indexOf('span') !== -1;
+  }
+  /**
+   * Return a final spec property
+   */
+  ;
+
+  _proto.normalize = function normalize(prop) {
+    return prop.replace('-start', '');
+  }
+  /**
+   * Change property name for IE
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var result = _Declaration.prototype.prefixed.call(this, prop, prefix);
+
+    if (prefix === '-ms-') {
+      result = result.replace('-start', '');
+    }
+
+    return result;
+  };
+
+  return GridStart;
+}(Declaration);
+
+_defineProperty(GridStart, "names", ['grid-row-start', 'grid-column-start']);
+
+module.exports = GridStart;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-template-areas.js b/node_modules/autoprefixer/lib/hacks/grid-template-areas.js
new file mode 100644
index 0000000..9da1685
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-template-areas.js
@@ -0,0 +1,103 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var _require = require('./grid-utils'),
+    parseGridAreas = _require.parseGridAreas,
+    warnMissedAreas = _require.warnMissedAreas,
+    prefixTrackProp = _require.prefixTrackProp,
+    prefixTrackValue = _require.prefixTrackValue,
+    getGridGap = _require.getGridGap,
+    warnGridGap = _require.warnGridGap,
+    inheritGridGap = _require.inheritGridGap;
+
+function getGridRows(tpl) {
+  return tpl.trim().slice(1, -1).split(/['"]\s*['"]?/g);
+}
+
+var GridTemplateAreas =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(GridTemplateAreas, _Declaration);
+
+  function GridTemplateAreas() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = GridTemplateAreas.prototype;
+
+  /**
+   * Translate grid-template-areas to separate -ms- prefixed properties
+   */
+  _proto.insert = function insert(decl, prefix, prefixes, result) {
+    if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    var hasColumns = false;
+    var hasRows = false;
+    var parent = decl.parent;
+    var gap = getGridGap(decl);
+    gap = inheritGridGap(decl, gap) || gap; // remove already prefixed rows
+    // to prevent doubling prefixes
+
+    parent.walkDecls(/-ms-grid-rows/, function (i) {
+      return i.remove();
+    }); // add empty tracks to rows
+
+    parent.walkDecls(/grid-template-(rows|columns)/, function (trackDecl) {
+      if (trackDecl.prop === 'grid-template-rows') {
+        hasRows = true;
+        var prop = trackDecl.prop,
+            value = trackDecl.value;
+        trackDecl.cloneBefore({
+          prop: prefixTrackProp({
+            prop: prop,
+            prefix: prefix
+          }),
+          value: prefixTrackValue({
+            value: value,
+            gap: gap.row
+          })
+        });
+      } else {
+        hasColumns = true;
+      }
+    });
+    var gridRows = getGridRows(decl.value);
+
+    if (hasColumns && !hasRows && gap.row && gridRows.length > 1) {
+      decl.cloneBefore({
+        prop: '-ms-grid-rows',
+        value: prefixTrackValue({
+          value: "repeat(" + gridRows.length + ", auto)",
+          gap: gap.row
+        }),
+        raws: {}
+      });
+    } // warnings
+
+
+    warnGridGap({
+      gap: gap,
+      hasColumns: hasColumns,
+      decl: decl,
+      result: result
+    });
+    var areas = parseGridAreas({
+      rows: gridRows,
+      gap: gap
+    });
+    warnMissedAreas(areas, decl, result);
+    return decl;
+  };
+
+  return GridTemplateAreas;
+}(Declaration);
+
+_defineProperty(GridTemplateAreas, "names", ['grid-template-areas']);
+
+module.exports = GridTemplateAreas;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-template.js b/node_modules/autoprefixer/lib/hacks/grid-template.js
new file mode 100644
index 0000000..88ce36b
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-template.js
@@ -0,0 +1,92 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var _require = require('./grid-utils'),
+    parseTemplate = _require.parseTemplate,
+    warnMissedAreas = _require.warnMissedAreas,
+    getGridGap = _require.getGridGap,
+    warnGridGap = _require.warnGridGap,
+    inheritGridGap = _require.inheritGridGap;
+
+var GridTemplate =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(GridTemplate, _Declaration);
+
+  function GridTemplate() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = GridTemplate.prototype;
+
+  /**
+   * Translate grid-template to separate -ms- prefixed properties
+   */
+  _proto.insert = function insert(decl, prefix, prefixes, result) {
+    if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+
+    if (decl.parent.some(function (i) {
+      return i.prop === '-ms-grid-rows';
+    })) {
+      return undefined;
+    }
+
+    var gap = getGridGap(decl);
+    /**
+     * we must insert inherited gap values in some cases:
+     * if we are inside media query && if we have no grid-gap value
+    */
+
+    var inheritedGap = inheritGridGap(decl, gap);
+
+    var _parseTemplate = parseTemplate({
+      decl: decl,
+      gap: inheritedGap || gap
+    }),
+        rows = _parseTemplate.rows,
+        columns = _parseTemplate.columns,
+        areas = _parseTemplate.areas;
+
+    var hasAreas = Object.keys(areas).length > 0;
+    var hasRows = Boolean(rows);
+    var hasColumns = Boolean(columns);
+    warnGridGap({
+      gap: gap,
+      hasColumns: hasColumns,
+      decl: decl,
+      result: result
+    });
+    warnMissedAreas(areas, decl, result);
+
+    if (hasRows && hasColumns || hasAreas) {
+      decl.cloneBefore({
+        prop: '-ms-grid-rows',
+        value: rows,
+        raws: {}
+      });
+    }
+
+    if (hasColumns) {
+      decl.cloneBefore({
+        prop: '-ms-grid-columns',
+        value: columns,
+        raws: {}
+      });
+    }
+
+    return decl;
+  };
+
+  return GridTemplate;
+}(Declaration);
+
+_defineProperty(GridTemplate, "names", ['grid-template']);
+
+module.exports = GridTemplate;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/grid-utils.js b/node_modules/autoprefixer/lib/hacks/grid-utils.js
new file mode 100644
index 0000000..06f868c
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-utils.js
@@ -0,0 +1,1150 @@
+"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
+};
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/image-rendering.js b/node_modules/autoprefixer/lib/hacks/image-rendering.js
new file mode 100644
index 0000000..d6de83c
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/image-rendering.js
@@ -0,0 +1,73 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var ImageRendering =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(ImageRendering, _Declaration);
+
+  function ImageRendering() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = ImageRendering.prototype;
+
+  /**
+   * Add hack only for crisp-edges
+   */
+  _proto.check = function check(decl) {
+    return decl.value === 'pixelated';
+  }
+  /**
+   * Change property name for IE
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    if (prefix === '-ms-') {
+      return '-ms-interpolation-mode';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Change property and value for IE
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    if (prefix !== '-ms-') return _Declaration.prototype.set.call(this, decl, prefix);
+    decl.prop = '-ms-interpolation-mode';
+    decl.value = 'nearest-neighbor';
+    return decl;
+  }
+  /**
+   * Return property name by spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'image-rendering';
+  }
+  /**
+   * Warn on old value
+   */
+  ;
+
+  _proto.process = function process(node, result) {
+    return _Declaration.prototype.process.call(this, node, result);
+  };
+
+  return ImageRendering;
+}(Declaration);
+
+_defineProperty(ImageRendering, "names", ['image-rendering', 'interpolation-mode']);
+
+module.exports = ImageRendering;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/image-set.js b/node_modules/autoprefixer/lib/hacks/image-set.js
new file mode 100644
index 0000000..2263aaf
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/image-set.js
@@ -0,0 +1,40 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Value = require('../value');
+
+var ImageSet =
+/*#__PURE__*/
+function (_Value) {
+  _inheritsLoose(ImageSet, _Value);
+
+  function ImageSet() {
+    return _Value.apply(this, arguments) || this;
+  }
+
+  var _proto = ImageSet.prototype;
+
+  /**
+   * Use non-standard name for WebKit and Firefox
+   */
+  _proto.replace = function replace(string, prefix) {
+    var fixed = _Value.prototype.replace.call(this, string, prefix);
+
+    if (prefix === '-webkit-') {
+      fixed = fixed.replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2');
+    }
+
+    return fixed;
+  };
+
+  return ImageSet;
+}(Value);
+
+_defineProperty(ImageSet, "names", ['image-set']);
+
+module.exports = ImageSet;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/inline-logical.js b/node_modules/autoprefixer/lib/hacks/inline-logical.js
new file mode 100644
index 0000000..819f14a
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/inline-logical.js
@@ -0,0 +1,42 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var InlineLogical =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(InlineLogical, _Declaration);
+
+  function InlineLogical() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = InlineLogical.prototype;
+
+  /**
+   * Use old syntax for -moz- and -webkit-
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    return prefix + prop.replace('-inline', '');
+  }
+  /**
+   * Return property name by spec
+   */
+  ;
+
+  _proto.normalize = function normalize(prop) {
+    return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2');
+  };
+
+  return InlineLogical;
+}(Declaration);
+
+_defineProperty(InlineLogical, "names", ['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', 'border-start', 'border-end', 'margin-start', 'margin-end', 'padding-start', 'padding-end']);
+
+module.exports = InlineLogical;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/intrinsic.js b/node_modules/autoprefixer/lib/hacks/intrinsic.js
new file mode 100644
index 0000000..59367c0
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/intrinsic.js
@@ -0,0 +1,76 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var OldValue = require('../old-value');
+
+var Value = require('../value');
+
+function _regexp(name) {
+  return new RegExp("(^|[\\s,(])(" + name + "($|[\\s),]))", 'gi');
+}
+
+var Intrinsic =
+/*#__PURE__*/
+function (_Value) {
+  _inheritsLoose(Intrinsic, _Value);
+
+  function Intrinsic() {
+    return _Value.apply(this, arguments) || this;
+  }
+
+  var _proto = Intrinsic.prototype;
+
+  _proto.regexp = function regexp() {
+    if (!this.regexpCache) this.regexpCache = _regexp(this.name);
+    return this.regexpCache;
+  };
+
+  _proto.isStretch = function isStretch() {
+    return this.name === 'stretch' || this.name === 'fill' || this.name === 'fill-available';
+  };
+
+  _proto.replace = function replace(string, prefix) {
+    if (prefix === '-moz-' && this.isStretch()) {
+      return string.replace(this.regexp(), '$1-moz-available$3');
+    }
+
+    if (prefix === '-webkit-' && this.isStretch()) {
+      return string.replace(this.regexp(), '$1-webkit-fill-available$3');
+    }
+
+    return _Value.prototype.replace.call(this, string, prefix);
+  };
+
+  _proto.old = function old(prefix) {
+    var prefixed = prefix + this.name;
+
+    if (this.isStretch()) {
+      if (prefix === '-moz-') {
+        prefixed = '-moz-available';
+      } else if (prefix === '-webkit-') {
+        prefixed = '-webkit-fill-available';
+      }
+    }
+
+    return new OldValue(this.name, prefixed, prefixed, _regexp(prefixed));
+  };
+
+  _proto.add = function add(decl, prefix) {
+    if (decl.prop.indexOf('grid') !== -1 && prefix !== '-webkit-') {
+      return undefined;
+    }
+
+    return _Value.prototype.add.call(this, decl, prefix);
+  };
+
+  return Intrinsic;
+}(Value);
+
+_defineProperty(Intrinsic, "names", ['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch']);
+
+module.exports = Intrinsic;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/justify-content.js b/node_modules/autoprefixer/lib/hacks/justify-content.js
new file mode 100644
index 0000000..7e7bb95
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/justify-content.js
@@ -0,0 +1,87 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var JustifyContent =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(JustifyContent, _Declaration);
+
+  function JustifyContent() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = JustifyContent.prototype;
+
+  /**
+   * Change property name for 2009 and 2012 specs
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2009) {
+      return prefix + 'box-pack';
+    }
+
+    if (spec === 2012) {
+      return prefix + 'flex-pack';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Return property name by final spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'justify-content';
+  }
+  /**
+   * Change value for 2009 and 2012 specs
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    var spec = flexSpec(prefix)[0];
+
+    if (spec === 2009 || spec === 2012) {
+      var value = JustifyContent.oldValues[decl.value] || decl.value;
+      decl.value = value;
+
+      if (spec !== 2009 || value !== 'distribute') {
+        return _Declaration.prototype.set.call(this, decl, prefix);
+      }
+    } else if (spec === 'final') {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    return undefined;
+  };
+
+  return JustifyContent;
+}(Declaration);
+
+_defineProperty(JustifyContent, "names", ['justify-content', 'flex-pack', 'box-pack']);
+
+_defineProperty(JustifyContent, "oldValues", {
+  'flex-end': 'end',
+  'flex-start': 'start',
+  'space-between': 'justify',
+  'space-around': 'distribute'
+});
+
+module.exports = JustifyContent;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/mask-border.js b/node_modules/autoprefixer/lib/hacks/mask-border.js
new file mode 100644
index 0000000..751615a
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/mask-border.js
@@ -0,0 +1,48 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var MaskBorder =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(MaskBorder, _Declaration);
+
+  function MaskBorder() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = MaskBorder.prototype;
+
+  /**
+   * Return property name by final spec
+   */
+  _proto.normalize = function normalize() {
+    return this.name.replace('box-image', 'border');
+  }
+  /**
+   * Return flex property for 2012 spec
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var result = _Declaration.prototype.prefixed.call(this, prop, prefix);
+
+    if (prefix === '-webkit-') {
+      result = result.replace('border', 'box-image');
+    }
+
+    return result;
+  };
+
+  return MaskBorder;
+}(Declaration);
+
+_defineProperty(MaskBorder, "names", ['mask-border', 'mask-border-source', 'mask-border-slice', 'mask-border-width', 'mask-border-outset', 'mask-border-repeat', 'mask-box-image', 'mask-box-image-source', 'mask-box-image-slice', 'mask-box-image-width', 'mask-box-image-outset', 'mask-box-image-repeat']);
+
+module.exports = MaskBorder;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/mask-composite.js b/node_modules/autoprefixer/lib/hacks/mask-composite.js
new file mode 100644
index 0000000..f68fe00
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/mask-composite.js
@@ -0,0 +1,106 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var MaskComposite =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(MaskComposite, _Declaration);
+
+  function MaskComposite() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = MaskComposite.prototype;
+
+  /**
+   * Prefix mask-composite for webkit
+   */
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    var isCompositeProp = decl.prop === 'mask-composite';
+    var compositeValues;
+
+    if (isCompositeProp) {
+      compositeValues = decl.value.split(',');
+    } else {
+      compositeValues = decl.value.match(MaskComposite.regexp) || [];
+    }
+
+    compositeValues = compositeValues.map(function (el) {
+      return el.trim();
+    }).filter(function (el) {
+      return el;
+    });
+    var hasCompositeValues = compositeValues.length;
+    var compositeDecl;
+
+    if (hasCompositeValues) {
+      compositeDecl = this.clone(decl);
+      compositeDecl.value = compositeValues.map(function (value) {
+        return MaskComposite.oldValues[value] || value;
+      }).join(', ');
+
+      if (compositeValues.includes('intersect')) {
+        compositeDecl.value += ', xor';
+      }
+
+      compositeDecl.prop = prefix + 'mask-composite';
+    }
+
+    if (isCompositeProp) {
+      if (!hasCompositeValues) {
+        return undefined;
+      }
+
+      if (this.needCascade(decl)) {
+        compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix);
+      }
+
+      return decl.parent.insertBefore(decl, compositeDecl);
+    }
+
+    var cloned = this.clone(decl);
+    cloned.prop = prefix + cloned.prop;
+
+    if (hasCompositeValues) {
+      cloned.value = cloned.value.replace(MaskComposite.regexp, '');
+    }
+
+    if (this.needCascade(decl)) {
+      cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+    }
+
+    decl.parent.insertBefore(decl, cloned);
+
+    if (!hasCompositeValues) {
+      return decl;
+    }
+
+    if (this.needCascade(decl)) {
+      compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix);
+    }
+
+    return decl.parent.insertBefore(decl, compositeDecl);
+  };
+
+  return MaskComposite;
+}(Declaration);
+
+_defineProperty(MaskComposite, "names", ['mask', 'mask-composite']);
+
+_defineProperty(MaskComposite, "oldValues", {
+  add: 'source-over',
+  substract: 'source-out',
+  intersect: 'source-in',
+  exclude: 'xor'
+});
+
+_defineProperty(MaskComposite, "regexp", new RegExp("\\s+(" + Object.keys(MaskComposite.oldValues).join('|') + ")\\b(?!\\))\\s*(?=[,])", 'ig'));
+
+module.exports = MaskComposite;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/order.js b/node_modules/autoprefixer/lib/hacks/order.js
new file mode 100644
index 0000000..1226a41
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/order.js
@@ -0,0 +1,74 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var Order =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(Order, _Declaration);
+
+  function Order() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = Order.prototype;
+
+  /**
+   * Change property name for 2009 and 2012 specs
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2009) {
+      return prefix + 'box-ordinal-group';
+    }
+
+    if (spec === 2012) {
+      return prefix + 'flex-order';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Return property name by final spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'order';
+  }
+  /**
+   * Fix value for 2009 spec
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    var spec = flexSpec(prefix)[0];
+
+    if (spec === 2009 && /\d/.test(decl.value)) {
+      decl.value = (parseInt(decl.value) + 1).toString();
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
+
+  return Order;
+}(Declaration);
+
+_defineProperty(Order, "names", ['order', 'flex-order', 'box-ordinal-group']);
+
+module.exports = Order;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/overscroll-behavior.js b/node_modules/autoprefixer/lib/hacks/overscroll-behavior.js
new file mode 100644
index 0000000..be58e9e
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/overscroll-behavior.js
@@ -0,0 +1,56 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var OverscrollBehavior =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(OverscrollBehavior, _Declaration);
+
+  function OverscrollBehavior() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = OverscrollBehavior.prototype;
+
+  /**
+   * Change property name for IE
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    return prefix + 'scroll-chaining';
+  }
+  /**
+   * Return property name by spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'overscroll-behavior';
+  }
+  /**
+   * Change value for IE
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    if (decl.value === 'auto') {
+      decl.value = 'chained';
+    } else if (decl.value === 'none' || decl.value === 'contain') {
+      decl.value = 'none';
+    }
+
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
+
+  return OverscrollBehavior;
+}(Declaration);
+
+_defineProperty(OverscrollBehavior, "names", ['overscroll-behavior', 'scroll-chaining']);
+
+module.exports = OverscrollBehavior;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/pixelated.js b/node_modules/autoprefixer/lib/hacks/pixelated.js
new file mode 100644
index 0000000..3e0b906
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/pixelated.js
@@ -0,0 +1,60 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var OldValue = require('../old-value');
+
+var Value = require('../value');
+
+var Pixelated =
+/*#__PURE__*/
+function (_Value) {
+  _inheritsLoose(Pixelated, _Value);
+
+  function Pixelated() {
+    return _Value.apply(this, arguments) || this;
+  }
+
+  var _proto = Pixelated.prototype;
+
+  /**
+   * Use non-standard name for WebKit and Firefox
+   */
+  _proto.replace = function replace(string, prefix) {
+    if (prefix === '-webkit-') {
+      return string.replace(this.regexp(), '$1-webkit-optimize-contrast');
+    }
+
+    if (prefix === '-moz-') {
+      return string.replace(this.regexp(), '$1-moz-crisp-edges');
+    }
+
+    return _Value.prototype.replace.call(this, string, prefix);
+  }
+  /**
+   * Different name for WebKit and Firefox
+   */
+  ;
+
+  _proto.old = function old(prefix) {
+    if (prefix === '-webkit-') {
+      return new OldValue(this.name, '-webkit-optimize-contrast');
+    }
+
+    if (prefix === '-moz-') {
+      return new OldValue(this.name, '-moz-crisp-edges');
+    }
+
+    return _Value.prototype.old.call(this, prefix);
+  };
+
+  return Pixelated;
+}(Value);
+
+_defineProperty(Pixelated, "names", ['pixelated']);
+
+module.exports = Pixelated;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/place-self.js b/node_modules/autoprefixer/lib/hacks/place-self.js
new file mode 100644
index 0000000..dc517ad
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/place-self.js
@@ -0,0 +1,57 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var utils = require('./grid-utils');
+
+var PlaceSelf =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(PlaceSelf, _Declaration);
+
+  function PlaceSelf() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = PlaceSelf.prototype;
+
+  /**
+   * Translate place-self to separate -ms- prefixed properties
+   */
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); // prevent doubling of prefixes
+
+    if (decl.parent.some(function (i) {
+      return i.prop === '-ms-grid-row-align';
+    })) {
+      return undefined;
+    }
+
+    var _utils$parse = utils.parse(decl),
+        _utils$parse$ = _utils$parse[0],
+        first = _utils$parse$[0],
+        second = _utils$parse$[1];
+
+    if (second) {
+      utils.insertDecl(decl, 'grid-row-align', first);
+      utils.insertDecl(decl, 'grid-column-align', second);
+    } else {
+      utils.insertDecl(decl, 'grid-row-align', first);
+      utils.insertDecl(decl, 'grid-column-align', first);
+    }
+
+    return undefined;
+  };
+
+  return PlaceSelf;
+}(Declaration);
+
+_defineProperty(PlaceSelf, "names", ['place-self']);
+
+module.exports = PlaceSelf;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/placeholder.js b/node_modules/autoprefixer/lib/hacks/placeholder.js
new file mode 100644
index 0000000..d84026f
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/placeholder.js
@@ -0,0 +1,58 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Selector = require('../selector');
+
+var Placeholder =
+/*#__PURE__*/
+function (_Selector) {
+  _inheritsLoose(Placeholder, _Selector);
+
+  function Placeholder() {
+    return _Selector.apply(this, arguments) || this;
+  }
+
+  var _proto = Placeholder.prototype;
+
+  /**
+   * Add old mozilla to possible prefixes
+   */
+  _proto.possible = function possible() {
+    return _Selector.prototype.possible.call(this).concat(['-moz- old', '-ms- old']);
+  }
+  /**
+   * Return different selectors depend on prefix
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prefix) {
+    if (prefix === '-webkit-') {
+      return '::-webkit-input-placeholder';
+    }
+
+    if (prefix === '-ms-') {
+      return '::-ms-input-placeholder';
+    }
+
+    if (prefix === '-ms- old') {
+      return ':-ms-input-placeholder';
+    }
+
+    if (prefix === '-moz- old') {
+      return ':-moz-placeholder';
+    }
+
+    return "::" + prefix + "placeholder";
+  };
+
+  return Placeholder;
+}(Selector);
+
+_defineProperty(Placeholder, "names", ['::placeholder']);
+
+module.exports = Placeholder;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js b/node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js
new file mode 100644
index 0000000..7c3e630
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js
@@ -0,0 +1,40 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var TextDecorationSkipInk =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(TextDecorationSkipInk, _Declaration);
+
+  function TextDecorationSkipInk() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = TextDecorationSkipInk.prototype;
+
+  /**
+   * Change prefix for ink value
+   */
+  _proto.set = function set(decl, prefix) {
+    if (decl.prop === 'text-decoration-skip-ink' && decl.value === 'auto') {
+      decl.prop = prefix + 'text-decoration-skip';
+      decl.value = 'ink';
+      return decl;
+    } else {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+  };
+
+  return TextDecorationSkipInk;
+}(Declaration);
+
+_defineProperty(TextDecorationSkipInk, "names", ['text-decoration-skip-ink', 'text-decoration-skip']);
+
+module.exports = TextDecorationSkipInk;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/text-decoration.js b/node_modules/autoprefixer/lib/hacks/text-decoration.js
new file mode 100644
index 0000000..40e0056
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/text-decoration.js
@@ -0,0 +1,38 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var BASIC = ['none', 'underline', 'overline', 'line-through', 'blink', 'inherit', 'initial', 'unset'];
+
+var TextDecoration =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(TextDecoration, _Declaration);
+
+  function TextDecoration() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = TextDecoration.prototype;
+
+  /**
+   * Do not add prefixes for basic values.
+   */
+  _proto.check = function check(decl) {
+    return decl.value.split(/\s+/).some(function (i) {
+      return BASIC.indexOf(i) === -1;
+    });
+  };
+
+  return TextDecoration;
+}(Declaration);
+
+_defineProperty(TextDecoration, "names", ['text-decoration']);
+
+module.exports = TextDecoration;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/text-emphasis-position.js b/node_modules/autoprefixer/lib/hacks/text-emphasis-position.js
new file mode 100644
index 0000000..eef1218
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/text-emphasis-position.js
@@ -0,0 +1,35 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var TextEmphasisPosition =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(TextEmphasisPosition, _Declaration);
+
+  function TextEmphasisPosition() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = TextEmphasisPosition.prototype;
+
+  _proto.set = function set(decl, prefix) {
+    if (prefix === '-webkit-') {
+      decl.value = decl.value.replace(/\s*(right|left)\s*/i, '');
+    }
+
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
+
+  return TextEmphasisPosition;
+}(Declaration);
+
+_defineProperty(TextEmphasisPosition, "names", ['text-emphasis-position']);
+
+module.exports = TextEmphasisPosition;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/transform-decl.js b/node_modules/autoprefixer/lib/hacks/transform-decl.js
new file mode 100644
index 0000000..94c5a85
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/transform-decl.js
@@ -0,0 +1,112 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var TransformDecl =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(TransformDecl, _Declaration);
+
+  function TransformDecl() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = TransformDecl.prototype;
+
+  /**
+   * Recursively check all parents for @keyframes
+   */
+  _proto.keyframeParents = function keyframeParents(decl) {
+    var parent = decl.parent;
+
+    while (parent) {
+      if (parent.type === 'atrule' && parent.name === 'keyframes') {
+        return true;
+      }
+
+      var _parent = parent;
+      parent = _parent.parent;
+    }
+
+    return false;
+  }
+  /**
+   * Is transform contain 3D commands
+   */
+  ;
+
+  _proto.contain3d = function contain3d(decl) {
+    if (decl.prop === 'transform-origin') {
+      return false;
+    }
+
+    for (var _iterator = TransformDecl.functions3d, _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 func = _ref;
+
+      if (decl.value.indexOf(func + "(") !== -1) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+  /**
+   * Replace rotateZ to rotate for IE 9
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    decl = _Declaration.prototype.set.call(this, decl, prefix);
+
+    if (prefix === '-ms-') {
+      decl.value = decl.value.replace(/rotateZ/gi, 'rotate');
+    }
+
+    return decl;
+  }
+  /**
+   * Don't add prefix for IE in keyframes
+   */
+  ;
+
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    if (prefix === '-ms-') {
+      if (!this.contain3d(decl) && !this.keyframeParents(decl)) {
+        return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+      }
+    } else if (prefix === '-o-') {
+      if (!this.contain3d(decl)) {
+        return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+      }
+    } else {
+      return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    }
+
+    return undefined;
+  };
+
+  return TransformDecl;
+}(Declaration);
+
+_defineProperty(TransformDecl, "names", ['transform', 'transform-origin']);
+
+_defineProperty(TransformDecl, "functions3d", ['matrix3d', 'translate3d', 'translateZ', 'scale3d', 'scaleZ', 'rotate3d', 'rotateX', 'rotateY', 'perspective']);
+
+module.exports = TransformDecl;
+\ No newline at end of file
diff --git a/node_modules/autoprefixer/lib/hacks/writing-mode.js b/node_modules/autoprefixer/lib/hacks/writing-mode.js
new file mode 100644
index 0000000..71bfc05
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/writing-mode.js
@@ -0,0 +1,61 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var WritingMode =
+/*#__PURE__*/
+function (_Declaration) {
+  _inheritsLoose(WritingMode, _Declaration);
+
+  function WritingMode() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = WritingMode.prototype;
+
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    if (prefix === '-ms-') {
+      var cloned = this.set(this.clone(decl), prefix);
+
+      if (this.needCascade(decl)) {
+        cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+      }
+
+      var direction = 'ltr';
+      decl.parent.nodes.forEach(function (i) {
+        if (i.prop === 'direction') {
+          if (i.value === 'rtl' || i.value === 'ltr') direction = i.value;
+        }
+      });
+      cloned.value = WritingMode.msValues[direction][decl.value] || decl.value;
+      return decl.parent.insertBefore(decl, cloned);
+    }
+
+    return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+  };
+
+  return WritingMode;
+}(Declaration);
+
+_defineProperty(WritingMode, "names", ['writing-mode']);
+
+_defineProperty(WritingMode, "msValues", {
+  ltr: {
+    'horizontal-tb': 'lr-tb',
+    'vertical-rl': 'tb-rl',
+    'vertical-lr': 'tb-lr'
+  },
+  rtl: {
+    'horizontal-tb': 'rl-tb',
+    'vertical-rl': 'bt-rl',
+    'vertical-lr': 'bt-lr'
+  }
+});
+
+module.exports = WritingMode;
+\ No newline at end of file